--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelmultimode/TETEL/te_EtelMM/TE_mmcall.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1640 @@
+// 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;
+ hscsdParams8.iBearerCap2 = DMMTSY_CALL_BEARER_CAP2;
+ hscsdParams8.iBCRepeatIndicator = DMMTSY_CALL_BC_REPEAT_INDICATOR;
+
+ // asynchronous
+ mmCall.Dial(reqStatus, hscsdParamsPckg8, iNumber);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Dial (HSCSDv8 Call Params) passed"), iTestCount++);
+
+ // Test Get Hscsd Params
+ TEST(mmCall.GetCallParams(retrieveHscsdParamsPckg8) == KErrNone);
+ TEST(retrieveHscsdParams8.ExtensionId()==RMobileCall::KETelMobileHscsdCallParamsV8);
+
+ TEST(retrieveHscsdParams8.iIdRestrict==DMMTSY_CALL_CLI_RESTRICT_SETTING1);
+ TEST(retrieveHscsdParams8.iCug.iExplicitInvoke==DMMTSY_CALL_CUG_INVOKE);
+ TEST(retrieveHscsdParams8.iCug.iCugIndex==DMMTSY_CALL_CUG_INDEX);
+ TEST(retrieveHscsdParams8.iCug.iSuppressOA==DMMTSY_CALL_CUG_OA);
+ TEST(retrieveHscsdParams8.iCug.iSuppressPrefCug==DMMTSY_CALL_CUG_PREF);
+ TEST(retrieveHscsdParams8.iAutoRedial==DMMTSY_CALL_AUTO_REDIAL_FLAG);
+
+ ValidateHscsdParams(retrieveHscsdParams8);
+ TEST(retrieveHscsdParams8.iSubAddress == DMMTSY_CALL_SUBADDRESS);
+ TEST(retrieveHscsdParams8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);
+ TEST(retrieveHscsdParams8.iBearerCap2 == DMMTSY_CALL_BEARER_CAP2);
+ TEST(retrieveHscsdParams8.iBCRepeatIndicator == DMMTSY_CALL_BC_REPEAT_INDICATOR);
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetCallParams (HSCSD params) passed"), iTestCount++);
+
+ // Test Get HSCSD Call Information with version 1
+ RMobileCall::TMobileCallHscsdInfoV1 hscsdInfo, asyncHscsdInfo;
+ RMobileCall::TMobileCallHscsdInfoV1Pckg hscsdInfoPckg(hscsdInfo);
+ RMobileCall::TMobileCallHscsdInfoV1Pckg asyncHscsdInfoPckg(asyncHscsdInfo);
+
+ TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoPckg) == KErrNone);
+ ValidateHscsdInfo(hscsdInfo);
+
+ // Test Get HSCSD Call Information with version 7
+ RMobileCall::TMobileCallHscsdInfoV7 hscsdInfoV7;
+ RMobileCall::TMobileCallHscsdInfoV7Pckg hscsdInfoV7Pckg(hscsdInfoV7);
+ TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoV7Pckg) == KErrNone);
+
+ ValidateHscsdInfo(hscsdInfoV7);
+ TEST(hscsdInfoV7.iCallParamOrigin == DMMTSY_CALL_PARAM_ORIGIN);
+ TEST(hscsdInfoV7.iIconId.iQualifier == DMMTSY_CALL_ICON_ID_QUALIFIER);
+ TEST(hscsdInfoV7.iIconId.iIdentifier == DMMTSY_CALL_ICON_ID_IDENTIFIER);
+ TEST(hscsdInfoV7.iAlphaId == DMMTSY_CALL_ALPHA_ID);
+ TEST(hscsdInfoV7.iParamsCallControlModified == DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED);
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetCurrentHscsdInfo (sync) passed"), iTestCount++);
+
+ // Test Get HSCSD Call Information with version 8
+ RMobileCall::TMobileCallHscsdInfoV8 hscsdInfoV8;
+ RMobileCall::TMobileCallHscsdInfoV8Pckg hscsdInfoV8Pckg(hscsdInfoV8);
+ TEST(mmCall.GetCurrentHscsdInfo(hscsdInfoV8Pckg) == KErrNone);
+
+ ValidateHscsdInfo(hscsdInfoV8);
+ TEST(hscsdInfoV8.iCallParamOrigin == DMMTSY_CALL_PARAM_ORIGIN);
+ TEST(hscsdInfoV8.iIconId.iQualifier == DMMTSY_CALL_ICON_ID_QUALIFIER);
+ TEST(hscsdInfoV8.iIconId.iIdentifier == DMMTSY_CALL_ICON_ID_IDENTIFIER);
+ TEST(hscsdInfoV8.iAlphaId == DMMTSY_CALL_ALPHA_ID);
+ TEST(hscsdInfoV8.iParamsCallControlModified == DMMTSY_CALL_PARAMS_CALL_CONTROL_MODIFIED);
+ TEST(hscsdInfoV8.iSubAddress == DMMTSY_CALL_SUBADDRESS);
+ TEST(hscsdInfoV8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);
+ TEST(hscsdInfoV8.iBearerCap2 == DMMTSY_CALL_BEARER_CAP2);
+ TEST(hscsdInfoV8.iBCRepeatIndicator == DMMTSY_CALL_BC_REPEAT_INDICATOR);
+
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetCurrentHscsdInfo (sync) passed"), iTestCount++);
+
+
+ // Test Notify Hscsd Info Change
+ // asynchronous
+ mmCall.NotifyHscsdInfoChange(reqStatus,asyncHscsdInfoPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ ValidateHscsdInfo(asyncHscsdInfo);
+
+ // asynchronous & cancel
+ mmCall.NotifyHscsdInfoChange(reqStatus,asyncHscsdInfoPckg);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyHscsdInfoChange);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyHscsdInfoChange (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ ValidateHscsdInfo(asyncHscsdInfo);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyHscsdInfoChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Close Call
+ mmCall.Close();
+ mmLine.Close();
+ mmPhone.Close();
+ INFO_PRINTF1(_L(""));
+
+ return TestStepResult();
+ }
+
+CTestCallb::CTestCallb()
+/** 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-2nd-part"));
+ }
+
+enum TVerdict CTestCallb::doTestStepL()
+//
+// Test Call Functions
+//
+ {
+ iTestCount =1;
+ INFO_PRINTF1(_L(""));
+ INFO_PRINTF1(_L("Test Mobile Call Functionality"));
+// LOGTEXT(_L8("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)
+
+ // Provide stndard multimode call parameter package for DialNoFdnCheck
+
+ RMobileCall::TMobileCallParamsV1 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;
+
+// test.Next(_L("OK: RMobileCall's HSCSD Call Info"));
+
+ // Test Voice Fallback for Multimedia Calls
+
+ TName falbackCallName;
+
+ // asynchronous
+
+ mmCall.NotifyVoiceFallback(reqStatus, falbackCallName);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(falbackCallName.Compare(DMMTSY_VOICE_FALLBACK_CALL_NAME) == 0);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyVoiceFallback(reqStatus, falbackCallName);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyVoiceFallback);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyVoiceFallback (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(falbackCallName.Compare(DMMTSY_VOICE_FALLBACK_CALL_NAME) == 0);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyVoiceFallback (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+// test.Next(_L("OK: RMobileCall's Voice Fallback"));
+
+
+ // Test SwitchAlternating Data Call
+
+ // asynchronous
+
+ mmCall.SwitchAlternatingCall(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.SwitchAlternatingCall(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallSwitchAlternatingCall);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SwitchAlternatingCall (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SwitchAlternatingCall (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+
+ // Test Notify Alternating Call Switch
+
+ // asynchronous
+
+ mmCall.NotifyAlternatingCallSwitch(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyAlternatingCallSwitch(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyAlternatingCallSwitch);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyAlternatingCallSwitch (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyAlternatingCallSwitch (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+// test.Next(_L("OK: RMobileCall's Alternating Calls"));
+
+ // Call Control caps
+
+ RMobileCall::TMobileCallCapsV1 callCaps;
+ RMobileCall::TMobileCallCapsV1Pckg callCapsPckg(callCaps);
+
+ // synchronous
+
+ TEST(mmCall.GetMobileCallCaps(callCapsPckg)==KErrNone);
+ TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS1);
+ TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS1);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallCaps (sync) passed"), iTestCount++);
+
+ // asynchronous
+
+ mmCall.NotifyMobileCallCapsChange(reqStatus, callCapsPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS2);
+ TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS2);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyMobileCallCapsChange(reqStatus, callCapsPckg);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyMobileCallCapsChange);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallCapsChange (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(callCaps.iCallControlCaps==DMMTSY_CALL_CONTROL_CAPS2);
+ TEST(callCaps.iCallEventCaps==DMMTSY_CALL_EVENT_CAPS2);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallCapsChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Call Status
+
+ RMobileCall::TMobileCallStatus callStatus;
+
+ // synchronous
+
+ TEST(KErrNone==mmCall.GetMobileCallStatus(callStatus));
+ TEST(callStatus==DMMTSY_CALL_STATUS1);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallStatus (sync) passed"), iTestCount++);
+
+ // asynchronous
+
+ mmCall.NotifyMobileCallStatusChange(reqStatus,callStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(callStatus==DMMTSY_CALL_STATUS2);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyMobileCallStatusChange(reqStatus,callStatus);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyMobileCallStatusChange);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallStatusChange (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(callStatus==DMMTSY_CALL_STATUS2);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyMobileCallStatusChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Call Hold
+
+ // asynchronous
+
+ mmCall.Hold(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.Hold(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallHold);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Hold (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Hold (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Call Resume
+
+ // asynchronous
+
+ mmCall.Resume(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.Resume(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallResume);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Resume (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Resume (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Call Swap
+
+ // asynchronous
+
+ mmCall.Swap(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.Swap(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallSwap);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Swap (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Swap (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+
+ // Call Deflect
+
+ RMobilePhone::TMobileAddress deflectAddress;
+ RMobileCall::TMobileCallDeflect deflectType=DMMTSY_CALL_DEFLECT_TYPE;
+
+ deflectAddress.iTypeOfNumber = DMMTSY_PHONE_TON;
+ deflectAddress.iNumberPlan = DMMTSY_PHONE_NPI;
+ deflectAddress.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;
+
+ // asynchronous
+
+ mmCall.Deflect(reqStatus,deflectType,deflectAddress);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.Deflect(reqStatus,deflectType,deflectAddress);
+ mmCall.CancelAsyncRequest(EMobileCallDeflect);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Deflect (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Deflect (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+
+ // Call Transfer
+
+ // asynchronous
+
+ mmCall.Transfer(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.Transfer(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallTransfer);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Transfer (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::Transfer (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Call Go one to one
+
+ // asynchronous
+
+ mmCall.GoOneToOne(reqStatus);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.GoOneToOne(reqStatus);
+ mmCall.CancelAsyncRequest(EMobileCallGoOneToOne);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GoOneToOne (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GoOneToOne (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // asynchronous
+
+ RMobileCall::TMobileCallEvent event;
+ mmCall.NotifyCallEvent(reqStatus, event);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(event==DMMTSY_CALL_EVENT1);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyCallEvent(reqStatus, event);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyCallEvent);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyCallEvent (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(event==DMMTSY_CALL_EVENT1);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyCallEvent (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Get the big block of call information
+
+ RMobileCall::TMobileCallInfoV1 syncCallInfo;
+ RMobileCall::TMobileCallInfoV1Pckg syncCallInfoPckg(syncCallInfo);
+
+ // synchronous
+
+ TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckg));
+ syncCallInfo = syncCallInfoPckg();
+
+ ValidateMobileCallInfo(syncCallInfo);
+
+ //repeat for V3
+ RMobileCall::TMobileCallInfoV3 syncCallInfoV3;
+ RMobileCall::TMobileCallInfoV3Pckg syncCallInfoPckgV3(syncCallInfoV3);
+
+ TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV3));
+ ValidateMobileCallInfo(syncCallInfoV3);
+
+ TEST(syncCallInfoV3.iSecurity == DMMTSY_CALL_SECURITY);
+
+ //repeat for V7
+ RMobileCall::TMobileCallInfoV7 syncCallInfoV7;
+ RMobileCall::TMobileCallInfoV7Pckg syncCallInfoPckgV7(syncCallInfoV7);
+ TEST(syncCallInfoV7.ExtensionId() == KEtelExtMultimodeV7);
+
+ TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV7));
+ ValidateMobileCallInfo(syncCallInfoV7);
+
+ TEST(syncCallInfoV7.iSecurity == DMMTSY_CALL_SECURITY);
+ TEST(syncCallInfoV7.iCallParamOrigin == DMMTSY_CALL_ORIGIN);
+ TEST(syncCallInfoV7.iIconId.iQualifier == DMMTSY_CALL_ICON_ID_QUALIFIER);
+ TEST(syncCallInfoV7.iIconId.iIdentifier == DMMTSY_CALL_ICON_ID_IDENTIFIER);
+ TEST(syncCallInfoV7.iAlphaId == DMMTSY_CALL_ALPHA_ID);
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallInfo (sync) passed"), iTestCount++);
+
+ //repeat for V8
+ RMobileCall::TMobileCallInfoV8 syncCallInfoV8;
+ RMobileCall::TMobileCallInfoV8Pckg syncCallInfoPckgV8(syncCallInfoV8);
+ TEST(syncCallInfoV8.ExtensionId() == KEtelExtMultimodeV8);
+ TEST(syncCallInfoV8.iBCRepeatIndicator == RMobileCall::EBCAlternateMode);
+
+ TEST(KErrNone==mmCall.GetMobileCallInfo(syncCallInfoPckgV8));
+ ValidateMobileCallInfo(syncCallInfoV8);
+
+ TEST(syncCallInfoV8.iSubAddress == DMMTSY_CALL_SUBADDRESS);
+ TEST(syncCallInfoV8.iBearerCap1 == DMMTSY_CALL_BEARER_CAP1);
+ TEST(syncCallInfoV8.iBearerCap2 == DMMTSY_CALL_BEARER_CAP2);
+ TEST(syncCallInfoV8.iBCRepeatIndicator == DMMTSY_CALL_BC_REPEAT_INDICATOR);
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetMobileCallInfo (sync) passed"), iTestCount++);
+
+
+ // Close Call
+ mmCall.Close();
+ mmLine.Close();
+ mmPhone.Close();
+ INFO_PRINTF1(_L(""));
+
+ return TestStepResult();
+ }
+
+CTestCallc::CTestCallc()
+/** 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-3rd-part"));
+ }
+
+enum TVerdict CTestCallc::doTestStepL()
+//
+// Test Call Functions
+//
+ {
+ iTestCount =1;
+ INFO_PRINTF1(_L(""));
+ INFO_PRINTF1(_L("Test Mobile Call Functionality"));
+// LOGTEXT(_L8("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)
+
+ // Provide stndard 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;
+
+ // Notify Call Event
+
+
+ //test.next(_L("OK: RMobileCall's MobileCallControl"));
+
+ // Notify Remote Party Info change
+
+ RMobileCall::TMobileCallRemotePartyInfoV1 remoteParty;
+ RMobileCall::TMobileCallRemotePartyInfoV1Pckg remotePartyPckg(remoteParty);
+
+ // asynchronous
+
+ mmCall.NotifyRemotePartyInfoChange(reqStatus, remotePartyPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ remoteParty=remotePartyPckg();
+ ValidateRemotePartyInfoChange(remoteParty);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyRemotePartyInfoChange(reqStatus, remotePartyPckg);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyRemotePartyInfoChange);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyRemotePartyInfoChange (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ remoteParty=remotePartyPckg();
+ ValidateRemotePartyInfoChange(remoteParty);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyRemotePartyInfoChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ //test.next(_L("OK: RMobileCall's MobileCallInformation"));
+
+ // Test Privacy functional unit
+
+ RMobilePhone::TMobilePhonePrivacy asyncPrivacy;
+
+ // Test Set Privacy Privacy
+
+ TEST(mmCall.SetPrivacy(DMMTSY_CALL_SET_PRIVACY) == KErrNone);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SetPrivacy (sync) passed"), iTestCount++);
+
+ // Test Notify Privacy Confirmation
+
+ // asynchronous
+
+ mmCall.NotifyPrivacyConfirmation(reqStatus, asyncPrivacy);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int() == KErrNone);
+ TEST(asyncPrivacy == DMMTSY_CALL_SET_PRIVACY);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyPrivacyConfirmation(reqStatus, asyncPrivacy);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyPrivacyConfirmation);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int() == KErrNone || reqStatus.Int() == KErrCancel);
+ if (reqStatus.Int() == KErrNone)
+ {
+ TEST(asyncPrivacy == DMMTSY_CALL_SET_PRIVACY);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyPrivacyConfirmation (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyPrivacyConfirmation (async & cancel (Cancelled Request)) passed"), iTestCount++);
+
+ //test.next(_L("OK: RMobileCall's Privacy Settings OK"));
+
+
+ // Test Set Traffic Channel Setting
+
+ TEST(mmCall.SetTrafficChannel(DMMTSY_CALL_TCH_REQUEST) == KErrNone);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SetTrafficChannelSetting (sync) passed"), iTestCount++);
+
+ // Test Notify Traffic Channel Confirmation
+
+ // asynchronous
+
+ RMobileCall::TMobileCallTch asyncTCHType;
+
+ mmCall.NotifyTrafficChannelConfirmation(reqStatus, asyncTCHType);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int() == KErrNone);
+ TEST(asyncTCHType == DMMTSY_CALL_TCH_SETTING);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyTrafficChannelConfirmation(reqStatus, asyncTCHType);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyTrafficChannelConfirmation);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int() == KErrNone || reqStatus.Int() == KErrCancel);
+ if (reqStatus.Int() == KErrNone)
+ {
+ TEST(asyncTCHType == DMMTSY_CALL_TCH_SETTING);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyTrafficChannelConfirmation (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyTrafficChannelConfirmation (async & cancel (Cancelled Request)) passed"), iTestCount++);
+
+ //test.next(_L("OK: RMobileCall's Traffic Channel OK"));
+
+ // asynchronous
+ // If this test fails, ensure that the lines:
+ // etel_KPriorityClientSid 0x10281806
+ // etel_KLocationServicesNetworkGatewaySid 0x10281806
+ // are present in \epoc32\data\epoc.ini
+
+ TBuf<RMobileENStore::KEmergencyNumberSize> aNumber(DMMTSY_EN_STORE_AMBULANCE_NUM);
+ mmCall.DialEmergencyCall(reqStatus, aNumber);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.DialEmergencyCall(reqStatus, aNumber);
+ mmCall.CancelAsyncRequest(EMobileCallDialEmergencyCall);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::DialEmergencyCall (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::DialEmergencyCall (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ //test.next(_L("OK: RMobileCall's MobileCallEmergency"));
+
+ // Test ActivateCCBS
+
+ // asynchronous
+
+ TInt index;
+ mmCall.ActivateCCBS(reqStatus, index);
+
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.ActivateCCBS(reqStatus, index=0);
+ mmCall.CancelAsyncRequest(EMobileCallActivateCCBS);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ActivateCCBS (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ActivateCCBS (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+
+ // Test RejectCCBS
+
+ TEST(mmCall.RejectCCBS() == KErrNone);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::RejectCCBS (sync) passed"), iTestCount++);
+
+
+
+ // Test Get UUS Caps
+
+ TUint32 uusCaps;
+
+ mmCall.GetUUSCaps(uusCaps);
+ TEST(mmCall.GetUUSCaps(uusCaps) == KErrNone);
+ TEST(uusCaps == DMMTSY_CALL_UUS_CAPS);
+
+ INFO_PRINTF2(_L("Test %d - RMobileCall::GetUUSCaps (sync) passed"), iTestCount++);
+
+ // Test Notify UUS Caps Change
+
+ // asynchronous
+
+ mmCall.NotifyUUSCapsChange(reqStatus, uusCaps);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.NotifyUUSCapsChange(reqStatus, uusCaps);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyUUSCapsChange);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyUUSCapsChange (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(uusCaps == DMMTSY_CALL_UUS_CAPS);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::NotifyUUSCapsChange (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Test Dial With UUI
+ // by passing UUI info into the Dial request
+
+ // Using multimode call parameters - mmCallParams2 & number
+
+ RMobileCall::TMobileCallUUSRequestV1 uusRequest;
+
+ uusRequest.iServiceReq = DMMTSY_CALL_UUI_SERVICE_REQ;
+ uusRequest.iUUI= DMMTSY_CALL_UUI_INFO_DIAL;
+
+ RMobileCall::TMobileCallUUSRequestV1Pckg uusRequestPckg(uusRequest);
+
+ // Test Activate UUS
+
+ // asynchronous
+
+ mmCall.ActivateUUS(reqStatus,uusRequestPckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.ActivateUUS(reqStatus,uusRequestPckg);
+ mmCall.CancelAsyncRequest(EMobileCallActivateUUS);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ActivateUUS (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ActivateUUS (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ RMobileCall::TMobileCallUUI uuiAnswerInfo(DMMTSY_CALL_UUI_INFO_ANSWER);
+
+ // Test AnswerIncomingCallWithUUI
+
+ 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;
+
+ mmCall.AnswerIncomingCallWithUUI(reqStatus, mmCallParamsPckg, uuiAnswerInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ mmCall.AnswerIncomingCallWithUUI(reqStatus, mmCallParamsPckg, uuiAnswerInfo);
+ mmCall.CancelAsyncRequest(EMobileCallAnswerWithUUI);
+ User::WaitForRequest(reqStatus);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerIncomingCallWithUUI (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerIncomingCallWithUUI (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Test Send UUI
+
+ // asynchronous
+ RMobileCall::TMobileCallUUI uuiInfo(DMMTSY_CALL_UUI_INFO);
+
+ mmCall.SendUUI(reqStatus, DMMTSY_CALL_UUI_MORE_INFO, uuiInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.SendUUI(reqStatus, DMMTSY_CALL_UUI_MORE_INFO, uuiInfo);
+ mmCall.CancelAsyncRequest(EMobileCallSendUUI);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SendUUI (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::SendUUI (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Test Receive UUI
+
+ RMobileCall::TMobileCallUUI uui;
+
+ // asynchronous
+
+ mmCall.ReceiveUUI(reqStatus, uui);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(uui.Compare(DMMTSY_CALL_UUI_INFO) == 0);
+
+ // asynchronous & cancel
+
+ mmCall.ReceiveUUI(reqStatus, uui);
+ mmCall.CancelAsyncRequest(EMobileCallReceiveUUI);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ReceiveUUI (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ {
+ TEST(uui.Compare(DMMTSY_CALL_UUI_INFO) != 0);
+ INFO_PRINTF2(_L("Test %d - RMobileCall::ReceiveUUI (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+ }
+
+ // Test HangUp With UUI
+
+ // asynchronous
+
+ TBuf<RMobileCall::KMaxUUISize> uuiHangupInfo(DMMTSY_CALL_UUI_INFO_HANGUP);
+
+ mmCall.HangupWithUUI(reqStatus, uuiHangupInfo);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ // asynchronous & cancel
+
+ mmCall.HangupWithUUI(reqStatus, uuiHangupInfo);
+ mmCall.CancelAsyncRequest(EMobileCallHangupWithUUI);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::HangupWithUUI (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::HangupWithUUI (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ //test.next(_L("OK: RMobileCall's MobileCallUUI"));
+
+ // Test AnswerMultimediaCallAsVoice
+ TName aName ;
+ // asynchronous
+
+ mmCall.AnswerMultimediaCallAsVoice(reqStatus, mmCallParamsPckg, aName);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(aName.Compare(DMMTSY_LINE_VOICE_NAME)==0);
+
+ // asynchronous & cancel
+
+ mmCall.AnswerMultimediaCallAsVoice(reqStatus,mmCallParamsPckg,aName);
+ mmCall.CancelAsyncRequest(EMobileCallAnswerMultimediaCallAsVoice);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerMultimediaCallAsVoice (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerMultimediaCallAsVoice (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ //test.next(_L("OK: RMobileCall's AnswerMultimediaCallAsVoice"));
+
+ // Test notification of audio tones
+ RMobileCall::TAudioToneV3 audioToneV3;
+ RMobileCall::TAudioToneV3Pckg audioToneV3Pckg(audioToneV3);
+
+ //asynchronous start notification
+ mmCall.NotifyAudioToneEvent(reqStatus, audioToneV3Pckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(audioToneV3.iEvent == DMMTSY_AUDIO_START_TONE);
+ TEST(audioToneV3.iTone == DMMTSY_AUDIO_CONGESTION_TONE);
+ TEST(audioToneV3.iPlayedLocally = DMMTSY_AUDIO_PLAYED_LOCALLY);
+
+ //asynchronous stop notification
+ mmCall.NotifyAudioToneEvent(reqStatus, audioToneV3Pckg);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+ TEST(audioToneV3.iEvent == DMMTSY_AUDIO_STOP_TONE);
+ TEST(audioToneV3.iTone == DMMTSY_AUDIO_NO_TONE);
+ TEST(audioToneV3.iPlayedLocally = DMMTSY_AUDIO_PLAYED_LOCALLY);
+
+ //asynchronous & cancel
+ mmCall.NotifyAudioToneEvent(reqStatus, audioToneV3Pckg);
+ mmCall.CancelAsyncRequest(EMobileCallNotifyAudioToneEvent);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+ if (reqStatus.Int()==KErrCancel)
+ INFO_PRINTF2(_L("Test %d - RMobileCall::EMobileCallNotifyAudioToneEvent (async & cancel (Cancelled Request)) passed"), iTestCount++);
+ else
+ INFO_PRINTF2(_L("Test %d - RMobileCall::EMobileCallNotifyAudioToneEvent (async & cancel (Request Not Cancelled)) passed"), iTestCount++);
+
+ // Close Call
+ mmCall.Close();
+ mmLine.Close();
+ mmPhone.Close();
+ INFO_PRINTF1(_L(""));
+
+ return TestStepResult();
+ }
+
+
+CTestCallISV::CTestCallISV()
+/** 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-ISV"));
+ }
+
+
+enum TVerdict CTestCallISV::doTestStepL()
+//
+// Test Call Functions
+//
+ {
+ iTestCount =1;
+ INFO_PRINTF1(_L(""));
+ INFO_PRINTF1(_L("Test Mobile Call Functionality - ISV"));
+
+ // Set up parameters for the call
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1 callParams1;
+ callParams1.iIdRestrict = DMMTSY_CALL_CLI_RESTRICT_SETTING1;
+ callParams1.iAutoRedial = DMMTSY_CALL_AUTO_REDIAL_FLAG;
+ RMobileCall::TEtel3rdPartyMobileCallParamsV1Pckg callParamsPckg1(callParams1);
+ TBuf<RMobilePhone::KMaxMobileTelNumberSize> telNumber(DMMTSY_PHONE_TEL_NUMBER);
+
+ 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 Dial ISV functionality
+ mmCall.DialISV(reqStatus, callParamsPckg1, telNumber);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ if (reqStatus.Int()==KErrNone)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall::DialISV passed"), iTestCount++);
+ }
+
+ // Test Dial ISV Cancel functionality
+ mmCall.DialISV(reqStatus, callParamsPckg1, telNumber);
+ // Attempt to cancel call immediately.
+ mmCall.CancelAsyncRequest(EMobileCallDialISV);
+
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+
+ if (reqStatus.Int()==KErrCancel)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall::DialISV Cancel Request passed"), iTestCount++);
+ }
+ else
+ {
+ if (reqStatus.Int()==KErrNone)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall::DialISV - Request Not Cancelled "), iTestCount++);
+ }
+ }
+
+
+ // Answer incoming call
+ mmCall.AnswerIncomingCallISV(reqStatus, callParamsPckg1);
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone);
+
+ if (reqStatus.Int()==KErrNone)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerIncomingCallISV passed"), iTestCount++);
+ }
+
+ // Test Answer Incoming ISV Cancel functionality
+ mmCall.AnswerIncomingCallISV(reqStatus, callParamsPckg1);
+ // Attempt to cancel call immediately.
+ mmCall.CancelAsyncRequest(EMobileCallAnswerISV);
+
+ User::WaitForRequest(reqStatus);
+ TEST(reqStatus.Int()==KErrNone || reqStatus.Int()==KErrCancel);
+
+ if (reqStatus.Int()==KErrCancel)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall::AnswerIncomingCallISV Cancel Request passed"), iTestCount++);
+ }
+ else
+ {
+ if (reqStatus.Int()==KErrNone)
+ {
+ INFO_PRINTF2(_L("Test %d - RMobileCall:: AnswerIncomingCallISV - Request Not Cancelled "), iTestCount++);
+ }
+ }
+
+
+ // Close Call
+ mmCall.Close();
+ mmLine.Close();
+ mmPhone.Close();
+ INFO_PRINTF1(_L(""));
+
+
+ return TestStepResult();
+ }
+
+
+void CTestCallc::ValidateRemotePartyInfoChange(const RMobileCall::TMobileCallRemotePartyInfoV1 &aRemoteParty)
+ {
+ TEST(aRemoteParty.iRemoteIdStatus==DMMTSY_CALL_REMOTEPARTYSTATUS2);
+ TEST(aRemoteParty.iRemoteNumber.iTelNumber.Compare(DMMTSY_CALL_EMPTY_STRING)==0);
+ TEST(aRemoteParty.iDirection==DMMTSY_CALL_REMOTEPARTYDIRECTION2);
+ TEST(aRemoteParty.iCallingName.Compare(DMMTSY_CALL_EMPTY_STRING)==0);
+ }
+
+void CTestCallb::ValidateMobileCallInfo(const RMobileCall::TMobileCallInfoV1 &aSyncCallInfo)
+ {
+ TEST(aSyncCallInfo.iCallName.Compare(DMMTSY_CALL_NAME1)==0);
+ TEST(aSyncCallInfo.iLineName.Compare(DMMTSY_LINE_VOICE_NAME)==0);
+ TEST(aSyncCallInfo.iService==DMMTSY_CALL_SERVICE);
+ TEST(aSyncCallInfo.iStatus==DMMTSY_CALL_STATUS4);
+ TEST(aSyncCallInfo.iValid==DMMTSY_CALL_VALID_FLAG);
+ TEST(aSyncCallInfo.iDuration.Int()==DMMTSY_CALL_DURATION1);
+ TEST(aSyncCallInfo.iCallId==DMMTSY_CALL_ID1);
+ TEST(aSyncCallInfo.iRemoteParty.iRemoteIdStatus==DMMTSY_CALL_REMOTEPARTYSTATUS1);
+ TEST(aSyncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Compare(DMMTSY_CALL_REMOTEPARTYNUMBER1)==0);
+ TEST(aSyncCallInfo.iRemoteParty.iDirection==DMMTSY_CALL_REMOTEPARTYDIRECTION1);
+ TEST(aSyncCallInfo.iRemoteParty.iCallingName.Compare(DMMTSY_CALL_REMOTEPARTYNAME)==0);
+ TEST(aSyncCallInfo.iExitCode==DMMTSY_CALL_EXIT_CODE);
+ TEST(aSyncCallInfo.iEmergency==DMMTSY_CALL_EMERGENCY_FLAG);
+ TEST(aSyncCallInfo.iForwarded==DMMTSY_CALL_FORWARDED_FLAG);
+ TEST(aSyncCallInfo.iPrivacy==DMMTSY_CALL_PRIVACY);
+ TEST(aSyncCallInfo.iTch==DMMTSY_CALL_CHANNEL);
+ TEST(aSyncCallInfo.iAlternatingCall==DMMTSY_CALL_ALTERNATING);
+ TEST(aSyncCallInfo.iStartTime.Year() == DMMTSY_PHONE_NWTINFO_YEAR);
+ TEST(aSyncCallInfo.iStartTime.Month() == DMMTSY_PHONE_NWTINFO_MONTH);
+ TEST(aSyncCallInfo.iStartTime.Day() == DMMTSY_PHONE_NWTINFO_DAY);
+ TEST(aSyncCallInfo.iStartTime.Hour() == DMMTSY_PHONE_NWTINFO_HOUR);
+ TEST(aSyncCallInfo.iStartTime.Minute() == DMMTSY_PHONE_NWTINFO_MINUTE);
+ TEST(aSyncCallInfo.iStartTime.Second() == DMMTSY_PHONE_NWTINFO_SECOND);
+ TEST(aSyncCallInfo.iStartTime.MicroSecond() == DMMTSY_PHONE_NWTINFO_MICRO);
+ }
+
+void CTestCall::ValidateCallDataCaps(const RMobileCall::TMobileCallDataCapsV1 &aDataCaps)
+ {
+ TEST(aDataCaps.iSpeedCaps == DMMTSY_CALL_DATA_CAPS_SPEED);
+ TEST(aDataCaps.iProtocolCaps == DMMTSY_CALL_DATA_CAPS_CARRIER);
+ TEST(aDataCaps.iServiceCaps == DMMTSY_CALL_DATA_CAPS_SERVICE);
+ TEST(aDataCaps.iHscsdSupport == DMMTSY_CALL_DATA_CAPS_HSCSD);
+ TEST(aDataCaps.iMClass == DMMTSY_CALL_DATA_CAPS_MCLASS);
+ TEST(aDataCaps.iMaxRxTimeSlots == DMMTSY_CALL_DATA_CAPS_MAXRXTS);
+ TEST(aDataCaps.iMaxTxTimeSlots == DMMTSY_CALL_DATA_CAPS_MAXTXTS);
+ TEST(aDataCaps.iTotalRxTxTimeSlots == DMMTSY_CALL_DATA_CAPS_TOTRXTXTS);
+ TEST(aDataCaps.iCodingCaps == DMMTSY_CALL_DATA_CAPS_CODING);
+ TEST(aDataCaps.iAsymmetryCaps == DMMTSY_CALL_DATA_CAPS_ASYMETRY);
+ TEST(aDataCaps.iUserInitUpgrade == DMMTSY_CALL_DATA_CAPS_USERIMI);
+ }
+
+void CTestCall::ValidateRLPRange(const RMobileCall::TMobileDataRLPRangesV1 &aRLPRanges)
+ {
+ TEST(aRLPRanges.iIWSMax == DMMTSY_CALL_DATA_RLP_WSMAX);
+ TEST(aRLPRanges.iIWSMin == DMMTSY_CALL_DATA_RLP_WSMIN);
+ TEST(aRLPRanges.iMWSMax == DMMTSY_CALL_DATA_RLP_MWSMAX);
+ TEST(aRLPRanges.iMWSMin == DMMTSY_CALL_DATA_RLP_MWSMIN);
+ TEST(aRLPRanges.iN2Max == DMMTSY_CALL_DATA_RLP_N2MAX);
+ TEST(aRLPRanges.iN2Min == DMMTSY_CALL_DATA_RLP_N2MIN);
+ TEST(aRLPRanges.iT1Max == DMMTSY_CALL_DATA_RLP_T1MAX);
+ TEST(aRLPRanges.iT1Min == DMMTSY_CALL_DATA_RLP_T1MIN);
+ TEST(aRLPRanges.iT4Max == DMMTSY_CALL_DATA_RLP_T4MAX);
+ TEST(aRLPRanges.iT4Min == DMMTSY_CALL_DATA_RLP_T4MIN);
+ }
+
+void CTestCall::ValidateHscsdParams(const RMobileCall::TMobileHscsdCallParamsV1& aHcsdParams)
+ {
+ TEST(aHcsdParams.iWantedAiur == DMMTSY_CALL_HCSD_AIUR);
+ TEST(aHcsdParams.iWantedRxTimeSlots == DMMTSY_CALL_HCSD_TS);
+ TEST(aHcsdParams.iMaxTimeSlots == DMMTSY_CALL_HCSD_MAXTS);
+ TEST(aHcsdParams.iCodings == DMMTSY_CALL_HCSD_CODING);
+ TEST(aHcsdParams.iAsymmetry == DMMTSY_CALL_HCSD_ASYMMETRY);
+ TEST(aHcsdParams.iUserInitUpgrade == DMMTSY_CALL_HCSD_USER_IMI);
+ }
+
+void CTestCall::ValidateHscsdInfo(const RMobileCall::TMobileCallHscsdInfoV1& aHcsdInfo)
+ {
+ TEST(aHcsdInfo.iAiur == DMMTSY_CALL_HCSD_AIUR);
+ TEST(aHcsdInfo.iRxTimeSlots == DMMTSY_CALL_HCSD_TS);
+ TEST(aHcsdInfo.iTxTimeSlots == DMMTSY_CALL_HCSD_TS);
+ TEST(aHcsdInfo.iCodings == DMMTSY_CALL_HCSD_CODING);
+ }
+
+