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

// TE_ETELISVLINEINFO.CPP

// 

//

#include "TE_EtelIsvbase.h"

#include "TE_EtelIsvCallFunc.h"

#include "TE_EtelIsvStress.h"

#include "TE_EtelIsvPhoneSettings.h"

#include "TE_EtelIsvNetworkInfo.h"

/**

*

@SYMTestCaseID Etel3rdParty 27.1, TestStress

@SYMTestCaseDesc Stress Test 3rd party APIs

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

* REQ 2116.4.2, 2116.4.3, 2116.4.3, 2116.4.4, 2116.4.6, 2116.3.2

*/  

CTestStress::CTestStress(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("TestStress"));

	}

enum TVerdict CTestStress::doTestStepL()

	{

/**

This performs some simple stress testing using multiple clients.

*/	

	TTestData testData1;

	TTestData testData2;

	TBuf<100> testbuf1;

	TBuf<100> testbuf2;	

	//

	//Test repeated concurrent calls to GetPhoneId() and GetSignalStrength() from separate clients

	//

	SetTestNumber(35);	

	testData1.iTestStep = this;

	testData1.iApiToTest = EGetPhoneIdAPI;

	testData1.iClientId = 1;

	testData1.iTestSuccess = EFalse;	

	testData1.iRepCount = 4;	

	testData2.iTestStep = this;

	testData2.iApiToTest = EGetSignalStrengthAPI;

	testData2.iClientId = 2;

	testData2.iTestSuccess = EFalse;	

	testData2.iRepCount = 4;

	testbuf1 = _L("Get Phone Id");

	testbuf2 = _L("Get Signal Strength");	

	RunTestL(testData1,testData2,testbuf1, testbuf2);

	//

	//Test repeated concurrent calls to DialNewCall() and GetPhoneId() from separate clients

	//

	testData1.iTestStep = this;

	testData1.iApiToTest = EGetNetworkInfoAPI;

	testData1.iClientId = 1;

	testData1.iTestSuccess = EFalse;	

	testData1.iRepCount = 4;	

	testData2.iTestStep = this;

	testData2.iApiToTest = EDialNewCallAPI;

	testData2.iClientId = 2;

	testData2.iTestSuccess = EFalse;	

	testData2.iRepCount = 4;

	testbuf1 = _L("Get Network Info");

	testbuf2 = _L("Dial New Call");	

	RunTestL(testData1,testData2,testbuf1, testbuf2);

	iMyAsyncOneShot = CMyAsyncOneShot::NewL();

	iMyAsyncOneShot->StartOneShot();

	CActiveScheduler::Start();

	return TestStepResult();

	}

void CTestStress::RunTestL(TTestData& aTestData1, TTestData& aTestData2,const TDes& aTestName1,const TDes& aTestName2)

/**

Launch threads and wait for them to complete.  Check the success status of the result.

*/

	{

	const TInt KStackSize=0x8000;

	const TInt KHeapSize=0x8000;

	const TInt KMaxHeapSize=0x80000;

	_LIT(KClient1ThreadName,"ClientThread1");

	_LIT(KClient2ThreadName,"ClientThread2");

	RThread t1;

	RThread t2;

	TInt res1=t1.Create(KClient1ThreadName,StartThreadFunction,

					    KStackSize,KHeapSize,KMaxHeapSize,&aTestData1);

	TInt res2=t2.Create(KClient2ThreadName,StartThreadFunction,

					    KStackSize,KHeapSize,KMaxHeapSize,&aTestData2);

	TRequestStatus reqStatus1;

	TRequestStatus reqStatus2;

	TBool req1Complete=EFalse;

	TBool req2Complete=EFalse;

	if (res1==KErrNone && res2==KErrNone)

		{

		t1.Resume();

		t2.Resume();

		t1.Logon(reqStatus1);

		t2.Logon(reqStatus2);

		while ( req1Complete==EFalse || req2Complete==EFalse)

			{

			User::WaitForAnyRequest();

			if (reqStatus1 != KRequestPending && req1Complete==EFalse)

				{

				TInt res1=reqStatus1.Int();

				TEST1(res1 == KErrNone,ETrue); 

				TEST1(aTestData1.iTestSuccess != EFalse,ETrue); 

				INFO_PRINTF4(_L("%S ClientId=%d TestSuccess = %d"), &aTestName1, aTestData1.iClientId,  aTestData1.iTestSuccess);

				req1Complete=ETrue;

				}

			if (reqStatus2 != KRequestPending && req2Complete==EFalse)

				{

				TInt res2=reqStatus2.Int();

				TEST1(res2 == KErrNone,ETrue);

				TEST1(aTestData2.iTestSuccess != EFalse,ETrue); 

				INFO_PRINTF4(_L("%S  ClientId=%d TestSuccess = %d"), &aTestName2, aTestData2.iClientId, aTestData2.iTestSuccess);

				req2Complete=ETrue;

				}

			}

		}

	t1.Close();

	t2.Close();

	}

