1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This program is designed to test the Data Line abilities of MMTSY and ETel.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include "Te_Data.h"

    23 

    24 _LIT(KDataLineName,"Data");

    25 _LIT(KCsyName, "ECUART.CSY");

    26 _LIT(KConsoleTitle,"Action Required");

    27 

    28 const TInt KTenPartOfSec = 100000 ;

    29 const TInt KOneSecond=1000000;	// Used in a time out function, 1 second (in microSeconds)

    30 const TInt KTenSeconds=10000000;	// Used in a time out function, 10 seconds (in microSeconds)

    31 const TInt KFifteenSeconds=15000000;	// 5 seconds (in microSeconds)

    32 

    33 _LIT8(KWriteTestData,"MM  TSY Data and Echo Server Test is in progress...");

    34 

    35 

    36 CTestLineStatusIncommingCall::CTestLineStatusIncommingCall()

    37 /** Each test step initialises it's own name

    38 */

    39 	{

    40 	// store the name of this test case

    41 	// this is the name that is used by the script file

    42 	SetTestStepName(_L("TestLineStatusIncommingCall"));

    43 	}

    44 //------------------------------------------------------------------

    45 

    46 TVerdict CTestLineStatusIncommingCall::doTestStepL( void )

    47 /**	 Tests line status function

    48  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

    49  * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic)

    50  * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle"""

    51  * @test GT83-TDATA-004.04 "Test retrieval of a data line's current status when the line's status is ""Ringing"""

    52  * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected"""

    53  * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up"""

    54  * @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

    55  * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic)

    56  * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic)

    57  * @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"""

    58  * @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"""

    59  * @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"""

    60 */

    61 	{

    62 	INFO_PRINTF1(_L("======Start test Test Line Status"));

    63 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

    64 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

    65     //to make sure that line and call will be closed in leave case

    66 	CleanupStack::PushL(*this) ; ;

    67 

    68 	RCall::TStatus lineStatus;

    69 	TBuf<16> GoodNumber ;

    70 	GetRemoteNumber(GoodNumber) ;

    71 	// Open a Data line and Call

    72 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

    73 	INFO_PRINTF1(_L("Opening Data Line"));

    74 	TEST_CHECKL(iLine.Open(iPhone,  KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

    75 

    76 	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

    77 	TInt ret = iLine.GetStatus(lineStatus);

    78 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.00 - *** Failed RMobileLine::GetStatus() ***")) ;

    79 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

    80 

    81 	RMobileCall::TMobileCallStatus mobileLineStatus;

    82 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

    83 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.00 - *** Failed RMobileLine::GetMobileLineStatus() ")) ;

    84 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ;

    85 

    86 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

    87     CleanupStack::PushL(console);

    88 	console->Printf(_L("Please ring the phone\n"));

    89 

    90 	TName callName;

    91 	/* @test GT83-AT-024	Test setting notification of an incoming call on a data line */

    92 	iLine.NotifyIncomingCall(iStatus, callName);	// wait for a call

    93 	WaitWithTimeoutL(iStatus,60*KOneSecond);		// but timeout after 60 second

    94 

    95 

    96 	CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::NotifyIncomingCall() ***")) ;

    97 	if(iStatus.Int() == KRequestPending)

    98 		{

    99 		iLine.NotifyIncomingCallCancel();

   100 		User::WaitForRequest(iStatus);

   101 		}

   102 

   103 	/* @test GT83-AT-36	Test retrieval of the current call status when it is ringing*/

   104 	ret = iLine.GetStatus(lineStatus);

   105 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetStatus() *** ")) ;

   106 	CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-0")) ;

   107 

   108 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   109 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetMobileLineStatus() *** ")) ;

   110 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-008.001")) ;

   111 	INFO_PRINTF1(_L("Phone is ringing..."));

   112 

   113 	//Test for incomming data call

   114 	TestLineCapabilitiesL(iLine);

   115 

   116 	/* @test GT83-AT-028	Test opening a new call by specifying the name of a line

   117 	*/

   118 	ret = iDataCall.OpenExistingCall(iLine, callName);

   119 	TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05 - *** Failed RMobileCall::OpenExistingCall() ***")) ;

   120 

   121 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

   122 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

   123 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

   124 	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

   125 

   126 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

   127 

   128 

   129 	// Answer an incoming call initiated by t_echo.exe and obtain the call's current status

   130 	//GT83-AT-032	Test answering a call on a data line (Generic)	RCall::AnswerIncomingCall

   131 	iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg);

   132 

   133 	// DEF55659-NCh : timout changed from 30 to 60 s. Current version of MM.TSY is pretty slow, due

   134 	// to the way it deal with the new comms repository. This timeout must be changed back to 30s

   135 	// when comms repository access code is updated.

   136 	WaitWithTimeoutL(iStatus,60*KOneSecond);		// but timeout after 60 seconds

   137 

   138 	//cancel AnswerIncomingCall if request is still pending

   139 	if(iStatus.Int() == KRequestPending)

   140 		{

   141 		iDataCall.AnswerIncomingCallCancel();

   142 		User::WaitForRequest(iStatus);

   143 		}

   144 

   145 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

   146 

   147 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00 -  *** Failed RMobileCall::AnswerIncomingCall() ***")) ;

   148 	ret = iLine.GetStatus(lineStatus);

   149 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.04 - *** Failed RMobileLine::GetStatus() ***")) ;

   150 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.04")) ;

   151 

   152 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   153 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.04 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   154 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.04")) ;

   155 	TestLineCapabilitiesL(iLine);

   156 

   157 	/* @test GT83-AT-36	Test retrieval of the current call status when it is connected*/

   158 	ret = iLine.GetStatus(lineStatus);

   159 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   160 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ;

   161 

   162 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   163 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.07 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   164 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-031.07")) ;

   165 

   166 	User::After(10*KOneSecond);

   167 

   168 	INFO_PRINTF1(_L("Hanging Up"));

   169 	iDataCall.HangUp(iStatus);

   170 

   171 	/* @test GT83-AT-36	Test retrieval of the current call status when it is hang up*/

   172 	ret = iLine.GetStatus(lineStatus);

   173 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.08 - *** Failed RMobileLine::GetStatus() *** ")) ;

   174 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-0")) ;

   175 

   176 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   177 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.09 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   178 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-004.09")) ;

   179 

   180 	User::WaitForRequest(iStatus);

   181 	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

   182 

   183 	//This test has some trobles with Ericsson phones

   184 	//R520m could return KErrGeneral

   185 	//SH888 could return KErrTimedOut

   186 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

   187 

   188 	//Check that line status is now idle. If line is still connected, Fail check and leave to 

   189 	//prevent problems down the line

   190 	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

   191 	ret = iLine.GetStatus(lineStatus);

   192 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02 - *** Failed RMobileLine::GetStatus() ***")) ;

   193 	TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02 - *** FAILED TO HANGUP CALL!! ***" )) ;

   194 

   195 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   196 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   197 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

   198 

   199 	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

   200 	ret = iLine.GetStatus(lineStatus);

   201 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ;

   202 	TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

   203 

   204 	console->Printf(_L("...Disconnected\n"));

   205 	User::After(10*KOneSecond);

   206     CleanupStack::PopAndDestroy(console);

   207 

   208 	// Close the line and call

   209 	CleanupStack::PopAndDestroy() ;

   210 

   211 	INFO_PRINTF1(_L("======End test ====="));

   212 	return TestStepResult() ;

   213 	}

   214 //------------------------------------------------------------------

   215 

   216 CTestLineStatusOutgoingCall::CTestLineStatusOutgoingCall()

   217 /** Each test step initialises it's own name

   218 */

   219 	{

   220 	// store the name of this test case

   221 	// this is the name that is used by the script file

   222 	SetTestStepName(_L("TestLineStatusOutgoingCall"));

   223 	}

   224 //------------------------------------------------------------------

   225 

   226 TVerdict CTestLineStatusOutgoingCall::doTestStepL( void )

   227 /**	 Tests line status function

   228  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   229  * @test GT83-TDATA-004.00 Test retrieval of a data line's current status (Generic)

   230  * @test GT83-TDATA-004.02 "Test retrieval of a data line's current status when the line's status is ""Idle"""

   231  * @test GT83-TDATA-004.03 "Test retrieval of a data line's current status when the line's status is ""Dialling"""

   232  * @test GT83-TDATA-004.07 "Test retrieval of a data line's current status when the line's status is ""Connected"""

   233  * @test GT83-TDATA-004.08 "Test retrieval of a data line's current status when the line's status is ""Hanging up"""

   234  * @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

   235  * @test GT83-TDATA-031.00 Test retrieval of a mobile data line's current status (Generic)

   236  * @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"""

   237 */

   238 	{

   239 	INFO_PRINTF1(_L("======Start test Test Line Status"));

   240 

   241 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

   242 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

   243     //to make sure that line and call will be closed in leave case

   244 	CleanupStack::PushL(*this) ; ;

   245 

   246 	TName callName;

   247 

   248 	RCall::TStatus lineStatus;

   249 	TBuf<16> GoodNumber ;

   250 	GetRemoteNumber(GoodNumber) ;

   251 	// Open a Data line and Call

   252 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

   253 	INFO_PRINTF1(_L("Opening Data Line"));

   254 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

   255 

   256 	/* @test GT83-AT-36	Test retrieval of the current call status when it is idle*/

   257 	TInt ret = iLine.GetStatus(lineStatus);

   258 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.00 - *** Failed RMobileLine::GetStatus() ***")) ;

   259 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02")) ;

   260 

   261 	RMobileCall::TMobileCallStatus mobileLineStatus;

   262 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   263 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.00 - *** Failed RMobileLine::GetMobileLineStatus() ")) ;

   264 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ;

   265 

   266 	/* @test GT83-AT-028	Test opening a new call by specifying the name of a line

   267 	*/

   268 	ret = iDataCall.OpenNewCall(iLine, callName);

   269 	TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05 - *** Failed RMobileCall::OpenNewCall() ***")) ;

   270 

   271 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

   272 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

   273 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

   274 	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

   275 

   276 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

   277 

   278 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

   279     CleanupStack::PushL(console);

   280 	console->Printf(_L("Calling...\n"));

   281 

   282 	INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);

   283 	iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber);

   284 	ret = iLine.GetStatus(lineStatus);

   285 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetStatus() *** ")) ;

   286 	//Commented out because phone does not report that it is going into this state

   287 	//TEST_CHECKL(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-004.03")) ;

   288 	WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds

   289 	CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ;

   290 	

   291 	if(iStatus.Int() == KRequestPending)

   292 		{

   293 		iDataCall.DialCancel();

   294 		User::WaitForRequest(iStatus);

   295 		}

   296 	

   297 	//Test for outgoing data call

   298 	TestLineCapabilitiesL(iLine);

   299 

   300 	/* @test GT83-AT-36	Test retrieval of the current call status when it is connected*/

   301 	ret = iLine.GetStatus(lineStatus);

   302 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.07 - *** Failed RMobileLine::GetStatus() *** ")) ;

   303 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-004.07")) ;

   304 

   305 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   306 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-0 - *** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   307 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-0")) ;

   308 

   309 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

   310 	User::After(10*KOneSecond);

   311 

   312 	INFO_PRINTF1(_L("Call connected - listen for 20 seconds..."));

   313 

   314 	User::After(20*KOneSecond); // hold call active for 20 seconds

   315 

   316 	INFO_PRINTF1(_L("Hanging up"));

   317 	iDataCall.HangUp(iStatus);

   318 

   319 	ret = iLine.GetStatus(lineStatus);

   320 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.08 - *** Failed RMobileLine::GetStatus() ***  ")) ;

   321 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-004.08")) ;

   322 

   323 	User::WaitForRequest(iStatus);

   324 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ;

   325 

   326 	//This test has some troubles with Ericsson phones

   327 	//R520m could return KErrGeneral

   328 	//SH888 could return KErrTimedOut

   329 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

   330 

   331 	//Test line capabilities

   332 	TestLineCapabilitiesL(iLine);

   333 

   334 	ret = iLine.GetStatus(lineStatus);

   335 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-004.02")) ;

   336 	TEST_CHECKL(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-004.02 - *** Phone Failed to hang up ***")) ;

   337 

   338 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   339 	CHECKPOINT(ret, KErrNone, _L("GT83-TDATA-031.01 -  *** Failed RMobileLine::GetMobileLineStatus() *** ")) ;

   340 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-031.01")) ;

   341 

   342 	console->Printf(_L("...Disconnected\n"));

   343 	User::After(10*KOneSecond);

   344     CleanupStack::PopAndDestroy(console);

   345 

   346 	// Close the line and call

   347 	CleanupStack::PopAndDestroy() ;

   348 

   349 	INFO_PRINTF1(_L("======End test ====="));

   350 	return TestStepResult() ;

   351 	}

   352 //------------------------------------------------------------------

   353 

   354 CTestLineInfo::CTestLineInfo()

   355 /** Each test step initialises it's own name

   356 */

   357 	{

   358 	// store the name of this test case

   359 	// this is the name that is used by the script file

   360 	SetTestStepName(_L("TestLineInfo"));

   361 	}

   362 //------------------------------------------------------------------

   363 

   364 TVerdict CTestLineInfo::doTestStepL( void )

   365 /**

   366  * This function gets the Line capabilities, line information, Number of calls

   367  * on the line and call information,

   368  * @test NONE	Test the ability to get the current line information of the data line (Generic)

   369  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   370  * @test GT83-TDATA-005.01 "Test retrieval of the current hook status, when the line is currently ""off hook"""

   371  * @test GT83-TDATA-005.02 "Test retrieval of the current hook status, when the line is currently ""on hook"""

   372  * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line

   373  * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic)

   374  * @test GT83-TDATA-026.02 Test the ability to place an asynchronous request to hang up a data call

   375  */

   376 	{

   377 	INFO_PRINTF1(_L("======Start test Test Line Information"));

   378     //to make sure that line and call will be closed in leave case

   379 	CleanupStack::PushL(*this) ; ;

   380 	INFO_PRINTF1(_L("Opening Data Line"));

   381 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01 - *** Failed RMobileLine::Open() ***"));

   382 	INFO_PRINTF1(_L("Opening New Data Call"));

   383 	TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06 - *** Failed RMobileCall::OpenNewCall() ***"));

   384 

   385 	// Line Information

   386 	RLine::TLineInfo lineInfo;

   387 	TRAPD(ret, ret=iLine.GetInfo(lineInfo));

   388 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetInfo ***"));

   389 	if (ret!=KErrNone)

   390 		{

   391 		INFO_PRINTF1(_L("Get Line Info. is NOT supported"));

   392 		}

   393 	else

   394 		{

   395 		INFO_PRINTF1(_L("Get Line Info is successful"));

   396 		CHECKPOINT(lineInfo.iHookStatus,  RCall::EHookStatusOn, _L("GT83-TDATA-0")) ;

   397 		TEST(lineInfo.iStatus == RCall::EStatusIdle) ;

   398 		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Name of last call added: %S")), &lineInfo.iNameOfLastCallAdded);

   399 		}

   400 

   401 	// Hook status information

   402 	INFO_PRINTF1(_L("\nRetrieving Hook Status..."));

   403 	RCall::THookStatus hookStatus;

   404 	ret=iLine.GetHookStatus(hookStatus);

   405 	if (ret!=KErrNone)

   406 		{

   407 		INFO_PRINTF1(_L("Get Hook status is NOT supported"));

   408 		}

   409 	else

   410 		{

   411 		CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-005.02")) ;

   412 		INFO_PRINTF1(_L("The line is currently ON Hook"));

   413 		}

   414 

   415 	// Post 'Answer a Call' Notifications

   416 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

   417 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

   418 

   419 

   420 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

   421 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

   422 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

   423 	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

   424 

   425 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

   426 

   427 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

   428     CleanupStack::PushL(console);

   429 	console->Printf(_L("Please ring the phone\n"));

   430 

   431 	// Answer an incoming call initiated by t_echo.exe and obtain the call's current status

   432 	//GT83-AT-032	Test answering a call on a data line (Generic)	RCall::AnswerIncomingCall

   433 	iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg);

   434 

   435 	WaitWithTimeoutL(iStatus,6*KTenSeconds);		// but timeout after 60 seconds

   436 

   437 	//cancel AnswerIncomingCall if request is still pending

   438 	if(iStatus.Int() == KRequestPending)

   439 		{

   440 		iDataCall.AnswerIncomingCallCancel();

   441 		User::WaitForRequest(iStatus);

   442 		}

   443 

   444 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

   445 

   446 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00 - *** Failed RMobileCall::AnswerIncomingCall() ***")) ;

   447 

   448 	// Count the no. of calls on the line & Get call info.

   449 	INFO_PRINTF1(_L("Retrieving no. of calls opened from the line.."));

   450 	TInt lineCount=0;

   451 	TEST(KErrNone == iLine.EnumerateCall(lineCount));

   452 	INFO_PRINTF2(TRefByValue<const TDesC>(_L("No of calls opened = %d")), lineCount);

   453 

   454 	INFO_PRINTF1(_L("Getting Call info.."));

   455 	RLine::TCallInfo callInfo;

   456 	ret=iLine.GetCallInfo(0,callInfo);

   457 	if (ret==KErrNotSupported)

   458 		{

   459 		INFO_PRINTF1(_L("Get Call information is NOT supported"));

   460 		}

   461 	if (ret==KErrNone)

   462 		{

   463 		INFO_PRINTF1(_L("Get Call information is successful"));

   464 		}

   465 

   466 	// Get the line's current hook status

   467 	ret=iLine.GetHookStatus(hookStatus);

   468 	if (ret!=KErrNone)

   469 		{

   470 		INFO_PRINTF1(_L("Get Hook status is NOT supported"));

   471 		}

   472 	else

   473 		{

   474 		TEST_CHECKL(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-005.01")) ;

   475 		INFO_PRINTF1(_L("The line is currently OFF Hook"));

   476 		}

   477 

   478 	User::After(KTenSeconds);

   479 

   480 	INFO_PRINTF1(_L("Hanging up"));

   481 	iDataCall.HangUp(iStatus);

   482 	User::WaitForRequest(iStatus);

   483 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ;

   484 

   485 	//This test has some trobles with Ericsson phones

   486 	//R520m could return KErrGeneral

   487 	//SH888 could return KErrTimedOut

   488 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

   489 

   490 	console->Printf(_L("...Disconnected\n"));

   491 	User::After(10*KOneSecond);

   492     CleanupStack::PopAndDestroy(console);

   493 

   494 	// Close the line and call

   495 	CleanupStack::PopAndDestroy() ;

   496 

   497 	INFO_PRINTF1(_L("======End test ====="));

   498 	return TestStepResult() ;

   499 	}

   500 //------------------------------------------------------------------

   501 

   502 CTestLineNotificationsIncommingCall::CTestLineNotificationsIncommingCall()

   503 /** Each test step initialises it's own name

   504 */

   505 	{

   506 	// store the name of this test case

   507 	// this is the name that is used by the script file

   508 	SetTestStepName(_L("TestLineNotificationsIncommingCall"));

   509 	}

   510 //------------------------------------------------------------------

   511 

   512 TVerdict CTestLineNotificationsIncommingCall::doTestStepL( void )

   513 /** Tests line notifications

   514  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   515  * @test GT83-TDATA-008.01 Test setting notification of an incoming call on a data line

   516  * @test GT83-TDATA-008.02 Test for a notification when there is an incoming call on a data line

   517  * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line

   518  * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on"""

   519  * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off"""

   520  * @test GT83-TDATA-010.01 Test setting notification of a change in the status of the data line

   521  * @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"""

   522  * @test GT83-TDATA-011.01 Test setting notification of a call being added to a data line

   523  * @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

   524  * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic)

   525  * @test GT83-TDATA-032.01 Test setting a request for a notification of a change in the status of the mobile data line

   526  * @test GT83-TDATA-032.07 "Test for a notification of a change in status of the mobile data line from ""connected"" to ""disconnecting"""

   527  * @test GT83-TDATA-032.08 "Test for a notification of a change in status of the mobile data line from ""disconnecting"" to ""idle"""

   528  * @test GT83-TDATA-032.09 "Test for a notification of a change in status of the mobile data line from ""idle"" to ""ringing"""

   529  * @test GT83-TDATA-032.10 "Test for a notification of a change in status of the mobile data line from ""ringing"" to ""answering"""

   530  * @test GT83-TDATA-032.11 "Test for a notification of a change in status of the mobile data line from ""answering"" to ""connected"""

   531 */

   532 	{

   533 	INFO_PRINTF1(_L("======Start test Test Line Notifications"));

   534     //to make sure that line and call will be closed in leave case

   535 	CleanupStack::PushL(*this) ; 

   536 

   537 	TBuf<16> GoodNumber ;

   538 	GetRemoteNumber(GoodNumber) ;

   539 

   540 	// NotifyIncomingCall and NotifyStatusChange

   541 	TName callName1;

   542 	TName callName2;

   543 	TInt ret = KErrNone;

   544 	RCall::TStatus lineStatus;

   545 	RMobileCall::TMobileCallStatus mobileLineStatus;

   546 	RCall::THookStatus hookStatus;

   547 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

   548 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

   549 

   550 

   551 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

   552 	INFO_PRINTF1(_L("Opening Data Line"));

   553 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

   554 

   555 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

   556     CleanupStack::PushL(console);

   557 	console->Printf(_L("Please ring the phone\n"));

   558 

   559 	iLine.NotifyIncomingCall(iStatus, callName1);	// wait for a call

   560 

   561 	// @test GT83-AT-026	Test setting notification of a change in the status of the data line

   562 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   563 

   564 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   565 

   566 	// @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

   567 	iLine.NotifyHookChange(iStatus4, hookStatus);

   568 

   569     /* @test GT83-AT-025	Test notification of a call being added to a data line 	*/

   570 	iLine.NotifyCallAdded(iStatus5, callName2);

   571 

   572 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.01")) ;

   573 	CHECKPOINT(iStatus2.Int(), KRequestPending, _L("GT83-TDATA-010.02")) ;

   574 	CHECKPOINT(iStatus3.Int(), KRequestPending, _L("GT83-TDATA-032.01")) ;

   575 	CHECKPOINT(iStatus4.Int(), KRequestPending, _L("GT83-TDATA-011.01")) ;

   576 	CHECKPOINT(iStatus5.Int(), KRequestPending, _L("GT83-TDATA-009.01")) ;

   577 

   578 	WaitWithTimeoutL(iStatus,90*KOneSecond); // but timeout after 90 seconds

   579 	CHECKPOINT(iStatus.Int(), KErrNone, _L("GT83-TDATA-008.02")) ;

   580 

   581 	if(iStatus.Int() == KRequestPending)

   582 		{

   583 		iLine.NotifyIncomingCallCancel();

   584 		User::WaitForRequest(iStatus);

   585 		}

   586 

   587     // @test GT83-AT-026	Test notification of a change in the status of the data line

   588 	// from "idle" to "ringing"

   589 	User::WaitForRequest(iStatus2);

   590 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ;

   591 	CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TDATA-010.02")) ;

   592 

   593 	User::WaitForRequest(iStatus3);

   594 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.09")) ;

   595 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TDATA-032.09")) ;

   596 

   597 	/* @test GT83-AT-025	Test notification of a call being added to a data line

   598 	that currently has no calls*/

   599 	User::WaitForRequest(iStatus5);

   600 	CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TDATA-011.01")) ;

   601 	CHECKPOINT(callName2 == callName1, 1,  _L("GT83-TDATA-011")) ;

   602 

   603 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

   604 

   605 	INFO_PRINTF1(_L("Phone is ringing... Now answering..."));

   606 

   607 	/* @test GT83-AT-026	Test notification of a change in the status of the data line from

   608 	 "idle" to "ringing" to "answering" to "connected" to "hanging up" to "idle"

   609 	 */

   610 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   611 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   612 

   613 	ret = iDataCall.OpenExistingCall(iLine, callName1);

   614 	TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05")) ;

   615 

   616 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

   617 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

   618 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

   619 	//callDataParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;

   620 

   621 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

   622 

   623 

   624 	// Answer an incoming call initiated by t_echo.exe and obtain the call's current status

   625 	//GT83-AT-032	Test answering a call on a data line (Generic)	RCall::AnswerIncomingCall

   626 	iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg);

   627     // @test GT83-AT-026	Test notification of a change in the status of the data line

   628 	// from "ringing" to "answering"

   629 	User::WaitForRequest(iStatus2);

   630 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ;

   631 	CHECKPOINT(lineStatus, RCall::EStatusAnswering, _L("GT83-TDATA-010.01")) ;

   632 

   633 	User::WaitForRequest(iStatus3);

   634 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.10")) ;

   635 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusAnswering, _L("GT83-TDATA-032.10")) ;

   636 	WaitWithTimeoutL(iStatus,30*KOneSecond);		// but timeout after 30 seconds

   637 

   638 	//cancel AnswerIncomingCall if request is still pending

   639 	if(iStatus.Int() == KRequestPending)

   640 		{

   641 		iDataCall.AnswerIncomingCallCancel();

   642 		User::WaitForRequest(iStatus);

   643 		}

   644 

   645 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ;	  //wrong code -2147483647

   646 

   647 

   648     // @test GT83-AT-026	Test notification of a change in the status of the data line

   649 	// from "answering"	to "connected"

   650 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   651 	User::WaitForRequest(iStatus2);

   652 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.01")) ;

   653 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.01")) ;

   654 

   655 

   656 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   657 	User::WaitForRequest(iStatus3);

   658 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.11")) ;

   659 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.11")) ;

   660 

   661 	User::WaitForRequest(iStatus4);

   662 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.02")) ;

   663 	CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.02")) ;

   664 

   665 	// now hangup call

   666 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   667 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   668 	iLine.NotifyHookChange(iStatus4, hookStatus);

   669 

   670 	INFO_PRINTF1(_L("Call connected - now hanging up..."));

   671 	iDataCall.HangUp(iStatus);

   672 	User::WaitForRequest(iStatus);

   673 

   674 	//This test has some trobles with Ericsson phones

   675 	//R520m could return KErrGeneral

   676 	//SH888 could return KErrTimedOut

   677 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

   678 

   679     // @test GT83-AT-026	Test notification of a change in the status of the data line

   680 	// from "connecting" to "hanging up"

   681 	User::WaitForRequest(iStatus2);

   682 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ;

   683 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.02")) ;

   684 

   685 	User::WaitForRequest(iStatus3);

   686 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ;

   687 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-032.07")) ;

   688 

   689 	// @test GT83-AT-026	Test notification of a change in the status of the data

   690 	// line from "hanging up" to "idle"

   691 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   692 	User::WaitForRequest(iStatus2);

   693 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.02")) ;

   694 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.02")) ;

   695 

   696 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   697 	User::WaitForRequest(iStatus3);

   698 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ;

   699 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-032.08")) ;

   700 

   701 	//!< @test GT83-AT-037	Test notification of a change in hook status of a data line

   702 	//!<  from "off" to "on" aHookStatus = EHookStatusOff before the hook status changes,

   703 	//!< and EHookStatusOn after the hook status changes

   704 	User::WaitForRequest(iStatus4);

   705 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.03")) ;

   706 	CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.03")) ;

   707 	//check that all request has been finished

   708 	TEST(iStatus.Int()!= KRequestPending) ;

   709 	TEST(iStatus2.Int() != KRequestPending) ;

   710 	TEST(iStatus3.Int() != KRequestPending) ;

   711 	TEST(iStatus4.Int() != KRequestPending) ;

   712 	TEST(iStatus5.Int() != KRequestPending) ;

   713 

   714 	console->Printf(_L("...Disconnected\n"));

   715 	User::After(10*KOneSecond);

   716     CleanupStack::PopAndDestroy(console);

   717 

   718 	// Close the line and call

   719 	CleanupStack::PopAndDestroy() ;

   720 

   721 	INFO_PRINTF1(_L("======End test ====="));

   722 	return TestStepResult() ;

   723 	}

   724 //------------------------------------------------------------------

   725 

   726 CTestLineNotificationsOutgoingCall::CTestLineNotificationsOutgoingCall()

   727 /** Each test step initialises it's own name

   728 */

   729 	{

   730 	// store the name of this test case

   731 	// this is the name that is used by the script file

   732 	SetTestStepName(_L("TestLineNotificationsOutgoingCall"));

   733 	}

   734 //------------------------------------------------------------------

   735 

   736 TVerdict CTestLineNotificationsOutgoingCall::doTestStepL( void )

   737 /** Tests line notifications

   738  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   739  * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on"""

   740  * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off"""

   741  * @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"""

   742  * @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

   743  * @test GT83-TDATA-032.02 "Test for a notification of a change in status of the mobile data line from ""idle"" to ""dialling"""

   744  * @test GT83-TDATA-032.04 "Test for a notification of a change in status of the mobile data line from ""connecting"" to ""connected"""

   745  * @test GT83-TDATA-032.07 "Test for a notification of a change in status of the mobile data line from ""connected"" to ""disconnecting"""

   746  * @test GT83-TDATA-032.08 "Test for a notification of a change in status of the mobile data line from ""disconnecting"" to ""idle"""

   747 */

   748 	{

   749 	INFO_PRINTF1(_L("======Start test Test Line Notifications"));

   750     //to make sure that line and call will be closed in leave case

   751 	CleanupStack::PushL(*this) ; 

   752 

   753 	TBuf<16> GoodNumber ;

   754 	GetRemoteNumber(GoodNumber) ;

   755 

   756 	// NotifyIncomingCall and NotifyStatusChange

   757 	TInt ret = KErrNone;

   758 	RCall::TStatus lineStatus;

   759 	RMobileCall::TMobileCallStatus mobileLineStatus;

   760 	RCall::THookStatus hookStatus;

   761 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

   762 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

   763 

   764 

   765 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

   766 	INFO_PRINTF1(_L("Opening Data Line"));

   767 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

   768 

   769 	ret = iDataCall.OpenNewCall(iLine);

   770 	TEST_CHECKL(ret, KErrNone, _L("GT83-TDATA-014.05")) ;

   771 	// Now test call status during an outgoing call

   772 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

   773 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

   774 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

   775 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

   776 

   777 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   778 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   779 	iLine.NotifyHookChange(iStatus4, hookStatus);

   780 

   781 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

   782     CleanupStack::PushL(console);

   783 	console->Printf(_L("Calling...\n"));

   784 

   785 	INFO_PRINTF2(_L("Dialling %S...."), &GoodNumber);

   786 	iDataCall.Dial(iStatus, callDataParamsPckg, GoodNumber);

   787 

   788 	User::WaitForRequest(iStatus2);

   789 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ;

   790 	CHECKPOINT(lineStatus, RCall::EStatusDialling, _L("GT83-TDATA-010.03")) ;

   791 

   792 	User::WaitForRequest(iStatus3);

   793 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.02")) ;

   794 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDialling, _L("GT83-TDATA-032.02")) ;

   795 

   796 	User::WaitForRequest(iStatus); //whaiting for dial

   797 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-0")) ;

   798 

   799 	User::WaitForRequest(iStatus4);

   800 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.03")) ;

   801 	CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TDATA-009.03")) ;

   802 

   803 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   804 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   805 

   806 	User::WaitForRequest(iStatus2);

   807 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ;

   808 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TDATA-010.03")) ;

   809 

   810 	User::WaitForRequest(iStatus3);

   811 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.13")) ;

   812 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TDATA-032.13")) ;

   813 

   814 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

   815 

   816 	INFO_PRINTF1(_L("Call connected - hanging up..."));

   817 

   818 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   819 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   820 	iLine.NotifyHookChange(iStatus4, hookStatus);

   821 

   822 	//HANG UP

   823 	User::After(10*KOneSecond);

   824 	iDataCall.HangUp(iStatus);

   825 	User::WaitForRequest(iStatus);

   826 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ;

   827 

   828 	//This test has some trobles with Ericsson phones

   829 	//R520m could return KErrGeneral

   830 	//SH888 could return KErrTimedOut

   831 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

   832 

   833 	User::WaitForRequest(iStatus2);

   834 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ;

   835 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TDATA-010.03")) ;

   836 

   837 	User::WaitForRequest(iStatus3);

   838 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.07")) ;

   839 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TDATA-032.07")) ;

   840 

   841 	/* @test GT83-AT-037	Test notification of a change in hook status of a data

   842 	 line from "on" to off"	aHookStatus = EHookStatusOn before the hook status changes,

   843 	 */

   844 	User::WaitForRequest(iStatus4);

   845 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TDATA-009.02")) ;

   846 	CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TDATA-009.02")) ;

   847 

   848 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   849 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   850 

   851 	User::WaitForRequest(iStatus2);

   852 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TDATA-010.03")) ;

   853 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TDATA-010.03")) ;

   854 

   855 	User::WaitForRequest(iStatus3);

   856 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TDATA-032.08")) ;

   857 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TDATA-032.08")) ;

   858 

   859 	TEST(iStatus != KRequestPending) ;

   860 	TEST(iStatus2 != KRequestPending) ;

   861 	TEST(iStatus3 != KRequestPending) ;

   862 	TEST(iStatus4 != KRequestPending) ;

   863 

   864 	console->Printf(_L("...Disconnected\n"));

   865 	User::After(10*KOneSecond);

   866     CleanupStack::PopAndDestroy(console);

   867 

   868 	// Close the line and call

   869 	CleanupStack::PopAndDestroy() ;

   870 

   871 	INFO_PRINTF1(_L("======End test ====="));

   872 	return TestStepResult() ;

   873 	}

   874 //------------------------------------------------------------------

   875 

   876 CTestLineCancels::CTestLineCancels()

   877 /** Each test step initialises it's own name

   878 */

   879 	{

   880 	// store the name of this test case

   881 	// this is the name that is used by the script file

   882 	SetTestStepName(_L("TestLineCancels"));

   883 	}

   884 //------------------------------------------------------------------

   885 

   886 TVerdict CTestLineCancels::doTestStepL( void )

   887 /**

   888  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   889  * @test GT83-TDATA-008.02 Test for a notification when there is an incoming call on a data line

   890  * @test GT83-TDATA-008.03 Test the ability to cancel the notification of an incoming call on a data line

   891  * @test GT83-TDATA-009.01 Test setting notification of a change in hook status of a data line

   892  * @test GT83-TDATA-009.04 Test the ability to cancel a notification of a change in hook status of a data line

   893  * @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"""

   894  * @test GT83-TDATA-010.04 Test the ability to cancel the notification of a change in the status of the data line

   895  * @test GT83-TDATA-011.01 Test setting notification of a call being added to a data line

   896  * @test GT83-TDATA-011.03 Test the ability to cancel a notification of a call being added to a data line

   897 */

   898 	{

   899 	INFO_PRINTF1(_L("======Start test Test Line Cancels"));

   900     //to make sure that line and call will be closed in leave case

   901 	CleanupStack::PushL(*this) ; ;

   902 

   903 	// Notify Incoming Call

   904 	TName callName;

   905 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

   906 	INFO_PRINTF1(_L("Opening Data Line"));

   907 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

   908 

   909 	iLine.NotifyIncomingCall(iStatus, callName);

   910 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-008.02")) ;

   911 	iLine.NotifyIncomingCallCancel();

   912 	User::WaitForRequest(iStatus);

   913 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-008.03")) ;

   914 

   915 	// Notify Status Change

   916 	RCall::TStatus lineStatus;

   917 	iLine.NotifyStatusChange(iStatus, lineStatus);

   918 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-010.02")) ;

   919 	User::After(KTenPartOfSec); //snack some sleep

   920 	/** @test GT83-AT-026 Test the ability to cancel the notification of a change in the

   921 	 status of the data line	aStatus = KErrCancel provided that the function

   922 	 being cancelled has not already completed */

   923 	iLine.NotifyStatusChangeCancel();

   924 	User::WaitForRequest(iStatus);

   925 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-010.04")) ;

   926 #if 0  //cancel functions don't work yet (?)

   927 	   //any way they are not declared 27.09.2001

   928 	// Notify Mobile Status Change

   929 	RMobileCall::TMobileCallStatus lineStatus2;

   930 	iLine.NotifyMobileLineStatusChange(iStatus, lineStatus2);

   931 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-0")) ;

   932 	iLine.NotifyMobileLineStatusChangeCancel();

   933 	User::WaitForRequest(iStatus);

   934 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-0")) ;

   935 #endif

   936 	// Notify Hook Change

   937 	RCall::THookStatus hookStatus;

   938 	iLine.NotifyHookChange(iStatus, hookStatus);

   939 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-009.01")) ;

   940 	User::After(KTenPartOfSec); //snack some sleep

   941 	// @test GT83-AT-037	Test the ability to cancel a notification of a

   942 	// change in hook status of a data line

   943 	// aStatus = KErrCancel provided that the function being cancelled has not already completed

   944 	iLine.NotifyHookChangeCancel();

   945 	User::WaitForRequest(iStatus);

   946 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-009.04")) ;

   947 

   948 	// Notify Call Added

   949 	iLine.NotifyCallAdded(iStatus, callName);

   950 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TDATA-011.01")) ;

   951 	User::After(KTenPartOfSec); //snack some sleep

   952 	/** GT83-AT-025	Test the ability to cancel a notification of a call being added

   953 	to a data line*/

   954 	iLine.NotifyCallAddedCancel();

   955 	User::WaitForRequest(iStatus);

   956 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TDATA-011.03")) ;

   957 

   958 	// Close the line and call

   959 	CleanupStack::PopAndDestroy() ;

   960 

   961 	INFO_PRINTF1(_L("======End test ====="));

   962 	return TestStepResult() ;

   963 	}

   964 //------------------------------------------------------------------

   965 

   966 CTestCallInfo::CTestCallInfo()

   967 /** Each test step initialises it's own name

   968 */

   969 	{

   970 	// store the name of this test case

   971 	// this is the name that is used by the script file

   972 	SetTestStepName(_L("TestCallInfo"));

   973 	}

   974 //------------------------------------------------------------------

   975 

   976 TVerdict CTestCallInfo::doTestStepL( void )

   977 /**

   978  * This function gets information pertaining to a call:

   979  * Bearer Service Information, Call duration

   980  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

   981  * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on"""

   982  * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line

   983  * @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."

   984  * @test GT83-TDATA-022.01 Test retrieval of the duration of a data call. Display the call duration to screen

   985  * @test GT83-TDATA-023.01 Test the ability to get the current call information of the data call. Display the call information to screen.

   986  * @test GT83-TDATA-025.00 Test answering a call on a data line (Generic)

   987  */

   988 	{

   989 	INFO_PRINTF1(_L("======Start test Test Call Information"));

   990     //to make sure that line and call will be closed in leave case

   991 	CleanupStack::PushL(*this) ; ;

   992 	// Open a Data line and Call

   993 	//GT83-AT-021	Test opening a data line from a phone that supports data functionality

   994 	RMobileCall::TMobileDataCallParamsV1 callDataParams;

   995 	RMobileCall::TMobileDataCallParamsV1Pckg callDataParamsPckg(callDataParams);

   996 

   997 	INFO_PRINTF1(_L("Opening Data Line"));

   998 	TEST_CHECKL(iLine.Open(iPhone, KDataLineName), KErrNone, _L("GT83-TDATA-001.01"));

   999 	INFO_PRINTF1(_L("Opening New Data Call"));

  1000 	TEST_CHECKL(iDataCall.OpenNewCall(iLine), KErrNone, _L("GT83-TDATA-013.06"));

  1001 	//get status

  1002 	//GT83-AT-026	Test retrieval of a data line's current status.

  1003 	RCall::TStatus callStatus;

  1004 	CHECKPOINT(iDataCall.GetStatus(callStatus), KErrNone, _L("GT83-TD-015.02")) ;

  1005 	CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TD-015.02")) ;

  1006 

  1007 	INFO_PRINTF2(_L("Call Status = %d"), callStatus);

  1008 	Print_RCall_TStatus(callStatus) ;

  1009 

  1010 

  1011 	callDataParams.iService = RMobileCall::EServiceDataCircuitAsync;

  1012 	callDataParams.iSpeed = RMobileCall::ESpeed9600;

  1013 	callDataParams.iProtocol = RMobileCall::EProtocolV32;

  1014 	callDataParams.iQoS = RMobileCall::EQoSNonTransparent;

  1015 

  1016 

  1017 	// Wait for an incoming call, then get the Call BearerServiceInfo. The

  1018 	// Bearer Service Info is only available if the call is currently active

  1019 	CConsoleBase* console = Console::NewL(KConsoleTitle,TSize(KConsFullScreen,KConsFullScreen));

  1020     CleanupStack::PushL(console);

  1021 	console->Printf(_L("Please ring the phone\n"));

  1022 

  1023 	// Answer an incoming call initiated by t_echo.exe and obtain the call's current status

  1024 	//GT83-AT-032	Test answering a call on a data line (Generic)	RCall::AnswerIncomingCall

  1025 	iDataCall.AnswerIncomingCall(iStatus, callDataParamsPckg);

  1026 	WaitWithTimeoutL(iStatus,60*KOneSecond);		// but timeout after 60 seconds

  1027 

  1028 	//cancel AnswerIncomingCall if request is still pending

  1029 	if(iStatus.Int() == KRequestPending)

  1030 		{

  1031 		iDataCall.AnswerIncomingCallCancel();

  1032 		User::WaitForRequest(iStatus);

  1033 		}

  1034 	console->Printf(_L("Please stay connected... the test will hang up shortly\n"));

  1035 

  1036 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TDATA-025.00")) ;

  1037 

  1038 	// User Information

  1039 	INFO_PRINTF1(_L("\nThe call is now connected.\nRetrieving Call Information."));

  1040 

  1041 	// Bearer Service Information

  1042 	INFO_PRINTF1(_L("\nGet Bearer Service Info..."));

  1043 	RCall::TBearerService bearerServiceInfo;

  1044 	TInt ret=iDataCall.GetBearerServiceInfo(bearerServiceInfo);

  1045 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-018.01")) ;

  1046 	if (ret==KErrNotSupported)

  1047 		INFO_PRINTF1(_L("Get BearerService Information is NOT Supported"));

  1048 	if (ret==KErrNone)

  1049 		INFO_PRINTF1(_L("Get BearerService Information is successful"));

  1050 

  1051 	// Get Call Information

  1052 	INFO_PRINTF1(_L("\nGet Current Call Info..."));

  1053 	ret=iDataCall.GetInfo(iCallInfo);

  1054 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-023.01")) ;

  1055 	if (ret==KErrNotSupported)

  1056 		{

  1057 		INFO_PRINTF1(_L("Get Current Call info is NOT Supported"));

  1058 		}

  1059 	if (ret==KErrNone)

  1060 		{

  1061 		INFO_PRINTF1(_L("Displaying Information about the Current Call"));

  1062 		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call name: %S")), &iCallInfo.iCallName);

  1063 		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Line name: %S")), &iCallInfo.iLineName);

  1064 		if (iCallInfo.iHookStatus==RCall::EHookStatusOff)

  1065 			{

  1066 			INFO_PRINTF1(_L("Current Hook Status: Off"));

  1067 			}

  1068 		if (iCallInfo.iStatus==RCall::EStatusConnected)

  1069 			{

  1070 			INFO_PRINTF1(_L("Current Call Status: Connected"));

  1071 			}

  1072 		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call Duration: %d seconds")), iCallInfo.iDuration.Int());

  1073 		}

  1074 

  1075 	// Hang up the Call

  1076 	User::After(5*KOneSecond);

  1077 

  1078 	// Call Duration

  1079 	INFO_PRINTF1(_L("Get Call Duration..."));

  1080 	TTimeIntervalSeconds callDuration2;

  1081 	ret=iDataCall.GetCallDuration(callDuration2);

  1082 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("GT83-TDATA-022.01")) ;

  1083 	if (ret==KErrNotSupported)

  1084 		{

  1085 		INFO_PRINTF1(_L("Get Current Call Duration is NOT Supported"));

  1086 		}

  1087 	if (ret==KErrNone)

  1088 		{

  1089 		INFO_PRINTF2(TRefByValue<const TDesC>(_L("Call duration = %d")), callDuration2.Int());

  1090 		}

  1091 

  1092 	iDataCall.HangUp(iStatus);

  1093 	User::WaitForRequest(iStatus);

  1094 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed to Hang Up. If you are using an Ericsson phone, this is a PHONE related problem! ***")) ;

  1095 

  1096 	//This test has some trobles with Ericsson phones

  1097 	//R520m could return KErrGeneral

  1098 	//SH888 could return KErrTimedOut

  1099 	INFO_PRINTF2(_L("iDataCall.HangUp() returned status %d"), iStatus.Int()) ;

  1100 

  1101 	console->Printf(_L("...Disconnected\n"));

  1102 	User::After(10*KOneSecond);

  1103     CleanupStack::PopAndDestroy(console);

  1104 

  1105 	// Close the line and call

  1106 	CleanupStack::PopAndDestroy() ;

  1107 

  1108 	INFO_PRINTF1(_L("======End test ====="));

  1109 	return TestStepResult() ;

  1110 	}

  1111 //------------------------------------------------------------------

  1112 

  1113 CTestCallNotifications::CTestCallNotifications()

  1114 /** Each test step initialises it's own name

  1115 */

  1116 	{

  1117 	// store the name of this test case

  1118 	// this is the name that is used by the script file

  1119 	SetTestStepName(_L("TestCallNotifications"));

  1120 	}

  1121 //------------------------------------------------------------------

  1122 

  1123 TVerdict CTestCallNotifications::doTestStepL( void )

  1124 /**

  1125  * @test GT83-TDATA-001.01 Test opening a data line from a phone that supports data functionality

  1126  * @test GT83-TDATA-002.01 Test retrieval of a data line's capabilities. Display the capabilities to screen

  1127  * @test GT83-TDATA-008.01 Test setting notification of an incoming call on a data line

  1128  * @test GT83-TDATA-009.02 "Test notification of a change in hook status of a data line from ""off"" to ""on"""

  1129  * @test GT83-TDATA-009.03 "Test notification of a change in hook status of a data line from ""on"" to off"""

  1130  * @test GT83-TDATA-013.06 Test opening a new call by specifying the name of a line

  1131  * @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

  1132  * @test GT83-TDATA-015.04 "Test retrieval of the current call status when the call's status is ""ringing"""

  1133  * @test GT83-TDATA-015.05 "Test retrieval of the current call status when the call's status is ""answering"""

  1134  * @test GT83-TDATA-017.02 Test notification of a change in the call's capabilities. Print the call's capabilities to screen