diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/simtsy/test/Te_SimData/Te_SimData.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/simtsy/test/Te_SimData/Te_SimData.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,2144 @@ +// 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: +// + +/** + @file +*/ + +#include "Te_SimData.h" + +#include + +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) + + +_LIT(KGoodNumber,"1789"); + + +static TInt NTRasThreadFunction(TAny* /*aThreadData*/) +/** +* Does 'durty' work to start NT RAS session +* @note It sets +* iRate = EBps38400; +* iDataBits = EData8; +* iStopBits = EStop1 ; +* iParity = EParityNone; +* be sure that your NT comport has the same settings. +*/ + { + _LIT(KCsyName,"LOOPBACK.CSY"); + _LIT(KPortName,"LOOPBACK::1"); + + _LIT8(KServerText,"SERVER"); + + CTrapCleanup* cleanup; + if ((cleanup=CTrapCleanup::New())==NULL) + return KErrGeneral; + + RCommServ commServ; + TInt r=commServ.Connect(); + r=commServ.LoadCommModule(KCsyName); + if( KErrNone == r) + { + RComm comm; + r=comm.Open(commServ,KPortName,ECommShared); + if( KErrNone == r) + { + TBuf8<6> readBuf; + TRequestStatus stat0; + comm.Read(stat0,readBuf); + User::WaitForRequest(stat0) ; + + comm.Write(stat0,KServerText); + User::WaitForRequest(stat0) ; + } + comm.Close() ; + } + commServ.Close() ; + delete cleanup; + return r; + } + +LOCAL_C TInt StartNTRasSimulation() +/** +* Starts virual, because of lookback serial driver, +* NT RAS session +*/ + { + const TInt KStackSize=0x8000; + const TInt KHeapSize=0x8000; + const TInt KMaxHeapSize=0x80000; + TInt res = KErrNone ; + _LIT(KNtRasName,"NTRasEmulation"); + + RThread t; + res=t.Create(KNtRasName,NTRasThreadFunction, + KStackSize,KHeapSize,KMaxHeapSize,NULL); + t.Resume(); + t.Close(); + + return res; + } + + +void CTestSimDataStep::WaitWithTimeout(TRequestStatus& aStatus, TInt aNumberOfMicroSeconds) +/** + * Timeout function + */ + { + TRequestStatus timerStatus; + RTimer timer ; + timer.CreateLocal() ; + timer.After(timerStatus,aNumberOfMicroSeconds); + + User::WaitForRequest(aStatus, timerStatus); + if (timerStatus == KRequestPending) + { + timer.Cancel(); + User::WaitForRequest(timerStatus); + } + else + { + INFO_PRINTF1(_L("Time is over!!!")) ; + } + timer.Close() ; + } + +// +// CTestSimDataStep Implementation +// + +void CTestSimDataStep::GetGoodNumber(TDes& aNum) +/**Returns string with number for outgoing call. + * For.ex Good number is 179 Vodaphone test line - recorded message. + * Function tries to read value of switch /modem, otherwise it use defualt value. + * @return phone number string + * @note have to be updated to read information from cmd line or config. file +*/ + { + aNum.Copy(KGoodNumber) ; + } + +void CTestSimDataStep::TestLineCapabilitiesL() +/** + * @test GT83-TDATA-002.01 Test retrieval of a data line's capabilities. Display the capabilities to screen +*/ + { + INFO_PRINTF1(_L("Test Line Capabilities")); + + // Line Capabilities + RLine::TCaps lineCaps; + TInt ret=iLine.GetCaps(lineCaps); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-002.01")) ; + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Line Capabilities is NOT supported")); + } + else + { + if ((lineCaps.iFlags&RLine::KCapsData) !=0) + { + INFO_PRINTF1(_L("This line supports Data connections")); + } + if ((lineCaps.iFlags&RLine::KCapsFax) !=0) + { + INFO_PRINTF1(_L("This line supports Fax connections")); + } + if ((lineCaps.iFlags&RLine::KCapsVoice) !=0) + { + INFO_PRINTF1(_L("This line supports Voice connections")); + } + if ((lineCaps.iFlags&RLine::KCapsEventIncomingCall) !=0) + { + INFO_PRINTF1(_L("This line supports Incoming Call Notification requests")); + } + } + } + +TInt CTestSimDataStep::CallMeDear() +/** +* Asks for incomming call +* @return KErrNone if could make it +*/ + { + iState++; + TInt ret = RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyIncomingDataCall, iState); + INFO_PRINTF2(_L("Set Incoming Call Publish & Subscribe property result: %d"),ret) ; + return ret; + } + +TInt CTestSimDataStep::HangMeUpDear() +/** +* Asks for remote hangup +* @return KErrNone if could make it +*/ + { + iState++; + TInt ret = RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyRemoteHangup, iState); + INFO_PRINTF2(_L("Set Remote Hangup Publish & Subscribe property result: %d"),ret) ; + return ret; + } + +void CTestSimDataStep::Print_RCall_TStatus(RCall::TStatus& aArg) + +/** Display value of enum RCall::TStatus to screen. + * @param value to print +*/ + { + switch(aArg) + { + case RCall::EStatusUnknown: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusUnknown")) ; + break ; + case RCall::EStatusIdle: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusIdle")) ; + break ; + case RCall::EStatusDialling: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusDialling")) ; + break ; + case RCall::EStatusRinging: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusRinging")) ; + break ; + case RCall::EStatusAnswering: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusAnswering")) ; + break ; + case RCall::EStatusConnecting: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusConnecting")) ; + break ; + case RCall::EStatusConnected: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusConnected")) ; + break ; + case RCall::EStatusHangingUp: + INFO_PRINTF1(_L("Value of enum is RCall::EStatusHangingUp")) ; + break ; + } + } + +void CTestSimDataStep::Print_TCapsEnum(RCall::TCaps& aArg) +/** Display value of enum RCall::TCapsEnum to screen. + * @param value to print +*/ + { + if(aArg.iFlags & RCall::KCapsData) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsData")) ; + } + if(aArg.iFlags & RCall::KCapsFax) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsFax")) ; + } + if(aArg.iFlags & RCall::KCapsVoice) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsVoice")) ; + } + if(aArg.iFlags & RCall::KCapsDial) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsDial")) ; + } + if(aArg.iFlags & RCall::KCapsConnect) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsConnect")) ; + } + if(aArg.iFlags & RCall::KCapsHangUp) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsHangUp")) ; + } + if(aArg.iFlags & RCall::KCapsAnswer) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsAnswer")) ; + } + if(aArg.iFlags & RCall::KCapsLoanDataPort) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsLoanDataPort")) ; + } + if(aArg.iFlags & RCall::KCapsRecoverDataPort) + { + INFO_PRINTF1(_L("Has a flag TCapsEnum::KCapsRecoverDataPort")) ; + } + } +//------------------------------------------------------------------ + +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() +/** 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("Test Line Status")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + RCall::TStatus lineStatus; + TBuf<16> GoodNumber ; + GetGoodNumber(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")); + CHECK_POINT(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); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.00")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + RMobileCall::TMobileCallStatus mobileLineStatus; + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.00")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ; + + INFO_PRINTF1(_L("Please ring the phone")); + + 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 + + CallMeDear() ; + + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + /* @test GT83-AT-36 Test retrieval of the current call status when it is ringing*/ + ret = iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ; + CHECK_POINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-0")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-008.001")) ; + + INFO_PRINTF1(_L("Phone is ringing...")); + //Test for incomming data call + TestLineCapabilitiesL(); + + /* @test GT83-AT-028 Test opening a new call by specifying the name of a line + */ + ret = iDataCall.OpenExistingCall(iLine, callName); + CHECK_POINT(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); + WaitWithTimeout(iStatus,30*KOneSecond); // but timeout after 2 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + ret = iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.04")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.04")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.04")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.04")) ; + TestLineCapabilitiesL(); + + /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/ + ret = iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.07")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.07")) ; + + + INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly")); + 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); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.08")) ; + CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-0")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.09")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-004.09")) ; + + User::WaitForRequest(iStatus); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; //??? line 825 + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + /* @test GT83-AT-36 Test retrieval of the current call status when it is idle*/ + ret = iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + ret = iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + CHECK_POINT(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); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** 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("Test Line Status")); + + TInt ret = RProperty::Set(KUidSystemCategory, KUidPhonePwrValue, ESAPhoneOff); + if(ret!=KErrNone) + { + INFO_PRINTF2(_L("Failed to set property KUidSystemCategory/KUidPhonePwr to ESAPhoneOff. The error was %d. Continuing..."),ret); + } + + User::After(5 * 1000000); // sleep 5 secs; make sure phone is off + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + StartNTRasSimulation(); + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + TName callName; + + RCall::TStatus lineStatus; + TBuf<16> GoodNumber ; + GetGoodNumber(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")); + CHECK_POINT(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*/ + iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.00")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ; + + RMobileCall::TMobileCallStatus mobileLineStatus; + iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-031.00")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ; + /* @test GT83-AT-028 Test opening a new call by specifying the name of a line + */ + iDataCall.OpenNewCall(iLine, callName); + CHECK_POINT(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; + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.03")) ; + //CHECK_POINT(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-004.03")) ; + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + //Test for outgoing data call + TestLineCapabilitiesL(); + + /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/ + iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.07")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ; + + iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-0")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-0")) ; + + + INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly")); + 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); + + iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.08")) ; + CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-004.08")) ; + + User::WaitForRequest(iStatus); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + //Test for outgoing data call after hang up + TestLineCapabilitiesL(); + /* @test GT83-AT-36 Test retrieval of the current call status when it is connected*/ + iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.09")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.09")) ; + + iLine.GetMobileLineStatus(mobileLineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-004.09")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-004.09")) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * 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("Test Line Information")); + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + // 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + // Line Information + RLine::TLineInfo lineInfo; + TRAPD(ret, ret=iLine.GetInfo(lineInfo)); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-013.06")); + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Line Info. is NOT supported")); + } + else + { + INFO_PRINTF1(_L("Get Line Info is successful")); + CHECK_POINT(lineInfo.iHookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-0")) ; + TESTL(lineInfo.iStatus == RCall::EStatusIdle) ; + INFO_PRINTF2(TRefByValue(_L("Name of last call added: %S")), &lineInfo.iNameOfLastCallAdded); + } + + // Hook status information + INFO_PRINTF1(_L("Retrieving Hook Status...")); + RCall::THookStatus hookStatus; + ret=iLine.GetHookStatus(hookStatus); + if (ret!=KErrNone) + { + INFO_PRINTF1(_L("Get Hook status is NOT supported")); + } + else + { + CHECK_POINT(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; + INFO_PRINTF1(_L("Please ring the phone ")); + CallMeDear() ; + + // 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); + + WaitWithTimeout(iStatus,2*KTenSeconds); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + + // 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; + 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 + { + CHECK_POINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-005.01")) ; + INFO_PRINTF1(_L("The line is currently OFF Hook")); + } + + INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly")); + User::After(KTenSeconds); + + INFO_PRINTF1(_L("Hanging up")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-026.02")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + // Close the line and call + //GT83-AT-022 Test closing a data line (Generic) RLine::Close + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** 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("Test Line Notifications")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + TBuf<16> GoodNumber ; + GetGoodNumber(GoodNumber) ; + + // NotifyIncomingCall and NotifyStatusChange + TName callName1; + TName callName2; + 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + INFO_PRINTF1(_L("Please ring the phone")); + + 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); + + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.01")) ; + CHECK_POINT(iStatus2.Int(), KRequestPending, _L("GT83-TDATA-010.02")) ; + CHECK_POINT(iStatus3.Int(), KRequestPending, _L("GT83-TDATA-032.01")) ; + CHECK_POINT(iStatus4.Int(), KRequestPending, _L("GT83-TDATA-011.01")) ; + CHECK_POINT(iStatus5.Int(), KRequestPending, _L("GT83-TDATA-009.01")) ; + + CallMeDear() ; + + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-008.02")) ; + + // @test GT83-AT-026 Test notification of a change in the status of the data line + // from "idle" to "ringing" + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ; + CHECK_POINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-010.02")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.09")) ; + CHECK_POINT(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); + CHECK_POINT(iStatus5.Int(), KErrNone, _L("GT83-TDATA-009.011.01")) ; + CHECK_POINT(callName2 == callName1, 1, _L("GT83-TDATA-011")) ; + + 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); + + iDataCall.OpenExistingCall(iLine, callName1); + CHECK_POINT(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); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ; + CHECK_POINT(lineStatus, RCall::EStatusAnswering, _L("GT83-TDATA-010.01")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.10")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-032.10")) ; + + WaitWithTimeout(iStatus,30*KOneSecond); // but timeout after 2 seconds + CHECK_POINT(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 "connecting" + iLine.NotifyStatusChange(iStatus2, lineStatus); + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.01")) ; + + + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.11")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.11")) ; + + User::WaitForRequest(iStatus4); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.02")) ; + CHECK_POINT(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 Erikson 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); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ; + CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.02")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ; + CHECK_POINT(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); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.02")) ; + + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ; + CHECK_POINT(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); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.03")) ; + CHECK_POINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.03")) ; + //check that all request has been finished + TESTL(iStatus.Int()!= KRequestPending) ; + TESTL(iStatus2.Int() != KRequestPending) ; + TESTL(iStatus3.Int() != KRequestPending) ; + TESTL(iStatus4.Int() != KRequestPending) ; + TESTL(iStatus5.Int() != KRequestPending) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** 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("Test Line Notifications")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + StartNTRasSimulation(); + + TBuf<16> GoodNumber ; + GetGoodNumber(GoodNumber) ; + + // NotifyIncomingCall and NotifyStatusChange + //TName callName1; + //TName callName2; + 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + CHECK_POINT(iDataCall.OpenNewCall(iLine), 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); + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECK_POINT(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.02")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusDialling, _L("GT83-TDATA-032.02")) ; + + User::WaitForRequest(iStatus); //waiting for dial + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + User::WaitForRequest(iStatus4); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.03")) ; + CHECK_POINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.03")) ; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + +#ifdef SIM_TSY + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnecting, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.04")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnecting, _L("GT83-TDATA-032.04")) ; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + +#endif + + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECK_POINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.04")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.04")) ; + + + 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); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ; + CHECK_POINT(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); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.02")) ; + CHECK_POINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.02")) ; + + iLine.NotifyStatusChange(iStatus2, lineStatus); + iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus); + + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ; + CHECK_POINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.03")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ; + CHECK_POINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-032.08")) ; + + TESTL(iStatus != KRequestPending) ; + TESTL(iStatus2 != KRequestPending) ; + TESTL(iStatus3 != KRequestPending) ; + TESTL(iStatus4 != KRequestPending) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * @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("Test Line Cancels")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + // 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + iLine.NotifyIncomingCall(iStatus, callName); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.02")) ; + iLine.NotifyIncomingCallCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-008.03")) ; + + // Notify Status Change + RCall::TStatus lineStatus; + iLine.NotifyStatusChange(iStatus, lineStatus); + CHECK_POINT(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); + CHECK_POINT(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); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ; + iLine.NotifyMobileLineStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + // Notify Hook Change + RCall::THookStatus hookStatus; + iLine.NotifyHookChange(iStatus, hookStatus); + CHECK_POINT(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); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-009.04")) ; + + // Notify Call Added + iLine.NotifyCallAdded(iStatus, callName); + CHECK_POINT(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); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-011.03")) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * This function gets information pertaining to a call: + * Bearer Service Information, Call duration, Remote Party Information (if available) + * @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("Test Call Information")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + // 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(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; + CHECK_POINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TD-015.02")) ; + CHECK_POINT(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 + INFO_PRINTF1(_L("Please ring the phone")); + + CallMeDear() ; + + // 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); + + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + + // User Information + INFO_PRINTF1(_L("The call is now connected. Retrieving Call Information.")); + + // Bearer Service Information + INFO_PRINTF1(_L("Get Bearer Service Info...")); + RCall::TBearerService bearerServiceInfo; + TInt ret=iDataCall.GetBearerServiceInfo(bearerServiceInfo); + CHECK_POINT(ret, KErrNone, _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("Get Current Call Info...")); + ret=iDataCall.GetInfo(iCallInfo); +#ifndef SIM_TSY + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; +#endif + 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()); + } + + //Get Remote Party Info (PDEF108459) + RMobileCall::TMobileCallRemotePartyInfoV1 remoteParty; + RMobileCall::TMobileCallRemotePartyInfoV1Pckg remotePartyPckg(remoteParty); + + TRequestStatus reqStatus; + iDataCall.NotifyRemotePartyInfoChange(reqStatus, remotePartyPckg); + User::WaitForRequest(reqStatus); + + TESTL(reqStatus == KErrNone); + + if (remoteParty.iRemoteIdStatus == RMobileCall::ERemoteIdentityAvailable) + { + INFO_PRINTF1(_L("Displaying Remote Party Information about the Current Call")); + _LIT(KCallingName, "Calling Name : %S"); + INFO_PRINTF2(KCallingName, &remoteParty.iCallingName); + _LIT(KRemoteNumber, "Remote Number : %S"); + INFO_PRINTF2(KRemoteNumber, &remoteParty.iRemoteNumber.iTelNumber); + } + else + { + _LIT(KRemoteIdentityNotAvilable,"Remote Identity is not available."); + INFO_PRINTF1(KRemoteIdentityNotAvilable); + } + + // Hang up the Call + INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly")); + User::After(5*KOneSecond); + + // Call Duration + INFO_PRINTF1(_L("Get Call Duration...")); + TTimeIntervalSeconds callDuration2; + ret=iDataCall.GetCallDuration(callDuration2); +#ifndef SIM_TSY + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-022.01")) ; +#endif + 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); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-009.02")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * @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("Test Call Notifications")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + TName callName1; + 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + + INFO_PRINTF1(_L("Please ring the phone")); + + iLine.NotifyIncomingCall(iStatus, callName1); // wait for a call + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.01")) ; + + CallMeDear() ; + + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-008.01")) ; + + TInt ret = iDataCall.OpenExistingCall(iLine, callName1); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-014.05")) ; + + iDataCall.GetStatus(callStatus); + CHECK_POINT(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-015.04")) ; + iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-035.04")) ; + + ret=iDataCall.GetCaps(caps); + Print_TCapsEnum(caps) ; + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-002.01")) ; + TESTL(caps.iFlags & (RCall::KCapsData | RCall::KCapsAnswer)); + +// INFO_PRINTF1(_L("Opening New Data Call")); +// CHECK_POINT(iiDataCall.OpenExistingCall(iLine, 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); + + 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); +#ifndef SIM_TSY + CHECK_POINT(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-015.05")) ; +#else + CHECK_POINT(callStatus, RCall::EStatusAnswering, _L("GT83-TDATA-015.05")) ; +#endif + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 2 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ; + + + //iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECK_POINT(callStatus, RCall::EStatusAnswering, _L("GT83-TDATA-020.10")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.10")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-036.10")) ; + + iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECK_POINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-020.02")) ; + + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.11")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-036.11")) ; + + User::WaitForRequest(iStatus4); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-017.02")) ; + Print_TCapsEnum(caps) ; + TEST_CHECKL(((caps.iFlags & RCall::KCapsData) !=0 ), ETrue, _L("GT83-TDATA-017.02")) ; + +#ifndef SIM_TSY + iDataCall.NotifyCapsChange(iStatus4, caps); + User::WaitForRequest(iStatus4); + CHECK_POINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-017.02")) ; + CHECK_POINT((caps.iFlags & (RCall::KCapsData | RCall::KCapsHangUp)!=0), ETrue, _L("GT83-TDATA-017.02")) ; +#endif + + User::WaitForRequest(iStatus5); + CHECK_POINT(iStatus5.Int(), KErrNone, _L("GT83-TDATA-009.03")) ; + CHECK_POINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.03")) ; + + User::WaitForRequest(iStatus6); +#ifndef SIM_TSY + CHECK_POINT(iStatus6.Int(), KErrNone, _L("GT83-TDATA-021.01")) ; +#endif + 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); + CHECK_POINT(iStatus7.Int(), KErrNone, _L("GT83-TDATA-034.01")) ; + TEST_CHECKL(((mobileCallCaps.iCallControlCaps & RCall::KCapsData) !=0), ETrue, _L("GT83-TDATA-034.01")) ; +#ifndef SIM_TSY + iDataCall.NotifyMobileCallCapsChange(iStatus7, mobileCallCapsPckg); + User::WaitForRequest(iStatus7); + CHECK_POINT(iStatus7.Int(), KErrNone, _L("GT83-TDATA-034.02")) ; + //CHECK_POINT(mobileCallCaps.iCallControlCaps, (RCall::KCapsData | RCall::KCapsHangUp), _L("GT83-TDATA-034.02")) ; + //MKV error +#endif + // 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); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-009.02")) ; //sometimes timed out -33 + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECK_POINT(callStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-020.02")) ; + + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.07")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-036.07")) ; + + iDataCall.NotifyStatusChange(iStatus2, callStatus); + User::WaitForRequest(iStatus2); + CHECK_POINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-020.02")) ; + CHECK_POINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-020.02")) ; + + iDataCall.NotifyMobileCallStatusChange(iStatus3, mobileCallStatus); + User::WaitForRequest(iStatus3); + CHECK_POINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-036.08")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-036.08")) ; + + TESTL(iStatus != KRequestPending) ; + TESTL(iStatus2 != KRequestPending) ; + TESTL(iStatus3 != KRequestPending) ; + TESTL(iStatus4 != KRequestPending) ; + TESTL(iStatus5 != KRequestPending) ; + TESTL(iStatus6 != KRequestPending) ; + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * 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("Get Call Status...")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + // Open a Data line and Call + RCall::TStatus callStatus; + RMobileCall::TMobileCallStatus mobileCallStatus; + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + TBuf<16> GoodNumber ; + GetGoodNumber(GoodNumber) ; + INFO_PRINTF1(_L("Opening Data Line")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + + TInt ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + TInt ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _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)) + { + CHECK_POINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(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 + INFO_PRINTF1(_L("Please ring the phone")); + CallMeDear() ; + + /* @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 +// WaitWithTimeout(iStatus,60*KOneSecond); // but timeout after 60 seconds + + ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; +// CHECK_POINT(callStatus, RCall::EStatusRinging, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; +// CHECK_POINT(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); + //CHECK_POINT(callStatus, RCall::EStatusAnswering, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + //CHECK_POINT(mobileCallStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-035.05")) ; + WaitWithTimeout(iStatus,20*KOneSecond); // but timeout after 60 seconds + + ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + + Print_RCall_TStatus(callStatus) ; + CHECK_POINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(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); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-009.01")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _L("GT83-TDATA-035.02")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECK_POINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle again")); + } + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * 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("Get Call Status...")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + StartNTRasSimulation(); + + // 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; + + //TName callName; + + RMobileCall::TMobileDataCallParamsV1 callDataParams; + RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams); + + TBuf<16> GoodNumber ; + GetGoodNumber(GoodNumber) ; + INFO_PRINTF1(_L("Opening Data Line")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + + TInt ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + TInt ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _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)) + { + CHECK_POINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(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; + + + INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber); + iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-024.00")) ; + + ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _L("GT83-TDATA-035.07")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + + Print_RCall_TStatus(callStatus) ; + CHECK_POINT(callStatus, RCall::EStatusConnected, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(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); + //CHECK_POINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-009.01")) ; + + //This test has some trobles with Erikson phones + //R520m could return KErrGeneral + //SH888 could return KErrTimedOut + INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ; + + ret=iDataCall.GetStatus(callStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-023.01")) ; + ret2=iDataCall.GetMobileCallStatus(mobileCallStatus); + CHECK_POINT(ret2, KErrNone, _L("GT83-TDATA-035.02")) ; + + if ((ret==KErrNone) && (ret2==KErrNone)) + { + CHECK_POINT(callStatus, RCall::EStatusIdle, _L("GT83-TDATA-023.01")) ; + CHECK_POINT(mobileCallStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-035.02")) ; + INFO_PRINTF1(_L("The call is Idle again")); + } + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + 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() +/** + * 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("Test Call Cancels")); + + //to make sure that line and call will be closed in leave case + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + // 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")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-001.01")); + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06")); + + // Call Status Change Cancel Request + RCall::TStatus callStatus; + iDataCall.NotifyStatusChange(iStatus, callStatus); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-020.02")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(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); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ; + iiDataCall.NotifyMobileCallStatusChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + // Hook Change Cancel Request + RCall::THookStatus hookStatus; + iDataCall.NotifyHookChange(iStatus, hookStatus); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-019.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyHookChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-019.04")) ; + + // Test Cancelling Notifications + RCall::TCaps callCaps; + iDataCall.NotifyCapsChange(iStatus, callCaps); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-017.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyCapsChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(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); + CHECK_POINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ; + iDataCall.NotifyMobileCallCapsChangeCancel(); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ; +#endif + + TTimeIntervalSeconds callDuration; + iDataCall.NotifyCallDurationChange(iStatus, callDuration); + CHECK_POINT((iStatus==KRequestPending || iStatus==KErrNotSupported), 1, _L("GT83-TDATA-021.01")) ; + User::After(KTenPartOfSec); //snack some sleep + iDataCall.NotifyCallDurationChangeCancel(); + User::WaitForRequest(iStatus); +#ifndef SIM_TSY + CHECK_POINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-021.03")) ; +#endif + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + + return TestStepResult(); + } + +CTestCallDuration::CTestCallDuration() + { + + SetTestStepName(_L("TestCallDuration")); + } + +CTestCallDuration::~CTestCallDuration() + { + } + +TVerdict CTestCallDuration::doTestStepL() + { + TVerdict Ret,Ret1; + INFO_PRINTF1(_L("Call Duration Test")); + +/* Log(_L("Change simtsy config number")); + iPhone->Close(); + SetTestNumber(1); + + User::LeaveIfError(iPhone->Open(*iTelServer,KPhoneName)) ; + // Initialize the Phone + TInt ret=iPhone->Initialise(); + if (ret!=KErrNone) + { + ERR_PRINTF2(_L("Failed to initialise the phone (%d)"), ret); + iPhone->Close(); + iTelServer->Close(); // disconnect from etel + return EFail; + } + */ + + Ret = RunTestL(TRUE); + Ret1 = RunTestL(FALSE); + if(Ret1 == EPass && Ret == EPass) + Ret = EPass; + else + Ret = EFail; + return Ret; + } + +TVerdict CTestCallDuration::RunTestL(TBool aBRingOut) + { + //RPhone::TLineInfo lineInfo; + TRequestStatus statDuration; + TTimeIntervalSeconds CallLengthDuration,CallLength; + TName CallName ; + + CleanupClosePushL(iLine); + CleanupClosePushL(iDataCall); + + INFO_PRINTF1(_L("Opening data Line")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("Call Duration Test 1")); + INFO_PRINTF1(_L("Opening New data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine, CallName), KErrNone, _L("Call Duration Test 2")); + INFO_PRINTF2(_L("data Call name is %S"), &CallName); + // start notification of call duration. + INFO_PRINTF1(_L("Testing Call Duration")); + iDataCall.NotifyCallDurationChange(statDuration,CallLengthDuration); + RingOrDialL(aBRingOut); + + User::WaitForRequest(statDuration); + CHECK_POINT(CallLengthDuration.Int() == 1,TRUE,_L("")); + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), CallLengthDuration.Int()); + User::After(5200000); + iDataCall.GetCallDuration(CallLength); + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), CallLength.Int()); + CHECK_POINT(CallLength.Int() >= 5 ,TRUE,_L("Call Duration Test 3")); + + + // Hang up the Call + INFO_PRINTF1(_L("Hanging up the call")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + INFO_PRINTF1(_L("HangUp successful")); + + iDataCall.GetCallDuration(CallLength); + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), CallLength.Int()); + + TInt numberOfNotifs=0 ; + for (; statDuration==KErrNone ;numberOfNotifs++) + { + iDataCall.NotifyCallDurationChange(statDuration,CallLengthDuration); + WaitWithTimeout(statDuration,5*KOneSecond); + } + + User::After(6000000); + + + INFO_PRINTF1(_L("Testing Call Duration Notification")); + RingOrDialL(aBRingOut); + User::After(2500000); + + iDataCall.GetCallDuration(CallLength); + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), CallLength.Int()); + CHECK_POINT(CallLength.Int() == 2,TRUE,_L("Call Duration Test 4")); + + User::WaitForRequest(statDuration); + iDataCall.NotifyCallDurationChange(statDuration,CallLengthDuration); + User::WaitForRequest(statDuration); + INFO_PRINTF2(TRefByValue(_L("Call duration = %d")), CallLengthDuration.Int()); + + CHECK_POINT(CallLengthDuration.Int() >= 2,TRUE,_L("Call Duration Test 5")); + + iDataCall.NotifyCallDurationChange(statDuration,CallLengthDuration); + iDataCall.NotifyCallDurationChangeCancel(); + WaitWithTimeout(statDuration,10*KOneSecond); + CHECK_POINT((statDuration.Int()==KErrNone)||(statDuration.Int()==KErrCancel), TRUE, _L("Call Duration Test 6")); + + INFO_PRINTF1(_L("Hanging up the call")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + INFO_PRINTF1(_L("HangUp successful")); + + + User::After(6000000); + + + INFO_PRINTF1(_L("Testing Call Duration Notification Cancel")); + iDataCall.NotifyCallDurationChange(statDuration,CallLengthDuration); + RingOrDialL(aBRingOut); + iDataCall.NotifyCallDurationChangeCancel(); + WaitWithTimeout(statDuration,10*KOneSecond); + CHECK_POINT(iStatus.Int(), KErrNone, _L("Call Duration Test 7")); + + // Hang up the Call + INFO_PRINTF1(_L("Hanging up the call")); + iDataCall.HangUp(iStatus); + User::WaitForRequest(iStatus); + INFO_PRINTF1(_L("HangUp successful")); + + + // Close the line and call + CleanupStack::PopAndDestroy(&iDataCall) ; + CleanupStack::PopAndDestroy(&iLine) ; + return TestStepResult(); + + } + +TBool CTestCallDuration::RingOrDialL(TBool aBRingOut) + { + if(!aBRingOut) + { + INFO_PRINTF1(_L("Please ring the phone")); + TESTL(CallMeDear() == KErrNone) ; //init sim incoming call + iDataCall.AnswerIncomingCall(iStatus); // wait for a call + WaitWithTimeout(iStatus,15*KOneSecond); // but timeout after 60 seconds + CHECK_POINT(iStatus.Int(), KErrNone, _L("Call Duration Test 8")); + } + else + { + StartNTRasSimulation(); + INFO_PRINTF2(_L("Dialling %S"),&KGoodNumber); + iDataCall.Dial(iStatus,KGoodNumber); + User::WaitForRequest(iStatus); + // Wait for the Call Status Change notification + TESTL(iStatus==KErrNone); + INFO_PRINTF1(_L("...Call is Connected")); + } + return TRUE; + } + + +//------------------------------------------------------------------ + +CTestRemoteHangup::CTestRemoteHangup() +/** 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("TestRemoteHangup")); + } +//------------------------------------------------------------------ + +TVerdict CTestRemoteHangup::doTestStepL() +/** + * This function tests call status at various times during calls + * @test GT83-TDATA-XXX.XX Test hanging up a data call from the remote end + */ + { + INFO_PRINTF1(_L("Test Remote Hangup")); + + StartNTRasSimulation(); + + RCall::TStatus lineStatus; + TName callName; + TBuf<16> goodNumber ; + GetGoodNumber(goodNumber) ; + + // Open a Data Line and Call + INFO_PRINTF1(_L("Opening Data Line")); + CHECK_POINT(iLine.Open(iPhone,KDataLineName), KErrNone, _L("GT83-TDATA-XXX.XX")); + + INFO_PRINTF1(_L("Opening New Data Call")); + CHECK_POINT(iDataCall.OpenNewCall(iLine, callName), KErrNone, _L("GT83-TDATA-XXX.XX")); + INFO_PRINTF2(_L("Data Call name is %S"), &callName); + + INFO_PRINTF2(_L("Dialling %S...."), &goodNumber); + iDataCall.Dial(iStatus, goodNumber); + User::WaitForRequest(iStatus); + CHECK_POINT(iStatus, KErrNone, _L("GT83-TDATA-XXX.XX")); + + // Trigger remote hangup + RCall::TStatus notifyLineStatus; + TRequestStatus notifyStatus; + iLine.NotifyStatusChange(notifyStatus, notifyLineStatus); + TESTL(HangMeUpDear() == KErrNone); + User::WaitForRequest(notifyStatus); + TESTL(notifyStatus.Int() == KErrNone); + CHECK_POINT(notifyLineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-XXX.XX")) ; + TInt ret = iLine.GetStatus(lineStatus); + CHECK_POINT(ret, KErrNone, _L("GT83-TDATA-XXX.XX")) ; + CHECK_POINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-XXX.XX")) ; + + // Close the line and call + iDataCall.Close(); + iLine.Close(); + + return TestStepResult(); + } +