--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/common_tsy/test/integration/src/cctsyintegrationtestdtmf.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1887 @@
+// 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:
+// Test step definitions for the DTMF functional unit.
+//
+//
+
+/**
+ @internalTechnology
+*/
+
+#include "cctsyintegrationtestdtmf.h"
+
+#include "cctsyinidata.h"
+
+
+
+
+CCTSYIntegrationTestDTMFBase::CCTSYIntegrationTestDTMFBase(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iCallControlTestHelper(*this), iNetworkTestHelper(*this)
+/**
+ * Constructor
+ */
+ {
+ }
+
+CCTSYIntegrationTestDTMFBase::~CCTSYIntegrationTestDTMFBase()
+/*
+ * Destructor
+ */
+ {
+ }
+
+CCTSYIntegrationTestDTMF0001::CCTSYIntegrationTestDTMF0001(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0001::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0001::~CCTSYIntegrationTestDTMF0001()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0001::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0001
+ * @SYMFssID BA/CTSY/DTMF-0001
+ * @SYMTestCaseDesc Get DTMF caps.
+ * @SYMTestPriority High
+ * @SYMTestActions RCall::Dial, RCall::HangUp, RMobilePhone::NotifyDTMFCapsChange, RMobilePhone::SetAlternatingCallMode
+ * @SYMTestExpectedResults Pass - DTMF caps set when call is active. DTMF caps are 0 when call is not active.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify dynamic DTMF caps set correctly.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get voice line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer,KMainPhone, KVoiceLine, KCall1);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Post notification RMobilePhone::NotifyDTMFCapsChange
+ TUint32 caps = 0;
+ TExtEtelRequestStatus notifyDTMFCapsChangeStatus(mobilePhone, EMobilePhoneNotifyDTMFCapsChange);
+ CleanupStack::PushL(notifyDTMFCapsChangeStatus);
+ mobilePhone.NotifyDTMFCapsChange(notifyDTMFCapsChangeStatus,caps);
+
+ // Dial a Phone Number
+ TPtrC number;
+ ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF1(_L("Board Now Dialling: "));
+ TCoreEtelRequestStatus<RCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RCall::Dial returned with an error"));
+
+ // Check RMobilePhone::NotifyDTMFCapsChange completes with caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 wantedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ iCallControlTestHelper.WaitForMobilePhoneNotifyDTMFCapsChange(mobilePhone,
+ notifyDTMFCapsChangeStatus,
+ caps,
+ wantedCaps,
+ KNoUnwantedBits,
+ KErrNone);
+
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(caps), KErrNone,_L("RMobilePhone::GetDTMFCaps returned with an error"))
+ ASSERT_BITS_SET(caps, wantedCaps, KNoUnwantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"))
+
+ // Post notifer
+ mobilePhone.NotifyDTMFCapsChange(notifyDTMFCapsChangeStatus,caps);
+
+ // Hang up call.
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone,_L("RMobileCall::HangUp returned with an error"))
+
+ // Check RMobilePhone::NotifyDTMFCapsChange completes with caps of 0
+ wantedCaps=0;
+ iCallControlTestHelper.WaitForMobilePhoneNotifyDTMFCapsChange(mobilePhone,
+ notifyDTMFCapsChangeStatus,
+ caps,
+ wantedCaps,
+ KNoUnwantedBits,
+ KErrNone);
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of 0
+ wantedCaps = 0;
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(caps), KErrNone,_L("RMobilePhone::GetDTMFCaps returned with an error"))
+ ASSERT_BITS_SET(caps, wantedCaps, KNoUnwantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"))
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ // Pop
+ // notifyDTMFCapsChangeStatus
+ // dialStatus
+ CleanupStack::PopAndDestroy(2,¬ifyDTMFCapsChangeStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0001::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0001");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0002::CCTSYIntegrationTestDTMF0002(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0002::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0002::~CCTSYIntegrationTestDTMF0002()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0002::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0002
+ * @SYMFssID BA/CTSY/DTMF-0002
+ * @SYMTestCaseDesc Send valid DTMF digits and strings.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::StopDTMFTone, RMobilePhone::SendDTMFTones, RMobilePhone::ContinueDTMFStringSending
+ * @SYMTestExpectedResults Pass - DTMF tones can be sent individually and as a string.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify single tones and strings can be sent.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_TRUE_L(mobilePhone.GetDTMFCaps(dtmfCaps)==KErrNone, _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ CHECK_BITS_SET_L(dtmfCaps, expectedCaps, KNoUnwantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // === Send DTMF tones individually. Do the following with aTone = 0-9, A,B,C,D, #,*, p, w in turn. ===
+ TChar tone[18] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','A' ,'B' ,'C' ,'D' ,'#' ,'*', 'p', 'w'};
+
+ for(TInt i = 0 ; i<16; i++)
+ {
+ DEBUG_PRINTF2(_L("Send DTMF tones: %c"), (char)tone[i]);
+
+ // Use RMobilePhone::StartDTMFTone to start sending a DTMF tone.
+ ASSERT_EQUALS(mobilePhone.StartDTMFTone(tone[i]), KErrNone, _L("RMobilePhone::StartDTMFTone completed with incorrect error"));
+
+ // Wait for one second
+ User::After(KOneSecond);
+
+ // Use RMobilePhone::StopDTMFTone to stop sending.
+ ASSERT_EQUALS(mobilePhone.StopDTMFTone(), KErrNone, _L("RMobilePhone::StopDTMFTone completed with incorrect error"));
+
+ // Repeat the above with other valid digits.
+ }
+
+ // Wait for 5 seconds
+ User::After(5*KOneSecond);
+
+ // === Send DTMF string with no 'w' character ===
+
+ // Send DTMF tones
+ TExtEtelRequestStatus sendDtmfTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDtmfTonesStatus);
+
+ TBufC<50> toneSet1 = _L("0123456p789ABCD");
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet1);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+
+ //Check request completes with KErrNone each time.
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+
+ // === Send DTMF string with 'w' character and continue sending (then repeat and not continue sending after the stop) ===
+
+ // Post notification for RMobilePhone::NotifyStopInDTMFString
+ TExtEtelRequestStatus notifyStopStatus(mobilePhone, EMobilePhoneNotifyStopInDTMFString);
+ CleanupStack::PushL(notifyStopStatus);
+ mobilePhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ // Send a DTMF string "1234w567"
+ TBufC<50> toneSet2 = _L("1234w567");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet2);
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet2);
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopStatus, KErrNone);
+
+ // Continue sending the string with RMobilePhone::ContinueDTMFStringSending with aContinue = ETrue
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(ETrue), KErrNone, _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones sendDtmfTonesStatus is not KErrNone."));
+
+ // Check request completes with KErrNone
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones sendDtmfTonesStatus completed with incorrect error"));
+
+
+ // Hang up the call
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(¬ifyStopStatus);
+ CleanupStack::PopAndDestroy(&sendDtmfTonesStatus);
+ CleanupStack::PopAndDestroy(&dialStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0002::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0002");
+ }
+
+CCTSYIntegrationTestDTMF0003::CCTSYIntegrationTestDTMF0003(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0003::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0003::~CCTSYIntegrationTestDTMF0003()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0003::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0003
+ * @SYMFssID BA/CTSY/DTMF-0003
+ * @SYMTestCaseDesc Send DTMF strings containing 'p' and 'w'
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::ContinueDTMFStringSending, RMobilePhone::NotifyStopInDTMFString
+ * @SYMTestExpectedResults Pass - Notification of a pause in DTMF received.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify DTMF stop notifications are received.
+ *
+ * @return - TVerdict code
+ */
+ {
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,
+ _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_EQUALS_L(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,
+ _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ TUint32 unwantedCaps = KNoWantedBits;
+ CHECK_BITS_SET_L(dtmfCaps, expectedCaps, unwantedCaps,
+ _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Request for notification of RMobilePhone::NotifyStopInDTMFString
+ TExtEtelRequestStatus notifyStopInDTMFStringStatus(mobilePhone, EMobilePhoneNotifyStopInDTMFString);
+ CleanupStack::PushL(notifyStopInDTMFStringStatus);
+ mobilePhone.NotifyStopInDTMFString(notifyStopInDTMFStringStatus);
+
+ // === Send DTMF string that contains digits only and check that ===
+
+ // Send DTMF tones with RMobilePhone::SendDTMFTones with aTones = "1234567890"
+ TBufC<50> toneDigitSet = _L("1234567890");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneDigitSet);
+ TExtEtelRequestStatus sendDTMFTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDTMFTonesStatus);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneDigitSet);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones status is not KErrNone"));
+
+ // === RMobilePhone::NotifyStopInDTMFString is still pending ===
+ ASSERT_EQUALS(notifyStopInDTMFStringStatus.Int(), KRequestPending,
+ _L("RMobilePhone::NotifyStopInDTMFString status is not KRequestPending"));
+
+ // *** Note: expecting NotifyStopInDTMFString to still be active from previous post
+
+ // === Send DTMF string with a pause and check that ===
+
+ // Send DTMF tones with RMobilePhone::SendDTMFTones with aTones = "12345p67890"
+ TBufC<50> toneDigitSet2 = _L("12345p67890");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneDigitSet2);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneDigitSet2);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones status is not KErrNone"));
+
+ // Check RMobilePhone::NotifyStopInDTMFString is still KRequestPending
+ ASSERT_EQUALS(notifyStopInDTMFStringStatus.Int(), KRequestPending,
+ _L("RMobilePhone::NotifyStopInDTMFString status is not KRequestPending"));
+
+ // Send DTMF tones with RMobilePhone::SendDTMFTones with aTones = "12345w67890"
+
+ // === Send DTMF string with a stop and check that ===
+ TBufC<50> toneDigitSet3 = _L("12345w67890");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneDigitSet3);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneDigitSet3);
+
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopInDTMFStringStatus, KErrNone);
+
+ // Complete the send
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(ETrue), KErrNone,
+ _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones status is not KErrNone"));
+
+ // Hang-up call
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(3, &dialStatus);
+ // sendDTMFTonesStatus
+ // notifyStopInDTMFStringStatus
+ // dialStatus
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0003::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0003");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0004::CCTSYIntegrationTestDTMF0004(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0004::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0004::~CCTSYIntegrationTestDTMF0004()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0004::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0004
+ * @SYMFssID BA/CTSY/DTMF-0004
+ * @SYMTestCaseDesc Send an invalid DTMF tone.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::StartDTMFTone
+ * @SYMTestExpectedResults Pass - Error from baseband / dispatch layer when sending an invalid tone.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify error is returned on attempt to send invalid tone.
+ *
+ * @return - TVerdict code
+ *
+ * $CTSYProblem - The invalid tone is sent to CTSY. CTSY simply passes it down to the LTSY.
+ * The LTSY is returning KErrNone, and CTSY is propogating the error back up to Etel.
+ */
+ {
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,
+ _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_EQUALS_L(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,
+ _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ TUint32 unwantedCaps = KNoWantedBits;
+ ASSERT_BITS_SET(dtmfCaps, expectedCaps, unwantedCaps,
+ _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // === Attempt to send a single but invalid tone ===
+
+ // Use RMobilePhone::StartDTMFTone to send an invalid tone character.
+
+ TChar invalidchar = 'Z';
+
+ DEBUG_PRINTF2(_L("Send invalid DTMF tones: %c"), (char)invalidchar);
+
+ ASSERT_EQUALS(mobilePhone.StartDTMFTone(invalidchar), KErrNone,
+ _L("RMobilePhone::StartDTMFTone returned with errror - not KErrNone"));
+
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(&dialStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0004::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0004");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0005::CCTSYIntegrationTestDTMF0005(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0005::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0005::~CCTSYIntegrationTestDTMF0005()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0005::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0005
+ * @SYMFssID BA/CTSY/DTMF-0005
+ * @SYMTestCaseDesc Send a string of DTMF tones contains an invalid tone.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SendDTMFTones
+ * @SYMTestExpectedResults Pass - Error from baseband / dispatch layer.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify error is returned on attempt to send DTMF string containing an invalid tone.
+ *
+ * @return - TVerdict code
+ *
+ * $CTSYProblem - LTSY is returning error code KErrGsmCCSemanticallyIncorrectMessage, and not KErrArgument
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse,
+ _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_EQUALS_L(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,
+ _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ TUint32 unwantedCaps = KNoWantedBits;
+ ASSERT_BITS_SET(dtmfCaps, expectedCaps, unwantedCaps,
+ _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // === Send some tones but containing an invalid tone character ===
+
+ // Use RMobilePhone::SendDTMFTones to send a string containing valid tones and an invalid tone
+
+ TBufC<50> toneInvalidSet = _L("0123456Q789ABCD");
+ DEBUG_PRINTF2(_L("Send invalid DTMF tones: %S"), &toneInvalidSet);
+
+ TExtEtelRequestStatus sendDTMFTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDTMFTonesStatus);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneInvalidSet);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ // Check KErrGsmCCSemanticallyIncorrectMessage is returned.
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrGsmCCSemanticallyIncorrectMessage,
+ _L("RMobilePhone::SendDTMFTones status is not KErrGsmCCSemanticallyIncorrectMessage"));
+
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(2, &dialStatus);
+ // sendDTMFTonesStatus
+ // dialStatus
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0005::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0005");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0006::CCTSYIntegrationTestDTMF0006(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0006::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0006::~CCTSYIntegrationTestDTMF0006()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0006::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0006
+ * @SYMFssID BA/CTSY/DTMF-0006
+ * @SYMTestCaseDesc Test sending DTMF digits during a video call.
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::StartDTMFTone, RMobilePhone::StopDTMFTone, RMobilePhone::SendDTMFTones, RMobilePhone::NotifyStopInDTMFString, RMobilePhone::ContinueDTMFStringSending, RCall::HangUp, RMobilePhone::GetDTMFCaps
+ * @SYMTestExpectedResults Pass - DTMF digits and strings sent.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify DTMF digits can be sent during a video call.
+ *
+ * @return - TVerdict code
+ */
+ { /*** NOTE: CODED BUT NOT TESTED ***/
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Ensure phone supports KCapsData caps.
+
+ RMobilePhone::TCaps mobilephonecaps;
+
+ CHECK_EQUALS_L(mobilePhone.GetCaps(mobilephonecaps), KErrNone, _L("RMobilePhone::GetCaps"));
+ TUint32 expectedmobilephoneCaps = RMobilePhone::KCapsData | RMobilePhone::KCapsVoice;
+ TUint32 unwantedmobilephoneCaps = KNoUnwantedBits;
+ ASSERT_BITS_SET(mobilephonecaps.iFlags, expectedmobilephoneCaps, unwantedmobilephoneCaps,
+ _L("RMobilePhone::GetCaps returned wrong dynamic caps"));
+
+ // Get data line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KDataLine); //KDataLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KDataLine, KCall1); //KDataLine, KCall1);
+
+ TPtrC number;
+ ASSERT_TRUE(GetStringFromConfig(KIniDataNumSection, KIniDataNumber1, number) != EFalse,
+ _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+
+ RMobileCall::TMobileDataCallParamsV1 dataParams, retrieveDataParams;
+ RMobileCall::TMobileDataCallParamsV1Pckg dataParamsPckg(dataParams);
+ RMobileCall::TMobileDataCallParamsV1Pckg retrieveDataParamsPckg(retrieveDataParams);
+
+ dataParams.iService = RMobileCall::EServiceDataCircuitAsyncRdi;
+ dataParams.iSpeed = RMobileCall::ESpeed9600;
+ dataParams.iProtocol = RMobileCall::EProtocolV110;
+ dataParams.iQoS = RMobileCall::EQoSNonTransparent;
+ dataParams.iRLPVersion = RMobileCall::ERLPSingleLinkVersion1;
+ dataParams.iV42bisReq = RMobileCall::EV42bisBothDirections;
+ dataParams.iUseEdge = ETrue;
+
+ // Post RMobilePhone::NotifyDTMFCapsChange (most likely to change when the phone starts and ends voice calls,
+ // so does this also apply to a data call ?)
+
+ TUint32 completiondtmfcaps;
+ TExtEtelRequestStatus notifyDTMFCapsChangeStatus(mobilePhone, EMobilePhoneNotifyDTMFCapsChange);
+ CleanupStack::PushL(notifyDTMFCapsChangeStatus);
+ mobilePhone.NotifyDTMFCapsChange(notifyDTMFCapsChangeStatus, completiondtmfcaps);
+
+ //IMPORT_C void Dial(TRequestStatus &aStatus, const TDesC8 &aCallParams, const TTelNumberC &aTelNumber);
+ mobileCall.Dial(dialStatus, dataParamsPckg, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::NotifyDTMFCapsChange completes with caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ TUint32 unwantedCaps = KNoUnwantedBits;
+ TInt wantedStatus = KErrNone;
+ iCallControlTestHelper.WaitForMobilePhoneNotifyDTMFCapsChange(
+ mobilePhone,
+ notifyDTMFCapsChangeStatus,
+ completiondtmfcaps,
+ expectedCaps,
+ unwantedCaps,
+ wantedStatus);
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,_L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ ASSERT_BITS_SET(dtmfCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Send a valid individual DTMF digits.
+
+ TChar tone = 'A';
+ DEBUG_PRINTF2(_L("Send DTMF tones: %c"), (char)tone);
+ ASSERT_EQUALS(mobilePhone.StartDTMFTone(tone), KErrNone,
+ _L("RMobilePhone::StartDTMFTone return value is not KErrNone"));
+ User::After(KOneSecond);
+ ASSERT_EQUALS(mobilePhone.StopDTMFTone(), KErrNone,
+ _L("RMobilePhone::StopDTMFTone return value is not KErrNone"));
+
+ // Send a valid DTMF string without a stop or pause character.
+
+ TBufC<50> toneSet1 = _L("0123456789ABCD");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+ TExtEtelRequestStatus sendDtmfTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDtmfTonesStatus);
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet1);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone,
+ _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+ if(sendDtmfTonesStatus.Int() != KErrNone)
+ {
+ sendDtmfTonesStatus.Cancel();
+ }
+
+ // Send a valid DTMF string "12345p67890"
+
+ TBufC<50> toneSet2 = _L("12345p67890");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet2);
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet2);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone,
+ _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+ if(sendDtmfTonesStatus.Int() != KErrNone)
+ {
+ sendDtmfTonesStatus.Cancel();
+ }
+
+ // Send a valid DTMF string "12345w67890"
+
+ TBufC<50> toneSet3 = _L("12345w67890");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet3);
+
+ // Post notification for RMobilePhone::NotifyStopInDTMFString
+ TExtEtelRequestStatus notifyStopStatus(mobilePhone, EMobilePhoneNotifyStopInDTMFString);
+ CleanupStack::PushL(notifyStopStatus);
+ mobilePhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet3);
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopStatus, KErrNone);
+
+ // Continue sending the string with RMobilePhone::ContinueDTMFStringSending with aContinue = ETrue
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(ETrue), KErrNone,
+ _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones status is not KErrNone"));
+ if(sendDtmfTonesStatus.Int() != KErrNone)
+ {
+ sendDtmfTonesStatus.Cancel();
+ }
+
+ // Send a valid DTMF string "12345w67890" again
+ DEBUG_PRINTF2(_L("Send DTMF tones (again): %S"), &toneSet3);
+
+ // Post notification for RMobilePhone::NotifyStopInDTMFString
+ mobilePhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet3);
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopStatus, KErrNone);
+
+ // Continue sending the string with RMobilePhone::ContinueDTMFStringSending with aContinue = EFalse
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(EFalse), KErrNone,
+ _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+
+ // Check request completes with KErrNone each time.
+ // *** Does the send complete even if we requested EFalse on the ContinueDTMFStringSending ?
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone,
+ _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones status is not KErrNone"));
+ if(sendDtmfTonesStatus.Int() != KErrNone)
+ {
+ sendDtmfTonesStatus.Cancel();
+ }
+
+ // Post NotifyDTMFCapsChange
+ mobilePhone.NotifyDTMFCapsChange(notifyDTMFCapsChangeStatus, completiondtmfcaps);
+
+ // Hang up.
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp did not return with KErrNone"));
+
+ // Check RMobilePhone::NotifyDTMFCapsChange completes with caps of 0
+ expectedCaps = KNoWantedBits;
+ unwantedCaps = KNoUnwantedBits;
+ wantedStatus = KErrNone;
+ iCallControlTestHelper.WaitForMobilePhoneNotifyDTMFCapsChange(
+ mobilePhone,
+ notifyDTMFCapsChangeStatus,
+ completiondtmfcaps,
+ expectedCaps,
+ unwantedCaps,
+ wantedStatus);
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of 0
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,_L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ ASSERT_BITS_SET(dtmfCaps, expectedCaps, unwantedCaps, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(4, &dialStatus);
+ // notifyStopStatus
+ // sendDtmfTonesStatus
+ // notifyDTMFCapsChangeStatus
+ // dialStatus
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0006::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0006");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0007::CCTSYIntegrationTestDTMF0007(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0007::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0007::~CCTSYIntegrationTestDTMF0007()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0007::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0007
+ * @SYMFssID BA/CTSY/DTMF-0007
+ * @SYMTestCaseDesc Cancel the sending of DTMF Tones
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SendDTMFTones
+ * @SYMTestExpectedResults Pass - KErrCancel returned on cancellation.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify request to send DTMF tones can be cancelled.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_TRUE_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium)==KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_TRUE_L(dialStatus.Int()==KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_TRUE_L(mobilePhone.GetDTMFCaps(dtmfCaps)==KErrNone, _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ CHECK_BITS_SET_L(dtmfCaps, expectedCaps, KNoWantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Use RMobilePhone::SendDTMFTones to send a valid, long DTMF string (e.g. 20 characters)
+ TBufC<50> toneSet1 = _L("0123456789ABCD0123456789");
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+
+ TExtEtelRequestStatus sendDtmfTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDtmfTonesStatus);
+ mobilePhone.SendDTMFTones(sendDtmfTonesStatus, toneSet1);
+ User::After(KOneSecond); // wait for 1 second
+
+ // Cancel sending DTMF tones here
+ mobilePhone.CancelAsyncRequest(EMobilePhoneSendDTMFTones);
+
+ // Check request completes with KErrCancel
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDtmfTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDtmfTonesStatus.Int(), KErrCancel, _L("RMobilePhone::SendDTMFTones sendDtmfTonesStatus completed with incorrect error"));
+
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::PopAndDestroy(&sendDtmfTonesStatus);
+ CleanupStack::PopAndDestroy(&dialStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0007::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0007");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0008::CCTSYIntegrationTestDTMF0008(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0008::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0008::~CCTSYIntegrationTestDTMF0008()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0008::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0008
+ * @SYMFssID BA/CTSY/DTMF-0008
+ * @SYMTestCaseDesc Remote party terminates call during DTMF sequence
+ * @SYMTestPriority High
+ * @SYMTestActions RMobilePhone::SendDTMFTones, RCall::NotifyStatusChange, RMobileCall::NotifyCallEvent
+ * @SYMTestExpectedResults Pass - Call terminates.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/manual
+ *
+ * Reason for test: Verify client is notified of call termination.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+
+ DisplayUserInteractionPromptL(_L("To run this test correctly, you should have set your own phone number to voice number 1 in the ini file."), ETimeLong);
+
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_EQUALS_L(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,_L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ CHECK_BITS_SET_L(dtmfCaps, expectedCaps, KNoWantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Use RMobilePhone::SendDTMFTones to send a long string of tones (20 characters).
+ // Do not wait for the request to complete before continuing.
+ TExtEtelRequestStatus callEventStatus(mobileCall, EMobileCallNotifyCallEvent);
+ CleanupStack::PushL(callEventStatus);
+ RMobileCall::TMobileCallEvent mobileCallEvent;
+
+ mobileCall.NotifyCallEvent(callEventStatus, mobileCallEvent);
+
+ TCoreEtelRequestStatus<RMobileCall> mobileStatus(mobileCall, &RCall::NotifyStatusChangeCancel);
+ CleanupStack::PushL(mobileStatus);
+ RMobileCall::TStatus changedStatus;
+
+ mobileCall.NotifyStatusChange(mobileStatus, changedStatus);
+
+ // Use RMobilePhone::SendDTMFTones to send a long string of tones (20 characters).
+ TBufC<50> toneSet1 = _L("0123456789ABCD01234567890123456789ABCD0123456789");
+ TExtEtelRequestStatus sendDTMFTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDTMFTonesStatus);
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet1);
+
+ User::After(KOneSecond); // wait for 1 second
+
+ DisplayUserInteractionPromptL(_L("Hang up the call."), ETimeLong);
+
+ RMobileCall::TMobileCallEvent expectedEvent = RMobileCall::ERemoteTerminated;
+ iCallControlTestHelper.WaitForMobileCallNotifyCallEvent(mobileCall,
+ callEventStatus,
+ mobileCallEvent,
+ expectedEvent,
+ KErrNone);
+
+ // Check RCall::NotifyStatusChange completes with EStatusHangingUp.
+ RMobileCall::TStatus expectedCallStatus = RMobileCall::EStatusHangingUp;
+ iCallControlTestHelper.WaitForCallNotifyStatusChange(mobileCall,
+ mobileStatus,
+ changedStatus,
+ expectedCallStatus,
+ KErrNone);
+
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ // Pop:
+ // dialStatus
+ // callEventStatus
+ // mobileStatus
+ // sendDTMFTonesStatus
+ CleanupStack::PopAndDestroy(4, &dialStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0008::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0008");
+ }
+
+
+
+CCTSYIntegrationTestDTMF0009::CCTSYIntegrationTestDTMF0009(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0009::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0009::~CCTSYIntegrationTestDTMF0009()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0009::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0009
+ * @SYMFssID BA/CTSY/DTMF-0009
+ * @SYMTestCaseDesc Check that outgoing DTMF tones are added to dialled party details
+ * @SYMTestPriority High
+ * @SYMTestActions RMobileCall::GetMobileCallInfo, RMobilePhone::SendDTMFTones
+ * @SYMTestExpectedResults Pass - Dialled party details contains DTMF tones, remote number does not.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify remote party info contains the dialled number and the sent DTMF digits.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ // Dial a number that answers.
+ TPtrC number;
+ CHECK_TRUE_L(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ CHECK_EQUALS_L(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ CHECK_EQUALS_L(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ CHECK_EQUALS_L(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone, _L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ CHECK_BITS_SET_L(dtmfCaps, expectedCaps, KNoWantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Check RMobileCall::GetMobileCallInfo returns correct number in iRemoteParty.iRemoteNumber
+ RMobileCall::TMobileCallInfoV1 syncCallInfo;
+ RMobileCall::TMobileCallInfoV1Pckg syncCallInfoPckg(syncCallInfo);
+
+ User::After(KOneSecond*10); // Give timers enough time to increment
+ ASSERT_EQUALS(mobileCall.GetMobileCallInfo(syncCallInfoPckg), KErrNone, _L("RMobilePhone::GetMobileCallInfo has not returned KErrNone"));
+
+ DEBUG_PRINTF2(_L("syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber: \"%S\""), &syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber);
+ DEBUG_PRINTF2(_L("number: \"%S\""), &number);
+
+ ASSERT_EQUALS(syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Compare(number), 0, _L("aSyncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber is not correct"));
+
+ // Check RMobileCall::GetMobileCallInfo returns correct number in iDialledParty
+ ASSERT_EQUALS(syncCallInfo.iDialledParty.iTelNumber.Compare(number), 0, _L("syncCallInfo.iDialledParty.iTelNumber is not correct"));
+
+ // Send some valid DTMF tones.
+ TExtEtelRequestStatus sendDTMFTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDTMFTonesStatus);
+
+ TBufC<50> toneSet1 = _L("0123456789ABCD");
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet1);
+
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrNone, _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+
+ // === Check that the DTMF has been added to the dialled number details, ===
+ ASSERT_EQUALS(mobileCall.GetMobileCallInfo(syncCallInfoPckg), KErrNone, _L("RMobilePhone::GetMobileCallInfo has not returned KErrNone"));
+
+ // === but not the remote party details. ===
+
+ DEBUG_PRINTF2(_L("syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber: %S"), &syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber);
+ DEBUG_PRINTF2(_L("number: %S"), &number);
+
+ // Check RMobileCall::GetMobileCallInfo returns correct destination number without DTMF in iRemoteParty.iRemoteNumber
+ ASSERT_EQUALS(syncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber.Compare(number), 0, _L("aSyncCallInfo.iRemoteParty.iRemoteNumber.iTelNumber is not correct"));
+
+ // Check RMobileCall::GetMobileCallInfo returns dialled number and DTMF tones sent in iDialledParty
+ TBuf<50> expectedval;
+
+ expectedval.Append(number);
+ expectedval.Append(toneSet1);
+
+ DEBUG_PRINTF2(_L("syncCallInfo.iDialledParty.iTelNumber: %S"), &syncCallInfo.iDialledParty.iTelNumber);
+ DEBUG_PRINTF2(_L("expectedval: %S"), &expectedval);
+
+ ASSERT_EQUALS(syncCallInfo.iDialledParty.iTelNumber.Compare(expectedval), 0, _L("syncCallInfo.iDialledParty.iTelNumber is not correct"));
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RMobileCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ CleanupStack::Pop(&dialStatus);
+ CleanupStack::Pop(&sendDTMFTonesStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0009::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0009");
+ }
+
+CCTSYIntegrationTestDTMF0010::CCTSYIntegrationTestDTMF0010(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0010::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0010::~CCTSYIntegrationTestDTMF0010()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0010::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0010
+ * @SYMFssID BA/CTSY/DTMF-0010
+ * @SYMTestCaseDesc Receive DTMF tones.
+ * @SYMTestPriority High
+ * @SYMTestActions RCall::NotifyStatusChange, RMobilePhone::ReadDTMFTones, RCall::HangUp
+ * @SYMTestExpectedResults Pass - DTMF tones read correctly.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/manual
+ *
+ * Reason for test: Verify DTMF tones received correctly.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Ensure phone supports KCapsVoice.
+ RMobilePhone::TCaps mobilePhoneCaps;
+
+ CHECK_TRUE_L(mobilePhone.GetCaps(mobilePhoneCaps) == KErrNone, _L("RMobilePhone::GetCaps"));
+ TUint32 expectedMobilePhoneCaps = RMobilePhone::KCapsVoice;
+ CHECK_BITS_SET_L(mobilePhoneCaps.iFlags, expectedMobilePhoneCaps, KNoWantedBits, _L("RMobilePhone::GetCaps returned wrong dynamic caps"));
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Set up an incoming call.
+ TName name;
+ TCoreEtelRequestStatus<RLine> notifyIncomingStatus(mobileLine, &RLine::NotifyIncomingCallCancel);
+ CleanupStack::PushL(notifyIncomingStatus);
+ mobileLine.NotifyIncomingCall(notifyIncomingStatus, name);
+
+ RCall::TStatus toneSet;
+ TCoreEtelRequestStatus<RMobileLine> notifyStatusChangeStatus(mobileLine, &RMobileLine::NotifyStatusChangeCancel);
+ CleanupStack::PushL(notifyStatusChangeStatus);
+ mobileLine.NotifyStatusChange(notifyStatusChangeStatus, toneSet);
+
+ DisplayUserInteractionPromptL(_L("Please call me "), ETimeMedium);
+
+ // Check RLine::NotifyIncomingCall completes with valid call name.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(notifyIncomingStatus,ETimeMedium), KErrNone,
+ _L("RLine::NotifyIncomingCall did not complete without error"));
+ ASSERT_EQUALS(notifyIncomingStatus.Int(), KErrNone,
+ _L("RLine::NotifyIncomingCall set requestStatus to an error"));
+ ASSERT_TRUE(name.Length() > 0,
+ _L("RLine::NotifyIncomingCall did not set the name"));
+
+ TCallId incomingCallId;
+ RMobileCall& incomingCall = iEtelSessionMgr.GetIncomingCallL(KMainServer, KMainPhone, KVoiceLine, name, incomingCallId);
+ TCoreEtelRequestStatus<RCall> answerIncomingStatus(incomingCall, &RCall::AnswerIncomingCallCancel);
+ CleanupStack::PushL(answerIncomingStatus);
+
+
+ RCall::TStatus expectedStatusChange=RCall::EStatusRinging;
+ iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,
+ notifyStatusChangeStatus,
+ toneSet,
+ expectedStatusChange,
+ KErrNone);
+
+ mobileLine.NotifyStatusChange(notifyStatusChangeStatus, toneSet);
+
+ // Answer the incoming call.
+ incomingCall.AnswerIncomingCall(answerIncomingStatus);
+
+ // Check RCall::NotifyStatusChange completes with EStatusAnswering -> EStatusConnected.
+ expectedStatusChange=RCall::EStatusAnswering;
+ iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,
+ notifyStatusChangeStatus,
+ toneSet,
+ expectedStatusChange,
+ KErrNone);
+
+ mobileLine.NotifyStatusChange(notifyStatusChangeStatus, toneSet);
+
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(answerIncomingStatus, ETimeMedium), KErrNone, _L("RCall::AnswerIncomingCall timed-out"));
+
+ expectedStatusChange=RCall::EStatusConnected;
+ iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,
+ notifyStatusChangeStatus,
+ toneSet,
+ expectedStatusChange,
+ KErrNone);
+
+ DisplayUserInteractionPromptL(_L("Please tone 1234567890"), ETimeMedium);
+
+ // Check RMobilePhone::ReadDTMFTones completes with correct tones
+ TBuf<50> tonesrecieved;
+ tonesrecieved.Zero();
+
+ TExtEtelRequestStatus readDtmfStatus(mobilePhone, EMobilePhoneReadDTMFTones);
+ CleanupStack::PushL(readDtmfStatus);
+ mobilePhone.ReadDTMFTones(readDtmfStatus, tonesrecieved);
+
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(readDtmfStatus, ETimeMedium), KErrNone, _L("RMobilePhone::ReadDTMFTones timed-out"));
+
+ ERR_PRINTF1(_L("<font color=Orange>$CTSYProblem: case EMobilePhoneReadDTMFTones: Not supported in CTSY </font>"));
+ ASSERT_EQUALS(KErrNotSupported, readDtmfStatus.Int(), _L("RMobilePhone::ReadDTMFTones returned incorrect status."));
+ ASSERT_TRUE(tonesrecieved.Compare(_L(""))==0, _L("RMobilePhone::ReadDTMFTones wrong tone was recieved."));
+
+ // Hang up call.
+ DEBUG_PRINTF1(_L("Hangup call"));
+ ASSERT_EQUALS(mobileCall.HangUp(), KErrNone, _L("RCall::HangUp return value not KErrNone"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ // notifyIncomingStatus
+ // notifyStatusChangeStatus
+ // answerIncomingStatus
+ // readDtmfStatus
+ CleanupStack::PopAndDestroy(4,¬ifyIncomingStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0010::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0010");
+ }
+
+CCTSYIntegrationTestDTMF0011::CCTSYIntegrationTestDTMF0011(CEtelSessionMgr& aEtelSessionMgr)
+ : CCTSYIntegrationTestDTMFBase(aEtelSessionMgr)
+/**
+ * Constructor.
+ */
+ {
+ SetTestStepName(CCTSYIntegrationTestDTMF0011::GetTestStepName());
+ }
+
+CCTSYIntegrationTestDTMF0011::~CCTSYIntegrationTestDTMF0011()
+/**
+ * Destructor.
+ */
+ {
+ }
+
+TVerdict CCTSYIntegrationTestDTMF0011::doTestStepL()
+/**
+ * @SYMTestCaseID BA-CTSY-INT-DTMF-0011
+ * @SYMFssID BA/CTSY/DTMF-0011
+ * @SYMTestCaseDesc Ensure that DTMF tones can be sent to all conference call participants
+ * @SYMTestPriority High
+ * @SYMTestActions RMobileCall::Hold, RCall::HangUp, RMobileConferenceCall::CreateConference, RMobilePhone::StartDTMFTone, RMobilePhone::StopDTMFTone, RMobilePhone::SendDTMFTones, RMobilePhone::NotifyStopInDTMFString, RMobilePhone::ContinueDTMFStringSending, RMobilePhone::GetDTMFCaps, RMobilePhone::NotifyDTMFCapsChange
+ * @SYMTestExpectedResults Pass - DTMF tones sent to all conference call participants.
+ * @SYMTestType CIT
+ * @SYMTestCaseDependencies live/automatic
+ *
+ * Reason for test: Verify sending of DTMF tones and strings can be sent.
+ *
+ * @return - TVerdict code
+ */
+ {
+
+ //
+ // SET UP
+ //
+
+ RMobilePhone& mobilePhone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);
+
+ // Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL
+ CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));
+
+ // Ensure phone supports KCapsVoice.
+ RMobilePhone::TCaps mobilephonecaps;
+
+ CHECK_EQUALS_L(mobilePhone.GetCaps(mobilephonecaps), KErrNone, _L("RMobilePhone::GetCaps"));
+ TUint32 expectedmobilephoneCaps = RMobilePhone::KCapsVoice;
+ CHECK_BITS_SET_L(mobilephonecaps.iFlags, expectedmobilephoneCaps, KNoWantedBits, _L("RMobilePhone::GetCaps returned wrong dynamic caps"));
+
+ // Get Voice Line 1.
+ RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);
+
+ // Get Call 1.
+ RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall1);
+
+ //
+ // SET UP END
+ //
+
+ StartTest();
+
+ //
+ // TEST START
+ //
+
+ // Set up a five party conference call.
+ TExtEtelRequestStatus holdStatus(mobilePhone, EMobileCallHold);
+ CleanupStack::PushL(holdStatus);
+
+ TPtrC number;
+ ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number), _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ mobileCall.Dial(dialStatus, number);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ mobileCall.Hold(holdStatus);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(holdStatus, ETimeMedium), KErrNone, _L("RMobileCall::Hold timed-out"));
+ ASSERT_EQUALS(holdStatus.Int(), KErrNone, _L("RMobileCall::Hold status incorrect"));
+
+ RMobileConferenceCall& cc = iEtelSessionMgr.GetConferenceCallL(KMainServer, KMainPhone, KMainConferenceCall);
+ RMobileCall& call2 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall2);
+
+ TPtrC number2;
+ ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber2, number2), _L("GetStringFromConfig did not complete as expected"));
+ DEBUG_PRINTF2(_L("Board Now Dialling: %S"), &number2);
+ TCoreEtelRequestStatus<RMobileCall> dialStatus2(mobileCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus2);
+ call2.Dial(dialStatus2, number2);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus2, ETimeMedium), KErrNone, _L("RCall::Dial timed-out"));
+ ASSERT_EQUALS(dialStatus2.Int(), KErrNone, _L("RCall::Dial problem dialling"));
+
+ TExtEtelRequestStatus createConferenceStatus(cc, EMobileConferenceCallCreateConference);
+ CleanupStack::PushL(createConferenceStatus);
+
+ cc.CreateConference(createConferenceStatus);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(createConferenceStatus, ETimeMedium), KErrNone, _L("RMobileConferenceCall::CreateConference timed-out"));
+ ASSERT_EQUALS(createConferenceStatus.Int(), KErrNone, _L("RMobileConferenceCall::CreateConference status incorrect"));
+
+ RMobileCall& call3 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall3 );
+ RMobileCall& call4 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall4 );
+ RMobileCall& call5 = iEtelSessionMgr.GetCallL(KMainServer, KMainPhone, KVoiceLine, KCall5 );
+
+ TPtrC num3, num4, num5;
+ ASSERT_TRUE(GetStringFromConfig( KIniVoiceNumSection, KIniVoiceNumber6, num3), _L("Failed to obtain 3rd number for test"));
+ ASSERT_TRUE(GetStringFromConfig( KIniVoiceNumSection, KIniVoiceNumber4, num4), _L("Failed to obtain 4th number for test"));
+ ASSERT_TRUE(GetStringFromConfig( KIniVoiceNumSection, KIniVoiceNumber5, num5), _L("Failed to obtain 5th number for test"));
+
+
+ AddCallToConferenceL(cc, call3, num3, 3);
+ TEST_CHECK_POINT_L(_L("Adding call3 failed"));
+ AddCallToConferenceL(cc, call4, num4, 4);
+ TEST_CHECK_POINT_L(_L("Adding call4 failed"));
+ AddCallToConferenceL(cc, call5, num5, 5);
+ TEST_CHECK_POINT_L(_L("Adding call5 failed"));
+
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of KCapsSendDTMFString | KCapsSendDTMFSingleTone
+ TUint32 dtmfCaps=0;
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(dtmfCaps), KErrNone,_L("RMobilePhone::GetDTMFCaps return value not KErrNone"));
+ TUint32 expectedCaps = RMobilePhone::KCapsSendDTMFString | RMobilePhone::KCapsSendDTMFSingleTone;
+ ASSERT_BITS_SET(dtmfCaps, expectedCaps, KNoWantedBits, _L("RMobilePhone::GetDTMFCaps returned wrong dynamic caps"));
+
+ // Send a single DTMF tone (repeat with each individual character).
+ TChar tone[18] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9','A' ,'B' ,'C' ,'D' ,'#' ,'*', 'p', 'w'};
+
+ for(TInt i = 0 ; i<18; i++)
+ {
+ DEBUG_PRINTF2(_L("Send DTMF tones: %c"), (char)tone[i]);
+ ASSERT_EQUALS(mobilePhone.StartDTMFTone(tone[i]), KErrNone, _L("RMobilePhone::StartDTMFTone completed with incorrect error"));
+ User::After(KOneSecond);
+ ASSERT_EQUALS(mobilePhone.StopDTMFTone(), KErrNone, _L("RMobilePhone::StopDTMFTone completed with incorrect error"));
+ }
+
+ // Wait for 5 seconds
+ User::After(5*KOneSecond);
+
+ // Send a DTMF string without 'w' or 'p'
+ TExtEtelRequestStatus sendDTMFTonesStatus(mobilePhone, EMobilePhoneSendDTMFTones);
+ CleanupStack::PushL(sendDTMFTonesStatus);
+
+ TBufC<50> toneSet1 = _L("0123456789");
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet1);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet1);
+
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+ ERR_PRINTF1(_L("<font color=Orange>$CTSYProblem: In case of conference call it gets \n KErrGsmCCSemanticallyIncorrectMessage from LTSY as an answer for SendDTMFTones() </font>"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrGsmCCSemanticallyIncorrectMessage, _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+
+ RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;
+ ASSERT_EQUALS(cc.GetConferenceStatus(confCallConfStatus), KErrNone,
+ _L("RMobileConferenceCall::GetConferenceStatus returned an error"));
+ ASSERT_EQUALS( confCallConfStatus, RMobileConferenceCall::EConferenceActive,
+ _L("RMobileConferenceCall::GetConferenceStatus did not return EConferenceActive"));
+
+ // Send a DTMF string with 'p'
+ TBufC<50> toneSet2 = _L("0123456p789ABCD");
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet2);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet2);
+
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrGsmCCSemanticallyIncorrectMessage, _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+
+ TExtEtelRequestStatus notifyStopStatus(mobilePhone, EMobilePhoneNotifyStopInDTMFString);
+ CleanupStack::PushL(notifyStopStatus);
+ mobilePhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ // Send a DTMF string "1234w567"
+ TBufC<50> toneSet3 = _L("1234w567");
+
+ DEBUG_PRINTF2(_L("Send DTMF tones: %S"), &toneSet3);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet3);
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopStatus, KErrNone);
+ DEBUG_PRINTF1(_L("RMobilePhone::NotifyStopInDTMFString completes"));
+
+ // Continue sending the string with RMobilePhone::ContinueDTMFStringSending with aContinue = ETrue
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(ETrue), KErrNone, _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+
+ // Check request completes with KErrNone each time.
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(sendDTMFTonesStatus, ETimeMedium), KErrNone, _L("RMobilePhone::SendDTMFTones timed-out"));
+ ASSERT_EQUALS(sendDTMFTonesStatus.Int(), KErrGsmCCSemanticallyIncorrectMessage, _L("RMobilePhone::SendDTMFTones completed with incorrect error"));
+
+ // Send a valid DTMF string "1234w567" again
+ mobilePhone.NotifyStopInDTMFString(notifyStopStatus);
+
+ DEBUG_PRINTF2(_L("Send DTMF tones (again): %S"), &toneSet3);
+ mobilePhone.SendDTMFTones(sendDTMFTonesStatus, toneSet3);
+
+ // Check RMobilePhone::NotifyStopInDTMFString completes
+ iCallControlTestHelper.WaitForMobilePhoneNotifyStopInDTMFString(notifyStopStatus, KErrNone);
+ DEBUG_PRINTF1(_L("RMobilePhone::NotifyStopInDTMFString completes"));
+
+ // Continue sending the string with RMobilePhone::ContinueDTMFStringSending with aContinue = EFalse
+ ASSERT_EQUALS(mobilePhone.ContinueDTMFStringSending(EFalse), KErrNone, _L("RMobilePhone::ContinueDTMFStringSending has not returned KErrNone"));
+
+ // Post NotifyDTMFCapsChange
+ TUint32 completiondtmfcaps;
+ TExtEtelRequestStatus notifyDTMFCapsChangeStatus(mobilePhone, EMobilePhoneNotifyDTMFCapsChange);
+ CleanupStack::PushL(notifyDTMFCapsChangeStatus);
+ mobilePhone.NotifyDTMFCapsChange(notifyDTMFCapsChangeStatus, completiondtmfcaps);
+
+ // Terminate the conference call.
+ TExtEtelRequestStatus reqHangupStatus(cc, EMobileConferenceCallHangUp);
+ CleanupStack::PushL(reqHangupStatus);
+ cc.HangUp(reqHangupStatus);
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(reqHangupStatus, ETimeMedium), KErrNone, _L("RMobileConferenceCall::HangUp timed-out"));
+ ASSERT_EQUALS(reqHangupStatus.Int(), KErrNone, _L("RMobileConferenceCall::HangUp completed with incorrect error"));
+
+ ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 10053);
+ // Check RMobilePhone::NotifyDTMFCapsChange completes with caps of 0
+ TUint32 wantedCaps=0;
+ iCallControlTestHelper.WaitForMobilePhoneNotifyDTMFCapsChange(
+ mobilePhone,
+ notifyDTMFCapsChangeStatus,
+ completiondtmfcaps,
+ wantedCaps,
+ KNoUnwantedBits,
+ KErrNone);
+
+ // Check RMobilePhone::GetDTMFCaps returns caps of 0
+ TUint32 getCaps;
+ ASSERT_EQUALS(mobilePhone.GetDTMFCaps(getCaps), KErrNone, _L("RMobilePhone::GetDTMFCaps returned incorrect value"));
+
+ //
+ // TEST END
+ //
+
+ StartCleanup();
+
+ //holdStatus
+ //dialStatus
+ //dialStatus2
+ //createConferenceStatus
+ //notifyStopStatus
+ //sendDTMFTonesStatus
+ //notifyDTMFCapsChangeStatus
+ //reqHangupStatus
+ CleanupStack::PopAndDestroy(8,&holdStatus);
+
+ return TestStepResult();
+ }
+
+TPtrC CCTSYIntegrationTestDTMF0011::GetTestStepName()
+/**
+ * @return The test step name.
+ */
+ {
+ return _L("CCTSYIntegrationTestDTMF0011");
+ }
+
+/**
+ * Add a call to a conference. Leaves on failure.
+ * @param aConfCall Conference call object
+ * @param aCall Call object to use
+ * @param aNumber Number to dial
+ *
+ */
+ void CCTSYIntegrationTestDTMF0011::AddCallToConferenceL(RMobileConferenceCall& aConfCall,
+ RMobileCall& aCall,
+ TPtrC& aNumber,
+ TInt aIndex)
+ {
+
+ DEBUG_PRINTF3(_L("Adding call %d to conference : %S"), aIndex, &aNumber );
+ // Swap the conference call.
+ TExtEtelRequestStatus reqSwapConfStatus(aConfCall,EMobileConferenceCallSwap);
+ CleanupStack::PushL(reqSwapConfStatus);
+
+ aConfCall.Swap(reqSwapConfStatus);
+ ASSERT_EQUALS( WaitForRequestWithTimeOut(reqSwapConfStatus,ETimeShort),KErrNone,
+ _L("RMobileConferenceCall::Swap timed out"));
+ ASSERT_EQUALS( reqSwapConfStatus.Int(),KErrNone,
+ _L("RMobileConferenceCall::Swap returned error"));
+ TEST_CHECK_POINT_L(_L("RMobileConferenceCall::Swap failed"));
+
+ // Dial a number that answers
+ // Check RMobileCall::GetMobileCallStatus returns status of EStatusConnected.
+ TCoreEtelRequestStatus<RMobileCall> dialStatus(aCall, &RCall::DialCancel);
+ CleanupStack::PushL(dialStatus);
+ aCall.Dial( dialStatus, aNumber );
+
+ ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));
+ ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial returned an error") );
+ TEST_CHECK_POINT_L(_L("Failed to connect call"));
+
+ // Set up notification
+ TExtEtelRequestStatus notifyConfEventStatus(aConfCall,EMobileConferenceCallNotifyConferenceEvent);
+ CleanupStack::PushL(notifyConfEventStatus);
+ RMobileConferenceCall::TMobileConferenceEvent confEvent;
+ TName confEventCallName;
+ aConfCall.NotifyConferenceEvent( notifyConfEventStatus, confEvent, confEventCallName );
+
+ // Add call to the conference
+ TExtEtelRequestStatus reqAddCallStatus(aConfCall,EMobileConferenceCallAddCall);
+ CleanupStack::PushL(reqAddCallStatus);
+
+ // Get the call info (need the name)
+ RCall::TCallInfo callInfo;
+ TInt err = aCall.GetInfo(callInfo);
+ ASSERT_EQUALS( err, KErrNone, _L("RCall::GetInfo returned error"));
+
+ aConfCall.AddCall(reqAddCallStatus,callInfo.iCallName);
+
+ ASSERT_EQUALS( WaitForRequestWithTimeOut(reqAddCallStatus,ETimeShort),KErrNone,
+ _L("RMobileConferenceCall::AddCall timed out"));
+ ASSERT_EQUALS( reqAddCallStatus.Int(),KErrNone,
+ _L("RMobileConferenceCall::AddCall returned error"));
+ TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));
+
+ // Check RMobileConferenceCall::NotifyConferenceEvent completes with EConferenceCallAdded
+ iCallControlTestHelper.WaitForMobileConferenceCallNotifyConferenceEvent( aConfCall,
+ notifyConfEventStatus,
+ confEvent,RMobileConferenceCall::EConferenceCallAdded,
+ confEventCallName,
+ KErrNone);
+
+ // Check RMobileConferenceCall::GetConferenceStatus returns EConferenceActive
+ RMobileConferenceCall::TMobileConferenceStatus confCallConfStatus;
+ ASSERT_EQUALS(aConfCall.GetConferenceStatus(confCallConfStatus), KErrNone,
+ _L("RMobileConferenceCall::GetConferenceStatus returned an error"));
+ ASSERT_EQUALS( confCallConfStatus, RMobileConferenceCall::EConferenceActive,
+ _L("RMobileConferenceCall::GetConferenceStatus did not return EConferenceActive"));
+
+ TEST_CHECK_POINT_L(_L("AddCallToConferenceL failed"));
+
+ // reqAddCallStatus
+ // dialStatus
+ // notifyConfEventStatus
+ // reqSwapConfStatus
+ CleanupStack::PopAndDestroy(4,&reqSwapConfStatus);
+ }