--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/multimodetsy/test/TE_Voice/TE_Voice.cpp Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,2492 @@
+// Copyright (c) 2005-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:
+// This program is designed the test the Voice functionality of the Basic MM Tsy.
+//
+//
+
+/**
+ @file
+*/
+
+#include <etelmm.h>
+
+#include "TE_Voice.h"
+#include "TE_VoiceTestStepBase.h"
+
+_LIT(KVoiceLineName,"Voice");
+_LIT(KConsoleTitle, "TE_Voice Test");
+_LIT(KPleaseRingThePhone, "Please ring the phone\n");
+
+const TInt KTenPartOfSec = 100000 ;
+const TInt KOneSecond=1000000; // Used in a time out function, 1 second (in microSeconds)
+const TInt KTenSeconds=10000000; // Used in a time out function, 10 seconds (in microSeconds)
+
+//------------------------------------------------------------------
+CTestPhoneInfo::CTestPhoneInfo()
+/* 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("TestPhoneInfo"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestPhoneInfo::doTestStepL()
+//void CTestVoice::TestPhoneInfoL()
+/**
+ * This function retrieves a snapshot of the phone's GSM information, gets the
+ * number of lines associated with the phone as well as information on the line
+ * and phone. Gets the phone's status and also performs some Cancel Requests.
+ * @test GT83-TVOICE-037.01 Retrieve phone's multimode capabilities and print them to screen.
+ */
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Phone Information test") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Phone Information Test...\n"));
+
+ // Retrieve a snapshot of the current phone information
+ INFO_PRINTF1(_L("Get Phone Info..."));
+ console->Printf(_L("Get Phone Info...\n"));
+ RPhone::TPhoneInfo phoneInfo;
+ RPhone::TCaps phoneCaps;
+ TInt ret=iPhone.GetInfo(phoneInfo);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobilePhone::GetInfo() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Phone info is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get Phone Info is successful."));
+ TEST_CHECKL(phoneInfo.iDetection, RPhone::EDetectedPresent, _L("GT83-TVOICE-0"));
+ TESTCHECKL(phoneInfo.iDetection,RPhone::EDetectedPresent);
+ INFO_PRINTF1(_L("Local Modem has been detected."));
+ }
+
+ //test mobile phone caps
+ RMobilePhone::TMobilePhoneModeCaps mobileCaps ;
+ ret = iPhone.GetMultimodeCaps((TUint32&)mobileCaps);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobilePhone::GetMultimodeCaps() ***")) ;
+ TESTCHECK(ret, KErrNone);
+
+ Print_TMobilePhoneModeCaps(mobileCaps);
+
+ // Number of lines associated with the phone
+ TInt lineCount=0;
+ TEST_CHECKL(iPhone.EnumerateLines(lineCount), KErrNone, _L("*** Failed RMobilePhone::EnumerateLines() ***"));
+ TESTL(lineCount>0);
+ TESTCHECKCONDITIONL(lineCount>0);
+ for (;lineCount>0; lineCount--)
+ {
+ ret = iPhone.GetLineInfo(lineCount-1, iLineInfo);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobilePhone::GetLineInfo() ***"));
+ TESTCHECK(ret, KErrNone);
+ INFO_PRINTF4(_L("Line %d (%S) cap flags = 0x%x"),
+ lineCount-1, &iLineInfo.iName,iLineInfo.iLineCapsFlags);
+ if (iLineInfo.iLineCapsFlags&RLine::KCapsVoice)
+ {
+ INFO_PRINTF3(_L("Line %d (%S) has voice capability"), lineCount-1, &iLineInfo.iName);
+ iLineIndex=lineCount-1;
+ break;
+ }
+ }
+ TESTL(lineCount>0);
+ TESTCHECKCONDITIONL(lineCount>0);
+ // Status of the Phone
+ INFO_PRINTF1(_L("Get the Phone's Status..."));
+ RPhone::TStatus phoneStatus;
+ ret=iPhone.GetStatus(phoneStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobilePhone::GetStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Phone Status is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get Phone Status is successful."));
+ TEST_CHECKL(phoneStatus.iMode, RPhone::EModeIdle, _L("GT83-TVOICE-0"));
+ TESTCHECKL(phoneStatus.iMode, RPhone::EModeIdle);
+ INFO_PRINTF1(_L("The phone is currently Idle"));
+ }
+
+ // Notification Cancel Requests : Modem Detected
+ INFO_PRINTF1(_L("Notify Modem Detected Cancel Request..."));
+ RPhone::TModemDetection detected;
+ iPhone.NotifyModemDetected(iStatus, detected);
+ iPhone.NotifyModemDetectedCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrCancel), _L("*** Failed RMobilePhone::NotifyModemDetectedCancel() ***"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Notify Modem Detected Cancel status: %d")), iStatus.Int());
+
+ // Notification Cancel Requests : Caps Change
+ INFO_PRINTF1(_L("Notify Caps Change Cancel Request..."));
+ iPhone.NotifyCapsChange(iStatus, phoneCaps);
+ iPhone.NotifyCapsChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrCancel), _L("*** Failed RMobilePhone::NotifyCapsChangeCancel() ***"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Notify Caps Change Cancel status: %d")), iStatus.Int());
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestLineStatusIncomingCall::CTestLineStatusIncomingCall()
+/* 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("TestLineStatusIncomingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineStatusIncomingCall::doTestStepL()
+//void CTestVoice::TestLineStatusIncomingCallL()
+/** Tests line status function
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-004.00 Test retrieval of a voice line's current status (Generic)
+ * @test GT83-TVOICE-004.02 "Test retrieval of a voice line's current status when the line's status is ""Idle"""
+ * @test GT83-TVOICE-004.04 "Test retrieval of a voice line's current status when the line's status is ""Ringing"""
+ * @test GT83-TVOICE-004.07 "Test retrieval of a voice line's current status when the line's status is ""Connected"""
+ * @test GT83-TVOICE-004.08 "Test retrieval of a voice line's current status when the line's status is ""Hanging up"""
+ * @test GT83-TVOICE-008.02 Test for a notification when there is an incoming call on a voice line
+ * @test GT83-TVOICE-015.05 Test opening an existing call from a voice line by specifying the name of the line and the name of an existing call
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-030.00 Test retrieval of a mobile voice line's current status (Generic)
+ * @test GT83-TVOICE-030.02 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Dialling"""
+ * @test GT83-TVOICE-030.03 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Ringing"""
+ * @test GT83-TVOICE-030.06 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Disconnecting"""
+ * @test GT83-TVOICE-030.07 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""on hold"""
+ * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle, TSize(KConsFullScreen, KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Status") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Status...\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ RCall::TStatus lineStatus;
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ TInt ret = iLine.Open(iPhone,KVoiceLineName);
+ TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-001.01"));
+ TESTCHECKL(ret,KErrNone);
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***"));
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;
+
+ RMobileCall::TMobileCallStatus mobileLineStatus;
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***"));
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.01")) ;
+
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ TName callName;
+ /* @test GT83-AT-024 Test setting notification of an incoming call on a Voice Line */
+ iLine.NotifyIncomingCall(iStatus, callName); // wait for a call
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ ret = iStatus.Int();
+ CHECKPOINT(ret, KErrNone, _L("GT83-TVOICE-008.02")) ;
+ TESTCHECK(ret, KErrNone);
+ INFO_PRINTF2(_L("Voice Call name is %S"), &callName);
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is ringing*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***"));
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TVOICE-004.04")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***"));
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TVOICE-030.003")) ;
+ INFO_PRINTF1(_L("Phone is ringing..."));
+ console->Printf(_L("Phone is ringing...\n"));
+
+ //Test for incoming Voice Call
+ TestLineCapabilitiesL();
+
+ /* @test GT83-AT-028 Test opening a new call by specifying the name of a line
+ */
+ ret = iVoiceCall.OpenExistingCall(iLine, callName);
+ TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-015.05 - *** Failed RMobileCall::OpenExistingCall() ***")) ;
+ TESTCHECKL(ret, KErrNone);
+ // Answer an incoming call initiated by t_echo.exe and obtain the call's current status
+ //GT83-AT-032 Test answering a call on a Voice Line (Generic) RCall::AnswerIncomingCall
+ iVoiceCall.AnswerIncomingCall(iStatus);
+ WaitWithTimeout(iStatus,30*KOneSecond); // but timeout after 2 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;
+ TESTCHECKL(iStatus.Int(), KErrNone);
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.04")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.03")) ;
+ TestLineCapabilitiesL();
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.07")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.07")) ;
+
+
+ INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));
+ console->Printf(_L("Please stay connected... the test will hang up shortly\n"));
+ User::After(10*KOneSecond);
+
+ INFO_PRINTF1(_L("Hanging Up"));
+ console->Printf(_L("Hanging Up\n"));
+ iVoiceCall.HangUp(iStatus);
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is hang up*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-004.08")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-034.09")) ;
+
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ; //??? line 825
+ TESTCHECKL(iStatus.Int(), KErrNone);
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-030.02")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+
+CTestLineStatusOutgoingCall::CTestLineStatusOutgoingCall()
+/* 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("TestLineStatusOutgoingCall"));
+ }
+//------------------------------------------------------------------
+enum TVerdict CTestLineStatusOutgoingCall::doTestStepL()
+//void CTestVoice::TestLineStatusOutgoingCallL()
+/** Tests line status function
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-004.00 Test retrieval of a voice line's current status (Generic)
+ * @test GT83-TVOICE-004.01 "Test retrieval of a voice line's current status when the line's status is ""Unknown"""
+ * @test GT83-TVOICE-004.02 "Test retrieval of a voice line's current status when the line's status is ""Idle"""
+ * @test GT83-TVOICE-004.03 "Test retrieval of a voice line's current status when the line's status is ""Dialling"""
+ * @test GT83-TVOICE-004.07 "Test retrieval of a voice line's current status when the line's status is ""Connected"""
+ * @test GT83-TVOICE-004.08 "Test retrieval of a voice line's current status when the line's status is ""Hanging up"""
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-030.00 Test retrieval of a mobile voice line's current status (Generic)
+ * @test GT83-TVOICE-030.07 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""on hold"""
+ * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle, TSize(KConsFullScreen, KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Status") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Status\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ RCall::TStatus lineStatus;
+ TName CallName ;
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("GT83-TVOICE-001.01"));
+
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/
+ TInt ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;
+
+ RMobileCall::TMobileCallStatus mobileLineStatus;
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.01")) ;
+ /* @test GT83-AT-028 Test opening a new call by specifying the name of a line
+ */
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ INFO_PRINTF2(_L("Dialling %S...."),&GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+
+ //doesn't work for MM.TSY
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("GT83-TVOICE-004.00")) ;
+ TESTCHECK(ret, KErrNone);
+ //TEST_CHECKL(lineStatus, RCall::EStatusDialling, _L("GT83-TVOICE-004.03")) ;
+
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Dial() ***")) ;
+ TESTCHECKL(iStatus.Int(), KErrNone);
+ //Test for outgoing Voice Call
+ TestLineCapabilitiesL();
+
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.07")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.07")) ;
+
+
+ INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));
+ console->Printf(_L("Please stay connected... the test will hang up shortly\n"));
+ User::After(10*KOneSecond);
+
+ INFO_PRINTF1(_L("Call connected - listen for 20 seconds..."));
+ console->Printf(_L("Call connected - listen for 20 seconds...\n"));
+ User::After(20*KOneSecond); // hold call active for 20 seconds
+
+ INFO_PRINTF1(_L("Hanging up"));
+ iVoiceCall.HangUp(iStatus);
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-004.08")) ;
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;
+ TESTCHECKL(iStatus.Int(), KErrNone);
+
+ //Test for outgoing Voice Call after hang up
+ TestLineCapabilitiesL();
+ /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/
+ ret = iLine.GetStatus(lineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;
+
+ ret = iLine.GetMobileLineStatus(mobileLineStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-004.01")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestLineInfo::CTestLineInfo()
+/* 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
+ //iTestStepName = _L("TestLineInfo"); //MODIFIIED -Was Incorrect ("TestLineInfoL")
+ SetTestStepName(_L("TestLineInfo"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineInfo::doTestStepL()
+//void CTestVoice::TestLineInfoL()
+/**
+ * This function gets the Line capabilities, line information, Number of calls
+ * on the line and call information,
+ * @test NONE Test the ability to get the current line information of the Voice Line (Generic)
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-005.01 "Test retrieval of the current hook status, when the line is currently ""off hook"""
+ * @test GT83-TVOICE-005.02 "Test retrieval of the current hook status, when the line is currently ""on hook"""
+ * @test GT83-TVOICE-012.01 Test the ability to get the current line information of the voice line. Display the line information to screen.
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-027.02 Test the ability to place an asynchronous request to hang up a voice call
+ * @test GT83-TVOICE-006.01 "Test enumeration of the number of calls on a voice line, when there is 0 active call."
+ * @test GT83-TVOICE-006.02 "Test enumeration of the number of calls on a voice line, when there is 1 active call."
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Information") ; TEST_START(&KStartText) ;
+ TInt lineCount=0;
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ INFO_PRINTF1(_L("Retrieving no. of calls opened from the line.."));
+ console->Printf(_L("Retrieving no. of calls opened from the line..\n"));
+ TEST_CHECKL(iLine.EnumerateCall(lineCount), KErrNone, _L("*** Failed RMobileLine::EnumerateCall() ***"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("No of calls opened = %d")), lineCount);
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** Failed RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ // Line Information
+ RLine::TLineInfo lineInfo;
+ TRAPD(ret, ret=iLine.GetInfo(lineInfo));
+ TESTCHECK(ret, KErrNone);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetInfo() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Line Info. is NOT supported"));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Get Line Info is successful"));
+ TESTL(lineInfo.iHookStatus == RCall::EHookStatusOn) ;
+ TESTCHECKL(lineInfo.iHookStatus, RCall::EHookStatusOn);
+ TESTL(lineInfo.iStatus == RCall::EStatusIdle) ;
+ TESTCHECKL(lineInfo.iStatus, RCall::EHookStatusOn);
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Name of last call added: %S")), &lineInfo.iNameOfLastCallAdded);
+ }
+
+ // Hook status information
+ INFO_PRINTF1(_L("Retrieving Hook Status..."));
+ console->Printf(_L("Retrieving Hook Status...\n"));
+ RCall::THookStatus hookStatus;
+ ret=iLine.GetHookStatus(hookStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetHookStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Hook status is NOT supported"));
+ }
+ else
+ {
+ TEST_CHECKL(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-005.02")) ;
+ TESTCHECKL(hookStatus, RCall::EHookStatusOn);
+ INFO_PRINTF1(_L("The line is currently ON Hook"));
+ }
+
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ // Answer an incoming call initiated and obtain the call's current status
+ iVoiceCall.AnswerIncomingCall(iStatus);
+
+ WaitWithTimeout(iStatus,6*KTenSeconds); // but timeout after 60 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;
+ TESTCHECKL(iStatus.Int(), KErrNone)
+ // Count the no. of calls on the line & Get call info.
+ INFO_PRINTF1(_L("Retrieving no. of calls opened from the line.."));
+ console->Printf(_L("Retrieving no. of calls opened from the line..\n"));
+ TEST_CHECKL(iLine.EnumerateCall(lineCount), KErrNone, _L("GT83-TVOICE-006.02 - *** Failed RMobileLine::EnumerateCall() ***"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("No of calls opened = %d")), lineCount);
+
+ //doesn't work for MM.TSY
+ INFO_PRINTF1(_L("Getting Call info.."));
+ console->Printf(_L("Getting Call info..\n"));
+ RLine::TCallInfo callInfo;
+ ret=iLine.GetCallInfo(0,callInfo);
+ //doesn't work for MM.TSY
+ CHECKPOINT_EXPR((ret == KErrNotSupported || ret == KErrNone), _L("GT83-TVOICE-007.01 - *** Failed RMobileLine::GetCallInfo() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Call information is NOT supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get Call information is successful"));
+ }
+
+ // Get the line's current hook status
+ ret=iLine.GetHookStatus(hookStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetHookStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Hook status is NOT supported"));
+ }
+ else
+ {
+ CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-005.01")) ;
+ INFO_PRINTF1(_L("The line is currently OFF Hook"));
+ }
+
+ INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));
+ console->Printf(_L("Please stay connected... the test will hang up shortly\n"));
+ User::After(KTenSeconds);
+
+ INFO_PRINTF1(_L("Hanging up"));
+ console->Printf(_L("Hanging up\n"));
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-027.02 - *** Failed RMobileCall::Hangup() ***")) ;
+ // Close the line and call
+ //GT83-AT-022 Test closing a Voice Line (Generic) RLine::Close
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestLineNotificationsIncomingCall::CTestLineNotificationsIncomingCall()
+/* 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("TestLineNotificationsIncomingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineNotificationsIncomingCall::doTestStepL()
+//void CTestVoice::TestLineNotificationsIncomingCallL()
+/** Tests line notifications
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-008.02 Test for a notification when there is an incoming call on a voice line
+ * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line
+ * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""
+ * @test GT83-TVOICE-009.03 "Test notification of a change in hook status of a voice line from ""on"" to off"""
+ * @test GT83-TVOICE-010.01 "Test notification of a change in the status of the voice line from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""
+ * @test GT83-TVOICE-011.02 Test notification of a call being added to a voice line that currently has no calls
+ * @test GT83-TVOICE-015.05 Test opening an existing call from a voice line by specifying the name of the line and the name of an existing call
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line
+ * @test GT83-TVOICE-031.07 "Test for a notification of a change in status of the mobile voice line from ""connected"" to ""disconnecting"""
+ * @test GT83-TVOICE-031.08 "Test for a notification of a change in status of the mobile voice line from ""disconnecting"" to ""idle"""
+ * @test GT83-TVOICE-031.09 "Test for a notification of a change in status of the mobile voice line from ""idle"" to ""ringing"""
+ * @test GT83-TVOICE-031.10 "Test for a notification of a change in status of the mobile voice line from ""ringing"" to ""answering"""
+ * @test GT83-TVOICE-031.11 "Test for a notification of a change in status of the mobile voice line from ""answering"" to ""connected"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Notifications") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Notifications\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+
+ // NotifyIncomingCall and NotifyStatusChange
+ TName callName1;
+ TName callName2;
+ TInt ret = KErrNone;
+ RCall::TStatus lineStatus;
+ RMobileCall::TMobileCallStatus mobileLineStatus;
+ RCall::THookStatus hookStatus;
+
+
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));
+
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ iLine.NotifyIncomingCall(iStatus, callName1); // wait for a call
+
+ //GT83-AT-026 Test setting notification of a change in the status of the Voice Line
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+
+ //GT83-AT-037 Test setting notification of a change in hook status of a Voice Line void RLine::NotifyHookChange(TRequestStatus& aStatus, THookStatus& aHookStatus) Function does not produce any unexpected errors. aStatus = KErrPending
+ iLine.NotifyHookChange(iStatus4, hookStatus);
+
+ /* GT83-AT-025 Test notification of a call being added to a Voice Line */
+ iLine.NotifyCallAdded(iStatus5, callName2);
+
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-008.02")) ;
+ CHECKPOINT(iStatus2.Int(), KRequestPending, _L("GT83-TVOICE-010.01")) ;
+ CHECKPOINT(iStatus3.Int(), KRequestPending, _L("GT83-TVOICE-031.01")) ;
+ CHECKPOINT(iStatus4.Int(), KRequestPending, _L("GT83-TVOICE-009.01")) ;
+ CHECKPOINT(iStatus5.Int(), KRequestPending, _L("GT83-TVOICE-0011.01")) ;
+
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-008.02")) ;
+
+ // @test GT83-AT-026 Test notification of a change in the status of the Voice Line
+ // from "idle" to "ringing"
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TVOICE-010.02")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.09")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TVOICE-031.09")) ;
+
+ /* GT83-AT-025 Test notification of a call being added to a Voice Line
+ that currently has no calls*/
+ User::WaitForRequest(iStatus5);
+ CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TVOICE-011.02")) ;
+ CHECKPOINT(callName2 == callName1, 1, _L("GT83-TVOICE-011.02")) ;
+
+ INFO_PRINTF1(_L("Phone is ringing... Now answering..."));
+ console->Printf(_L("Phone is ringing... Now answering...\n"));
+
+ /* @test GT83-AT-026 Test notification of a change in the status of the Voice Line from
+ "idle" to "ringing" to "answering" to "connected" to "hanging up" to "idle"
+ */
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+
+ ret = iVoiceCall.OpenExistingCall(iLine, callName1);
+ TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-015.05")) ;
+
+ // Answer an incoming call initiated by t_echo.exe and obtain the call's current status
+ //GT83-AT-032 Test answering a call on a Voice Line (Generic) RCall::AnswerIncomingCall
+ iVoiceCall.AnswerIncomingCall(iStatus);
+ // GT83-AT-026 Test notification of a change in the status of the Voice Line
+ // from "ringing" to "answering"
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.01")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusAnswering, _L("GT83-TVOICE-010.01")) ;
+
+ WaitWithTimeout(iStatus,2*KOneSecond); // but timeout after 2 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ; //wrong code -2147483647
+
+
+ // @test GT83-AT-026 Test notification of a change in the status of the Voice Line
+ // from "answering" to "connecting"
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.01")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-010.01")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.10")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusAnswering, _L("GT83-TVOICE-031.10")) ;
+
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.11")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-031.11")) ;
+
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.02")) ;
+ CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-009.02")) ;
+
+ // now hangup call
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+ iLine.NotifyHookChange(iStatus4, hookStatus);
+
+ INFO_PRINTF1(_L("Call connected - now hanging up..."));
+ console->Printf(_L("Call connected - now hanging up...\n"));
+
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;
+
+ //GT83-AT-026 Test notification of a change in the status of the Voice Line
+ // from "connecting" to "hanging up"
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-010.02")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.07")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-031.07")) ;
+
+ // @test GT83-AT-026 Test notification of a change in the status of the data
+ // line from "hanging up" to "idle"
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-010.02")) ;
+
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.08")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.08")) ;
+
+ //!< @test GT83-AT-037 Test notification of a change in hook status of a Voice Line
+ //!< from "off" to "on" aHookStatus = EHookStatusOff before the hook status changes,
+ //!< and EHookStatusOn after the hook status changes
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.03")) ;
+ CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-009.03")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestLineNotificationsOutgoingCall::CTestLineNotificationsOutgoingCall()
+/* 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("TestLineNotificationsOutgoingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineNotificationsOutgoingCall::doTestStepL()
+//void CTestVoice::TestLineNotificationsOutgoingCallL()
+/** Tests line notifications
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""
+ * @test GT83-TVOICE-009.03 "Test notification of a change in hook status of a voice line from ""on"" to off"""
+ * @test GT83-TVOICE-010.03 "Test notification of a change in the status of the voice line from ""idle"" to ""dialling"" to ""connecting"" to ""connected"" to ""hanging up"" to ""idle""
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-031.02 "Test for a notification of a change in status of the mobile voice line from ""idle"" to ""dialling"""
+ * @test GT83-TVOICE-031.04 "Test for a notification of a change in status of the mobile voice line from ""connecting"" to ""connected"""
+ * @test GT83-TVOICE-031.07 "Test for a notification of a change in status of the mobile voice line from ""connected"" to ""disconnecting"""
+ * @test GT83-TVOICE-031.08 "Test for a notification of a change in status of the mobile voice line from ""disconnecting"" to ""idle"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Notifications") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Notifications\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+
+ // NotifyIncomingCall and NotifyStatusChange
+ TName callName1;
+ RCall::TStatus lineStatus;
+ RMobileCall::TMobileCallStatus mobileLineStatus;
+ RCall::THookStatus hookStatus;
+
+
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));
+
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, callName1), KErrNone, _L("GT83-TVOICE-014.05"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &callName1);
+
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+ iLine.NotifyHookChange(iStatus4, hookStatus);
+
+ // Now test call status during an outgoing call
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusDialling, _L("GT83-TVOICE-010.03")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.02")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDialling, _L("GT83-TVOICE-031.02")) ;
+
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.03")) ;
+ CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-009.03")) ;
+
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+ iLine.NotifyHookChange(iStatus4, hookStatus);
+
+ User::WaitForRequest(iStatus); //end of dial
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-010.03")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.04")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-031.04")) ;
+
+ INFO_PRINTF1(_L("Call connected - hanging up..."));
+ console->Printf(_L("Call connected - hanging up...\n"));
+
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+
+ User::After(10*KOneSecond);
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-010.03")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.07")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-031.07")) ;
+
+ /* @test GT83-AT-037 Test notification of a change in hook status of a data
+ line from "on" to off" aHookStatus = EHookStatusOn before the hook status changes,
+ */
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.02")) ;
+ CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-009.02")) ;
+
+ iLine.NotifyStatusChange(iStatus2, lineStatus);
+ iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;
+ CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-010.03")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.08")) ;
+ CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.08")) ;
+
+ // Using TESTCHECKL
+ TESTCHECKL(iStatus.Int(), KErrNone);
+ TESTCHECKL(iStatus2.Int(), KErrNone);
+ TESTCHECKL(iStatus3.Int(), KErrNone);
+ TESTCHECKL(iStatus4.Int(), KErrNone);
+ TESTCHECKL(iStatus5.Int(), KErrNone);
+ TESTCHECKL(iStatus6.Int(), KErrNone);
+ TESTCHECKL(iStatus7.Int(), KErrNone);
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestLineCancels::CTestLineCancels()
+/* 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("TestLineCancels"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineCancels::doTestStepL()
+//void CTestVoice::TestLineCancelsL()
+/**
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-008.01 Test setting notification of an incoming call on a voice line
+ * @test GT83-TVOICE-008.03 Test the ability to cancel the notification of an incoming call on a voice line
+ * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line
+ * @test GT83-TVOICE-009.04 Test the ability to cancel a notification of a change in hook status of a voice line
+ * @test GT83-TVOICE-010.04 Test the ability to cancel the notification of a change in the status of the voice line
+ * @test GT83-TVOICE-011.01 Test setting notification of a call being added to a voice line
+ * @test GT83-TVOICE-011.05 Test the ability to cancel a notification of a call being added to a voice line
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Cancels") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Cancels\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ // Notify Incoming Call
+ TName callName;
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));
+
+ iLine.NotifyIncomingCall(iStatus, callName);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-008.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iLine.NotifyIncomingCallCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-008.03")) ;
+
+ // Notify Status Change
+ RCall::TStatus lineStatus;
+ iLine.NotifyStatusChange(iStatus, lineStatus);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-010.02")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iLine.NotifyStatusChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-010.04")) ;
+
+#if 0 //cancel functions don't work yet (?)
+ //any way they are not declared 27.09.2001
+ // Notify Mobile Status Change
+ RMobileCall::TMobileCallStatus lineStatus2;
+ iLine.NotifyMobileLineStatusChange(iStatus, lineStatus2);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-0")) ;
+ iLine.NotifyMobileLineStatusChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-0")) ;
+#endif
+ // Notify Hook Change
+ RCall::THookStatus hookStatus;
+ iLine.NotifyHookChange(iStatus, hookStatus);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-009.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iLine.NotifyHookChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-009.04")) ;
+
+ // Notify Call Added
+ iLine.NotifyCallAdded(iStatus, callName);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-011.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iLine.NotifyCallAddedCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-011.05")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCallInfo::CTestCallInfo()
+/* 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("TestCallInfo"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallInfo::doTestStepL()
+//void CTestVoice::TestCallInfoL()
+/**
+ * This function gets information pertaining to a call:
+ * Bearer Service Information, Call duration
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-019.01 "Test retrieval of the bearer service info of a call. Display to screen, all the bearer service information associated with the call."
+ * @test GT83-TVOICE-023.01 Test retrieval of the duration of a voice call. Display the call duration to screen
+ * @test GT83-TVOICE-024.01 Test the ability to get the current call information of the voice call. Display the call information to screen.
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-036.01 Test retreival of the call information and print the call information to screen.
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Call Information") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Call Information"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ RMobileCall::TMobileCallInfoV1 mobileCallInfo;
+ RMobileCall::TMobileCallInfoV1Pckg mobileCallInfoPckg(mobileCallInfo) ;
+
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** Failed RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ //get status
+ RCall::TStatus callStatus;
+
+ TInt ret = iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("GT83-TD-016.02 - *** Failed RMobileCall::iVoiceCall.GetStatus() ***")) ;
+ CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TD-016.02")) ;
+
+ INFO_PRINTF2(_L("Call Status = %d"), callStatus);
+ Print_RCall_TStatus(callStatus) ;
+ // Wait for an incoming call, then get the Call BearerServiceInfo. The
+ // Bearer Service Info is only available if the call is currently active
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ // Answer an incoming call initiated by t_echo.exe and obtain the call's current status
+ //GT83-AT-032 Test answering a call on a Voice Line (Generic) RCall::AnswerIncomingCall
+ iVoiceCall.AnswerIncomingCall(iStatus);
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;
+
+ // User Information
+ INFO_PRINTF1(_L("The call is now connected."));
+ console->Printf(_L("The call is now connected.\n"));
+ INFO_PRINTF1(_L("Retrieving Call Information."));
+ console->Printf(_L("Retrieving Call Information.\n"));
+
+ // Bearer Service Information
+ INFO_PRINTF1(_L("Get Bearer Service Info..."));
+ console->Printf(_L("Get Bearer Service Info...\n"));
+ RCall::TBearerService bearerServiceInfo;
+ ret=iVoiceCall.GetBearerServiceInfo(bearerServiceInfo);
+ CHECKPOINT_EXPR((ret == KErrNone || ret == KErrNotSupported), _L("GT83-TVOICE-019.01")) ;
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get BearerService Information is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get BearerService Information is successful"));
+ }
+
+ // Get Call Information
+ INFO_PRINTF1(_L("Get Current Call Info..."));
+ console->Printf(_L("Get Current Call Info...\n"));
+ ret=iVoiceCall.GetInfo(iCallInfo);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetInfo() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Current Call info is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Displaying Information about the Current Call"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call name: %S")), &iCallInfo.iCallName);
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Line name: %S")), &iCallInfo.iLineName);
+ if (iCallInfo.iHookStatus==RCall::EHookStatusOff)
+ {
+ INFO_PRINTF1(_L("Current Hook Status: Off"));
+ }
+ if (iCallInfo.iStatus==RCall::EStatusConnected)
+ {
+ INFO_PRINTF1(_L("Current Call Status: Connected"));
+ }
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call Duration: %d seconds")), iCallInfo.iDuration.Int());
+ }
+
+
+
+ INFO_PRINTF1(_L("Get Current Mobile Call Info..."));
+ console->Printf(_L("Get Current Mobile Call Info...\n"));
+ ret=iVoiceCall.GetMobileCallInfo(mobileCallInfoPckg);
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-036.01")) ;
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetMobileCallInfo() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Current Call info is NOT Supported"));
+ }
+
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Displaying Information about the Current Call"));
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call name: %S")), &iCallInfo.iCallName);
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Line name: %S")), &iCallInfo.iLineName);
+ if (iCallInfo.iHookStatus==RCall::EHookStatusOff)
+ {
+ INFO_PRINTF1(_L("Current Hook Status: Off"));
+ }
+ if (iCallInfo.iStatus==RCall::EStatusConnected)
+ {
+ INFO_PRINTF1(_L("Current Call Status: Connected"));
+ }
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call Duration: %d seconds")), iCallInfo.iDuration.Int());
+ }
+
+ // Hang up the Call
+ INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));
+ console->Printf(_L("Please stay connected... the test will hang up shortly\n"));
+ User::After(5*KOneSecond);
+
+ // Call Duration
+ INFO_PRINTF1(_L("Get Call Duration..."));
+ console->Printf(_L("Get Call Duration...\n"));
+ TTimeIntervalSeconds callDuration2;
+ ret=iVoiceCall.GetCallDuration(callDuration2);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** RMobileCall::GetCallDuration() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Current Call Duration is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call duration = %d")), callDuration2.Int());
+ }
+
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-009.02 - *** Failed RMobileCall::Hangup() ***")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCallNotificationsIncomingCall::CTestCallNotificationsIncomingCall()
+/* 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("TestCallNotificationsIncomingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallNotificationsIncomingCall::doTestStepL()
+//void CTestVoice::TestCallNotificationsIncomingCallL()
+/**
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-002.00 Test retrieval of a voice line's capabilities (Generic)
+ * @test GT83-TVOICE-008.01 Test setting notification of an incoming call on a voice line
+ * @test GT83-TVOICE-015.05 Test opening an existing call from a voice line by specifying the name of the line and the name of an existing call
+ * @test GT83-TVOICE-016.04 "Test retrieval of the current call status when the call's status is ""ringing"""
+ * @test GT83-TVOICE-016.05 "Test retrieval of the current call status when the call's status is ""answering"""
+ * @test GT83-TVOICE-018.01 Test setting notification of a change in the call's capabilities
+ * @test GT83-TVOICE-018.02 Test notification of a change in the call's capabilities as the call's state changes (eg. From idle to connected). Print the call's capabilities to screen
+ * @test GT83-TVOICE-020.01 Test setting notification of a change in hook status of a voice call
+ * @test GT83-TVOICE-020.02 "Test notification of a change in hook status of a voice call from ""off"" to ""on"""
+ * @test GT83-TVOICE-020.03 "Test notification of a change in hook status of a voice call from ""on"" to off"""
+ * @test GT83-TVOICE-021.01 Test setting notification of a change in the status of the voice call
+ * @test GT83-TVOICE-021.02 "Test notification of a change in the status of the voice call from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""
+ * @test GT83-TVOICE-022.01 Test setting notification of a change in the voice call's duration
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-033.01 Test setting notification of a change in the call's dynamic call control and call event capabilities
+ * @test GT83-TVOICE-033.02 Test notification of a change in the call's dynamic call control and call event capabilities. Print the call's capabilities to screen
+ * @test GT83-TVOICE-034.04 "Test retrieval of the current status of the voice call when the call's status is ""ringing"""
+ * @test GT83-TVOICE-035.01 Test setting a request for a notification of a change in the status of the mobile voice call
+ * @test GT83-TVOICE-035.07 "Test for a notification of a change in status of the mobile voice call from ""connected"" to ""disconnecting"""
+ * @test GT83-TVOICE-035.08 "Test for a notification of a change in status of the mobile voice call from ""disconnecting"" to ""idle"""
+ * @test GT83-TVOICE-035.10 "Test for a notification of a change in status of the mobile voice call from ""ringing"" to ""answering"""
+ * @test GT83-TVOICE-035.11 "Test for a notification of a change in status of the mobile voice call from ""answering"" to ""connected"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ // Post call status change notifications
+ TName callName1;
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ RCall::TStatus callStatus;
+ RMobileCall::TMobileCallStatus mobileCallStatus;
+
+ RCall::TCaps caps;
+ RCall::THookStatus hookStatus;
+ TTimeIntervalSeconds time;
+
+ RMobileCall::TMobileCallCapsV1 mobileCallCaps;
+ RMobileCall::TMobileCallCapsV1Pckg mobileCallCapsPckg(mobileCallCaps);
+
+ _LIT(KStartText, "Test Call Notifications") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Call Notifications\n"));
+
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ iLine.NotifyIncomingCall(iStatus, callName1); // wait for a call
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-008.01")) ;
+
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TVOICE-008.01")) ;
+
+ TInt ret = iVoiceCall.OpenExistingCall(iLine, callName1);
+ TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-015.05 - *** Failed RMobileCall::OpenExistingCall()")) ;
+
+ iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(callStatus, RCall::EStatusRinging, _L("GT83-TVOICE-016.04")) ;
+
+ iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusRinging, _L("GT83-TVOICE-034.04")) ;
+
+ ret=iVoiceCall.GetCaps(caps);
+ TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-002.00")) ;
+ Print_TCapsEnum(caps) ;
+ TEST(caps.iFlags & RCall::KCapsVoice ) ;
+ TEST(caps.iFlags & RCall::KCapsAnswer);
+
+// INFO_PRINTF1(_L("Opening New Voice Call"));
+// TEST_CHECKL(iiVoiceCall.OpenExistingCall(iLine, callName2), KErrNone, _L("GT83-TVOICE-013.06")) ;
+
+ iVoiceCall.NotifyStatusChange(iStatus2, callStatus);
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+ iVoiceCall.NotifyCapsChange(iStatus4, caps);
+ iVoiceCall.NotifyHookChange(iStatus5, hookStatus);
+ iVoiceCall.NotifyCallDurationChange(iStatus6, time) ;
+ iVoiceCall.NotifyMobileCallCapsChange(iStatus7, mobileCallCapsPckg);
+
+ INFO_PRINTF1(_L("Phone is ringing... Now answering..."));
+ console->Printf(_L("Phone is ringing... Now answering...\n"));
+ //GT83-AT-032 Test answering a call on a Voice Line (Generic) RCall::AnswerIncomingCall
+ iVoiceCall.AnswerIncomingCall(iStatus);
+
+ //doesn't work for MM.TSY iVoiceCall.GetStatus(callStatus);
+ //TEST_CHECKL(callStatus, RCall::EStatusAnswering, _L("GT83-TVOICE-016.05")) ;
+
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 2 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-026.00 - *** Failed RMobileCall::AnswerIncomingCall() ***")) ;
+
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-021.01")) ;
+ CHECKPOINT(callStatus, RCall::EStatusAnswering, _L("GT83-TVOICE-021.02")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-035.01")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TVOICE-035.10")) ;
+
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-035.01 - *** Failed RMobileCall::Notify")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-035.11")) ;
+
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-018.01 - *** Failed RMobileCall::NotifyCapsChange() ***")) ;
+ Print_TCapsEnum(caps) ;
+ TEST_CHECKL(((caps.iFlags & RCall::KCapsVoice) != 0), ETrue , _L("GT83-TVOICE-018.02")) ;
+
+ iVoiceCall.NotifyCapsChange(iStatus4, caps);
+ User::WaitForRequest(iStatus4);
+ CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-018.01 - *** Failed RMobileCall::NotifyCapsChange() ***")) ;
+ TEST_CHECKL( (caps.iFlags & RCall::KCapsVoice) !=0 , ETrue, _L("GT83-TVOICE-018.01")) ;
+ TEST_CHECKL( (caps.iFlags & RCall::KCapsHangUp) !=0 , ETrue, _L("GT83-TVOICE-018.01")) ;
+
+ User::WaitForRequest(iStatus5);
+ CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TVOICE-020.01 - *** Failed RMobileCall::NotifyHookChange() ***")) ;
+ TEST_CHECKL(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-020.03")) ;
+
+ User::WaitForRequest(iStatus6);
+ CHECKPOINT_EXPR((iStatus6==KErrNone || iStatus6==KErrNotSupported), _L("*** Failed RMobileCall::NotifyCallDurationChange() ***"));
+ if (iStatus6==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Notify Call Duration Change is NOT Supported"));
+ }
+ if (iStatus6==KErrNone)
+ {
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call duration = %d")), time.Int());
+ }
+
+ User::WaitForRequest(iStatus7);
+ CHECKPOINT(iStatus7.Int(), KErrNone, _L("GT83-TVOICE-033.01 - *** Failed RMobileCall::NotifyMobileCallCapsChange() ***")) ;
+ TEST_CHECKL(((mobileCallCaps.iCallControlCaps & RCall::KCapsVoice)!=0), ETrue, _L("GT83-TVOICE-033.02")) ;
+
+ iVoiceCall.NotifyMobileCallCapsChange(iStatus7, mobileCallCapsPckg);
+ User::WaitForRequest(iStatus7);
+ CHECKPOINT(iStatus7.Int(), KErrNone, _L("GT83-TVOICE-033.01 - *** Failed RMobileCall::NotifyMobileCallCapsChange() ***")) ;
+ TEST_CHECKL( (mobileCallCaps.iCallControlCaps & RCall::KCapsHangUp)!=0, ETrue, _L("GT83-TVOICE-033.02")) ;
+ TEST_CHECKL( (mobileCallCaps.iCallControlCaps & RCall::KCapsVoice)!=0, ETrue, _L("GT83-TVOICE-033.02")) ;
+ // now hangup call
+ iVoiceCall.NotifyStatusChange(iStatus2, callStatus);
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+
+ INFO_PRINTF1(_L("Call connected - now hanging up..."));
+ console->Printf(_L("Call connected - now hanging up...\n"));
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ; //sometimes timed out -33
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-021.01 - *** Failed RMobileCall::NotifyStatusChange() ***")) ;
+ TEST_CHECKL(callStatus, RCall::EStatusConnected, _L("GT83-TVOICE-021.02")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-035.07 - *** Failed RMobileCall::NotifyMobileCallStatusChange() ***")) ;
+ TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-035.07")) ;
+
+ iVoiceCall.NotifyStatusChange(iStatus2, callStatus);
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-021.01 - *** Failed RMobileCall::NotifyStatusChange() ***")) ;
+ TEST_CHECKL(callStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-021.02")) ;
+
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-035.07 - *** Failed RMobileCall::NotifyMobileCallStatusChange() ***")) ;
+ TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-035.08")) ;
+
+ // Using TESTCHECKL
+ TESTCHECKL(iStatus.Int(), KErrNone);
+ TESTCHECKL(iStatus2.Int(), KErrNone);
+ TESTCHECKL(iStatus3.Int(), KErrNone);
+ TESTCHECKL(iStatus4.Int(), KErrNone);
+ TESTCHECKL(iStatus5.Int(), KErrNone);
+ TESTCHECKL(iStatus6.Int(), KErrNone);
+ TESTCHECKL(iStatus7.Int(), KErrNone);
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCallNotificationsOutgoingCall::CTestCallNotificationsOutgoingCall()
+/* 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("TestCallNotificationsOutgoingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallNotificationsOutgoingCall::doTestStepL()
+//void CTestVoice::TestCallNotificationsOutgoingCallL()
+/**
+* Post call status change notifications
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-016.03 "Test retrieval of the current call status when the call's status is ""dialling"""
+ * @test GT83-TVOICE-016.08 "Test retrieval of the current call status when the call's status is ""hanging up"""
+ * @test GT83-TVOICE-020.01 Test setting notification of a change in hook status of a voice call
+ * @test GT83-TVOICE-021.01 Test setting notification of a change in the status of the voice call
+ * @test GT83-TVOICE-021.03 "Test notification of a change in the status of the voice call from ""idle"" to ""dialling"" to ""connected"" to ""hanging up"" to ""idle"""
+ * @test GT83-TVOICE-034.03 "Test retrieval of the current status of the voice call when the call's status is ""dialling"""
+ * @test GT83-TVOICE-035.01 Test setting a request for a notification of a change in the status of the mobile voice call
+ * @test GT83-TVOICE-035.02 "Test for a notification of a change in status of the mobile voice call from ""idle"" to ""dialling"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ TName CallName ;
+
+ RCall::TStatus callStatus;
+ RMobileCall::TMobileCallStatus mobileCallStatus;
+
+ //TTimeIntervalSeconds time;
+ //RMobileCall::TMobileCallCapsV1 mobileCallCaps;
+ //RMobileCall::TMobileCallCapsV1Pckg mobileCallCapsPckg(mobileCallCaps);
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+
+ _LIT(KStartText, "Test Call Notifications") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Call Notifications\n"));
+
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ iVoiceCall.NotifyStatusChange(iStatus2, callStatus);
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+
+ // Now test call status during an outgoing call
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-021.01 - *** Failed RMobileCall::NotifyStatusChange() ***")) ;
+ CHECKPOINT(callStatus, RCall::EStatusDialling, _L("GT83-TVOICE-021.03")) ;
+ iVoiceCall.GetStatus(callStatus) ;
+ CHECKPOINT(callStatus, RCall::EStatusDialling, _L("GT83-TVOICE-016.03 - *** Failed RMobileCall::GetStatus() ***")) ;
+
+ User::WaitForRequest(iStatus3);
+ CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-035.01 - *** Failed RMobileCall::NotifyMobileCallStatusChange() ***")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusDialling, _L("GT83-TVOICE-035.02")) ;
+ iVoiceCall.GetMobileCallStatus(mobileCallStatus) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusDialling, _L("GT83-TVOICE-034.03 - *** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+
+ // now hangup call
+ iVoiceCall.NotifyStatusChange(iStatus2, callStatus);
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus);
+
+ INFO_PRINTF1(_L("Call connected - now hanging up..."));
+ console->Printf(_L("Call connected - now hanging up...\n"));
+ iVoiceCall.HangUp(iStatus);
+
+ //doesn't work for MM.TSY
+ User::WaitForRequest(iStatus2);
+ CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-021.01 - *** Failed RMobileCall::NotifyStatusChange() ***")) ;
+ //TEST_CHECKL(callStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-021.03")) ;
+
+ User::WaitForRequest(iStatus3);
+ iVoiceCall.GetMobileCallStatus(mobileCallStatus) ;
+ TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusHangingUp, _L("GT83-TVOICE-016.08 - *** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+
+
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ; //sometimes timed out -33
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCallStatusIncomingCall::CTestCallStatusIncomingCall()
+/* 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("TestCallStatusIncomingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallStatusIncomingCall::doTestStepL()
+//void CTestVoice::TestCallStatusIncomingCallL()
+/**
+ * This function tests call status at various times during calls
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-016.00 Test retrieval of the current call status (Generic)
+ * @test GT83-TVOICE-016.02 "Test retrieval of the current call status when the call's status is ""idle"""
+ * @test GT83-TVOICE-016.04 "Test retrieval of the current call status when the call's status is ""ringing"""
+ * @test GT83-TVOICE-016.05 "Test retrieval of the current call status when the call's status is ""answering"""
+ * @test GT83-TVOICE-016.07 "Test retrieval of the current call status when the call's status is ""connected"""
+ * @test GT83-TVOICE-034.00 Test retrieval of the current status of the voice call (Generic)
+ * @test GT83-TVOICE-034.02 "Test retrieval of the current status of the voice call when the call's status is ""idle"""
+ * @test GT83-TVOICE-034.04 "Test retrieval of the current status of the voice call when the call's status is ""ringing"""
+ * @test GT83-TVOICE-034.05 "Test retrieval of the current status of the voice call when the call's status is ""answering"""
+ * @test GT83-TVOICE-034.07 "Test retrieval of the current status of the voice call when the call's status is ""connected"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ // Get the Call Status
+ _LIT(KStartText, "Get Call Status...") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Get Call Status...\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+ RMobileCall::TMobileCallStatus mobileCallStatus;
+
+ // Open a Voice Line and Call
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+
+ RCall::TStatus callStatus;
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+
+ TInt ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Call Status is NOT Supported"));
+ }
+
+ TInt ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT_EXPR((ret2==KErrNone || ret2==KErrNotSupported), _L("*** Failed RMobileCall::GetMobileCallStatus() ***"));
+ if (ret2==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Mobile Call Status is NOT Supported"));
+ }
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+ CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TVOICE-016.02")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-034.02")) ;
+ INFO_PRINTF1(_L("The call is Idle"));
+ }
+
+ // Now test call status during an incoming call
+
+ // Wait for an incoming call, then get the Call BearerServiceInfo. The
+ // Bearer Service Info is only available if the call is currently active
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ /* GT83-AT-024 Test setting notification of an incoming call on a Voice Line */
+
+ //I had to comment these lines, because
+ // NotifyIncommigCall + AnswerIncommigCall doesn't work
+ //in such situation. Any way we can't get any good
+ //status without notifycation
+
+ //iLine.NotifyIncomingCall(iStatus, callName); // wait for a call
+ //WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+
+ //ret=iVoiceCall.GetStatus(callStatus);
+ //TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-016.00")) ;
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(callStatus, RCall::EStatusIdle, _L("GT83-TVOICE-016.01")) ;
+
+ //ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ //TEST_CHECKL(ret2, KErrNone, _L("GT83-TVOICE-034.00")) ;
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-034.01")) ;
+
+ // Answer an incoming call initiated by t_echo.exe and obtain the call's current status
+ iVoiceCall.AnswerIncomingCall(iStatus);
+ ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("GT83-TVOICE-016.00 - *** Failed RMobileCall::GetStatus() ***")) ;
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(callStatus, RCall::EStatusAnswering, _L("GT83-TVOICE-016.05")) ;
+
+ ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT(ret2, KErrNone, _L("GT83-TVOICE-034.00 - *** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TVOICE-034.05")) ;
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+
+ ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileCall::GetStatus() ***")) ;
+ ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ TEST_CHECKL(ret2, KErrNone, _L("*** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+
+ Print_RCall_TStatus(callStatus) ;
+ CHECKPOINT(callStatus, RCall::EStatusConnected, _L("GT83-TVOICE-016.07")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-034.07")) ;
+ INFO_PRINTF1(_L("The call is Connected"));
+ }
+ INFO_PRINTF1(_L("Hanging up..."));
+ console->Printf(_L("Hanging up...\n"));
+ User::After(10*KOneSecond);
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-009.01 - *** Failed RMobileCall::Hangup() ***")) ;
+
+ ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileCall::GetStatus() ***")) ;
+ ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT(ret2, KErrNone, _L("*** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+ CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TVOICE-016.02")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-034.02")) ;
+ INFO_PRINTF1(_L("The call is Idle again"));
+ }
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCallStatusOutgoingCall::CTestCallStatusOutgoingCall( )
+/* 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("TestCallStatusOutgoingCall"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallStatusOutgoingCall::doTestStepL()
+// void CTestVoice::TestCallStatusOutgoingCallL()
+/**
+ * This function tests call status at various times during calls
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-016.00 Test retrieval of the current call status (Generic)
+ * @test GT83-TVOICE-016.02 "Test retrieval of the current call status when the call's status is ""idle"""
+ * @test GT83-TVOICE-016.07 "Test retrieval of the current call status when the call's status is ""connected"""
+ * @test GT83-TVOICE-025.00 Test dialling a voice call (Generic)
+ * @test GT83-TVOICE-034.00 Test retrieval of the current status of the voice call (Generic)
+ * @test GT83-TVOICE-034.02 "Test retrieval of the current status of the voice call when the call's status is ""idle"""
+ * @test GT83-TVOICE-034.07 "Test retrieval of the current status of the voice call when the call's status is ""connected"""
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ // Get the Call Status
+ _LIT(KStartText, "Get Call Status...") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Get Call Status...\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ // Open a Voice Line and Call
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+
+ RCall::TStatus callStatus;
+ RMobileCall::TMobileCallStatus mobileCallStatus;
+ TName CallName ;
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("*** RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ TInt ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Call Status is NOT Supported"));
+ }
+
+ TInt ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT_EXPR((ret2==KErrNone || ret2==KErrNotSupported), _L("*** Failed RMobileCall::GetMobileCallStatus() ***"));
+ if (ret2==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Mobile Call Status is NOT Supported"));
+ }
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+ CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TVOICE-016.02")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-034.02")) ;
+ INFO_PRINTF1(_L("The call is Idle"));
+ }
+
+ // Now test call status during an outgoing call
+
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Dial() ***")) ;
+
+ ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileCall::GetStatus() ***")) ;
+ ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT(ret2, KErrNone, _L("*** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+
+ Print_RCall_TStatus(callStatus) ;
+ CHECKPOINT(callStatus, RCall::EStatusConnected, _L("GT83-TVOICE-016.07")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-034.07")) ;
+ INFO_PRINTF1(_L("The call is Connected"));
+ }
+
+ INFO_PRINTF1(_L("Hanging up..."));
+ console->Printf(_L("Hanging up...\n"));
+
+ User::After(10*KOneSecond);
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;
+
+ ret=iVoiceCall.GetStatus(callStatus);
+ CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileCall::GetStatus() ***")) ;
+ ret2=iVoiceCall.GetMobileCallStatus(mobileCallStatus);
+ CHECKPOINT(ret2, KErrNone, _L("*** Failed RMobileCall::GetMobileCallStatus() ***")) ;
+
+ if ((ret==KErrNone) && (ret2==KErrNone))
+ {
+ CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TVOICE-016.02")) ;
+ CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-034.02")) ;
+ INFO_PRINTF1(_L("The call is Idle again"));
+ }
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+
+CTestCallCancels::CTestCallCancels()
+/* 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("TestCallCancels"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCallCancels::doTestStepL()
+//void CTestVoice::TestCallCancelsL()
+/**
+ * This function posts and then cancels Call Notifications.
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-018.01 Test setting notification of a change in the call's capabilities
+ * @test GT83-TVOICE-018.03 Test the ability to cancel a notification of a change in the call's capabilities
+ * @test GT83-TVOICE-020.01 Test setting notification of a change in hook status of a voice call
+ * @test GT83-TVOICE-020.04 Test the ability to cancel a notification of a change in hook status of a voice call
+ * @test GT83-TVOICE-021.01 Test setting notification of a change in the status of the voice call
+ * @test GT83-TVOICE-022.01 Test setting notification of a change in the voice call's duration
+ * @test GT83-TVOICE-022.03 Test cancelling notification of a change in the voice call's duration
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Call Cancels") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Call Cancels...\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ // Open a Voice Line and Call
+ //GT83-AT-021 Test opening a Voice Line from a phone that supports data functionality
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("*** Failed RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ // Call Status Change Cancel Request
+ RCall::TStatus callStatus;
+ iVoiceCall.NotifyStatusChange(iStatus, callStatus);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-021.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iVoiceCall.NotifyStatusChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-021.04")) ;
+
+#if 0 //cancel functions don't work yet (?)
+ //any way they are not declared 27.09.2001
+ RMobileCall::TMobileCallStatus mobileCallStatus;
+ iVoiceCall.NotifyMobileCallStatusChange(iStatus, mobileCallStatus);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-0")) ;
+ iVoiceCall.NotifyMobileCallStatusChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-0")) ;
+#endif
+ // Hook Change Cancel Request
+ RCall::THookStatus hookStatus;
+ iVoiceCall.NotifyHookChange(iStatus, hookStatus);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-020.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iVoiceCall.NotifyHookChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-020.04")) ;
+
+ // Test Cancelling Notifications
+ RCall::TCaps callCaps;
+ iVoiceCall.NotifyCapsChange(iStatus, callCaps);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-018.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iVoiceCall.NotifyCapsChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-018.03")) ;
+
+#if 0 //cancel functions don't work yet (?)
+ //any way they are not declared 27.09.2001
+ RMobileCall::TMobileCallCapsV1 mobileCallCaps;
+ RMobileCall::TMobileCallCapsV1Pckg mobileCallCapsPckg(mobileCallCaps);
+ iVoiceCall.NotifyMobileCallCapsChange(iStatus, mobileCallCapsPckg);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-0")) ;
+ iVoiceCall.NotifyMobileCallCapsChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-0")) ;
+#endif
+
+ TTimeIntervalSeconds callDuration;
+ iVoiceCall.NotifyCallDurationChange(iStatus, callDuration);
+ CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-022.01")) ;
+ User::After(KTenPartOfSec); //snack some sleep
+ iVoiceCall.NotifyCallDurationChangeCancel();
+ User::WaitForRequest(iStatus);
+ CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-022.03")) ;
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestMoreCallInfo::CTestMoreCallInfo()
+/* 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("TestMoreCallInfo"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestMoreCallInfo::doTestStepL()
+//void CTestVoice::TestMoreCallInfoL()
+/**
+ * This function gets more information pertaining to a Voice Call: Call ownership,
+ * Call parameters, Loan data port requests and Transfer ownership requests.
+ * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"
+ * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"
+ * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)
+ * @test GT83-TVOICE-028.01 Test the ability to make a request to acquire the ownership of a call
+ * @test GT83-TVOICE-029.01 Test transferring the call ownership when another client has requested to acquire call ownership
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "More Call Information Tests") ; TEST_START(&KStartText) ;
+ console->Printf(_L("More Call Information Tests\n"));
+
+ //to make sure that line and call will be closed in leave case
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ TInt ret ;
+
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+
+ TName CallName ;
+ // TName CallName2 ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("*** Failed RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ // Wait for an incoming Call
+ INFO_PRINTF1(_L("Please ring the phone "));
+ console->Printf(KPleaseRingThePhone);
+
+ iVoiceCall.AnswerIncomingCall(iStatus); // wait for a call
+ WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***"));
+
+ // Retrieve Call Ownership information
+ INFO_PRINTF1(_L("Get Call Ownership.."));
+ RCall::TOwnershipStatus callOwner;
+ ret=iVoiceCall.GetOwnershipStatus(callOwner);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetOwnershipStatus() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Call OwnerShip is NOT Supported"));
+ }
+
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get Call OwnerShip is Supported"));
+
+ switch(callOwner)
+ {
+ case RCall::EOwnershipUnowned:
+ INFO_PRINTF1(_L("The call is unowned"));
+ break;
+ case RCall::EOwnershipOwnedByAnotherClient:
+ INFO_PRINTF1(_L("The call is owned by another Client"));
+ break;
+ case RCall::EOwnershipOwnedByThisClient:
+ INFO_PRINTF1(_L("The call is owned by this client"));
+ break;
+ default:
+ INFO_PRINTF1(_L("Error in Call Ownership details"));
+ break;
+ }
+ }
+
+ // Call Parameters
+ INFO_PRINTF1(_L("Get Call Parameters..."));
+ console->Printf(_L("Get Call Parameters...\n"));
+ RCall::TCallParams callParams;
+ RCall::TCallParamsPckg callParamsPckg(callParams);
+ ret=iVoiceCall.GetCallParams(callParamsPckg);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::GetCallParams() ***"));
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Call Parameters is NOT Supported"));
+ }
+ if (ret==KErrNone)
+ {
+ INFO_PRINTF1(_L("Get Call Parameters is successful"));
+ }
+
+ // Post a 'New call added' notification
+ TName callName;
+ iLine.NotifyCallAdded(iStatus, callName);
+
+ // Open a 2nd Voice Call, see BeginTest() function for explanatory comments
+ INFO_PRINTF1(_L("Opening another Voice Call"));
+ console->Printf(_L("Opening another Voice Call\n"));
+ _LIT(KAutomaticName,"::");
+ TName callName2(iLineInfo.iName);
+ callName2.Append(KAutomaticName);
+
+ RMobileCall VoiceCall2;
+ INFO_PRINTF1(_L("Opening 2nd Voice Call"));
+ console->Printf(_L("Opening 2nd Voice Call\n"));
+ ret = VoiceCall2.OpenNewCall(iLine, CallName);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileCall::OpenNewCall() ***"));
+ if(ret == KErrNone)
+ {
+ INFO_PRINTF1(_L("2nd Voice Call opened successfully"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+ }
+
+ if(ret == KErrNotSupported) //we don't have anything to do, bye...
+ {
+ INFO_PRINTF1(_L("2nd Voice Call not supported "));
+ INFO_PRINTF1(_L("Hanging up"));
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-0"));
+ INFO_PRINTF1(_L("HangUp successful"));
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ return EInconclusive;
+ }
+
+
+ User::WaitForRequest(iStatus); // Notify Call added completion
+ if (iStatus==KErrNone)
+ {
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("Notify Call added status = %d")), iStatus.Int());
+ }
+
+ // Acquire Ownership Cancel Request
+ INFO_PRINTF1(_L("AcquireOwnership Cancel Request..."));
+ console->Printf(_L("AcquireOwnership Cancel Request...\n"));
+ VoiceCall2.AcquireOwnership(iStatus);
+ //doesn't work for MM.TSY
+ //TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-028.01"));
+
+ VoiceCall2.AcquireOwnershipCancel();
+ User::WaitForRequest(iStatus);
+ if (iStatus==KErrEtelCallNotActive)
+ {
+ INFO_PRINTF1(_L("Voice Call 2 is not currently active"));
+ }
+ else
+ {
+ INFO_PRINTF2(TRefByValue<const TDesC>(_L("AcquireOwnership Cancel status: %d")), iStatus.Int());
+ }
+
+ // Transfer Ownership Request
+ INFO_PRINTF1(_L("Voice Call 1 is trying to Transfer Ownership of the Call.."));
+ ret=iVoiceCall.TransferOwnership();
+ CHECKPOINT(ret, KErrEtelNoClientInterestedInThisCall, _L("GT83-TVOICE-029.01"));
+ INFO_PRINTF1(_L("There is no Client currently interested in Ownership"));
+
+ // Close the 2nd Voice Call
+ VoiceCall2.Close();
+ INFO_PRINTF1(_L("Closing the 2nd Voice Call"));
+ console->Printf(_L("Closing the 2nd Voice Call\n"));
+
+ // Hang up the Call
+ INFO_PRINTF1(_L("Hanging up"));
+ console->Printf(_L("Hanging up\n"));
+ iVoiceCall.HangUp(iStatus);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***"));
+ INFO_PRINTF1(_L("HangUp successful"));
+ console->Printf(_L("HangUp successful\n"));
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END();
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+//------------------------------------------------------------------
+
+CTestCloseCallWhenActive::CTestCloseCallWhenActive( )
+/* 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("TestCloseCallWhenActive"));
+ }
+//------------------------------------------------------------------
+
+enum TVerdict CTestCloseCallWhenActive::doTestStepL()
+//void CTestVoice::TestCloseCallWhenActiveL()
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+ console->Printf(_L("Test Call Close When Active..."));
+
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("GT83-TVOICE-Test15-LineOpened - *** Failed RMobileLine::Open() ***"));
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("*** RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+
+ //Activate a call by dialing a number
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::WaitForRequest(iStatus);
+ TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-Test15-CallDialled - *** Failed RMobileCall::Dial() ***"));
+
+ // Close call while it is active - without calling HangUp
+ User::After(5000000);
+ iVoiceCall.Close();
+ iLine.Close();
+ INFO_PRINTF1(_L("Close successful - check call not active on phone"));
+ console->Printf(_L("Close successful - check call not active on phone\n"));
+ TEST_END();
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+
+//SUBSTITUTE CLASS FOR DEFECT FIX DEF010965
+
+CTestLineCapabilities::CTestLineCapabilities()
+/* 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("TestLineCapabilities"));
+ }
+
+//------------------------------------------------------------------
+
+enum TVerdict CTestLineCapabilities::doTestStepL()
+/**
+* @test GT83-TVOICE-002.01 Test retrieval of a voice line's capabilities. Display the capabilities to screen
+*/
+ {
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+
+ _LIT(KStartText, "Test Line Capabilities") ; TEST_START(&KStartText) ;
+ console->Printf(_L("Test Line Capabilities\n"));
+
+ CleanupClosePushL(iVoiceCall) ;
+ CleanupClosePushL(iLine) ;
+
+ // Line Capabilities
+
+ RLine::TCaps lineCaps;
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));
+ TInt ret=iLine.GetCaps(lineCaps);
+ CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetCaps() ***")) ;
+ if (ret==KErrNotSupported)
+ {
+ INFO_PRINTF1(_L("Get Line Capabilities is NOT supported"));
+ }
+ else
+ {
+ if ((lineCaps.iFlags&RLine::KCapsData) !=0)
+ {
+ INFO_PRINTF1(_L("This line supports Data connections"));
+ }
+ if ((lineCaps.iFlags&RLine::KCapsFax) !=0)
+ {
+ INFO_PRINTF1(_L("This line supports Fax connections"));
+ }
+ if ((lineCaps.iFlags&RLine::KCapsVoice) !=0)
+ {
+ INFO_PRINTF1(_L("This line supports Voice connections"));
+ }
+ if ((lineCaps.iFlags&RLine::KCapsEventIncomingCall) !=0)
+ {
+ INFO_PRINTF1(_L("This line supports Incoming Call Notification requests"));
+ }
+ }
+
+ // Close the line and call
+ CleanupStack::PopAndDestroy(&iLine) ;
+ CleanupStack::PopAndDestroy(&iVoiceCall) ;
+
+ TEST_END() ;
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ return TestStepResult();
+ }
+
+CTestCancelDialRequest::CTestCancelDialRequest()
+/* 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("TestCancelDialRequest"));
+ }
+
+
+enum TVerdict CTestCancelDialRequest::doTestStepL()
+{
+
+// void CTestVoice::TestCancelDialRequestL()
+// {
+
+ CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));
+ CleanupStack::PushL(console);
+ console->Printf(_L("Test Cancel Dial Request...\n"));
+
+
+ User::After(2000000); //settling pause to allow previous test to complete hang up first.
+
+ //Tests cancelling dial requests for various periods after they are made.
+ INFO_PRINTF1(_L("Opening Voice Line"));
+ console->Printf(_L("Opening Voice Line\n"));
+ TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("GT83-TVOICE-Test15-LineOpened - *** Failed RMobileLine::Open() ***"));
+
+ TName CallName ;
+ INFO_PRINTF1(_L("Opening New Voice Call"));
+ console->Printf(_L("Opening New Voice Call\n"));
+ TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("*** RMobileCall::OpenNewCall() ***"));
+ INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);
+
+ TBuf<16> GoodNumber ;
+ GetGoodNumber(GoodNumber) ;
+
+ //Cancel Tests
+
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::After(500000); //cancel after 0.5 second
+ INFO_PRINTF1(_L("Cancelling Dial After 0.5s..."));
+ console->Printf(_L("Cancelling Dial After 0.5s...\n"));
+ iVoiceCall.DialCancel();
+ User::WaitForRequest(iStatus);
+
+ if(iStatus==KErrCancel)
+ {
+ INFO_PRINTF1(_L("Dial Cancelled ok!..."));
+ }
+
+ if(iStatus==KErrNone)
+ {
+ INFO_PRINTF1(_L("Dial Cancel Request after 0.5sec of dialling, Failed..."));
+ iVoiceCall.HangUp(iStatus);
+ INFO_PRINTF1(_L("Call Hang Up Requested..."));
+ User::WaitForRequest(iStatus);
+ // Removed SetTestStepResult(EFail); here because original TS_Voice test always returns EPass anyway
+ }
+
+ INFO_PRINTF1(_L("Wait For Next Dial..."));
+ console->Printf(_L("Wait For Next Dial...\n"));
+ User::After(5000000); //wait 5 seconds
+
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::After(1000000); //cancel after 1.0 seconds
+ INFO_PRINTF1(_L("Cancelling Dial After 1.0s..."));
+ console->Printf(_L("Cancelling Dial After 1.0s...\n"));
+ iVoiceCall.DialCancel();
+ User::WaitForRequest(iStatus);
+
+ if(iStatus==KErrCancel)
+ {
+ INFO_PRINTF1(_L("Dial Cancelled ok!..."));
+ }
+
+ else
+ {
+ INFO_PRINTF1(_L("Dial Cancel Request after 1sec of dialling, Failed..."));
+ iVoiceCall.HangUp(iStatus);
+ INFO_PRINTF1(_L("Call Hang Up Requested..."));
+ User::WaitForRequest(iStatus);
+ // Removed SetTestStepResult(EFail); here because original TS_Voice test always returns EPass anyway
+ }
+
+ INFO_PRINTF1(_L("Wait For Next Dial..."));
+ console->Printf(_L("Wait For Next Dial...\n"));
+ User::After(3000000); //wait 3 seconds
+
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::After(1500000); //cancel after 1.5 seconds
+ INFO_PRINTF1(_L("Cancelling Dial After 1.5s..."));
+ console->Printf(_L("Cancelling Dial After 1.5s...\n"));
+ iVoiceCall.DialCancel();
+ User::WaitForRequest(iStatus);
+
+ if(iStatus==KErrCancel)
+ {
+ INFO_PRINTF1(_L("Dial Cancelled ok!..."));
+ }
+
+ else
+ {
+ INFO_PRINTF1(_L("Dial Cancel Request after 1.5sec of dialling, Failed..."));
+ iVoiceCall.HangUp(iStatus);
+ INFO_PRINTF1(_L("Call Hang Up Requested..."));
+ User::WaitForRequest(iStatus);
+ // Removed SetTestStepResult(EFail); here because original TS_Voice test always returns EPass anyway
+ }
+
+ INFO_PRINTF1(_L("Wait For Next Dial..."));
+ console->Printf(_L("Wait For Next Dial...\n"));
+ User::After(3000000); //wait 3 seconds
+
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::After(2000000); //cancel after 2.0 seconds
+ INFO_PRINTF1(_L("Cancelling Dial After 2.0s..."));
+ console->Printf(_L("Cancelling Dial After 2.0s...\n"));
+ iVoiceCall.DialCancel();
+ User::WaitForRequest(iStatus);
+
+ if(iStatus==KErrCancel)
+ {
+ INFO_PRINTF1(_L("Dial Cancelled ok!..."));
+ }
+
+ else
+ {
+ INFO_PRINTF1(_L("Dial Cancel Request after 2sec of dialling, Failed..."));
+ iVoiceCall.HangUp(iStatus);
+ INFO_PRINTF1(_L("Call Hang Up Requested..."));
+ User::WaitForRequest(iStatus);
+ // Removed SetTestStepResult(EFail); here because original TS_Voice test always returns EPass anyway
+ }
+
+ User::After(3000000); //wait 3 seconds
+
+ //Connect without cancelling
+ INFO_PRINTF1(_L("Now Dialling without Cancelling..."));
+ console->Printf(_L("Now Dialling without Cancelling...\n"));
+ INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);
+ console->Printf(_L("Dialling %S....\n"), &GoodNumber);
+ iVoiceCall.Dial(iStatus, GoodNumber);
+ User::WaitForRequest(iStatus);
+ TEST(iStatus.Int() == KErrNone);
+ if(iStatus == KErrNone)
+ {
+ INFO_PRINTF1(_L("Connected Ok. Please wait, will hang up shortly..."));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Failed subsequant dial without cancelling!"));
+ }
+
+ User::After(10000000);
+ INFO_PRINTF1(_L("Closing call..."));
+ console->Printf(_L("Closing call...\n"));
+ iVoiceCall.Close();
+ iLine.Close();
+
+ INFO_PRINTF1(_L("Close successful - check call not active on phone"));
+ console->Printf(_L("Close successful - check call not active on phone\n"));
+
+ console->Printf(_L("Finished\n"));
+ User::After(10*KOneSecond);
+ CleanupStack::PopAndDestroy(console);
+
+ // Returns EPass as it is debatable if this is a valid test as the functionality
+ // being tested is very network dependant but test has been left none the less
+ SetTestStepResult(EPass);
+ return EPass;
+ }