// Copyright (c) 2006-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

*/

#include "te_simeap.h"

_LIT8(KConfigScAuthAIDAscii, "AID1");

_LIT8(KConfigScAuthAUTN, "AUTN_IN");

_LIT8(KConfigScAuthRAND, "RAND_IN");

_LIT8(KConfigScAuthRES, "123456789");

_LIT8(KConfigScAuthIK, "1234567890");

_LIT8(KConfigScAuthCK, "1234567899");

_LIT8(KConfigScAuthKC, "12345678");

_LIT8(KConfigScAuthAUTS, "1234567897");

_LIT8(KConfigScAuthAUTNbin, "\x00\x01\x02\x03\x04\x05");

_LIT8(KConfigScAuthRANDbin, "\x00\x01\x02\x03\x06\x07");

_LIT8(KConfigScAuthRESbin, "\x00\x00\x00\x11\x11\x11");

_LIT8(KConfigScAuthIKbin, "\x00\x00\x00\x11\x11\x22");

_LIT8(KConfigScAuthCKbin, "\x00\x00\x00\x11\x22\x33");

_LIT8(KConfigScAuthKCbin, "\x00\x01\x00\x02\x03\x04\x05\x06");

_LIT8(KConfigScAuthAIDBin, "\x00\x01\x00\x02");

_LIT8(KConfigEapListAID, "AID00");

_LIT8(KConfigEapListLabel, "EAPAID");

_LIT8(KConfigEapListEapList, "1723");

_LIT8(KConfigScEapAID1, "\x00\x01\x00\x00\x02");

_LIT8(KConfigScEapType1, "17");

_LIT8(KConfigScEapId1, "EAP_ID1");

_LIT8(KConfigScEapPsId1, "EAP_PseudonymID1");

_LIT8(KConfigScEapKey1, "EAP_KEY1");

_LIT8(KConfigScEapKey1EMSK, "EAP_KEY1EXT");

_LIT8(KConfigScEapChal11, "CHALLENGE_DATA1");

_LIT8(KConfigScEapResp11, "RESPONSE_DATA1");

const RMobileSmartCardEap::TEapAuthStatus KEapAuthStatus1_1 = RMobileSmartCardEap::EAuthenticating;

_LIT8(KConfigScEapChal12, "CHALLENGE_DATA2");

_LIT8(KConfigScEapResp12, "RESPONSE_DATA2");

const RMobileSmartCardEap::TEapAuthStatus KEapAuthStatus1_2 = RMobileSmartCardEap::EAuthenticating;

_LIT8(KConfigScEapChal13, "CHALLENGE_DATA3");

_LIT8(KConfigScEapResp13, "RESPONSE_DATA3");

const RMobileSmartCardEap::TEapAuthStatus KEapAuthStatus1_3 = RMobileSmartCardEap::EAuthenticated;

_LIT8(KConfigScEapAID2, "\x00\x02\x00\x00\x02");

_LIT8(KConfigScEapType2, "23");

_LIT8(KConfigScEapId2, "\x00\x01\x02\x03\x04\x05");

_LIT8(KConfigScEapKey2, "\x00\x01\x02\x03\x04\x66");

_LIT8(KConfigScEapChal21, "\x00\x00\x00\x11\x11\x11\x22\x22\x22");

_LIT8(KConfigScEapResp21, "\xAA\xBB\xCC\x00\xDD\xEE\xFF");

const RMobileSmartCardEap::TEapAuthStatus KEapAuthStatus2_1 = RMobileSmartCardEap::EAuthenticating;

_LIT8(KConfigScEapChal22, "\x00\x00\x00\x12\x12\x12\x22\x22\x22");

_LIT8(KConfigScEapResp22, "\xAB\xBB\xCC\x00\xDD\xEE\xFF");

const RMobileSmartCardEap::TEapAuthStatus KEapAuthStatus2_2 = RMobileSmartCardEap::EAuthenticated;

_LIT8(KConfigScReInitEapAID, "\x00\x00\x00\x00\xEE");

_LIT8(KConfigScReInitEapType1, "22");

_LIT8(KConfigScReInitEapType2, "11");

