// 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:

// Tests for ETEL 3rd Party Call APIs.

// 

//

/**

 @file

*/

#include "TE_EtelIsvbase.h"

#include "TE_EtelIsvCallFunc.h"

CTestDialNewCall::CTestDialNewCall()

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

}

/**

*

@SYMTestCaseID Etel3rdParty 9.1

@SYMTestCaseDesc Test DialNewCall 3rd party API

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

*/ 

enum TVerdict CTestDialNewCall::doTestStepL()

{

	INFO_PRINTF1(_L("CTestDialNewCall::doTestStepL Start"));

	_LIT(KGoodNumber,"1789");

	SetTestNumber(15); 

	//Set the call parameters for call 1

	CTelephony::TCallParamsV1 callParams1;

	callParams1.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

	TTestCallParams testCallParams1;

	testCallParams1.iLine = CTelephony::EVoiceLine;

	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

	testCallParams1.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams1.iExpStat = KErrNone;

	//Set the call parameters for call 2

	CTelephony::TCallParamsV1 callParams2;

	callParams2.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg2(callParams2);	

	TTestCallParams testCallParams2;

	testCallParams2.iLine = CTelephony::EVoiceLine;

	testCallParams2.iCallParamsV1Pckg = &callParamsPckg2;

	testCallParams2.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams2.iExpStat = KErrNone;

	//Set the call parameters for call 3 - should not successfully make a call

	CTelephony::TCallParamsV1 callParams3;

	callParams3.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg3(callParams3);	

	TTestCallParams testCallParams3;

	testCallParams3.iLine = CTelephony::EVoiceLine;

	testCallParams3.iCallParamsV1Pckg = &callParamsPckg3;

	testCallParams3.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams3.iExpStat = KErrAccessDenied;

	CTelephony::TCallStatusV1 status;

	CTelephony::TCallStatusV1Pckg statusPckg(status);

	// Create active DialNewCallAct objects

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

//

//TEST 1: Test making call on fax & data line.  Should fail

//

	INFO_PRINTF1(_L("Test making call on fax & data line.  Should fail"));

	testCallParams1.iLine = CTelephony::EDataLine;

	testCallParams1.iExpStat = KErrAccessDenied;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

	testCallParams1.iLine = CTelephony::EFaxLine;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();	

//

//TEST 2: Test OOM on Dial

//

#if defined(_DEBUG)

	INFO_PRINTF1(_L("Test OOM on for Dial"));

	testCallParams1.iLine = CTelephony::EVoiceLine;

	testCallParams1.iExpStat = KErrNoMemory;

	testCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;	

	__UHEAP_FAILNEXT(1);	

	// Create a call - should fail	

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

	__UHEAP_RESET;

	__UHEAP_FAILNEXT(2);	 

	// Create a call - should fail

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

	__UHEAP_RESET;

#endif

//

//TEST 3: Create & Hangup a single call

//

	INFO_PRINTF1(_L("Create & Hangup a single call"));

	testCallParams1.iLine = CTelephony::EVoiceLine;

	testCallParams1.iExpStat = KErrNone;		 

	// Create a call - should succeed

	testCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;

	testDialNewCallAct1->TestDialNewCall(testCallParams1, ETrue);

	CActiveScheduler::Start();

	TInt err = iTelephony->GetCallStatus(testCallParams1.iCallId,  statusPckg);

	TEST1(err == KErrNone, ETrue);	

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

	TEST1(testCallParams1.iCallId == CTelephony::EISVCall1, ETrue);

	TEST1(callParams1.iIdRestrict == CTelephony::ESendMyId, ETrue);

	// Create an activeHangupAct object

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

	testCallParams1.iExpStat = KErrNone;

	testHangupAct1->TestHangup(testCallParams1);

	CActiveScheduler::Start();

	err = iTelephony->GetLineStatus(testCallParams1.iLine,  statusPckg);

	TEST1(err == KErrNone, ETrue);

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

//

//TEST 4: Create 2 calls. try and create a third which should fail

//

	INFO_PRINTF1(_L(" Create 2 calls. try and create a third which should fail."));

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

	INFO_PRINTF1(_L(" Create first call."));

	testCallParams1.iExpStat = KErrNone;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

