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

*/

#include "cctsymbmscontextfu.h"

#include "cctsyactiveretriever.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>

#include <pcktcs.h>

#include <pcktlist.h>

#include "pcktretrieve.h"

#include "CMmCommonStaticUtility.h"

#include <ctsy/serviceapi/mmtsy_defaults.h>

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

	{

	SUB_SUITE;

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestOpenNewContext0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestInitialiseContext0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestSetConfig0005L);             

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestActivate0005L);                

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0004L);  

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDeactivate0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0004L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestDelete0005L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestClose0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0001L);    

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0002L); 

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetConfig0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetStatus0001L);    

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestGetLastErrorCause0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0003L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyConfigChanged0004L);    

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0001L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0002L);

    ADD_TEST_STEP_ISO_CPP(CCTsyMbmsContextFU, TestNotifyStatusChange0003L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-MCF-PONC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::OpenNewContext

@SYMTestPriority High

@SYMTestActions Invokes RPacketMbmsContext::OpenNewContext

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestOpenNewContext0001L()

    {

    OpenEtelServerL( EUseExtendedError );

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

	OpenPhoneL();	

	RPacketService packetService;

	OpenPacketServiceL( packetService );

    CleanupClosePushL( packetService );

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

    // TEST create

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

	TInfoName contextId;

    RPacketMbmsContext packetMbmsContext;

    TInt retCode;

    // memory leak check

	__UHEAP_MARK;

    retCode = packetMbmsContext.OpenNewContext(packetService, contextId);

    ASSERT_EQUALS(KErrNone, retCode);

    _LIT(KContextName, "MBMS_Context_0");

    ASSERT_FALSE(contextId.Compare(KContextName));

    packetMbmsContext.Close();

    __UHEAP_MARKEND;

    // end memory leak check

    // test maximum number of contexts allowed

    TInt count(0);

    TInt maxAllowed(0);

    TRequestStatus requestStatus;

    packetService.EnumerateMbmsActiveServiceList(requestStatus, count, maxAllowed); 

    User::WaitForRequest( requestStatus );

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

    TInt err = 0;  

    TInt status = 0;

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

        {

   		RPacketMbmsContext newPacketMbmsContext;

   		TInfoName contextId;

   		err = newPacketMbmsContext.OpenNewContext(packetService, contextId);

   		ASSERT_EQUALS(KErrNone, err);

   		CleanupClosePushL(newPacketMbmsContext); 			

   		// check the context can be initialised 

   		status = InitMbmsContextL(newPacketMbmsContext, contextId);            

   	    ASSERT_EQUALS(KErrNone, status);	

   	    CleanupStack::Pop();

    	}

    RPacketMbmsContext OneMorePacketContext;

 	TInfoName contextId1;

 	err = OneMorePacketContext.OpenNewContext(packetService, contextId1);

    ASSERT_EQUALS(KErrOverflow, err); 

	OneMorePacketContext.Close();

	packetService.Close();

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

    }

/**

@SYMTestCaseID BA-CTSY-MCF-PIC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext

@SYMTestPriority High

@SYMTestActions Invokes RPacketMbmsContext::InitialiseContext

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestInitialiseContext0001L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	// Open new context

	TInfoName contextId;	

	RPacketMbmsContext packetContext;

	packetContext.OpenNewContext(packetService, contextId);

	CleanupClosePushL(packetContext);	

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

	// TEST A: failure to dispatch request to LTSY

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

	RBuf8 expectData;

	CleanupClosePushL(expectData);

	TMockLtsyData1<TInfoName> ltsyExpect(contextId);

	ltsyExpect.SerialiseL(expectData);

 	// data for initialisation of the context 

	TRequestStatus requestStatus;

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData, KErrNotSupported);

	//initialisation of the context

	RPacketContext::TDataChannelV2 dataCh;

	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);

    packetContext.InitialiseContext(requestStatus, pckgInit);

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());	

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

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

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

 	RPacketContext::TDataChannelV2 retDataCh;

 	_LIT(KDataChannelName, "DataChannel_1");

 	retDataCh.iChannelId.Copy(KDataChannelName);

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData);

	RBuf8 data;

	CleanupClosePushL(data);

	TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData(contextId,retDataCh);

	data.Close();

	ltsyData.SerialiseL(data);	

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrGeneral, data);

	//initialisation of the context

	packetContext.InitialiseContext(requestStatus, pckgInit);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrGeneral, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// TEST C: Successful completion request of

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

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

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data);

	//initialisation of the context

	packetContext.InitialiseContext(requestStatus, pckgInit);

	User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	RPacketContext::TDataChannelV2 dataChannel = pckgInit();

	// check this

	ASSERT_TRUE(contextId.Compare(KDataChannelName));

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

	// TEST E: Unsolicited completion of RPacketContext::InitialiseContext

	// from LTSY.

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

	TRequestStatus mockLtsyStatus;	

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data);

	User::WaitForRequest(mockLtsyStatus);

	ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, this); // expectData, data, this, packetService, packetContext	

	}  

/**

@SYMTestCaseID BA-CTSY-MCF-PIC-0002

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for cancelling of RPacketMbmsContext::InitialiseContext

@SYMTestPriority High

@SYMTestActions Invokes cancelling of RPacketMbmsContext::InitialiseContext

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestInitialiseContext0002L()

    {

    OpenEtelServerL( EUseExtendedError );

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

	OpenPhoneL();

	RPacketService packetService;

    OpenPacketServiceL( packetService );

    CleanupClosePushL( packetService );        

	TInfoName contextId;

    RPacketMbmsContext packetMbmsContext;

    packetMbmsContext.OpenNewContext( packetService, contextId );

    CleanupClosePushL( packetMbmsContext );

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);    

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

	// TEST C: Successful completion request of

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

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

	// data for initialisation of the context 

	TRequestStatus requestStatus;

	RPacketContext::TDataChannelV2 dataCh;

	TPckg<RPacketContext::TDataChannelV2> pckgInit(dataCh);

	RBuf8 data;

	CleanupClosePushL( data );

	TMockLtsyData1< TInfoName> ltsyInit(contextId);

	ltsyInit.SerialiseL(data);	

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, data);

	RBuf8 expectData;

	CleanupClosePushL( expectData );	

	RPacketContext::TDataChannelV2 retDataCh;

	TMockLtsyData2< TInfoName, RPacketContext::TDataChannelV2 > ltsyData(contextId, retDataCh);

	data.Close();

	ltsyData.SerialiseL(data);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data, 10);

	// initialisation of the context

	packetMbmsContext.InitialiseContext(requestStatus, pckgInit);

    // cancel request

	packetMbmsContext.CancelAsyncRequest(EPacketContextInitialiseContext);

	User::WaitForRequest(requestStatus);	

	// CTSY has started a request and it is not possible to then cancel 

    // this request. The best thing for the TSY to do in this case is to

    // proceed as though the Cancel never happened.

	ASSERT_EQUALS(KErrNone, requestStatus.Int());	 	

	// Wait for completion of iMockLTSY.NotifyTerminated

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(2); // packetContext, packetService

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

    }    

/**

@SYMTestCaseID BA-CTSY-MCF-PIC-0003

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext with bad parameter data

@SYMTestPriority High

@SYMTestActions Invokes RPacketMbmsContext::InitialiseContext with bad parameter data

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestInitialiseContext0003L()

	{

	OpenEtelServerL( EUseExtendedError );

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

	OpenPhoneL();

	RBuf8 data;

	CleanupClosePushL( data );

	RBuf8 expectData;

	CleanupClosePushL( expectData );

	RPacketService packetService;

	OpenPacketServiceL( packetService );

	CleanupClosePushL( packetService );

	// Open new context

	TInfoName contextId;	

	RPacketMbmsContext packetMbmsContext;

	packetMbmsContext.OpenNewContext( packetService, contextId );

	CleanupClosePushL( packetMbmsContext );

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

	// Test A: Test passing wrong version of parameters to

	// RPacketMbmsContext::InitialiseContext

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

	// data for initialisation of the context 

	TRequestStatus requestStatus;

	RCall::TCommPort dataCh; // wrong type of data package

	TPckg<RCall::TCommPort> pckgInit( dataCh );

	//initialisation of the context

	packetMbmsContext.InitialiseContext( requestStatus, pckgInit );	

	User::WaitForRequest( requestStatus );	

	ASSERT_EQUALS( KErrArgument, requestStatus.Int() );

	AssertMockLtsyStatusL();	 	

	CleanupStack::PopAndDestroy( 2 ); // packetMbmsContext, packetService

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

	}   

/**

@SYMTestCaseID BA-CTSY-MCF-PIC-0004

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for multiple client requests to RPacketMbmsContext::InitialiseContext

@SYMTestPriority High

@SYMTestActions Invokes multiple client requests to RPacketMbmsContext::InitialiseContext

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestInitialiseContext0004L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	// Open new context

	TInfoName contextId;	

	RPacketMbmsContext packetContext;

	packetContext.OpenNewContext(packetService, contextId);

	CleanupClosePushL(packetContext);

	// Open second context

	TInfoName contextId2;	

	RPacketMbmsContext packetContext2;

	packetContext2.OpenNewContext(packetService, contextId2);

	CleanupClosePushL(packetContext2);

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

	// Test A: Test multiple clients requesting RPacketMbmsContext::InitialiseContext

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

	// for the first request

	RBuf8 expectData;

	CleanupClosePushL(expectData);

    TMockLtsyData1<TInfoName> ltsyExpect(contextId);

	ltsyExpect.SerialiseL(expectData);

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData);	

	RBuf8 data;

	CleanupClosePushL(data);

	RPacketContext::TDataChannelV2 dataCh;

	TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData(contextId, dataCh);

	ltsyData.SerialiseL(data);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data);	

	// for the first request

	RBuf8 expectData2;

	CleanupClosePushL(expectData2);

	TMockLtsyData1<TInfoName> ltsyExpect2(contextId2);

	ltsyExpect2.SerialiseL(expectData2);

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData2);	

	RBuf8 data2;

	CleanupClosePushL(data2);

	RPacketContext::TDataChannelV2 dataCh2;

	TMockLtsyData2<TInfoName, RPacketContext::TDataChannelV2> ltsyData2(contextId2, dataCh2);

	ltsyData2.SerialiseL(data2);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data2);	

	//first request

	TRequestStatus requestStatus;

	RPacketContext::TDataChannelV2 dataChannel1;

	TPckg<RPacketContext::TDataChannelV2> pckgInit1(dataChannel1);	

    packetContext.InitialiseContext(requestStatus, pckgInit1);

	//second request

	TRequestStatus requestStatus2;

	RPacketContext::TDataChannelV2 dataChannel2;

	TPckg<RPacketContext::TDataChannelV2> pckgInit2(dataChannel2);	

    packetContext2.InitialiseContext(requestStatus2, pckgInit2);	

    User::WaitForRequest(requestStatus);		

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	User::WaitForRequest(requestStatus2);		

	ASSERT_EQUALS(KErrNone, requestStatus2.Int());	

	AssertMockLtsyStatusL();	 	

	CleanupStack::PopAndDestroy(8, this); //packetContext2, packetContext, packetService, expectData, expectData2, data, data2, this

	}   

/**

@SYMTestCaseID BA-CTSY-MCF-PIC-0005

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RPacketMbmsContext::InitialiseContext with timeout

@SYMTestPriority High

@SYMTestActions Invokes RPacketMbmsContext::InitialiseContext and tests for timeout

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyMbmsContextFU::TestInitialiseContext0005L()

	{

	OpenEtelServerL(EUseExtendedError);

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

	OpenPhoneL();

	RPacketService packetService;

	OpenPacketServiceL(packetService);

	CleanupClosePushL(packetService);

	// Open new context

	TInfoName contextId;

	RPacketMbmsContext packetMbmsContext;

	packetMbmsContext.OpenNewContext(packetService, contextId);

	CleanupClosePushL(packetMbmsContext);

	RBuf8 expectData;

	CleanupClosePushL(expectData);

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

	// Test A: Test timeout of RPacketContext::InitialiseContext

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

    TMockLtsyData1<TInfoName> ltsyExpect(contextId);

	ltsyExpect.SerialiseL(expectData);

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, expectData);