_LIT8(KConfigScEapAIDBadCli, "\x00\x03\x00\x00\x02");

_LIT8(KConfigScEapTypeBadCli, "25");

CTestSmartCardEap::CTestSmartCardEap()

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("TestSmartCardEap"));

	}

TVerdict CTestSmartCardEap::doTestStepL()

	{

	INFO_PRINTF1(_L("CTestSmartCardEap"));

	// Vars to be used throughout test

	TRequestStatus reqStatus = KErrNone;

	RMobilePhone::TAID myAID = KConfigScEapAID1();

	RMobileSmartCardEap::TEapType myEapType = KConfigScEapType1();

	RMobileSmartCardEap simScEap, simScEap2;

	// simScEap0 will be a handle to same sub-session as simScEap.

	// simScEap0 is used for mainly testing the

	// NotifyEapMethodAccessStatusChange() notification.

	RMobileSmartCardEap simScEap0;

	// A quick open/close

	RMobileSmartCardEap simScEapQuick;

	TInt ret = simScEapQuick.Open(iPhone, myAID, myEapType);

	TESTL(ret == KErrNone);

	simScEapQuick.Close();

	// Test opening handle with bad params

	INFO_PRINTF1(_L("Attempting to create handle to sub-session with non-existent <AID,EAPType>"));

	_LIT8(badAID, "badAID");

	_LIT8(badEAP, "badEAP");

	myAID = badAID();

	myEapType = badEAP();

	ret = simScEap.Open(iPhone, myAID, myEapType);

	TESTL(ret == KErrNotFound);

	// Test opening 2 handles to the same sub-session using good params

	// for a handle

	INFO_PRINTF1(_L("Creating handle to sub-session"));

	myAID = KConfigScEapAID1();

	myEapType = KConfigScEapType1();

	ret = simScEap0.Open(iPhone, myAID, myEapType);

	CleanupClosePushL(simScEap0);

	TESTL(ret == KErrNone);

	TEST(!simScEap0.IsEapMethodOwner());

	ret = simScEap.Open(iPhone, myAID, myEapType);

	CleanupClosePushL(simScEap);

	TESTL(ret == KErrNone);

	TEST(!simScEap.IsEapMethodOwner());

	// Test notification for only one of the handles; the one that does

	// NOT initialise.

	RMobileSmartCardEap::TEapMethodAccessStatus eapAccessStatNotif = RMobileSmartCardEap::EEapMethodInUseApplicationInactive;

	TRequestStatus reqStatusNotif = KErrNone;

	simScEap0.NotifyEapMethodAccessStatusChange(reqStatusNotif, eapAccessStatNotif);

	// Test GetEapMethodAccessStatus()

	INFO_PRINTF1(_L("RMobileSmartCardEap::GetEapMethodAccessStatus sync."));

	RMobileSmartCardEap::TEapMethodAccessStatus eapAccessStat = RMobileSmartCardEap::EEapMethodInUseApplicationInactive;

	simScEap0.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodAvailable);

	simScEap.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodAvailable);

	// Initialise only one of the handles

	INFO_PRINTF1(_L("Initialising handle to sub-session"));

	simScEap.InitialiseEapMethod(reqStatus);

	User::WaitForRequest(reqStatus);

	TESTL(reqStatus == KErrNone);

	TESTL(simScEap.IsEapMethodOwner());

	simScEap.InitialiseEapMethod(reqStatus); // second initialise should do nothing and succeed

	User::WaitForRequest(reqStatus);

	TESTL(reqStatus == KErrNone);

	// new status should be achieved

	simScEap0.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodInUseApplicationActive);

	simScEap.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodInUseApplicationActive);

	// Notification should have now completed.

	User::WaitForRequest(reqStatusNotif);

	TEST(reqStatusNotif == KErrNone);

	TEST(eapAccessStatNotif == RMobileSmartCardEap::EEapMethodInUseApplicationActive);

	// re-post notification for later!

	simScEap0.NotifyEapMethodAccessStatusChange(reqStatusNotif, eapAccessStatNotif);

	// Test GetUserIdentity

	INFO_PRINTF1(_L("RMobileSmartCardEap::GetEapSimUserIdentity async."));

	RMobileSmartCardEap::TEapUserIdentityV6 userId;

	RMobileSmartCardEap::TEapUserIdentityV6Pckg userIdPckg(userId);

	RMobileSmartCardEap::TEapUserIdType eapIdType = RMobileSmartCardEap::EPermanentIdentity;

	RMobileSmartCardEap::TEapUserIdType eapPsIdType = RMobileSmartCardEap::EPseudonymIdentity;

	// EPermanentIdentity

	simScEap.GetUserIdentity(reqStatus, eapIdType, userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(userId.iEapId == KConfigScEapId1());

	// EPseudonymIdentity

	simScEap.GetUserIdentity(reqStatus, eapPsIdType, userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(userId.iEapId == KConfigScEapPsId1());

	// bad id tag

	simScEap.GetUserIdentity(reqStatus, static_cast<RMobileSmartCardEap::TEapUserIdType>(5), userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrArgument);

	// Test GetAuthenticationStatus

	INFO_PRINTF1(_L("RMobileSmartCardEap::GetAuthenticationStatus async."));

	RMobileSmartCardEap::TEapAuthStatus authStatus = RMobileSmartCardEap::EHeld;

	simScEap.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == RMobileSmartCardEap::ENoAuthStarted);

	// Test GetEapKey

	INFO_PRINTF1(_L("RMobileSmartCardEap::GetEapKey async."));

	RMobileSmartCardEap::TEapKeyV6 eapKey;

	RMobileSmartCardEap::TEapKeyV6Pckg eapKeyPckg(eapKey);

	RMobileSmartCardEap::TEapKeyTag eapKeyTag = RMobileSmartCardEap::EEapKeyMSK;

	RMobileSmartCardEap::TEapKeyTag eapExtKeyTag = RMobileSmartCardEap::EEapKeyEMSK;

	// MSK

	simScEap.GetEapKey(reqStatus, eapKeyTag, eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(eapKey.iEapKey == KConfigScEapKey1());

	// EMSK

	simScEap.GetEapKey(reqStatus, eapExtKeyTag, eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(eapKey.iEapKey == KConfigScEapKey1EMSK());

	// bad key tag

	simScEap.GetEapKey(reqStatus, static_cast<RMobileSmartCardEap::TEapKeyTag>(5), eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrArgument);

	CActiveScheduler* iSimEapTestScheduler = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(iSimEapTestScheduler);

	CActiveScheduler::Install(iSimEapTestScheduler);

	// Test CAsyncSmartCardEapAuthentication *3 as specified in config file

	INFO_PRINTF1(_L("CAsyncSmartCardEapAuthentication async."));

	// 1st

	TPtrC8 reqPacketPtr(KConfigScEapChal11);

	CTestSimEapAuthenticateData* eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp11());

	TEST(ret == KErrNone);

	CleanupStack::PopAndDestroy(eapAuth);

	simScEap.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == KEapAuthStatus1_1);

	// bad authenticate creeps in!

	_LIT8(badAuthChall, "what????");

	reqPacketPtr.Set(badAuthChall);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(badAuthChall());

	TEST(ret == KErrCorrupt);

	CleanupStack::PopAndDestroy(eapAuth);

	// 2nd

	reqPacketPtr.Set(KConfigScEapChal12);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp12());

	TEST(ret == KErrNone);

	CleanupStack::PopAndDestroy(eapAuth);

	simScEap.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == KEapAuthStatus1_2);

	// third authenticate will be tested after running some requests on

	// a second sub-session, simScEap2.

	// run a second sub-session at the same time

	INFO_PRINTF1(_L("Opening and submitting requests on a second sub-session"));

	myAID = KConfigScEapAID2();

	myEapType = KConfigScEapType2();

	ret = simScEap2.Open(iPhone, myAID, myEapType);

	CleanupClosePushL(simScEap2);

	TESTL(ret == KErrNone);

	TEST(!simScEap2.IsEapMethodOwner());

	simScEap2.InitialiseEapMethod(reqStatus);

	User::WaitForRequest(reqStatus);

	TESTL(reqStatus == KErrNone);

	TESTL(simScEap2.IsEapMethodOwner());

	// EPermanentIdentity

	simScEap2.GetUserIdentity(reqStatus, eapIdType, userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(userId.iEapId == KConfigScEapId2());

	// EPseudonymIdentity - which doesn't exist for this sub-session!

	simScEap2.GetUserIdentity(reqStatus, eapPsIdType, userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNotFound);

	simScEap2.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == RMobileSmartCardEap::ENoAuthStarted);

	// MSK

	simScEap2.GetEapKey(reqStatus, eapKeyTag, eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(eapKey.iEapKey == KConfigScEapKey2());

	// EMSK - which doesn't exist for this sub-session!

	simScEap2.GetEapKey(reqStatus, eapExtKeyTag, eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNotFound);

	// 2* Authenticate as per config.txt

	reqPacketPtr.Set(KConfigScEapChal21);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap2, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp21());

	TEST(ret == KErrNone);

	CleanupStack::PopAndDestroy(eapAuth);

	simScEap2.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == KEapAuthStatus2_1);

	reqPacketPtr.Set(KConfigScEapChal22);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap2, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp22());

	TEST(ret == KErrNone);

	CleanupStack::PopAndDestroy(eapAuth);

	simScEap2.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == KEapAuthStatus2_2);

	// see if first sub-session still works

	reqPacketPtr.Set(KConfigScEapChal13);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp13());

	TEST(ret == KErrNone);

	CleanupStack::PopAndDestroy(eapAuth);

	simScEap.GetAuthenticationStatus(reqStatus, authStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	TEST(authStatus == KEapAuthStatus1_3);

	// one more attempt at authenticate on each sub-session for an

	// error (i.e. no more entries in config.txt!)

	INFO_PRINTF1(_L("Test one too many authenticates"));

	reqPacketPtr.Set(KConfigScEapChal13);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp13());

	TEST(ret == KErrAccessDenied); // it's just an error code that simtsy returns in such a use case

	CleanupStack::PopAndDestroy(eapAuth);

	reqPacketPtr.Set(KConfigScEapChal21);

	eapAuth = CTestSimEapAuthenticateData::NewLC(simScEap2, static_cast<TDesC8&>(reqPacketPtr));

	eapAuth->Start();

	CActiveScheduler::Start();

	ret = eapAuth->ValidateEapResponse(KConfigScEapResp21());

	TEST(ret == KErrAccessDenied); // it's just an error code that simtsy returns in such a use case

	CleanupStack::PopAndDestroy(eapAuth);

	// Release simScEap handle and check completion of simScEap0's

	// previously placed notification, and do a couple more get status.

	INFO_PRINTF1(_L("Releasing first handle"));

	ret = simScEap.ReleaseEapMethod();

	TESTL(ret == KErrNone);

	User::WaitForRequest(reqStatusNotif);

	TEST(reqStatusNotif == KErrNone);

	TEST(eapAccessStatNotif == RMobileSmartCardEap::EEapMethodAvailable);

	simScEap0.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodAvailable);

	simScEap.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodAvailable);

	// Now that simScEap has released, simScEap0 should be able to

	// initialise, but no more config data, so KErrNotFound should be

	// returned.  simScEap0 takes ownership anyway!

	simScEap0.InitialiseEapMethod(reqStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNotFound);

	TEST(simScEap0.IsEapMethodOwner());

	// kill both sub-sessions and active scheduler

	CleanupStack::PopAndDestroy(&simScEap2);

	CleanupStack::PopAndDestroy(iSimEapTestScheduler);

	CleanupStack::PopAndDestroy(&simScEap);

	CleanupStack::PopAndDestroy(&simScEap0);

	// Initialise two further sub-sessions, for stress testing, and

	// ensuring simulator's array indices do not get mangled.

	// Open both sub-sessions

	RMobileSmartCardEap simScEapReInit_1, simScEapReInit_2;

	myAID = KConfigScReInitEapAID();

	myEapType = KConfigScReInitEapType1();

	ret = simScEapReInit_1.Open(iPhone, myAID, myEapType);

	TESTL(ret == KErrNone);

	CleanupClosePushL(simScEapReInit_1);

	myEapType = KConfigScReInitEapType2();

	ret = simScEapReInit_2.Open(iPhone, myAID, myEapType);

	TESTL(ret == KErrNone);

	CleanupClosePushL(simScEapReInit_2);

	// Initialise both sub-sessions

	simScEapReInit_1.InitialiseEapMethod(reqStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	simScEapReInit_2.InitialiseEapMethod(reqStatus);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNone);

	// Neither sub-session contains any data, so any request will

	// return an error.  Plus, making the following two erroneous

	// requests will give more branch coverage to them in simtsy! :-)

	simScEapReInit_1.GetUserIdentity(reqStatus, eapIdType, userIdPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNotFound);

	simScEapReInit_2.GetEapKey(reqStatus, eapKeyTag, eapKeyPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus == KErrNotFound);

	// now they are both in use

	simScEapReInit_1.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodInUseApplicationActive);

	simScEapReInit_2.GetEapMethodAccessStatus(eapAccessStat);

	TEST(eapAccessStat == RMobileSmartCardEap::EEapMethodInUseApplicationActive);

	ret = simScEapReInit_1.ReleaseEapMethod();

	TESTL(ret == KErrNone);

	ret = simScEapReInit_2.ReleaseEapMethod();

	TESTL(ret == KErrNone);

	// kill 'em; I've had enough

	CleanupStack::PopAndDestroy(&simScEapReInit_2);

	CleanupStack::PopAndDestroy(&simScEapReInit_1);

	return TestStepResult();

	}

