// 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 The TEFUnit test suite for SupplementaryServicesControl in the Common TSY.

*/

#include "cctsysupplementaryservicesfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <test/tmockltsydata.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/ltsy/mltsydispatchsupplementaryservicesinterface.h>

#include "mockltsyindicatorids.h"

#include <mmretrieve.h>

#include <ctsy/rmmcustomapi.h>

#include "cctsyactiveretriever.h"

#include <ctsy/ltsy/mltsydispatchcallcontrolinterface.h>

CTestSuite* CCTsySupplementaryServicesFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	//add use-case tests

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUseCase0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUseCase0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUseCase0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUseCase0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUseCase0005L);

	//add other unit tests

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsySupplementaryServicesFU, TestUnit0008L);

	END_SUITE;

	}

//

// Use-case tests

//

/**

 * Compare two RMobilePhone::TMobileAddress objects.

 * 

 * @param aAddr1 the first object.

 * @param aAddr2 the second object.

 * @return ETrue iff the two object are the same.

 * 

 * */ 

TBool operator ==(const RMobilePhone::TMobileAddress& aAddr1, 

		const RMobilePhone::TMobileAddress& aAddr2)

	{

	if(aAddr1.iTypeOfNumber != aAddr2.iTypeOfNumber)

		{

		return EFalse;

		}

	if(aAddr1.iNumberPlan != aAddr2.iNumberPlan)

		{

		return EFalse;

		}

	if(aAddr1.iTelNumber != aAddr2.iTelNumber)

		{

		return EFalse;

		}

	return ETrue;

	}

/**

 * Compare two RMobilePhone::TMobilePhoneCFInfoEntryV1 objects.

 * 

 * @param aEntry1 the first object.

 * @param aEntry2 the second object.

 * @return ETrue iff the two object are the same.

 * 

 * */ 

TBool operator ==(const RMobilePhone::TMobilePhoneCFInfoEntryV1& aEntry1, 

		const RMobilePhone::TMobilePhoneCFInfoEntryV1& aEntry2)

	{

	if(aEntry1.iCondition!=aEntry2.iCondition)

		{

		return EFalse;

		}

	if(aEntry1.iServiceGroup!=aEntry2.iServiceGroup)

		{

		return EFalse;

		}

	if(aEntry1.iStatus!=aEntry2.iStatus)

		{

		return EFalse;

		}

	if(!(aEntry1.iNumber==aEntry2.iNumber))

		{

		return EFalse;

		}

	if(aEntry1.iTimeout!=aEntry2.iTimeout)

		{

		return EFalse;

		}

	return ETrue;

	}

/**

 * Compare two RMobilePhone::TMobilePhoneCWInfoEntryV1 objects.

 * 

 * @param aEntry1 the first object.

 * @param aEntry2 the second object.

 * @return ETrue iff the two object are the same.

 * 

 * */ 

TBool operator ==(const RMobilePhone::TMobilePhoneCWInfoEntryV1& aEntry1, 

		const RMobilePhone::TMobilePhoneCWInfoEntryV1& aEntry2)

	{

	if(aEntry1.iStatus!=aEntry2.iStatus)

		{

		return EFalse;

		}

	if(aEntry1.iServiceGroup!=aEntry2.iServiceGroup)

		{

		return EFalse;

		}

	return ETrue;

	}

/**

 * Compare two RMobilePhone::TMobilePhoneCWInfoEntryV1 objects.

 * 

 * @param aEntry1 the first object.

 * @param aEntry2 the second object.

 * @return ETrue iff the two object are the same.

 * 

 * */ 

TBool operator ==(const RMobilePhone::TMobilePhoneCBInfoEntryV1& aEntry1, 

		const RMobilePhone::TMobilePhoneCBInfoEntryV1& aEntry2)

	{

	if(aEntry1.iStatus!=aEntry2.iStatus)

		{

		return EFalse;

		}

	if(aEntry1.iCondition!=aEntry2.iCondition)

		{

		return EFalse;

		}

	if(aEntry1.iServiceGroup!=aEntry2.iServiceGroup)

		{

		return EFalse;

		}

	return ETrue;

	}

