--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyutils/etel3rdpartyapi/Test/te_etelIsv/TE_EtelIsvStress.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,523 @@
+// 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()
+	{
+	//
+	// Set the SIMTSY config to be invalid and open CTelephony.
+	//
+	User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory,
+									  KPSSimTsyTestNumber, 999));
+	
+	TRAPD(leaveCode, iTelephony = CTelephony::NewL());
+	TEST1(leaveCode == KErrNotFound, ETrue);
+
+	delete iTelephony;
+	iTelephony = NULL;
+	
+	return TestStepResult();
+	} // CTestFailedOpen::doTestStepL
+
+
+/**
+ *  Simple post-amble that deletes the Active Scheduler.
+ */
+TVerdict CTestFailedOpen::doTestStepPostambleL()
+	{
+	delete iScheduler;
+
+	__UHEAP_MARKEND;
+
+ 	return TestStepResult();
+	} // CTestFailedOpen::doTestStepPostambleL