// Copyright (c) 2003-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:

//

#include "TE_EtelIsvbase.h"

#include "TE_EtelIsvCallFunc.h"

#include "TE_EtelIsvLineInfo.h"

/**

@file

@SYMTestCaseID Etel3rdParty 22.1, TestGetLineStatus

@SYMTestCaseDesc Test GetLineStatus 3rd party API

@SYMFssID SGL.GT0166.054 v1.3 A2_Telephony_Functional_Specification.doc, REQ 2116.2.2

*/ 

CTestGetLineStatus::CTestGetLineStatus(TInt& aCallCount)

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

*/

	: iCallCount(aCallCount)

	{

	// store the name of this test case

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

	SetTestStepName(_L("TestGetLineStatus"));

	}

enum TVerdict CTestGetLineStatus::doTestStepL()

	{

/**

This step tests the CTelephony::GetLineStatus() API

*/

	INFO_PRINTF1(_L("START TEST 22.1"));	

	INFO_PRINTF1(_L("Test retrieving of the mobile line status"));

	_LIT(KGoodNumber,"1789");

	SetTestNumber(15); 

	//Set the call parameters for MO call

	CTelephony::TCallParamsV1 callParams;

	callParams.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg(callParams);	

	TTestCallParams testCallParams;

	testCallParams.iLine = CTelephony::EVoiceLine;

	testCallParams.iCallParamsV1Pckg = &callParamsPckg;

	testCallParams.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams.iExpStat = KErrNone;

	testCallParams.iExpAPIErr = KErrNone;

	CTelephony::TCallStatusV1 statusV1;

	CTelephony::TCallStatusV1Pckg statusV1Pckg(statusV1);

	// set up local data references

	TDes8* statusV1Data;

	if (iBufferMode)

		{

		statusV1Data = &iStatusV1Buff;

		}

	else

		{

		statusV1Data = &statusV1Pckg;

		}

	CTelephony::TCallStatusV1& statusV1Results = reinterpret_cast<CTelephony::TCallStatusV1&> 

    												( const_cast<TUint8&> ( *statusV1Data->Ptr() ));

	//	

	//TEST 1: GetLineStatus with on Data & Fax line.

	//

	testCallParams.iLine = CTelephony::EDataLine;

	TInt err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err==KErrNone, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusIdle, ETrue);

	testCallParams.iLine = CTelephony::EFaxLine;

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	//Fax line not in SIM TSY

	TEST1(err==KErrNotSupported, ETrue);

	//	

	//TEST 2: GetLineStatus with no active call.

	//

	testCallParams.iLine = CTelephony::EVoiceLine;

	//test GetLineStatus with no active call	

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err==testCallParams.iExpAPIErr, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusIdle, ETrue);

	//	

	//TEST 3:Make a call & Hangup a call.  Set a linetstatus notifer going and each time it is invoked call

	//		 GetLineStatus to compare the states which should match.

	//

	//test line status for MO calls

	testCallParams.iExpAPIErr = KErrNone;

	CNotifyLineStatusMOAct* testGetLineStatusMOAct = CNotifyLineStatusMOAct::NewLC(this, iTelephony);	

	testGetLineStatusMOAct->StartTestL(testCallParams, CNotifyLineStatusBaseAct::EGetLineStatus);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(); //testGetLineStatusMOAct

	//

	//TEST 4:Answer a call & Hangup a call.  Set a linestatus notifer going and each time it is invoked call

	//		 GetLineStatus to compare the states which should match.

	//

	//test line status for MT calls

	CNotifyLineStatusMTAct* testGetLineStatusMTAct = CNotifyLineStatusMTAct::NewLC(this, iTelephony, iCallCount);	

	testGetLineStatusMTAct->StartTestL(testCallParams, CNotifyLineStatusBaseAct::EGetLineStatus);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(); //testGetLineStatusMTAct	

//

//TEST 5:Make a call - check the line state.  

//	     Put the call on hold - check the line state. 

//		 Resume the call - check the line state.

//       Hangup the call.- check the line state.