/**

 * Compare two CMobilePhoneReadOnlyList objects.

 * 

 * @param aList1 the first object.

 * @param aList2 the second object.

 * @return ETrue iff the two object are the same.

 * 

 * */ 

template<class T>

TBool operator ==(const CMobilePhoneReadOnlyList<T>& aList1, 

		const CMobilePhoneReadOnlyList<T>& aList2)

	{

	TInt size1 = aList1.Enumerate();

	TInt size2 = aList2.Enumerate();

	if(size1 != size2)

		{

		return EFalse;

		}

	for(TInt i = 0; i < size1; ++i)

		{

		if(!(aList1.GetEntryL(i) == aList2.GetEntryL(i)))

			{

			return EFalse;

			}

		}

	return ETrue;

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-UC0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for notify, set and get the call forwarding

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::NotifyCallForwardingActive, RMobilePhone::NotifyCallForwardingStatusChange, RMobilePhone::SetCallForwardingStatus, CRetrieveMobilePhoneCFList::Start

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySupplementaryServicesFU::TestUseCase0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);	

	// post NotifyCallForwardingActive and NotifyCallForwardingStatusChange 

	TRequestStatus notifyCallForwardingActiveStatus;

	RMobilePhone::TMobileService service;

	RMobilePhone::TMobilePhoneCFActive active;

	iPhone.NotifyCallForwardingActive(notifyCallForwardingActiveStatus,service,active);

	TRequestStatus notifyCallForwardingStatusChangeStatus;

	RMobilePhone::TMobilePhoneCFCondition notifyCondition;

	iPhone.NotifyCallForwardingStatusChange(notifyCallForwardingStatusChangeStatus,notifyCondition);

	// prepare ltsy to accept and answer the SetCallForwardingStatus

	RMobilePhone::TMobilePhoneCFCondition setCondition = RMobilePhone::ECallForwardingNoReply;

	RMobilePhone::TMobilePhoneCFChangeV1  callForwardinginfo;

	callForwardinginfo.iAction = RMobilePhone::EServiceActionRegister;

	callForwardinginfo.iNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;

	callForwardinginfo.iNumber.iNumberPlan   = RMobilePhone::EIsdnNumberPlan;

	_LIT(KTelNumber,"+74951000000");

	callForwardinginfo.iNumber.iTelNumber.Copy(KTelNumber);

	callForwardinginfo.iServiceGroup = RMobilePhone::EVoiceService;

	callForwardinginfo.iTimeout = 20;

	TMockLtsyData5<RMobilePhone::TMobilePhoneCFCondition, 

	               RMobilePhone::TMobileService,

	               RMobilePhone::TMobilePhoneServiceAction,

	               TInt,

	               TBuf<RMobilePhone::KMaxMobileTelNumberSize> > mockCompleteSetData(setCondition,

	            		   callForwardinginfo.iServiceGroup,

	            		   callForwardinginfo.iAction,

	            		   callForwardinginfo.iTimeout,

	            		   callForwardinginfo.iNumber.iTelNumber);

	data.Close();

	mockCompleteSetData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesSetCallForwardingStatus::KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId, data, KErrNone);

	// call to RMobilePhone::SetCallForwardingStatus

	TRequestStatus requestStatusSet;

	iPhone.SetCallForwardingStatus(requestStatusSet, setCondition, callForwardinginfo);

	ASSERT_EQUALS(KRequestPending, notifyCallForwardingActiveStatus.Int());

	ASSERT_EQUALS(KRequestPending, notifyCallForwardingStatusChangeStatus.Int());

	ASSERT_EQUALS(KRequestPending, requestStatusSet.Int());

	// complete NotifyCallForwardingStatusChange

	RMobilePhone::TMobilePhoneCFCondition completeCondition = RMobilePhone::ECallForwardingNoReply;

	TMockLtsyData1<RMobilePhone::TMobilePhoneCFCondition> mockCompleteNotifyCFStatusChangeData(completeCondition);

	data.Close();

	mockCompleteNotifyCFStatusChangeData.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSupplementaryServicesNotifyCallForwardingStatusChangeIndId, KErrNone, data);

	//Wait for NotifyCallForwardingStatusChange

	User::WaitForRequest(notifyCallForwardingStatusChangeStatus);

	ASSERT_EQUALS(KErrNone, notifyCallForwardingStatusChangeStatus.Int());

	ASSERT_EQUALS(KRequestPending, requestStatusSet.Int());

	ASSERT_EQUALS(notifyCondition, completeCondition);

	// complete SetCallForwardingStatus

	iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesSetCallForwardingStatus::KLtsyDispatchSupplementaryServicesSetCallForwardingStatusApiId, KErrNone);

	//Wait for SetCallForwardingStatus

	User::WaitForRequest(requestStatusSet);

	ASSERT_EQUALS(KErrNone, requestStatusSet.Int());

	// complete notify NotifyCallForwardingActive

	RMobilePhone::TMobileService completeService = callForwardinginfo.iServiceGroup;

	RMobilePhone::TMobilePhoneCFActive completeActive = RMobilePhone::ECFConditionalActive;

	TMockLtsyData2<RMobilePhone::TMobileService, RMobilePhone::TMobilePhoneCFActive> mockCompleteNotifyCFAData(completeService,completeActive);

	data.Close();

	mockCompleteNotifyCFAData.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSupplementaryServicesNotifyCallForwardingActiveIndId, KErrNone, data);

	//Wait for NotifyCallForwardingActive

	User::WaitForRequest(notifyCallForwardingActiveStatus);

	ASSERT_EQUALS(KErrNone, notifyCallForwardingActiveStatus.Int());

	ASSERT_EQUALS(service, completeService);

	ASSERT_EQUALS(active, completeActive);

	// prepare ltsy to accept the CRetrieveMobilePhoneCFList::Start

	//CFilteringActiveScheduler does not need to be used, this should be changed

	//to a listretrieverao type class

	CFilteringActiveScheduler* scheduler = new (ELeave) CFilteringActiveScheduler();

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	RMobilePhone::TMobilePhoneCFCondition getCondition = RMobilePhone::ECallForwardingBusy;

	RMobilePhone::TMobileService getServiceGroup = RMobilePhone::EVoiceService;

	TMockLtsyData2<RMobilePhone::TMobilePhoneCFCondition, RMobilePhone::TMobileService> mockCompleteGetData(getCondition,getServiceGroup);

	data.Close();

	mockCompleteGetData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesGetCallForwardingStatus::KLtsyDispatchSupplementaryServicesGetCallForwardingStatusApiId, data, KErrNone);	

	// Get the call forwarding list

	TRequestStatus requestStatusGet;

	RMobilePhone::TMobilePhoneCFCondition condition = getCondition;

	RMobilePhone::TMobileService serviceGroup = getServiceGroup;

	CRetrieveMobilePhoneCFList* asyncRetrieveMobilePhoneCFList =

	                                       CRetrieveMobilePhoneCFList::NewL(iPhone);    

	CleanupStack::PushL(asyncRetrieveMobilePhoneCFList);

	CActiveRetriever::ResetRequestsNumber();

	CActiveRetriever* activeRetriever = 

						CActiveRetriever::NewL(*asyncRetrieveMobilePhoneCFList);

	CleanupStack::PushL(activeRetriever);

	scheduler->AddRetrieverL(*activeRetriever);

	asyncRetrieveMobilePhoneCFList->Start(activeRetriever->iStatus, condition, serviceGroup);

	activeRetriever->Activate();

	// Complete get call forwarding list

	CMobilePhoneCFList* completeCFList = CMobilePhoneCFList::NewL();

	CleanupStack::PushL(completeCFList);

	RMobilePhone::TMobilePhoneCFInfoEntryV1	entryCFInfoEntry;

	entryCFInfoEntry.iTimeout              = 20;

	entryCFInfoEntry.iCondition            = RMobilePhone::ECallForwardingUnconditional;

	entryCFInfoEntry.iServiceGroup         = RMobilePhone::EVoiceService;

	entryCFInfoEntry.iStatus               = RMobilePhone::ECallForwardingStatusNotProvisioned;

	entryCFInfoEntry.iNumber.iTypeOfNumber = RMobilePhone::EInternationalNumber;

	entryCFInfoEntry.iNumber.iNumberPlan   = RMobilePhone::EIsdnNumberPlan;

	entryCFInfoEntry.iNumber.iTelNumber.Copy(KTelNumber);

	completeCFList->AddEntryL(entryCFInfoEntry);

	entryCFInfoEntry.iTimeout              = 15;

	entryCFInfoEntry.iCondition            = RMobilePhone::ECallForwardingNoReply;

	entryCFInfoEntry.iServiceGroup         = RMobilePhone::EServiceUnspecified;

	entryCFInfoEntry.iStatus               = RMobilePhone::ECallForwardingStatusActive;

	entryCFInfoEntry.iNumber.iTypeOfNumber = RMobilePhone::ENationalNumber;

	entryCFInfoEntry.iNumber.iNumberPlan   = RMobilePhone::ENationalNumberPlan;

	_LIT(KTelNumber2,"123456789");

	entryCFInfoEntry.iNumber.iTelNumber.Copy(KTelNumber2);

	completeCFList->AddEntryL(entryCFInfoEntry);

	CBufBase* completeCFListBuf = completeCFList->StoreLC();

	data.Create(completeCFListBuf->Ptr(0));

    iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesGetCallForwardingStatus::KLtsyDispatchSupplementaryServicesGetCallForwardingStatusApiId, KErrNone, data);

	//Wait for CRetrieveMobilePhoneCFList::Start

	scheduler->StartScheduler();

	ASSERT_EQUALS(KErrNone, activeRetriever->iStatus.Int());

	CMobilePhoneCFList *list = asyncRetrieveMobilePhoneCFList->RetrieveListL();

	ASSERT_EQUALS(*completeCFList,*list);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(7, this); // completeCFListBuf, completeCFList, activeRetriever, asyncRetrieveMobilePhoneCFList, scheduler, data, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-UC0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for send a network service request string (with and without FDN check)

