// 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());

	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);