1 // Copyright (c) 2005-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 the test the Voice functionality of the Basic MM Tsy.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include <etelmm.h>

    23 

    24 #include "TE_Voice.h"

    25 #include "TE_VoiceTestStepBase.h"

    26 

    27 _LIT(KVoiceLineName,"Voice");

    28 _LIT(KConsoleTitle, "TE_Voice Test");

    29 _LIT(KPleaseRingThePhone, "Please ring the phone\n");

    30 

    31 const TInt KTenPartOfSec = 100000 ;

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

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

    34  

    35 //------------------------------------------------------------------

    36 CTestPhoneInfo::CTestPhoneInfo()

    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("TestPhoneInfo"));

    43 	}

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

    45 

    46 enum TVerdict CTestPhoneInfo::doTestStepL()

    47 //void CTestVoice::TestPhoneInfoL()

    48 /**

    49  * This function retrieves a snapshot of the phone's GSM information, gets the

    50  * number of lines associated with the phone as well as information on the line

    51  * and phone. Gets the phone's status and also performs some Cancel Requests.

    52  * @test GT83-TVOICE-037.01	Retrieve phone's multimode capabilities and print them to screen.

    53  */

    54 	{

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

    56     CleanupStack::PushL(console);

    57 	

    58 	_LIT(KStartText, "Phone Information test") ; TEST_START(&KStartText) ;

    59 	console->Printf(_L("Phone Information Test...\n"));

    60 

    61 	// Retrieve a snapshot of the current phone information

    62 	INFO_PRINTF1(_L("Get Phone Info..."));

    63 	console->Printf(_L("Get Phone Info...\n"));

    64 	RPhone::TPhoneInfo phoneInfo;

    65 	RPhone::TCaps phoneCaps;

    66 	TInt ret=iPhone.GetInfo(phoneInfo);

    67 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobilePhone::GetInfo() ***"));

    68 	if (ret==KErrNotSupported)

    69 		{

    70 		INFO_PRINTF1(_L("Get Phone info is NOT Supported"));

    71 		}

    72 	if (ret==KErrNone)

    73 		{

    74 		INFO_PRINTF1(_L("Get Phone Info is successful."));

    75 		TEST_CHECKL(phoneInfo.iDetection, RPhone::EDetectedPresent, _L("GT83-TVOICE-0"));

    76 		TESTCHECKL(phoneInfo.iDetection,RPhone::EDetectedPresent);

    77 		INFO_PRINTF1(_L("Local Modem has been detected."));

    78 		}

    79 

    80 	//test mobile phone caps

    81 	RMobilePhone::TMobilePhoneModeCaps mobileCaps ;

    82 	ret = iPhone.GetMultimodeCaps((TUint32&)mobileCaps);

    83 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobilePhone::GetMultimodeCaps() ***")) ;

    84 	TESTCHECK(ret, KErrNone);

    85 	

    86 	Print_TMobilePhoneModeCaps(mobileCaps);

    87 

    88 	// Number of lines associated with the phone

    89 	TInt lineCount=0;

    90 	TEST_CHECKL(iPhone.EnumerateLines(lineCount), KErrNone, _L("*** Failed RMobilePhone::EnumerateLines() ***"));

    91 	TESTL(lineCount>0);

    92 	TESTCHECKCONDITIONL(lineCount>0);

    93 	for (;lineCount>0; lineCount--)

    94 		{

    95 		ret = iPhone.GetLineInfo(lineCount-1, iLineInfo);

    96 		CHECKPOINT(ret, KErrNone, _L("*** Failed RMobilePhone::GetLineInfo() ***"));

    97 		TESTCHECK(ret, KErrNone);

    98 		INFO_PRINTF4(_L("Line %d (%S) cap flags = 0x%x"),

    99 			lineCount-1, &iLineInfo.iName,iLineInfo.iLineCapsFlags);

   100 		if (iLineInfo.iLineCapsFlags&RLine::KCapsVoice)

   101 			{

   102 			INFO_PRINTF3(_L("Line %d (%S) has voice capability"), lineCount-1, &iLineInfo.iName);

   103 			iLineIndex=lineCount-1;

   104 			break;

   105 			}

   106 		}

   107 	TESTL(lineCount>0);

   108 	TESTCHECKCONDITIONL(lineCount>0);

   109 	// Status of the Phone

   110 	INFO_PRINTF1(_L("Get the Phone's Status..."));

   111 	RPhone::TStatus phoneStatus;

   112 	ret=iPhone.GetStatus(phoneStatus);

   113 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobilePhone::GetStatus() ***"));

   114 	if (ret==KErrNotSupported)

   115 		{

   116 		INFO_PRINTF1(_L("Get Phone Status is NOT Supported"));

   117 		}

   118 	if (ret==KErrNone)

   119 		{

   120 		INFO_PRINTF1(_L("Get Phone Status is successful."));

   121 		TEST_CHECKL(phoneStatus.iMode, RPhone::EModeIdle, _L("GT83-TVOICE-0"));

   122 		TESTCHECKL(phoneStatus.iMode, RPhone::EModeIdle);

   123 		INFO_PRINTF1(_L("The phone is currently Idle"));

   124 		}

   125 

   126 	// Notification Cancel Requests : Modem Detected

   127 	INFO_PRINTF1(_L("Notify Modem Detected Cancel Request..."));

   128 	RPhone::TModemDetection detected;

   129 	iPhone.NotifyModemDetected(iStatus, detected);

   130 	iPhone.NotifyModemDetectedCancel();

   131 	User::WaitForRequest(iStatus);

   132 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrCancel), _L("*** Failed RMobilePhone::NotifyModemDetectedCancel() ***"));

   133 	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Notify Modem Detected Cancel status: %d")), iStatus.Int());

   134 

   135 	// Notification Cancel Requests : Caps Change

   136 	INFO_PRINTF1(_L("Notify Caps Change Cancel Request..."));

   137 	iPhone.NotifyCapsChange(iStatus, phoneCaps);

   138 	iPhone.NotifyCapsChangeCancel();

   139 	User::WaitForRequest(iStatus);

   140 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrCancel), _L("*** Failed RMobilePhone::NotifyCapsChangeCancel() ***"));

   141 	INFO_PRINTF2(TRefByValue<const TDesC>(_L("Notify Caps Change Cancel status: %d")), iStatus.Int());

   142 	TEST_END() ;

   143 

   144 	console->Printf(_L("Finished\n"));

   145 	User::After(10*KOneSecond);

   146    	CleanupStack::PopAndDestroy(console);

   147 

   148 	return TestStepResult();

   149 	}

   150 //------------------------------------------------------------------

   151 

   152 CTestLineStatusIncomingCall::CTestLineStatusIncomingCall()

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

   154 */

   155 	{

   156 	// store the name of this test case

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

   158 	SetTestStepName(_L("TestLineStatusIncomingCall"));

   159 	}

   160 //------------------------------------------------------------------

   161 

   162 enum TVerdict CTestLineStatusIncomingCall::doTestStepL()

   163 //void CTestVoice::TestLineStatusIncomingCallL()

   164 /**	 Tests line status function

   165  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

   166  * @test GT83-TVOICE-004.00 Test retrieval of a voice line's current status (Generic)

   167  * @test GT83-TVOICE-004.02 "Test retrieval of a voice line's current status when the line's status is ""Idle"""

   168  * @test GT83-TVOICE-004.04 "Test retrieval of a voice line's current status when the line's status is ""Ringing"""

   169  * @test GT83-TVOICE-004.07 "Test retrieval of a voice line's current status when the line's status is ""Connected"""

   170  * @test GT83-TVOICE-004.08 "Test retrieval of a voice line's current status when the line's status is ""Hanging up"""

   171  * @test GT83-TVOICE-008.02 Test for a notification when there is an incoming call on a voice line

   172  * @test GT83-TVOICE-015.05 Test opening an existing call from a voice line by specifying the name of the line and the name of an existing call

   173  * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)

   174  * @test GT83-TVOICE-030.00 Test retrieval of a mobile voice line's current status (Generic)

   175  * @test GT83-TVOICE-030.02 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Dialling"""

   176  * @test GT83-TVOICE-030.03 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Ringing"""

   177  * @test GT83-TVOICE-030.06 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""Disconnecting"""

   178  * @test GT83-TVOICE-030.07 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""on hold"""

   179  * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line

   180 */

   181 	{

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

   183 	CleanupStack::PushL(console);

   184 	

   185 	_LIT(KStartText, "Test Line Status") ; TEST_START(&KStartText) ;

   186 	console->Printf(_L("Test Line Status...\n"));

   187 	

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

   189 	CleanupClosePushL(iVoiceCall) ;

   190 	CleanupClosePushL(iLine) ;

   191 

   192 	RCall::TStatus lineStatus;

   193 	TBuf<16> GoodNumber ;

   194 	GetGoodNumber(GoodNumber) ;

   195 	// Open a Voice Line and Call

   196 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

   197 	INFO_PRINTF1(_L("Opening Voice Line"));

   198 	TInt ret = iLine.Open(iPhone,KVoiceLineName);

   199 	TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-001.01"));

   200 	TESTCHECKL(ret,KErrNone);

   201 

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

   203 	ret = iLine.GetStatus(lineStatus);

   204 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***"));

   205 	TESTCHECK(ret, KErrNone);

   206 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;

   207 

   208 	RMobileCall::TMobileCallStatus mobileLineStatus;

   209 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   210 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***"));

   211 	TESTCHECK(ret, KErrNone);

   212 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.01")) ;

   213 

   214 	INFO_PRINTF1(_L("Please ring the phone "));

   215 	console->Printf(KPleaseRingThePhone);

   216 

   217 	TName callName;

   218 	/* @test GT83-AT-024	Test setting notification of an incoming call on a Voice Line */

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

   220 	WaitWithTimeout(iStatus,60*KOneSecond);				// but timeout after 60 seconds

   221 	ret = iStatus.Int();

   222 	CHECKPOINT(ret, KErrNone, _L("GT83-TVOICE-008.02")) ;

   223 	TESTCHECK(ret, KErrNone);

   224 	INFO_PRINTF2(_L("Voice Call name is %S"), &callName);

   225 

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

   227 	ret = iLine.GetStatus(lineStatus);

   228 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***"));

   229 	TESTCHECK(ret, KErrNone);

   230 	CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TVOICE-004.04")) ;

   231 

   232 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   233 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***"));

   234 	TESTCHECK(ret, KErrNone);

   235 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TVOICE-030.003")) ;

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

   237 	console->Printf(_L("Phone is ringing...\n"));

   238 	

   239 	//Test for incoming Voice Call

   240 	TestLineCapabilitiesL();

   241 

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

   243 	*/

   244 	ret = iVoiceCall.OpenExistingCall(iLine, callName);

   245 	TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-015.05 - *** Failed RMobileCall::OpenExistingCall() ***")) ;

   246 	TESTCHECKL(ret, KErrNone);

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

   248 	//GT83-AT-032	Test answering a call on a Voice Line (Generic)	RCall::AnswerIncomingCall

   249 	iVoiceCall.AnswerIncomingCall(iStatus);

   250 	WaitWithTimeout(iStatus,30*KOneSecond);		// but timeout after 2 seconds

   251 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;

   252 	TESTCHECKL(iStatus.Int(), KErrNone);

   253 	ret = iLine.GetStatus(lineStatus);

   254 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   255 	TESTCHECK(ret, KErrNone);

   256 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.04")) ;

   257 

   258 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   259 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   260 	TESTCHECK(ret, KErrNone);

   261 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.03")) ;

   262 	TestLineCapabilitiesL();

   263 

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

   265 	ret = iLine.GetStatus(lineStatus);

   266 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   267 	TESTCHECK(ret, KErrNone);

   268 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.07")) ;

   269 

   270 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   271 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   272 	TESTCHECK(ret, KErrNone);

   273 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.07")) ;

   274 

   275 

   276 	INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));

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

   278 	User::After(10*KOneSecond);

   279 

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

   281 	console->Printf(_L("Hanging Up\n"));

   282 	iVoiceCall.HangUp(iStatus);

   283 

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

   285 	ret = iLine.GetStatus(lineStatus);

   286 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   287 	TESTCHECK(ret, KErrNone);

   288 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-004.08")) ;

   289 

   290 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   291 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   292 	TESTCHECK(ret, KErrNone);

   293 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-034.09")) ;

   294 

   295 	User::WaitForRequest(iStatus);

   296 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;  //???  line 825

   297 	TESTCHECKL(iStatus.Int(), KErrNone);

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

   299 	ret = iLine.GetStatus(lineStatus);

   300 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   301 	TESTCHECK(ret, KErrNone);

   302 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;

   303 

   304 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   305 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   306 	TESTCHECK(ret, KErrNone);

   307 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-030.02")) ;

   308 

   309 	// Close the line and call

   310 	CleanupStack::PopAndDestroy(&iLine) ;

   311 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

   312 

   313 	TEST_END() ;

   314 

   315 	console->Printf(_L("Finished\n"));

   316 	User::After(10*KOneSecond);

   317 	CleanupStack::PopAndDestroy(console);

   318 

   319 	return TestStepResult();

   320 	}

   321 //------------------------------------------------------------------

   322 

   323 

   324 CTestLineStatusOutgoingCall::CTestLineStatusOutgoingCall()

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

   326 */

   327 	{

   328 	// store the name of this test case

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

   330 	SetTestStepName(_L("TestLineStatusOutgoingCall"));

   331 	}

   332 //------------------------------------------------------------------

   333 enum TVerdict CTestLineStatusOutgoingCall::doTestStepL()

   334 //void CTestVoice::TestLineStatusOutgoingCallL()

   335 /**	 Tests line status function

   336  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

   337  * @test GT83-TVOICE-004.00 Test retrieval of a voice line's current status (Generic)

   338  * @test GT83-TVOICE-004.01 "Test retrieval of a voice line's current status when the line's status is ""Unknown"""

   339  * @test GT83-TVOICE-004.02 "Test retrieval of a voice line's current status when the line's status is ""Idle"""

   340  * @test GT83-TVOICE-004.03 "Test retrieval of a voice line's current status when the line's status is ""Dialling"""

   341  * @test GT83-TVOICE-004.07 "Test retrieval of a voice line's current status when the line's status is ""Connected"""

   342  * @test GT83-TVOICE-004.08 "Test retrieval of a voice line's current status when the line's status is ""Hanging up"""

   343  * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"

   344  * @test GT83-TVOICE-030.00 Test retrieval of a mobile voice line's current status (Generic)

   345  * @test GT83-TVOICE-030.07 "Test retrieval of a mobile voice line's current status when there is only one call on the line and it's status is ""on hold"""

   346  * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line

   347 */

   348 	{

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

   350 	CleanupStack::PushL(console);

   351 	

   352 	_LIT(KStartText, "Test Line Status") ; TEST_START(&KStartText) ;

   353 	console->Printf(_L("Test Line Status\n"));

   354 	

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

   356 	CleanupClosePushL(iVoiceCall) ;

   357 	CleanupClosePushL(iLine) ;

   358 

   359 	RCall::TStatus lineStatus;

   360     TName CallName ;

   361 	TBuf<16> GoodNumber ;

   362 	GetGoodNumber(GoodNumber) ;

   363 	// Open a Voice Line and Call

   364 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

   365 	INFO_PRINTF1(_L("Opening Voice Line"));

   366 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("GT83-TVOICE-001.01"));

   367 	

   368 

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

   370 	TInt ret = iLine.GetStatus(lineStatus);

   371 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   372 	TESTCHECK(ret, KErrNone);

   373 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;

   374 

   375 	RMobileCall::TMobileCallStatus mobileLineStatus;

   376 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   377 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   378 	TESTCHECK(ret, KErrNone);

   379 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.01")) ;

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

   381 	*/

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

   383 	TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05"));

   384 	INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);

   385 

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

   387 	iVoiceCall.Dial(iStatus, GoodNumber);

   388 

   389 	//doesn't work for MM.TSY

   390 	ret = iLine.GetStatus(lineStatus);

   391 	CHECKPOINT(ret, KErrNone, _L("GT83-TVOICE-004.00")) ;

   392 	TESTCHECK(ret, KErrNone);

   393 	//TEST_CHECKL(lineStatus, RCall::EStatusDialling, _L("GT83-TVOICE-004.03")) ;

   394 

   395 	WaitWithTimeout(iStatus,60*KOneSecond);				// but timeout after 60 seconds

   396 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Dial() ***")) ;

   397 	TESTCHECKL(iStatus.Int(), KErrNone);

   398 	//Test for outgoing Voice Call

   399 	TestLineCapabilitiesL();

   400 

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

   402 	ret = iLine.GetStatus(lineStatus);

   403 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   404 	TESTCHECK(ret, KErrNone);

   405 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-004.07")) ;

   406 

   407 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   408 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   409 	TESTCHECK(ret, KErrNone);

   410 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-030.07")) ;

   411 

   412 

   413 	INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));

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

   415 	User::After(10*KOneSecond);

   416 

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

   418 	console->Printf(_L("Call connected - listen for 20 seconds...\n"));

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

   420 

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

   422 	iVoiceCall.HangUp(iStatus);

   423 	ret = iLine.GetStatus(lineStatus);

   424 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   425 	TESTCHECK(ret, KErrNone);

   426 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-004.08")) ;

   427 	User::WaitForRequest(iStatus);

   428 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;

   429 	TESTCHECKL(iStatus.Int(), KErrNone);

   430 

   431 	//Test for outgoing Voice Call after hang up

   432 	TestLineCapabilitiesL();

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

   434 	ret = iLine.GetStatus(lineStatus);

   435 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetStatus() ***")) ;

   436 	TESTCHECK(ret, KErrNone);

   437 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-004.02")) ;

   438 

   439 	ret = iLine.GetMobileLineStatus(mobileLineStatus);

   440 	CHECKPOINT(ret, KErrNone, _L("*** Failed RMobileLine::GetMobileLineStatus() ***")) ;

   441 	TESTCHECK(ret, KErrNone);

   442 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-004.01")) ;

   443 

   444 	// Close the line and call

   445 	CleanupStack::PopAndDestroy(&iLine) ;

   446 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

   447 

   448 	TEST_END() ;

   449 

   450 	console->Printf(_L("Finished\n"));

   451 	User::After(10*KOneSecond);

   452    	CleanupStack::PopAndDestroy(console);

   453 

   454 	return TestStepResult();

   455 	}

   456 //------------------------------------------------------------------

   457 

   458 CTestLineInfo::CTestLineInfo()

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

   460 */

   461 	{

   462 	// store the name of this test case

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

   464 	//iTestStepName = _L("TestLineInfo");  //MODIFIIED -Was Incorrect ("TestLineInfoL")

   465 	SetTestStepName(_L("TestLineInfo"));

   466 	}

   467 //------------------------------------------------------------------

   468 

   469 enum TVerdict CTestLineInfo::doTestStepL()

   470 //void CTestVoice::TestLineInfoL()

   471 /**

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

   473  * on the line and call information,

   474  * @test NONE	Test the ability to get the current line information of the Voice Line (Generic)

   475  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

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

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

   478  * @test GT83-TVOICE-012.01 Test the ability to get the current line information of the voice line. Display the line information to screen.

   479  * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"

   480  * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)

   481  * @test GT83-TVOICE-027.02 Test the ability to place an asynchronous request to hang up a voice call

   482  * @test GT83-TVOICE-006.01 "Test enumeration of the number of calls on a voice line, when there is 0 active call."

   483  * @test GT83-TVOICE-006.02 "Test enumeration of the number of calls on a voice line, when there is 1 active call."

   484 */

   485 	{

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

   487     CleanupStack::PushL(console);

   488 	

   489 	_LIT(KStartText, "Test Line Information") ; TEST_START(&KStartText) ;

   490 	TInt lineCount=0;

   491 

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

   493 	CleanupClosePushL(iVoiceCall) ;

   494 	CleanupClosePushL(iLine) ;

   495 

   496 	// Open a Voice Line and Call

   497 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

   498 	INFO_PRINTF1(_L("Opening Voice Line"));

   499 	console->Printf(_L("Opening Voice Line\n"));

   500 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine::Open() ***"));

   501 

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

   503    	console->Printf(_L("Retrieving no. of calls opened from the line..\n"));

   504 	TEST_CHECKL(iLine.EnumerateCall(lineCount), KErrNone, _L("*** Failed RMobileLine::EnumerateCall() ***"));

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

   506 

   507     TName CallName ;

   508 	INFO_PRINTF1(_L("Opening New Voice Call"));

   509 	console->Printf(_L("Opening New Voice Call\n"));

   510 	TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** Failed RMobileCall::OpenNewCall() ***"));

   511 	INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);

   512 

   513 	// Line Information

   514 	RLine::TLineInfo lineInfo;

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

   516 	TESTCHECK(ret, KErrNone);

   517 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetInfo() ***"));

   518 	if (ret==KErrNotSupported)

   519 		{

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

   521 		}

   522 	else

   523 		{

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

   525 		TESTL(lineInfo.iHookStatus ==  RCall::EHookStatusOn) ;

   526 		TESTCHECKL(lineInfo.iHookStatus, RCall::EHookStatusOn);

   527 		TESTL(lineInfo.iStatus == RCall::EStatusIdle) ;

   528 		TESTCHECKL(lineInfo.iStatus, RCall::EHookStatusOn);

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

   530 		}

   531 

   532 	// Hook status information

   533 	INFO_PRINTF1(_L("Retrieving Hook Status..."));

   534 	console->Printf(_L("Retrieving Hook Status...\n"));

   535 	RCall::THookStatus hookStatus;

   536 	ret=iLine.GetHookStatus(hookStatus);

   537 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetHookStatus() ***"));

   538 	if (ret==KErrNotSupported)

   539 		{

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

   541 		}

   542 	else

   543 		{

   544 		TEST_CHECKL(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-005.02")) ;

   545 		TESTCHECKL(hookStatus, RCall::EHookStatusOn);

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

   547 		}

   548 

   549 	INFO_PRINTF1(_L("Please ring the phone "));

   550 	console->Printf(KPleaseRingThePhone);

   551 

   552 	// Answer an incoming call initiated  and obtain the call's current status

   553 	iVoiceCall.AnswerIncomingCall(iStatus);

   554 

   555 	WaitWithTimeout(iStatus,6*KTenSeconds);		// but timeout after 60 seconds

   556 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;

   557 	TESTCHECKL(iStatus.Int(), KErrNone)

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

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

   560 	console->Printf(_L("Retrieving no. of calls opened from the line..\n"));

   561 	TEST_CHECKL(iLine.EnumerateCall(lineCount), KErrNone, _L("GT83-TVOICE-006.02 - *** Failed RMobileLine::EnumerateCall() ***"));

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

   563 

   564 	//doesn't work for MM.TSY

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

   566 	console->Printf(_L("Getting Call info..\n"));

   567 	RLine::TCallInfo callInfo;

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

   569 	//doesn't work for MM.TSY

   570 	CHECKPOINT_EXPR((ret == KErrNotSupported || ret == KErrNone), _L("GT83-TVOICE-007.01 - *** Failed RMobileLine::GetCallInfo() ***"));

   571 	if (ret==KErrNotSupported)

   572 		{

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

   574 		}

   575 	if (ret==KErrNone)

   576 		{

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

   578 		}

   579 

   580 	// Get the line's current hook status

   581 	ret=iLine.GetHookStatus(hookStatus);

   582 	CHECKPOINT_EXPR((ret==KErrNone || ret==KErrNotSupported), _L("*** Failed RMobileLine::GetHookStatus() ***"));

   583 	if (ret==KErrNotSupported)

   584 		{

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

   586 		}

   587 	else

   588 		{

   589 		CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-005.01")) ;

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

   591 		}

   592 

   593 	INFO_PRINTF1(_L("Please stay connected... the test will hang up shortly"));

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

   595 	User::After(KTenSeconds);

   596 

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

   598 	console->Printf(_L("Hanging up\n"));

   599 	iVoiceCall.HangUp(iStatus);

   600 	User::WaitForRequest(iStatus);

   601 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-027.02 - *** Failed RMobileCall::Hangup() ***")) ;

   602 	// Close the line and call

   603 	//GT83-AT-022	Test closing a Voice Line (Generic)	RLine::Close

   604 

   605 	// Close the line and call

   606 	CleanupStack::PopAndDestroy(&iLine) ;

   607 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

   608 

   609 	TEST_END() ;

   610 

   611 	console->Printf(_L("Finished\n"));

   612 	User::After(10*KOneSecond);

   613    	CleanupStack::PopAndDestroy(console);	

   614 

   615 	return TestStepResult();

   616 	}

   617 //------------------------------------------------------------------

   618 

   619 CTestLineNotificationsIncomingCall::CTestLineNotificationsIncomingCall()

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

   621 */

   622 	{

   623 	// store the name of this test case

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

   625 	SetTestStepName(_L("TestLineNotificationsIncomingCall"));

   626 	}

   627 //------------------------------------------------------------------

   628 

   629 enum TVerdict CTestLineNotificationsIncomingCall::doTestStepL()

   630 //void CTestVoice::TestLineNotificationsIncomingCallL()

   631 /** Tests line notifications

   632  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

   633  * @test GT83-TVOICE-008.02 Test for a notification when there is an incoming call on a voice line

   634  * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line

   635  * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""

   636  * @test GT83-TVOICE-009.03 "Test notification of a change in hook status of a voice line from ""on"" to off"""

   637  * @test GT83-TVOICE-010.01 "Test notification of a change in the status of the voice line from ""idle"" to ""ringing"" to ""answering"" to ""connected"" to ""hanging up"" to ""idle""

   638  * @test GT83-TVOICE-011.02 Test notification of a call being added to a voice line that currently has no calls

   639  * @test GT83-TVOICE-015.05 Test opening an existing call from a voice line by specifying the name of the line and the name of an existing call

   640  * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)

   641  * @test GT83-TVOICE-031.01 Test setting a request for a notification of a change in the status of the mobile voice line

   642  * @test GT83-TVOICE-031.07 "Test for a notification of a change in status of the mobile voice line from ""connected"" to ""disconnecting"""

   643  * @test GT83-TVOICE-031.08 "Test for a notification of a change in status of the mobile voice line from ""disconnecting"" to ""idle"""

   644  * @test GT83-TVOICE-031.09 "Test for a notification of a change in status of the mobile voice line from ""idle"" to ""ringing"""

   645  * @test GT83-TVOICE-031.10 "Test for a notification of a change in status of the mobile voice line from ""ringing"" to ""answering"""

   646  * @test GT83-TVOICE-031.11 "Test for a notification of a change in status of the mobile voice line from ""answering"" to ""connected"""

   647 */

   648 	{

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

   650     CleanupStack::PushL(console);

   651 	

   652 	_LIT(KStartText, "Test Line Notifications") ; TEST_START(&KStartText) ;

   653 	console->Printf(_L("Test Line Notifications\n"));

   654 	

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

   656 	CleanupClosePushL(iVoiceCall) ;

   657 	CleanupClosePushL(iLine) ;

   658 

   659 	TBuf<16> GoodNumber ;

   660 	GetGoodNumber(GoodNumber) ;

   661 

   662 	// NotifyIncomingCall and NotifyStatusChange

   663 	TName callName1;

   664 	TName callName2;

   665 	TInt ret = KErrNone;

   666 	RCall::TStatus lineStatus;

   667 	RMobileCall::TMobileCallStatus mobileLineStatus;

   668 	RCall::THookStatus hookStatus;

   669 

   670 

   671 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

   672 	INFO_PRINTF1(_L("Opening Voice Line"));

   673 	console->Printf(_L("Opening Voice Line\n"));

   674 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));

   675 

   676 	INFO_PRINTF1(_L("Please ring the phone "));

   677 	console->Printf(KPleaseRingThePhone);

   678 

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

   680 

   681 	//GT83-AT-026	Test setting notification of a change in the status of the Voice Line

   682 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   683 

   684 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   685 

   686 	//GT83-AT-037	Test setting notification of a change in hook status of a Voice Line	void RLine::NotifyHookChange(TRequestStatus& aStatus, THookStatus& aHookStatus)	Function does not produce any unexpected errors. aStatus = KErrPending

   687 	iLine.NotifyHookChange(iStatus4, hookStatus);

   688 

   689     /* GT83-AT-025	Test notification of a call being added to a Voice Line 	*/

   690 	iLine.NotifyCallAdded(iStatus5, callName2);

   691 

   692 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-008.02")) ;

   693 	CHECKPOINT(iStatus2.Int(), KRequestPending, _L("GT83-TVOICE-010.01")) ;

   694 	CHECKPOINT(iStatus3.Int(), KRequestPending, _L("GT83-TVOICE-031.01")) ;

   695 	CHECKPOINT(iStatus4.Int(), KRequestPending, _L("GT83-TVOICE-009.01")) ;

   696 	CHECKPOINT(iStatus5.Int(), KRequestPending, _L("GT83-TVOICE-0011.01")) ;

   697 

   698 	WaitWithTimeout(iStatus,60*KOneSecond);				// but timeout after 60 seconds

   699 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("GT83-TVOICE-008.02")) ;

   700 

   701     // @test GT83-AT-026	Test notification of a change in the status of the Voice Line

   702 	// from "idle" to "ringing"

   703 	User::WaitForRequest(iStatus2);

   704 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;

   705 	CHECKPOINT(lineStatus, RCall::EStatusRinging, _L("GT83-TVOICE-010.02")) ;

   706 

   707 	User::WaitForRequest(iStatus3);

   708 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.09")) ;

   709 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusRinging, _L("GT83-TVOICE-031.09")) ;

   710 

   711 	/* GT83-AT-025	Test notification of a call being added to a Voice Line

   712 	that currently has no calls*/

   713 	User::WaitForRequest(iStatus5);

   714 	CHECKPOINT(iStatus5.Int(), KErrNone, _L("GT83-TVOICE-011.02")) ;

   715 	CHECKPOINT(callName2 == callName1, 1,  _L("GT83-TVOICE-011.02")) ;

   716 

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

   718 	console->Printf(_L("Phone is ringing... Now answering...\n"));

   719 

   720 	/* @test GT83-AT-026	Test notification of a change in the status of the Voice Line from

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

   722 	 */

   723 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   724 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   725 

   726 	ret = iVoiceCall.OpenExistingCall(iLine, callName1);

   727 	TEST_CHECKL(ret, KErrNone, _L("GT83-TVOICE-015.05")) ;

   728 

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

   730 	//GT83-AT-032	Test answering a call on a Voice Line (Generic)	RCall::AnswerIncomingCall

   731 	iVoiceCall.AnswerIncomingCall(iStatus);

   732     // GT83-AT-026	Test notification of a change in the status of the Voice Line

   733 	// from "ringing" to "answering"

   734 	User::WaitForRequest(iStatus2);

   735 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.01")) ;

   736 	CHECKPOINT(lineStatus, RCall::EStatusAnswering, _L("GT83-TVOICE-010.01")) ;

   737 

   738 	WaitWithTimeout(iStatus,2*KOneSecond);		// but timeout after 2 seconds

   739 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;	  //wrong code -2147483647

   740 

   741 

   742     // @test GT83-AT-026	Test notification of a change in the status of the Voice Line

   743 	// from "answering"	to "connecting"

   744 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   745 	User::WaitForRequest(iStatus2);

   746 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.01")) ;

   747 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-010.01")) ;

   748 

   749 	User::WaitForRequest(iStatus3);

   750 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.10")) ;

   751 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusAnswering, _L("GT83-TVOICE-031.10")) ;

   752 

   753 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   754 	User::WaitForRequest(iStatus3);

   755 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.11")) ;

   756 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-031.11")) ;

   757 

   758 	User::WaitForRequest(iStatus4);

   759 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.02")) ;

   760 	CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-009.02")) ;

   761 

   762 	// now hangup call

   763 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   764 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   765 	iLine.NotifyHookChange(iStatus4, hookStatus);

   766 

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

   768 	console->Printf(_L("Call connected - now hanging up...\n"));

   769 	

   770 	iVoiceCall.HangUp(iStatus);

   771 	User::WaitForRequest(iStatus);

   772 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;

   773 

   774     //GT83-AT-026	Test notification of a change in the status of the Voice Line

   775 	// from "connecting" to "hanging up"

   776 	User::WaitForRequest(iStatus2);

   777 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;

   778 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-010.02")) ;

   779 

   780 	User::WaitForRequest(iStatus3);

   781 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.07")) ;

   782 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-031.07")) ;

   783 

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

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

   786 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   787 	User::WaitForRequest(iStatus2);

   788 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.02")) ;

   789 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-010.02")) ;

   790 

   791 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   792 	User::WaitForRequest(iStatus3);

   793 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.08")) ;

   794 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.08")) ;

   795 

   796 	//!< @test GT83-AT-037	Test notification of a change in hook status of a Voice Line

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

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

   799 	User::WaitForRequest(iStatus4);

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

   801 	CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-009.03")) ;

   802 

   803 	// Close the line and call

   804 	CleanupStack::PopAndDestroy(&iLine) ;

   805 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

   806 

   807 	TEST_END() ;

   808 

   809 	console->Printf(_L("Finished\n"));

   810 	User::After(10*KOneSecond);

   811    	CleanupStack::PopAndDestroy(console);

   812 

   813 	return TestStepResult();

   814 	}

   815 //------------------------------------------------------------------

   816 

   817 CTestLineNotificationsOutgoingCall::CTestLineNotificationsOutgoingCall()

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

   819 */

   820 	{

   821 	// store the name of this test case

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

   823 	SetTestStepName(_L("TestLineNotificationsOutgoingCall"));

   824 	}

   825 //------------------------------------------------------------------

   826 

   827 enum TVerdict CTestLineNotificationsOutgoingCall::doTestStepL()

   828 //void CTestVoice::TestLineNotificationsOutgoingCallL()

   829 /** Tests line notifications

   830  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

   831  * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""

   832  * @test GT83-TVOICE-009.03 "Test notification of a change in hook status of a voice line from ""on"" to off"""

   833  * @test GT83-TVOICE-010.03 "Test notification of a change in the status of the voice line from ""idle"" to ""dialling"" to ""connecting"" to ""connected"" to ""hanging up"" to ""idle""

   834  * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"

   835  * @test GT83-TVOICE-031.02 "Test for a notification of a change in status of the mobile voice line from ""idle"" to ""dialling"""

   836  * @test GT83-TVOICE-031.04 "Test for a notification of a change in status of the mobile voice line from ""connecting"" to ""connected"""

   837  * @test GT83-TVOICE-031.07 "Test for a notification of a change in status of the mobile voice line from ""connected"" to ""disconnecting"""

   838  * @test GT83-TVOICE-031.08 "Test for a notification of a change in status of the mobile voice line from ""disconnecting"" to ""idle"""

   839 */

   840 	{

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

   842     CleanupStack::PushL(console);

   843 	

   844 	_LIT(KStartText, "Test Line Notifications") ; TEST_START(&KStartText) ;

   845 	console->Printf(_L("Test Line Notifications\n"));

   846 	

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

   848 	CleanupClosePushL(iVoiceCall) ;

   849 	CleanupClosePushL(iLine) ;

   850 

   851 	TBuf<16> GoodNumber ;

   852 	GetGoodNumber(GoodNumber) ;

   853 

   854 	// NotifyIncomingCall and NotifyStatusChange

   855 	TName callName1;

   856 	RCall::TStatus lineStatus;

   857 	RMobileCall::TMobileCallStatus mobileLineStatus;

   858 	RCall::THookStatus hookStatus;

   859 

   860 

   861 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

   862 	INFO_PRINTF1(_L("Opening Voice Line"));

   863 	console->Printf(_L("Opening Voice Line\n"));

   864 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));

   865 

   866 	INFO_PRINTF1(_L("Opening New Voice Call"));

   867 	console->Printf(_L("Opening New Voice Call\n"));

   868 	TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, callName1), KErrNone, _L("GT83-TVOICE-014.05"));

   869 	INFO_PRINTF2(_L("Voice Call name is %S"), &callName1);

   870 

   871 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   872 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   873 	iLine.NotifyHookChange(iStatus4, hookStatus);

   874 

   875 	// Now test call status during an outgoing call

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

   877 	console->Printf(_L("Dialling %S....\n"), &GoodNumber);

   878 	iVoiceCall.Dial(iStatus, GoodNumber);

   879 

   880 	User::WaitForRequest(iStatus2);

   881 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;

   882 	CHECKPOINT(lineStatus, RCall::EStatusDialling, _L("GT83-TVOICE-010.03")) ;

   883 

   884 	User::WaitForRequest(iStatus3);

   885 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.02")) ;

   886 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDialling, _L("GT83-TVOICE-031.02")) ;

   887 

   888 	User::WaitForRequest(iStatus4);

   889 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.03")) ;

   890 	CHECKPOINT(hookStatus, RCall::EHookStatusOff, _L("GT83-TVOICE-009.03")) ;

   891 

   892 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   893 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   894 	iLine.NotifyHookChange(iStatus4, hookStatus);

   895 

   896 	User::WaitForRequest(iStatus); //end of dial

   897 	

   898 	User::WaitForRequest(iStatus2);

   899 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;

   900 	CHECKPOINT(lineStatus, RCall::EStatusConnected, _L("GT83-TVOICE-010.03")) ;

   901 

   902 	User::WaitForRequest(iStatus3);

   903 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.04")) ;

   904 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusConnected, _L("GT83-TVOICE-031.04")) ;

   905 

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

   907 	console->Printf(_L("Call connected - hanging up...\n"));

   908 

   909 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   910 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   911 

   912 	User::After(10*KOneSecond);

   913 	iVoiceCall.HangUp(iStatus);

   914 	User::WaitForRequest(iStatus);

   915 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::Hangup() ***")) ;

   916 

   917 	User::WaitForRequest(iStatus2);

   918 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;

   919 	CHECKPOINT(lineStatus, RCall::EStatusHangingUp, _L("GT83-TVOICE-010.03")) ;

   920 

   921 	User::WaitForRequest(iStatus3);

   922 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.07")) ;

   923 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusDisconnecting, _L("GT83-TVOICE-031.07")) ;

   924 

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

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

   927 	 */

   928 	User::WaitForRequest(iStatus4);

   929 	CHECKPOINT(iStatus4.Int(), KErrNone, _L("GT83-TVOICE-009.02")) ;

   930 	CHECKPOINT(hookStatus, RCall::EHookStatusOn, _L("GT83-TVOICE-009.02")) ;

   931 

   932 	iLine.NotifyStatusChange(iStatus2, lineStatus);

   933 	iLine.NotifyMobileLineStatusChange(iStatus3, mobileLineStatus);

   934 

   935 	User::WaitForRequest(iStatus2);

   936 	CHECKPOINT(iStatus2.Int(), KErrNone, _L("GT83-TVOICE-010.03")) ;

   937 	CHECKPOINT(lineStatus, RCall::EStatusIdle, _L("GT83-TVOICE-010.03")) ;

   938 

   939 	User::WaitForRequest(iStatus3);

   940 	CHECKPOINT(iStatus3.Int(), KErrNone, _L("GT83-TVOICE-031.08")) ;

   941 	CHECKPOINT(mobileLineStatus, RMobileCall::EStatusIdle, _L("GT83-TVOICE-031.08")) ;

   942 

   943 	// Using TESTCHECKL

   944 	TESTCHECKL(iStatus.Int(), KErrNone);

   945 	TESTCHECKL(iStatus2.Int(), KErrNone);

   946 	TESTCHECKL(iStatus3.Int(), KErrNone);

   947 	TESTCHECKL(iStatus4.Int(), KErrNone);

   948 	TESTCHECKL(iStatus5.Int(), KErrNone);

   949 	TESTCHECKL(iStatus6.Int(), KErrNone);

   950 	TESTCHECKL(iStatus7.Int(), KErrNone);

   951 	

   952 	// Close the line and call

   953 	CleanupStack::PopAndDestroy(&iLine) ;

   954 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

   955 

   956 	TEST_END() ;

   957 

   958 	console->Printf(_L("Finished\n"));

   959 	User::After(10*KOneSecond);

   960    	CleanupStack::PopAndDestroy(console);

   961 

   962 	return TestStepResult();

   963 	}

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

   965 

   966 CTestLineCancels::CTestLineCancels()

   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 

   973 	SetTestStepName(_L("TestLineCancels"));

   974 	}

   975 //------------------------------------------------------------------

   976 

   977 enum TVerdict CTestLineCancels::doTestStepL()

   978 //void CTestVoice::TestLineCancelsL()

   979 /**

   980  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

   981  * @test GT83-TVOICE-008.01 Test setting notification of an incoming call on a voice line

   982  * @test GT83-TVOICE-008.03 Test the ability to cancel the notification of an incoming call on a voice line

   983  * @test GT83-TVOICE-009.01 Test setting notification of a change in hook status of a voice line

   984  * @test GT83-TVOICE-009.04 Test the ability to cancel a notification of a change in hook status of a voice line

   985  * @test GT83-TVOICE-010.04 Test the ability to cancel the notification of a change in the status of the voice line

   986  * @test GT83-TVOICE-011.01 Test setting notification of a call being added to a voice line

   987  * @test GT83-TVOICE-011.05 Test the ability to cancel a notification of a call being added to a voice line

   988 */

   989 	{

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

   991     CleanupStack::PushL(console);

   992 

   993 	_LIT(KStartText, "Test Line Cancels") ; TEST_START(&KStartText) ;

   994 	console->Printf(_L("Test Line Cancels\n"));

   995 

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

   997 	CleanupClosePushL(iVoiceCall) ;

   998 	CleanupClosePushL(iLine) ;

   999 

  1000 	// Notify Incoming Call

  1001 	TName callName;

  1002 	//GT83-AT-021	Test opening a Voice Line from a phone that supports data functionality

  1003 	INFO_PRINTF1(_L("Opening Voice Line"));

  1004 	console->Printf(_L("Opening Voice Line\n"));

  1005 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));

  1006 

  1007 	iLine.NotifyIncomingCall(iStatus, callName);

  1008 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-008.01")) ;

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

  1010 	iLine.NotifyIncomingCallCancel();

  1011 	User::WaitForRequest(iStatus);

  1012 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-008.03")) ;

  1013 

  1014 	// Notify Status Change

  1015 	RCall::TStatus lineStatus;

  1016 	iLine.NotifyStatusChange(iStatus, lineStatus);

  1017 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-010.02")) ;

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

  1019 	iLine.NotifyStatusChangeCancel();

  1020 	User::WaitForRequest(iStatus);

  1021 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-010.04")) ;

  1022 

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

  1024 	   //any way they are not declared 27.09.2001

  1025 	// Notify Mobile Status Change

  1026 	RMobileCall::TMobileCallStatus lineStatus2;

  1027 	iLine.NotifyMobileLineStatusChange(iStatus, lineStatus2);

  1028 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-0")) ;

  1029 	iLine.NotifyMobileLineStatusChangeCancel();

  1030 	User::WaitForRequest(iStatus);

  1031 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-0")) ;

  1032 #endif

  1033 	// Notify Hook Change

  1034 	RCall::THookStatus hookStatus;

  1035 	iLine.NotifyHookChange(iStatus, hookStatus);

  1036 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-009.01")) ;

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

  1038 	iLine.NotifyHookChangeCancel();

  1039 	User::WaitForRequest(iStatus);

  1040 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-009.04")) ;

  1041 

  1042 	// Notify Call Added

  1043 	iLine.NotifyCallAdded(iStatus, callName);

  1044 	CHECKPOINT(iStatus.Int(), KRequestPending, _L("GT83-TVOICE-011.01")) ;

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

  1046 	iLine.NotifyCallAddedCancel();

  1047 	User::WaitForRequest(iStatus);

  1048 	CHECKPOINT(iStatus.Int(), KErrCancel, _L("GT83-TVOICE-011.05")) ;

  1049 

  1050 	// Close the line and call

  1051 	CleanupStack::PopAndDestroy(&iLine) ;

  1052 	CleanupStack::PopAndDestroy(&iVoiceCall) ;

  1053 

  1054 	TEST_END() ;

  1055 

  1056 	console->Printf(_L("Finished\n"));

  1057 	User::After(10*KOneSecond);

  1058    	CleanupStack::PopAndDestroy(console);

  1059 

  1060 	return TestStepResult();

  1061 	}

  1062 //------------------------------------------------------------------

  1063 

  1064 CTestCallInfo::CTestCallInfo()

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

  1066 */

  1067 	{

  1068 	// store the name of this test case

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

  1070 	SetTestStepName(_L("TestCallInfo"));

  1071 	}

  1072 //------------------------------------------------------------------

  1073 

  1074 enum TVerdict CTestCallInfo::doTestStepL()

  1075 //void CTestVoice::TestCallInfoL()

  1076 /**

  1077  * This function gets information pertaining to a call:

  1078  * Bearer Service Information, Call duration

  1079  * @test GT83-TVOICE-001.01 "Test opening a voice line, specifying the phone that should be used"

  1080  * @test GT83-TVOICE-009.02 "Test notification of a change in hook status of a voice line from ""off"" to ""on"""

  1081  * @test GT83-TVOICE-014.05 "Test opening a new call by specifying the name of a line, and displaying the name of the new call"

  1082  * @test GT83-TVOICE-019.01 "Test retrieval of the bearer service info of a call. Display to screen, all the bearer service information associated with the call."

  1083  * @test GT83-TVOICE-023.01 Test retrieval of the duration of a voice call. Display the call duration to screen

  1084  * @test GT83-TVOICE-024.01 Test the ability to get the current call information of the voice call. Display the call information to screen.

  1085  * @test GT83-TVOICE-026.00 Test answering a call on a voice line (Generic)

  1086  * @test GT83-TVOICE-036.01 Test retreival of the call information and print the call information to screen.

  1087 */

  1088 	{

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

  1090     CleanupStack::PushL(console);

  1091 	

  1092 	_LIT(KStartText, "Test Call Information") ; TEST_START(&KStartText) ;

  1093 	console->Printf(_L("Test Call Information"));

  1094 	

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

  1096 	CleanupClosePushL(iVoiceCall) ;

  1097 	CleanupClosePushL(iLine) ;

  1098 

  1099 	RMobileCall::TMobileCallInfoV1 mobileCallInfo;

  1100 	RMobileCall::TMobileCallInfoV1Pckg mobileCallInfoPckg(mobileCallInfo) ;

  1101 

  1102 	INFO_PRINTF1(_L("Opening Voice Line"));

  1103 	console->Printf(_L("Opening Voice Line\n"));

  1104 	TEST_CHECKL(iLine.Open(iPhone,KVoiceLineName), KErrNone, _L("*** Failed RMobileLine.Open() ***"));

  1105 

  1106 	TName CallName ;

  1107 	INFO_PRINTF1(_L("Opening New Voice Call"));

  1108 	console->Printf(_L("Opening New Voice Call\n"));

  1109 	TEST_CHECKL(iVoiceCall.OpenNewCall(iLine, CallName), KErrNone, _L("GT83-TVOICE-014.05 - *** Failed RMobileCall::OpenNewCall() ***"));

  1110 	INFO_PRINTF2(_L("Voice Call name is %S"), &CallName);

  1111 

  1112 	//get status

  1113 	RCall::TStatus callStatus;

  1114 

  1115 	TInt ret = iVoiceCall.GetStatus(callStatus);

  1116 	CHECKPOINT(ret, KErrNone, _L("GT83-TD-016.02 - *** Failed RMobileCall::iVoiceCall.GetStatus() ***")) ;

  1117 	CHECKPOINT(callStatus, RCall::EStatusIdle, _L("GT83-TD-016.02")) ;

  1118 

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

  1120 	Print_RCall_TStatus(callStatus) ;

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

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

  1123 	INFO_PRINTF1(_L("Please ring the phone "));

  1124 	console->Printf(KPleaseRingThePhone);

  1125 

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

  1127 	//GT83-AT-032	Test answering a call on a Voice Line (Generic)	RCall::AnswerIncomingCall

  1128 	iVoiceCall.AnswerIncomingCall(iStatus);

  1129 	WaitWithTimeout(iStatus,60*KOneSecond);		// but timeout after 60 seconds

  1130 	TEST_CHECKL(iStatus.Int(), KErrNone, _L("*** Failed RMobileCall::AnswerIncomingCall() ***")) ;

  1131 

  1132 	// User Information

  1133 	INFO_PRINTF1(_L("The call is now connected."));

  1134 	console->Printf(_L("The call is now connected.\n"));