--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmhais/dvbhunittest/hai/dvbh/src/dvbhhaitest.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,2196 @@
+// 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 "dvbhhaitest.h"
+#include "dvbhhaitestutil.h"
+#include <mobiletv/hai/dvbh/dvbhtypes.h>
+
+/**
+* RDvbhHaiTest 
+*	DVB-H HAI Unit Tests on stub implementations
+*/
+		
+RDvbhHaiTest* RDvbhHaiTest::NewL(TBool aRequireReceiverInfo, const TDesC& aTestName)
+	{
+	RDvbhHaiTest* self = new (ELeave) RDvbhHaiTest(aRequireReceiverInfo, aTestName);
+	return self;	
+	}
+	
+RDvbhHaiTest::RDvbhHaiTest(TBool aRequireReceiverInfo, const TDesC& aTestName)
+: RTestStep(), iDvbhTestDriverVersion(1, 2, 3), iDvbhTestTime(TDateTime(2007, EJuly, 30, 16, 35, 22, 18)),
+  iDvbhTestPerformanceData(), iDvbhTestScanConfiguration(), iDvbhTestPlatform(), iDvbhTestHardwareInfo(),
+  iDvbhTestNetwork(), iDvbhTestNetworkTime(), iDvbhTestScanResult(), iRequireReceiverInfo(aRequireReceiverInfo),
+  iRxInfo(NULL), iTestUtils(NULL), iReceiverType(EDvbhReceiverBluetooth)
+	{
+	iTestStepName.Copy(aTestName);
+	SetupParameterData();
+	}
+
+void RDvbhHaiTest::SetupParameterData()
+	{
+	// The members initialised here should be treated as constants
+	// and not changed.
+	iDvbhTestPerformanceData.iFilterCount = 1;
+	iDvbhTestPerformanceData.iMaxFilters = 2;
+	iDvbhTestPerformanceData.iDataCount = 3;
+	iDvbhTestPerformanceData.iWriteCount = 4;
+	iDvbhTestPerformanceData.iWriteCommandCount = 5;
+	iDvbhTestPerformanceData.iReadCount = 6;
+	iDvbhTestPerformanceData.iReadCommandCount = 7;
+	
+	iDvbhTestScanConfiguration.iScanStartFrequency = 100;
+	iDvbhTestScanConfiguration.iScanEndFrequency = 200;
+	iDvbhTestScanConfiguration.iSignalBandwidth = 10;
+	iDvbhTestScanConfiguration.iScanOptions = EDvbhScanOptionFullScan;
+
+	iDvbhTestPlatform.iPlatform.iId = KInitialPlatformId;
+	iDvbhTestPlatform.iPlatform.iName = KInitialPlatformName;
+	iDvbhTestPlatform.iEsgRoot = KDvbhTestIpV6Addr;
+	
+	iDvbhTestHardwareInfo = KDvbhTestHardwareInfo;
+	
+	iDvbhTestNetworkTime.iNetworkTime = iDvbhTestTime;
+	iDvbhTestNetworkTime.iTerminalTimeStamp = KDvbhTestTerminalTimeStamp;
+	iDvbhTestNetworkTime.iPlatformId = KInitialPlatformId;
+	}
+
+void RDvbhHaiTest::InfoPrintf3(const TDesC16& aString, TInt aInt1, TInt aInt2)
+	{
+	INFO_PRINTF3(aString, aInt1, aInt2);
+	}
+
+void RDvbhHaiTest::InfoPrintf4(const TDesC16& aString, TInt aInt1, TInt aInt2, TInt aInt3)
+	{
+	INFO_PRINTF4(aString, aInt1, aInt2, aInt3);
+	}
+		
+TVerdict RDvbhHaiTest::DoTestStepPreambleL()
+	{
+	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-101")) == 0)		
+		{
+		result = iTestUtils->DefineAllDvbhProperties();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-103")) == 0)	
+		{
+		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateInactive);
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-104")) == 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-105")) == 0)		
+		{
+		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.
+		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);
+		if (result == KErrNone)
+			{
+			TPckg<TDvbhPlatformProperty> initialPlatformPckg(iDvbhTestPlatform);
+			result = iTestUtils->DefineDvbhProperty(EDvbhPropertyKeyPlatform, CDvbhTestUtil::GetType(EDvbhPropertyKeyPlatform), initialPlatformPckg);			
+			}
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-106")) == 0)		
+		{
+		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.
+		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);
+		if (result == KErrNone)
+			{
+			TPckg<TDvbhNetworkTime> initialTimePckg(iDvbhTestNetworkTime);
+			result = iTestUtils->DefineDvbhProperty(EDvbhPropertyKeyNetworkTime, CDvbhTestUtil::GetType(EDvbhPropertyKeyNetworkTime), initialTimePckg);			
+			}		
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-107")) == 0)		
+		{
+		 // Receiver state must be EDvbhStateReady or EDvbhStateReceiving before we can do this test.
+		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReady);
+		if (result == KErrNone)
+			{
+			TPckg<TDvbhPerformanceData> initialDataPckg(iDvbhTestPerformanceData);
+			result = iTestUtils->DefineDvbhProperty(EDvbhPropertyKeyPerformanceData, CDvbhTestUtil::GetType(EDvbhPropertyKeyPerformanceData), initialDataPckg);			
+			}		
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-108")) == 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-109")) == 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-110")) == 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-309")) == 0)		
+		{
+		 // Receiver state must be EDvbhStateReceiving before we can do this test.
+		result = iTestUtils->DefineDvbhStateProperty(EDvbhStateReceiving);
+		}
+
+	return (result == KErrNone ? EPass : EInconclusive);				
+	}
+	
+TVerdict RDvbhHaiTest::DoTestStepPostambleL()
+	{
+	delete iRxInfo;
+	iRxInfo = NULL;
+	
+	TInt result = KErrNone;
+	if (iTestStepName.Compare(_L("MM-TV-DVBH-U-101")) == 0)		
+		{
+		result = iTestUtils->DeleteAllDvbhProperties();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-103")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-104")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeySignalQuality);
+		result = result2 != KErrNone ? result2 : result; 		
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-105")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyPlatform);
+		result = result2 != KErrNone ? result2 : result;			
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-106")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyNetworkTime);
+		result = result2 != KErrNone ? result2 : result;					
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-107")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyPerformanceData);
+		result = result2 != KErrNone ? result2 : result;			
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-108")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState);
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyFrequency);	
+		result = result2 != KErrNone ? result2 : result;		
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-109")) == 0)		
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState );
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyCellId);
+		result = result2 != KErrNone ? result2 : result;			
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-110")) == 0)	
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState );
+		TInt result2 = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyNetworkId);
+		result = result2 != KErrNone ? result2 : result;			
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-309")) == 0)	
+		{
+		result = iTestUtils->DeleteDvbhProperty(EDvbhPropertyKeyState );			
+		}
+		
+	delete iTestUtils;
+	iTestUtils = NULL;
+	return (result == KErrNone ? EPass : EInconclusive);
+	}
+	
+TVerdict RDvbhHaiTest::DoTestStepL()
+	{
+	if(iTestStepName.Compare(_L("MM-TV-DVBH-U-001")) == 0)
+		{
+		return DoCreateReceiverOnStackTestStep();
+		}
+	else if(iTestStepName.Compare(_L("MM-TV-DVBH-U-002")) == 0)		
+		{
+		return DoCreateReceiverOnHeapTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-003")) == 0)		
+		{
+		return DoGetDriverVersionBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-004")) == 0)		
+		{
+		return DoReceiverOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-005")) == 0)		
+		{
+		return DoMultipleReceiverOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-006")) == 0)		
+		{
+		return DoGetDriverVersionAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-007")) == 0)		
+		{
+		return DoPowerOnAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-008")) == 0)		
+		{
+		return DoSetScanConfigurationAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-009")) == 0)		
+		{
+		return DoGetScanConfigurationAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-010")) == 0)		
+		{
+		return DoGetDvbhVersionAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-011")) == 0)		
+		{
+		return DoGetHardwareInfoAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-012")) == 0)		
+		{
+		return DoScanAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-013")) == 0)		
+		{
+		return DoSetPlatformAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-014")) == 0)		
+		{
+		return DoCreateFilterAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-015")) == 0)		
+		{
+		return DoCancelFilterAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-016")) == 0)		
+		{
+		return DoReceiveIpDataAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-017")) == 0)		
+		{
+		return DoUpdateNetworkTimeAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-018")) == 0)		
+		{
+		return DoCustomAsyncAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-019")) == 0)		
+		{
+		return DoCancelCustomAsyncAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-020")) == 0)		
+		{
+		return DoCustomAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-022")) == 0)		
+		{
+		return DoPowerOffAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-023")) == 0)		
+		{
+		return DoSetDisabledAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-024")) == 0)		
+		{
+		return DoCancelScanAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-025")) == 0)		
+		{
+		return DoCancelSetPlatformAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-026")) == 0)		
+		{
+		return DoCancelReceiveIpDataAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-027")) == 0)		
+		{
+		return DoCancelUpdateNetworkTimeAfterOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-101")) == 0)		
+		{
+		return DoCreateReceiverInfoTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-102")) == 0)		
+		{
+		return DoCreateReceiverInfoTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-103")) == 0)		
+		{
+		return DoGetStateTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-104")) == 0)		
+		{
+		return DoGetSignalQualityTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-105")) == 0)		
+		{
+		return DoGetPlatformTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-106")) == 0)		
+		{
+		return DoGetNetworkTimeTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-107")) == 0)		
+		{
+		return DoGetPerformanceDataTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-108")) == 0)		
+		{
+		return DoGetFrequencyTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-109")) == 0)		
+		{
+		return DoGetCellIdTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-110")) == 0)		
+		{
+		return DoGetNetworkIdTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-202")) == 0)		
+		{
+		return DoPowerOnBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-203")) == 0)		
+		{
+		return DoSetScanConfigurationBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-204")) == 0)		
+		{
+		return DoGetScanConfigurationBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-205")) == 0)		
+		{
+		return DoGetDvbhVersionBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-206")) == 0)		
+		{
+		return DoGetHardwareInfoBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-207")) == 0)		
+		{
+		return DoScanBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-208")) == 0)		
+		{
+		return DoSetPlatformBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-209")) == 0)		
+		{
+		return DoCreateFilterBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-210")) == 0)		
+		{
+		return DoCancelFilterBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-211")) == 0)		
+		{
+		return DoReceiveIpDataBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-212")) == 0)		
+		{
+		return DoUpdateNetworkTimeBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-213")) == 0)		
+		{
+		return DoCustomAsyncBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-214")) == 0)		
+		{
+		return DoCancelCustomAsyncBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-215")) == 0)		
+		{
+		return DoCustomBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-216")) == 0)		
+		{
+		return DoCloseBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-217")) == 0)		
+		{
+		return DoPowerOffBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-218")) == 0)		
+		{
+		return DoSetDisabledBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-219")) == 0)		
+		{
+		return DoCancelScanBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-220")) == 0)		
+		{
+		return DoCancelSetPlatformBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-221")) == 0)		
+		{
+		return DoCancelReceiveIpDataBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-222")) == 0)		
+		{
+		return DoCancelUpdateNetworkTimeBeforeOpenTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-301")) == 0)		
+		{
+		return DoGetStateNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-302")) == 0)		
+		{
+		return DoGetSignalQualityNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-303")) == 0)		
+		{
+		return DoGetPlatformNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-304")) == 0)		
+		{
+		return DoGetNetworkTimeNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-305")) == 0)		
+		{
+		return DoGetPerformanceDataNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-306")) == 0)		
+		{
+		return DoGetFrequencyNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-307")) == 0)		
+		{
+		return DoGetCellIdNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-308")) == 0)		
+		{
+		return DoGetNetworkIdNoPropertiesTestStep();
+		}
+	else if	(iTestStepName.Compare(_L("MM-TV-DVBH-U-309")) == 0)		
+		{
+		return DoGetTestsNoProperties();
+		}
+		
+	return EInconclusive;
+	}
+
+TVerdict RDvbhHaiTest::DoCreateReceiverOnStackTestStep()
+	{
+	__MM_HEAP_MARK;
+		{
+		//Create RDvbhReceiver on stack
+		RDvbhReceiver receiver;
+		}
+	//RDvbhReceiver out-of-scope, verify no heap leaks
+	__MM_HEAP_MARKEND;
+	return EPass;
+	}
+	
+TVerdict RDvbhHaiTest::DoCreateReceiverOnHeapTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+	
+	RDvbhReceiver* receiver = new RDvbhReceiver;
+	if (receiver == NULL)
+		{
+		verdict = EInconclusive;
+		}
+	else
+		{
+		delete receiver;
+		receiver = NULL;
+		}
+
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+
+TVerdict RDvbhHaiTest::DoGetDriverVersion(RDvbhReceiver& aReceiver)
+	{
+	TVerdict verdict = EPass;
+	TVersion version = iDvbhTestDriverVersion;
+	
+	TInt result = aReceiver.GetDriverVersion(version);
+	if (result != KErrNotSupported)
+		{
+		INFO_PRINTF2(_L("RDvbhReceiver::GetDriverVersion returned %d"), result);
+		verdict = EFail;
+		}
+	else if (!CDvbhTestUtil::CompareVersions(version, iDvbhTestDriverVersion))
+		{
+		INFO_PRINTF1(_L("RDvbhReceiver::GetDriverVersion modified its arguments."));
+		verdict = EFail;
+		}
+	return verdict;	
+	}
+	
+TVerdict RDvbhHaiTest::DoGetDriverVersionBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		verdict = DoGetDriverVersion(receiver);
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+/**
+* @param aMultiples the number of times to call open on a single RDvbhReceiver instance.  Must be greater than 0.
+*
+* Creates a RDvbhReceiver instance, calls Open aMultiples of times on it, then Closes it.
+*/
+TVerdict RDvbhHaiTest::DoReceiverOpenAndClose(TUint aMultiples)
+	{
+	TVerdict verdict = EPass;
+	RDvbhReceiver receiver;
+	
+	if (aMultiples == 0)
+		{
+		verdict = EInconclusive;
+		}
+	else
+		{
+		for (TUint i=0;i < aMultiples;++i)
+			{
+			TVerdict openVerdict = OpenReceiver(receiver);
+			verdict = (openVerdict == EPass) ? verdict : openVerdict;
+			}
+		}
+	receiver.Close();
+	return verdict;
+	}
+
+/**
+* Helper used to open a receiver before testing other methods.  
+* @return EInconclusive if the Open call did not behave as expected so it shouldn't be used to test the Open() method itself.
+*/	
+TVerdict RDvbhHaiTest::OpenReceiver(RDvbhReceiver& aReceiver)
+	{
+	TVerdict verdict = EPass;
+	TInt result = aReceiver.Open(iReceiverType);
+	if (result != KErrNotSupported)
+		{
+		INFO_PRINTF2(_L("RDvbhReceiver::Open returned %d"), result);
+		verdict = EInconclusive;
+		}
+	return verdict;	
+	}
+
+TVerdict RDvbhHaiTest::DoReceiverOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = DoReceiverOpenAndClose();
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+
+TVerdict RDvbhHaiTest::DoMultipleReceiverOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = DoReceiverOpenAndClose(3);
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoGetDriverVersionAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;	
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			verdict = DoGetDriverVersion(receiver);
+			receiver.Close();
+			}
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+
+TVerdict RDvbhHaiTest::DoPowerOnAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;	
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TRequestStatus status;
+			TInt result = receiver.PowerOn(status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::PowerOn returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoSetScanConfigurationAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TInt result = receiver.SetScanConfiguration(iDvbhTestScanConfiguration);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::SetScanConfiguration returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoGetScanConfigurationAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TDvbhScanConfiguration scanConfig;
+			scanConfig.iScanStartFrequency = iDvbhTestScanConfiguration.iScanStartFrequency;
+			scanConfig.iScanEndFrequency = iDvbhTestScanConfiguration.iScanEndFrequency;
+			scanConfig.iSignalBandwidth = iDvbhTestScanConfiguration.iSignalBandwidth;
+			scanConfig.iScanOptions = iDvbhTestScanConfiguration.iScanOptions;
+	
+			TInt result = receiver.GetScanConfiguration(scanConfig);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::GetScanConfiguration returned %d"), result);
+				verdict = EFail;
+				}
+			else
+				{
+				if (!CDvbhTestUtil::CompareScanConfigurations(scanConfig, iDvbhTestScanConfiguration))
+					{
+					INFO_PRINTF1(_L("RDvbhReceiver::GetScanConfiguration modified its arguments."));
+					verdict = EFail;					
+					}
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoGetDvbhVersionAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TVersion version = iDvbhTestDriverVersion;
+			TInt result = receiver.GetDvbhVersion(version);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::GetDvbhVersion returned %d"), result);
+				verdict = EFail;
+				}
+			else
+				{
+				if (!CDvbhTestUtil::CompareVersions(version, iDvbhTestDriverVersion))
+					{
+					INFO_PRINTF1(_L("RDvbhReceiver::GetDvbhVersion modified its arguments."));
+					verdict = EFail;					
+					}
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoGetHardwareInfoAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TDvbhHardwareInfo info = iDvbhTestHardwareInfo;
+			TInt result = receiver.GetHardwareInfo(info);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::GetHardwareInfo returned %d"), result);
+				verdict = EFail;
+				}
+			else
+				{
+				if (info.Compare(iDvbhTestHardwareInfo) != 0) // Compare returns 0 if they are the same
+					{
+					INFO_PRINTF1(_L("RDvbhReceiver::GetHardwareInfo modified its arguments."));
+					verdict = EFail;					
+					}
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoScanAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TRequestStatus status;
+			TInt result = receiver.Scan(*this, status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::Scan returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoSetPlatformAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TRequestStatus status;
+			TInt result = receiver.SetPlatform(iDvbhTestNetwork, iDvbhTestPlatform.iPlatform, status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::SetPlatform returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCreateFilterAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TInt filterId = KDvbhTestFilterId;
+			TRequestStatus status;
+			TInt result = receiver.CreateFilter(KDvbhTestIpV6Addr, filterId, status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::CreateFilter returned %d"), result);
+				verdict = EFail;
+				}
+			else
+				{
+				if (filterId != KDvbhTestFilterId)
+					{
+					INFO_PRINTF1(_L("RDvbhReceiver::CreateFilter modified its arguments."));
+					verdict = EFail;					
+					}
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelFilterAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TInt filterId = KDvbhTestFilterId;
+			TInt result = receiver.CancelFilter(filterId);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::CancelFilter returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoReceiveIpDataAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TInt result = receiver.ReceiveIPData(*this);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::ReceiveIPData returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoUpdateNetworkTimeAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TRequestStatus status;
+			TInt result = receiver.UpdateNetworkTime(status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::UpdateNetworkTime returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCustomAsyncAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TBuf8<32> output;
+			output = KDvbhTestCustomCommandOutput;
+			TRequestStatus status;
+			TInt result = receiver.CustomCommand(KDvbhTestCustomCommand, KDvbhTestCustomCommandInput, output, status);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::CustomCommand returned %d"), result);
+				verdict = EFail;
+				}
+			else
+				{
+				if (output.Compare(KDvbhTestCustomCommandOutput) != 0) // Compare returns 0 if they are the same
+					{
+					INFO_PRINTF1(_L("RDvbhReceiver::CustomCommand modified its arguments."));
+					verdict = EFail;					
+					}
+				}
+			receiver.Close();
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelCustomAsyncAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TRequestStatus status;
+			receiver.CancelCustomCommand(status);
+			receiver.Close();
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCustomAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			TInt result = receiver.CustomCommand(KDvbhTestCustomCommand, KDvbhTestCustomCommandInput);
+			if (result != KErrNotSupported)
+				{
+				INFO_PRINTF2(_L("RDvbhReceiver::CustomCommand returned %d"), result);
+				verdict = EFail;
+				}
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+		
+TVerdict RDvbhHaiTest::DoPowerOffAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+            TRequestStatus status;
+			receiver.PowerOff(status);
+			//User::WaitForRequest(status);
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoSetDisabledAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+            TRequestStatus status;
+			receiver.SetDisabled(ETrue, status);
+            //User::WaitForRequest(status);
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelScanAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			receiver.CancelScan();
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelSetPlatformAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			receiver.CancelSetPlatform();
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelReceiveIpDataAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			receiver.CancelReceiveIPData();
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+TVerdict RDvbhHaiTest::DoCancelUpdateNetworkTimeAfterOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		if ((verdict = OpenReceiver(receiver))  == EPass)
+			{
+			receiver.CancelUpdateNetworkTime();
+			receiver.Close();
+			}	
+		} //end of receiver's scope
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+//
+//
+// CDvbhReceiverInfo Positive Tests
+//
+//
+
+// 101 & 102
+TVerdict RDvbhHaiTest::DoCreateReceiverInfoTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	delete iRxInfo; 
+	iRxInfo = NULL;
+	TRAPD(result, iRxInfo = CDvbhReceiverInfo::NewL())
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d creating CDvbhReceiverInfo"), result);
+		verdict = EFail;
+		}
+	delete iRxInfo; 
+	iRxInfo = NULL;
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+// 103
+TVerdict RDvbhHaiTest::DoGetStateTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the state to a known value (expectedState) so that we know 
+ 	//what we are trying to Get.
+ 	const TInt expectedState = EDvbhStateInactive;
+	if (iTestUtils->SetStateProperty(expectedState) != KErrNone)
+		{
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhState state = EDvbhStateNoHardware;
+		TInt result = iRxInfo->GetState(state);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting state"), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (state != expectedState)
+				{
+				INFO_PRINTF2(_L("Got unexpected state %d"), state);
+				verdict = EFail;
+				}
+			}
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+// 104
+TVerdict RDvbhHaiTest::DoGetSignalQualityTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the signal quality to a known value (expectedQuality) so that we know 
+ 	//what we are trying to Get.
+	const TInt expectedQuality = EDvbhSignalQualityFair;
+	TInt result = iTestUtils->SetIntegerProperty(EDvbhPropertyKeySignalQuality, expectedQuality);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF3(_L("Error %d setting signal quality property to %d"), result, expectedQuality);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhSignalQuality quality = EDvbhSignalQualityNoSignal;
+		result = iRxInfo->GetSignalQuality(quality);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting signal quality"), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (quality != expectedQuality)
+				{
+				INFO_PRINTF2(_L("Got unexpected quality %d"), quality);
+				verdict = EFail;
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+// 105	
+TVerdict RDvbhHaiTest::DoGetPlatformTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the platform property to a known value (iDvbhTestPlatform) so that we know 
+ 	//what we are trying to Get.
+	TPckg<TDvbhPlatformProperty> platformPckg(iDvbhTestPlatform);
+	TInt result = iTestUtils->SetByteArrayProperty(EDvbhPropertyKeyPlatform, platformPckg);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting platform property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhPlatform platform;
+		TIp6Addr esgRoot;
+		result = iRxInfo->GetPlatform(platform, esgRoot);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting platform."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (!CDvbhTestUtil::ComparePlatforms(platform, iDvbhTestPlatform.iPlatform))
+				{
+				INFO_PRINTF1(_L("Got unexpected platform."));
+				verdict = EFail;
+				}
+			if (!esgRoot.IsEqual(iDvbhTestPlatform.iEsgRoot))
+				{
+				INFO_PRINTF1(_L("Got unexpected esgRoot."));
+				verdict = EFail;				
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+//Helper for test 106
+TVerdict RDvbhHaiTest::DoGetNetworkTime(TBool aExpectedValidity)
+	{
+	TVerdict verdict = EPass;
+
+	//Expected result is based on whether or not the platformId in the network time we
+	//set is valid.
+ 	TInt expectedResult = KErrNone;
+ 	if (iDvbhTestNetworkTime.iPlatformId == KDvbhInvalidPlatform)
+ 		{
+ 		expectedResult = KErrNotReady;
+ 		}
+ 	
+ 	//Set the time to a known value (iDvbhTestNetworkTime) so that we know 
+ 	//what we are trying to Get.
+	TPckg<TDvbhNetworkTime> timePckg(iDvbhTestNetworkTime);	
+	TInt result = iTestUtils->SetByteArrayProperty(EDvbhPropertyKeyNetworkTime, timePckg);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting network time property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TTime initialTime(TInt64(0));
+		TTime time = initialTime;
+		TBool valid = EFalse;
+		result = iRxInfo->GetNetworkTime(time, valid);
+		if (result != expectedResult)
+			{
+			INFO_PRINTF2(_L("Unexptected result %d getting network time."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (result == KErrNone)
+				{
+				//Check if what we got was as expected
+				if (time != iDvbhTestNetworkTime.iNetworkTime || (valid != aExpectedValidity))
+					{
+					INFO_PRINTF1(_L("Got unexpected network time or validity."));
+					verdict = EFail;
+					}				
+				}
+			else
+				{
+				//Check that the arguments weren't updated
+				if (time != initialTime || (valid != EFalse))
+					{
+					INFO_PRINTF1(_L("GetNetworkTime modified its args on failure."));
+					verdict = EFail;
+					}
+				}
+			}				
+		}
+	return verdict;
+	}
+
+// 106
+TVerdict RDvbhHaiTest::DoGetNetworkTimeTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+
+	//The 1st two tests are positive tests, so we do not want to get KErrNotReady
+	//so we leave iDvbhTestNetworkTime.iPlatformId != KDvbhInvalidPlatform
+	//(which is how it is set by default).
+	
+	//Test one: Set state to Receiving or Ready so that we expect a valid network time
+	TDvbhState state = EDvbhStateReady;
+	TInt result = iTestUtils->SetStateProperty(state);
+	if (result != KErrNone)
+		{
+		verdict =  EInconclusive;
+		}
+	else
+		{
+		verdict = DoGetNetworkTime((state == EDvbhStateReady) || (state == EDvbhStateReceiving));
+		}
+	
+	if (verdict != EPass)
+		{
+		__MM_HEAP_MARKEND;
+		return verdict;		
+		}
+		
+	//Test two: Set state to something other than Ready or Receiving so we expect
+	//and invalid network time
+	state = EDvbhStateScanning;
+	result = iTestUtils->SetStateProperty(state);
+	if (result != KErrNone)
+		{
+		verdict =  EInconclusive;
+		}
+	else
+		{
+		verdict = DoGetNetworkTime((state == EDvbhStateReady) || (state == EDvbhStateReceiving));
+		}
+	
+	if (verdict != EPass)
+		{
+		__MM_HEAP_MARKEND;
+		return verdict;		
+		}
+		
+	//Test three: Set iDvbhTestNetworkTime.iPlatformId = KDvbhInvalidPlatform
+	//which indicates the receiver is not ready to give network time, regardless
+	//of the state it is in.  Will result in KErrNotReady being returned from
+	//CDvbhReceiverInfo::GetNetworkTime()
+	iDvbhTestNetworkTime.iPlatformId = KDvbhInvalidPlatform;
+	verdict = DoGetNetworkTime((state == EDvbhStateReady) || (state == EDvbhStateReceiving));
+			
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+// 107 
+TVerdict RDvbhHaiTest::DoGetPerformanceDataTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the data to a known value (expectedData) so that we know 
+ 	//what we are trying to Get.
+	TPckg<TDvbhPerformanceData> dataPckg(iDvbhTestPerformanceData);	
+	TInt result = iTestUtils->SetByteArrayProperty(EDvbhPropertyKeyPerformanceData, dataPckg);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting performance data property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhPerformanceData data; //Is initialised to 0s by constructor.
+		result = iRxInfo->GetPerformanceData(data);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting performance data."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (!CDvbhTestUtil::ComparePerformanceDatas(data, iDvbhTestPerformanceData))
+				{
+				INFO_PRINTF1(_L("Got unexpected performance data."));
+				verdict = EFail;
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+// 108
+TVerdict RDvbhHaiTest::DoGetFrequencyTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the data to a known value (expectedFrequency) so that we know 
+ 	//what we are trying to Get.
+	const TDvbhFrequency expectedFrequency = 150000;	
+	TInt result = iTestUtils->SetIntegerProperty(EDvbhPropertyKeyFrequency, expectedFrequency);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting frequency property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhFrequency frequency = 0;
+		result = iRxInfo->GetFrequency(frequency);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting frequency."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (frequency != expectedFrequency)
+				{
+				INFO_PRINTF2(_L("Got unexpected frequency %d."), frequency);
+				verdict = EFail;
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+// 109
+TVerdict RDvbhHaiTest::DoGetCellIdTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the data to a known value (expectedId) so that we know 
+ 	//what we are trying to Get.
+	const TDvbhCellId expectedId = 1001;	
+	TInt result = iTestUtils->SetIntegerProperty(EDvbhPropertyKeyCellId , expectedId);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting cellId property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhCellId id = 0;
+		result = iRxInfo->GetCellId(id);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting cellId."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (id != expectedId)
+				{
+				INFO_PRINTF2(_L("Got unexpected cellId %d."), id);
+				verdict = EFail;
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+// 110
+TVerdict RDvbhHaiTest::DoGetNetworkIdTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+ 	//First set the data to a known value (expectedId) so that we know 
+ 	//what we are trying to Get.
+	const TDvbhNetworkId expectedId = 9876;	
+	TInt result = iTestUtils->SetIntegerProperty(EDvbhPropertyKeyNetworkId , expectedId);
+	if (result != KErrNone)
+		{
+		INFO_PRINTF2(_L("Error %d setting networkId property."), result);
+		verdict = EInconclusive;			
+		}
+	else
+		{
+		TDvbhNetworkId id = 0;
+		result = iRxInfo->GetNetworkId(id);
+		if (result != KErrNone)
+			{
+			INFO_PRINTF2(_L("Error %d getting networkId."), result);
+			verdict = EFail;				
+			}
+		else
+			{
+			if (id != expectedId)
+				{
+				INFO_PRINTF2(_L("Got unexpected networkId %d."), id);
+				verdict = EFail;
+				}
+			}				
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+	
+//
+//
+// RDvbhReceiver negative tests
+//
+//
+	
+//202
+TVerdict RDvbhHaiTest::DoPowerOnBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+        TRequestStatus status;
+		TInt result = receiver.PowerOn(status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::PowerOn returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+//203
+TVerdict RDvbhHaiTest::DoSetScanConfigurationBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TInt result = receiver.SetScanConfiguration(iDvbhTestScanConfiguration);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::SetScanConfiguration returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//204
+TVerdict RDvbhHaiTest::DoGetScanConfigurationBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TDvbhScanConfiguration config;
+		config.iScanStartFrequency = iDvbhTestScanConfiguration.iScanStartFrequency;
+		config.iScanEndFrequency = iDvbhTestScanConfiguration.iScanEndFrequency;
+		config.iSignalBandwidth = iDvbhTestScanConfiguration.iSignalBandwidth;
+		config.iScanOptions = iDvbhTestScanConfiguration.iScanOptions;
+		
+		TInt result = receiver.GetScanConfiguration(config);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::GetScanConfiguration returned %d"), result);
+			verdict = EFail;
+			}
+		else
+			{
+			if (!iTestUtils->CompareScanConfigurations(iDvbhTestScanConfiguration, config))
+				{
+				INFO_PRINTF1(_L("RDvbhReceiver::GetScanConfiguration modified its arg on failure."));
+				verdict = EFail;			
+				}			
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//205
+TVerdict RDvbhHaiTest::DoGetDvbhVersionBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TVersion version = iDvbhTestDriverVersion;
+		
+		TInt result = receiver.GetDvbhVersion(version);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::GetDvbhVersion returned %d"), result);
+			verdict = EFail;
+			}
+		else
+			{
+			if (!iTestUtils->CompareVersions(version, iDvbhTestDriverVersion))
+				{
+				INFO_PRINTF1(_L("RDvbhReceiver::GetDvbhVersion modified its arg on failure."));
+				verdict = EFail;			
+				}			
+			}
+
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//206
+TVerdict RDvbhHaiTest::DoGetHardwareInfoBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TDvbhHardwareInfo info = iDvbhTestHardwareInfo;
+		
+		TInt result = receiver.GetHardwareInfo(info);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::GetHardwareInfo returned %d"), result);
+			verdict = EFail;
+			}
+		else
+			{
+			if (info.Compare(iDvbhTestHardwareInfo) != 0) // Compare returns 0 if they are the same
+				{
+				INFO_PRINTF1(_L("RDvbhReceiver::GetHardwareInfo modified its arg on failure."));
+				verdict = EFail;			
+				}			
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+//207	
+TVerdict RDvbhHaiTest::DoScanBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TRequestStatus status;
+		TInt result = receiver.Scan(*this, status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::Scan returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//208
+TVerdict RDvbhHaiTest::DoSetPlatformBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TRequestStatus status;
+		TInt result = receiver.SetPlatform(iDvbhTestNetwork, iDvbhTestPlatform.iPlatform, status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::SetPlatform returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//209
+TVerdict RDvbhHaiTest::DoCreateFilterBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TInt filterId = 100;
+		TInt origFilterId = filterId;
+		TRequestStatus status;
+		TInt result = receiver.CreateFilter(KDvbhTestIpV6Addr, filterId, status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::CreateFilter returned %d"), result);
+			verdict = EFail;
+			}
+		else
+			{
+			if (filterId != origFilterId)
+				{
+				INFO_PRINTF1(_L("RDvbhReceiver::CreateFilter modified its arg on failure."));
+				verdict = EFail;			
+				}			
+			}			
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//210
+TVerdict RDvbhHaiTest::DoCancelFilterBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TInt filterId = 7;
+		TInt result = receiver.CancelFilter(filterId);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::CancelFilter returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//211
+TVerdict RDvbhHaiTest::DoReceiveIpDataBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TInt result = receiver.ReceiveIPData(*this);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::ReceiveIPData returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//212
+TVerdict RDvbhHaiTest::DoUpdateNetworkTimeBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TRequestStatus status;
+		TInt result = receiver.UpdateNetworkTime(status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::UpdateNetworkTime returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//213
+TVerdict RDvbhHaiTest::DoCustomAsyncBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TBuf8<32> output = _L8("Output");
+		TBuf8<32> origOutput = output;
+		TRequestStatus status;
+		TInt result = receiver.CustomCommand(KDvbhTestCustomCommand, KDvbhTestCustomCommandInput, output, status);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::CustomCommand returned %d"), result);
+			verdict = EFail;
+			}
+		else
+			{
+			if (output.Compare(origOutput) != 0) //Compare returns 0 if they are the same
+				{
+				INFO_PRINTF1(_L("RDvbhReceiver::CustomCommand modified its arg on failure."));
+				verdict = EFail;			
+				}			
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;		
+	}
+	
+//214
+TVerdict RDvbhHaiTest::DoCancelCustomAsyncBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TRequestStatus status;
+		receiver.CancelCustomCommand(status);
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//215
+TVerdict RDvbhHaiTest::DoCustomBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		TInt result = receiver.CustomCommand(KDvbhTestCustomCommand, KDvbhTestCustomCommandInput);
+		if (result != KErrNotReady)
+			{
+			INFO_PRINTF2(_L("RDvbhReceiver::CustomCommand returned %d"), result);
+			verdict = EFail;
+			}
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//216
+TVerdict RDvbhHaiTest::DoCloseBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		receiver.Close();
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;		
+	}
+
+//217
+TVerdict RDvbhHaiTest::DoPowerOffBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+        TRequestStatus status;
+		receiver.PowerOff(status);
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//218
+TVerdict RDvbhHaiTest::DoSetDisabledBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+        TRequestStatus status;
+		receiver.SetDisabled(ETrue, status);
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//219
+TVerdict RDvbhHaiTest::DoCancelScanBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		receiver.CancelScan();
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//220
+TVerdict RDvbhHaiTest::DoCancelSetPlatformBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		receiver.CancelSetPlatform();
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//221
+TVerdict RDvbhHaiTest::DoCancelReceiveIpDataBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		receiver.CancelReceiveIPData();
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//222
+TVerdict RDvbhHaiTest::DoCancelUpdateNetworkTimeBeforeOpenTestStep()
+	{
+	__MM_HEAP_MARK;
+	TVerdict verdict = EPass;
+		{
+		RDvbhReceiver receiver;
+		receiver.CancelUpdateNetworkTime();
+		} //end of receiver's scope	
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+	
+						
+// 301	
+TVerdict RDvbhHaiTest::DoGetStateNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhState state = EDvbhStateReady;
+	TInt result = iRxInfo->GetState(state);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting state but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (state != EDvbhStateReady)
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetState modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;
+	}
+
+//302	
+TVerdict RDvbhHaiTest::DoGetSignalQualityNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhSignalQuality quality = EDvbhSignalQualityVeryGood;
+	TInt result = iRxInfo->GetSignalQuality(quality);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting signal quality but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (quality != EDvbhSignalQualityVeryGood)
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetSignalQuality modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//303	
+TVerdict RDvbhHaiTest::DoGetPlatformNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhPlatform platform;
+	platform.iId = iDvbhTestPlatform.iPlatform.iId;
+	platform.iName = iDvbhTestPlatform.iPlatform.iName;
+	
+	TIp6Addr esgRoot = iDvbhTestPlatform.iEsgRoot;
+
+	TInt result = iRxInfo->GetPlatform(platform, esgRoot);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting platform but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (!CDvbhTestUtil::ComparePlatforms(platform, iDvbhTestPlatform.iPlatform)  ||
+			!esgRoot.IsEqual(iDvbhTestPlatform.iEsgRoot) )
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetPlatform modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//304	
+TVerdict RDvbhHaiTest::DoGetNetworkTimeNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;	
+	TTime time = iDvbhTestTime;
+	TBool valid = ETrue;
+	
+	TInt result = iRxInfo->GetNetworkTime(time, valid);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting network time but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (time != iDvbhTestTime  || !valid )
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetNetworkTime modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+
+//305	
+TVerdict RDvbhHaiTest::DoGetPerformanceDataNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhPerformanceData data;
+	data.iFilterCount = iDvbhTestPerformanceData.iFilterCount;
+	data.iMaxFilters = iDvbhTestPerformanceData. iMaxFilters;
+	data.iDataCount = iDvbhTestPerformanceData.iDataCount;
+	data.iWriteCount = iDvbhTestPerformanceData.iWriteCount;
+	data.iWriteCommandCount = iDvbhTestPerformanceData.iWriteCommandCount;
+	data.iReadCount = iDvbhTestPerformanceData.iReadCount;
+	data.iReadCommandCount = iDvbhTestPerformanceData.iReadCommandCount;
+	
+	TInt result = iRxInfo->GetPerformanceData(data);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting performance data but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (!CDvbhTestUtil::ComparePerformanceDatas(data, iDvbhTestPerformanceData))
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetPerformaceData modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;		
+	}
+
+//306	
+TVerdict RDvbhHaiTest::DoGetFrequencyNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhFrequency frequency = KInitialFrequency;
+	
+	TInt result = iRxInfo->GetFrequency(frequency);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting frequency but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (frequency != KInitialFrequency)
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetFrequency modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;		
+	}
+
+//307	
+TVerdict RDvbhHaiTest::DoGetCellIdNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhCellId cellId = KInitialCellId;
+	
+	TInt result = iRxInfo->GetCellId(cellId);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting cellId but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (cellId != KInitialCellId)
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetCellId modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+//308
+TVerdict RDvbhHaiTest::DoGetNetworkIdNoPropertiesTestStep()
+	{
+	TVerdict verdict = EPass;
+	__MM_HEAP_MARK;
+	TDvbhNetworkId networkId = KInitialNetworkId;
+	
+	TInt result = iRxInfo->GetNetworkId(networkId);
+	if (result != KErrNotFound)
+		{
+		INFO_PRINTF2(_L("Got error %d getting networkId but expected KErrNotFound"), result);
+		verdict = EFail;				
+		}
+	else
+		{
+		if (networkId != KInitialNetworkId)
+			{
+			INFO_PRINTF1(_L("RDvbhReceiverInfo::GetNetworkId modified its arg on failure."));
+			verdict = EFail;			
+			}			
+		}
+	__MM_HEAP_MARKEND;
+	return verdict;	
+	}
+	
+
+//309
+/**
+* Test added to improve conditional code coverage.  It tries to get all the properties
+* that depend on state when the state property is defined, but no other properties are
+* defined.
+*/
+TVerdict RDvbhHaiTest::DoGetTestsNoProperties()
+	{
+	TVerdict verdict = EPass;
+		
+	//Preamble will have defined the state property and set it to EDvbhStateReceiving.  So
+	//we just have to try to get each (non-defined) property that depends on state.
+
+	//CellId
+	verdict = DoGetCellIdNoPropertiesTestStep();
+	if (verdict != EPass)
+		{
+		return verdict;
+		}
+		
+	//Frequency
+	verdict = DoGetFrequencyNoPropertiesTestStep();
+	if (verdict != EPass)
+		{
+		return verdict;
+		}
+
+	//NetworkId
+	verdict = DoGetNetworkIdNoPropertiesTestStep();
+	if (verdict != EPass)
+		{
+		return verdict;
+		}
+		
+	//Platform
+	verdict = DoGetPlatformNoPropertiesTestStep();
+	if (verdict != EPass)
+		{
+		return verdict;
+		}
+
+	//Signal Quality
+	verdict = DoGetSignalQualityNoPropertiesTestStep();
+	if (verdict != EPass)
+		{
+		return verdict;
+		}
+	
+	return verdict;	
+	}
+	
+//MDvbhScanObserver
+void RDvbhHaiTest::DvbhScanProgress( const TDvbhScanResult& /*aResult*/ )
+	{	
+	//Should never be called
+	ASSERT(EFalse);
+	}
+	
+//MDvbhDataObserver
+void RDvbhHaiTest::DvbhPacketReceived( const TDesC8& /*aPacket*/ )
+	{
+	//Should never be called
+	ASSERT(EFalse);	
+	}
+