--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmhais/dvbhunittest/hai/dvbh/src/dvbhhaiasynctest.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,895 @@
+// 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);
+ }
+
+
+
+
+
+
+