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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Tests for ETEL 3rd Party Call APIs.

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include "TE_EtelIsvbase.h"

    23 #include "TE_EtelIsvCallFunc.h"

    24 

    25 

    26 CTestDialNewCall::CTestDialNewCall()

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

    28 */

    29 {

    30 	// store the name of this test case

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

    32 	SetTestStepName(_L("TestDialNewCall"));

    33 }

    34 

    35 /**

    36 *

    37 @SYMTestCaseID Etel3rdParty 9.1

    38 @SYMTestCaseDesc Test DialNewCall 3rd party API

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

    40 */ 

    41 

    42 enum TVerdict CTestDialNewCall::doTestStepL()

    43 {

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

    45 	

    46 	_LIT(KGoodNumber,"1789");

    47 	

    48 	SetTestNumber(15); 

    49 	

    50 	//Set the call parameters for call 1

    51 	CTelephony::TCallParamsV1 callParams1;

    52 	callParams1.iIdRestrict = CTelephony::ESendMyId;

    53 	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

    54 	

    55 	TTestCallParams testCallParams1;

    56 	testCallParams1.iLine = CTelephony::EVoiceLine;

    57 	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

    58 	testCallParams1.iTelAddress.iTelNumber = KGoodNumber;

    59 	testCallParams1.iExpStat = KErrNone;

    60 	

    61 	//Set the call parameters for call 2

    62 	CTelephony::TCallParamsV1 callParams2;

    63 	callParams2.iIdRestrict = CTelephony::ESendMyId;

    64 	CTelephony::TCallParamsV1Pckg callParamsPckg2(callParams2);	

    65 	

    66 	TTestCallParams testCallParams2;

    67 	testCallParams2.iLine = CTelephony::EVoiceLine;

    68 	testCallParams2.iCallParamsV1Pckg = &callParamsPckg2;

    69 	testCallParams2.iTelAddress.iTelNumber = KGoodNumber;

    70 	testCallParams2.iExpStat = KErrNone;

    71 	

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

    73 	CTelephony::TCallParamsV1 callParams3;

    74 	callParams3.iIdRestrict = CTelephony::ESendMyId;

    75 	CTelephony::TCallParamsV1Pckg callParamsPckg3(callParams3);	

    76 	

    77 	TTestCallParams testCallParams3;

    78 	testCallParams3.iLine = CTelephony::EVoiceLine;

    79 	testCallParams3.iCallParamsV1Pckg = &callParamsPckg3;

    80 	testCallParams3.iTelAddress.iTelNumber = KGoodNumber;

    81 	testCallParams3.iExpStat = KErrAccessDenied;

    82 	

    83 	CTelephony::TCallStatusV1 status;

    84 	CTelephony::TCallStatusV1Pckg statusPckg(status);

    85 	

    86 	// Create active DialNewCallAct objects

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

    88 	

    89 //

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

    91 //

    92 	

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

    94 	testCallParams1.iLine = CTelephony::EDataLine;

    95 	testCallParams1.iExpStat = KErrAccessDenied;

    96 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

    97 	CActiveScheduler::Start();

    98 	

    99 	testCallParams1.iLine = CTelephony::EFaxLine;

   100 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   101 	CActiveScheduler::Start();	

   102 	

   103 //

   104 //TEST 2: Test OOM on Dial

   105 //

   106 #if defined(_DEBUG)

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

   108 	testCallParams1.iLine = CTelephony::EVoiceLine;

   109 	testCallParams1.iExpStat = KErrNoMemory;

   110 	testCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;	

   111 	__UHEAP_FAILNEXT(1);	

   112 	// Create a call - should fail	

   113 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   114 	CActiveScheduler::Start();

   115 	__UHEAP_RESET;

   116 	

   117 	__UHEAP_FAILNEXT(2);	 

   118 	// Create a call - should fail

   119 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   120 	CActiveScheduler::Start();

   121 	__UHEAP_RESET;

   122 #endif

   123 //

   124 //TEST 3: Create & Hangup a single call

   125 //

   126 

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

   128 	testCallParams1.iLine = CTelephony::EVoiceLine;

   129 	testCallParams1.iExpStat = KErrNone;		 

   130 	// Create a call - should succeed

   131 	testCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;

   132 	testDialNewCallAct1->TestDialNewCall(testCallParams1, ETrue);

   133 	CActiveScheduler::Start();

   134 			

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

   136 	TEST1(err == KErrNone, ETrue);	

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

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

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

   140 	

   141 	// Create an activeHangupAct object

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

   143 

   144 	testCallParams1.iExpStat = KErrNone;

   145 	testHangupAct1->TestHangup(testCallParams1);

   146 	CActiveScheduler::Start();

   147 	

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

   149 	TEST1(err == KErrNone, ETrue);

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

   151 	

   152 //

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

   154 //

   155 	

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

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

   158 	

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

   160 	testCallParams1.iExpStat = KErrNone;

   161 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   162 	CActiveScheduler::Start();

   163 	

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

   165 	TEST1(err == KErrNone, ETrue);	

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

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

   168 	

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

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

   171 	testCallParams2.iExpStat = KErrGeneral;

   172 	testDialNewCallAct1->TestDialNewCall(testCallParams2);

   173 	CActiveScheduler::Start();

   174 	

   175 	//put 1st call on hold

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

   177 	testCallParams1.iExpStat=KErrNone;

   178 	TestHoldAct->TestHold(testCallParams1);

   179 	CActiveScheduler::Start();	

   180 	

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

   182 	TEST1(err == KErrNone, ETrue);	

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

   184 	

   185 	// Create 2nd call - should suceed

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

   187 	testCallParams2.iExpStat=KErrNone;

   188 	testDialNewCallAct1->TestDialNewCall(testCallParams2);

   189 	CActiveScheduler::Start();

   190 	

   191 	// Create a 3rd call - should fail

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

   193 	testCallParams3.iExpStat = KErrAccessDenied;

   194 	testDialNewCallAct1->TestDialNewCall(testCallParams3);

   195 	CActiveScheduler::Start();			

   196 	

   197 	//Hangup calls

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

   199 	testCallParams1.iExpStat = KErrNone;

   200 	testHangupAct1->TestHangup(testCallParams1);

   201 	CActiveScheduler::Start();

   202 	

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

   204 	TEST1(err == KErrNone, ETrue);

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

   206 	

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

   208 	testCallParams1.iExpStat = KErrNone;

   209 	testHangupAct1->TestHangup(testCallParams2);

   210 	CActiveScheduler::Start();

   211 	

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

   213 	TEST1(err == KErrNone, ETrue);

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

   215 

   216 //

   217 //TEST 5: test cancel

   218 //

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

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

   221 	TEST1(cancelerr == KErrNotFound, ETrue);

   222 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   223 	CTestCanceller* canceller = testDialNewCallAct1->RetrieveCanceller();

   224 	canceller->Call();

   225 	CActiveScheduler::Start();	

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

   227 	

   228 //

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

   230 //

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

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

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

   234 	

   235 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   236 	CActiveScheduler::Start();	

   237 	

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

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

   240 	

   241 	

   242 	//Hangup calls

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

   244 	testCallParams1.iExpStat = KErrNone;

   245 	testHangupAct1->TestHangup(testCallParams1);

   246 	CActiveScheduler::Start();	

   247 	

   248 	CleanupStack::PopAndDestroy(TestHoldAct);

   249 	CleanupStack::PopAndDestroy(testHangupAct1);

   250 	CleanupStack::PopAndDestroy(testDialNewCallAct1);

   251 	

   252 	return TestStepResult();	

   253 }

   254 

   255 /**

   256 Dial New Call Active Object

   257 **/

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

   259 //Factory constructor

   260 	{

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

   262 	CleanupStack::PushL(obj);

   263 	obj->ConstructL();

   264 	return obj;

   265 	}

   266 	

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

   268 //Factory constructor

   269 	{

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

   271 	CleanupStack::PushL(obj);

   272 	obj->ConstructL();

   273 	CleanupStack::Pop(obj);

   274 	return obj;

   275 	}

   276 	

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

   278     : CEtelIsvActBase(aTestStep, aTelephony)

   279     , iParent(aParent)

   280     , iUseMacros(aUseMacros) 

   281 	{  

   282 	}

   283 

   284 void CTestDialNewCallAct::ConstructL()

   285 	{    

   286 	iCanceller = new(ELeave) CTestCanceller(this);

   287 	CActiveScheduler::Add(this);

   288 	}

   289 

   290 CTestDialNewCallAct::~CTestDialNewCallAct()

   291 	{  

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

   293 	delete iCanceller;

   294 	}

   295 

   296 void CTestDialNewCallAct::DoCancel()

   297 	{

   298 	iTelephony->CancelAsync(CTelephony::EDialNewCallCancel);

   299 	}

   300 

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

   302 	{

   303  	iTestCallParams = &aTestCallParams;

   304 

   305 	// Update the expected return value.

   306 	iExpStat=aTestCallParams.iExpStat;

   307 	

   308 	TDes8* data;

   309     

   310 	if (iTestStep->iBufferMode)

   311  		{

   312  		// initialize the buffer first

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

   314 		data = &iCallParamsBuff;   

   315 		}

   316 	else

   317 		{

   318 		data = aTestCallParams.iCallParamsV1Pckg;

   319 		}

   320 

   321         

   322 	// Make a new call

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

   324 	if(aCheckConcurrency)

   325 		{

   326 		TRequestStatus tmpStatus;

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

   328 		User::WaitForRequest(tmpStatus);

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

   330 		}

   331 	SetActive(); 

   332 	}

   333 	

   334 void CTestDialNewCallAct::RunL()

   335 	{

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

   337 	// calling this RunL().

   338 	if(iUseMacros)

   339 		{

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

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

   342 

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

   344 		}

   345 

   346 	if(iStatus.Int() == KErrNone)

   347 		{

   348 		if(iUseMacros)

   349 			{

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

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

   352 

   353 			CTelephony::TCallStatusV1 status;

   354 			CTelephony::TCallStatusV1Pckg statusPckg(status);

   355 

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

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

   358 			}

   359 		}

   360 	else

   361 		{

   362 		if(iUseMacros)

   363 			{

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

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

   366 			}

   367 		}

   368 	if(!iParent)

   369 		CActiveScheduler::Stop();

   370 	else

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

   372 	}

   373 	

   374  

   375 CTestHangup::CTestHangup()

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

   377 */

   378 	{

   379 	// store the name of this test case

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

   381 	SetTestStepName(_L("TestHangup"));

   382 	}

   383 

   384 /**

   385 *

   386 @SYMTestCaseID Etel3rdParty 10.1

   387 @SYMTestCaseDesc Test Hangup 3rd party API

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

   389 */

   390 

   391 enum TVerdict CTestHangup::doTestStepL()

   392 	{

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

   394 	

   395 	_LIT(KGoodNumber,"1789");

   396 	

   397 	SetTestNumber(15); 

   398 	

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

   400 	//hang-up when a call is not active

   401 	

   402 	//Set the call parameters

   403 	CTelephony::TCallParamsV1 callParams1;

   404 	callParams1.iIdRestrict = CTelephony::ESendMyId;

   405 	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

   406 	

   407 	TTestCallParams testCallParams1;

   408 	testCallParams1.iLine = CTelephony::EVoiceLine;

   409 	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

   410 	testCallParams1.iTelAddress.iTelNumber = KGoodNumber;

   411 	testCallParams1.iExpStat = KErrNone;

   412  

   413  	// Create an active HangupAct object

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

   415 	// Create active DialNewCallAct objects

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

   417 	

   418 //

   419 //TEST 1: Test Hangup with no active call

   420 //

   421 

   422 	//try hanging up when no call active

   423 	testCallParams1.iCallId = CTelephony::EISVCall1;

   424 	testCallParams1.iExpStat = KErrAccessDenied;

   425 	TestHangupAct->TestHangup(testCallParams1);

   426 	CActiveScheduler::Start();

   427 	

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

   429 	testCallParams1.iExpStat = KErrNone;

   430 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   431 	CActiveScheduler::Start();

   432 	

   433 //

   434 //TEST 2: Test OOM on Hangup

   435 //

   436 #if defined(_DEBUG)

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

   438 	testCallParams1.iExpStat = KErrNoMemory;

   439 	__UHEAP_FAILNEXT(1);	

   440 	TestHangupAct->TestHangup(testCallParams1);

   441 	CActiveScheduler::Start();

   442 	__UHEAP_RESET;

   443 #endif

   444 //

   445 //TEST 3: Test make a call and hangup

   446 //

   447 	

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

   449 	testCallParams1.iExpStat = KErrNone;

   450 	TestHangupAct->TestHangup(testCallParams1, ETrue);

   451 	CActiveScheduler::Start();

   452 	

   453 //

   454 //TEST 4: Test Cancel

   455 //

   456 

   457 	//make a call first

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

   459 	testCallParams1.iExpStat = KErrNone;

   460 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

   461 	CActiveScheduler::Start();	

   462 	

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

   464 	TEST1(cancelerr == KErrNotFound, ETrue);

   465 	TestHangupAct->TestHangup(testCallParams1);

   466 	CTestCanceller* canceller = TestHangupAct->RetrieveCanceller();

   467 	canceller->Call();

   468 	CActiveScheduler::Start();

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

   470 	

   471 	if(result == KErrCancel)

   472 		{

   473 		//call should still be active

   474 		CTelephony::TCallStatusV1 status;

   475 		CTelephony::TCallStatusV1Pckg statusPckg(status);

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

   477 		TEST1(err == KErrNone, ETrue);	

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

   479 	

   480 		//now hangup properly

   481 		TestHangupAct->TestHangup(testCallParams1);

   482 		CActiveScheduler::Start();

   483 		}

   484 	else if (result == KErrNone)

   485 		{

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

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

   488 		SetTestStepResult(EInconclusive);

   489 		}

   490 	else

   491 		{

   492 		SetTestStepResult(EFail);	

   493 		}

   494  

   495 	CleanupStack::PopAndDestroy(testDialNewCallAct1);

   496 	CleanupStack::PopAndDestroy(TestHangupAct);

   497 	return TestStepResult();

   498 	}

   499 

   500 

   501 /**

   502 Hangup Active Object

   503 **/

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

   505 //Factory constructor

   506 	{

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

   508 	CleanupStack::PushL(obj);

   509 	obj->ConstructL();

   510 	return obj;

   511 	}

   512 	

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

   514 //Factory constructor

   515 	{

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

   517 	CleanupStack::PushL(obj);

   518 	obj->ConstructL();

   519 	CleanupStack::Pop();//obj

   520 	return obj;

   521 	}

   522 	

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

   524 	: CEtelIsvActBase(aTestStep, aTelephony)	 

   525 	, iParent(aParent)

   526     , iUseMacros(aUseMacros)

   527 	{  

   528 	}

   529 

   530 void CTestHangupAct::ConstructL()

   531 	{    

   532 	iCanceller = new(ELeave) CTestCanceller(this);

   533 	CActiveScheduler::Add(this);

   534 	}

   535 

   536 CTestHangupAct::~CTestHangupAct()

   537 	{  

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

   539 	delete iCanceller;

   540 	}

   541 

   542 void CTestHangupAct::DoCancel()

   543 	{

   544 	iTelephony->CancelAsync(CTelephony::EHangupCancel);

   545 	}

   546 

   547 void CTestHangupAct::TestHangup(TTestCallParams& aTestCallParams, TBool aCheckConcurrency) 

   548                

   549 	{

   550  	iTestCallParams = &aTestCallParams;

   551 

   552 	// Update the expected return value.

   553 	iExpStat=iTestCallParams->iExpStat;

   554 

   555 	// Hangup existing call

   556 	iTelephony->Hangup(iStatus, iTestCallParams->iCallId);

   557 	if(aCheckConcurrency)

   558 		{

   559 		TRequestStatus tmpStatus;

   560 		iTelephony->Hangup(tmpStatus, iTestCallParams->iCallId);

   561 		User::WaitForRequest(tmpStatus);

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

   563 		}

   564 	SetActive(); 

   565 	}

   566 	

   567 void CTestHangupAct::RunL()

   568 	{ 

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

   570 	// calling this RunL().

   571 	if(iUseMacros)

   572 		{

   573 		iTestStep-> INFO_PRINTF1(_L(" CTestHangupAct::RunL "));

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

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

   576 		}

   577 	

   578 	if(iStatus.Int() == KErrNone)

   579 		{

   580 		if(iUseMacros)

   581 			{

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

   583 			}

   584 		}

   585 		else

   586 		{

   587 		if(iUseMacros)

   588 			{

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

   590 			}

   591 		}

   592 	if(!iParent)

   593 		CActiveScheduler::Stop();

   594 	else

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

   596 	}

   597 

   598 CTestAnswerIncomingCall::CTestAnswerIncomingCall(TInt& aCallCount)

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

   600 */

   601 : iCallCount(aCallCount)

   602 	{

   603 	// store the name of this test case

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

   605 	SetTestStepName(_L("TestAnswerIncomingCall"));

   606 	}

   607 

   608 /**

   609 *

   610 @SYMTestCaseID Etel3rdParty 11.1

   611 @SYMTestCaseDesc Test AnswerIncomingCall 3rd party API

   612 @SYMFssID SGL.GT0166.054 v1.3 A2_Telephony_Functional_Specification.doc, REQ 2116.3.5, INC074753 

   613 */

   614 enum TVerdict CTestAnswerIncomingCall::doTestStepL()

   615 	{

   616 	INFO_PRINTF1(_L("CTestAnswerIncomingCall::doTestStepL Start"));

   617 	

   618 	SetTestNumber(15); 

   619 	

   620 	_LIT(KGoodNumber,"1789");

   621 	

   622 	//Set the call parameters to receive call 1

   623 	TTestCallParams testCallParams1;

   624 	testCallParams1.iLine = CTelephony::EVoiceLine;

   625 	testCallParams1.iCallParamsV1Pckg = NULL;

   626 	testCallParams1.iExpStat = KErrNone;

   627 	

   628 	//Set the call parameters for MO call 1

   629 	CTelephony::TCallParamsV1 callParams1;

   630 	callParams1.iIdRestrict = CTelephony::ESendMyId;

   631 	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

   632 	

   633 	TTestCallParams testMOCallParams1;

   634 	testMOCallParams1.iLine = CTelephony::EVoiceLine;

   635 	testMOCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

   636 	testMOCallParams1.iTelAddress.iTelNumber = KGoodNumber;

   637 	testMOCallParams1.iExpStat = KErrNone; 

   638 	

   639 	

   640 	//Set the call parameters for MO call 2

   641 	CTelephony::TCallParamsV1 callParams2;

   642 	callParams2.iIdRestrict = CTelephony::ESendMyId;

   643 	CTelephony::TCallParamsV1Pckg callParamsPckg2(callParams2);	

   644 	

   645 	TTestCallParams testMOCallParams2;

   646 	testMOCallParams2.iLine = CTelephony::EVoiceLine;

   647 	testMOCallParams2.iCallParamsV1Pckg = &callParamsPckg2;

   648 	testMOCallParams2.iTelAddress.iTelNumber = KGoodNumber;

   649 	testMOCallParams2.iExpStat = KErrNone; 

   650 	

   651 	// Create an active AnswerIncomingCallAct object

   652 	CTestAnswerIncomingCallAct* testAnswerIncomingCallAct1 = CTestAnswerIncomingCallAct::NewLC(this, iTelephony);

   653 	

   654 //

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

   656 //

   657 	

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

   659 	testCallParams1.iLine = CTelephony::EDataLine;

   660 	testCallParams1.iExpStat = KErrAccessDenied;

   661 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   662 	CActiveScheduler::Start();

   663 	

   664 	testCallParams1.iLine = CTelephony::EFaxLine;

   665 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   666 	CActiveScheduler::Start();	

   667 

   668 //

   669 //TEST 2: Test AnswerIncomingCall with no ringing call

   670 //

   671 	INFO_PRINTF1(_L("Test answering call with no ringing"));

   672 	testCallParams1.iLine = CTelephony::EVoiceLine;

   673 	testCallParams1.iExpStat = KErrAccessDenied;

   674 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   675 	CActiveScheduler::Start();

   676 	

   677 	//initiate callback

   678 	testAnswerIncomingCallAct1->CallMe(iCallCount);

   679 	 

   680 //

   681 //TEST 2: Test OOM on AnswerIncomingCall

   682 //

   683 #if defined(_DEBUG)

   684 	INFO_PRINTF1(_L("Test answering call with OOM"));

   685 	testCallParams1.iExpStat = KErrNoMemory;

   686 	__UHEAP_FAILNEXT(1);

   687 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   688 	CActiveScheduler::Start();

   689 	__UHEAP_RESET;

   690 #endif

   691  	

   692 //

   693 //TEST 3: Test answering call & hanging up on voice line 

   694 //	

   695 	INFO_PRINTF1(_L("Test answering call with hangup"));

   696 

   697 	CTelephony::TCallInfoV1 callInfoV1;

   698 	CTelephony::TCallInfoV1Pckg callInfoV1Pckg(callInfoV1);

   699 	CTelephony::TRemotePartyInfoV1 remoteInfoV1;

   700 	CTelephony::TRemotePartyInfoV1Pckg remoteInfoV1Pckg(remoteInfoV1);

   701 	

   702 	CTelephony::TCallSelectionV1 callSelection;

   703 	CTelephony::TCallSelectionV1Pckg callSelectionV1Pckg(callSelection);

   704 	callSelection.iSelect = CTelephony::EInProgressCall;

   705 	callSelection.iLine = CTelephony::EVoiceLine;

   706 	

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

   708 

   709 	testCallParams1.iExpStat = KErrNone;

   710 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1, ETrue);

   711 	CActiveScheduler::Start();

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

   713 		

   714 	CTelephony::TCallStatusV1 status;

   715 	CTelephony::TCallStatusV1Pckg statusPckg(status);		

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

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

   718 	

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

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

   721 	

   722 	//and hangup

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

   724 	

   725 	testHangupAct1->TestHangup(testCallParams1);

   726 	CActiveScheduler::Start();

   727 	

   728 //

   729 //TEST 4: Test dialling a call & answering a 2nd call

   730 //	

   731 	INFO_PRINTF1(_L("Test dial a call & answering call."));

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

   733 	INFO_PRINTF1(_L("Create a single call"));

   734 	// Create a call - should succeed

   735 	testMOCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;

   736 	testDialNewCallAct1->TestDialNewCall(testMOCallParams1);

   737 	CActiveScheduler::Start();

   738 	

   739 	iTelephony->GetCallStatus(testMOCallParams1.iCallId, statusPckg);

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

   741 	

   742 	//initiate callback

   743 	testAnswerIncomingCallAct1->CallMe(iCallCount);

   744 	

   745 	iTelephony->GetLineStatus(testMOCallParams1.iLine,  statusPckg);

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

   747 	

   748 	//put 1st call on hold

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

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

   751 	testCallParams1.iExpStat=KErrNone;

   752 	TestHoldAct->TestHold(testCallParams1);

   753 	CActiveScheduler::Start();

   754 	CleanupStack::PopAndDestroy(TestHoldAct);

   755 	

   756 	iTelephony->GetCallStatus(testMOCallParams1.iCallId, statusPckg);

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

   758 	

   759 	//answer a call

   760 	testCallParams1.iExpStat = KErrNone;

   761 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   762 	CActiveScheduler::Start();

   763 	

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

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

   766 	

   767 	//try and make a 3rd call - should fail

   768 	testMOCallParams2.iExpStat = KErrAccessDenied;

   769 	testDialNewCallAct1->TestDialNewCall(testMOCallParams2);

   770 	CActiveScheduler::Start();

   771 		

   772 	//Hangup calls

   773 	testCallParams1.iExpStat = KErrNone;

   774 	testHangupAct1->TestHangup(testCallParams1);

   775 	CActiveScheduler::Start();

   776 	

   777 	testHangupAct1->TestHangup(testMOCallParams1);

   778 	CActiveScheduler::Start();	

   779 	

   780 //

   781 //TEST 5: Test Cancel

   782 //

   783 	INFO_PRINTF1(_L("Test answering call cancel"));

   784 	

   785 	//initiate callback

   786 	testAnswerIncomingCallAct1->CallMe(iCallCount);	

   787 	

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

   789 	TEST1(cancelerr == KErrNotFound, ETrue);

   790 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   791 	CTestCanceller* canceller = testAnswerIncomingCallAct1->RetrieveCanceller();

   792 	canceller->Call();

   793 	CActiveScheduler::Start();	

   794 	TEST1(testAnswerIncomingCallAct1->iStatus.Int() == KErrNone, ETrue);

   795 	

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

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

   798 	

   799 	//NOTE: Attempting to Cancel an AnswerIncomingCall fails.  The specs say you can disconnect from

   800 	//an answering state but this is not implemented in the SIM TSY which means the cancel request fails.

   801 	

   802 	//Hangup calls

   803 	testCallParams1.iExpStat = KErrNone;

   804 	testHangupAct1->TestHangup(testCallParams1);

   805 	CActiveScheduler::Start();

   806 	

   807 	

   808 //

   809 //TEST 6: Test Answer call after a cancel

   810 //

   811 	INFO_PRINTF1(_L("Test answering call after a cancel"));

   812 	

   813 	//initiate callback

   814 	testAnswerIncomingCallAct1->CallMe(iCallCount);	

   815 	

   816 	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams1);

   817 	CActiveScheduler::Start();	

   818 	

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

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

   821 	

   822 	//Hangup calls

   823 	testCallParams1.iExpStat = KErrNone;

   824 	testHangupAct1->TestHangup(testCallParams1);

   825 	CActiveScheduler::Start();

   826 

   827 	

   828 //

   829 //TEST 7: Test Answer call when no notification of incoming call received

   830 //

   831 	INFO_PRINTF1(_L("Test answering call when no notification of incoming call received."));

   832  

   833  	SetTestNumber(38);

   834  

   835 	//Set the call parameters for call

   836 	CTelephony::TCallParamsV1 callParams3;

   837 	//callParams1.iIdRestrict = CTelephony::ESendMyId;

   838 	CTelephony::TCallParamsV1Pckg callParamsPckg3(callParams3);	

   839 	

   840 	TTestCallParams testCallParams3;

   841 	testCallParams3.iLine = CTelephony::EVoiceLine;

   842 	testCallParams3.iCallParamsV1Pckg = &callParamsPckg3;

   843 	testCallParams3.iTelAddress.iTelNumber = KGoodNumber;

   844 	testCallParams3.iExpStat = KErrTimedOut; 

   845 

   846 	CTelephony::TCallStatusV1 status2;

   847 	CTelephony::TCallStatusV1Pckg statusPckg2(status2);		

   848 	iTelephony->GetLineStatus(testCallParams3.iLine, statusPckg2);

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

   850  	

   851  	// Initiate callback

   852 	testAnswerIncomingCallAct1->CallMe(iCallCount);

   853 	

   854 	iTelephony->GetLineStatus(testCallParams3.iLine,  statusPckg2);

   855 	TEST1(status2.iStatus == CTelephony::EStatusRinging, ETrue);

   856  	

   857  	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams3);

   858  	CActiveScheduler::Start();

   859 

   860 //

   861 //TEST 8: Test Answer call when notify incoming call completes 

   862 //        when answer incoming call is waiting for it. 

   863 //

   864  	

   865  	// NOTE - This test tries to force the incoming call notification to complete

   866  	// when AnswerIncomingCall is doing its one second wait. The 

   867  	// NotifyIncomingCallPauseDuration in the config file may have to be adjusted to make 

   868  	// sure this happens on your computer.  	

   869  	INFO_PRINTF1(_L("Test answering call when answer incoming call needs to wait for the call name"));

   870 	INFO_PRINTF1(_L("NOTE: This test forces simtsy to delay sending the incoming call notification"));

   871 	INFO_PRINTF1(_L("(which provides the call name) when an incoming call arrives."));

   872 	INFO_PRINTF1(_L("CAnswerIncomingCallAct will wait up to one second it. This test will fail if"));

   873 	INFO_PRINTF1(_L("the computer running this test is running slowly causing the notification to arrive"));

   874 	INFO_PRINTF1(_L("too late."));

   875  	

   876  	SetTestNumber(39);

   877  	

   878  	testCallParams3.iExpStat = KErrNone;

   879  	

   880  	 // Initiate callback

   881 	testAnswerIncomingCallAct1->CallMe(iCallCount);

   882 	

   883 	iTelephony->GetLineStatus(testCallParams3.iLine,  statusPckg2);

   884 	TEST1(status2.iStatus == CTelephony::EStatusRinging, ETrue);

   885  	

   886  	testAnswerIncomingCallAct1->TestAnswerIncomingCall(testCallParams3);

   887  	CActiveScheduler::Start();	

   888  	 

   889 	CleanupStack::PopAndDestroy(testDialNewCallAct1);

   890 	CleanupStack::PopAndDestroy(testHangupAct1); 

   891 	CleanupStack::PopAndDestroy(testAnswerIncomingCallAct1); //testAnswerIncomingCallAct1

   892 	return TestStepResult();	

   893 	}

   894 

   895  

   896 CTestAnswerIncomingCallAct* CTestAnswerIncomingCallAct::NewLC(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony)

   897 //Factory constructor

   898 	{

   899 	CTestAnswerIncomingCallAct* obj = new(ELeave) CTestAnswerIncomingCallAct(aTestStep, aTelephony, NULL);

   900 	CleanupStack::PushL(obj);

   901 	obj->ConstructL();

   902 	return obj;

   903 	}

   904 	

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

   906 //Factory constructor

   907 	{

   908 	CTestAnswerIncomingCallAct* obj = new(ELeave) CTestAnswerIncomingCallAct(aTestStep, aTelephony, aParent);

   909 	CleanupStack::PushL(obj);

   910 	obj->ConstructL();

   911 	CleanupStack::Pop(obj);

   912 	return obj;

   913 	}

   914 		

   915 CTestAnswerIncomingCallAct::CTestAnswerIncomingCallAct(CEtelIsvTestStep* aTestStep, CTelephony* aTelephony, MActionParent* aParent)

   916 	: CEtelIsvActBase(aTestStep, aTelephony)

   917 	, iParent(aParent)	 

   918 	{  

   919 	}

   920 

   921 void CTestAnswerIncomingCallAct::ConstructL()

   922 	{    

   923 	iCanceller = new(ELeave) CTestCanceller(this);

   924 	CActiveScheduler::Add(this);

   925 	}

   926 

   927 CTestAnswerIncomingCallAct::~CTestAnswerIncomingCallAct()

   928 	{  

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

   930 	delete iCanceller;

   931 	}

   932 

   933 void CTestAnswerIncomingCallAct::DoCancel()

   934 	{

   935 	iTelephony->CancelAsync(CTelephony::EAnswerIncomingCallCancel);

   936 	}

   937 

   938 void CTestAnswerIncomingCallAct::TestAnswerIncomingCall(TTestCallParams& aTestCallParams, TBool aCheckConcurrency) 

   939 	{

   940 	// Update the expected return value.

   941 	iTestCallParams = &aTestCallParams;

   942 

   943 	// Update the expected return value.

   944 	iExpStat=aTestCallParams.iExpStat;

   945 

   946 	// Answer incoming call

   947 	iTelephony->AnswerIncomingCall(iStatus, iTestCallParams->iCallId, iTestCallParams->iLine);

   948 	if(aCheckConcurrency)

   949 		{

   950 		TRequestStatus tmpStatus;

   951 		iTelephony->AnswerIncomingCall(tmpStatus, iTestCallParams->iCallId, iTestCallParams->iLine);

   952 		User::WaitForRequest(tmpStatus);

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

   954 		}

   955 	SetActive(); 

   956 	}

   957 	

   958 void CTestAnswerIncomingCallAct::RunL()

   959 	{ 

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

   961 	// calling this RunL().

   962 	iTestStep->INFO_PRINTF1(_L(" CTestAnswerIncomingCallAct::RunL "));

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

   964 	iTestStep->INFO_PRINTF2(_L("Expected Status: %d"), iExpStat.Int());

   965 		

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

   967 	

   968 	if(iStatus.Int() == KErrNone)

   969 		{

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

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

   972 		}

   973 	else

   974 		{

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

   976 		}

   977 

   978 	if(!iParent)

   979 		CActiveScheduler::Stop();

   980 	else

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

   982 	}

   983 

   984 CTestHold::CTestHold()

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

   986 */

   987 {

   988 	// store the name of this test case

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

   990 	SetTestStepName(_L("TestHold"));

   991 }

   992 

   993 /**

   994 *

   995 @SYMTestCaseID Etel3rdParty 12.1

   996 @SYMTestCaseDesc Test Hold 3rd party API

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

   998 */

   999   

  1000 enum TVerdict CTestHold::doTestStepL()

  1001 {

  1002 	INFO_PRINTF1(_L("CTestHold::doTestStepL Start"));

  1003 	

  1004 	_LIT(KCallNumber1,"1789");

  1005 	

  1006 	// Set mapping to config.txt 

  1007 	SetTestNumber(15); 

  1008 	

  1009 	//Set the call parameters for a basic call. 

  1010 	CTelephony::TCallParamsV1 callParams1;

  1011 	callParams1.iIdRestrict = CTelephony::ESendMyId;

  1012 	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

  1013 	

  1014 	TTestCallParams testCallParams1;

  1015 	testCallParams1.iLine = CTelephony::EVoiceLine;

  1016 	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

  1017 	testCallParams1.iTelAddress.iTelNumber = KCallNumber1;

  1018 	testCallParams1.iExpStat = KErrNone; 

  1019 	

  1020 	//

  1021 	//

  1022 	// TEST 1: OOM error case

  1023 	// Make a call. Put the call on hold. 

  1024 	//

  1025 	//

  1026 	

  1027 	INFO_PRINTF1(_L("HOLD TEST 1 Make call.Set OOM condition. Attempt to put call on hold."));

  1028 	

  1029 	// Create an active DialNewCallAct object

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

  1031 	

  1032 	// Create an active TestHoldAct object

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

  1034 	  

  1035 	// Create a call

  1036 	testCallParams1.iExpStat=KErrNone;	

  1037 	testDialNewCallAct1->TestDialNewCall(testCallParams1);

  1038 	CActiveScheduler::Start();

  1039 	

  1040 	//while call is active test OOM before first hold call

  1041 	#if defined(_DEBUG)

  1042 	INFO_PRINTF1(_L("Test OOM on for Hold"));

  1043 	testCallParams1.iExpStat = KErrNoMemory;

  1044 	__UHEAP_FAILNEXT(1);	

  1045 	TestHoldAct->TestHold(testCallParams1);

  1046 	CActiveScheduler::Start(); 

  1047 	__UHEAP_RESET;

  1048 	#endif

  1049 	

  1050 	INFO_PRINTF1(_L("END TEST 1"));

  1051 

  1052 	//

  1053 	//

  1054 	// TEST 2: Normal case

  1055 	// Make a call. Put the call on hold. 

  1056 	//

  1057 	//

  1058 

  1059 	INFO_PRINTF1(_L("HOLD TEST 2 Call active. Hold call. "));

  1060 	

  1061 	// Put the call on hold.

  1062 	// by calling the ETEL 3rd party API

  1063 	  

  1064 	testCallParams1.iExpStat=KErrNone;

  1065 	TestHoldAct->TestHold(testCallParams1, ETrue);

  1066 	CActiveScheduler::Start();

  1067 		 

  1068  

  1069 	// Check that the call is now at held status.

  1070 	CTelephony::TCallStatusV1 CallStatusV1;

  1071 	CTelephony::TCallStatusV1Pckg CallStatusPckg(CallStatusV1);

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

  1073 	TEST1(err == KErrNone,1);

  1074 	TEST1(CallStatusV1.iStatus == CTelephony::EStatusHold,1);	

  1075 	 

  1076 	INFO_PRINTF1(_L("END TEST 2"));

  1077 	

  1078 	//

  1079 	//

  1080 	// TEST 3: Error case

  1081 	// Call is already on hold. Try to perform a hold on the call.

  1082 	//

  1083 	//

  1084 	

  1085 	INFO_PRINTF1(_L("HOLD TEST 3. Call already held. Call hold API.")); 

  1086 	

  1087 	// Call 3rd Party hold API

  1088 	testCallParams1.iExpStat=KErrAccessDenied;

  1089 	TestHoldAct->TestHold(testCallParams1);

  1090 	CActiveScheduler::Start();

  1091 			 

  1092 	// Make sure call is still in held status

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

  1094 	TEST1(err == KErrNone,1);

  1095 	TEST1(CallStatusV1.iStatus == CTelephony::EStatusHold,1);	

  1096 	

  1097 	INFO_PRINTF1(_L("END TEST 3"));

  1098 	

  1099 	//

  1100 	//

  1101 	// TEST 4: Error case

  1102 	// Hang up a call. Try to put the call on hold.

  1103 	//

  1104 	//

  1105 	

  1106 	INFO_PRINTF1(_L("HOLD TEST 4 Hangup call. Try to put on hold."));

  1107 	

  1108 	// Call hangup 3rd party API

  1109 	testCallParams1.iExpStat=KErrNone;	

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

  1111 	testHangupAct1->TestHangup(testCallParams1);

  1112 	CActiveScheduler::Start();	

  1113  

  1114 	// Make sure the line is idle

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

  1116 	TEST1(err == KErrNone,1);

  1117 	TEST1(CallStatusV1.iStatus == CTelephony::EStatusIdle,1);	

  1118  

  1119  	// Attempt to hold call. Should fail. 

  1120 	testCallParams1.iExpStat=KErrAccessDenied;	 

  1121 	TestHoldAct->TestHold(testCallParams1);

  1122 	CActiveScheduler::Start();

  1123 	

  1124 	// Make sure call is still in idle status

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

  1126 	TEST1(err == KErrNone,1);

  1127 	TEST1(CallStatusV1.iStatus == CTelephony::EStatusIdle,1);	

  1128 	

  1129 	INFO_PRINTF1(_L("END TEST 4"));	

  1130 	

  1131 	//

  1132 	//

  1133 	// TEST 5: Test cancel

  1134 	// Dial call. Make a request to hold call. Attempt to cancel 

  1135 	// the request.