CTestSimEapAuthenticateData* CTestSimEapAuthenticateData::NewLC(RMobileSmartCardEap& aPhone, TDesC8& aDes)

	{

	CTestSimEapAuthenticateData* self = new(ELeave) CTestSimEapAuthenticateData(aPhone, aDes);

	CleanupStack::PushL(self);

	self->ConstructL(aDes);

	return self;

	}

CTestSimEapAuthenticateData::CTestSimEapAuthenticateData(RMobileSmartCardEap& aPhone, TDesC8& aDes)

: CActive(EPriorityStandard), iPhone(aPhone), iDes(aDes), iAuthResp(NULL)

	{

	}

CTestSimEapAuthenticateData::~CTestSimEapAuthenticateData()

	{

	delete iTwoPhaseRetrieve;

	iTwoPhaseRetrieve = NULL;

	}

void CTestSimEapAuthenticateData::ConstructL(TDesC8& aDes)

	{

    CActiveScheduler::Add(this);

	iTwoPhaseRetrieve = CAsyncSmartCardEapAuthentication::NewL(iPhone, aDes);

	}

void CTestSimEapAuthenticateData::Start()

	{

	iTwoPhaseRetrieve->Start(iStatus);

	SetActive();

	}

void CTestSimEapAuthenticateData::RunL()

	{

	if (iStatus == KErrNone)

		{

		iAuthResp = &(iTwoPhaseRetrieve->RetrieveEapResponse());

		}

	CActiveScheduler::Stop();

	}

/**

Validates if the EAP authenticate response is the same as the

aExpectedResponse the user expects.

@param aExpectedResponse The response that this active object should

                         have retrieved from the TSY.

@return iStatus of this active object if it has not completed

        successfully, KErrCorrupt if the data retrieved from TSY is not

        the same as the aExpectedResponse, or KErrNone if all is well.

*/

TInt CTestSimEapAuthenticateData::ValidateEapResponse(const TDesC8& aExpectedResponse)

	{

	TInt ret = KErrNone;

	// iStatus will be an error if the request data is invalid.

	if (iStatus != KErrNone)

		{

		ret = iStatus.Int();

		}

	else if ((*iAuthResp) != aExpectedResponse)

		{

		ret = KErrCorrupt;

		}

	return ret;

	}

void CTestSimEapAuthenticateData::DoCancel()

	{

	iTwoPhaseRetrieve->Cancel();

	CActiveScheduler::Stop();

	}

// Now test for bad clients who open but never close the phone //

/**

Each test step initialises its own name.

*/

CTestInitEapWithoutClosing::CTestInitEapWithoutClosing()