TInt CTestStress::StartThreadFunction(TAny* aThreadData)

/**

Thread has started. Check which API thread function is to be tested and set it going.

*/

	{

	CTrapCleanup* cleanup;

	if ((cleanup=CTrapCleanup::New())==NULL)

		return KErrGeneral;

	CActiveScheduler* activeScheduler=new CActiveScheduler();

	if(activeScheduler==NULL)

		return KErrNoMemory;

	CActiveScheduler::Install(activeScheduler);

	TTestData* testData = static_cast<TTestData*>(aThreadData);

	TInt ret = KErrNone;

	if(testData->iApiToTest == EGetPhoneIdAPI)

		{

		TRAP(ret,GetPhoneIdThreadFunctionL(testData));

		}	

	else if(testData->iApiToTest == EGetSignalStrengthAPI)

		{

		TRAP(ret,GetSignalStrengthThreadFunctionL(testData));	

		}	

	else if(testData->iApiToTest == EDialNewCallAPI	)

		{

		TRAP(ret,MakeCallHangupThreadFunctionL(testData));	

		}

	else if(testData->iApiToTest == EGetNetworkInfoAPI	)

		{

		TRAP(ret,GetCurrentNetworkInfoThreadFunctionL(testData));	

		}

	else

		{

		ret = KErrNotFound;

		}		

	delete activeScheduler;

	delete cleanup;

	return ret;

	}

TInt CTestStress::GetPhoneIdThreadFunctionL(TTestData* aTestData)

/**

Thread function which repeatedly calls GetPhoneId()

*/

	{	

	//Open a new client

	CTelephony* telephony = CTelephony::NewLC();	

	//expected data

	_LIT16(manufacturerid, "PSION");

	_LIT16(modelid, "666");

	_LIT16(serialid, "1234567890");

	CTelephony::TPhoneIdV1 ExpectedPhoneId;

	ExpectedPhoneId.iManufacturer=manufacturerid;

	ExpectedPhoneId.iModel=modelid;

	ExpectedPhoneId.iSerialNumber=serialid;

	TRequestStatus expStat=KErrNone;

	CTelephony::TPhoneIdV1Pckg ExpectedPhoneIdPckg(ExpectedPhoneId);

	CTestGetPhoneIdAct* GetPhoneIdAct = CTestGetPhoneIdAct::NewLC(aTestData->iTestStep, telephony, EFalse);

	for(int i = 0; i < aTestData->iRepCount; i++)

		{

		//start GetPhoneId

		GetPhoneIdAct->GetPhoneId(ExpectedPhoneIdPckg, expStat);

		CActiveScheduler::Start();

		//have to perform the etst oursleves as cannot use test execute macros in threads!!	

		aTestData->iTestSuccess = ETrue;

		if(GetPhoneIdAct->iStatus != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetPhoneIdAct->iPhoneId.iManufacturer != ExpectedPhoneId.iManufacturer)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetPhoneIdAct->iPhoneId.iModel != ExpectedPhoneId.iModel)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetPhoneIdAct->iPhoneId.iSerialNumber != ExpectedPhoneId.iSerialNumber)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(aTestData->iTestSuccess == EFalse)

			{

			break;	//test failed.

			}

		}

	CleanupStack::PopAndDestroy(GetPhoneIdAct); //GetPhoneIdAct

	CleanupStack::PopAndDestroy(telephony); //telephony

	return KErrNone;

	}

