--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstatereferenceplugins/test/tunitcustcmd/src/tcmd_step_simsecuritycheck.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,1067 @@
+// 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:
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#include "tcmd_step_simsecuritycheck.h"
+#include "ssmsecuritychecknotifier.h"
+#include "ssmuiproviderdll.h"
+#include "ssmcustomcmdfactory.h"
+#include <ssm/startupdomainpskeys.h>
+#include <e32event.h>
+#include <e32std.h>
+#include <s32file.h>
+
+//Swp policy file for sim status swp
+_LIT(KTestSimStatusSwpPolicy, "ssm.swp.policy.simstatus.dll");
+
+//Exe name which defines startup PS keys
+_LIT (KExeToDefineStartUpPS, "\\sys\\bin\\definestartupps.exe");
+
+//Exe name which defines emergency call PS keys
+_LIT (KExeToDefineEmergencyCallPS, "\\sys\\bin\\defineemergencycallps.exe");
+
+// Use to write the PIN Check Security test case nos.
+_LIT(KTestCmdSecurityCheckTestFile, "c:\\cmdsecuritychecktest\\pinchecksecuritycaseno.txt");
+
+static TInt CallBack2L(TAny* aCCustomCmdTestSecurityCheck);
+
+CCustomCmdTestSimSecurityCheck::~CCustomCmdTestSimSecurityCheck()
+	{
+	delete iAsyncStopScheduler;
+	delete iActiveSchedulerWait;
+	delete iActiveScheduler;
+	}
+
+CCustomCmdTestSimSecurityCheck::CCustomCmdTestSimSecurityCheck()
+	{
+	//Set test step name
+	SetTestStepName(KTCCustomCmdTestSimSecurityCheck);
+	}
+
+TVerdict CCustomCmdTestSimSecurityCheck::doTestStepPreambleL()
+	{
+	INFO_PRINTF1(_L("doTestStepPreambleL"));
+	//Create and install active scheduler
+	iActiveScheduler = new(ELeave) CActiveScheduler;
+	CActiveScheduler::Install (iActiveScheduler);
+	iActiveSchedulerWait = new(ELeave) CActiveSchedulerWait;
+	
+	//Needed fro calling calback for stopping active scheduler
+	iAsyncStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle);
+
+	RProcess processHandle;
+	CleanupClosePushL(processHandle);
+	//Start the test exe which defines startup related property keys
+	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();
+	
+	//Start the test exe which defines emergency call related property keys
+	processHandle.Create(KExeToDefineEmergencyCallPS, KNullDesC);
+	processHandle.Resume();
+	processHandle.Close();
+	
+	RegisterSimSecurityStatus();
+	
+	//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() function uses pinchecksecuritycaseno.txt file to select the scenarios.
+ 	//This test case uses scenario 1 to test custom command.
+	_LIT(KDirNameOfTestCasesNumFile, "c:\\cmdsecuritychecktest\\");
+	
+	//connect to file server
+	User::LeaveIfError(iFs.Connect());
+	TInt err = iFs.MkDirAll(KDirNameOfTestCasesNumFile);
+	if (KErrAlreadyExists != err && KErrNone != err)
+		{
+		INFO_PRINTF1(_L("Leaving as it could not create directory"));
+		User::Leave(err);
+		}
+	RFile file;
+	CleanupClosePushL(file);
+	err = file.Replace(iFs, KTestCmdSecurityCheckTestFile, EFileWrite | EFileStream);
+	RFileWriteStream stream(file);
+	CleanupClosePushL(stream);
+   
+	stream.WriteInt32L(1);
+	stream.CommitL();
+	CleanupStack::PopAndDestroy(&stream);
+	CleanupStack::PopAndDestroy(&file);
+	
+	User::After(1000000);
+	//Create a security check cmd
+	iCustomCmdCheck = static_cast<CCustomCmdSimSecurityCheck*>(SsmCustomCmdFactory::CmdSimSecurityCheckNewL());
+	return CTestStep::doTestStepPreambleL();
+	}
+
+TVerdict CCustomCmdTestSimSecurityCheck::doTestStepPostambleL()
+	{
+	iFs.Delete(KTestCmdSecurityCheckTestFile);
+	iFs.Close();
+	return CTestStep::doTestStepPostambleL();
+	}
+
+// CCustomCmdTestSimSecurityCheck::RegisterSimSecurityStatus()
+// This method is used to define the SIM status proeprty with SSM's secure ID
+// and to map the SIM status PandS key with the SIM Status SWP policy
+void CCustomCmdTestSimSecurityCheck::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);
+    
+    //Connect to SsmStateManager
+    RSsmStateManager stateManager;
+    ret = stateManager.Connect();
+    TEST(KErrNone == ret);
+    const TUint KStartupSimSecurityStatusUid = CSsmUiSpecific::SimStatusPropertyKey();
+    
+    //register the swp mapping for Sim security status with its swp policy
+    ret = stateManager.RegisterSwpMapping(KStartupSimSecurityStatusUid, KTestSimStatusSwpPolicy);
+    TEST(KErrNone == ret || KErrAlreadyExists == ret);
+    stateManager.Close();
+    }
+
+/////////////////////////////////////////////////////////////////////////////////////
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0006
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+
+void CCustomCmdTestSimSecurityCheck::TestGeneralL()
+	{
+	//Testing some of the functions from ui specific dll.
+	const TUid KPSStartupUid = {0x2000E65E};
+	const TUid KSecurityPinNotifierUid = {0x2000E667};
+	
+	TUid uid1 = CSsmUiSpecific::StartupPSUid();
+	TEST(KPSStartupUid == uid1);
+
+	TUid uid2 = CSsmUiSpecific::SecurityPinNotifierUid();
+	TEST(KSecurityPinNotifierUid == uid2);
+	
+	TEST( CSsmUiSpecific::IsSimlessOfflineSupported() );
+	
+	TEST( CSsmUiSpecific::IsNormalBoot() );
+	
+	TEST( CSsmUiSpecific::IsSimChangedReset() );
+    
+	//Get the instance of ui specific dll
+	CSsmUiSpecific* ssmSecurityCustomCmdUid = CSsmUiSpecific::InstanceL();
+	
+	//Set the security status as passed
+	ssmSecurityCustomCmdUid->SetSecurityStatus(EStrtSecurityCheckPassed);
+	
+	//Get the security status
+	TStrtSecurityStatus sst = ssmSecurityCustomCmdUid->SecurityStatus();
+	
+	//Test the security status with EStrtSecurityCheckPassed which was set
+	TEST(EStrtSecurityCheckPassed == sst); 
+
+	//Delete created uispecific object
+	CSsmUiSpecific::Release();
+	}
+
+//
+static TInt CallBack1L(TAny* aCCustomCmdTestSimSecurityCheck)
+	{
+	//Call back function to stop active scheduler
+	CCustomCmdTestSimSecurityCheck* test = reinterpret_cast<CCustomCmdTestSimSecurityCheck*>(aCCustomCmdTestSimSecurityCheck);
+	test->CallBack1RunL();
+	return KErrNone;
+	}
+
+void CCustomCmdTestSimSecurityCheck::CallBack1RunL()
+	{
+	//Stop the active scheduler if the request is completed else
+	//callback once again
+	if(iRequest != KRequestPending)
+		{
+		iActiveSchedulerWait->AsyncStop();
+		}
+	else
+		{
+		iAsyncStopScheduler->CallBack();
+		}
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0007
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMPresentL()
+	{
+	TestHandleSIMPresent1L();
+	TestHandleSIMPresent2L();
+	TestHandleSIMPresent3L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMPresent1L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMPresent1L");
+	INFO_PRINTF1(KTESTLOG);
+
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPUK1Required;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMPresent();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMPresent2L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMPresent2L");
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimStatusUninitialized);
+	TEST(KErrNone == result);
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EYes;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMPresent();
+	TCallBack stop(CallBack2L, this);
+
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+#ifdef __WINS__	
+	TEST(KErrNone == iRequest.Int());
+#else
+	//Other tests which ran before this might have already loaded sus pluing (ssmclayersup.dll) which 
+	//will result in KErrAlreadyExists. This will happen only in armv5 as it runs 
+	//all the tests with out rebooting
+	TEST(KErrNone == iRequest.Int() || KErrAlreadyExists == iRequest.Int());
+#endif
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMPresent3L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMPresent3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ENo;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMPresent();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+//
+
+/*
+Test Case ID            DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+*/
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMInvalidL()
+    {
+    TestHandleSIMInvalid1L();
+    TestHandleSIMInvalid2L();
+    TestHandleSIMInvalid3L();
+    }
+
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMInvalid1L()
+    {
+    _LIT(KTESTLOG, "TestHandleSIMInvalid1L");
+    INFO_PRINTF1(KTESTLOG);
+    iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPUK1Required;
+    iRequest = KRequestPending;
+    iCustomCmdCheck->iExecuteRequest = &iRequest;
+    iCustomCmdCheck->HandleSIMInvalid();
+
+    TCallBack stop(CallBack2L, this);
+    iAsyncStopScheduler->Set(stop);
+    iAsyncStopScheduler->CallBack();
+    iActiveSchedulerWait->Start();
+    TEST(KErrGeneral == iRequest.Int());
+    }
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMInvalid2L()
+    {
+    _LIT(KTESTLOG, "TestHandleSIMInvalid2L");
+    INFO_PRINTF1(KTESTLOG);
+    iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EYes;
+    iRequest = KRequestPending;
+    iCustomCmdCheck->iExecuteRequest = &iRequest;
+    iCustomCmdCheck->HandleSIMInvalid();
+
+    TCallBack stop(CallBack2L, this);
+    iAsyncStopScheduler->Set(stop);
+    iAsyncStopScheduler->CallBack();
+    iActiveSchedulerWait->Start();
+    TEST(KErrNone == iRequest.Int());
+    }
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMInvalid3L()
+    {
+    _LIT(KTESTLOG, "TestHandleSIMInvalid3L");
+    INFO_PRINTF1(KTESTLOG);
+    iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ENo;
+    iRequest = KRequestPending;
+    iCustomCmdCheck->iExecuteRequest = &iRequest;
+    iCustomCmdCheck->HandleSIMInvalid();
+
+    TCallBack stop(CallBack2L, this);
+    iAsyncStopScheduler->Set(stop);
+    iAsyncStopScheduler->CallBack();
+    iActiveSchedulerWait->Start();
+    TEST(KErrNone == iRequest.Int());
+    }
+
+//
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0008
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMRejectedL()
+	{
+	TestHandleSIMRejected1L();
+	TestHandleSIMRejected2L();
+	TestHandleSIMRejected3L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMRejected1L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMRejected1L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPUK1Required;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMRejected();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMRejected2L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMRejected2L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EYes;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMRejected();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	//Security observer might have already been loaded so returning with KErrAlreadyExists
+	TEST(KErrNone == iRequest.Int());
+
+	TInt val;
+	//Get the startup PS value for sim security status
+	TInt result = RProperty::Get(iCustomCmdCheck->iStartupPSUid, KStartupSimSecurityStatus, val);
+	TEST(KErrNone == result);
+	
+	//Test the sim security status value
+	TEST(ESimRejected == val);
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMRejected3L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMRejected3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ENo;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMRejected();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+//
+static TInt CallBack2L(TAny* aCCustomCmdTestSimSecurityCheck)
+	{
+	CCustomCmdTestSimSecurityCheck* test = reinterpret_cast<CCustomCmdTestSimSecurityCheck*>(aCCustomCmdTestSimSecurityCheck);
+	test->CallBack2RunL();
+	return KErrNone;
+	}
+
+void CCustomCmdTestSimSecurityCheck::CallBack2RunL()
+	{
+	if(iRequest != KRequestPending)
+		{
+		iActiveSchedulerWait->AsyncStop();
+		}
+	else
+		{
+		iAsyncStopScheduler->CallBack();
+		
+		//Simulate entering the password only when it is asked for
+		if(iCustomCmdCheck->iState == StartupAdaptation::EAskPIN ||
+			iCustomCmdCheck->iState == StartupAdaptation::EAskPUK ||
+			iCustomCmdCheck->iState == StartupAdaptation::EAskSEC ||
+			iCustomCmdCheck->iState == StartupAdaptation::ESIMLock)
+			{
+			SimulatePasswordEntry();
+			}
+		}
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0009
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMBlockedL()
+	{
+	TestHandleSIMBlocked1L();
+	TestHandleSIMBlocked2L();
+	TestHandleSIMBlocked3L();
+	TestHandleSIMBlocked4L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMBlocked1L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMBlocked1L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPUK1Required;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMBlocked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMBlocked2L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMBlocked2L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EYes;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMBlocked();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMBlocked3L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMBlocked3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ENo;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMBlocked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMBlocked4L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMBlocked4L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EUPUKRequired;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMBlocked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+//
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0010
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINRequiredL()
+	{
+	TestHandlePINRequired1L();
+	TestHandlePINRequired2L();
+	TestHandlePINRequired3L();
+	TestHandlePINRequired4L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINRequired1L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINRequired1L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EUPUKRequired;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandlePINRequired();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINRequired2L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINRequired2L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPIN1Required;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandlePINRequired();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINRequired3L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINRequired3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EUPINRequired;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandlePINRequired();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINRequired4L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINRequired4L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ENo;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandlePINRequired();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+//
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0012
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLessOfflineSupportedL()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLessOfflineSupportedL");
+	INFO_PRINTF1(KTESTLOG);
+	
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLessOfflineSupported();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+//
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0013
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLockL()
+	{
+	TestHandleSIMLock1L();
+	TestHandleSIMLock2L();
+	TestHandleSIMLock3L();
+	TestHandleSIMLock4L();
+	TestHandleSIMLock5L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLock1L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLock1L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EUPUKRequired;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLock();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLock2L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLock2L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ESimLockRestricted;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLock();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLock3L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLock3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ESimLockOk;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLock();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLock4L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLock4L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ESimLockRestrictionOn;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLock();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandleSIMLock5L()
+	{
+	_LIT(KTESTLOG, "TestHandleSIMLock5L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::ESimLockRestrictionPending;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandleSIMLock();
+
+	TCallBack stop(CallBack1L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	}
+
+//
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0015
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINAskedL()
+	{
+	TestHandlePINAsked1L();
+	TestHandlePINAsked2L();
+	TestHandlePINAsked3L();
+	TestHandlePINAsked4L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINAsked1L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINAsked1L");
+	INFO_PRINTF1(KTESTLOG);
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn);
+	iCustomCmdCheck->HandlePINAsked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+
+	delete iCustomCmdCheck->iSsmSecurityCheckNotifier;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = NULL;
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINAsked2L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINAsked2L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iNoteType = ESecCodePIN1;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn);
+	iCustomCmdCheck->ExecuteCancel();
+	iCustomCmdCheck->HandlePINAsked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrCancel == iRequest.Int());
+
+	delete iCustomCmdCheck->iSsmSecurityCheckNotifier;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = NULL;
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINAsked3L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINAsked3L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iNoteType = ESecCodeUPIN;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->iStateChangePending = EFalse;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn);
+	iCustomCmdCheck->Cancel();
+	iCustomCmdCheck->HandlePINAsked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+
+	delete iCustomCmdCheck->iSsmSecurityCheckNotifier;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = NULL;
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePINAsked4L()
+	{
+	_LIT(KTESTLOG, "TestHandlePINAsked4L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iNoteType = ESecCodeSPC;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn);
+	iCustomCmdCheck->Cancel();
+	iCustomCmdCheck->HandlePINAsked();
+	
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrGeneral == iRequest.Int());
+	delete iCustomCmdCheck->iSsmSecurityCheckNotifier;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = NULL;
+	}
+
+//
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0016
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+void CCustomCmdTestSimSecurityCheck::TestHandlePUKAskedL()
+	{
+	_LIT(KTESTLOG, "TestHandlePUKAskedL");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EUPUKRequired;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->iStateChangePending = EFalse;
+	iCustomCmdCheck->iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn);
+	iCustomCmdCheck->Cancel();
+	iCustomCmdCheck->HandlePUKAsked();
+
+	TCallBack stop(CallBack2L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+
+	TInt val;
+	TInt result = RProperty::Get(iCustomCmdCheck->iStartupPSUid, KStartupSimSecurityStatus, val);
+	TEST(KErrNone == result);
+	TEST(ESimRejected == val);
+	}
+//
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0018
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+
+void CCustomCmdTestSimSecurityCheck::TestSimFunctionsL()
+	{
+	_LIT(KTESTLOG, "TestSimFunctions");
+	INFO_PRINTF1(KTESTLOG);
+
+	TestSimNotSupported();
+	TestSimRemoved();
+	TestSimReadable();
+	TestSimUsable();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSimNotSupported()
+	{
+	//Cancel any request if they are active
+	iCustomCmdCheck->Cancel();
+
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimStatusUninitialized);
+	TEST(KErrNone == result);
+	iCustomCmdCheck->SimNotSupported();
+
+	//Wait for PS value to get updated
+	User::After(2000000);
+
+	TInt simResult;
+	result = RProperty::Get(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), simResult);
+	TEST(KErrNone == result);
+	TEST(simResult == ESimNotSupported);
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSimRemoved()
+	{
+	//Cancel any request if they are active
+	iCustomCmdCheck->Cancel();
+
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimUsable);
+	TEST(KErrNone == result);
+	iCustomCmdCheck->SimRemoved();
+
+	//Wait for PS value to get updated
+	User::After(2000000);
+
+	TInt simResult;
+	result = RProperty::Get(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), simResult);
+	TEST(KErrNone == result);
+	TEST(simResult == ESimNotPresent);
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSimReadable()
+	{
+	//Cancel any request if they are active
+	iCustomCmdCheck->Cancel();
+
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimNotPresent);
+	TEST(KErrNone == result);
+	iCustomCmdCheck->SimReadable();
+
+	//Wait for PS value to get updated
+	User::After(2000000);
+
+	TInt simResult;
+	result = RProperty::Get(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), simResult);
+	TEST(KErrNone == result);
+	TEST(simResult == ESimReadable);
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSimUsable()
+	{
+	//Cancel any request if they are active
+	iCustomCmdCheck->Cancel();
+
+	TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), ESimReadable);
+	TEST(KErrNone == result);
+	iCustomCmdCheck->SimUsable();
+
+	//Wait for PS value to get updated
+	User::After(2000000);
+
+	TInt simResult;
+	result = RProperty::Get(CSsmUiSpecific::StartupPSUid(), CSsmUiSpecific::SimStatusPropertyKey(), simResult);
+	TEST(KErrNone == result);
+	TEST(simResult == ESimUsable);
+	}
+
+//
+static TInt CallBack3L(TAny* aCCustomCmdTestSimSecurityCheck)
+	{
+	CCustomCmdTestSimSecurityCheck* test = reinterpret_cast<CCustomCmdTestSimSecurityCheck*>(aCCustomCmdTestSimSecurityCheck);
+	test->CallBack3RunL();
+	return KErrNone;
+	}
+
+void CCustomCmdTestSimSecurityCheck::SimulatePasswordEntry()
+	{
+	TRawEvent eventDown;
+	TRawEvent eventUp;
+
+	//Simulate the key press ,(comma) in to pin notifier dialogue
+	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);
+	}
+
+void CCustomCmdTestSimSecurityCheck::CallBack3RunL()
+	{
+	if(iRequest != KRequestPending)
+		{
+		iActiveSchedulerWait->AsyncStop();
+		}
+	else
+		{
+		iAsyncStopScheduler->CallBack();
+		if(iCustomCmdCheck->iState == StartupAdaptation::EAskPIN ||
+			iCustomCmdCheck->iState == StartupAdaptation::EAskPUK ||
+			iCustomCmdCheck->iState == StartupAdaptation::EAskSEC ||
+			iCustomCmdCheck->iState == StartupAdaptation::ESIMLock)
+			{
+			//Reset the security code status PS so that test goes further
+			TInt result = RProperty::Set(CSsmUiSpecific::StartupPSUid(), KStartupSecurityCodeQueryStatus, ESecurityQueryActive);
+			TEST(KErrNone == result);
+			SimulatePasswordEntry();
+			}
+		}
+	}
+
+/**
+Old Test CaseID 		APPFWK-CUSTCMD-0020
+New Test CaseID 		DEVSRVS-SSREFPLUGINS-CUSTCMD-0006
+ */
+
+void CCustomCmdTestSimSecurityCheck::TestSecurityNoteObserverL()
+	{
+	TestSecurityNoteObserver1L();
+	TestSecurityNoteObserver2L();
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSecurityNoteObserver1L()
+	{
+	_LIT(KTESTLOG, "TestSecurityNoteObserver1L");
+	INFO_PRINTF1(KTESTLOG);
+	iCustomCmdCheck->iSecurityStateInfo = StartupAdaptation::EPIN1Required;
+	iRequest = KRequestPending;
+	iCustomCmdCheck->iExecuteRequest = &iRequest;
+	iCustomCmdCheck->HandlePINRequired();
+
+	TCallBack stop(CallBack3L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrNone == iRequest.Int());
+	TInt propertyValue;
+	TInt result = RProperty::Get(CSsmUiSpecific::StartupPSUid(), KPSSplashShutdown, propertyValue);
+	TEST(KErrNone == result);
+	TEST(propertyValue == ESplashShutdown);
+	}
+
+void CCustomCmdTestSimSecurityCheck::TestSecurityNoteObserver2L()
+	{
+	_LIT(KTESTLOG, "TestSecurityNoteObserver2L");
+	INFO_PRINTF1(KTESTLOG);
+	TBufC8<1> dummy;
+	iCustomCmdCheck->StartSecurityNoteObserverL();
+	iCustomCmdCheck->Execute(dummy, iRequest);
+	iCustomCmdCheck->ExecuteCancel();
+	iCustomCmdCheck->iStateChangePending = EFalse;
+	
+	TCallBack stop(CallBack3L, this);
+	iAsyncStopScheduler->Set(stop);
+	iAsyncStopScheduler->CallBack();
+	iActiveSchedulerWait->Start();
+	TEST(KErrCancel == iRequest.Int());
+	}
+
+//
+TVerdict CCustomCmdTestSimSecurityCheck::doTestStepL()
+	{
+	__UHEAP_MARK;
+	TestGeneralL();
+	TestHandleSIMPresentL();
+	TestHandleSIMInvalidL();
+	TestHandleSIMRejectedL();
+	TestHandleSIMBlockedL();
+	TestHandlePINRequiredL();
+	TestSecurityNoteObserverL();
+	TestHandleSIMLessOfflineSupportedL();
+	TestHandleSIMLockL();
+	TestHandlePINAskedL();
+	TestHandlePUKAskedL();
+	TestSimFunctionsL();
+
+	//Close the security check custom custom
+	iCustomCmdCheck->Close();
+
+	//Delete the security check custom custom
+	iCustomCmdCheck->Release();
+	__UHEAP_MARKEND;
+	return TestStepResult();
+	}