diff -r 000000000000 -r 40261b775718 mmhais/dvbhunittest/hai/dvbh/src/dvbhhaiasynctest.cpp --- /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 + +/** +* 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 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 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(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 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 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(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); + } + + + + + + +