	err = iTelephony->GetCallStatus(testCallParams1.iCallId,  statusPckg);

	TEST1(err == KErrNone, ETrue);	

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

	TEST1(testCallParams1.iCallId == CTelephony::EISVCall1, ETrue);

	// Create 2nd call - should fail as other call is active

	INFO_PRINTF1(_L(" Create first 2nd call - should fail as 1st call active"));

	testCallParams2.iExpStat = KErrGeneral;

	testDialNewCallAct1->TestDialNewCall(testCallParams2);

	CActiveScheduler::Start();

	//put 1st call on hold

	INFO_PRINTF1(_L(" Put 1st call on hold."));

	testCallParams1.iExpStat=KErrNone;

	TestHoldAct->TestHold(testCallParams1);

	CActiveScheduler::Start();	

	err = iTelephony->GetCallStatus(testCallParams1.iCallId,  statusPckg);

	TEST1(err == KErrNone, ETrue);	

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

	// Create 2nd call - should suceed

	INFO_PRINTF1(_L(" Create 2nd call."));

	testCallParams2.iExpStat=KErrNone;

	testDialNewCallAct1->TestDialNewCall(testCallParams2);

	CActiveScheduler::Start();

	// Create a 3rd call - should fail

	INFO_PRINTF1(_L(" Create 3rd call - should fail"));

	testCallParams3.iExpStat = KErrAccessDenied;

	testDialNewCallAct1->TestDialNewCall(testCallParams3);

	CActiveScheduler::Start();			

	//Hangup calls

	INFO_PRINTF1(_L("Hangup 1st call"));

	testCallParams1.iExpStat = KErrNone;

	testHangupAct1->TestHangup(testCallParams1);

	CActiveScheduler::Start();

	err = iTelephony->GetLineStatus(testCallParams1.iLine,  statusPckg);

	TEST1(err == KErrNone, ETrue);

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

	INFO_PRINTF1(_L("Hangup 2nd call"));

	testCallParams1.iExpStat = KErrNone;

	testHangupAct1->TestHangup(testCallParams2);

	CActiveScheduler::Start();

	err = iTelephony->GetLineStatus(testCallParams2.iLine,  statusPckg);

	TEST1(err == KErrNone, ETrue);

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

//

//TEST 5: test cancel

//

	INFO_PRINTF1(_L(" Test dial cancel."));

	TInt cancelerr = iTelephony->CancelAsync(CTelephony::EDialNewCallCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CTestCanceller* canceller = testDialNewCallAct1->RetrieveCanceller();

	canceller->Call();

	CActiveScheduler::Start();	

	TEST1(testDialNewCallAct1->iStatus.Int() == KErrCancel, ETrue);

//

//TEST 6: Test re-dialling after a cancel

//

 	INFO_PRINTF1(_L(" Test dial after a cancel."));

 	err = iTelephony->GetLineStatus(testCallParams1.iLine,  statusPckg);

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

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();	

	err = iTelephony->GetCallStatus(testCallParams1.iCallId,  statusPckg);

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

	//Hangup calls

	INFO_PRINTF1(_L("Hangup call"));

	testCallParams1.iExpStat = KErrNone;

	testHangupAct1->TestHangup(testCallParams1);

	CActiveScheduler::Start();	

	CleanupStack::PopAndDestroy(TestHoldAct);

	CleanupStack::PopAndDestroy(testHangupAct1);

	CleanupStack::PopAndDestroy(testDialNewCallAct1);

	return TestStepResult();	

}

/**

Dial New Call Active Object

**/

CTestDialNewCallAct* CTestDialNewCallAct::NewLC(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, TBool aUseMacros)

//Factory constructor

	{

	CTestDialNewCallAct* obj = new(ELeave) CTestDialNewCallAct(aTestStep, aTelephony, NULL, aUseMacros);

	CleanupStack::PushL(obj);

	obj->ConstructL();

	return obj;

	}

CTestDialNewCallAct* CTestDialNewCallAct::NewL(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent)

//Factory constructor

