// 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:

// base class for CTSY component tests

// 

//

/**

 @file 

*/

#include "cctsycomponenttestbase.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <pcktcs.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/rmmcustomapi.h>

#include "cctsycustomipcfu.h"

_LIT(KDoubleColon, "::");

/**

To push a CleanupItem ont the cleanupstack to close the phone

*/

void CCtsyComponentTestBase::Cleanup(TAny* aSelf)

	{

	static_cast<CCtsyComponentTestBase*>(aSelf)->DoCleanup();

	}

/**

Close the Phone a the server connection

*/	

void CCtsyComponentTestBase::DoCleanup()

	{

	iPhone.Close();

	iMockLTSY.Close();

	TInt ret = iTelServer.UnloadPhoneModule(KMmTsyModuleName);

	if (ret != KErrNone)

		{

		INFO_PRINTF1(_L("Failed to unload phone module"));

		}

	iTelServer.Close();

	}

/**

Assert MockLtsy Terminated all handlings without errors

*/

void CCtsyComponentTestBase::AssertMockLtsyStatusL()

	{

	TBool hasWaitingExpect;

	TBool hasPendingComplete;

	TBool hasError;

	iMockLTSY.GetStatus(hasWaitingExpect,hasPendingComplete,hasError);

	if (hasWaitingExpect || hasPendingComplete)

		{

		ERR_PRINTF1(_L("MockLTsy still have pending/waiting events!"));

		}

	if (hasWaitingExpect || hasPendingComplete || hasError)

		{

		TBuf<255> log;

		do	{

			iMockLTSY.GetNextLogLine(log);

			INFO_PRINTF1(log);

			} 

		while(log.Length() > 0);

		User::Leave(KErrTEFUnitFail); // Fail the test

		}

	}

/**

Open Server session

*/

void CCtsyComponentTestBase::OpenEtelServerL(TExtendedErrorClient aSetExtendedErrorClient)

	{

	TInt ret = iTelServer.Connect();

	if (ret != KErrNone)

		{

		INFO_PRINTF1(_L("Failed connect phone"));

		User::Leave(ret);

		}

	ret = iTelServer.LoadPhoneModule(KMmTsyModuleName);

	if (ret != KErrNone)

		{

		INFO_PRINTF1(_L("Failed load phone module"));

		iTelServer.Close();

		User::Leave(ret);

		}

	if(aSetExtendedErrorClient == EUseExtendedError)

		{

		iTelServer.SetExtendedErrorGranularity(	RTelServer::EErrorExtended );

		}

	}

/**

Standard function to open the phone up to the end of the boot sequence

*/

