// 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 PacketQoS in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsypacketqosfu.h"

#include <ctsy/serviceapi/cmmutility.h> // TContextMisc

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <pcktcs.h>

#include <etelqos.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

#include "Cmmpacketdef.h"

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

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddMediaAuthorizationL0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddMediaAuthorizationL0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddMediaAuthorizationL0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddMediaAuthorizationL0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestRemoveMediaAuthorization0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestRemoveMediaAuthorization0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestRemoveMediaAuthorization0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileParameters0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileParameters0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileParameters0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestNotifyProfileChanged0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestNotifyProfileChanged0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestNotifyProfileChanged0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestNotifyProfileChanged0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestSetProfileParameters0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestSetProfileParameters0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestSetProfileParameters0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestSetProfileParameters0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestSetProfileParameters0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileCapabilities0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileCapabilities0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetProfileCapabilities0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestCreateNewTFT0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddPacketFilter0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddPacketFilter0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddPacketFilter0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestAddPacketFilter0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestRemovePacketFilter0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestRemovePacketFilter0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetPacketFilterInfo0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetPacketFilterInfo0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestGetPacketFilterInfo0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestDeleteTFT0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestOpenNewQoS0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestOpenNewQoS0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestOpenExistingQoS0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestOpenExistingQoS0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyPacketQoSFU, TestOpenExistingQoS0004L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-PKTQ-PCAMA-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketContext::AddMediaAuthorizationL

@SYMTestPriority High

@SYMTestActions Invokes RPacketContext::AddMediaAuthorizationL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPacketQoSFU::TestAddMediaAuthorizationL0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RBuf8 completeData;

	CleanupClosePushL(completeData);

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	TInfoName contextName;	

	RPacketContext packetContext;

	TInt ret = packetContext.OpenNewContext(packetService, contextName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext);

	TInfoName contextName2;	

	RPacketContext packetContext2;

	ret = packetContext2.OpenNewSecondaryContext(packetService, contextName, contextName2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext2);

	TRequestStatus requestStatus;

	TRequestStatus mockLtsyStatus;

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

	// TEST A: failure to dispatch request to LTSY

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

	RPacketContext::TContextConfigGPRS contextConfig;

	TInt configurationType = 0;

	RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = NULL;

	mediaAuthorization = RPacketContext::CTFTMediaAuthorizationV3::NewL();

	CleanupStack::PushL(mediaAuthorization);

	mediaAuthorization->iAuthorizationToken = _L8("test");

	RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier flowId;

	flowId.iIPFlowNumber         = 0x100;

	flowId.iMediaComponentNumber = 0x200;

	mediaAuthorization->iFlowIds.Append(flowId);

	flowId.iIPFlowNumber         = 0x10;

	flowId.iMediaComponentNumber = 0x20;

	mediaAuthorization->iFlowIds.Append(flowId);

	TMockLtsyContextData2< TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

		expExpect(contextConfig, configurationType, contextName2, mediaAuthorization);

	expExpect.SerialiseL(data);

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data, KErrNotSupported);

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

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

	// TEST for increasing the coverage 

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

	for (TInt index = 0; index < 3; index++)

		{

		RPacketContext::CTFTMediaAuthorizationV3* media= NULL;

		media = RPacketContext::CTFTMediaAuthorizationV3::NewL();

		CleanupStack::PushL(media);

		TMockLtsyContextData2<TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

			exp(contextConfig, configurationType, contextName2, mediaAuthorization);

		data.Close();

		exp.SerialiseL(data);

	    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data, KErrNotSupported);

		packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

		User::WaitForRequest(requestStatus);

		AssertMockLtsyStatusL();

		ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

		CleanupStack::Pop(media);

		}

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

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

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

 	TMockLtsyData1<TInfoName > contexName(contextName2);

    contexName.SerialiseL(completeData);

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data);    

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrGeneral, completeData);    

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

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

	// TEST C: Successful completion request of

	// RPacketContext::AddMediaAuthorizationL when result is not cached.

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

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data);

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, completeData);

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// TEST for coverage increasing 

	// with context status != Unknown

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

	// set  context status to EStatusActive

	TInt err = SetContextActiveL(contextName2);

	AssertMockLtsyStatusL();

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

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

	// TEST for coverage increasing 

	// with context status != Unknown

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

	// set  context status to EStatusInactive 

	err = SetContextStatusL(contextName2, RPacketContext::EStatusInactive );

	// call AddMediaAuthorizationL itself

	iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data);

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, completeData);

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	CleanupStack::Pop(mediaAuthorization);

	CleanupStack::PopAndDestroy(3); // packetService1, packetContext1, packetContext2

	CleanupStack::PopAndDestroy(3); // completeData, data, this, dataSerialise

	}