//

	//test state change for calls on hold

	// Create active DialNewCallAct objects

	CTestDialNewCallAct* testDialNewCallAct = CTestDialNewCallAct::NewLC(this, iTelephony);	

	// Create a call - should succeed

	testCallParams.iCallId = CTelephony::EISVMaxNumOfCalls;

	testDialNewCallAct->TestDialNewCall(testCallParams);

	CActiveScheduler::Start();

	//get line status from GetLineStatus API

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err == KErrNone, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusConnected, ETrue);	

	//put call on hold

	CTestHoldAct* TestHoldAct = CTestHoldAct::NewLC(this, iTelephony);

	testCallParams.iExpStat=KErrNone;

	TestHoldAct->TestHold(testCallParams);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(TestHoldAct);//TestHoldAct

	//get line status from GetLineStatus API

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err == KErrNone, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusHold, ETrue);	

	//resume the call

	CTestResumeAct* testResumeAct = CTestResumeAct::NewLC(this, iTelephony);

	testCallParams.iExpStat=KErrNone;

	testResumeAct->TestResume(testCallParams);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(testResumeAct);//testResumeAct

	//get line status from GetLineStatus API

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err == KErrNone, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusConnected, ETrue);	

	// Create an activeHangupAct object

	CTestHangupAct* testHangupAct = CTestHangupAct::NewLC(this, iTelephony);	

	//Hangup call1

	testHangupAct->TestHangup(testCallParams);

	CActiveScheduler::Start();

	err = iTelephony->GetLineStatus(testCallParams.iLine, *statusV1Data);

	TEST1(err == KErrNone, ETrue);

	TEST1(statusV1Results.iStatus==CTelephony::EStatusIdle, ETrue);	

	CleanupStack::PopAndDestroy(testHangupAct);//testHangupAct

	CleanupStack::PopAndDestroy(testDialNewCallAct);//testDialNewCallAct

	return TestStepResult();

	}

CTestGetCallInfo::CTestGetCallInfo()

/** 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("TestGetCallInfo"));

	}

/**

*

@SYMTestCaseID Etel3rdParty 23.1, TestGetCallInfo

@SYMTestCaseDesc Test GetCallInfo 3rd party API

@SYMFssID SGL.GT0166.054 v1.3 A2_Telephony_Functional_Specification.doc, REQ 2116.3.4, REQ 2116.3.9

*/ 