void CCtsyComponentTestBase::OpenPhoneL()

	{

	RBuf8 data;

	CleanupClosePushL(data);

	//Initialize local variables first:

	//EMobilePhoneGetHomeNetwork

    RMobilePhone::TMobilePhoneNetworkInfoV8 homeNetwork;

    homeNetwork.iMode = RMobilePhone::ENetworkModeWcdma;

    homeNetwork.iStatus = RMobilePhone::ENetworkStatusCurrent;

    homeNetwork.iBandInfo = RMobilePhone::EBandUnknown;

    homeNetwork.iCountryCode = _L("234");

    homeNetwork.iCdmaSID = _L("");

    homeNetwork.iAnalogSID = _L("");

    homeNetwork.iNetworkId = _L("23499");

    homeNetwork.iDisplayTag = _L("symbian");

    homeNetwork.iShortName = _L("symbian");

    homeNetwork.iLongName = _L("symbian mobile");

    homeNetwork.iAccess = RMobilePhone::ENetworkAccessUtran;

    homeNetwork.iEgprsAvailableIndicator = ETrue;

    homeNetwork.iHsdpaAvailableIndicator = ETrue;

    homeNetwork.iHsupaAvailableIndicator = ETrue;

    TMockLtsyData1<RMobilePhone::TMobilePhoneNetworkInfoV8> homeNetworkData(homeNetwork);

    homeNetworkData.SerialiseL(data);

    TInt err = iPhone.Open(iTelServer,KMmTsyPhoneName);

	ASSERT_EQUALS(KErrNone, err);

	err=iMockLTSY.Connect();

	ASSERT_EQUALS(KErrNone, err);

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	// EMmTsyBootNotifyModemStatusReadyIPC

    ASSERT_EQUALS(KErrNone, iMockLTSY.PauseCompletion());

	iMockLTSY.CompleteL(EMmTsyBootNotifyModemStatusReadyIPC,KErrNone);

	// EMobilePhoneGetNetworkRegistrationStatus

	iMockLTSY.ExpectL(EMobilePhoneGetNetworkRegistrationStatus);

	iMockLTSY.CompleteL(EMobilePhoneGetNetworkRegistrationStatus,KErrNone,0);

	// EMmTsyBootNotifySimStatusReadyIPC

	iMockLTSY.ExpectL(EMmTsyBootNotifySimStatusReadyIPC);

	iMockLTSY.CompleteL(EMmTsyBootNotifySimStatusReadyIPC,KErrNone,0);

	// EMobilePhoneGetHomeNetwork

	iMockLTSY.ExpectL(EMobilePhoneGetHomeNetwork);

	iMockLTSY.CompleteL(EMobilePhoneGetHomeNetwork,KErrNone,data,0);

	// EMmTsyPhoneGetPin1DisableSupportedIPC

 	iMockLTSY.ExpectL(EMmTsyPhoneGetPin1DisableSupportedIPC);

 	// EMmTsySimRefreshRegisterIPC

 	iMockLTSY.ExpectL(EMmTsySimRefreshRegisterIPC);

	// EMobilePhoneGetServiceTable

	RMobilePhone::TMobilePhoneServiceTable serviceTable = RMobilePhone::ESIMServiceTable;

	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTable> serviceTableData(serviceTable);

	data.Close();

	serviceTableData.SerialiseL(data);

	iMockLTSY.ExpectL(EMobilePhoneGetServiceTable, data);

	// EMobilePhoneGetALSLine

	iMockLTSY.ExpectL(EMobilePhoneGetALSLine);

	iMockLTSY.ExpectL(ECustomGetIccCallForwardingStatusIPC);

	// EMobilePhoneGetIccMessageWaitingIndicators

    iMockLTSY.ExpectL(EMobilePhoneGetIccMessageWaitingIndicators);

    //ECustomCheckAlsPpSupportIPC

    iMockLTSY.ExpectL(ECustomCheckAlsPpSupportIPC);

    //EMobilePhoneGetCustomerServiceProfile

    iMockLTSY.ExpectL(EMobilePhoneGetCustomerServiceProfile);

	// Complete for EMmTsyPhoneGetPin1DisableSupportedIPC 

 	TBool pin1DisableSupport = ETrue;

	TMockLtsyData1<TBool> pin1DisableSupportData(pin1DisableSupport);

	data.Close();

	pin1DisableSupportData.SerialiseL(data);

	iMockLTSY.CompleteL(EMmTsyPhoneGetPin1DisableSupportedIPC,KErrNone,data,0);

	// Complete for EMmTsySimRefreshRegisterIPC

	iMockLTSY.CompleteL(EMmTsySimRefreshRegisterIPC, KErrGeneral, 0);		

	// Complete for EMobilePhoneGetServiceTable

	RMobilePhone::TMobilePhoneServiceTableV1 serviceTableResult;

	serviceTableResult.iServices1To8  = 0xFF;

	serviceTableResult.iServices9To16 = 0xFF;

	serviceTableResult.iServices17To24= 0xFF;

	serviceTableResult.iServices25To32= 0xFF;

	serviceTableResult.iServices33To40= 0xFF;

	serviceTableResult.iServices41To48= 0xFF;

	serviceTableResult.iServices49To56= 0xFF;

	TMockLtsyData1<RMobilePhone::TMobilePhoneServiceTableV1> serviceTableResultData(serviceTableResult);

	data.Close();

	serviceTableResultData.SerialiseL(data);

	iMockLTSY.CompleteL(EMobilePhoneGetServiceTable,KErrNone,data,0);

	// Complete for EMobilePhoneGetALSLine

	RMobilePhone::TMobilePhoneALSLine alsLine = RMobilePhone::EAlternateLinePrimary;

	TMockLtsyData1<RMobilePhone::TMobilePhoneALSLine> alsLineData(alsLine);

	data.Close();

	alsLineData.SerialiseL(data);

	iMockLTSY.CompleteL(EMobilePhoneGetALSLine,KErrNone,data,0);

	// Complete for EMobilePhoneGetIccMessageWaitingIndicators

	RMobilePhone::TMobilePhoneMessageWaitingV1 expectedMessageIndicators;

	TMockLtsyData1<RMobilePhone::TMobilePhoneMessageWaitingV1>

	                                indicatorsData(expectedMessageIndicators);

	data.Close();

	indicatorsData.SerialiseL(data); 

	iMockLTSY.CompleteL(EMobilePhoneGetIccMessageWaitingIndicators, KErrNone, data);

	//Complete for ECustomCheckAlsPpSupportIPC

	RMmCustomAPI::TAlsSupport alsSupport(RMmCustomAPI::EAlsSupportOff); 

	TMockLtsyData1< RMmCustomAPI::TAlsSupport > alsSupportData(alsSupport);

	data.Close();	

    alsSupportData.SerialiseL(data);

	iMockLTSY.CompleteL(ECustomCheckAlsPpSupportIPC, KErrNone, data);

	// Complete for EMobilePhoneGetCustomerServiceProfile

	RMobilePhone::TMobilePhoneCspFileV1 completeCsp;

	completeCsp.iCallOfferingServices = 1;

	completeCsp.iCallRestrictionServices = 2;

	completeCsp.iOtherSuppServices = 3;

	completeCsp.iCallCompletionServices = 4;

	completeCsp.iTeleservices = 5;

	completeCsp.iCphsTeleservices = 6;

	completeCsp.iCphsFeatures = 7;

	completeCsp.iNumberIdentServices = 8;

	completeCsp.iPhase2PlusServices = 9;

	completeCsp.iValueAddedServices = 10;

	TMockLtsyData1<RMobilePhone::TMobilePhoneCspFileV1> completeLtsyData(completeCsp);

	data.Close();

	completeLtsyData.SerialiseL(data);

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

    ASSERT_EQUALS(KErrNone, iMockLTSY.ResumeCompletion());

	User::WaitForRequest(mockLtsyStatus);

	CleanupStack::PopAndDestroy(1); // data

	}

