// Copyright (c) 2007-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:

 //

 /**

  @file

  @internalComponent

  @prototype

 */

 #include "dvbhhaiasynctest.h"

 #include <mobiletv/hai/dvbh/dvbhtypes.h>

 /**

 * RDvbhHaiAsyncTest 

 *	DVB-H HAI Asynchronous Unit Tests on stub implementations

 */

 RDvbhHaiAsyncTest* RDvbhHaiAsyncTest::NewL(TBool aRequireReceiverInfo, const TDesC& aTestName)

 	{

 	RDvbhHaiAsyncTest* self = new (ELeave) RDvbhHaiAsyncTest(aRequireReceiverInfo, aTestName);

 	return self;	

 	}

 RDvbhHaiAsyncTest::RDvbhHaiAsyncTest(TBool aRequireReceiverInfo, const TDesC& aTestName)

 : RAsyncTestStep(), iExpectedNetworkTime(TDateTime(2007, EJuly, 30, 16, 35, 22, 18)),

   iInitialNetworkTime(TDateTime(1997, EMay, 10, 10, 00, 34, 02)), iInitialPlatform(),

   iExpectedPlatform(), iPreTestRun(EFalse), iRequireReceiverInfo(aRequireReceiverInfo),

   iRxInfo(NULL), i2ndRxInfo(NULL), iTestUtils(NULL), i2ndStateObserver(NULL)

 	{

 	iStateCallbackVerdicts[E1stStateObserver] = KNoVerdict;

 	iStateCallbackVerdicts[E2ndStateObserver] = KNoVerdict;

 	iTestStepName.Copy(aTestName);

 	SetupParameterData();

 	}

 void RDvbhHaiAsyncTest::SetupParameterData()

 	{

 	iInitialPlatform.iPlatform.iId = KInitialPlatformId;

 	iInitialPlatform.iPlatform.iName = KInitialPlatformName;

 	iInitialPlatform.iEsgRoot = KInet6AddrLinkLocal;

 	iExpectedPlatform.iPlatform.iId = KExpectedPlatformId;

 	iExpectedPlatform.iPlatform.iName = KExpectedPlatformName;	

 	iExpectedPlatform.iEsgRoot = KDvbhTestIpV6Addr;

 	}

 void RDvbhHaiAsyncTest::InfoPrintf3(const TDesC16& aString, TInt aInt1, TInt aInt2)

 	{

 	INFO_PRINTF3(aString, aInt1, aInt2);

 	}

 void RDvbhHaiAsyncTest::InfoPrintf4(const TDesC16& aString, TInt aInt1, TInt aInt2, TInt aInt3)

 	{

 	INFO_PRINTF4(aString, aInt1, aInt2, aInt3);

 	}

 /**

 * Allocs objects, defines properties, etc. as needed for each test step.

 * Takes the role of the Preamble in synchornous tests.  It is called once

 * when a test step is first kicked off.

 */

 TVerdict RDvbhHaiAsyncTest::DoPreTest()

 	{

 	TRAPD(result, iTestUtils = CDvbhTestUtil::NewL(*this));

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("Error %d creating CDvbhTestUtil"), result);

 		return EInconclusive;		

 		}

 	if (iRequireReceiverInfo)

 		{

 		TRAP(result, iRxInfo = CDvbhReceiverInfo::NewL())

 		if (result != KErrNone)

 			{

 			INFO_PRINTF2(_L("Error %d creating CDvbhReceiverInfo"), result);

 			return EInconclusive;

 			}

 		}

 	if (iTestStepName.Compare(_L("MM-TV-DVBH-U-111")) == 0)		

 		{

 		result = iTestUtils->DefineDvbhStateProperty(KInitialState);		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-112")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReceiving);

 		if (result == KErrNone)

 			{

 			result = iTestUtils->DefineDvbhIntegerProperty(EDvbhPropertyKeySignalQuality, KInitialSignalQuality);			

 			}				

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-113")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);

 		if (result == KErrNone)

 			{

 			TPckg<TDvbhPlatformProperty> initialPlatformPckg(iInitialPlatform);

 			result = iTestUtils->DefineDvbhProperty(EDvbhPropertyKeyPlatform, CDvbhTestUtil::GetType(EDvbhPropertyKeyPlatform), initialPlatformPckg);			

 			}		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-114")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);

 		if (result == KErrNone)

 			{

 			TPckg<TTime> initialTimePckg(iInitialNetworkTime);

 			result = iTestUtils->DefineDvbhProperty(EDvbhPropertyKeyNetworkTime, CDvbhTestUtil::GetType(EDvbhPropertyKeyNetworkTime), initialTimePckg);			

 			}		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-115")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);

 		if (result == KErrNone)

 			{

 			result = iTestUtils->DefineDvbhIntegerProperty(EDvbhPropertyKeyFrequency, KInitialFrequency);			

 			}		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-116")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);

 		if (result == KErrNone)

 			{

 			result = iTestUtils->DefineDvbhIntegerProperty(EDvbhPropertyKeyCellId, KInitialCellId);			

 			}		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-117")) == 0)		

 		{

 		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.

 		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);

 		if (result == KErrNone)

 			{

 			result = iTestUtils->DefineDvbhIntegerProperty(EDvbhPropertyKeyNetworkId, KInitialNetworkId);			

 			}		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-125")) == 0)		

 		{

 		result = iTestUtils->DefineDvbhStateProperty(KInitialState);

 		if (result == KErrNone)

 			{

 			TRAP(result, i2ndStateObserver = CAlternativeStateObserver::NewL(*this));		

 			}

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-126")) == 0)		

 		{

 		TRAP(result, i2ndStateObserver = CAlternativeStateObserver::NewL(*this));		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-127")) == 0)		

 		{

 		result = iTestUtils->DefineDvbhStateProperty(KInitialState);

 		if (result == KErrNone)

 			{

 			TRAP(result, i2ndRxInfo = CDvbhReceiverInfo::NewL());

 			if (result == KErrNone)

 				{

 				TRAP(result, i2ndStateObserver = CAlternativeStateObserver::NewL(*this));		

 				}

 			}

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-128")) == 0)		

 		{

 		TRAP(result, i2ndRxInfo = CDvbhReceiverInfo::NewL());

 		if (result == KErrNone)

 			{

 			TRAP(result, i2ndStateObserver = CAlternativeStateObserver::NewL(*this));		

 			}

 		}

 	else if (iTestStepName.Compare(_L("MM-TV-DVBH-U-401")) == 0)		

 		{

 		result = iTestUtils->DefineAllDvbhProperties();		

 		}

 	iPreTestRun = ETrue;	

 	return (result == KErrNone ? EPass : EInconclusive);				

 	}

 void RDvbhHaiAsyncTest::CloseTest()

 	{

 	delete iRxInfo;

 	iRxInfo = NULL;

 	delete i2ndStateObserver;

 	i2ndStateObserver = NULL;

 	delete i2ndRxInfo;

 	i2ndRxInfo = NULL;

 	TInt result = KErrNone;

 	if (iTestStepName.Compare(_L("MM-TV-DVBH-U-111")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-112")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeySignalQuality);	

 		result = result2 != KErrNone ? result2 : result;		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-113")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyPlatform);

 		result = result2 != KErrNone ? result2 : result;			

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-114")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyNetworkTime);

 		result = result2 != KErrNone ? result2 : result;			

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-115")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyFrequency);	

 		result = result2 != KErrNone ? result2 : result;		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-116")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyCellId);	

 		result = result2 != KErrNone ? result2 : result;		

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-117")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyNetworkId);

 		result = result2 != KErrNone ? result2 : result;			

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-125")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-127")) == 0)		

 		{

 		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);

 		}	

 	else if (iTestStepName.Compare(_L("MM-TV-DVBH-U-401")) == 0)		

 		{

 		result = iTestUtils->DeleteAllDvbhProperties();		

 		}

 	delete iTestUtils;

 	iTestUtils = NULL;

 	//Make sure we are not leaving anything laying around.  This is

 	//to verify the integrity of the test code more than anything else.

 	ASSERT(result == KErrNone);

 	}

 void RDvbhHaiAsyncTest::KickoffTestL()

 	{

 	//Run the pre-test set-up if it has not been run already

 	if (!iPreTestRun)

 		{

 		TVerdict preTestResult = DoPreTest();

 		if (preTestResult != EPass)

 			{

 			INFO_PRINTF2(_L("DoPreTest failed with error %d."), preTestResult);

 			StopTest(preTestResult);

 			return;

 			}

 		}

 	if (iTestStepName.Compare(_L("MM-TV-DVBH-U-111")) == 0)		

 		{

 		DoSetStateObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-112")) == 0)		

 		{

 		DoSetSignalQualityObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-113")) == 0)		

 		{

 		DoSetPlatformObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-114")) == 0)		

 		{

 		DoSetNetworkTimeObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-115")) == 0)		

 		{

 		DoSetFrequencyObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-116")) == 0)		

 		{

 		DoSetCellIdObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-117")) == 0)		

 		{

 		DoSetNetworkIdObserverTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-118")) == 0)		

 		{

 		DoSetStateObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-119")) == 0)		

 		{

 		DoSetSignalQualityObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-120")) == 0)		

 		{

 		DoSetPlatformObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-121")) == 0)		

 		{

 		DoSetNetworkTimeObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-122")) == 0)		

 		{

 		DoSetFrequencyObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-123")) == 0)		

 		{

 		DoSetCellIdObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-124")) == 0)		

 		{

 		DoSetNetworkIdObserverTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-125")) == 0)		

 		{

 		DoSetMultipleStateObserversTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-126")) == 0)		

 		{

 		DoSetMultipleStateObserversTestStep(EFalse);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-127")) == 0)		

 		{

 		DoCreateMultipleReceiverInfoTestStep(ETrue);

 		}

 	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-128")) == 0)		

 		{

 		DoCreateMultipleReceiverInfoTestStep(EFalse);

 		}

 	else if (iTestStepName.Compare(_L("MM-TV-DVBH-U-401")) == 0)		

 		{

 		DoSetObserversNoMemory();		

 		}

 	else

 		{

 		StopTest(EInconclusive);

 		}

 	}

 //

 //

 // CDvbhReceiverInfo Positive Async Tests

 //

 //

 // 111 & 118

 void RDvbhHaiAsyncTest::DoSetStateObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetStateObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetStateObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the state to KInitialState.

 		//Now change it to KExpectedState.

 		if (iTestUtils->SetStateProperty(KExpectedState) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the state property changes if this state observer has been registerd

 void RDvbhHaiAsyncTest::DvbhStateChange( TDvbhState aNewState )

 	{

 	TVerdict verdict = EPass;

 	// We have to make sure that this observer was not called for the wrong test.

 	if ( iTestStepName.Compare(_L("MM-TV-DVBH-U-125")) == 0 ||

 		 iTestStepName.Compare(_L("MM-TV-DVBH-U-126")) == 0 )		

 		{

 		INFO_PRINTF1(_L("RDvbhHaiAsyncTest::DvbhStateChange called for wrong test."));

 		verdict = EFail;

 		}

 	else

 		{

 		if (aNewState != KExpectedState)

 			{

 			INFO_PRINTF2(_L("DvbhStateChange received unexpected value %d."), aNewState);

 			verdict = EFail;

 			}

 		else

 			{

 			// Test case MM-TV-DVBH-U-127 is expecting two callbacks on two different observers

 			if (iTestStepName.Compare(_L("MM-TV-DVBH-U-127")) == 0)

 				{

 				// Set the verdict for this observer

 				iStateCallbackVerdicts[E1stStateObserver] = verdict;

 				//Check if the 2nd observer has reported back yet. If not then we

 				//do not want to stop the test yet.

 				if (iStateCallbackVerdicts[E2ndStateObserver] == KNoVerdict)

 					{

 					return;

 					}

 				else

 					{

 					verdict = static_cast<TVerdict>(iStateCallbackVerdicts[E2ndStateObserver]);

 					}

 				}		

 			}		

 		}

 	StopTest(verdict);

 	}	

 // 112 & 119

 void RDvbhHaiAsyncTest::DoSetSignalQualityObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetSignalQualityObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetSignalQualityObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the signal quality to KInitialSignalQuality.

 		//Now change it to KExpectedSignalQuality.

 		if (iTestUtils->SetIntegerProperty(EDvbhPropertyKeySignalQuality, KExpectedSignalQuality) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the signal quality property changes this a signal quality observer has been registerd

 void RDvbhHaiAsyncTest::DvbhSignalQualityChange( const TDvbhSignalQuality& aNewSignalQuality )

 	{

 	TVerdict verdict = EPass;

 	if (aNewSignalQuality != KExpectedSignalQuality)

 		{

 		INFO_PRINTF2(_L("DvbhSignalQualityChange received unexpected value %d."), aNewSignalQuality);

 		verdict = EFail;

 		}

 	StopTest(verdict);

 	}

 // 113 & 120

 void RDvbhHaiAsyncTest::DoSetPlatformObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetPlatformObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetPlatformObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the platform to iInitialPlatform.

 		//Now change it to iExpectedPlatform.

 		TPckg<TDvbhPlatformProperty> platformPckg(iExpectedPlatform);

 		if (iTestUtils->SetByteArrayProperty(EDvbhPropertyKeyPlatform, platformPckg) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the platform property changes if this platform observer has been registerd

 void RDvbhHaiAsyncTest::DvbhPlatformChange( const TDvbhPlatform& aNewPlatform, const TIp6Addr& aESGRoot )

 	{

 	TVerdict verdict = EPass;

 	if ( !CDvbhTestUtil::ComparePlatforms(aNewPlatform, iExpectedPlatform.iPlatform))

 		{

 		INFO_PRINTF1(_L("DvbhPlatformChangeDvbhPlatformChange received unexpected platform."));

 		verdict = EFail;

 		}

 	if (!aESGRoot.IsEqual(iExpectedPlatform.iEsgRoot))

 		{

 		INFO_PRINTF1(_L("DvbhPlatformChangeDvbhPlatformChange received unexpected esgRoot."));

 		verdict = EFail;		

 		}

 	StopTest(verdict);

 	}

 // 114 & 121

 void RDvbhHaiAsyncTest::DoSetNetworkTimeObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetNetworkTimeObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetNetworkTimeObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the NetworkTime to iInitialNetworkTime.

 		//Now change it to KExpectedNetworkTime.

 		TPckg<TTime> timePckg(iExpectedNetworkTime);	

 		if (iTestUtils->SetByteArrayProperty(EDvbhPropertyKeyNetworkTime, timePckg) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the network time property changes if this network time observer has been registerd

 void RDvbhHaiAsyncTest::DvbhNetworkTimeUpdate()

 	{

 	// Since this method has no parameters, there are no variables for us to verify.

 	// The fact that this method was called at all means that CDvbhReceiverInfo::SetNetworkTimeObserver()

 	// worked correctly, and thus we can now stop the test as passed.

 	StopTest(EPass);

 	}

 // 115 & 122

 void RDvbhHaiAsyncTest::DoSetFrequencyObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetFrequencyObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetFrequencyObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the frequency to KInitialFrequency.

 		//Now change it to KExpectedFrequency.

 		if (iTestUtils->SetIntegerProperty(EDvbhPropertyKeyFrequency, KExpectedFrequency) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the frequency property changes if this frequency observer has been registerd

 void RDvbhHaiAsyncTest::DvbhFrequencyChange( const TDvbhFrequency& aNewFrequency )

 	{

 	TVerdict verdict = EPass;

 	if (aNewFrequency != KExpectedFrequency)

 		{

 		INFO_PRINTF2(_L("DvbhFrequencyChange received unexpected value %d."), aNewFrequency);

 		verdict = EFail;

 		}

 	StopTest(verdict);

 	}

 // 116 & 123

 void RDvbhHaiAsyncTest::DoSetCellIdObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetCellIdObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetCellIdObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the CellId to KInitialCellId.

 		//Now change it to KExpectedCellId.

 		if (iTestUtils->SetIntegerProperty(EDvbhPropertyKeyCellId, KExpectedCellId) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}			

 	}

 //Called when the CellId property changes if this CellId observer has been registerd

 void RDvbhHaiAsyncTest::DvbhCellIdChange( const TDvbhCellId& aNewCellId )

 	{

 	TVerdict verdict = EPass;

 	if (aNewCellId != KExpectedCellId)

 		{

 		INFO_PRINTF2(_L("DvbhCellIdChange received unexpected value %d."), aNewCellId);

 		verdict = EFail;

 		}

 	StopTest(verdict);

 	}

 // 117 & 124

 void RDvbhHaiAsyncTest::DoSetNetworkIdObserverTestStep(TBool aProperyExists)

 	{

 	TInt result = iRxInfo->SetNetworkIdObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("SetNetworkIdObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the NetworkId to KInitialNetworkId.

 		//Now change it to KExpectedNetworkId.

 		if (iTestUtils->SetIntegerProperty(EDvbhPropertyKeyNetworkId, KExpectedNetworkId) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

 //Called when the NetworkId property changes if this NetworkId observer has been registerd

 void RDvbhHaiAsyncTest::DvbhNetworkIdChange( const TDvbhNetworkId& aNewNetworkId )

 	{

 	TVerdict verdict = EPass;

 	if (aNewNetworkId != KExpectedNetworkId)

 		{

 		INFO_PRINTF2(_L("DvbhNetworkIdChange received unexpected value %d."), aNewNetworkId);

 		verdict = EFail;

 		}

 	StopTest(verdict);

 	}

 // 125 & 126

 void RDvbhHaiAsyncTest::DoSetMultipleStateObserversTestStep(TBool aProperyExists)

 	{

 	// Set a state observer

 	TInt result = iRxInfo->SetStateObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("1st SetStateObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	// Now try to set another one

 	result = iRxInfo->SetStateObserver(*i2ndStateObserver);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("2nd SetStateObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		//DoPreTest will have initialised the state to KInitialState.

 		//Now change it.

 		if (iTestUtils->SetStateProperty(KExpectedState) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}

 	}

  //127 & 128

 void RDvbhHaiAsyncTest::DoCreateMultipleReceiverInfoTestStep(TBool aProperyExists)

 	{

 	// Set a state observer on the first CDvbhReceiverInfo object

 	TInt result = iRxInfo->SetStateObserver(*this);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("1st SetStateObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	// Now try to set another one on the 2nd CDvbhReceiverInfo object 

 	result = i2ndRxInfo->SetStateObserver(*i2ndStateObserver);

 	if (result != KErrNone)

 		{

 		INFO_PRINTF2(_L("2nd SetStateObserver returned error %d."), result);

 		StopTest(EFail);

 		return;

 		}

 	if (aProperyExists)

 		{

 		iStateCallbackVerdicts[E1stStateObserver] = KNoVerdict;

 		iStateCallbackVerdicts[E2ndStateObserver] = KNoVerdict;

 		//DoPreTest will have initialised the state to KInitialState.

 		//Now change it.

 		if (iTestUtils->SetStateProperty(KExpectedState) != KErrNone)

 			{

 			StopTest(EInconclusive);

 			return;		

 			}		

 		}

 	else

 		{

 		StopTest(EPass);

 		}	

 	}

 //

 //

 // RDvbhHaiAsyncTest::CAlternativeStateObserver

 //

 //

 RDvbhHaiAsyncTest::CAlternativeStateObserver* RDvbhHaiAsyncTest::CAlternativeStateObserver::NewL(RDvbhHaiAsyncTest& aTestStep)

 	{

 	CAlternativeStateObserver* self = new (ELeave) CAlternativeStateObserver(aTestStep);

 	return self;	

 	}

 RDvbhHaiAsyncTest::CAlternativeStateObserver::CAlternativeStateObserver(RDvbhHaiAsyncTest& aTestStep)

 : iTestStep(aTestStep)

 	{

 	}

 void RDvbhHaiAsyncTest::CAlternativeStateObserver::DvbhStateChange( TDvbhState aNewState )

 	{

 	TVerdict verdict = EPass;

 	if (aNewState != KExpectedState)

 		{

 		iTestStep.INFO_PRINTF2(_L("CAlternativeStateObserver::DvbhStateChange received unexpected value %d."), aNewState);

 		verdict = EFail;

 		}

 	else

 		{

 		// Test case MM-TV-DVBH-U-127 is expecting two callbacks on two different observers

 		if (iTestStep.iTestStepName.Compare(_L("MM-TV-DVBH-U-127")) == 0)

 			{

 			// Set the verdict for this observer

 			iTestStep.iStateCallbackVerdicts[E2ndStateObserver] = verdict;

 			//Check if the 1st observer has reported back yet. If not then we

 			//do not want to stop the test yet.

 			if (iTestStep.iStateCallbackVerdicts[E1stStateObserver] == KNoVerdict)

 				{

 				return;

 				}

 			else

 				{

 				verdict = static_cast<TVerdict>(iTestStep.iStateCallbackVerdicts[E1stStateObserver]);

 				}

 			}		

 		}

 	iTestStep.StopTest(verdict);

 	}

 //401

 /**

 * Test to improve conditional code coverage.  Tests KErrNoMemory failures

 * with SetObserver methods.

 */

 void RDvbhHaiAsyncTest::DoSetObserversNoMemory()

 	{

 	//SetStateObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	TInt result = iRxInfo->SetStateObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetStateObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetSignalQualityObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetSignalQualityObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetSignalQualityObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetPlatformObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetPlatformObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetPlatformObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetNetworkTimeObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetNetworkTimeObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetNetworkTimeObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetFrequencyObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetFrequencyObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetFrequencyObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetCellIdObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetCellIdObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetCellIdObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	//SetNetworkIdObserver

 	__UHEAP_SETFAIL(RHeap::EFailNext, 1);

 	result = iRxInfo->SetNetworkIdObserver(*this);

 	if (result != KErrNoMemory)

 		{

 		INFO_PRINTF2(_L("SetNetworkIdObserver returned %d."), result);

 		StopTest(EInconclusive);

 		__UHEAP_SETFAIL(RHeap::ENone, 0);

 		return;

 		}

 	__UHEAP_SETFAIL(RHeap::ENone, 0);

 	StopTest(EPass);

 	}