enum TVerdict CTestGetCallInfo::doTestStepL()

	{

/**

This step tests the CTelephony::GetCallInfo() API

*/

	INFO_PRINTF1(_L("Test retrieving of the mobile call status"));

	_LIT(KGoodNumber,"1789");

	SetTestNumber(15); 

	//Set the call parameters for MO call

	CTelephony::TCallParamsV1 callParams;

	callParams.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg(callParams);	

	TTestCallParams testCallParams;

	testCallParams.iLine = CTelephony::EVoiceLine;

	testCallParams.iCallParamsV1Pckg = &callParamsPckg;

	testCallParams.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams.iExpStat = KErrNone;

	//test GetCallInfo with no active call

	CTelephony::TCallInfoV1 callInfoV1;

	CTelephony::TCallInfoV1 expCallInfoV1;

	CTelephony::TCallInfoV1Pckg callInfoV1Pckg(callInfoV1);

	CTelephony::TRemotePartyInfoV1 remoteInfoV1;

	CTelephony::TRemotePartyInfoV1 expRemoteInfoV1;

	CTelephony::TRemotePartyInfoV1Pckg remoteInfoV1Pckg(remoteInfoV1);

	CTelephony::TCallSelectionV1 callSelection;

	CTelephony::TCallSelectionV1Pckg callSelectionV1Pckg(callSelection);

	callSelection.iSelect = CTelephony::EActiveCall;

	callSelection.iLine = CTelephony::EVoiceLine;

	// set up local data references

	TDes8* callInfoV1Data;

	TDes8* remoteInfoV1Data;

	TDes8* callSelectionV1Data;

	if (iBufferMode)

		{

		// initialize required buffers

		iCallSelectionV1Buff = callSelection;

		//initialize data pointers

		callInfoV1Data = &iCallInfoV1Buff;

		remoteInfoV1Data = &iRemoteInfoV1Buff;

		callSelectionV1Data = &iCallSelectionV1Buff;

		}

	else

		{

		callInfoV1Data = &callInfoV1Pckg;

		remoteInfoV1Data = &remoteInfoV1Pckg;

		callSelectionV1Data = &callSelectionV1Pckg;

		}

	CTelephony::TCallInfoV1& callInfoV1Results = reinterpret_cast<CTelephony::TCallInfoV1&> 

													( const_cast<TUint8&> ( *callInfoV1Data->Ptr() ) );

	CTelephony::TRemotePartyInfoV1& remoteInfoV1Results = reinterpret_cast<CTelephony::TRemotePartyInfoV1&> 

													( const_cast<TUint8&> ( *remoteInfoV1Data->Ptr() ) );

	TInt err;

	#if defined(_DEBUG)

	//

	//TEST 1: OOM

	//

		__UHEAP_FAILNEXT(3);

		err = iTelephony->GetCallInfo(callSelectionV1Pckg, callInfoV1Pckg, remoteInfoV1Pckg);

		TEST1(err==KErrNoMemory, ETrue);

		__UHEAP_RESET;

	#endif

	//

	//TEST 2: GetCallInfo with no active call

	//	

	err = iTelephony->GetCallInfo(*callSelectionV1Data, *callInfoV1Data, *remoteInfoV1Data);

	TEST1(err==KErrNotFound, ETrue);

	//

	//TEST 2: GetCallInfo for a single MO call that is put on held and resumed

	//	      This tests EActiveCall and EHeldCall

	//

	// Create active DialNewCallAct object and Hangup object

	CTestDialNewCallAct* testDialNewCallAct = CTestDialNewCallAct::NewLC(this, iTelephony);	

	// Create a call - should succeed

	testCallParams.iCallId = CTelephony::EISVMaxNumOfCalls;

	testDialNewCallAct->TestDialNewCall(testCallParams);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(testDialNewCallAct);

	CTelephony::TCallStatusV1 status;

	CTelephony::TCallStatusV1Pckg statusPckg(status);		

	iTelephony->GetCallStatus(testCallParams.iCallId,  statusPckg);	

	TEST1(status.iStatus == CTelephony::EStatusConnected, ETrue);

	expCallInfoV1.iStatus = CTelephony::EStatusConnected;

	expCallInfoV1.iCallId = CTelephony::EISVCall1;

	expCallInfoV1.iDuration = 0;

	expCallInfoV1.iExitCode = 0;

	expCallInfoV1.iSecurity = CTelephony::ECipheringOff;

	expCallInfoV1.iDialledParty.iTypeOfNumber = CTelephony::EUnknownNumber;

	expCallInfoV1.iDialledParty.iNumberPlan = CTelephony::EUnknownNumberingPlan;

	expRemoteInfoV1.iRemoteIdStatus = CTelephony::ERemoteIdentityUnknown;

	expRemoteInfoV1.iDirection = CTelephony::EDirectionUnknown;

	expRemoteInfoV1.iRemoteNumber.iTypeOfNumber = CTelephony::EUnknownNumber;

	expRemoteInfoV1.iRemoteNumber.iNumberPlan = CTelephony::EUnknownNumberingPlan;

	//check status of active call

	callSelection.iSelect = CTelephony::EActiveCall;

	if (iBufferMode)

		{

		iCallSelectionV1Buff = callSelection;

		}

	err = iTelephony->GetCallInfo(*callSelectionV1Data, *callInfoV1Data, *remoteInfoV1Data);

	TEST1(err==KErrNone, ETrue);

	if(err == KErrNone)

		{

		CNotifyLineStatusBaseAct::PrintGetCallInfo(this, CTelephony::EActiveCall, callInfoV1Results, remoteInfoV1Results);

		TestResults(callInfoV1Results, expCallInfoV1, remoteInfoV1Results, expRemoteInfoV1);

		}

	//check status of held call - should fail

	callSelection.iSelect = CTelephony::EHeldCall;

	if (iBufferMode)

		{

		iCallSelectionV1Buff = callSelection;

		}

	err = iTelephony->GetCallInfo(*callSelectionV1Data, *callInfoV1Data, *remoteInfoV1Data);

	TEST1(err==KErrNotFound, ETrue);

	//check status of in-progress call - should fail

	callSelection.iSelect = CTelephony::EInProgressCall;

	if (iBufferMode)

		{

		iCallSelectionV1Buff = callSelection;

		}	

	err = iTelephony->GetCallInfo(*callSelectionV1Data, *callInfoV1Data, *remoteInfoV1Data);

	TEST1(err==KErrNotFound, ETrue);

	//put call on hold

	CTestHoldAct* TestHoldAct = CTestHoldAct::NewLC(this, iTelephony);

	testCallParams.iExpStat=KErrNone;

	TestHoldAct->TestHold(testCallParams);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(TestHoldAct);//TestHoldAct

	//check status of held call 

	callSelection.iSelect = CTelephony::EHeldCall;

	if (iBufferMode)

		{

		iCallSelectionV1Buff = callSelection;

		}

	expCallInfoV1.iStatus = CTelephony::EStatusHold;

	err = iTelephony->GetCallInfo(*callSelectionV1Data, *callInfoV1Data, *remoteInfoV1Data);

	TEST1(err==KErrNone, ETrue);

	if(err == KErrNone)

		{

		CNotifyLineStatusBaseAct::PrintGetCallInfo(this, CTelephony::EHeldCall, callInfoV1Results, remoteInfoV1Results);

		TestResults(callInfoV1Results, expCallInfoV1, remoteInfoV1Results, expRemoteInfoV1);

		}

	//Hangup call1

	CTestHangupAct* testHangupAct = CTestHangupAct::NewLC(this, iTelephony);	

	testCallParams.iExpStat = KErrNone;

	testHangupAct->TestHangup(testCallParams);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(testHangupAct);

	//

	//TEST 3: Create a single MO call and each time a line state change notification is received call

	//	      GetCallInfo. This tests EInProgressCall

	//

	//test call info for MO calls

	CNotifyLineStatusMOAct* testGetCallInfoMOAct = CNotifyLineStatusMOAct::NewLC(this, iTelephony);	

	testGetCallInfoMOAct->StartTestL(testCallParams, CNotifyLineStatusBaseAct::EGetCallInfo);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(); //testGetCallInfoMOAct

	return TestStepResult();

	}