/**

Dial  call

@param aCall the call to use to dial

@param aService type of call (must match the line the call what created on)

@param aCallId callId ltsy must allocate for this call

*/

void CCtsyComponentTestBase::DialL(RCall& aCall, const TInt aCallId, const RMobilePhone::TMobileService aService)

	{

	DialL(aCall, aCallId, aService, _L("01632960000"));

	}

/**

Dial  call

@param aCall the call to use to dial

@param aCallId callId ltsy must allocate for this call

@param aService type of call (must match the line the call what created on)

@param aTelNumber A telephone number

*/

void CCtsyComponentTestBase::DialL(RCall& aCall,

	                                     const TInt aCallId,

	                                     const RMobilePhone::TMobileService aService,

	                                     const TDesC &aTelNumber)

	{

	RBuf8 data;

	CleanupClosePushL(data);

	// EEtelCallDial

	RMobileCall::TMobileCallParamsV1 callParams;

	RMobileCall::TMobileCallParamsV1Pckg callParamsPckg(callParams);

    callParams.iInterval = 0;

    callParams.iCug.iCugIndex = 0xFFFF;

	RMobileCall::TMobileCallInfoV8 callInfo;

	callInfo.iDialledParty.iTelNumber.Copy(aTelNumber);

	callInfo.iService = aService;

	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;

	TMockLtsyCallData2<RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8> 

		dialData(0, aService, callParams, callInfo);

	dialData.SerialiseL(data);

	iMockLTSY.ExpectL(EEtelCallDial,data);

	// EMobileCallGetMobileCallInfo

	CallGetMobileCallInfoL(aCallId, aService, aTelNumber);

	// complete Dial

	TMockLtsyCallData0 dialCompleteData(aCallId,aService);

	data.Close();

	dialCompleteData.SerialiseL(data);

	iMockLTSY.CompleteL(EEtelCallDial,KErrNone,data);

	TRequestStatus requestStatus ;

	aCall.Dial(requestStatus, callInfo.iDialledParty.iTelNumber);

    User::WaitForRequest(requestStatus);

	AssertMockLtsyStatusL();

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	CleanupStack::PopAndDestroy(1);

	}