TInt CTestStress::GetSignalStrengthThreadFunctionL(TTestData* aTestData)

/**

Thread function which repeatedly calls GetSignalStrength()

*/

	{

	//Open a new client

	CTelephony* telephony = CTelephony::NewLC();	

	//Set expected result values

	TRequestStatus expStat=KErrNone;

	CTelephony::TSignalStrengthV1 ExpSignalStrength;

	ExpSignalStrength.iBar=3;

	ExpSignalStrength.iSignalStrength=-51;

	CTelephony::TSignalStrengthV1Pckg expSignalStrengthPckg(ExpSignalStrength);

	CTestGetSignalStrengthAct* GetSignalStrengthAct = CTestGetSignalStrengthAct::NewLC(aTestData->iTestStep, telephony, EFalse);

	//start get signal strength

	for(int i = 0; i < aTestData->iRepCount; i++)

		{

		GetSignalStrengthAct->GetSignalStrength(expSignalStrengthPckg, expStat);	

		CActiveScheduler::Start();

		aTestData->iTestSuccess = ETrue;

		if(GetSignalStrengthAct->iStatus != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetSignalStrengthAct->iSignalStrength.iBar != ExpSignalStrength.iBar)

			{

			aTestData->iTestSuccess = EFalse;

			}		

		if(GetSignalStrengthAct->iSignalStrength.iSignalStrength != ExpSignalStrength.iSignalStrength)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(aTestData->iTestSuccess == EFalse)

			{

			break;	//test failed.

			}		

		}

	CleanupStack::PopAndDestroy(GetSignalStrengthAct); //GetSignalStrengthAct	

	CleanupStack::PopAndDestroy(telephony); //telephony	

	return KErrNone;

	}

TInt CTestStress::MakeCallHangupThreadFunctionL(TTestData* aTestData)

