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

//

#include <e32test.h>

#include "TE_EtelMMTestStepBase.h"

#include "TE_mmcall.h"

#include "testdef.h"

CTestCall::CTestCall()

/** Each test step initialises it's own name

*/

	{

	// store the name of this test case

	// this is the name that is used by the script file

	SetTestStepName(_L("TestCall"));

	}

enum TVerdict CTestCall::doTestStepL()

//

// Test Call Functions

//

    {

	iTestCount =1;

	INFO_PRINTF1(_L(""));

	INFO_PRINTF1(_L("Test Mobile Call Functionality"));

	RMobilePhone mmPhone;

	TInt ret=mmPhone.Open(iTelServer,DMMTSY_PHONE_NAME);

	TEST(ret==KErrNone);

	RMobileLine mmLine;

	ret=mmLine.Open(mmPhone,DMMTSY_LINE_VOICE_NAME);

    TEST(ret==KErrNone);

	RMobileCall mmCall;

	TName callName;

	ret=mmCall.OpenNewCall(mmLine,callName);

    TEST(ret==KErrNone);

	TRequestStatus reqStatus;

   	// Test DialNoFdnCheck (Overloaded)

	TBuf<RMobilePhone::KMaxMobileTelNumberSize> TelNumber(DMMTSY_PHONE_TEL_NUMBER);

	// Provide standard multimode call parameter package for DialNoFdnCheck

	RMobileCall::TMobileCallParamsV1  mmCallParams;

	RMobileCall::TMobileCallParamsV1Pckg mmCallParamsPckg(mmCallParams);

	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	// First Asynchronous

	mmCall.DialNoFdnCheck(reqStatus, TelNumber);

	User::WaitForRequest(reqStatus);

   	TEST(reqStatus.Int()==KErrNone);

	INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async) passed"), iTestCount++);

	// First Asynchronous & cancel

	mmCall.DialNoFdnCheck(reqStatus, TelNumber);

	mmCall.CancelAsyncRequest(EMobileCallDialNoFdnCheck);

    User::WaitForRequest(reqStatus);

   	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   	if (reqStatus.Int()==KErrCancel)

   		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async & cancel (Cancelled Request)) passed"), iTestCount++);

   	else

   		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (First async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Second Asynchronous

	mmCall.DialNoFdnCheck(reqStatus, mmCallParamsPckg, TelNumber);

	User::WaitForRequest(reqStatus);

   	TEST(reqStatus.Int()==KErrNone);

	INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async) passed"), iTestCount++);

	// Second Asynchronous & cancel

	mmCall.DialNoFdnCheck(reqStatus, mmCallParamsPckg, TelNumber);

	mmCall.CancelAsyncRequest(EMobileCallDialNoFdnCheck);

    User::WaitForRequest(reqStatus);

   	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

   	if (reqStatus.Int()==KErrCancel)

   		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async & cancel (Cancelled Request)) passed"), iTestCount++);

   	else

   		INFO_PRINTF2(_L("Test %d - RMobileCall::DialNoFdnCheck (Second async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Test Set Call Parameters within Dial

	// Create a multimode call parameter package, send it as part of Dial

	mmCallParams.iInterval = DMMTSY_CALL_INTERVAL;

	mmCallParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	mmCallParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	mmCallParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	mmCallParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	mmCallParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	mmCallParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

//	TBuf<RMobilePhone::KMaxMobileTelNumberSize> number(DMMTSY_PHONE_TEL_NUMBER);

	iNumber = DMMTSY_PHONE_TEL_NUMBER;

	TEST(KErrNone==mmCall.Dial(mmCallParamsPckg, iNumber));

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MM Call Params) passed"), iTestCount++);

	// Test Set Call using V2 Parameters within Dial

	// Create a multimode call parameter package, send it as part of Dial

	RMobileCall::TMobileCallParamsV2  mmCallParamsV2;

	mmCallParamsV2.iInterval = DMMTSY_CALL_INTERVAL;

	mmCallParamsV2.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	mmCallParamsV2.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	mmCallParamsV2.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	mmCallParamsV2.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	mmCallParamsV2.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	mmCallParamsV2.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	mmCallParamsV2.iBearerMode = DMMTSY_CALL_NEW_BEARER;

	RMobileCall::TMobileCallParamsV2Pckg mmCallParamsV2Pckg(mmCallParamsV2);

	TEST(KErrNone==mmCall.Dial(mmCallParamsV2Pckg, iNumber));

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MMv2 Call Params) passed"), iTestCount++);

	// Test Set Call using V7 Parameters within Dial

	// Create a multimode call parameter package, send it as part of Dial

	RMobileCall::TMobileCallParamsV7 mmCallParamsV7;

	TEST(mmCallParamsV7.ExtensionId() == RMobileCall::KETelMobileCallParamsV7);

	mmCallParamsV7.iInterval = DMMTSY_CALL_INTERVAL;

	mmCallParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	mmCallParamsV7.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	mmCallParamsV7.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	mmCallParamsV7.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	mmCallParamsV7.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	mmCallParamsV7.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	mmCallParamsV7.iBearerMode = DMMTSY_CALL_NEW_BEARER;

	mmCallParamsV7.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

	mmCallParamsV7.iSubAddress = DMMTSY_CALL_SUBADDRESS;

	mmCallParamsV7.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;

	mmCallParamsV7.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;

	mmCallParamsV7.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;

	mmCallParamsV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

	mmCallParamsV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

	mmCallParamsV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;

	RMobileCall::TMobileCallParamsV7Pckg mmCallParamsV7Pckg(mmCallParamsV7);

	TEST(KErrNone==mmCall.Dial(mmCallParamsV7Pckg, iNumber));

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (MMv7 Call Params) passed"), iTestCount++);

	// Test RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV7

	// If this test fails, ensure that the line:

	// etel_KSatEngineSid 0x10281806

	// is present in \epoc32\data\epoc.ini

	TRequestStatus dialCallControlStatus;

	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, iNumber);

	User::WaitForRequest(dialCallControlStatus);

	TEST(KErrNone==dialCallControlStatus.Int());

	// Asynchronous and cancel

	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, iNumber);

	mmCall.CancelAsyncRequest(EMobileCallDialCallControl);

	User::WaitForRequest(dialCallControlStatus);

	TEST(KErrNone==dialCallControlStatus.Int() || KErrCancel==dialCallControlStatus.Int());

	INFO_PRINTF2(_L("Test %d - RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV3 passed"), iTestCount++);

	// Test RMobileCall::DialCallControl with no number

	TBuf<1> noNumberBuf;

	noNumberBuf.Zero();

	mmCall.DialCallControl(dialCallControlStatus, mmCallParamsV7Pckg, noNumberBuf);

	User::WaitForRequest(dialCallControlStatus);

	TEST(KErrArgument==dialCallControlStatus.Int());	

	INFO_PRINTF2(_L("Test %d - RMobileCall::DialCallControl with RMobileCall::TMobileCallParamsV3 and no number passed"), iTestCount++);

	//

	// Try to get just the core ETel API parts of the TCallParams

	RCall::TCallParams coreCallParams;

	RCall::TCallParamsPckg coreCallParamsPckg(coreCallParams);

	TEST(KErrNone==mmCall.GetCallParams(coreCallParamsPckg));

	TEST(coreCallParams.ExtensionId()==0);

	TEST(coreCallParams.iInterval==DMMTSY_CALL_INTERVAL);

	// Get the multimode call parameters this time

	RMobileCall::TMobileCallParamsV1  mmCallParams2;

	RMobileCall::TMobileCallParamsV1Pckg mmCallParams2Pckg(mmCallParams2);

	TEST(KErrNone==mmCall.GetCallParams(mmCallParams2Pckg));

	TEST(mmCallParams2.ExtensionId()==RMobileCall::KETelMobileCallParamsV1);

	TEST(mmCallParams2.iInterval==DMMTSY_CALL_INTERVAL);

	TEST(mmCallParams2.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

	TEST(mmCallParams2.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

	TEST(mmCallParams2.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

	TEST(mmCallParams2.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

	TEST(mmCallParams2.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

	TEST(mmCallParams2.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (MM Call Params) passed"), iTestCount++);

	// Test GetMobileDataCallCaps

	RMobileCall::TMobileCallDataCapsV1 dataCaps, asyncDataCaps;

	RMobileCall::TMobileCallDataCapsV1Pckg dataCapsPckg(dataCaps);

	RMobileCall::TMobileCallDataCapsV1Pckg asyncDataCapsPckg(asyncDataCaps);

	TEST(mmCall.GetMobileDataCallCaps(dataCapsPckg) == KErrNone);

	ValidateCallDataCaps(dataCaps);

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallCaps (sync) passed"), iTestCount++);

	// Test NotifyMobileDataCallCapsChange

	// asynchronous

	mmCall.NotifyMobileDataCallCapsChange(reqStatus,asyncDataCapsPckg);

  	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	ValidateCallDataCaps(asyncDataCaps);

	// asynchronous & cancel

	mmCall.NotifyMobileDataCallCapsChange(reqStatus,asyncDataCapsPckg);

	mmCall.CancelAsyncRequest(EMobileCallNotifyMobileDataCallCapsChange);

  	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone  || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileDataCallCapsChange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

	else

		{

		ValidateCallDataCaps(asyncDataCaps);

		INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileDataCallCapsChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

	// Test Set Data Call Parameters within Dial

	RMobileCall::TMobileDataCallParamsV1 dataParams, retrieveDataParams;

	RMobileCall::TMobileDataCallParamsV1Pckg dataParamsPckg(dataParams);

	RMobileCall::TMobileDataCallParamsV1Pckg retrieveDataParamsPckg(retrieveDataParams);

	dataParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	dataParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	dataParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	dataParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	dataParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	dataParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	dataParams.iService = DMMTSY_DATA_CALL_SERVICE;

	dataParams.iSpeed = DMMTSY_DATA_CALL_SPEED;

	dataParams.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

	dataParams.iQoS = DMMTSY_DATA_CALL_QOS;

	dataParams.iRLPVersion = DMMTSY_DATA_CALL_RLP;

	dataParams.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

	dataParams.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

	mmCall.Dial(reqStatus, dataParamsPckg, iNumber);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (Data Call Params) passed"), iTestCount++);

	// Test Get Data Call Params

	TEST(mmCall.GetCallParams(retrieveDataParamsPckg) == KErrNone);

	TEST(retrieveDataParams.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV1);

	TEST(retrieveDataParams.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

	TEST(retrieveDataParams.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

	TEST(retrieveDataParams.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

	TEST(retrieveDataParams.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

	TEST(retrieveDataParams.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

	TEST(retrieveDataParams.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

	ValidateDataCallParams(retrieveDataParams, 0);

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (Data Call Params) passed"), iTestCount++);

	// Test Set Data Call Parameters within Dial

	RMobileCall::TMobileDataCallParamsV8 dataParams8, retrieveDataParams8;

	RMobileCall::TMobileDataCallParamsV8Pckg dataParamsPckg8(dataParams8);

	RMobileCall::TMobileDataCallParamsV8Pckg retrieveDataParamsPckg8(retrieveDataParams8);

	TEST(dataParams8.ExtensionId()== RMobileCall::KETelMobileDataCallParamsV8);

	TEST(dataParams8.iCallParamOrigin == RMobileCall::EOriginatorUnknown);

	TEST(dataParams8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);

	dataParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	dataParams8.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	dataParams8.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	dataParams8.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	dataParams8.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	dataParams8.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	dataParams8.iService = DMMTSY_DATA_CALL_SERVICE;

	dataParams8.iSpeed = DMMTSY_DATA_CALL_SPEED;

	dataParams8.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

	dataParams8.iQoS = DMMTSY_DATA_CALL_QOS;

	dataParams8.iRLPVersion = DMMTSY_DATA_CALL_RLP;

	dataParams8.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

	dataParams8.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

	dataParams8.iBearerMode = DMMTSY_PHONE_MULTICALLBEARERMODE_NOTSUPPORTED;

	dataParams8.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

	dataParams8.iSubAddress = DMMTSY_CALL_SUBADDRESS;

	dataParams8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;

	dataParams8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;

	dataParams8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;

	dataParams8.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

	dataParams8.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

	dataParams8.iAlphaId = DMMTSY_CALL_ALPHA_ID;

	mmCall.Dial(reqStatus, dataParamsPckg8, iNumber);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (Data Call Params8) passed"), iTestCount++);

	// Test Get Data Call Params

	TEST(mmCall.GetCallParams(retrieveDataParamsPckg8) == KErrNone);

	TEST(retrieveDataParams8.ExtensionId()==RMobileCall::KETelMobileDataCallParamsV8);

	TEST(retrieveDataParams8.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

	TEST(retrieveDataParams8.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

	TEST(retrieveDataParams8.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

	TEST(retrieveDataParams8.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

	TEST(retrieveDataParams8.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

	TEST(retrieveDataParams8.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

	ValidateDataCallParams(retrieveDataParams8, 0);

	TEST(retrieveDataParams8.iCallParamOrigin==DMMTSY_CALL_PARAM_ORIGIN);

	TEST(retrieveDataParams8.iSubAddress==DMMTSY_CALL_SUBADDRESS);

	TEST(retrieveDataParams8.iBearerCap1==DMMTSY_CALL_BEARER_CAP1);

	TEST(retrieveDataParams8.iBearerCap2==DMMTSY_CALL_BEARER_CAP2);

	TEST(retrieveDataParams8.iBCRepeatIndicator==DMMTSY_CALL_BC_REPEAT_INDICATOR);

	TEST(retrieveDataParams8.iIconId.iIdentifier==DMMTSY_CALL_ICON_ID_IDENTIFIER);

	TEST(retrieveDataParams8.iIconId.iQualifier==DMMTSY_CALL_ICON_ID_QUALIFIER);

	TEST(retrieveDataParams8.iAlphaId==DMMTSY_CALL_ALPHA_ID);

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (Data Call Params8) passed"), iTestCount++);

	// Test GetMobileDataCallRLPRange

	RMobileCall::TMobileDataRLPRangesV1 rlpRanges;

	RMobileCall::TMobileDataRLPRangesV1Pckg rlpRangesPckg(rlpRanges);

	// asynchronous

	mmCall.GetMobileDataCallRLPRange(reqStatus, DMMTSY_CALL_RLP_VERSION1, rlpRangesPckg);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// extract the returned rlpRanges from the package

	rlpRanges = rlpRangesPckg();

	ValidateRLPRange(rlpRanges);	

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange passed"), iTestCount++);

	// asynchronous & cancel

	mmCall.GetMobileDataCallRLPRange(reqStatus, DMMTSY_CALL_RLP_VERSION1, rlpRangesPckg);

	mmCall.CancelAsyncRequest(EMobileCallGetMobileDataCallRLPRange);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange (async & cancel (Cancelled Request)) passed"), iTestCount++);	

	else

		{

		// extract the returned rlpRanges from the package

		rlpRanges = rlpRangesPckg();

		ValidateRLPRange(rlpRanges);

		INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileDataCallRLPRange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

		}

	// Test Set Hcsd Parameters within Dial

	RMobileCall::TMobileHscsdCallParamsV1 hscsdParams, retrieveHscsdParams;

	RMobileCall::TMobileHscsdCallParamsV1Pckg hscsdParamsPckg(hscsdParams);

	RMobileCall::TMobileHscsdCallParamsV1Pckg retrieveHscsdParamsPckg(retrieveHscsdParams);

	hscsdParams.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	hscsdParams.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	hscsdParams.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	hscsdParams.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	hscsdParams.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	hscsdParams.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	hscsdParams.iService = DMMTSY_DATA_CALL_SERVICE;

	hscsdParams.iSpeed = DMMTSY_DATA_CALL_SPEED;

	hscsdParams.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

	hscsdParams.iQoS = DMMTSY_DATA_CALL_QOS;

	hscsdParams.iRLPVersion = DMMTSY_DATA_CALL_RLP;

	hscsdParams.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

	hscsdParams.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

	hscsdParams.iInterval = DMMTSY_CALL_INTERVAL;

	hscsdParams.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

	hscsdParams.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

	hscsdParams.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

	hscsdParams.iCodings = DMMTSY_CALL_HCSD_CODING;

	hscsdParams.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

	hscsdParams.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

	// asynchronous

	mmCall.Dial(reqStatus, hscsdParamsPckg, iNumber);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// Set the dyanmic HSCSD params

	mmCall.SetDynamicHscsdParams(reqStatus,hscsdParams.iWantedAiur,hscsdParams.iWantedRxTimeSlots);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	// asynchronous & cancel

	mmCall.SetDynamicHscsdParams(reqStatus,hscsdParams.iWantedAiur,hscsdParams.iWantedRxTimeSlots);

	mmCall.CancelAsyncRequest(EMobileCallSetDynamicHscsdParams);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);

	if (reqStatus.Int()==KErrCancel)

		INFO_PRINTF2(_L("Test %d - RMobileCall::SetDynamicHscsdParams (async & cancel (Cancelled Request)) passed"), iTestCount++);	

	else

		INFO_PRINTF2(_L("Test %d - RMobileCall::SetDynamicHscsdParams (async & cancel (Request Not Cancelled)) passed"), iTestCount++);

	// Test Set Hscsd Params V7 within Dial

	RMobileCall::TMobileHscsdCallParamsV7 hscsdParamsV7;

	RMobileCall::TMobileHscsdCallParamsV7Pckg hscsdParamsV7Pckg(hscsdParamsV7);

	hscsdParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	hscsdParamsV7.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	hscsdParamsV7.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	hscsdParamsV7.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	hscsdParamsV7.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	hscsdParamsV7.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	hscsdParamsV7.iService = DMMTSY_DATA_CALL_SERVICE;

	hscsdParamsV7.iSpeed = DMMTSY_DATA_CALL_SPEED;

	hscsdParamsV7.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

	hscsdParamsV7.iQoS = DMMTSY_DATA_CALL_QOS;

	hscsdParamsV7.iRLPVersion = DMMTSY_DATA_CALL_RLP;

	hscsdParamsV7.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

	hscsdParamsV7.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

	hscsdParamsV7.iInterval = DMMTSY_CALL_INTERVAL;

	hscsdParamsV7.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	hscsdParamsV7.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

	hscsdParamsV7.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

	hscsdParamsV7.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

	hscsdParamsV7.iCodings = DMMTSY_CALL_HCSD_CODING;

	hscsdParamsV7.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

	hscsdParamsV7.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

	hscsdParamsV7.iBearerMode = DMMTSY_CALL_NEW_BEARER;

	hscsdParamsV7.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

	hscsdParamsV7.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

	hscsdParamsV7.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

	hscsdParamsV7.iAlphaId = DMMTSY_CALL_ALPHA_ID;

	// asynchronous

	mmCall.Dial(reqStatus, hscsdParamsV7Pckg, iNumber);

	User::WaitForRequest(reqStatus);

	TEST(reqStatus.Int()==KErrNone);

	INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (HSCSDv7 Call Params) passed"), iTestCount++);

	// Test Get Hscsd Params

	TEST(mmCall.GetCallParams(retrieveHscsdParamsPckg) == KErrNone);

	TEST(retrieveHscsdParams.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV1);

	TEST(retrieveHscsdParams.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);

	TEST(retrieveHscsdParams.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);

	TEST(retrieveHscsdParams.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);

	TEST(retrieveHscsdParams.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);

	TEST(retrieveHscsdParams.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);

	TEST(retrieveHscsdParams.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);

	ValidateHscsdParams(retrieveHscsdParams);

	INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (HSCSD params) passed"), iTestCount++);

	// Test Set Hscsd Params V8 within Dial

	RMobileCall::TMobileHscsdCallParamsV8 hscsdParams8, retrieveHscsdParams8;

	RMobileCall::TMobileHscsdCallParamsV8Pckg hscsdParamsPckg8(hscsdParams8);

	RMobileCall::TMobileHscsdCallParamsV8Pckg retrieveHscsdParamsPckg8(retrieveHscsdParams8);

	TEST(hscsdParams8.ExtensionId()== RMobileCall::KETelMobileHscsdCallParamsV8);

	TEST(hscsdParams8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);

	hscsdParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	hscsdParams8.iCug.iExplicitInvoke = DMMTSY_CALL_CUG_INVOKE;

	hscsdParams8.iCug.iCugIndex = DMMTSY_CALL_CUG_INDEX;

	hscsdParams8.iCug.iSuppressOA = DMMTSY_CALL_CUG_OA;

	hscsdParams8.iCug.iSuppressPrefCug = DMMTSY_CALL_CUG_PREF;

	hscsdParams8.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;

	hscsdParams8.iService = DMMTSY_DATA_CALL_SERVICE;

	hscsdParams8.iSpeed = DMMTSY_DATA_CALL_SPEED;

	hscsdParams8.iProtocol = DMMTSY_DATA_CALL_PROTOCOL;

	hscsdParams8.iQoS = DMMTSY_DATA_CALL_QOS;

	hscsdParams8.iRLPVersion = DMMTSY_DATA_CALL_RLP;

	hscsdParams8.iV42bisReq = DMMTSY_DATA_CALL_V42BIS;

	hscsdParams8.iUseEdge = DMMTSY_DATA_CALL_EGPRS_REQUIRED;

	hscsdParams8.iInterval = DMMTSY_CALL_INTERVAL;

	hscsdParams8.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;

	hscsdParams8.iWantedAiur = DMMTSY_CALL_HCSD_AIUR;

	hscsdParams8.iWantedRxTimeSlots = DMMTSY_CALL_HCSD_TS;

	hscsdParams8.iMaxTimeSlots = DMMTSY_CALL_HCSD_MAXTS;

	hscsdParams8.iCodings = DMMTSY_CALL_HCSD_CODING;

	hscsdParams8.iAsymmetry = DMMTSY_CALL_HCSD_ASYMMETRY;

	hscsdParams8.iUserInitUpgrade = DMMTSY_CALL_HCSD_USER_IMI;

	hscsdParams8.iBearerMode = DMMTSY_CALL_NEW_BEARER;

	hscsdParams8.iCallParamOrigin = DMMTSY_CALL_PARAM_ORIGIN;

	hscsdParams8.iIconId.iIdentifier = DMMTSY_CALL_ICON_ID_IDENTIFIER;

	hscsdParams8.iIconId.iQualifier = DMMTSY_CALL_ICON_ID_QUALIFIER;

	hscsdParams8.iAlphaId = DMMTSY_CALL_ALPHA_ID;

	hscsdParams8.iSubAddress = DMMTSY_CALL_SUBADDRESS;

	hscsdParams8.iBearerCap1 = DMMTSY_CALL_BEARER_CAP1;