// 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_EtelIsvNotifiers.h"

#include "TE_EtelIsvCallFunc.h"

/**

Each test step initialises it's own name

*/

CTestNotifyChange::CTestNotifyChange()

	{

	// store the name of this test case

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

	SetTestStepName(_L("TestRegisterForNotification"));

	}

/**

@SYMTestCaseID Etel3rdParty 26.1, TestNotifyChange

@SYMTestCaseDesc Test NotifyChange 3rd party API

@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

*/ 

TVerdict CTestNotifyChange::doTestStepL()

	{

	INFO_PRINTF1(_L("Test notifications"));

	TInt numberNotifierTestsActive = 0;	

	const TInt invalidNotificationEvent = 61;

	//Test 1: Try send a request for an invalid event range

	SetTestNumber(16);

	INFO_PRINTF1(_L("Testing invalid event notification"));

	CTelephony::TFlightModeV1 notifierStatus;

	CTelephony::TFlightModeV1Pckg notifierStatusPckg(notifierStatus);	

	TDes8* notifierStatusData;

	if (iBufferMode)

		{

		notifierStatusData = &iNotifierStatusBuff;

		}

	else

		{

		notifierStatusData = &notifierStatusPckg;

		}

	CTestRegisterNotifierAct* modeChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, (CTelephony::TNotificationEvent)invalidNotificationEvent);	

	//add the number of notification status objects for the test

	CTelephony::TFlightModeV1 expNotifierStatus1;

	CTelephony::TFlightModeV1Pckg expNotifierStatusPckg1(expNotifierStatus1);	

	expNotifierStatus1.iFlightModeStatus = CTelephony::EFlightModeOn;	

	modeChangeAct->iExpNotificationCompleteList.Append(expNotifierStatusPckg1);

	numberNotifierTestsActive = 0;

	modeChangeAct->StartNotifier(*notifierStatusData, KErrArgument);	

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(modeChangeAct);	

	//Notification Test 2: EFlightModeChange

	SetTestNumber(16);

	INFO_PRINTF1(_L("Testing EFlightModeChange notification"));

	CTelephony::TFlightModeV1 fmNotifierStatus;

	CTelephony::TFlightModeV1Pckg fmNotifierStatusPckg(fmNotifierStatus);	

	TDes8* fmNotifierStatusData;

	if (iBufferMode)

		{

		fmNotifierStatusData = &iFmNotifierStatusBuff;

		}

	else

		{

		fmNotifierStatusData = &fmNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* FlightModeChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EFlightModeChange);

	//add the number of notification status objects for the test	

	CTelephony::TFlightModeV1 fmExpNotifierStatus1;

	CTelephony::TFlightModeV1Pckg fmExpNotifierStatusPckg1(fmExpNotifierStatus1);	

	fmExpNotifierStatus1.iFlightModeStatus = CTelephony::EFlightModeOff;	

	FlightModeChangeAct->iExpNotificationCompleteList.Append(fmExpNotifierStatusPckg1);

	CTelephony::TFlightModeV1 fmExpNotifierStatus2;

	CTelephony::TFlightModeV1Pckg fmExpNotifierStatusPckg2(fmExpNotifierStatus2);	

	fmExpNotifierStatus2.iFlightModeStatus = CTelephony::EFlightModeOn;

	FlightModeChangeAct->iExpNotificationCompleteList.Append(fmExpNotifierStatusPckg2);

	CTelephony::TFlightModeV1 fmExpNotifierStatus3;

	CTelephony::TFlightModeV1Pckg fmExpNotifierStatusPckg3(fmExpNotifierStatus3);	

	fmExpNotifierStatus3.iFlightModeStatus = CTelephony::EFlightModeOff;

	FlightModeChangeAct->iExpNotificationCompleteList.Append(fmExpNotifierStatusPckg3);

	numberNotifierTestsActive = 0;

	FlightModeChangeAct->StartNotifier(*fmNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(FlightModeChangeAct);

	//Notification Test 3: EIndicatorChange

	SetTestNumber(17);

	INFO_PRINTF1(_L("Testing EIndicatorChange notification"));

	CTelephony::TIndicatorV1 indNotifierStatus;

	CTelephony::TIndicatorV1Pckg indNotifierStatusPckg(indNotifierStatus);	

	TDes8* indNotifierStatusData;

	if (iBufferMode)

		{

		indNotifierStatusData = &iIndNotifierStatusBuff;

		}

	else

		{

		indNotifierStatusData = &indNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* IndicatorChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EIndicatorChange);

	//add the number of notification status objects for the test	

	CTelephony::TIndicatorV1 indExpNotifierStatus1;

	CTelephony::TIndicatorV1Pckg indExpNotifierStatusPckg1(indExpNotifierStatus1);	

	indExpNotifierStatus1.iCapabilities = CTelephony::KIndChargerConnected | CTelephony::KIndNetworkAvailable | CTelephony::KIndCallInProgress;

	indExpNotifierStatus1.iIndicator = CTelephony::KIndChargerConnected;

	IndicatorChangeAct->iExpNotificationCompleteList.Append(indExpNotifierStatusPckg1);

	#if defined(_DEBUG)

	//test OOM case

		numberNotifierTestsActive = 0;

		__UHEAP_FAILNEXT(1);

		IndicatorChangeAct->StartNotifier(*indNotifierStatusData, KErrNoMemory);

		CActiveScheduler::Start();

		__UHEAP_RESET;

	#endif

	CTelephony::TIndicatorV1 indExpNotifierStatus2;

	CTelephony::TIndicatorV1Pckg indExpNotifierStatusPckg2(indExpNotifierStatus2);	

	indExpNotifierStatus2.iCapabilities = CTelephony::KIndChargerConnected | CTelephony::KIndNetworkAvailable | CTelephony::KIndCallInProgress;

	indExpNotifierStatus2.iIndicator = CTelephony::KIndChargerConnected | CTelephony::KIndNetworkAvailable;

	IndicatorChangeAct->iExpNotificationCompleteList.Append(indExpNotifierStatusPckg2);

	CTelephony::TIndicatorV1 indExpNotifierStatus3;

	CTelephony::TIndicatorV1Pckg indExpNotifierStatusPckg3(indExpNotifierStatus3);	

	indExpNotifierStatus3.iCapabilities = CTelephony::KIndChargerConnected | CTelephony::KIndNetworkAvailable | CTelephony::KIndCallInProgress;

	indExpNotifierStatus3.iIndicator = CTelephony::KIndChargerConnected;

	IndicatorChangeAct->iExpNotificationCompleteList.Append(indExpNotifierStatusPckg3);

	numberNotifierTestsActive = 0;

	IndicatorChangeAct->StartNotifier(*indNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(IndicatorChangeAct);

	//Notification Test 4: EBatteryInfoChange

	SetTestNumber(18);

	INFO_PRINTF1(_L("Testing EBatteryInfoChange notification"));

	CTelephony::TBatteryInfoV1 batNotifierStatus;

	CTelephony::TBatteryInfoV1Pckg batNotifierStatusPckg(batNotifierStatus);	

	TDes8* batNotifierStatusData;

	if (iBufferMode)

		{

		batNotifierStatusData = &iBatNotifierStatusBuff;

		}

	else

		{

		batNotifierStatusData = &batNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* batteryInfoChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EBatteryInfoChange);

	CTelephony::TBatteryInfoV1 batExpNotifierStatus1;

	CTelephony::TBatteryInfoV1Pckg batExpNotifierStatusPckg1(batExpNotifierStatus1);	

	batExpNotifierStatus1.iChargeLevel = 2;

	batExpNotifierStatus1.iStatus = CTelephony::EBatteryConnectedButExternallyPowered;

	batteryInfoChangeAct->iExpNotificationCompleteList.Append(batExpNotifierStatusPckg1);

	#if defined(_DEBUG)	

	//test OOM case

		numberNotifierTestsActive = 0;

		__UHEAP_FAILNEXT(1);

		batteryInfoChangeAct->StartNotifier(*batNotifierStatusData, KErrNoMemory);

		CActiveScheduler::Start();

		__UHEAP_RESET;

	#endif

	CTelephony::TBatteryInfoV1 batExpNotifierStatus2;

	CTelephony::TBatteryInfoV1Pckg batExpNotifierStatusPckg2(batExpNotifierStatus2);	

	batExpNotifierStatus2.iChargeLevel = 3;

	batExpNotifierStatus2.iStatus = CTelephony::ENoBatteryConnected;

	batteryInfoChangeAct->iExpNotificationCompleteList.Append(batExpNotifierStatusPckg2);	

	numberNotifierTestsActive = 0;

	batteryInfoChangeAct->StartNotifier(*batNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(batteryInfoChangeAct);

	//Notification Test 5: ESignalStrengthChange

	SetTestNumber(19);

	INFO_PRINTF1(_L("Testing ESignalStrengthChange notification"));

	CTelephony::TSignalStrengthV1 sigNotifierStatus;

	CTelephony::TSignalStrengthV1Pckg sigNotifierStatusPckg(sigNotifierStatus);	

	TDes8* sigNotifierStatusData;

	if (iBufferMode)

		{

		sigNotifierStatusData = &iSigNotifierStatusBuff;

		}

	else

		{

		sigNotifierStatusData = &sigNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* signalStrengthChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::ESignalStrengthChange);

	CTelephony::TSignalStrengthV1 sigExpNotifierStatus1;

	CTelephony::TSignalStrengthV1Pckg sigExpNotifierStatusPckg1(sigExpNotifierStatus1);	

	sigExpNotifierStatus1.iBar = 3;

	sigExpNotifierStatus1.iSignalStrength = -51;

	signalStrengthChangeAct->iExpNotificationCompleteList.Append(sigExpNotifierStatusPckg1);

	#if defined(_DEBUG)

	//test OOM case

		numberNotifierTestsActive = 0;

		__UHEAP_FAILNEXT(1);

		signalStrengthChangeAct->StartNotifier(*sigNotifierStatusData, KErrNoMemory);

		CActiveScheduler::Start();

		__UHEAP_RESET;

	#endif

	CTelephony::TSignalStrengthV1 sigExpNotifierStatus2;

	CTelephony::TSignalStrengthV1Pckg sigExpNotifierStatusPckg2(sigExpNotifierStatus2);	

	sigExpNotifierStatus2.iBar = 2;

	sigExpNotifierStatus2.iSignalStrength = -40;

	signalStrengthChangeAct->iExpNotificationCompleteList.Append(sigExpNotifierStatusPckg2);

	numberNotifierTestsActive = 0;

	signalStrengthChangeAct->StartNotifier(*sigNotifierStatusData,KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(signalStrengthChangeAct);

	//Notification Test 6: EPin1LockInfoChange

	SetTestNumber(20);

	INFO_PRINTF1(_L("Testing EPin1LockInfoChange notification"));

	CTelephony::TIccLockInfoV1 locNotifierStatus;

	CTelephony::TIccLockInfoV1Pckg locNotifierStatusPckg(locNotifierStatus);

	TDes8* locNotifierStatusData;

	if (iBufferMode)

		{

		locNotifierStatusData = &iLocNotifierStatusBuff;

		}

	else

		{

		locNotifierStatusData = &locNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* pin1lockInfoChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EPin1LockInfoChange);

	CTelephony::TIccLockInfoV1 locExpNotifierStatus1;

	CTelephony::TIccLockInfoV1Pckg locExpNotifierStatusPckg1(locExpNotifierStatus1);	

	locExpNotifierStatus1.iSetting = CTelephony::ELockSetEnabled;

	locExpNotifierStatus1.iStatus = CTelephony::EStatusUnlocked;

	pin1lockInfoChangeAct->iExpNotificationCompleteList.Append(locExpNotifierStatusPckg1);

	#if defined(_DEBUG)

	//test OOM case

		numberNotifierTestsActive = 0;

		__UHEAP_FAILNEXT(1);

		pin1lockInfoChangeAct->StartNotifier(*locNotifierStatusData, KErrNoMemory);

		CActiveScheduler::Start();

		__UHEAP_RESET;

	#endif

	//try initiating both pin1 & pin2 request notification. The test should pass.

	CTestRegisterNotifierAct* temppin2lockInfoChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EPin2LockInfoChange);

	temppin2lockInfoChangeAct->iExpNotificationCompleteList.Append(locExpNotifierStatusPckg1);

	CTelephony::TIccLockInfoV1 locExpNotifierStatus2;

	CTelephony::TIccLockInfoV1Pckg locExpNotifierStatusPckg2(locExpNotifierStatus2);	

	locExpNotifierStatus2.iSetting = CTelephony::ELockSetDisabled;

	locExpNotifierStatus2.iStatus = CTelephony::EStatusUnlocked;

	pin1lockInfoChangeAct->iExpNotificationCompleteList.Append(locExpNotifierStatusPckg2);	

	numberNotifierTestsActive = 0;

	pin1lockInfoChangeAct->StartNotifier(*locNotifierStatusData, KErrNone, ETrue);

	temppin2lockInfoChangeAct->StartNotifier(*locNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(temppin2lockInfoChangeAct);

	CleanupStack::PopAndDestroy(pin1lockInfoChangeAct);

	//Notification Test 6b: EPin2LockInfoChange

	INFO_PRINTF1(_L("Testing EPin2LockInfoChange notification"));

	CTestRegisterNotifierAct* pin2lockInfoChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EPin2LockInfoChange);

	locExpNotifierStatus1.iSetting = CTelephony::ELockSetDisabled;

	locExpNotifierStatus1.iStatus = CTelephony::EStatusLocked;

	pin2lockInfoChangeAct->iExpNotificationCompleteList.Append(locExpNotifierStatusPckg1);	

	locExpNotifierStatus2.iSetting = CTelephony::ELockSetUnknown;

	locExpNotifierStatus2.iStatus = CTelephony::EStatusLocked;

	pin2lockInfoChangeAct->iExpNotificationCompleteList.Append(locExpNotifierStatusPckg2);	

	numberNotifierTestsActive = 0;	

	pin2lockInfoChangeAct->StartNotifier(*locNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(pin2lockInfoChangeAct);

	//Notification Test 7: EVoiceLineStatusChange

	SetTestNumber(21);

	INFO_PRINTF1(_L("Testing EVoiceLineStatusChange notification"));

	CTelephony::TCallStatusV1 linNotifierStatus;

	CTelephony::TCallStatusV1Pckg linNotifierStatusPckg(linNotifierStatus);	

	TDes8* linNotifierStatusData;

	if (iBufferMode)

		{

		linNotifierStatusData = &iLinNotifierStatusBuff;

		}

	else

		{

		linNotifierStatusData = &linNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* lineStatusChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EVoiceLineStatusChange);

	CTelephony::TCallStatusV1 linExpNotifierStatus1;

	CTelephony::TCallStatusV1Pckg linExpNotifierStatusPckg1(linExpNotifierStatus1);	

	linExpNotifierStatus1.iStatus = CTelephony::EStatusDialling;

	lineStatusChangeAct->iExpNotificationCompleteList.Append(linExpNotifierStatusPckg1);

	CTelephony::TCallStatusV1 linExpNotifierStatus2;

	CTelephony::TCallStatusV1Pckg linExpNotifierStatusPckg2(linExpNotifierStatus2);	

	linExpNotifierStatus2.iStatus = CTelephony::EStatusConnecting;

	lineStatusChangeAct->iExpNotificationCompleteList.Append(linExpNotifierStatusPckg2);

	CTelephony::TCallStatusV1 linExpNotifierStatus3;

	CTelephony::TCallStatusV1Pckg linExpNotifierStatusPckg3(linExpNotifierStatus3);	

	linExpNotifierStatus3.iStatus = CTelephony::EStatusConnected;

	lineStatusChangeAct->iExpNotificationCompleteList.Append(linExpNotifierStatusPckg3);	

	CTelephony::TCallStatusV1 linExpNotifierStatus4;

	CTelephony::TCallStatusV1Pckg linExpNotifierStatusPckg4(linExpNotifierStatus4);	

	linExpNotifierStatus4.iStatus = CTelephony::EStatusDisconnecting;

	lineStatusChangeAct->iExpNotificationCompleteList.Append(linExpNotifierStatusPckg4);

	CTelephony::TCallStatusV1 linExpNotifierStatus5;

	CTelephony::TCallStatusV1Pckg linExpNotifierStatusPckg5(linExpNotifierStatus5);	

	linExpNotifierStatus5.iStatus = CTelephony::EStatusIdle;

	lineStatusChangeAct->iExpNotificationCompleteList.Append(linExpNotifierStatusPckg5);	

	numberNotifierTestsActive = 0;

	lineStatusChangeAct->StartNotifier(*linNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(lineStatusChangeAct);

	//Notification Test 7a: EFaxLineStatusChange & EDataLineStatusChange

	INFO_PRINTF1(_L("Testing EFaxLineStatusChange & EDataLineStatusChange notification"));

	TRequestStatus faxDataNotifierStatus(0);

	CTelephony::TCallStatusV1 faxDataLinExpNotifierStatus;

	CTelephony::TCallStatusV1Pckg faxDataLinExpNotifierStatusPckg(faxDataLinExpNotifierStatus);

	TDes8* faxDataLinExpNotifierStatusData;

	if (iBufferMode)

		{

		faxDataLinExpNotifierStatusData = &iFaxDataLinExpNotifierStatusBuff;

		}

	else

		{

		faxDataLinExpNotifierStatusData = &faxDataLinExpNotifierStatusPckg;

		}

	CTelephony::TNotificationEvent telEvent = CTelephony::EFaxLineStatusChange;

	iTelephony->NotifyChange(faxDataNotifierStatus, telEvent, *faxDataLinExpNotifierStatusData);

	User::WaitForRequest(faxDataNotifierStatus);

	TEST(faxDataNotifierStatus == KErrNotSupported);

	faxDataNotifierStatus = 0;

	telEvent = CTelephony::EDataLineStatusChange;

	iTelephony->NotifyChange(faxDataNotifierStatus, telEvent, *faxDataLinExpNotifierStatusData);

	User::WaitForRequest(faxDataNotifierStatus);

	TEST(faxDataNotifierStatus == KErrNotSupported);

	//Notification Test 8: EOwnedCall1CallStatusChange

	//don't need to set test number as previous test (line notifier) is the same

	INFO_PRINTF1(_L("Testing EOwnedCall1CallStatusChange notification"));

	CTelephony::TCallStatusV1 calNotifierStatus;

	CTelephony::TCallStatusV1Pckg calNotifierStatusPckg(calNotifierStatus);	

	TDes8* calNotifierStatusData;

	if (iBufferMode)

		{

		calNotifierStatusData = &iCalNotifierStatusBuff;

		}

	else

		{

		calNotifierStatusData = &calNotifierStatusPckg;

		}

	CTestRegisterNotifierAct* call1StatusChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EOwnedCall1StatusChange);

	CTelephony::TCallStatusV1 calExpNotifierStatus1;

	CTelephony::TCallStatusV1Pckg calExpNotifierStatusPckg1(calExpNotifierStatus1);	

	calExpNotifierStatus1.iStatus = CTelephony::EStatusDisconnecting;

	call1StatusChangeAct->iExpNotificationCompleteList.Append(calExpNotifierStatusPckg1);

	CTelephony::TCallStatusV1 calExpNotifierStatus2;

	CTelephony::TCallStatusV1Pckg calExpNotifierStatusPckg2(calExpNotifierStatus2);	

	calExpNotifierStatus2.iStatus = CTelephony::EStatusIdle;

	call1StatusChangeAct->iExpNotificationCompleteList.Append(calExpNotifierStatusPckg2);	

	//make call

	call1StatusChangeAct->MakeCallL();

	CActiveScheduler::Start();

	numberNotifierTestsActive = 0;

	call1StatusChangeAct->StartNotifier(*calNotifierStatusData, KErrNone, ETrue);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(call1StatusChangeAct);

	//Notification Test 8b: EOwnedCall2CallStatusChange

	//don't need to set test number as previous test (line notifier) is the same

	INFO_PRINTF1(_L("Testing EOwnedCall2CallStatusChange notification"));

	CTestRegisterNotifierAct* call2StatusChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EOwnedCall2StatusChange);

	calExpNotifierStatus1.iStatus = CTelephony::EStatusDisconnecting;

	call2StatusChangeAct->iExpNotificationCompleteList.Append(calExpNotifierStatusPckg1);

	calExpNotifierStatus2.iStatus = CTelephony::EStatusIdle;

	call2StatusChangeAct->iExpNotificationCompleteList.Append(calExpNotifierStatusPckg2);

	//make first call

	CTelephony::TCallParamsV1 callParams1;

	callParams1.iIdRestrict = CTelephony::ESendMyId;

	CTelephony::TCallParamsV1Pckg callParamsPckg1(callParams1);	

	CTelephony::TCallStatusV1 status;

	CTelephony::TCallStatusV1Pckg statusPckg(status);

	TTestCallParams testCallParams1;

	testCallParams1.iLine = CTelephony::EVoiceLine;

	testCallParams1.iCallParamsV1Pckg = &callParamsPckg1;

	testCallParams1.iTelAddress.iTelNumber = _L("1234");

	testCallParams1.iExpStat = KErrNone;

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

	// Create a call - should succeed

	testCallParams1.iCallId = CTelephony::EISVMaxNumOfCalls;

	testDialNewCallAct1->TestDialNewCall(testCallParams1);

	CActiveScheduler::Start();

	//should be conected

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

	TEST1(err == KErrNone, ETrue);

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

	//put first call on hold

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

	TestHoldAct->TestHold(testCallParams1);

	CActiveScheduler::Start();	

	//make second call

	call2StatusChangeAct->MakeCallL();

	CActiveScheduler::Start();

	//hangup first call

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

	testHangupAct1->TestHangup(testCallParams1);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(testHangupAct1);

	CleanupStack::PopAndDestroy(TestHoldAct);

	CleanupStack::PopAndDestroy(testDialNewCallAct1);

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

	TEST1(err == KErrNone, ETrue);

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

	//set notifier going for the second owned call

	numberNotifierTestsActive = 0;

	call2StatusChangeAct->StartNotifier(*calNotifierStatusData, KErrNone);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(call2StatusChangeAct);

	//Notification Test 9: EOwnedCall1RemotePartyInfoChange

	SetTestNumber(22);

	INFO_PRINTF1(_L("Testing EOwnedCall1RemotePartyInfoChange notification"));

	CTelephony::TRemotePartyInfoV1 remNotifierStatus;

	CTelephony::TRemotePartyInfoV1Pckg remNotifierStatusPckg(remNotifierStatus);	

	TDes8* remNotifierStatusData;

	if (iBufferMode)

		{

		remNotifierStatusData = &iRemNotifierStatusBuff;

		}

	else

		{

		remNotifierStatusData = &remNotifierStatusPckg;

		}

	CTestRegisterNotifierAct*call1RemotePartyInfoChangeAct = CTestRegisterNotifierAct::NewLC(this, iTelephony, numberNotifierTestsActive, CTelephony::EOwnedCall1RemotePartyInfoChange);

	CTelephony::TRemotePartyInfoV1 remExpNotifierStatus1;

	CTelephony::TRemotePartyInfoV1Pckg remExpNotifierStatusPckg1(remExpNotifierStatus1);	

	remExpNotifierStatus1.iCallingName = _L("call0");

	remExpNotifierStatus1.iDirection = CTelephony::EMobileOriginated;

	remExpNotifierStatus1.iRemoteIdStatus = CTelephony::ERemoteIdentityAvailable;

	remExpNotifierStatus1.iRemoteNumber.iTypeOfNumber = CTelephony::EInternationalNumber;

	remExpNotifierStatus1.iRemoteNumber.iNumberPlan = CTelephony::EIsdnNumberPlan;

	remExpNotifierStatus1.iRemoteNumber.iTelNumber = _L("12345678");

	call1RemotePartyInfoChangeAct->iExpNotificationCompleteList.Append(remExpNotifierStatusPckg1);

	//make call

	call1RemotePartyInfoChangeAct->MakeCallL();

	CActiveScheduler::Start();