void CTestGetCallInfo::TestResults(CTelephony::TCallInfoV1& aActualCallInfo, CTelephony::TCallInfoV1& aExpCallInfo, CTelephony::TRemotePartyInfoV1& aActualRemotePartyInfo,  CTelephony::TRemotePartyInfoV1& aExpRemotePartyInfo)

	{

	TEST1(aActualCallInfo.iStatus == aExpCallInfo.iStatus, ETrue);

	TEST1(aActualCallInfo.iDialledParty.iTypeOfNumber == aExpCallInfo.iDialledParty.iTypeOfNumber, ETrue);

	TEST1(aActualCallInfo.iDialledParty.iNumberPlan == aExpCallInfo.iDialledParty.iNumberPlan, ETrue);

	TEST1(aActualCallInfo.iDialledParty.iTelNumber == aExpCallInfo.iDialledParty.iTelNumber, ETrue);

	TEST1(aActualCallInfo.iDuration == aExpCallInfo.iDuration, ETrue);

	TEST1(aActualCallInfo.iExitCode == aExpCallInfo.iExitCode, ETrue);

	TEST1(aActualCallInfo.iSecurity == aExpCallInfo.iSecurity, ETrue);

	TEST1(aActualCallInfo.iCallId == aExpCallInfo.iCallId, ETrue);

	TEST1(aActualRemotePartyInfo.iRemoteIdStatus == aExpRemotePartyInfo.iRemoteIdStatus, ETrue);

	TEST1(aActualRemotePartyInfo.iCallingName == aExpRemotePartyInfo.iCallingName, ETrue);

	TEST1(aActualRemotePartyInfo.iDirection == aExpRemotePartyInfo.iDirection, ETrue);

	TEST1(aActualRemotePartyInfo.iRemoteNumber.iTypeOfNumber == aExpRemotePartyInfo.iRemoteNumber.iTypeOfNumber, ETrue);

	TEST1(aActualRemotePartyInfo.iRemoteNumber.iNumberPlan == aExpRemotePartyInfo.iRemoteNumber.iNumberPlan, ETrue);

	TEST1(aActualRemotePartyInfo.iRemoteNumber.iTelNumber == aExpRemotePartyInfo.iRemoteNumber.iTelNumber, ETrue);	

	}

//

//AO classes used by test steps above

