// Copyright (c) 2003-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 "TE_EtelIsvbase.h"

#include "TE_EtelIsvSuppServices.h"

/**

@SYMTestCaseID Etel3rdParty 22.1, TestGetSupplementaryServiceStatus

@SYMTestCaseDesc Test GetCallForwardingStatus, GetCallBarringStatus and

* GetCallWaitingStatus  3rd party APIs

@SYMFssID SGL.GT0166.054 v1.3 A2_Telephony_Functional_Specification.doc, REQ 2116.4.11

*/

 //

// RETRIEVE SUPPLEMENTARY SERVICE INFORMATION //

//

CTestGetSupplementaryServiceStatus::CTestGetSupplementaryServiceStatus()

/** Each test step initialises it's own name

*/

{

	// store the name of this test case

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

	SetTestStepName(_L("TestGetSupplementaryService"));

}

enum TVerdict CTestGetSupplementaryServiceStatus::doTestStepL()

{

	INFO_PRINTF1(_L("Test retrieval of supplementary service information"));

	// Set the config.txt test number mapping

	SetTestNumber(13);

	// Set the expected request status

	TRequestStatus ExpStat=KErrNone;

	CTelephony::TCallBarringSupplServicesV1 ExpectedCallBarringStatus; 

	CTelephony::TCallForwardingSupplServicesV1 ExpectedCallForwardingStatus;

	CTelephony::TCallWaitingSupplServicesV1 ExpectedCallWaitingStatus;  

	// Create an active object and push it onto the clean up stack

	CTestGetSupplementaryServiceStatusAct* GetSupplementaryServiceStatusAct = CTestGetSupplementaryServiceStatusAct::NewLC(this, iTelephony);

	//

	// Test call barring //

	//

	INFO_PRINTF1(_L("Test retrieval of call barring information"));

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.

	//go through each condition, status and service group. 

	//Test retrieving condition which is out of range

	ExpStat=KErrNotSupported;

	ExpectedCallBarringStatus.iCallBarring=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,(CTelephony::TCallBarringCondition)7, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	//Test OOM

	#if defined(_DEBUG)

		ExpStat=KErrNoMemory;

		__UHEAP_FAILNEXT(1);

		ExpectedCallBarringStatus.iCallBarring=CTelephony::EStatusActive;

		GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarAllIncoming, CTelephony::EVoiceService, ExpStat);

		CActiveScheduler::Start();

	__UHEAP_RESET;

	#endif

    ExpStat=KErrNone;

	ExpectedCallBarringStatus.iCallBarring=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarAllIncoming, CTelephony::EVoiceService, ExpStat, ETrue);

	CActiveScheduler::Start();

	// INC085718: SimTSY is configured to have EBarIncomingRoaming for EVoiceService. A query of the status for an other service must return ENotActive

	ExpectedCallBarringStatus.iCallBarring=CTelephony::ENotActive;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarIncomingRoaming, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallBarringStatus.iCallBarring=CTelephony::ENotProvisioned;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarAllOutgoing, CTelephony::EFaxService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallBarringStatus.iCallBarring=CTelephony::ENotAvailable;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarOutgoingInternational, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallBarringStatus.iCallBarring=CTelephony::EUnknown;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarOutgoingInternationalExHC, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	//Test cancel

	INFO_PRINTF1(_L("Test cancel of call barring information"));

	TInt cancelerr = iTelephony->CancelAsync(CTelephony::EGetCallBarringStatusCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarAllIncoming, CTelephony::EDataService, ExpStat);

	CTestCanceller* canceller = GetSupplementaryServiceStatusAct->RetrieveCanceller();

	canceller->Call();

	CActiveScheduler::Start();	

	TEST1(GetSupplementaryServiceStatusAct->iStatus.Int() == KErrCancel, ETrue);

	//

	// Test call forwarding //

	//

	INFO_PRINTF1(_L("Test retrieval of call forwarding information"));

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.

	//Test retrieving condition which is out of range

	ExpStat=KErrNotSupported;

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, (CTelephony::TCallForwardingCondition)7, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	ExpStat=KErrNone;

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingUnconditional, CTelephony::EVoiceService, ExpStat, ETrue);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::ENotActive;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingBusy, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EUnknown;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingNoReply, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::ENotProvisioned;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingNotReachable, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::ENotAvailable;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingBusy, CTelephony::EFaxService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EUnknown;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingNoReply, CTelephony::EFaxService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EUnknown;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingNotReachable, CTelephony::EFaxService, ExpStat);

	CActiveScheduler::Start();

	//Test cancel

	INFO_PRINTF1(_L("Test cancel of call forwarding information"));

	cancelerr = iTelephony->CancelAsync(CTelephony::EGetCallForwardingStatusCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingNoReply, CTelephony::EVoiceService, ExpStat);

	canceller = GetSupplementaryServiceStatusAct->RetrieveCanceller();

	canceller->Call();

	CActiveScheduler::Start();	

	TEST1(GetSupplementaryServiceStatusAct->iStatus.Int() == KErrCancel, ETrue);

	//

	// Test call waiting //

	//

	INFO_PRINTF1(_L("Test retrieval of call waiting information"));

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.

	ExpStat=KErrNone;

	ExpectedCallWaitingStatus.iCallWaiting=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCWSupplementaryServiceStatus(ExpectedCallWaitingStatus, CTelephony::EVoiceService, ExpStat, ETrue);

	CActiveScheduler::Start();

	ExpectedCallWaitingStatus.iCallWaiting=CTelephony::ENotActive;

	GetSupplementaryServiceStatusAct->TestGetCWSupplementaryServiceStatus(ExpectedCallWaitingStatus, CTelephony::EDataService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallWaitingStatus.iCallWaiting=CTelephony::ENotProvisioned;

	GetSupplementaryServiceStatusAct->TestGetCWSupplementaryServiceStatus(ExpectedCallWaitingStatus, CTelephony::EFaxService, ExpStat);

	CActiveScheduler::Start();

	//Test cancel

	INFO_PRINTF1(_L("Test cancel of call waiting information"));

	cancelerr = iTelephony->CancelAsync(CTelephony::EGetCallWaitingStatusCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	GetSupplementaryServiceStatusAct->TestGetCWSupplementaryServiceStatus(ExpectedCallWaitingStatus,CTelephony::EVoiceService, ExpStat);

	canceller = GetSupplementaryServiceStatusAct->RetrieveCanceller();

	canceller->Call();

	CActiveScheduler::Start();	

	TEST1(GetSupplementaryServiceStatusAct->iStatus.Int() == KErrCancel, ETrue);

    // Clean up

	CleanupStack::PopAndDestroy(); //GetSupplementaryServiceStatusAct

	//Part 2 - Open a new test which tests EAllServices responses 

	// Set the config.txt test number mapping

	SetTestNumber(33);	

	GetSupplementaryServiceStatusAct = CTestGetSupplementaryServiceStatusAct::NewLC(this, iTelephony);

	//Call barring

	ExpStat=KErrNone;

	ExpectedCallBarringStatus.iCallBarring=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCBSupplementaryServiceStatus(ExpectedCallBarringStatus,CTelephony::EBarAllIncoming, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	//Call forwarding

	ExpStat=KErrNone;

	ExpectedCallForwardingStatus.iCallForwarding=CTelephony::EUnknown;

	GetSupplementaryServiceStatusAct->TestGetCFSupplementaryServiceStatus(ExpectedCallForwardingStatus, CTelephony::ECallForwardingUnconditional, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	ExpectedCallWaitingStatus.iCallWaiting=CTelephony::EStatusActive;

	GetSupplementaryServiceStatusAct->TestGetCWSupplementaryServiceStatus(ExpectedCallWaitingStatus, CTelephony::EVoiceService, ExpStat);

	CActiveScheduler::Start();

	// Clean up

	CleanupStack::PopAndDestroy(); //GetSupplementaryServiceStatusAct

	return TestStepResult();

}

CTestGetSupplementaryServiceStatusAct* CTestGetSupplementaryServiceStatusAct::NewLC(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony)

//Factory constructor

	{

	CTestGetSupplementaryServiceStatusAct* obj = new(ELeave) CTestGetSupplementaryServiceStatusAct(aTestStep, aTelephony);

	CleanupStack::PushL(obj);

	obj->ConstructL();

	return obj;

	}

CTestGetSupplementaryServiceStatusAct::CTestGetSupplementaryServiceStatusAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony)

	: CEtelIsvActBase(aTestStep, aTelephony),

	  iCallBarringStatusPckg(iCallBarringStatus),

	  iCallBarringStatusBuff(iCallBarringStatus),

	  iCallWaitingStatusPckg(iCallWaitingStatus),

	  iCallWaitingStatusBuff(iCallWaitingStatus),

	  iCallForwardingStatusPckg(iCallForwardingStatus),

	  iCallForwardingStatusBuff(iCallForwardingStatus)

	{  

	}

void CTestGetSupplementaryServiceStatusAct::ConstructL()

	{  

	iCanceller = new(ELeave) CTestCanceller(this);

	CActiveScheduler::Add(this);

	}

CTestGetSupplementaryServiceStatusAct::~CTestGetSupplementaryServiceStatusAct()

	{  

	Cancel();	// if any Req outstanding, calls DoCancel() to cleanup.

	delete iCanceller;

	}

void CTestGetSupplementaryServiceStatusAct::DoCancel()

	{

	if(iSupplServiceType == ETestSupplServiceCB)

		{

		iTelephony->CancelAsync(CTelephony::EGetCallBarringStatusCancel);

		}

	else if(iSupplServiceType == ETestSupplServiceCF)

		{

		iTelephony->CancelAsync(CTelephony::EGetCallForwardingStatusCancel);

		}

	else if(iSupplServiceType == ETestSupplServiceCW)

		{

		iTelephony->CancelAsync(CTelephony::EGetCallWaitingStatusCancel);

		}

	}

void CTestGetSupplementaryServiceStatusAct::TestGetCFSupplementaryServiceStatus(CTelephony::TCallForwardingSupplServicesV1& aExpSupplementaryServiceStatus, CTelephony::TCallForwardingCondition aSSCondition, CTelephony::TServiceGroup aServiceGroup, TRequestStatus aExpStat, TBool aCheckConcurrency)

	{	

	// Set the service type requested

	iSupplServiceType=ETestSupplServiceCF;	

	// Set the expected return value

	iExpStat=aExpStat;	

	iExpectedCallForwardingStatus.iCallForwardingCondition = aSSCondition;

	iServiceGroup = aServiceGroup;

 	// Set the expected return values for call forwarding

	iExpectedCallForwardingStatus.iCallForwarding= aExpSupplementaryServiceStatus.iCallForwarding;		

	// Make a call to the 3rd party API

	TDes8* data;

	if (iTestStep->iBufferMode)

		{

		data = &iCallForwardingStatusBuff;

		}

	else

		{

		data = &iCallForwardingStatusPckg;

		}

	iTelephony->GetCallForwardingStatus(iStatus, aSSCondition, *data, aServiceGroup );

	if(aCheckConcurrency)

		{

		TRequestStatus tmpStatus;

		iTelephony->GetCallForwardingStatus(tmpStatus, aSSCondition, *data, aServiceGroup );

		User::WaitForRequest(tmpStatus);

		iTestStep->TEST1(tmpStatus.Int() == KErrInUse, ETrue);

		}

	SetActive();			

	}

void CTestGetSupplementaryServiceStatusAct::TestGetCBSupplementaryServiceStatus(CTelephony::TCallBarringSupplServicesV1& aExpSupplementaryServiceStatus, CTelephony::TCallBarringCondition aSSCondition, CTelephony::TServiceGroup aServiceGroup, TRequestStatus aExpStat, TBool aCheckConcurrency)

	{	

	// Set the service type requested

	iSupplServiceType=ETestSupplServiceCB;	

	// Set the expected return value

	iExpStat=aExpStat;	

	iExpectedCallBarringStatus.iCallBarringCondition = aSSCondition;

	iServiceGroup = aServiceGroup;

 	// Set the expected return values for call forwarding

	iExpectedCallBarringStatus.iCallBarring= aExpSupplementaryServiceStatus.iCallBarring;		

	// Make a call to the 3rd party API

	TDes8* data;

	if (iTestStep->iBufferMode)

		{

		data = &iCallBarringStatusBuff;

		}

	else

		{

		data = &iCallBarringStatusPckg;

		}

	iTelephony->GetCallBarringStatus(iStatus, aSSCondition, *data, aServiceGroup );

	if(aCheckConcurrency)

		{

		TRequestStatus tmpStatus;

		iTelephony->GetCallBarringStatus(tmpStatus, aSSCondition, *data, aServiceGroup );

		User::WaitForRequest(tmpStatus);

		iTestStep->TEST1(tmpStatus.Int() == KErrInUse, ETrue);

		}

	SetActive();			

	}

void CTestGetSupplementaryServiceStatusAct::TestGetCWSupplementaryServiceStatus(CTelephony::TCallWaitingSupplServicesV1& aExpSupplementaryServiceStatus, CTelephony::TServiceGroup aServiceGroup, TRequestStatus aExpStat, TBool aCheckConcurrency)

	{	

	// Set the service type requested

	iSupplServiceType=ETestSupplServiceCW;	

	// Set the expected return value

	iExpStat=aExpStat;	

	iServiceGroup = aServiceGroup;

 	// Set the expected return values for call forwarding

	iExpectedCallWaitingStatus.iCallWaiting= aExpSupplementaryServiceStatus.iCallWaiting;		

	// Make a call to the 3rd party API

	TDes8* data;

	if (iTestStep->iBufferMode)

		{

		data = &iCallWaitingStatusBuff;

		}

	else

		{

		data = &iCallWaitingStatusPckg;

		}

	iTelephony->GetCallWaitingStatus(iStatus, *data, aServiceGroup );

	if(aCheckConcurrency)

		{

		TRequestStatus tmpStatus;

		iTelephony->GetCallWaitingStatus(tmpStatus, *data, aServiceGroup );

		User::WaitForRequest(tmpStatus);

		iTestStep->TEST1(tmpStatus.Int() == KErrInUse, ETrue);

		}

	SetActive();			

	}

void CTestGetSupplementaryServiceStatusAct::RunL()

	{ 

	iTestStep->INFO_PRINTF2(_L("Request status set =  %d"), iStatus.Int() ); 

	iTestStep->TEST1(iStatus.Int() == iExpStat.Int(), ETrue);

	if(iStatus.Int() == KErrNone)

	{

		iTestStep->INFO_PRINTF2(_L("Service Group = : %d"),iServiceGroup );		

		if (iSupplServiceType == ETestSupplServiceCB)

		{		

			CTelephony::TCallBarringSupplServicesV1* cbData;

			if (iTestStep->iBufferMode)

				{

				cbData = reinterpret_cast<CTelephony::TCallBarringSupplServicesV1*> ( &iCallBarringStatusBuff() );

				}

			else

				{

				cbData = reinterpret_cast<CTelephony::TCallBarringSupplServicesV1*> ( &iCallBarringStatusPckg() );

				}

			// Print off the call barring values retrieved and those expected

			iTestStep->INFO_PRINTF2(_L("Call barring condition expected: %d"),iExpectedCallBarringStatus.iCallBarringCondition );

			iTestStep->INFO_PRINTF2(_L("Call barring condition: %d"),cbData->iCallBarringCondition );

			iTestStep->INFO_PRINTF2(_L("Call Barring status  expected: %d"), iExpectedCallBarringStatus.iCallBarring );

			iTestStep->INFO_PRINTF2(_L("Call barring status retrieved: %d"), cbData->iCallBarring );

			// Check that the retrieved values match those expected.

			iTestStep->TEST1( cbData->iCallBarringCondition ==  iExpectedCallBarringStatus.iCallBarringCondition, ETrue );

			iTestStep->TEST1( cbData->iCallBarring ==  iExpectedCallBarringStatus.iCallBarring, ETrue );

	 	}

	 	else 

	 	if (iSupplServiceType == ETestSupplServiceCF)

		{

			CTelephony::TCallForwardingSupplServicesV1* cfData;

			if (iTestStep->iBufferMode)

				{

				cfData = reinterpret_cast<CTelephony::TCallForwardingSupplServicesV1*> ( &iCallForwardingStatusBuff() );

				}

			else

				{

				cfData = reinterpret_cast<CTelephony::TCallForwardingSupplServicesV1*> ( &iCallForwardingStatusPckg() );

				}

			// Print off the call forwarding values retrieved and those expected

			iTestStep->INFO_PRINTF2(_L("Call forwarding expected condition: %d"), iExpectedCallForwardingStatus.iCallForwardingCondition );

			iTestStep->INFO_PRINTF2(_L("Call forwarding condition: %d"), cfData->iCallForwardingCondition );

			iTestStep->INFO_PRINTF2(_L("Call Forwarding status  expected: %d"), iExpectedCallForwardingStatus.iCallForwarding );

			iTestStep->INFO_PRINTF2(_L("Call forwarding status retrieved: %d"), cfData->iCallForwarding );

			// Check that the retrieved values match those expected.

			iTestStep->TEST1( cfData->iCallForwardingCondition ==  iExpectedCallForwardingStatus.iCallForwardingCondition, ETrue );

			iTestStep->TEST1( cfData->iCallForwarding ==  iExpectedCallForwardingStatus.iCallForwarding, ETrue );

		}

		else 

	 	if (iSupplServiceType == ETestSupplServiceCW)

		{

			CTelephony::TCallWaitingSupplServicesV1* cwData;

			if (iTestStep->iBufferMode)

				{

				cwData = reinterpret_cast<CTelephony::TCallWaitingSupplServicesV1*> ( &iCallWaitingStatusBuff() );

				}

			else

				{

				cwData = reinterpret_cast<CTelephony::TCallWaitingSupplServicesV1*> ( &iCallWaitingStatusPckg() );

				}

			// Print off the call waiting values retrieved and those expected

			iTestStep->INFO_PRINTF2(_L("Call Waiting status  expected: %d"), iExpectedCallWaitingStatus.iCallWaiting );

			iTestStep->INFO_PRINTF2(_L("Call Waiting status retrieved: %d"), cwData->iCallWaiting );

			// Check that the retrieved values match those expected.

			iTestStep->TEST1( cwData->iCallWaiting ==  iExpectedCallWaitingStatus.iCallWaiting , ETrue);

		}

	}

	else

		{

		iTestStep->INFO_PRINTF2(_L("Unexpected request status received:: %d"), iStatus.Int() );

		}

	CActiveScheduler::Stop();

	}

/**

@SYMTestCaseID Etel3rdParty 23.1, TestGetIdentityServiceStatus

@SYMTestCaseDesc Test GetIdentityServiceStatus  3rd party API

@SYMFssID SGL.GT0166.054 v1.3 A2_Telephony_Functional_Specification.doc, REQ 2116.4.12

*/

//

// RETRIEVE IDENTITY SERVICE INFORMATION //

//

CTestGetIdentityServiceStatus::CTestGetIdentityServiceStatus()

/** Each test step initialises it's own name

*/

{

	// store the name of this test case

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

	SetTestStepName(_L("TestGetIdentityService"));

}

enum TVerdict CTestGetIdentityServiceStatus::doTestStepL()

{

	INFO_PRINTF1(_L("Test retrieval of identity service information"));

	// Set the config.txt test number mapping

	SetTestNumber(14);

	// Set the expected request status

	TRequestStatus ExpStat=KErrNone;

	// Create an active object and push it onto the clean up stack

	CTestGetIdentityServiceStatusAct* GetIdentityServiceStatusAct = CTestGetIdentityServiceStatusAct::NewLC(this, iTelephony);

	CTelephony::TIdentityServiceV1 ExpectedIdentityStatus;

	CTelephony::TIdentityService IdentityServiceTypeRequired; 

	//Test OOM

	#if defined(_DEBUG)

		INFO_PRINTF1(_L("Test GetIdentityServiceStatus OOM"));

		ExpStat=KErrNoMemory;

		IdentityServiceTypeRequired=CTelephony::EIdServiceCallerPresentation;

		ExpectedIdentityStatus.iIdentityStatus=CTelephony::EIdServiceActiveDefaultRestricted;

		__UHEAP_FAILNEXT(1);

		GetIdentityServiceStatusAct->TestGetIdentityServiceStatus(ExpectedIdentityStatus,IdentityServiceTypeRequired, ExpStat);

		CActiveScheduler::Start();

		__UHEAP_RESET;

	#endif

	ExpStat=KErrNone;

	// Test EIdServiceCallerPresentation

	INFO_PRINTF1(_L("Test retrieval of EIdServiceCallerPresentation status"));

	// Set the type of supplementary service info required

	IdentityServiceTypeRequired=CTelephony::EIdServiceCallerPresentation;

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.	

	ExpectedIdentityStatus.iIdentityStatus=CTelephony::EIdServiceActiveDefaultRestricted;

	// Attempt to retrieve the service information. Pass the expected values. 

	GetIdentityServiceStatusAct->TestGetIdentityServiceStatus(ExpectedIdentityStatus,IdentityServiceTypeRequired, ExpStat, ETrue);

	// Start the active scheduler

	CActiveScheduler::Start();

	// Test EIdServiceCallerRestriction

	INFO_PRINTF1(_L("Test retrieval of EIdServiceCallerRestriction status"));

	// Set the type of supplementary service info required

	IdentityServiceTypeRequired=CTelephony::EIdServiceCallerRestriction;

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.	

	ExpectedIdentityStatus.iIdentityStatus=CTelephony::EIdServiceNotProvisioned;

	// Attempt to retrieve the service information. Pass the expected values. 

	GetIdentityServiceStatusAct->TestGetIdentityServiceStatus(ExpectedIdentityStatus,IdentityServiceTypeRequired, ExpStat);

	// Start the active scheduler

	CActiveScheduler::Start();

	//Test cancel

	TInt cancelerr = iTelephony->CancelAsync(CTelephony::EGetIdentityServiceStatusCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	GetIdentityServiceStatusAct->TestGetIdentityServiceStatus(ExpectedIdentityStatus,IdentityServiceTypeRequired, ExpStat);

	CTestCanceller* canceller = GetIdentityServiceStatusAct->RetrieveCanceller();

	canceller->Call();