	{

	CTestDialNewCallAct* obj = new(ELeave) CTestDialNewCallAct(aTestStep, aTelephony, aParent, ETrue);

	CleanupStack::PushL(obj);

	obj->ConstructL();

	CleanupStack::Pop(obj);

	return obj;

	}

CTestDialNewCallAct::CTestDialNewCallAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent, TBool aUseMacros)

    : CEtelIsvActBase(aTestStep, aTelephony)

    , iParent(aParent)

    , iUseMacros(aUseMacros) 

	{  

	}

void CTestDialNewCallAct::ConstructL()

	{    

	iCanceller = new(ELeave) CTestCanceller(this);

	CActiveScheduler::Add(this);

	}

CTestDialNewCallAct::~CTestDialNewCallAct()

	{  

	Cancel();	// if any Req outstanding, calls DoCancel() to cleanup.

	delete iCanceller;

	}

void CTestDialNewCallAct::DoCancel()

	{

	iTelephony->CancelAsync(CTelephony::EDialNewCallCancel);

	}

void CTestDialNewCallAct::TestDialNewCall(TTestCallParams& aTestCallParams, TBool aCheckConcurrency)

	{

 	iTestCallParams = &aTestCallParams;

	// Update the expected return value.

	iExpStat=aTestCallParams.iExpStat;

	TDes8* data;

	if (iTestStep->iBufferMode)

 		{

 		// initialize the buffer first

		iCallParamsBuff = *(reinterpret_cast<CTelephony::TCallParamsV1*> ( const_cast<TUint8*> (aTestCallParams.iCallParamsV1Pckg->Ptr() ) ));

		data = &iCallParamsBuff;   

		}

	else

		{

		data = aTestCallParams.iCallParamsV1Pckg;

		}

	// Make a new call

	iTelephony->DialNewCall(iStatus, *data ,iTestCallParams->iTelAddress.iTelNumber, iTestCallParams->iCallId, iTestCallParams->iLine);

	if(aCheckConcurrency)

		{

		TRequestStatus tmpStatus;

		iTelephony->DialNewCall(tmpStatus, *data ,iTestCallParams->iTelAddress.iTelNumber, iTestCallParams->iCallId, iTestCallParams->iLine);

		User::WaitForRequest(tmpStatus);

		iTestStep->TEST1(tmpStatus.Int() == KErrInUse, ETrue);

		}

	SetActive(); 

	}

void CTestDialNewCallAct::RunL()

	{

	// ActiveScheduler will have set status to KRequestComplete, just before

	// calling this RunL().

	if(iUseMacros)

		{

		iTestStep-> INFO_PRINTF1(_L(" CTestDialNewCallAct::RunL "));

		iTestStep->INFO_PRINTF2(_L("Request Status returned is: %d"), iStatus.Int()   );

		iTestStep->TEST1(iStatus.Int() == iExpStat.Int(), ETrue);

		}

	if(iStatus.Int() == KErrNone)

		{

		if(iUseMacros)

			{

			iTestStep->INFO_PRINTF1(_L(" KErrNone returned") );

			iTestStep->INFO_PRINTF2(_L(" Call ID is %d"), iTestCallParams->iCallId );	

			CTelephony::TCallStatusV1 status;

			CTelephony::TCallStatusV1Pckg statusPckg(status);

			iTelephony->GetCallStatus(iTestCallParams->iCallId,  statusPckg);

			iTestStep->INFO_PRINTF2(_L(" Call status is %d"), status.iStatus );

			}

		}

	else

		{

		if(iUseMacros)

			{

			iTestStep->INFO_PRINTF2(_L("Request Status expected is: %d"), iExpStat.Int()   ); 

			iTestStep->INFO_PRINTF2(_L("Error for dialnewcall: %d"), iStatus.Int() );

			}

		}

	if(!iParent)

		CActiveScheduler::Stop();

	else

		iParent->ActionParent(iStatus.Int(), MActionParent::EDialNewCall);

	}

CTestHangup::CTestHangup()

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

	}

/**

*

@SYMTestCaseID Etel3rdParty 10.1

@SYMTestCaseDesc Test Hangup 3rd party API

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

*/