/**

@SYMTestCaseID BA-CTSY-PKTQ-PCAMA-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketContext::AddMediaAuthorizationL

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RPacketContext::AddMediaAuthorizationL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPacketQoSFU::TestAddMediaAuthorizationL0002L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RBuf8 completeData;

	CleanupClosePushL(completeData);

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	TInfoName contextName;	

	RPacketContext packetContext;

	TInt ret = packetContext.OpenNewContext(packetService, contextName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext);

	TInfoName contextName2;	

	RPacketContext packetContext2;

	ret = packetContext2.OpenNewSecondaryContext(packetService, contextName, contextName2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext2);

	TRequestStatus requestStatus;

	TRequestStatus mockLtsyStatus;

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

	// Test cancelling of RPacketContext::AddMediaAuthorizationL

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

 	RPacketContext::TContextConfigGPRS contextConfig;

	TInt configurationType = 0;

	RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = NULL;

	mediaAuthorization = RPacketContext::CTFTMediaAuthorizationV3::NewL();

	CleanupStack::PushL(mediaAuthorization);

	TMockLtsyContextData2< TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

		expExpect(contextConfig, configurationType, contextName2, mediaAuthorization);

	expExpect.SerialiseL(data);

	// data CompleteL

	TMockLtsyData1<TInfoName > contexName(contextName2);

    contexName.SerialiseL(completeData);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data);

	packetContext2.AddMediaAuthorizationL(requestStatus, *mediaAuthorization);	

    packetContext2.CancelAsyncRequest(EPacketAddMediaAuthorization);

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, completeData);

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	User::WaitForRequest(mockLtsyStatus);

	CleanupStack::Pop(mediaAuthorization);

	CleanupStack::PopAndDestroy(3); // packetService1, packetContext1, packetContext2

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

	}

/**

@SYMTestCaseID BA-CTSY-PKTQ-PCAMA-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketContext::AddMediaAuthorizationL

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RPacketContext::AddMediaAuthorizationL

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPacketQoSFU::TestAddMediaAuthorizationL0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data1;

	CleanupClosePushL(data1);

	RBuf8 data2;

	CleanupClosePushL(data2);

	RBuf8 completeData1;

	CleanupClosePushL(completeData1);

	RBuf8 completeData2;

	CleanupClosePushL(completeData2);

	// Open second client

	RTelServer telServer1;

	TInt ret = telServer1.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer1);

	RTelServer telServer1S;

	ret = telServer1S.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer1S);

	RTelServer telServer2S;

	ret = telServer2S.Connect();

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(telServer2S);

	RMobilePhone phone2;

	ret = phone2.Open(iTelServer,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2);

	RMobilePhone phone1S;

	ret = phone1S.Open(iTelServer,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone1S);

	RMobilePhone phone2S;

	ret = phone2S.Open(iTelServer,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(phone2S);

	RPacketService packetService1;

	OpenPacketServiceL(packetService1);

	CleanupClosePushL(packetService1);

	RPacketService packetService2;                

	ret = packetService2.Open(phone2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetService2);

	RPacketService packetService1S;                

	ret = packetService1S.Open(phone1S);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetService1S);

	RPacketService packetService2S;                

	ret = packetService2S.Open(phone2S);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetService2S);

	TInfoName contextName1;	

	RPacketContext packetContext1;

	ret = packetContext1.OpenNewContext(packetService1, contextName1);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext1);

	TInfoName contextName2;	

	RPacketContext packetContext2;

	ret = packetContext2.OpenNewContext(packetService2, contextName2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext2);

	TInfoName contextName1S;	

	RPacketContext packetContext1S;

	ret = packetContext1S.OpenNewSecondaryContext(packetService1S, contextName1, contextName1S);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext1S);

	TInfoName contextName2S;	

	RPacketContext packetContext2S;

	ret = packetContext2S.OpenNewSecondaryContext(packetService2S, contextName2, contextName2S);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext2S);

	TRequestStatus requestStatus1;

	TRequestStatus requestStatus2;

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

	// Test A: Test multiple clients requesting RPacketContext::AddMediaAuthorizationL

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

	RPacketContext::TContextConfigGPRS contextConfig;

	TInt configurationType = 0;

	RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = NULL;

	mediaAuthorization = RPacketContext::CTFTMediaAuthorizationV3::NewL();

	CleanupStack::PushL(mediaAuthorization);

	// first client	

 	TMockLtsyData1<TInfoName > contexName1(contextName1S);

    contexName1.SerialiseL(completeData1);

	TMockLtsyContextData2<TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

		expExpect1(contextConfig, configurationType, contextName1S, mediaAuthorization);

	expExpect1.SerialiseL(data1);

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data1);

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, completeData1);

	packetContext1S.AddMediaAuthorizationL(requestStatus1, *mediaAuthorization);	

	// second client	

 	TMockLtsyData1<TInfoName > contexName2(contextName2S);

    contexName2.SerialiseL(completeData2);

	TMockLtsyContextData2<TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

		expExpect2(contextConfig, configurationType, contextName2S, mediaAuthorization);

	expExpect2.SerialiseL(data2);

    iMockLTSY.ExpectL(EPacketAddMediaAuthorization, data2);

    iMockLTSY.CompleteL(EPacketContextSetConfig, KErrNone, completeData2);

	packetContext2S.AddMediaAuthorizationL(requestStatus2, *mediaAuthorization);	

	User::WaitForRequest(requestStatus1);

	ASSERT_EQUALS(KErrNone, requestStatus1.Int());

	User::WaitForRequest(requestStatus2);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus2.Int());

	CleanupStack::Pop(mediaAuthorization);

	CleanupStack::PopAndDestroy(14);

	CleanupStack::PopAndDestroy(5, this); // data1, data2, this, completeData1, completeData2

	}

/**

@SYMTestCaseID BA-CTSY-PKTQ-PCAMA-0005

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketContext::AddMediaAuthorizationL with timeout

@SYMTestPriority High

@SYMTestActions Invokes RPacketContext::AddMediaAuthorizationL and tests for timeout

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyPacketQoSFU::TestAddMediaAuthorizationL0005L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL(data);

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	TInfoName contextName;	

	RPacketContext packetContext;

	TInt ret = packetContext.OpenNewContext(packetService, contextName);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext);

	TInfoName contextName2;	

	RPacketContext packetContext2;

	ret = packetContext2.OpenNewSecondaryContext(packetService, contextName, contextName2);

	ASSERT_EQUALS(KErrNone, ret);

	CleanupClosePushL(packetContext2);

	TRequestStatus requestStatus;

	RPacketContext::TContextConfigGPRS contextConfig;

	TInt configurationType = 0;

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

	// Test A: Test timeout of RPacketContext::AddMediaAuthorizationL

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