/**

Open packet service session.

@param aStartAttachStatus Starting attach status.

@param aStartAttachMode Starting atach mode.  The CTSY does not even cache this value so it does not really matter what it gets set to.

*/

void CCtsyComponentTestBase::OpenPacketServiceL

    (

    RPacketService& aRPacketService,     

    RPacketService::TStatus aStartAttachStatus,     

    RPacketService::TAttachMode aStartAttachMode,    

    TInt aMaxMonitorServices,   

    TInt aMaxServices

    )

	{

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	iMockLTSY.ExpectL(EPacketNotifyStatusChange);

	TBool resumed = EFalse;

	TMockLtsyData2<RPacketService::TStatus , TBool> comNotifyStatus(aStartAttachStatus, resumed);

	comNotifyStatus.SerialiseL(data);

	iMockLTSY.CompleteL(EPacketNotifyStatusChange,KErrNone, data);

	TBool expInitState = ETrue;	 

	TMockLtsyData1<TBool> expGetAttachMode(expInitState);

	data.Close();

	expGetAttachMode.SerialiseL(data);

	iMockLTSY.ExpectL(EPacketGetAttachMode, data);

	TMockLtsyData1<RPacketService::TAttachMode> comGetAttachMode(aStartAttachMode);

	data.Close();

	comGetAttachMode.SerialiseL(data);

	iMockLTSY.CompleteL(EPacketGetAttachMode,KErrNone, data);

	TMockLtsyData1< TInt > iniData(aMaxServices);

    iniData.SerialiseL(data); 

    iMockLTSY.ExpectL(EPacketEnumerateMbmsMonitorServiceList);	

	iMockLTSY.CompleteL( EPacketEnumerateMbmsMonitorServiceList, KErrNone, data );

	TMockLtsyData1< TInt > iniData2(aMaxMonitorServices);

    iniData2.SerialiseL(data); 	

    iMockLTSY.ExpectL(EPacketEnumerateMbmsActiveServiceList);

	iMockLTSY.CompleteL( EPacketEnumerateMbmsActiveServiceList, KErrNone, data );

	//this is actually a sync call to LTSY where return represents a context id offset rather than error code.	

	iMockLTSY.ExpectL(EPacketInitProxiesIPC, 3);	

	//this actually completes before all messages between CTSY<->LTSY have finished.

	TInt err = aRPacketService.Open(iPhone);

	// Wait for the end of initialisation

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(); // data

	}	

/**

Context initiation

@param aPacketContext context object

@param aContextName context name

*/

TInt CCtsyComponentTestBase::InitContextL(RPacketContext& aPacketContext, 

                                          TInfoName& aContextName, 

                                          TInfoName aHostCidName)