enum TVerdict CTestHangup::doTestStepL()

	{

	INFO_PRINTF1(_L("CTestHangup::doTestStepL Start"));

	_LIT(KGoodNumber,"1789");

	SetTestNumber(15); 

	//Hangup is been used extensively in other tests.  This test therefore just tests cancelling and trying to 

	//hang-up when a call is not active

	//Set the call parameters

	CTelephony::TCallParamsV1 callParams1;

	callParams1.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

	TTestCallParams testCallParams1;

	testCallParams1.iLine = CTelephony::EVoiceLine;

	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

	testCallParams1.iTelAddress.iTelNumber = KGoodNumber;

	testCallParams1.iExpStat = KErrNone;

 	// Create an active HangupAct object

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

	// Create active DialNewCallAct objects

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

//

//TEST 1: Test Hangup with no active call

//

	//try hanging up when no call active

	testCallParams1.iCallId = CTelephony::EISVCall1;

	testCallParams1.iExpStat = KErrAccessDenied;

	TestHangupAct->TestHangup(testCallParams1);

	CActiveScheduler::Start();

	INFO_PRINTF1(_L(" Create a call."));

	testCallParams1.iExpStat = KErrNone;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

//

//TEST 2: Test OOM on Hangup

//

#if defined(_DEBUG)

	INFO_PRINTF1(_L("Test OOM on for Hangup"));

	testCallParams1.iExpStat = KErrNoMemory;

	__UHEAP_FAILNEXT(1);	

	TestHangupAct->TestHangup(testCallParams1);

	CActiveScheduler::Start();

	__UHEAP_RESET;

#endif

//

//TEST 3: Test make a call and hangup

//

	INFO_PRINTF1(_L("Hangup the call"));

	testCallParams1.iExpStat = KErrNone;

	TestHangupAct->TestHangup(testCallParams1, ETrue);

	CActiveScheduler::Start();

//

//TEST 4: Test Cancel

//

	//make a call first

	INFO_PRINTF1(_L(" Create a call."));

	testCallParams1.iExpStat = KErrNone;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();	

	TInt cancelerr = iTelephony->CancelAsync(CTelephony::EHangupCancel);

	TEST1(cancelerr == KErrNotFound, ETrue);

	TestHangupAct->TestHangup(testCallParams1);

	CTestCanceller* canceller = TestHangupAct->RetrieveCanceller();

	canceller->Call();

	CActiveScheduler::Start();

	TInt result = TestHangupAct->iStatus.Int();

	if(result == KErrCancel)

		{

		//call should still be active

		CTelephony::TCallStatusV1 status;

		CTelephony::TCallStatusV1Pckg statusPckg(status);

		TInt err = iTelephony->GetCallStatus(testCallParams1.iCallId,  statusPckg);

		TEST1(err == KErrNone, ETrue);	

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

		//now hangup properly

		TestHangupAct->TestHangup(testCallParams1);

		CActiveScheduler::Start();

		}

	else if (result == KErrNone)

		{

		INFO_PRINTF1(_L("Test Cancel HangUp call: HangUp completed with KErrNone,"));

		INFO_PRINTF1(_L("KErrCancel expected. Test Inconclusive."));

		SetTestStepResult(EInconclusive);

		}

	else

		{

		SetTestStepResult(EFail);	

		}

	CleanupStack::PopAndDestroy(testDialNewCallAct1);

	CleanupStack::PopAndDestroy(TestHangupAct);

	return TestStepResult();

	}

/**

Hangup Active Object

**/

CTestHangupAct* CTestHangupAct::NewLC(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, TBool aUseMacros)

//Factory constructor

	{

	CTestHangupAct* obj = new(ELeave) CTestHangupAct(aTestStep, aTelephony, NULL, aUseMacros);

	CleanupStack::PushL(obj);

	obj->ConstructL();

	return obj;

	}

CTestHangupAct* CTestHangupAct::NewL(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent)

//Factory constructor

	{

	CTestHangupAct* obj = new(ELeave) CTestHangupAct(aTestStep, aTelephony, aParent, ETrue);

	CleanupStack::PushL(obj);

	obj->ConstructL();

	CleanupStack::Pop();//obj

	return obj;

	}

CTestHangupAct::CTestHangupAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent, TBool aUseMacros)

	: CEtelIsvActBase(aTestStep, aTelephony)	 

	, iParent(aParent)

    , iUseMacros(aUseMacros)

	{  

	}