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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// This program is designed the test the Voice functionality of the Basic MM Tsy.

// 

//

/**

 @file

*/

#include <etelmm.h>

#include "TE_Voice.h"

#include "TE_VoiceTestStepBase.h"

_LIT(KVoiceLineName,"Voice");

_LIT(KConsoleTitle, "TE_Voice Test");

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

const TInt KTenPartOfSec = 100000 ;

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

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

//------------------------------------------------------------------

CTestPhoneInfo::CTestPhoneInfo()

/* Each test step initialises it's own name

*/

	{

	// store the name of this test case

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

	SetTestStepName(_L("TestPhoneInfo"));

	}

//------------------------------------------------------------------

enum TVerdict CTestPhoneInfo::doTestStepL()

//void CTestVoice::TestPhoneInfoL()

/**

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

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

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

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

 */

	{

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

    CleanupStack::PushL(console);

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

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

	// Retrieve a snapshot of the current phone information

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

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

	RPhone::TPhoneInfo phoneInfo;

	RPhone::TCaps phoneCaps;

	TInt ret=iPhone.GetInfo(phoneInfo);

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

	if (ret==KErrNotSupported)

		{

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

		}

	if (ret==KErrNone)

		{

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

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

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

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

		}

	//test mobile phone caps

	RMobilePhone::TMobilePhoneModeCaps mobileCaps ;

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

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

	TESTCHECK(ret, KErrNone);

	Print_TMobilePhoneModeCaps(mobileCaps);

	// Number of lines associated with the phone

	TInt lineCount=0;

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

	TESTL(lineCount>0);

	TESTCHECKCONDITIONL(lineCount>0);

	for (;lineCount>0; lineCount--)

		{

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

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

		TESTCHECK(ret, KErrNone);

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

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

		if (iLineInfo.iLineCapsFlags&RLine::KCapsVoice)

			{

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

			iLineIndex=lineCount-1;

			break;

			}

		}

	TESTL(lineCount>0);

	TESTCHECKCONDITIONL(lineCount>0);

	// Status of the Phone

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

	RPhone::TStatus phoneStatus;

	ret=iPhone.GetStatus(phoneStatus);

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

	if (ret==KErrNotSupported)

		{

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

		}

	if (ret==KErrNone)

		{

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

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

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

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

		}

	// Notification Cancel Requests : Modem Detected

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

	RPhone::TModemDetection detected;

	iPhone.NotifyModemDetected(iStatus, detected);

	iPhone.NotifyModemDetectedCancel();

	User::WaitForRequest(iStatus);

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

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

	// Notification Cancel Requests : Caps Change

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

	iPhone.NotifyCapsChange(iStatus, phoneCaps);

	iPhone.NotifyCapsChangeCancel();

	User::WaitForRequest(iStatus);

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

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

	TEST_END() ;

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

	User::After(10*KOneSecond);

   	CleanupStack::PopAndDestroy(console);

	return TestStepResult();

	}

//------------------------------------------------------------------

CTestLineStatusIncomingCall::CTestLineStatusIncomingCall()

/* Each test step initialises it's own name

*/

	{

	// store the name of this test case

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

	SetTestStepName(_L("TestLineStatusIncomingCall"));

	}

//------------------------------------------------------------------

enum TVerdict CTestLineStatusIncomingCall::doTestStepL()

//void CTestVoice::TestLineStatusIncomingCallL()