{

	RBuf8 data;

	CleanupClosePushL(data);

	// data for initialisation of the context 

	TRequestStatus initStatus;

	RPacketContext::TDataChannelV2 dataCh;

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

    TMockLtsyData2< TInfoName, TInfoName > ltsyInit(aContextName, aHostCidName);

	ltsyInit.SerialiseL(data);	

	iMockLTSY.ExpectL(EPacketContextInitialiseContext, data);

	TMockLtsyData1< TInfoName > ltsyData(aContextName);

	data.Close();

	ltsyData.SerialiseL(data);

	iMockLTSY.CompleteL(EPacketContextInitialiseContext, KErrNone, data);

	//initialisation of the context

	aPacketContext.InitialiseContext(initStatus, pckgInit);

	User::WaitForRequest(initStatus);

	CleanupStack::PopAndDestroy(1); // data

	return initStatus.Int();

}

/**

Context initiation

@param aPacketContext context object

@param aContextName context name

*/

TInt CCtsyComponentTestBase::InitMbmsContextL(RPacketMbmsContext& aPacketContext, 

                                              TInfoName& aContextName )

{

	RBuf8 data;

	CleanupClosePushL(data);

	// data for initialisation of the context 

    TMockLtsyData1< TInfoName> ltsyInit(aContextName);

	ltsyInit.SerialiseL(data);	

	iMockLTSY.ExpectL(ECtsyPacketMbmsInitialiseContextReq, data);

	RPacketMbmsContext::TDataChannelV2 dataCh;

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

	TMockLtsyData2< TInfoName, RPacketMbmsContext::TDataChannelV2 > ltsyData(aContextName, dataCh);

	data.Close();

	ltsyData.SerialiseL(data);

	iMockLTSY.CompleteL(ECtsyPacketMbmsInitialiseContextComp, KErrNone, data);

	//initialisation of the context

	TRequestStatus initStatus;

	aPacketContext.InitialiseContext(initStatus, pckgInit);

	User::WaitForRequest(initStatus);

	CleanupStack::PopAndDestroy(1); // data

	return initStatus.Int();

}

/**

Context activation

@param aContextName context name

*/

TInt CCtsyComponentTestBase::SetContextActiveL(TInfoName& aContextName)

{

	RBuf8 data;

	CleanupClosePushL(data);

	//data for CompleteL    

 	TContextMisc  completeMisc;

    completeMisc.iStatus = RPacketContext::EStatusActive;

 	TMockLtsyData2 <TInfoName, TContextMisc>

    ltsyData1(aContextName, completeMisc);

	ltsyData1.SerialiseL(data);	

	TRequestStatus mockLtsyStatus;

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

	//send completion

	iMockLTSY.CompleteL(EPacketContextNotifyStatusChange, KErrNone, data);

	// wait for completion

	User::WaitForRequest(mockLtsyStatus);	

	CleanupStack::PopAndDestroy(1); // data

	return mockLtsyStatus.Int();

}

/**

Context activation

@param aContextName context name

*/

TInt CCtsyComponentTestBase::SetMbmsActiveL(RPacketMbmsContext& aMbmsContext,

                                            RPacketMbmsContext::TContextConfigMbmsV1& aConfig,

                                            TInfoName& aContextName)

{

	RBuf8 data;

	CleanupClosePushL(data);

	RBuf8 expectData;

	CleanupClosePushL(expectData);	

 	TMockLtsyData1 <TInfoName> expData( aContextName );

	expData.SerialiseL( expectData );

	TMockLtsyData2< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1 > ltsyData1(aContextName, aConfig);

	ltsyData1.SerialiseL(data);	

 	iMockLTSY.ExpectL( EPacketContextActivate, expectData );

 	iMockLTSY.CompleteL(EPacketContextActivate, KErrNone, data);

 	TRequestStatus	requestStatus;

	aMbmsContext.Activate( requestStatus );

	User::WaitForRequest( requestStatus );	

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

	return requestStatus.Int();

}

TInt CCtsyComponentTestBase::SetMbmsDeactiveL(RPacketMbmsContext& aPacketContext, 

                                              TInfoName& aContextName)

{

	RBuf8 data;

	CleanupClosePushL(data);

	RPacketMbmsContext::CMbmsSession* list=RPacketMbmsContext::CMbmsSession::NewL();

	CleanupStack::PushL(list);