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

// The TEFUnit test suite for UssdMessaging in the Common TSY.

// 

//

/**

 @file

*/

#include "cctsyussdmessagingfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessage0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0001dL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0002bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0004bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendRelease0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002dL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002eL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002fL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002gL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002hL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0002iL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004bL);	

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004dL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004eL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessage0004fL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001eL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0001dL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestNotifyNetworkRelease0004bL);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestSendMessageNoFdnCheck0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestGetCaps0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestGetCaps0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0011L);

    ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0013L);

    ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0016L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestReceiveMessageWithTestClient0017L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestAcceptRejectMisuse0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestAcceptRejectMisuse0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyUssdMessagingFU, TestMultipleIncomingUssdMessages0001L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-USSDM-USM-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage

@SYMTestPriority High

@SYMTestActions Invokes RMobileUssdMessaging::SendMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyUssdMessagingFU::TestSendMessage0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileUssdMessaging ussdMessaging;

	TInt ret = ussdMessaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(ussdMessaging);

	TRequestStatus requestStatus;

	TUint32 flags = 100;

	RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;

	RMobileUssdMessaging::TMobileUssdMessageType type  = RMobileUssdMessaging::EUssdMORequest;

	TUint8 dcs = 200;

 	//-------------------------------------------------------------------------

	// function parameters

	RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

	TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

	attributes.iFlags  = flags;

	attributes.iFormat = format;

	attributes.iType   = type;

	attributes.iDcs   = dcs;

	TName name = _L("Name1");

	TPckg<TName> msgData(name);

 	//-------------------------------------------------------------------------

	TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1> 

		mockData2(name, attributes);

	mockData2.SerialiseL(data);

 	//-------------------------------------------------------------------------

	// TEST A: failure to dispatch request to LTSY

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data, KErrNotSupported);

	ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

    User::WaitForRequest(requestStatus);        

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	

	//-------------------------------------------------------------------------

	// TEST B: failure on completion of pending request from LTSY->CTSY

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);

    iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrGeneral);

	ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

    User::WaitForRequest(requestStatus);        

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());	

 	//-------------------------------------------------------------------------

	// TEST C: Successful completion request of

	// RMobileUssdMessaging::SendMessage when result is not cached.

 	//-------------------------------------------------------------------------

    iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);

    iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);

	ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

    User::WaitForRequest(requestStatus);        

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());	

 	//-------------------------------------------------------------------------

	// TEST E: Unsolicited completion of RMobileUssdMessaging::SendMessage

	// from LTSY.

 	//-------------------------------------------------------------------------

    TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

 	//-------------------------------------------------------------------------

	// TEST : to increase CMmUssdTsy::ExtFunc coverage

	// covers "if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() && 

	// ( !IsRequestPossibleInOffline( aIpc ) ) )" condition

 	//-------------------------------------------------------------------------

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	TRfStateInfo rfInfo = ERfsStateInfoInactive;

	TMockLtsyData1<TRfStateInfo> mockData1(rfInfo);

	data.Close();

	mockData1.SerialiseL(data);

	iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, data);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

	User::WaitForRequest(requestStatus);        

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrGsmOfflineOpNotAllowed, requestStatus.Int());	

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

	}