/**	 Tests line status function

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

*/

	{

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

	CleanupStack::PushL(console);

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

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

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

	CleanupClosePushL(iVoiceCall) ;

	CleanupClosePushL(iLine) ;

	RCall::TStatus lineStatus;

	TBuf<16> GoodNumber ;

	GetGoodNumber(GoodNumber) ;

	// Open a Voice Line and Call

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

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

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

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

	TESTCHECKL(ret,KErrNone);

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	RMobileCall::TMobileCallStatus mobileLineStatus;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

	console->Printf(KPleaseRingThePhone);

	TName callName;

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

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

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

	ret = iStatus.Int();

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

	TESTCHECK(ret, KErrNone);

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

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

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

	//Test for incoming Voice Call

	TestLineCapabilitiesL();

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

	*/

	ret = iVoiceCall.OpenExistingCall(iLine, callName);

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

	TESTCHECKL(ret, KErrNone);

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

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

	iVoiceCall.AnswerIncomingCall(iStatus);

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

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

	TESTCHECKL(iStatus.Int(), KErrNone);

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	TestLineCapabilitiesL();

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

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

	User::After(10*KOneSecond);

	INFO_PRINTF1(_L("Hanging Up"));

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

	iVoiceCall.HangUp(iStatus);

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	User::WaitForRequest(iStatus);

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

	TESTCHECKL(iStatus.Int(), KErrNone);

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	// Close the line and call

	CleanupStack::PopAndDestroy(&iLine) ;

	CleanupStack::PopAndDestroy(&iVoiceCall) ;

	TEST_END() ;

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

	User::After(10*KOneSecond);

	CleanupStack::PopAndDestroy(console);

	return TestStepResult();

	}

//------------------------------------------------------------------

CTestLineStatusOutgoingCall::CTestLineStatusOutgoingCall()

/* Each test step initialises it's own name

*/

	{

	// store the name of this test case

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

	SetTestStepName(_L("TestLineStatusOutgoingCall"));

	}

//------------------------------------------------------------------

enum TVerdict CTestLineStatusOutgoingCall::doTestStepL()

//void CTestVoice::TestLineStatusOutgoingCallL()

/**	 Tests line status function

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

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

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

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

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

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

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

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

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

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

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

*/

	{

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

	CleanupStack::PushL(console);

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

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

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

	CleanupClosePushL(iVoiceCall) ;

	CleanupClosePushL(iLine) ;

	RCall::TStatus lineStatus;

    TName CallName ;

	TBuf<16> GoodNumber ;

	GetGoodNumber(GoodNumber) ;

	// Open a Voice Line and Call

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

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

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

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

	TInt ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	RMobileCall::TMobileCallStatus mobileLineStatus;

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

	*/

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

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

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

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

	iVoiceCall.Dial(iStatus, GoodNumber);

	//doesn't work for MM.TSY

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

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

	TESTCHECKL(iStatus.Int(), KErrNone);

	//Test for outgoing Voice Call

	TestLineCapabilitiesL();

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

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

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

	User::After(10*KOneSecond);

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

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

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

	INFO_PRINTF1(_L("Hanging up"));

	iVoiceCall.HangUp(iStatus);

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	User::WaitForRequest(iStatus);

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

	TESTCHECKL(iStatus.Int(), KErrNone);

	//Test for outgoing Voice Call after hang up

	TestLineCapabilitiesL();

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

	ret = iLine.GetStatus(lineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	ret = iLine.GetMobileLineStatus(mobileLineStatus);

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

	TESTCHECK(ret, KErrNone);

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

	// Close the line and call

	CleanupStack::PopAndDestroy(&iLine) ;

	CleanupStack::PopAndDestroy(&iVoiceCall) ;

	TEST_END() ;

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

	User::After(10*KOneSecond);

   	CleanupStack::PopAndDestroy(console);

	return TestStepResult();

	}

//------------------------------------------------------------------

CTestLineInfo::CTestLineInfo()

/* Each test step initialises it's own name

*/

	{

	// store the name of this test case

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

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

	SetTestStepName(_L("TestLineInfo"));

	}

//------------------------------------------------------------------

enum TVerdict CTestLineInfo::doTestStepL()

//void CTestVoice::TestLineInfoL()

/**

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

 * on the line and call information,

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

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

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

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

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

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

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

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

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

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

*/

	{

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

    CleanupStack::PushL(console);

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

	TInt lineCount=0;

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

	CleanupClosePushL(iVoiceCall) ;

	CleanupClosePushL(iLine) ;

	// Open a Voice Line and Call

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

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

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

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

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

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

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

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

    TName CallName ;

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

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

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

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

	// Line Information

	RLine::TLineInfo lineInfo;

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

	TESTCHECK(ret, KErrNone);

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

	if (ret==KErrNotSupported)

		{

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

		}

	else

		{

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

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

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

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

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