@SYMTestPriority High

@SYMTestActions Invokes RMobilePhone::SendNetworkServiceRequest, RMobilePhone::SendNetworkServiceRequestNoFdnCheck

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySupplementaryServicesFU::TestUseCase0002L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);	

	// prepare ltsy to accept and answer the SendNetworkServiceRequest

	_LIT(KMsg1,"SendNetworkServiceRequest1.1");

	TName expServiceString(KMsg1);

 	TMockLtsyData1<TName > expLtsyData(expServiceString);

    expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestApiId, data, KErrNone);

	// Send Network Service Request

	TRequestStatus sendNetworkServiceRequestStatus;

	iPhone.SendNetworkServiceRequest(sendNetworkServiceRequestStatus,expServiceString);

	ASSERT_EQUALS(KRequestPending, sendNetworkServiceRequestStatus.Int());

	// complete notify SendNetworkServiceRequest

	iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesSendNetworkServiceRequest::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestApiId, KErrNone);

	//Wait for NotifyCallForwardingActive

	User::WaitForRequest(sendNetworkServiceRequestStatus);

	ASSERT_EQUALS(KErrNone, sendNetworkServiceRequestStatus.Int());

	// prepare ltsy to accept and answer the SendNetworkServiceRequestNoFdnCheck

	_LIT(KMsg2,"SendNetworkServiceRequest1.2");

	TName expServiceStringNoFDN(KMsg2);

 	TMockLtsyData1<TName > expLtsyDataNoFDN(expServiceStringNoFDN);

 	expLtsyDataNoFDN.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId, data, KErrNone);

	// Send Network Service Request

	TRequestStatus sendNetworkServiceRequestNoFDNStatus;

	iPhone.SendNetworkServiceRequestNoFdnCheck(sendNetworkServiceRequestNoFDNStatus,expServiceStringNoFDN);

	ASSERT_EQUALS(KRequestPending, sendNetworkServiceRequestNoFDNStatus.Int());

	// complete notify SendNetworkServiceRequestNoFDNCheck

	iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheck::KLtsyDispatchSupplementaryServicesSendNetworkServiceRequestNoFdnCheckApiId, KErrNone);

	//Wait for SendNetworkServiceRequestNoFDNCheck

	User::WaitForRequest(sendNetworkServiceRequestNoFDNStatus);

	ASSERT_EQUALS(KErrNone, sendNetworkServiceRequestNoFDNStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(2, this); // data, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-UC0003

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for send a USSD request to the network

@SYMTestPriority High

@SYMTestActions Invokes RMobileUssdMessaging::ReceiveMessage, RMobileUssdMessaging::SendMessage, RMobileUssdMessaging::SendRelease

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySupplementaryServicesFU::TestUseCase0003L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);	

	RMobileUssdMessaging ussdMessaging;

	ASSERT_EQUALS(KErrNone, ussdMessaging.Open(iPhone));

	CleanupClosePushL(ussdMessaging);

	// Request CTSY to notify for USSD message

	RMobileUssdMessaging::TGsmUssdMessageData recvData;

	RMobileUssdMessaging::TMobileUssdAttributesV1 recvAttr; 

	RMobileUssdMessaging::TMobileUssdAttributesV1Pckg recvAttrPckg(recvAttr);

	TRequestStatus receiveMessageStatus;

	ussdMessaging.ReceiveMessage(receiveMessageStatus,recvData,recvAttrPckg);

	ASSERT_EQUALS(KRequestPending, receiveMessageStatus.Int());

	// prepare ltsy to accept the SendMessage

	_LIT8(KMsg1,"SendMessage1.1");

	RMobileUssdMessaging::TGsmUssdMessageData expSendData(KMsg1);

	RMobileUssdMessaging::TMobileUssdAttributesV1 expSendAttr;

	expSendAttr.iDcs = 50;

	expSendAttr.iFormat = RMobileUssdMessaging::EFormatUnspecified;

	expSendAttr.iType = RMobileUssdMessaging::EUssdMORequest;

	expSendAttr.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType | RMobileUssdMessaging::KUssdMessageDcs;

 	TMockLtsyData2<RMobileUssdMessaging::TGsmUssdMessageData, RMobileUssdMessaging::TMobileUssdAttributesV1> expLtsySendData(expSendData, expSendAttr);

 	expLtsySendData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesSendUssdMessage::KLtsyDispatchSupplementaryServicesSendUssdMessageApiId, data, KErrNone);

	// Send USSD Message

	TRequestStatus sendMessageStatus;

	RMobileUssdMessaging::TMobileUssdAttributesV1Pckg sendAttrPckg(expSendAttr);

	ussdMessaging.SendMessage(sendMessageStatus,expSendData,sendAttrPckg);

	ASSERT_EQUALS(KRequestPending, sendMessageStatus.Int());

	ASSERT_EQUALS(KRequestPending, receiveMessageStatus.Int());

	// complete SendMessage

	iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesSendUssdMessage::KLtsyDispatchSupplementaryServicesSendUssdMessageApiId, KErrNone);

	//Wait for SendMessage

	User::WaitForRequest(sendMessageStatus);

	ASSERT_EQUALS(KErrNone, sendMessageStatus.Int());

	ASSERT_EQUALS(KRequestPending, receiveMessageStatus.Int());

	// complete ReceiveMessage

	_LIT8(KMsg2,"ReceiveMessage1.2");

	TDesC8* messagePtr = const_cast<TDesC8*>(&KMsg2);

	RMobileUssdMessaging::TMobileUssdAttributesV1 compRecvAttr;

	compRecvAttr.iDcs = 16;

	compRecvAttr.iFormat = RMobileUssdMessaging::EFormatUnspecified;

	compRecvAttr.iType = RMobileUssdMessaging::EUssdMTReply;

	compRecvAttr.iFlags = RMobileUssdMessaging::KUssdDataFormat | RMobileUssdMessaging::KUssdMessageType | RMobileUssdMessaging::KUssdMessageDcs;

	TMockLtsyData2<TDesC8*, RMobileUssdMessaging::TMobileUssdAttributesV1> mockCompleteReceiveMessageData(messagePtr,compRecvAttr);

	data.Close();

	mockCompleteReceiveMessageData.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSupplementaryServicesReceiveUssdMessageIndId, KErrNone, data);

	//Wait for ReceiveMessage

	User::WaitForRequest(receiveMessageStatus);

	ASSERT_EQUALS(KErrNone, receiveMessageStatus.Int());

	ASSERT_TRUE(recvData == *messagePtr);

	ASSERT_EQUALS(recvAttr.iDcs, compRecvAttr.iDcs);

	ASSERT_EQUALS(recvAttr.iFormat, compRecvAttr.iFormat);

	ASSERT_EQUALS(recvAttr.iType, compRecvAttr.iType);

	ASSERT_EQUALS(recvAttr.iFlags, compRecvAttr.iFlags);

	// prepare ltsy to accept the SendRelease

	iMockLTSY.ExpectL(MLtsyDispatchSupplementaryServicesSendUssdRelease::KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId, KErrNone);

	// Send USSD Release

	TRequestStatus sendReleaseStatus;

	RMobilePhone::TMobilePhoneSendSSRequestV3 sendSSRequest;

	RMobilePhone::TMobilePhoneSendSSRequestV3Pckg sendSSRequestPckg(sendSSRequest);

	ussdMessaging.SendRelease(sendReleaseStatus,sendSSRequestPckg);

	ASSERT_EQUALS(KRequestPending, sendReleaseStatus.Int());

	// complete SendRelease

	RMobilePhone::TMobilePhoneSendSSRequestV3 compSendSSRequest;

	_LIT(KMsg3,"SendRelease1.3");

	compSendSSRequest.iAdditionalInfo = KMsg3;

	compSendSSRequest.iOpCode = 14;

 	TMockLtsyData1<RMobilePhone::TMobilePhoneSendSSRequestV3> expLtsySendRelease(compSendSSRequest);

	data.Close();

 	expLtsySendRelease.SerialiseL(data);

	iMockLTSY.CompleteL(MLtsyDispatchSupplementaryServicesSendUssdRelease::KLtsyDispatchSupplementaryServicesSendUssdReleaseApiId, KErrNone, data);

	//Wait for SendRelease

	User::WaitForRequest(sendReleaseStatus);

	ASSERT_EQUALS(KErrNone, sendReleaseStatus.Int());

	// CTSY defect:  defect id 380202 in the component tests. SendRelease does not propogate the return values into ETEL  

	//ASSERT_EQUALS(compSendSSRequest.iAdditionalInfo, sendSSRequest.iAdditionalInfo);

	//ASSERT_EQUALS(compSendSSRequest.iOpCode, sendSSRequest.iOpCode);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(3, this); // ussdMessaging, data, this

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SUPPLEMENTARYSERVICES-UC0004