/**

@SYMTestCaseID BA-CTSY-USSDM-USM-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RMobileUssdMessaging::SendMessage

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RMobileUssdMessaging::SendMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyUssdMessagingFU::TestSendMessage0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus mockLtsyStatus;

	TRequestStatus requestStatus;

	RMobileUssdMessaging ussdMessaging;

	TInt ret = ussdMessaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(ussdMessaging);

	TUint32 flags = 100;

	RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;

	RMobileUssdMessaging::TMobileUssdMessageType type  = RMobileUssdMessaging::EUssdMORequest;

	TUint8 dcs = 200;

 	//-------------------------------------------------------------------------

	// function parameters

	RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

	TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

	attributes.iFlags  = flags;

	attributes.iFormat = format;

	attributes.iType   = type;

	attributes.iDcs   = dcs;

	TName name = _L("Name1");

	TPckg<TName> msgData(name);

 	//-------------------------------------------------------------------------

	TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1> 

		mockData2(name, attributes);

 	//-------------------------------------------------------------------------

	// Test cancelling of RMobileUssdMessaging::SendMessage

 	//-------------------------------------------------------------------------

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	mockData2.SerialiseL(data);

    iMockLTSY.ExpectL(EMobileUssdMessagingSendMessage, data);

    iMockLTSY.CompleteL(EMobileUssdMessagingSendMessage, KErrNone, 10);

	ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

    ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingSendMessage);

	User::WaitForRequest(mockLtsyStatus);

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);

    ASSERT_EQUALS(KErrCancel, requestStatus.Int());

    AssertMockLtsyStatusL();

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

	}

/**

@SYMTestCaseID BA-CTSY-USSDM-USM-0003

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::SendMessage with bad parameter data

@SYMTestPriority High

@SYMTestActions Invokes RMobileUssdMessaging::SendMessage with bad parameter data

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyUssdMessagingFU::TestSendMessage0003L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RMobileUssdMessaging ussdMessaging;

	TInt ret = ussdMessaging.Open(iPhone);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(ussdMessaging);

	TRequestStatus requestStatus;

 	//-------------------------------------------------------------------------

	// function parameter

	TName name = _L("Name1");

	TPckg<TName> msgData(name);

	//-------------------------------------------------------------------------

	// Test B: Test passing wrong descriptor size to parameter in

	// RMobileUssdMessaging::SendMessage

 	//-------------------------------------------------------------------------

	TBuf8<1> badSizeDescriptor;

	ussdMessaging.SendMessage(requestStatus, msgData, badSizeDescriptor);

	User::WaitForRequest(requestStatus);        

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrArgument, requestStatus.Int());	

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

	}

/**

@SYMTestCaseID BA-CTSY-USSDM-USM-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RMobileUssdMessaging::SendMessage

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RMobileUssdMessaging::SendMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyUssdMessagingFU::TestSendMessage0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	// Open second client

	RTelServer telServer2;

	TInt ret = telServer2.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer2);

	RMobilePhone phone2;

	ret = phone2.Open(telServer2,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2);

	RMobileUssdMessaging ussdMessaging1;

	ret = ussdMessaging1.Open(iPhone);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(ussdMessaging1);

	RMobileUssdMessaging ussdMessaging2;

	ret = ussdMessaging2.Open(phone2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(ussdMessaging2);

	TRequestStatus requestStatus1;

	TRequestStatus requestStatus2;

	TUint32 flags = 100;

	RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;

	RMobileUssdMessaging::TMobileUssdMessageType type  = RMobileUssdMessaging::EUssdMORequest;

	TUint8 dcs = 200;

 	//-------------------------------------------------------------------------

	// parameters for first function

	RMobileUssdMessaging::TMobileUssdAttributesV1 attributes1;

	TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes1(attributes1);

	attributes1.iFlags  = flags;

	attributes1.iFormat = format;

	attributes1.iType   = type;

	attributes1.iDcs    = dcs;

	TName name1 = _L("Name1");

	TPckg<TName> msgData1(name1);

 	//-------------------------------------------------------------------------

	// parameters for second function

	RMobileUssdMessaging::TMobileUssdAttributesV1 attributes2;

	TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes2(attributes2);

	flags  = 10;

	format = RMobileUssdMessaging::EFormatPackedString;

	type   = RMobileUssdMessaging::EUssdMOAcknowledgement;

	dcs    = 20;

	attributes2.iFlags  = flags;

	attributes2.iFormat = format;

	attributes2.iType   = type;

	attributes2.iDcs    = dcs;

	TName name2 = _L("Name2");

	TPckg<TName> msgData2(name2);

 	//-------------------------------------------------------------------------

	TMockLtsyData2<TName, RMobileUssdMessaging::TMobileUssdAttributesV1> 

		mockData2(name1, attributes1);

	mockData2.SerialiseL(data);

	RBuf8 data3;

	CleanupClosePushL(data3);

	RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

	    TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

	RMobileUssdMessaging::TGsmUssdMessageData name;

	//-------------------------------------------------------------------------

	RMobileUssdMessaging::TMobileUssdAttributesV1 completeAttributes;

	completeAttributes.iFlags  = flags;

	completeAttributes.iFormat = format;

	completeAttributes.iType   = type;

	completeAttributes.iDcs    = dcs;

	TBuf8<KMaxName> completeName = _L8("Name1");

	TMockLtsyData2<TBuf8<KMaxName>, RMobileUssdMessaging::TMobileUssdAttributesV1> 

		mockData3(completeName, completeAttributes);

	mockData3.SerialiseL(data3);

	//-------------------------------------------------------------------------

	// Test A: Test multiple clients requesting RMobileUssdMessaging::SendMessage

 	//-------------------------------------------------------------------------

	iMockLTSY.CompleteL(EMobileUssdMessagingReceiveMessage, KErrNone, data3);

	ussdMessaging1.ReceiveMessage(requestStatus1, name, msgAttributes);   

	User::WaitForRequest(requestStatus1);        

	ret = requestStatus1.Int();

	ASSERT_EQUALS(KErrNone, ret);

	ussdMessaging1.AcceptIncomingDialogue();