//

CNotifyLineStatusBaseAct::CNotifyLineStatusBaseAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony)

 	: CEtelIsvActBase(aTestStep, aTelephony)

   	, iCallStatusV1Pckg(iCallStatusV1)

   	, iFinish(EFalse)

    {

    }

void CNotifyLineStatusBaseAct::PrintGetCallInfo(CEtelIsvTestStep* aTestStep, CTelephony::TCallSelect aCallSelect, CTelephony::TCallInfoV1& aCallInfoV1, CTelephony::TRemotePartyInfoV1& aRemoteInfoV1)

/**

Print out results for GetCallInfo

*/

	{

	TBuf<150> strBuf;

	if(aCallSelect == CTelephony::EActiveCall)

		strBuf = _L("EActiveCall");

	else if(aCallSelect == CTelephony::EHeldCall)

		strBuf = _L("EHeldCall");

	else // CTelephony::EInProgressCall

		strBuf = _L("EInProgressCall");

	aTestStep->INFO_PRINTF2(_L("For %S GetCallInfo paramters are..."), &strBuf );

	//TCallInfoV1

	strBuf=_L("GetCallInfo TCallInfoV1::iStatus=");

	PrintLineStatus(aTestStep, strBuf, aCallInfoV1.iStatus); 

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TCallInfoV1::iDuration=%d "), aCallInfoV1.iDuration.Int() );

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TCallInfoV1::iExitCode=%d "), aCallInfoV1.iExitCode );

	switch(aCallInfoV1.iSecurity)

		{

	case CTelephony::ECipheringOff:

		strBuf = _L("ECipheringOff");

		break;

	case CTelephony::ECipheringGSM:

		strBuf = _L("ECipheringGSM");

		break;

	case CTelephony::ECipheringWCDMA:

		strBuf = _L("ECipheringWCDMA");

		break;

	default:

		strBuf = _L("UNKNOWN");

		break;

		};

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TCallInfoV1::iSecurity=%S "), &strBuf );

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TCallInfoV1::iCallId=%d "), aCallInfoV1.iCallId );

	switch(aRemoteInfoV1.iRemoteIdStatus)

		{

	case CTelephony::ERemoteIdentityUnknown:

		strBuf = _L("ERemoteIdentityUnknown");

		break;

	case CTelephony::ERemoteIdentityAvailable:

		strBuf = _L("ERemoteIdentityAvailable");

		break;

	case CTelephony::ERemoteIdentitySuppressed:

		strBuf = _L("ERemoteIdentitySuppressed");

		break;

	default:

		strBuf = _L("UNKNOWN");

		break;

		};

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TRemotePartyInfoV1::iRemoteIdStatus=%S "), &strBuf );

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TRemotePartyInfoV1::iCallingName=%S "), &aRemoteInfoV1.iCallingName );

	switch( aRemoteInfoV1.iDirection)

		{

	case CTelephony::EDirectionUnknown:

		strBuf = _L("EDirectionUnknown");

		break;

	case CTelephony::EMobileOriginated:

		strBuf = _L("EMobileOriginated");

		break;

	case CTelephony::EMobileTerminated:

		strBuf = _L("EMobileTerminated");

		break;

	default:

		strBuf = _L("UNKNOWN");

		break;

		};

	aTestStep->INFO_PRINTF2(_L("GetCallInfo TRemotePartyInfoV1::iDirection=%S "), &strBuf );

	}

void CNotifyLineStatusBaseAct::PrintLineStatus(CEtelIsvTestStep* aTestStep, TDes& aLine, const CTelephony::TCallStatus aStatus) 

/**

Print out line status

*/

	{	

	switch(aStatus)

		{

	case CTelephony::EStatusUnknown:

		aLine.Append(_L("EStatusUnknown"));

		break;

	case CTelephony::EStatusIdle:

		aLine.Append(_L("EStatusIdle"));

		break;

	case CTelephony::EStatusDialling:

		aLine.Append(_L("EStatusDialling"));

		break;

	case CTelephony::EStatusRinging:

		aLine.Append(_L("EStaEStatusRinging"));

		break;

	case CTelephony::EStatusAnswering:

		aLine.Append(_L("EStatusAnswering"));

		break;

	case CTelephony::EStatusConnecting: