// 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:
// EtelPacketMbmsContext.cpp
// This contains EtelPacket TestCase 
// 
//

// Symbian OS includes
#include <e32base.h>
#include <etelpckt.h>
#include "pcktretrieve.h"
#include <pcktcs.h>
#include "Te_EtelPacketTestStepBase.h"
#include "testdef.h"
#include "Te_EtelPacketMbmsContext.h"
#include "Te_etelpckt_defs.h"

// constructor
CTestMbmsContext::CTestMbmsContext()
	{
	// store the name of this test case
	SetTestStepName(_L("MBMS_CONTEXT"));
	}

// destructor
CTestMbmsContext::~CTestMbmsContext()
{
}

TVerdict CTestMbmsContext::doTestStepPreambleL()
	{
	CTestStepEtelPacket::doTestStepPreambleL();
	TInt ret=iPhone.Open(iTelServer,DPCKTTSY_PHONE_NAME);
	if(ret != KErrNone)
		{
		INFO_PRINTF1(_L("Failed to open phone"));
		User::Leave(ret);
		}
	ret=iPcktService.Open(iPhone);
	if(ret != KErrNone)
		{
		INFO_PRINTF1(_L("Failed to open packet service"));
		User::Leave(ret);
		}
	iTestScheduler=new (ELeave) CActiveScheduler;
	CActiveScheduler::Install(iTestScheduler);
	return TestStepResult();
	}
	
TVerdict CTestMbmsContext::doTestStepPostambleL()
	{
	delete iTestScheduler;
	iPcktService.Close();
	iPhone.Close();
	CTestStepEtelPacket::doTestStepPostambleL();
	return TestStepResult();
	}
	
enum TVerdict CTestMbmsContext::doTestStepL( void )
/**
 * Test step to check MBMS service availability functionality
 */
	{
	TestOpenMbmsContextL();
	TestInitialiseMbmsContextL();
	TestMbmsConfigurationL();
	TestActivateMbmsContextL();
	TestMbmsServiceStatusL();
	TestMbmsUpdateSessionL();
	TestMbmsGetSessionListL();
	TestDeactivateMbmsContextL();
	return TestStepResult();
	}

void CTestMbmsContext::TestOpenMbmsContextL()
	{
	/*
	 * Verify whether a MBMS context is opened successfully.
	 */
	TInt retMbmsContext;
	TName contextName;
	
	retMbmsContext = iMbmsContext.OpenNewContext(iPcktService, contextName);
	if(retMbmsContext != KErrNone)
		{
		INFO_PRINTF1(_L("Failed to open packet context"));
		User::Leave(retMbmsContext);
		}
	INFO_PRINTF1(_L("Open a MBMS context - Completed"));
	}

