diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/multimodetsy/test/Te_Data/Te_Data.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/multimodetsy/test/Te_Data/Te_Data.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2222 @@ +// Copyright (c) 2002-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 to test the Data Line abilities of MMTSY and ETel. +// +// + +/** + @file +*/ + +#include "Te_Data.h" + +_LIT(KDataLineName,"Data"); +_LIT(KCsyName, "ECUART.CSY"); +_LIT(KConsoleTitle,"Action Required"); + +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) +const TInt KFifteenSeconds=15000000; // 5 seconds (in microSeconds) + +_LIT8(KWriteTestData,"MM TSY Data and Echo Server Test is in progress..."); + + +CTestLineStatusIncommingCall::CTestLineStatusIncommingCall() +/** 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("TestLineStatusIncommingCall")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineStatusIncommingCall::doTestStepL( void ) +/** Tests line status function + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic) + * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle""" + * @test GT83-TDATA-004.04 "Test retrieval of a data line's current status when the line's status is ""Ringing""" + * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected""" + * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up""" + * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic) + * @test GT83-TDATA-031.01 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Idle""" + * @test GT83-TDATA-031.04 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Answering""" + * @test GT83-TDATA-031.07 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Waiting CCBS Recall""" +*/ + { + INFO_PRINTF1(_L("======Start test Test Line Status")); + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + + RCall::TStatus lineStatus; + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-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("GT83-TDATA-004.00 - *** Failed RMobileLine::GetStatus() ***")) ; + CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + RMobileCall::TMobileCallStatus mobileLineStatus; + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.00 - *** Failed RMobileLine::GetMobileLineStatus() ")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ; + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + TName callName; + /* @test GT83-AT-024 Test setting notification of an incoming call on a data line */ + iLine.NotifyIncomingCall(iStatus, callName); // wait for a call + WaitWithTimeoutL(iStatus,60*KOneSecond); // but timeout after 60 second + + + CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::NotifyIncomingCall() ***")) ; + if(iStatus.Int() == KRequestPending) + { + iLine.NotifyIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + /* @test GT83-AT-36 Test retrieval of the current call status when it is ringing*/ + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetStatus() *** ")) ; + CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-0")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetMobileLineStatus() *** ")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-008.001")) ; + INFO_PRINTF1(_L("Phone is ringing...")); + + //Test for incomming data call + TestLineCapabilitiesL(iLine); + + /* @test GT83-AT-028 Test opening a new call by specifying the name of a line + */ + ret = iDataCall.OpenExistingCall(iLine, callName); + TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05 - *** Failed RMobileCall::OpenExistingCall() ***")) ; + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + + // DEF55659-NCh : timout changed from 30 to 60 s. Current version of MM.TSY is pretty slow, due + // to the way it deal with the new comms repository. This timeout must be changed back to 30s + // when comms repository access code is updated. + WaitWithTimeoutL(iStatus,60*KOneSecond); // but timeout after 60 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00 - *** Failed RMobileCall::AnswerIncomingCall() ***")) ; + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.04 - *** Failed RMobileLine::GetStatus() ***")) ; + CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.04")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.04 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.04")) ; + TestLineCapabilitiesL(iLine); + + /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/ + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.07 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.07")) ; + + User::After(10*KOneSecond); + + INFO_PRINTF1(_L("Hanging Up")); + iDataCall.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("GT83-TDATA-004.08 - *** Failed RMobileLine::GetStatus() *** ")) ; + CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-0")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.09 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-004.09")) ; + + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; //??? line 825 + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + //Check that line status is now idle. If line is still connected, Fail check and leave to + //prevent problems down the line + /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/ + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02 - *** Failed RMobileLine::GetStatus() ***")) ; + TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02 - *** FAILED TO HANGUP CALL!! ***" )) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/ + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineStatusOutgoingCall::doTestStepL( void ) +/** Tests line status function + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic) + * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle""" + * @test GT83-TDATA-004.03 "Test retrieval of a data line's current status when the line's status is ""Dialling""" + * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected""" + * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up""" + * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call + * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic) + * @test GT83-TDATA-031.01 "Test retrieval of a mobile data line's current status when there is only one call on the line and it's status is ""Idle""" +*/ + { + INFO_PRINTF1(_L("======Start test Test Line Status")); + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + + TName callName; + + RCall::TStatus lineStatus; + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-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("GT83-TDATA-004.00 - *** Failed RMobileLine::GetStatus() ***")) ; + CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + RMobileCall::TMobileCallStatus mobileLineStatus; + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.00 - *** Failed RMobileLine::GetMobileLineStatus() ")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ; + + /* @test GT83-AT-028 Test opening a new call by specifying the name of a line + */ + ret = iDataCall.OpenNewCall(iLine, callName); + TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05 - *** Failed RMobileCall::OpenNewCall() ***")) ; + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Calling...\n")); + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetStatus() *** ")) ; + //Commented out because phone does not report that it is going into this state + //TEST_CHECKL(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-004.03")) ; + WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds + CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + if(iStatus.Int() == KRequestPending) + { + iDataCall.DialCancel(); + User::WaitForRequest(iStatus); + } + + //Test for outgoing data call + TestLineCapabilitiesL(iLine); + + /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/ + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07 - *** Failed RMobileLine::GetStatus() *** ")) ; + CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-0")) ; + + 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...")); + + User::After(20*KOneSecond); // hold call active for 20 seconds + + INFO_PRINTF1(_L("Hanging up")); + iDataCall.HangUp(iStatus); + + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.08 - *** Failed RMobileLine::GetStatus() *** ")) ; + CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-004.08")) ; + + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some troubles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + //Test line capabilities + TestLineCapabilitiesL(iLine); + + ret = iLine.GetStatus(lineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02 - *** Phone Failed to hang up ***")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.01 - *** Failed RMobileLine::GetMobileLineStatus() *** ")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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 + SetTestStepName(_L("TestLineInfo")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineInfo::doTestStepL( void ) +/** + * 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 data line (Generic) + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-005.01 "Test retrieval of the current hook status, when the line is currently ""off hook""" + * @test GT83-TDATA-005.02 "Test retrieval of the current hook status, when the line is currently ""on hook""" + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + * @test GT83-TDATA-026.02 Test the ability to place an asynchronous request to hang up a data call + */ + { + INFO_PRINTF1(_L("======Start test Test Line Information")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01 - *** Failed RMobileLine::Open() ***")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06 - *** Failed RMobileCall::OpenNewCall() ***")); + + // Line Information + RLine::TLineInfo lineInfo; + TRAPD(ret, ret=iLine.GetInfo(lineInfo)); + CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetInfo ***")); + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Line Info. is NOT supported")); + } + else + { + INFO_PRINTF1(_L("Get Line Info is successful")); + CHECKPOINT(lineInfo.iHookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-0")) ; + TEST(lineInfo.iStatus == RCall::EStatusIdle) ; + INFO_PRINTF2(TRefByValue(_L("Name of last call added: %S")), &lineInfo.iNameOfLastCallAdded); + } + + // Hook status information + INFO_PRINTF1(_L("\nRetrieving Hook Status...")); + RCall::THookStatus hookStatus; + ret=iLine.GetHookStatus(hookStatus); + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Hook status is NOT supported")); + } + else + { + CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-005.02")) ; + INFO_PRINTF1(_L("The line is currently ON Hook")); + } + + // Post 'Answer a Call' Notifications + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + + WaitWithTimeoutL(iStatus,6*KTenSeconds); // but timeout after 60 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00 - *** Failed RMobileCall::AnswerIncomingCall() ***")) ; + + // Count the no. of calls on the line & Get call info. + INFO_PRINTF1(_L("Retrieving no. of calls opened from the line..")); + TInt lineCount=0; + TEST(KErrNone == iLine.EnumerateCall(lineCount)); + INFO_PRINTF2(TRefByValue(_L("No of calls opened = %d")), lineCount); + + INFO_PRINTF1(_L("Getting Call info..")); + RLine::TCallInfo callInfo; + ret=iLine.GetCallInfo(0,callInfo); + 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); + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Hook status is NOT supported")); + } + else + { + TEST_CHECKL(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-005.01")) ; + INFO_PRINTF1(_L("The line is currently OFF Hook")); + } + + User::After(KTenSeconds); + + INFO_PRINTF1(_L("Hanging up")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + return TestStepResult() ; + } +//------------------------------------------------------------------ + +CTestLineNotificationsIncommingCall::CTestLineNotificationsIncommingCall() +/** 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("TestLineNotificationsIncommingCall")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineNotificationsIncommingCall::doTestStepL( void ) +/** Tests line notifications + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-008.01 Test setting notification of an incoming call on a data line + * @test GT83-TDATA-008.02 Test for a notification when there is an incoming call on a data line + * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line + * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on""" + * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off""" + * @test GT83-TDATA-010.01 Test setting notification of a change in the status of the data line + * @test GT83-TDATA-010.02 "Test notification of a change in the status of the data line from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""" + * @test GT83-TDATA-011.01 Test setting notification of a call being added to a data line + * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + * @test GT83-TDATA-032.01 Test setting a request for a notification of a change in the status of the mobile data line + * @test GT83-TDATA-032.07 "Test for a notification of a change in status of the mobile data line from ""connected"" to ""disconnecting""" + * @test GT83-TDATA-032.08 "Test for a notification of a change in status of the mobile data line from ""disconnecting"" to ""idle""" + * @test GT83-TDATA-032.09 "Test for a notification of a change in status of the mobile data line from ""idle"" to ""ringing""" + * @test GT83-TDATA-032.10 "Test for a notification of a change in status of the mobile data line from ""ringing"" to ""answering""" + * @test GT83-TDATA-032.11 "Test for a notification of a change in status of the mobile data line from ""answering"" to ""connected""" +*/ + { + INFO_PRINTF1(_L("======Start test Test Line Notifications")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; + + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + + // NotifyIncomingCall and NotifyStatusChange + TName callName1; + TName callName2; + TInt ret = KErrNone; + RCall::TStatus lineStatus; + RMobileCall::TMobileCallStatus mobileLineStatus; + RCall::THookStatus hookStatus; + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + iLine.NotifyIncomingCall(iStatus, callName1); // wait for a call + + // @test GT83-AT-026 Test setting notification of a change in the status of the data line + iLine.NotifyStatusChange(iStatus2, lineStatus); + + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + + // @test GT83-AT-037 Test setting notification of a change in hook status of a data line void RLine::NotifyHookChange(TRequestStatus& aStatus, THookStatus& aHookStatus) Function does not produce any unexpected errors. aStatus = KErrPending + iLine.NotifyHookChange(iStatus4, hookStatus); + + /* @test GT83-AT-025 Test notification of a call being added to a data line */ + iLine.NotifyCallAdded(iStatus5, callName2); + + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.01")) ; + CHECKPOINT(iStatus2.Int(), KRequestPending, _L("GT83-TDATA-010.02")) ; + CHECKPOINT(iStatus3.Int(), KRequestPending, _L("GT83-TDATA-032.01")) ; + CHECKPOINT(iStatus4.Int(), KRequestPending, _L("GT83-TDATA-011.01")) ; + CHECKPOINT(iStatus5.Int(), KRequestPending, _L("GT83-TDATA-009.01")) ; + + WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds + CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-008.02")) ; + + if(iStatus.Int() == KRequestPending) + { + iLine.NotifyIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + // @test GT83-AT-026 Test notification of a change in the status of the data line + // from "idle" to "ringing" + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ; + CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-010.02")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.09")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-032.09")) ; + + /* @test GT83-AT-025 Test notification of a call being added to a data line + that currently has no calls*/ + User::WaitForRequest(iStatus5); + CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TDATA-011.01")) ; + CHECKPOINT(callName2 == callName1, 1, _L("GT83-TDATA-011")) ; + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + INFO_PRINTF1(_L("Phone is ringing... Now answering...")); + + /* @test GT83-AT-026 Test notification of a change in the status of the data line from + "idle" to "ringing" to "answering" to "connected" to "hanging up" to "idle" + */ + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + + ret = iDataCall.OpenExistingCall(iLine, callName1); + TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05")) ; + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + // @test GT83-AT-026 Test notification of a change in the status of the data line + // from "ringing" to "answering" + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ; + CHECKPOINT(lineStatus, RCall::EStatusAnswering, _L("GT83-TDATA-010.01")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.10")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-032.10")) ; + WaitWithTimeoutL(iStatus,30*KOneSecond); // but timeout after 30 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; //wrong code -2147483647 + + + // @test GT83-AT-026 Test notification of a change in the status of the data line + // from "answering" to "connected" + iLine.NotifyStatusChange(iStatus2, lineStatus); + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ; + CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.01")) ; + + + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.11")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.11")) ; + + User::WaitForRequest(iStatus4); + CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.02")) ; + CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-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...")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + // @test GT83-AT-026 Test notification of a change in the status of the data line + // from "connecting" to "hanging up" + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ; + CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.02")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-032.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-TDATA-010.02")) ; + CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.02")) ; + + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-032.08")) ; + + //!< @test GT83-AT-037 Test notification of a change in hook status of a data 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-TDATA-009.03")) ; + CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.03")) ; + //check that all request has been finished + TEST(iStatus.Int()!= KRequestPending) ; + TEST(iStatus2.Int() != KRequestPending) ; + TEST(iStatus3.Int() != KRequestPending) ; + TEST(iStatus4.Int() != KRequestPending) ; + TEST(iStatus5.Int() != KRequestPending) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineNotificationsOutgoingCall::doTestStepL( void ) +/** Tests line notifications + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on""" + * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off""" + * @test GT83-TDATA-010.03 "Test notification of a change in the status of the data line from ""idle"" to ""dialling"" to ""connecting"" to ""connected"" to ""hanging up"" to ""idle""" + * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call + * @test GT83-TDATA-032.02 "Test for a notification of a change in status of the mobile data line from ""idle"" to ""dialling""" + * @test GT83-TDATA-032.04 "Test for a notification of a change in status of the mobile data line from ""connecting"" to ""connected""" + * @test GT83-TDATA-032.07 "Test for a notification of a change in status of the mobile data line from ""connected"" to ""disconnecting""" + * @test GT83-TDATA-032.08 "Test for a notification of a change in status of the mobile data line from ""disconnecting"" to ""idle""" +*/ + { + INFO_PRINTF1(_L("======Start test Test Line Notifications")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; + + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + + // NotifyIncomingCall and NotifyStatusChange + TInt ret = KErrNone; + RCall::TStatus lineStatus; + RMobileCall::TMobileCallStatus mobileLineStatus; + RCall::THookStatus hookStatus; + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + ret = iDataCall.OpenNewCall(iLine); + TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05")) ; + // Now test call status during an outgoing call + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + iLine.NotifyHookChange(iStatus4, hookStatus); + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Calling...\n")); + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECKPOINT(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.02")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDialling, _L("GT83-TDATA-032.02")) ; + + User::WaitForRequest(iStatus); //whaiting for dial + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + User::WaitForRequest(iStatus4); + CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.03")) ; + CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.03")) ; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.13")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.13")) ; + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + INFO_PRINTF1(_L("Call connected - hanging up...")); + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + iLine.NotifyHookChange(iStatus4, hookStatus); + + //HANG UP + User::After(10*KOneSecond); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-032.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-TDATA-009.02")) ; + CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.02")) ; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ; + CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-032.08")) ; + + TEST(iStatus != KRequestPending) ; + TEST(iStatus2 != KRequestPending) ; + TEST(iStatus3 != KRequestPending) ; + TEST(iStatus4 != KRequestPending) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestLineCancels::doTestStepL( void ) +/** + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-008.02 Test for a notification when there is an incoming call on a data line + * @test GT83-TDATA-008.03 Test the ability to cancel the notification of an incoming call on a data line + * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line + * @test GT83-TDATA-009.04 Test the ability to cancel a notification of a change in hook status of a data line + * @test GT83-TDATA-010.02 "Test notification of a change in the status of the data line from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""" + * @test GT83-TDATA-010.04 Test the ability to cancel the notification of a change in the status of the data line + * @test GT83-TDATA-011.01 Test setting notification of a call being added to a data line + * @test GT83-TDATA-011.03 Test the ability to cancel a notification of a call being added to a data line +*/ + { + INFO_PRINTF1(_L("======Start test Test Line Cancels")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + + // Notify Incoming Call + TName callName; + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + iLine.NotifyIncomingCall(iStatus, callName); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.02")) ; + iLine.NotifyIncomingCallCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-008.03")) ; + + // Notify Status Change + RCall::TStatus lineStatus; + iLine.NotifyStatusChange(iStatus, lineStatus); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-010.02")) ; + User::After(KTenPartOfSec); //snack some sleep + /** @test GT83-AT-026 Test the ability to cancel the notification of a change in the + status of the data line aStatus = KErrCancel provided that the function + being cancelled has not already completed */ + iLine.NotifyStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-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-TDATA-0")) ; + iLine.NotifyMobileLineStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + // Notify Hook Change + RCall::THookStatus hookStatus; + iLine.NotifyHookChange(iStatus, hookStatus); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-009.01")) ; + User::After(KTenPartOfSec); //snack some sleep + // @test GT83-AT-037 Test the ability to cancel a notification of a + // change in hook status of a data line + // aStatus = KErrCancel provided that the function being cancelled has not already completed + iLine.NotifyHookChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-009.04")) ; + + // Notify Call Added + iLine.NotifyCallAdded(iStatus, callName); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-011.01")) ; + User::After(KTenPartOfSec); //snack some sleep + /** GT83-AT-025 Test the ability to cancel a notification of a call being added + to a data line*/ + iLine.NotifyCallAddedCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-011.03")) ; + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestCallInfo::doTestStepL( void ) +/** + * This function gets information pertaining to a call: + * Bearer Service Information, Call duration + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on""" + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-018.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-TDATA-022.01 Test retrieval of the duration of a data call. Display the call duration to screen + * @test GT83-TDATA-023.01 Test the ability to get the current call information of the data call. Display the call information to screen. + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + */ + { + INFO_PRINTF1(_L("======Start test Test Call Information")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + //get status + //GT83-AT-026 Test retrieval of a data line's current status. + RCall::TStatus callStatus; + CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TD-015.02")) ; + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TD-015.02")) ; + + INFO_PRINTF2(_L("Call Status = %d"), callStatus); + Print_RCall_TStatus(callStatus) ; + + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + + // Wait for an incoming call, then get the Call BearerServiceInfo. The + // Bearer Service Info is only available if the call is currently active + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + WaitWithTimeoutL(iStatus,60*KOneSecond); // but timeout after 60 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + + // User Information + INFO_PRINTF1(_L("\nThe call is now connected.\nRetrieving Call Information.")); + + // Bearer Service Information + INFO_PRINTF1(_L("\nGet Bearer Service Info...")); + RCall::TBearerService bearerServiceInfo; + TInt ret=iDataCall.GetBearerServiceInfo(bearerServiceInfo); + CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-018.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("\nGet Current Call Info...")); + ret=iDataCall.GetInfo(iCallInfo); + CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-023.01")) ; + 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(_L("Call name: %S")), &iCallInfo.iCallName); + INFO_PRINTF2(TRefByValue(_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(_L("Call Duration: %d seconds")), iCallInfo.iDuration.Int()); + } + + // Hang up the Call + User::After(5*KOneSecond); + + // Call Duration + INFO_PRINTF1(_L("Get Call Duration...")); + TTimeIntervalSeconds callDuration2; + ret=iDataCall.GetCallDuration(callDuration2); + CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-022.01")) ; + if (ret==KErrNotSupported) + { + INFO_PRINTF1(_L("Get Current Call Duration is NOT Supported")); + } + if (ret==KErrNone) + { + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), callDuration2.Int()); + } + + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + return TestStepResult() ; + } +//------------------------------------------------------------------ + +CTestCallNotifications::CTestCallNotifications() +/** 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("TestCallNotifications")); + } +//------------------------------------------------------------------ + +TVerdict CTestCallNotifications::doTestStepL( void ) +/** + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-002.01 Test retrieval of a data line's capabilities. Display the capabilities to screen + * @test GT83-TDATA-008.01 Test setting notification of an incoming call on a data line + * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on""" + * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off""" + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-014.05 Test opening an existing call from a data line by specifying the name of the line and the name of an existing call + * @test GT83-TDATA-015.04 "Test retrieval of the current call status when the call's status is ""ringing""" + * @test GT83-TDATA-015.05 "Test retrieval of the current call status when the call's status is ""answering""" + * @test GT83-TDATA-017.02 Test notification of a change in the call's capabilities. Print the call's capabilities to screen + * @test GT83-TDATA-020.02 "Test notification of a change in the status of the data call from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""" + * @test GT83-TDATA-021.01 Test setting notification of a change in the data call's duration + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + * @test GT83-TDATA-034.01 Test setting notification of a change in the call's dynamic call control and call event capabilities + * @test GT83-TDATA-034.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-TDATA-035.04 "Test retrieval of the current status of the data call when the call's status is ""ringing""" + * @test GT83-TDATA-036.07 "Test for a notification of a change in status of the mobile data call from ""connected"" to ""disconnecting""" + * @test GT83-TDATA-036.08 "Test for a notification of a change in status of the mobile data call from ""disconnecting"" to ""idle""" + * @test GT83-TDATA-036.10 "Test for a notification of a change in status of the mobile data call from ""ringing"" to ""answering""" + * @test GT83-TDATA-036.11 "Test for a notification of a change in status of the mobile data call from ""answering"" to ""connected""" +*/ + + { + // Post call status change notifications + INFO_PRINTF1(_L("======Start test Test Call Notifications")); + TName callName1; + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + RCall::TStatus callStatus; + RMobileCall::TMobileCallStatus mobileCallStatus; + + RCall::TCaps caps; + RCall::THookStatus hookStatus; + TTimeIntervalSeconds time; + + RMobileCall::TMobileCallCapsV1 mobileCallCaps; + RMobileCall::TMobileCallCapsV1Pckg mobileCallCapsPckg(mobileCallCaps); + + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + iLine.NotifyIncomingCall(iStatus, callName1); // wait for a call + + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.01")) ; + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds + CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-008.01")) ; + if(iStatus.Int() == KRequestPending) + { + iLine.NotifyIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + + TInt ret = iDataCall.OpenExistingCall(iLine, callName1); + TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05")) ; + + iDataCall.GetStatus(callStatus); + CHECKPOINT(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-015.04")) ; + iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-035.04")) ; + + ret=iDataCall.GetCaps(caps); + Print_TCapsEnum(caps) ; + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-002.01")) ; + TEST(caps.iFlags==(RCall::KCapsData | RCall::KCapsAnswer)); + +// INFO_PRINTF1(_L("Opening New Data Call")); +// TEST_CHECKL(iiDataCall.OpenExistingCall(theLine, callName2), KErrNone, _L("GT83-TDATA-013.06")) ; + + iDataCall.NotifyStatusChange(iStatus2, callStatus); + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + iDataCall.NotifyCapsChange(iStatus4, caps); + iDataCall.NotifyHookChange(iStatus5, hookStatus); + iDataCall.NotifyCallDurationChange(iStatus6, time) ; + iDataCall.NotifyMobileCallCapsChange(iStatus7, mobileCallCapsPckg); + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + INFO_PRINTF1(_L("Phone is ringing... Now answering...")); + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + //GT83-AT-032 Test answering a call on a data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + + iDataCall.GetStatus(callStatus); + CHECKPOINT(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-015.05")) ; + + WaitWithTimeoutL(iStatus,60*KOneSecond); // but timeout after 60 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + + + //iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECKPOINT(callStatus, RCall::EStatusAnswering, _L("GT83-TDATA-020.10")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.10")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-036.10")) ; + + iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECKPOINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-020.02")) ; + + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.11")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-036.11")) ; + + User::WaitForRequest(iStatus4); + CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-017.02")) ; + Print_TCapsEnum(caps) ; + CHECKPOINT(caps.iFlags, RCall::KCapsData, _L("GT83-TDATA-017.02")) ; + + iDataCall.NotifyCapsChange(iStatus4, caps); + User::WaitForRequest(iStatus4); + CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-017.02")) ; + //TEST_CHECKL(caps.iFlags, (RCall::KCapsData | RCall::KCapsHangUp), _L("GT83-TDATA-017.02")) ; + //MKV error + + User::WaitForRequest(iStatus5); + CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TDATA-009.03")) ; + CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.03")) ; + + User::WaitForRequest(iStatus6); + CHECKPOINT_EXPR((iStatus6.Int()==KErrNone || iStatus6.Int()==KErrNotSupported), _L("GT83-TDATA-021.01")) ; + if (iStatus6==KErrNotSupported) + { + INFO_PRINTF1(_L("Notify Call Duration Change is NOT Supported")); + } + if (iStatus6==KErrNone) + { + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), time.Int()); + } + + User::WaitForRequest(iStatus7); + CHECKPOINT(iStatus7.Int(), KErrNone, _L("GT83-TDATA-034.01")) ; + CHECKPOINT(mobileCallCaps.iCallControlCaps, RCall::KCapsData, _L("GT83-TDATA-034.01")) ; + iDataCall.NotifyMobileCallCapsChange(iStatus7, mobileCallCapsPckg); + User::WaitForRequest(iStatus7); + CHECKPOINT(iStatus7.Int(), KErrNone, _L("GT83-TDATA-034.02")) ; + //TEST_CHECKL(mobileCallCaps.iCallControlCaps, (RCall::KCapsData | RCall::KCapsHangUp), _L("GT83-TDATA-034.02")) ; + //MKV error + + // now hangup call + iDataCall.NotifyStatusChange(iStatus2, callStatus); + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + + INFO_PRINTF1(_L("Call connected - now hanging up...")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; //sometimes timed out -33 + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECKPOINT(callStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-020.02")) ; + + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.07")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-036.07")) ; + + iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-020.02")) ; + + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + User::WaitForRequest(iStatus3); + CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.08")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-036.08")) ; + + TEST(iStatus != KRequestPending) ; + TEST(iStatus2 != KRequestPending) ; + TEST(iStatus3 != KRequestPending) ; + TEST(iStatus4 != KRequestPending) ; + TEST(iStatus5 != KRequestPending) ; + TEST(iStatus6 != KRequestPending) ; + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + return TestStepResult() ; + } +//------------------------------------------------------------------ + +CTestCallStatusIncommingCall::CTestCallStatusIncommingCall() +/** 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("TestCallStatusIncommingCall")); + } +//------------------------------------------------------------------ + +TVerdict CTestCallStatusIncommingCall::doTestStepL( void ) +/** + * This function tests call status at various times during calls + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-023.01 Test the ability to get the current call information of the data call. Display the call information to screen. + * @test GT83-TDATA-035.02 "Test retrieval of the current status of the data call when the call's status is ""idle""" + * @test GT83-TDATA-035.04 "Test retrieval of the current status of the data call when the call's status is ""ringing""" + * @test GT83-TDATA-035.05 "Test retrieval of the current status of the data call when the call's status is ""answering""" + * @test GT83-TDATA-035.07 "Test retrieval of the current status of the data call when the call's status is ""connected""" + */ + { + // Get the Call Status + INFO_PRINTF1(_L("======Start test Get Call Status")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + + // Open a Data line and Call + RCall::TStatus callStatus; + RMobileCall::TMobileCallStatus mobileCallStatus; + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + + TInt ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + TInt ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT_EXPR((ret2==KErrNone || ret2==KErrNotSupported), _L("GT83-TDATA-035.02")) ; + if (ret==KErrNotSupported) + { + INFO_PRINTF1(_L("Get Call Status is NOT Supported")); + } + + if (ret2==KErrNotSupported) + { + INFO_PRINTF1(_L("Get Mobile Call Status is NOT Supported")); + } + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle")); + } + + // Now test call status during an incomming call + + // Wait for an incoming call, then get the Call BearerServiceInfo. The + // Bearer Service Info is only available if the call is currently active + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Please ring the phone\n")); + + /* @test GT83-AT-024 Test setting notification of an incoming call on a data line */ + //commented out because connecting process too long and modem breaks connection + // by temeout +// iLine.NotifyIncomingCall(iStatus, callName); // wait for a call +// WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds + + ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.04")) ; +// TEST_CHECKL(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-004.04.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; +// TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-035.04")) ; + +// INFO_PRINTF1(_L("Phone is ringing...")); + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + ret=iDataCall.GetStatus(callStatus); + //TEST_CHECKL(callStatus, RCall::EStatusAnswering, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + //TEST_CHECKL(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-035.05")) ; + WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + Print_RCall_TStatus(callStatus) ; + CHECKPOINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-035.07")) ; + INFO_PRINTF1(_L("The call is Connected")); + } + + INFO_PRINTF1(_L("Hanging up...")); + + User::After(10*KOneSecond); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(ret2, KErrNone, _L("GT83-TDATA-035.02")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle again")); + } + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestCallStatusOutgoingCall::doTestStepL( void ) +/** + * This function tests call status at various times during calls + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-023.01 Test the ability to get the current call information of the data call. Display the call information to screen. + * @test GT83-TDATA-024.00 Test dialling a data call (Generic) + * @test GT83-TDATA-035.02 "Test retrieval of the current status of the data call when the call's status is ""idle""" + * @test GT83-TDATA-035.07 "Test retrieval of the current status of the data call when the call's status is ""connected""" + */ + { + // Get the Call Status + INFO_PRINTF1(_L("======Start test Get Call Status...")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + + RCall::TStatus callStatus; + RMobileCall::TMobileCallStatus mobileCallStatus; + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + TBuf<16> GoodNumber ; + GetRemoteNumber(GoodNumber) ; + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + + TInt ret=iDataCall.GetStatus(callStatus); + CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-004.02")) ; + TInt ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT_EXPR((ret2==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-035.02")) ; + + if (ret==KErrNotSupported) + { + INFO_PRINTF1(_L("Get Call Status is NOT Supported")); + } + + if (ret2==KErrNotSupported) + { + INFO_PRINTF1(_L("Get Mobile Call Status is NOT Supported")); + } + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle")); + } + + // Now test call status during an outgoing call + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Calling...\n")); + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-024.00")) ; + + ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + + Print_RCall_TStatus(callStatus) ; + CHECKPOINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-035.07")) ; + INFO_PRINTF1(_L("The call is Connected")); + } + + console->Printf(_L("Please stay connected... the test will hang up shortly\n")); + + INFO_PRINTF1(_L("Hanging up...")); + + User::After(10*KOneSecond); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + ret=iDataCall.GetStatus(callStatus); + CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECKPOINT(ret2, KErrNone, _L("GT83-TDATA-035.02")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + CHECKPOINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle again")); + } + + console->Printf(_L("...Disconnected\n")); + User::After(10*KOneSecond); + CleanupStack::PopAndDestroy(console); + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + 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")); + } +//------------------------------------------------------------------ + +TVerdict CTestCallCancels::doTestStepL( void ) +/** + * This function posts and then cancels Call Notifications. + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-017.01 Test setting notification of a change in the call's capabilities + * @test GT83-TDATA-017.03 Test the ability to cancel a notification of a change in the call's capabilities + * @test GT83-TDATA-019.01 Test setting notification of a change in hook status of a data call + * @test GT83-TDATA-019.04 Test the ability to cancel a notification of a change in hook status of a data call + * @test GT83-TDATA-020.02 "Test notification of a change in the status of the data call from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""" + * @test GT83-TDATA-021.01 Test setting notification of a change in the data call's duration + * @test GT83-TDATA-021.03 Test cancelling notification of a change in the data call's duration + */ + { + INFO_PRINTF1(_L("======Start test Test Call Cancels")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; + + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + // Call Status Change Cancel Request + RCall::TStatus callStatus; + iDataCall.NotifyStatusChange(iStatus, callStatus); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-020.02")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-020.4")) ; + +#if 0 //cancel functions don't work yet (?) + //any way they are not declared 27.09.2001 + RMobileCall::TMobileCallStatus mobileCallStatus; + iiDataCall.NotifyMobileCallStatusChange(iStatus, mobileCallStatus); + TEST_CHECKL(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ; + iiDataCall.NotifyMobileCallStatusChangeCancel(); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + // Hook Change Cancel Request + RCall::THookStatus hookStatus; + iDataCall.NotifyHookChange(iStatus, hookStatus); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-019.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyHookChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-019.04")) ; + + // Test Cancelling Notifications + RCall::TCaps callCaps; + iDataCall.NotifyCapsChange(iStatus, callCaps); + TEST_CHECKL(iStatus.Int(), KRequestPending, _L("GT83-TDATA-017.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyCapsChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-017.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); + iDataCall.NotifyMobileCallCapsChange(iStatus, mobileCallCapsPckg); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ; + iDataCall.NotifyMobileCallCapsChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + + TTimeIntervalSeconds callDuration; + iDataCall.NotifyCallDurationChange(iStatus, callDuration); + CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-021.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyCallDurationChangeCancel(); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-021.03")) ; + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + return TestStepResult() ; + } +//------------------------------------------------------------------ + +CTestHandShake::CTestHandShake() +/** Each test step initialises it's own name +*/ + { + CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen)); + CleanupStack::PushL(console); + console->Printf(_L("Start the echo batch file then press any key to continue.\n")); + console->Getch(); + console->Printf(_L("Te_echo.script is running.\n")); + CleanupStack::PopAndDestroy(console); + // store the name of this test case + // this is the name that is used by the script file + SetTestStepName(_L("TestHandShake")); + } +//------------------------------------------------------------------ +TInt CTestHandShake::DialRemoteModemTestL() +/** + * Dials a data call. + * This method opens a data line and call, and retrieves the status of the call. + * It then dials a remote modem (initiated by t_data.exe), loans the Comm port, + * connects to the Comms Server, opens a serial port and proceeds to transmit data to + * the remote modem. It subsequently reads the data echoed back by the remote modem and + * compares the transmitted and received data. The serial port, the connection to the + * Comms Server, the data port, call and line are then closed. + * @return TBool indicating whether this test was successful. If it's unsuccessful, the + * test exits because it will not be possible to do the AnswerTest as the telephone no. + * of the phone was not transferred due to the failure of the DialTest. + * + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle""" + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-024.00 Test dialling a data call (Generic) + * @test GT83-TDATA-026.02 Test the ability to place an asynchronous request to hang up a data call + * @test GT83-TDATA-028.02 Test the ability to recover a loaned port that was requested by an asynchronous request and the request completed + */ + { + + INFO_PRINTF1(_L("======Start test Dial Remote Modem test")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + const TInt KNumOfBytes=51; // Number of bytes of data to send to remote end + + // Open a data line and call + INFO_PRINTF1(_L("Opening Data Line")); + // GT83-AT-021 Test opening a data line from a phone that supports data functionality + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + + //GT83-AT-028 Test opening a new call from data line (Generic) + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + // Get the call's status + RCall::TStatus callStatus; + CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TDATA-004.02")); + INFO_PRINTF2(_L("Call Status = %d"), callStatus); + Print_RCall_TStatus(callStatus) ; + TestGetCallCapabilitiesL(iDataCall) ; + + // Dial remote modem and obtain the call's current status + TBuf<16> remoteNum; + GetRemoteNumber(remoteNum); + + INFO_PRINTF2(_L("Dialling %S...."), &remoteNum); + + // new stuff + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + INFO_PRINTF2(_L("Dialling %S...."), &remoteNum); + iDataCall.Dial(iStatus, callDataParamsPckg, remoteNum); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-024.00")); + + CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TDATA-024.00")); + INFO_PRINTF2(_L("Call Status = %d"), callStatus); + Print_RCall_TStatus(callStatus) ; + + // Loan the Comm port + TInt retValue=KErrNone; // return value for the test + RCall::TCommPort commPort; + iDataCall.LoanDataPort(iStatus,commPort); + User::WaitForRequest(iStatus); + if (iStatus==KErrNone) + { + INFO_PRINTF1(_L("Comm port loaned successfully")); + } + else if (iStatus==KErrCommsLineFail) + { + INFO_PRINTF1(_L("Loan Data port error: 'KErrCommsLineFail'.")); + INFO_PRINTF1(_L("This error is currently known to only happen with the Motorola")); + INFO_PRINTF1(_L("Time port. Please see the PhoneInfo.cpp file for more information.")); + retValue=iStatus.Int(); + iDataCall.Close(); + iLine.Close(); + return retValue; + } + else + { + INFO_PRINTF2(_L("Error %d occured during"), iStatus.Int()); + INFO_PRINTF1(_L("Loan comm port request.\nUnable to continue.")); + retValue=iStatus.Int(); + iDataCall.Close(); + iLine.Close(); + return retValue; + } + + // Connect to the Comms Server and load the CSY + RCommServ cs; + TEST_CHECKL(cs.Connect(), KErrNone, _L("GT83-TDATA-0")); + TInt ret=cs.LoadCommModule(KCsyName); + TESTL(ret==KErrNone || ret==KErrAlreadyExists); + + // Open a serial port + RComm port; + TEST_CHECKL(port.Open(cs,commPort.iPort,ECommShared), KErrNone, _L("*** Failed to open serial port ***")); + INFO_PRINTF1(_L("Serial port opened successfully")); + + // Write own telephone number to the Data Port. + TBuf<16> localNumUnicode; + TBuf8<16> localNum; // We need this to be large + + GetLocalNumber(localNumUnicode); // Get out own phone number in unicode + localNum.Copy(localNumUnicode); // Convert unicode to 8 bit string + + // The T_ECHO client we are talking to expects the localNum to be 12 chars. + // Therefore we have to ensure our localNum is exactly 12 chars by padding with spaces. + const TInt len=localNum.Length(); + if(len<12) + localNum.AppendFill(TChar(' '),12-len); + localNum.SetLength(12); + + port.Write(iStatus,localNum); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to write to comm port ***")); + INFO_PRINTF1(_L("Data stream 1 (tel. no.) written successfully")); + + // Write more data + port.Write(iStatus, KWriteTestData); + User::WaitForRequest(iStatus); + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to write to comm port***")) ; + INFO_PRINTF1(_L("Data stream 2 written successfully")); + + // Receive the echoed data from the remote machine + TInt success=EFalse; + TBuf8 echoedData; + port.Read(iStatus,KFifteenSeconds,echoedData); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus, KErrNone, _L("*** Failed to read echoed data!! ***")); + + if (iStatus==KErrTimedOut) + { + INFO_PRINTF1(_L("A Time out error occured during the read")); + } + else if (iStatus==KErrNone) + { + INFO_PRINTF1(_L("Data stream read successfully")); + success=ETrue; + } + else + { + INFO_PRINTF2(_L("Error %d occured"), iStatus.Int()); + } + + // Compare the received data and then display the data + if (success) + { + TEST(echoedData == KWriteTestData) ; + + TBuf convertData; // Convert the 8-bit data read from serial port to 16- + convertData.Copy(echoedData); // bit so that it can be displayed to the user. + INFO_PRINTF2(_L("Echoed Data stream = %S"), &convertData); + } + + // Close the serial port, connection to Comms Server and recover the data port + port.Close(); + cs.Close(); + //GT83-AT-034 Test the ability to recover a loaned port (Generic) RCall::RecoverDataPort + TEST_CHECKL(iDataCall.RecoverDataPort(), KErrNone, _L("GT83-TDATA-028.02")) ; + + // Hang up the call + INFO_PRINTF1(_L("Hanging up the Data call")); + //GT83-AT-035 Test hanging up a data call (Generic) RCall::HangUp + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + TEST_CHECKL(iDataCall.HangUp(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ; + INFO_PRINTF2(_L("DataCall.HangUp() returns %d"), iDataCall.HangUp()) ; + // Close the line and call. + //GT83-AT-022 Test closing a data line (Generic) RLine::Close + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + return retValue; + } + +//------------------------------------------------------------------ +void CTestHandShake::AnswerIncomingCallTestL() +/** + * Answers an incoming data call. + * This method opens a data line and call, and retrieves the status of the call. + * It then answers an incoming call from a remote modem (initiated by t_echo.exe), + * loans the Comm port, connects to the Comms Server, opens a serial port and proceeds + * to read data transmitted by the remote modem. It then echoes the received data + * closes the serial port, its connection to the Comms Server, the data port, call and + * line. + * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality + * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle""" + * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line + * @test GT83-TDATA-015.05 "Test retrieval of the current call status when the call's status is ""answering""" + * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic) + * @test GT83-TDATA-026.02 Test the ability to place an asynchronous request to hang up a data call + * @test GT83-TDATA-027.03 Test support for asynchronous loaning of the data port to the client when a connection has been established to a remote modem + * @test GT83-TDATA-028.02 Test the ability to recover a loaned port that was requested by an asynchronous request and the request completed +*/ + { + INFO_PRINTF1(_L("======Start test Answer Incoming call test")); + //to make sure that line and call will be closed in leave case + CleanupStack::PushL(*this) ; ; + const TInt KExpectedBytes=57; // Number of bytes of data expected from remote end + + // Open a Data line and Call + //GT83-AT-021 Test opening a data line from a phone that supports data functionality + INFO_PRINTF1(_L("Opening Data Line")); + + TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + //get status + //GT83-AT-026 Test retrieval of a data line's current status. + RCall::TStatus callStatus; + CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TDATA-004.02")); + INFO_PRINTF2(_L("Call Status = %d"), callStatus); + Print_RCall_TStatus(callStatus) ; + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + + callDataParams.iService = RMobileCall::EServiceDataCircuitAsync; + callDataParams.iSpeed = RMobileCall::ESpeed9600; + callDataParams.iProtocol = RMobileCall::EProtocolV32; + //callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia; + + callDataParams.iQoS = RMobileCall::EQoSNonTransparent; + + + // 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 data line (Generic) RCall::AnswerIncomingCall + iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg); + INFO_PRINTF1(_L("Waiting for incoming call...")); + + // DEF55659-NCh : timout changed from 60s to 120s. Must be changed back to 10s when MMTSY is optimized + WaitWithTimeoutL(iStatus,120*KOneSecond); // but timeout after 120 seconds + + //cancel AnswerIncomingCall if request is still pending + if(iStatus.Int() == KRequestPending) + { + iDataCall.AnswerIncomingCallCancel(); + User::WaitForRequest(iStatus); + } + + TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed AnswerIncomingCallTestL() ***")) ; + + CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TDATA-015.05")); + INFO_PRINTF2(_L("Call Status = %d"), callStatus); + TestGetCallCapabilitiesL(iDataCall) ; + + // Loan the Comm port + RCall::TCommPort commPort; + + // GT83-AT-033 Test support for loaning the data port to the client (Generic) RCall::LoanDataPort + iDataCall.LoanDataPort(iStatus,commPort); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-027.03")); + if (iStatus==KErrNone) + { + INFO_PRINTF1(_L("Comm port loaned successfully")); + } + else if (iStatus==KErrCommsLineFail) + { + INFO_PRINTF1(_L("Loan Data port Error: 'KErrCommsLineFail'.")); + INFO_PRINTF1(_L("This error is currently known to only happen with the Motorola")); + INFO_PRINTF1(_L("Time port. Please see the PhoneInfo.cpp file for more information.")); + return; + } + else + { + INFO_PRINTF2(_L("Error %d occured during"), iStatus.Int()); + INFO_PRINTF1(_L("Loan comm port request.\nUnable to continue.")); + return; + } + + // Connect to the Comms Server and load the CSY + RCommServ cs; + TESTL(cs.Connect() == KErrNone); + TInt ret=cs.LoadCommModule(KCsyName); + CHECKPOINT_EXPR((ret==KErrNone || ret==KErrAlreadyExists), _L("*** Failed to load CSY ***")); + + // Open a serial port + RComm port; + TEST_CHECKL(port.Open(cs,commPort.iPort,ECommShared), KErrNone, _L("*** Failed to open serial port ***")); + INFO_PRINTF1(_L("Serial port opened successfully")); + + // Read a stream of data from the serial port + TInt success=EFalse; // Boolean indicating whether data read has been successful + + TBuf8 readData; + INFO_PRINTF1(_L("Posting a read...")); + // DEF55659-NCh : timout changed from 20s to 40s. Must be changed back when MMTSY is optimized + port.Read(iStatus,KTenSeconds*4,readData); + User::WaitForRequest(iStatus); + CHECKPOINT(iStatus, KErrNone, _L("*** Failed to read data from serial port ***")); + + if (iStatus==KErrTimedOut) + { + INFO_PRINTF1(_L("A Time out error occured during the read")); + } + else if (iStatus==KErrNone) + { + INFO_PRINTF1(_L("Data stream read successfully")); + success=ETrue; + } + else + { + INFO_PRINTF2(_L("Error %d occured"), iStatus.Int()); + } + + // Display and then echo the received data + if (success) + { + TBuf convertData; // Convert the 8-bit data read from serial port to 16-bit + convertData.Copy(readData); // so that it can be displayed to the screen + INFO_PRINTF2(_L("Data stream = %S"), &convertData); + + // Echo the data + //User::After(KFiveSeconds); // Give remote end time to post a read request + port.Write(iStatus,readData); + User::WaitForRequest(iStatus); + TESTL(iStatus == KErrNone); + INFO_PRINTF1(_L("Data stream echoed successfully")); + } + + // Close the serial port, connection to Comms Server and recover the data port + port.Close(); + cs.Close(); + //GT83-AT-034 Test the ability to recover a loaned port (Generic) RCall::RecoverDataPort + TEST_CHECKL(iDataCall.RecoverDataPort(),KErrNone, _L("GT83-TDATA-028.02")); + + // Hang up the call + INFO_PRINTF1(_L("Hanging up the Data call")); + TEST_CHECKL(iDataCall.HangUp(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")); + + //This test has some trobles with Ericsson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("DataCall.HangUp() returned status %d"), iDataCall.HangUp()) ; + + // Close the line and call + //GT83-AT-022 Test closing a data line (Generic) RLine::Close + + // Close the line and call + CleanupStack::PopAndDestroy() ; + + INFO_PRINTF1(_L("======End test =====")); + } +//------------------------------------------------------------------ + +TVerdict CTestHandShake::doTestStepL() + { + // DEF55659-NCh : this warning must be removed when the MMSTY is optimised. + INFO_PRINTF1(_L("\n*** NOTE: this test is not reliable and takes time ***")); + INFO_PRINTF1(_L("*** to run because timeout where changed due to the ***")); + INFO_PRINTF1(_L("*** way the TSY fetches info from the Comms repository. ***")); + + TInt ret = DialRemoteModemTestL(); + if (ret==KErrNone) + { + INFO_PRINTF1(_L("The next test will start shortly...")); + User::After(KTenSeconds); + AnswerIncomingCallTestL(); + } + else + INFO_PRINTF1(_L("An error occured during the DialRemoteModemTest\n.")); + return TestStepResult() ; + } +//------------------------------------------------------------------ + +CTestGetMobileDataCallCaps::CTestGetMobileDataCallCaps() +/** Each test step initialises it's own name +*/ + { + SetTestStepName(_L("TestGetMobileDataCallCapsL")); + } +//------------------------------------------------------------------ + +TVerdict CTestGetMobileDataCallCaps::doTestStepL() + { + RMobileLine line; + TEST_CHECKL(line.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + RMobileCall call ; + TEST_CHECKL(call.OpenNewCall(line), KErrNone, _L("GT83-TDATA-013.06")); + + RMobileCall::TMobileCallDataCapsV1 caps; + RMobileCall::TMobileCallDataCapsV1Pckg capsPckg(caps); + TEST(KErrNone == call.GetMobileDataCallCaps(capsPckg)); + + User::After(KTenSeconds); + + call.Close(); + line.Close(); + return TestStepResult() ; + } + +//New object to load and parse the test config file + +CConfigParams* CConfigParams::NewL(const TDesC &aCfgFileName) + { + CConfigParams *f; + f=new (ELeave) CConfigParams(); + CleanupStack::PushL(f); + //A leave during the ConstrucL is not fatal, just means there's no param file + TRAP_IGNORE(f->ConstructL(aCfgFileName)); + CleanupStack::Pop(); + return f; + } + +void CConfigParams::ConstructL(const TDesC &aCfgFileName) + { + //Find the config file + TAutoClose fs; + User::LeaveIfError(fs.iObj.Connect()); + fs.PushL(); + //Location for the test parameter config file + _LIT(KTinetConfigFilePaths,"\\;\\system\\data\\"); + TFindFile filePath(fs.iObj); + User::LeaveIfError(filePath.FindByPath(aCfgFileName,&KTinetConfigFilePaths)); + //read the content of the file + TAutoClose fl; + fl.PushL(); + User::LeaveIfError(fl.iObj.Open(fs.iObj,filePath.File(),EFileShareExclusive)); + User::LeaveIfError(fl.iObj.Read(iConfigParamBuf8)); + iConfigParamBuf.Copy(iConfigParamBuf8); + CleanupStack::PopAndDestroy(2); + iFileExist = ETrue; + } + +const TPtrC CConfigParams::FindAlphaVar(const TDesC &aVarName, const TDesC &aDefault) + { + if(!iFileExist) + return TPtrC(aDefault); + TInt pos=iConfigParamBuf.Find(aVarName); + if (pos==KErrNotFound) + return TPtrC(aDefault); + TLex lex(iConfigParamBuf.Mid(pos)); + lex.SkipCharacters(); + lex.SkipSpaceAndMark(); // Should be at the start of the data + lex.SkipCharacters(); + return TPtrC(lex.MarkedToken().Ptr(),lex.MarkedToken().Length()); + } + +TInt CConfigParams::FindNumVar(const TDesC &aVarName, const TInt aDefault) + { + TInt result; + TPtrC ptr = FindAlphaVar(aVarName,KNullDesC); + if(ptr.Length()) + { + TLex lex(ptr); + if (lex.Val(result)==KErrNone) + return result; + } + return aDefault; + } + +TBool CConfigParams::ConfigFileExist() + { + return iFileExist; + } +