/**

Thread function which repeatedly initiates a call and hangups

*/

	{	

	_LIT(KGoodNumber,"1789");

	//Open a new client

	CTelephony* telephony = CTelephony::NewLC();	

	//Set the call parameters for call 

	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;

	CTelephony::TCallStatusV1 status;

	CTelephony::TCallStatusV1Pckg statusPckg(status);

	// Create active DialNewCallAct objects

	CTestDialNewCallAct* testDialNewCallAct1 = CTestDialNewCallAct::NewLC(aTestData->iTestStep, telephony, EFalse);

	CTestHangupAct* testHangupAct1 = CTestHangupAct::NewLC(aTestData->iTestStep, telephony, EFalse);

	for(int i = 0; i < aTestData->iRepCount; i++)

		{

		//dial a new call

		testDialNewCallAct1->TestDialNewCall(testCallParams1);

		CActiveScheduler::Start();

		aTestData->iTestSuccess = ETrue;

		if(testDialNewCallAct1->iStatus != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}

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

		if(err != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(status.iStatus != CTelephony::EStatusConnected)

			{

			aTestData->iTestSuccess = EFalse;

			}

		//hangup the call

		testHangupAct1->TestHangup(testCallParams1);

		CActiveScheduler::Start();

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

		if(err != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(status.iStatus != CTelephony::EStatusIdle)

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(aTestData->iTestSuccess == EFalse)

			{

			break;	//test failed.

			}	

		}

	CleanupStack::PopAndDestroy(testHangupAct1);	//testHangupAct1

	CleanupStack::PopAndDestroy(testDialNewCallAct1); //testDialNewCallAct1

	CleanupStack::PopAndDestroy(telephony); //telephony	

	return KErrNone;

	}

TInt CTestStress::GetCurrentNetworkInfoThreadFunctionL(TTestData* aTestData)	

/**

Thread function which repeatedly calls GetCurrentNetworkInfo()

*/

	{

	// Set up the expected value to be the same as that provisioned in 

	// the SIM TSY config.txt file.

	_LIT16(KCountrycode, "ABCD");

	_LIT16(KNetworkid, "Network0");

	// Need to test display tag

	_LIT16(KDisplaytag, "Vodafone");

	_LIT16(KShortname, "Voda");

	_LIT16(KLongname, "Vodafone_UK");

	//Open a new client

	CTelephony* telephony = CTelephony::NewLC();	

	CTelephony::TNetworkInfoV1 ExpectedNetworkInfo;

	ExpectedNetworkInfo.iCountryCode=KCountrycode;

	ExpectedNetworkInfo.iNetworkId=KNetworkid;

	ExpectedNetworkInfo.iDisplayTag=KDisplaytag;

	ExpectedNetworkInfo.iShortName=KShortname;

	ExpectedNetworkInfo.iLongName=KLongname;	

	ExpectedNetworkInfo.iMode=CTelephony::ENetworkModeGsm;

	ExpectedNetworkInfo.iStatus = CTelephony::ENetworkStatusCurrent;

	ExpectedNetworkInfo.iBandInfo=CTelephony::EBandUnknown;

	ExpectedNetworkInfo.iCdmaSID.SetLength(0);

	ExpectedNetworkInfo.iAccess = CTelephony::ENetworkAccessGsm; 

	ExpectedNetworkInfo.iAreaKnown = EFalse;

	ExpectedNetworkInfo.iLocationAreaCode = 0;

	ExpectedNetworkInfo.iCellId = 0;

	TRequestStatus ExpStat=KErrNone;

	// Create an active object and push it onto the clean up stack

	CTestGetCurrentNetworkInfoAct* GetCurrentNetworkInfoAct = CTestGetCurrentNetworkInfoAct::NewLC(aTestData->iTestStep, telephony, EFalse);

	for(int i = 0; i < aTestData->iRepCount; i++)

		{

		GetCurrentNetworkInfoAct->TestGetCurrentNetworkInfo(ExpectedNetworkInfo, ExpStat);

		CActiveScheduler::Start();

		aTestData->iTestSuccess = ETrue;

		if(GetCurrentNetworkInfoAct->iStatus != KErrNone)

			{

			aTestData->iTestSuccess = EFalse;

			}			

		if(GetCurrentNetworkInfoAct->iNetworkInfo.iCountryCode != ExpectedNetworkInfo.iCountryCode )

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetCurrentNetworkInfoAct->iNetworkInfo.iNetworkId != ExpectedNetworkInfo.iNetworkId )

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetCurrentNetworkInfoAct->iNetworkInfo.iDisplayTag != ExpectedNetworkInfo.iDisplayTag )

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetCurrentNetworkInfoAct->iNetworkInfo.iShortName != ExpectedNetworkInfo.iShortName )

			{

			aTestData->iTestSuccess = EFalse;

			}

		if(GetCurrentNetworkInfoAct->iNetworkInfo.iLongName!= ExpectedNetworkInfo.iLongName )

			{

			aTestData->iTestSuccess = EFalse;

			}					

		if(aTestData->iTestSuccess == EFalse)

			{

			break;	//test failed.

			}	

		}	

	CleanupStack::PopAndDestroy(GetCurrentNetworkInfoAct); //GetCurrentNetworkInfoAct

	CleanupStack::PopAndDestroy(telephony); //telephony	

	return KErrNone;

	}

/**

 *  Simple pre-amble that doesn't open CTelephony.

 */

TVerdict CTestFailedOpen::doTestStepPreambleL()

	{

	//

	// Just mark the heap and create an Active Scheduler...

	//

	__UHEAP_MARK;

	iScheduler = new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(iScheduler);

	return TestStepResult();

	} // CTestFailedOpen::doTestStepPreambleL

/**

 *  Test of opening CTelephony without a phone being available.

 */

enum TVerdict CTestFailedOpen::doTestStepL()