void CTestMbmsContext::TestMbmsConfigurationL()
	{
	/**
	 * Set the MBMS context configuration successfully
	 */
	TRequestStatus mbmsConfigStatus;
	RPacketMbmsContext::TContextConfigMbmsV1 mbmsContextConfig;
	mbmsContextConfig.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_ONE);
	mbmsContextConfig.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_ONE);
	mbmsContextConfig.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_ONE);
	mbmsContextConfig.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_ONE;
	mbmsContextConfig.iMbmsServicePriority = DPCKTTSY_MBMS_SERVICEPRIORITY_ONE;
	mbmsContextConfig.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_ONE;
	mbmsContextConfig.iMbmsSessionFlag = DPCKTTSY_MBMS_SESSION_FLAG_TRUE;
	RPacketMbmsContext::TContextConfigMbmsV1Pckg iMbmsContextConfigPckg(mbmsContextConfig);
	
	iMbmsContext.SetConfig(mbmsConfigStatus, iMbmsContextConfigPckg);
	User::WaitForRequest(mbmsConfigStatus);
	TESTL(mbmsConfigStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS context set configurations - Completed"));
	
	/**
	 * Set the MBMS context configuration successfully
	 */
	TRequestStatus mbmsConfigStatusCancel;
	iMbmsContext.SetConfig(mbmsConfigStatusCancel, iMbmsContextConfigPckg);
	iMbmsContext.CancelAsyncRequest(EPacketContextSetConfig);
	User::WaitForRequest(mbmsConfigStatusCancel);
	TESTL(mbmsConfigStatusCancel == KErrCancel);
	INFO_PRINTF1(_L("Cancel MBMS context set configurations - CANCELLED"));
		
	/**
	 * Set MBMS context configuration with invalid inputs
	 */
	mbmsContextConfig.iTmgi.SetMCC(DPCKTTSY_MBMS_MCC_INVALID);
	mbmsContextConfig.iTmgi.SetMNC(DPCKTTSY_MBMS_MNC_INVALID);
	mbmsContextConfig.iTmgi.SetServiceId(DPCKTTSY_MBMS_SERVICEID_INVALID);
	mbmsContextConfig.iMbmsAccessBearer = DPCKTTSY_MBMS_ACCESSBEARER_INVALID;
	mbmsContextConfig.iMbmsSessionFlag = DPCKTTSY_MBMS_SESSION_FLAG_TRUE;
	mbmsContextConfig.iMbmsServiceMode = DPCKTTSY_MBMS_SERVICEMODE_INVALID;
	
	iMbmsContext.SetConfig(mbmsConfigStatus, iMbmsContextConfigPckg);
	User::WaitForRequest(mbmsConfigStatus);
	TESTL(mbmsConfigStatus == KErrCorrupt);
	INFO_PRINTF1(_L("MBMS set context invalid configurations - Completed"));
	
	/**
	 * Get MBMS context configuration.
	 */
	RPacketMbmsContext::TContextConfigMbmsV1 mbmsGetContextConfig;
	RPacketMbmsContext::TContextConfigMbmsV1Pckg mbmsGetContextConfigPckg(mbmsGetContextConfig);
	iMbmsContext.GetConfig(mbmsConfigStatus, mbmsGetContextConfigPckg);
	User::WaitForRequest(mbmsConfigStatus);
	mbmsGetContextConfig = mbmsGetContextConfigPckg();
	TESTL(mbmsGetContextConfig.iTmgi.GetMCC() == DPCKTTSY_MBMS_MCC_ONE);
	TESTL(mbmsGetContextConfig.iTmgi.GetMNC() == DPCKTTSY_MBMS_MNC_ONE);
	TESTL(mbmsGetContextConfig.iTmgi.GetServiceId() == DPCKTTSY_MBMS_SERVICEID_ONE);
	TESTL(mbmsGetContextConfig.iMbmsAccessBearer == DPCKTTSY_MBMS_ACCESSBEARER_ONE);
	TESTL(mbmsGetContextConfig.iMbmsServicePriority == DPCKTTSY_MBMS_SERVICEPRIORITY_ONE);
	TESTL(mbmsGetContextConfig.iMbmsServiceMode == DPCKTTSY_MBMS_SERVICEMODE_ONE);
	TESTL(mbmsGetContextConfig.iMbmsSessionFlag = DPCKTTSY_MBMS_SESSION_FLAG_TRUE);
	TESTL(mbmsConfigStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS get context configurations - Completed"));	
	}

void CTestMbmsContext::TestActivateMbmsContextL()
	{
	/**
	 * Activate MBMS context.
	 */
	TRequestStatus activateStatus;
	iMbmsContext.Activate(activateStatus);
	User::WaitForRequest(activateStatus);
	TESTL(activateStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS context activation - Completed"));
	}
	
void CTestMbmsContext::TestMbmsServiceStatusL()
	{
	/**
	 * Verify the status of the service being received
	 */
	TRequestStatus activateStatus;
	RPacketMbmsContext::TContextStatus contextStatus;
	iMbmsContext.NotifyStatusChange(activateStatus,contextStatus);
	User::WaitForRequest(activateStatus);
	TESTL(contextStatus == DPCKTTSY_CONTEXT_STATUS2);
	TESTL(activateStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS context status notification - Completed"));
	
	/**
	 * Receive notification on status change of a MBMS service
	 */
	TInt retStatus = iMbmsContext.GetStatus(contextStatus);
	TESTL(contextStatus == DPCKTTSY_CONTEXT_STATUS1);
	TESTL(retStatus == KErrNone);
	INFO_PRINTF1(_L("Get MBMS context status - Completed"));
	
	/**
	 * Cancel MBMS status notification on status change.
	 */
	iMbmsContext.NotifyStatusChange(activateStatus,contextStatus);
	iMbmsContext.CancelAsyncRequest(EPacketContextNotifyStatusChange);
	User::WaitForRequest(activateStatus);
	TESTL( activateStatus == KErrCancel);
	INFO_PRINTF1(_L("MBMS context status notification cancellation - CANCELLED"));
	}
	
void CTestMbmsContext::TestMbmsUpdateSessionL()
	{
	/**
	 * Add MBMS session
	 */
	TRequestStatus sessionStatus;
	TUint sessionId = DPCKTTSY_MBMS_SESSIONID_ONE;
	iMbmsContext.UpdateMbmsSessionList(sessionStatus, EAddEntries, sessionId);
	User::WaitForRequest(sessionStatus);
	TESTL(sessionStatus == KErrNone);
	INFO_PRINTF1(_L("Add MBMS session - Completed"));

	/**
	 * Test cancelling the UpdateMbmsSessionList API
	 */
	TRequestStatus sessionStatusCancel;
	sessionId = DPCKTTSY_MBMS_SESSIONID_ONE;
	iMbmsContext.UpdateMbmsSessionList(sessionStatusCancel, EAddEntries, sessionId);
	iMbmsContext.CancelAsyncRequest(EPacketContextUpdateMbmsSessionList);
	User::WaitForRequest(sessionStatusCancel);
	TESTL(sessionStatusCancel == KErrCancel);
	INFO_PRINTF1(_L("Cancel UpdateMbmsSessionList - CANCELLED"));
	
	/**
	 * Remove MBMS session
	 */
	iMbmsContext.UpdateMbmsSessionList(sessionStatus, ERemoveEntries, sessionId);
	User::WaitForRequest(sessionStatus);
	TESTL(sessionStatus == KErrNone);
	INFO_PRINTF1(_L("Remove MBMS session - Completed"));
	
	/**
	 * Remove an invalid MBMS session
	 */
	sessionId = DPCKTTSY_MBMS_SESSIONID_INVALID;
	iMbmsContext.UpdateMbmsSessionList(sessionStatus, ERemoveEntries, sessionId);
	User::WaitForRequest(sessionStatus);
	TESTL(sessionStatus == KErrNotFound);
	INFO_PRINTF1(_L("Remove invalid MBMS session - Completed"));
	
	/**
	 * Remove all MBMS sessions
	 */
	iMbmsContext.UpdateMbmsSessionList(sessionStatus, ERemoveAllEntries);
	User::WaitForRequest(sessionStatus);
	TESTL(sessionStatus == KErrNone);
	INFO_PRINTF1(_L("Remove all MBMS sessions - Completed"));
	
	/**
	 * Remove all MBMS sessions completes with error.
	 */
	sessionId = DPCKTTSY_MBMS_SESSIONID_ONE;
	iMbmsContext.UpdateMbmsSessionList(sessionStatus, ERemoveAllEntries, sessionId);
	User::WaitForRequest(sessionStatus);
	TESTL(sessionStatus == KErrMbmsImpreciseServiceEntries);
	INFO_PRINTF1(_L("Failure scenario - Remove all MBMS sessions - Completed"));
	}

void CTestMbmsContext::TestDeactivateMbmsContextL()
	{
	/**
	 * Deactivate a MBMS context.
	 */
	TRequestStatus mbmsDeactivateStatus;
	iMbmsContext.Deactivate(mbmsDeactivateStatus);
	User::WaitForRequest(mbmsDeactivateStatus);
	TESTL(mbmsDeactivateStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS context deactivation - Completed"));
	
	/**
	 * Delete the context
	 */
	TRequestStatus mbmsDeleteStatus;
	iMbmsContext.Delete(mbmsDeleteStatus);
	User::WaitForRequest(mbmsDeleteStatus);
	TESTL(mbmsDeleteStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS context deleted - Completed"));
	
	/**
	 * Close the context
	 */
	iMbmsContext.Close();
	}

void CTestMbmsContext::TestInitialiseMbmsContextL()
	{
	/**
	 * Initialise MBMS context.
	 */
	RPacketMbmsContext::TDataChannelV2 dataChannel;
	RPacketMbmsContext::TDataChannelV2Pckg dataChannelPckg(dataChannel);
	TRequestStatus mbmsInitContextStatus;
	iMbmsContext.InitialiseContext(mbmsInitContextStatus, dataChannelPckg);
	User::WaitForRequest(mbmsInitContextStatus);
	TESTL(dataChannel.iCsy == DPCKTTSY_CSY_ASYNC);
	TESTL(dataChannel.iPort == DPCKTTSY_PORT_ASYNC);
	TESTL(dataChannel.iChannelId == DPCKTTSY_CHANNEL_ID);
	TESTL(mbmsInitContextStatus == KErrNone);
	INFO_PRINTF1(_L("MBMS Initialise context - Completed"));
	}

void CTestMbmsContext::TestMbmsGetSessionListL()
	{
	__UHEAP_MARK;
	TInt ret(KErrNone);
	TRequestStatus reqStatus;
	TUint sessionId1=1000, sessionId2=2000, sessionId3=3000;
	
	/**
	 * Test serialization
	 */
	RPacketMbmsContext::CMbmsSession* mbmsSession = RPacketMbmsContext::CMbmsSession::NewL();
	CleanupStack::PushL(mbmsSession);
	TESTL(mbmsSession->ExtensionId() == KETelExtPcktV1);
	mbmsSession->iSessionIdList.Append(sessionId1);
	mbmsSession->iSessionIdList.Append(sessionId2);
	mbmsSession->iSessionIdList.Append(sessionId3);
	HBufC8* buff  = HBufC8::NewL(15);
	mbmsSession->ExternalizeL(buff);	
	CleanupStack::PushL(buff);
	RPacketMbmsContext::CMbmsSession* mbmsSessionCopy = RPacketMbmsContext::CMbmsSession::NewL();
	CleanupStack::PushL(mbmsSessionCopy);
	
	TBuf8<256> buffBig;
	buffBig=*buff;

	/**
	 * Memory overflow test for Internalize function
	 */
	TInt err=KErrNone;
	TInt len=0;
	do
		{
		buffBig.SetLength(len);
		TRAP(err, mbmsSessionCopy->InternalizeL(buffBig));
		if(err == KErrOverflow)
			{
			len++;	
			}
		else
			{
			TESTL(err == KErrNone);
			break;
			}		
		}
	while(len < 100); //just in case, set a limit to finish the loop.
	TESTL(len<100);
	TRAP(ret,mbmsSessionCopy->InternalizeL(buffBig));
	TEST(ret==KErrNone);
	TESTL(mbmsSessionCopy->iSessionIdList.Count() == mbmsSession->iSessionIdList.Count());
	TESTL(mbmsSessionCopy->iSessionIdList[0] == mbmsSession->iSessionIdList[0]);
	TESTL(mbmsSessionCopy->iSessionIdList[1] == mbmsSession->iSessionIdList[1]);
	TESTL(mbmsSessionCopy->iSessionIdList[2] == mbmsSession->iSessionIdList[2]);
	CleanupStack::PopAndDestroy(mbmsSessionCopy);
	CleanupStack::PopAndDestroy(buff);
	CleanupStack::PopAndDestroy(mbmsSession);
	INFO_PRINTF1(_L("Test serialization of sessions - Completed"));
	INFO_PRINTF1(_L("OOM test for Internalize API - Completed"));
	
	/**
	 * Retrieve a list of session ids of a MBMS service
	 */
	RPacketMbmsContext::CMbmsSession* mbmsSession1 = RPacketMbmsContext::CMbmsSession::NewL();
	CleanupStack::PushL(mbmsSession1);
	CTestMbmsSession* testMbmsSession = CTestMbmsSession::NewLC(iMbmsContext,*mbmsSession1, this);
	testMbmsSession->Start();
	CActiveScheduler::Start();
	TEST(testMbmsSession->iRetrieve != NULL);
	if(testMbmsSession->iRetrieve )
		{
		TESTL(mbmsSession1->iSessionIdList.Count() == DPCKTTSY_MBMS_CONTEXT_SESSION_ID_COUNT);
		TESTL(mbmsSession1->iSessionIdList[0] == DPCKTTSY_MBMS_CONTEXT_SESSION_ID_ONE);
		TESTL(mbmsSession1->iSessionIdList[1] == DPCKTTSY_MBMS_CONTEXT_SESSION_ID_TWO);
		TESTL(mbmsSession1->iSessionIdList[2] == DPCKTTSY_MBMS_CONTEXT_SESSION_ID_THREE);
		}
	INFO_PRINTF1(_L("Retrieve a list of sessions IDs of a MBMS service - Completed"));
    
	/**
     * Test cancellation of retrieval of sessions
     */	
    testMbmsSession->Start();	
    testMbmsSession->iCanceller->Call();
    CActiveScheduler::Start();
    INFO_PRINTF1(_L("Cancel retrieval of MBMS sessions - Completed"));
    
	CleanupStack::PopAndDestroy(testMbmsSession);
	CleanupStack::PopAndDestroy(mbmsSession1);
	iPcktService.Close();
	iPhone.Close();
	__UHEAP_MARKEND;
	}
//
CTestMbmsSession* CTestMbmsSession::NewLC(RPacketMbmsContext& aPcktMbmsContext,RPacketMbmsContext::CMbmsSession& aSessionIdList, CTestMbmsContext* aTestMbmsContext)
	{
    CTestMbmsSession* self = new(ELeave) CTestMbmsSession(aPcktMbmsContext, aSessionIdList, aTestMbmsContext);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CTestMbmsSession::CTestMbmsSession(RPacketMbmsContext& aPcktMbmsContext, RPacketMbmsContext::CMbmsSession& aSessionIdList, CTestMbmsContext* aTestMbmsContext)
    : CActive(EPriorityHigh), iSessionIdList(aSessionIdList), iPcktMbmsContext(aPcktMbmsContext), iTestMbmsContext(aTestMbmsContext)
    {
    }

TInt CTestMbmsSession::RunError(TInt /*aError*/)
	{
	return KErrNone;
	}

void CTestMbmsSession::ConstructL()
	{
    CActiveScheduler::Add(this);
	iRetrieve=CRetrievePcktMbmsSessionList::NewL(iPcktMbmsContext, iSessionIdList);
	iCanceller=new (ELeave) CTestCanceller(this);
    }

CTestMbmsSession::~CTestMbmsSession()
    {
    delete iCanceller;
	delete iRetrieve;
	}

void CTestMbmsSession::Start()
    {
    iRetrieve->Start(iStatus);
    //Test the CompleteIfInUse case of Start API
    TRequestStatus tmpStatus;
	iRetrieve->Start(tmpStatus);
	User::WaitForRequest(tmpStatus);
	iTestMbmsContext->TEST(tmpStatus.Int() == KErrInUse);
    SetActive();    
    }

void CTestMbmsSession::RunL()
    {    
    CActiveScheduler::Stop();
	}

void CTestMbmsSession::DoCancel()
    {
    iRetrieve->Cancel();    
    }