--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resourcemgmt/hwresourcesmgr/test/te_hwrm/hwrmtestbase.h Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,488 @@
+// 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:
+//
+
+#ifndef hwrmtestbase_h
+#define hwrmtestbase_h
+
+#include <tefunit.h>
+#include <hwrmvibra.h>
+#include <hwrmlight.h>
+#include <hwrmextendedlight.h>
+#include <hwrmenhancedlight.h>
+#include <hwrmpower.h>
+#include <hwrmfmtx.h>
+#include <rmocklight.h>
+#include <rmockpowerstate.h>
+#include <rmockvibra.h>
+#include <rmockpower.h>
+#include <rmockfmtx.h>
+#include <e32property.h>
+#include <hwrmpowerstatesdkpskeys.h>
+#include "endstatetimer.h"
+#include "pspropertyobserver.h"
+
+const TInt KMaxNoOpenSessionsForResource = 3;
+const TInt KMaxNoStateTransitions = 5;
+
+const TInt KDefaultVibraMinOffTime = 0;
+
+// temp, may need to move but in original test was in main.cpp
+const TUint32 KHWRMTestLightIntensityValue = 0x10000007;
+const TUint32 KHWRMTestLightSensitivityValue = 0x10000008;
+
+
+class CHWRMTestBase : public CTestFixture ,
+ public MHWRMVibraObserver,
+ public MHWRMLightObserver,
+ public MHWRMExtendedLightObserver,
+ public MHWRMBatteryPowerObserver,
+ public MHWRMFmTxObserver,
+ public MTimerExpired,
+ public MPsPropertyObserver,
+ public MHWRMVibraFeedbackObserver
+#ifdef SYMBIAN_HWRM_EXTPOWERINFO
+ ,
+ public MHWRMBatteryChargingStatusObserver,
+ public MHWRMBatteryFullChargingTimeObserver,
+ public MHWRMBatteryChargingCurrentObserver
+#endif //SYMBIAN_HWRM_EXTPOWERINFO
+ {
+public:// from MHWRMVibraObserver
+ virtual void VibraModeChanged(CHWRMVibra::TVibraModeState aStatus);
+ virtual void VibraStatusChanged(CHWRMVibra::TVibraStatus aStatus);
+ // from MHWRMVibraFeedbackObserver
+ virtual void VibraFeedbackModeChanged(CHWRMVibra::TVibraFeedbackModeState aMode);
+
+public: // from MHWRMLightObserver
+ virtual void LightStatusChanged(TInt aTarget, CHWRMLight::TLightStatus aStatus);
+
+public: //from MHWRMExtendedLightObserver
+ virtual void LightStatusChanged(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus);
+
+public: //from MHWRMBatteryPowerObserver
+
+ virtual void PowerMeasurement(TInt aErrorCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement);
+public: //from MHWRMFmTxObserver
+ virtual void FmTxStatusChanged(TFmTxState aState);
+ virtual void FmTxFrequencyChanged(TInt aFrequency);
+
+public: // from MPsPropertyObserver
+ virtual void PsPropertyChanged(TInt aKey, TInt aValue);
+
+public: //from MTimerExpired
+ void EndStateTimerExpired(TInt aError);
+
+#ifdef SYMBIAN_HWRM_EXTPOWERINFO
+public:
+ //from MHWRMBatteryChargingStatusObserver
+ void ChargingStatusChange(TInt aErrorCode, CHWRMPower::TBatteryChargingStatus aChrgStatus);
+ //from MHWRMBatteryFullChargingTimeObserver
+ void BatteryFullChargingTimeChange(TInt aErrorCode, TUint aTime);
+ //from MHWRMBatteryChargingCurrentObserver
+ void AverageChargingCurrentChange(TInt aErrorCode, TInt aMeasurement);
+#endif //SYMBIAN_HWRM_EXTPOWERINFO
+
+public:
+ // SetUp and TearDown code
+ void SetupL();
+ void TearDownL();
+ inline void SetTestFail();
+
+protected: //useful functions
+ template <class T>
+ void AddTestStateL(T* aObject, void (T::*aTestStateFptr)(),TReal aMaxDurationIsSecs);
+
+ void OpenSessionsL(TInt aNoLightSessionsToOpen, TInt aNoVibraSessionsToOpen, TInt aNoExtLightSessionsToOpen = 0, TInt aNoFmTxSessionsToOpen = 0, TInt aNoPowerSessionsToOpen = 0);
+ void OpenPowerStateSessionL();
+ void OpenLightSessionEnhancedL(TInt aNoEnhancedLightSessionsToOpen);
+ inline CHWRMVibra& GetVibraSessionL(TInt aIndex);
+ inline CHWRMLight& GetLightSessionL(TInt aIndex);
+ inline CHWRMExtendedLight& GetExtLightSessionL(TInt aIndex);
+ inline CHWRMEnhancedLight& GetEnhancedLightSessionL(TInt aIndex);
+ inline CHWRMPower& GetPowerSessionL(TInt aIndex);
+ inline CHWRMFmTx& GetFmTxSessionL(TInt aIndex);
+ inline CHWRMVibra& GetVibraSessionWithCallbackRegisteredL();
+ inline CHWRMLight& GetLightSessionWithCallbackRegisteredL();
+ inline CHWRMExtendedLight& GetExtLightSessionWithCallbackRegisteredL();
+ inline CHWRMEnhancedLight& GetEnhancedLightSessionWithCallbackRegisteredL();
+ inline CHWRMPower& GetPowerSessionWithCallbackRegisteredL();
+ inline CHWRMFmTx& GetFmTxSessionWithCallbackRegisteredL();
+
+ void SetCRVibraAttributeL(TUint32 aVibraKey, TInt aValue);
+ TInt SetCRVibraAttribute(TUint32 aVibraKey, TInt aValue);
+ void GetCRVibraAttributeL(TUint32 aVibraKey, TInt& aValue);
+ void GetVibraTimeAttributesL();
+
+ void SetCRLightAttributes(TUint32 aLightKey, TInt aValue);
+ void GetCRLightAttributes(TUint32 aLightKey, TInt &aValue);
+ void SetLightControlAttributes(TInt aIntensity, TInt aSensitivity, TInt aInUse);
+ void GetLightControlAttributes();
+
+ void SetCRPowerAttributeL(TUint32 aVibraKey, TInt aValue);
+ void GetCRPowerAttributeL(TUint32 aVibraKey, TInt &aValue);
+ void GetPowerAttributesL();
+ void SetPowerAttributesMeasurementProcessingTime(TUint aMeasurementProcessingTime);
+
+ void SetCRFmTxAttributeL(TUint32 aVibraKey, TInt aValue);
+ void GetCRFmTxAttributeL(TUint32 aVibraKey, TInt &aValue);
+ void GetFmTxFrequencyStepSizeL();
+ void SetFmTxFrequencyRangeJapanL();
+ void SetFmTxFrequencyRangeEuropeL();
+ void SetFmTxInactivityTimeOutL(TUint aInactivityTimeOut);
+
+ void ResetDefaultsL();
+
+ inline RMockLight& GetMockLight();
+ inline RMockVibra& GetMockVibra();
+
+ inline RMockFmTx& GetMockFmTx();
+
+ inline RMockPowerState& GetMockPowerState();
+ inline RMockPower& GetMockPower();
+
+ void ExpectVibraStatusNotificationL(CHWRMVibra::TVibraStatus aStatus);
+ void ExpectVibraModeNotificationL(CHWRMVibra::TVibraModeState aState);
+ void ExpectVibraModeNotificationL();
+
+ void ExpectVibraFeedbackModeNotificationL(CHWRMVibra::TVibraFeedbackModeState aStatus);
+
+ void ExpectLightStatusNotificationL(TInt aTarget, CHWRMLight::TLightStatus aStatus);
+ void ExpectExtLightStatusNotificationL(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus);
+
+ void ExpectFmTxStatusNotificationL(TFmTxState aStatus);
+ void ExpectFmTxStatusNotificationL(TFmTxState aStatus1, TFmTxState aStatus2);
+ void ExpectFmTxFrequencyNotificationL(TInt aFrequency);
+
+ void ExpectBatteryLevelNotificationL(EPSHWRMBatteryLevel aBatteryLevel);
+ void ExpectBatteryStatusNotificationL(EPSHWRMBatteryStatus aStatus);
+ void ExpectedChargingStatusNotificationsL(EPSHWRMChargingStatus aStatus);
+
+ void ExpectBatteryPowerMeasurementsErrorL(TInt aErrorCode);
+
+ // TO DO: temp solution, need to add counters
+ void CheckPluginInsensitivity();
+
+ void ExpectLeave(TInt aError);
+ void EndExpectLeaveL(TInt aErr, const TText8* aFile,TInt aLine);
+ void CheckMockSYResultL();
+ void CheckAllExpectedNotificationsReceived();
+
+ void ExecuteTestL();
+ void CheckForEndOfTransition();
+
+ void CleanupPropertyObservers();
+ void BatteryLevelChanged(TInt aBatteryLevel);
+ void BatteryStatusChanged(TInt aBatteryStatus);
+ void ChargingStatusChanged(TInt aChargingStatus);
+
+ const TDesC& MapVibraModeState(CHWRMVibra::TVibraModeState aState);
+ const TDesC& MapVibraModeStatus(CHWRMVibra::TVibraStatus aStatus);
+ const TDesC& MapLightStatus(CHWRMLight::TLightStatus aStatus);
+ const TDesC& MapFmTxStatus(TFmTxState aStatus);
+
+ void SetIgnoreStatusNotifications(TBool aIgnore);
+ TBool IgnoringStatusNotifications() const;
+
+ void GetTargetsOn(TInt& aTargetsOnMask) const;
+
+#ifdef SYMBIAN_HWRM_EXTPOWERINFO
+ void OpenPowerStateSessionforChrgStatusL();
+ void SetPowerChargingCurrentMeasurementProcessingTime(TUint aCallbackProcessingTime);
+ void ExpectBatteryChargingStatusErrorL(TInt aErrorCode);
+ void ExpectBatteryChargingTimeMeasurementsErrorL(TInt aErrorCode);
+ void ExpectBatteryChargingCurrentMeasurementsErrorL(TInt aErrorCode);
+#endif
+
+protected:
+ TFixedArray<CHWRMVibra*,KMaxNoOpenSessionsForResource> iVibraSessions;
+ TFixedArray<CHWRMLight*,KMaxNoOpenSessionsForResource> iLightSessions;
+ TFixedArray<CHWRMExtendedLight*,KMaxNoOpenSessionsForResource> iExtLightSessions;
+ TFixedArray<CHWRMPower*,KMaxNoOpenSessionsForResource> iPowerSessions;
+ TFixedArray<CHWRMFmTx*,KMaxNoOpenSessionsForResource> iFmTxSessions;
+ TFixedArray<CHWRMEnhancedLight*,KMaxNoOpenSessionsForResource> iEnhancedLightSessions;
+
+ RMockLight iMockLight;
+ TBool iIsMockLightSessionOpen;
+ RMockVibra iMockVibra;
+ TBool iIsMockVibraSessionOpen;
+ RMockPowerState iMockPowerState;
+ TBool iIsMockPowerStateSessionOpen;
+ RMockPower iMockPower;
+ TBool iIsMockPowerSessionOpen;
+ RMockFmTx iMockFmTx;
+ TBool iIsMockFmTxSessionOpen;
+
+ struct TStepStateBase
+ {
+ virtual void ExecuteTestState() =0;
+ TReal iMaxDurationInSecs;
+ };
+
+ template <class T>
+ struct TStepState : public TStepStateBase
+ {
+ typedef void (T::*TTestStateFptr)();
+ T* iObject;
+ TTestStateFptr iStateFptr;
+ virtual void ExecuteTestState();
+ };
+
+ RPointerArray<TStepStateBase> iStepStates;
+ CActiveScheduler* iScheduler;
+ CEndStateTimer* iEndStateTimer;
+ TInt iTestResult;
+ TInt iCurrentState;
+ TInt iExpectedLeaveCode;
+
+ RArray<CHWRMVibra::TVibraStatus> iExpectedVibraStatusNotifications;
+ RArray<CHWRMVibra::TVibraModeState> iExpectedVibraModeNotifications;
+ RArray<CHWRMVibra::TVibraFeedbackModeState> iExpectedVibraFeedbackModeNotifications;
+ RArray<EPSHWRMBatteryLevel> iExpectedBatteryLevelNotifications;
+ RArray<EPSHWRMBatteryStatus> iExpectedBatteryStatusNotifications;
+ RArray<EPSHWRMChargingStatus> iExpectedChargingStatusNotifications;
+ RArray<TInt> iExpectedBatteryPowerMeasurementsError;
+#ifdef SYMBIAN_HWRM_EXTPOWERINFO
+ RArray<TInt> iExpectedBatteryChargingTimeMeasurementsError;
+ RArray<TInt> iExpectedBatteryChargingCurrentMeasurementsError;
+#endif //SYMBIAN_HWRM_EXTPOWERINFO
+
+ struct TLightNotification
+ {
+ TInt iTarget;
+ CHWRMLight::TLightStatus iStatus;
+ };
+ RArray<TLightNotification> iExpectedLightNotifications;
+
+ struct TExtLightNotification
+ {
+ TInt iTarget;
+ CHWRMExtendedLight::TLightStatus iStatus;
+ };
+ RArray<TExtLightNotification> iExpectedExtLightNotifications;
+
+ struct TFmTxNotification
+ {
+ TFmTxState iState1;
+ TFmTxState iState2;
+ };
+ RArray<TFmTxNotification> iExpectedFmTxStatusNotifications;
+
+ RArray<TInt> iExpectedFmTxFrequencyNotifications;
+
+ //vibra control attributes
+ TInt iVibraMinOffTime;
+ TInt iVibraMaxOnTime;
+ TInt iPulseMaxDuration;
+ TInt iPulseMaxIntensity;
+
+ //light control attributes
+ TInt iLightDefaultIntensity;
+ TInt iLightDefaultSensitivity;
+ TInt iLightSensorEnabled;
+
+ RProperty iLightIntensityProperty;
+ RProperty iLightSensitivityProperty;
+
+ TInt iPowerMaxReportingPeriodMicroSeconds;
+ TInt iPowerBaseIntervalMicroSeconds;
+
+ TUint iPowerAttributesMeasurementProcessingTime;// milliseconds
+#ifdef SYMBIAN_HWRM_EXTPOWERINFO
+ TUint iPowerChargingCurrentMeasurementProcessingTime; //milliseconds
+#endif //SYMBIAN_HWRM_EXTPOWERINFO
+
+ TInt iFmTxFrequencyStepSize; // KHz
+
+ TBool iSensorSupported;
+
+#ifdef INSECURE_AUDIO_POLICY_KEYS
+ //fmtx control attributes
+ // Used to mimic Audio Policy behaviour
+ RProperty iAudioRoutedProperty;
+#endif // INSECURE_AUDIO_POLICY_KEYS
+
+ // P&S property observers
+ CPsPropertyObserver* iBatteryLevelObserver;
+ CPsPropertyObserver* iBatteryStatusObserver;
+ CPsPropertyObserver* iChargingStatusObserver;
+
+ TBool iTearingDown;
+ TBool iIgnoreStatusNotifications;
+ };
+
+//inlines
+
+template <class T>
+void CHWRMTestBase::AddTestStateL(T* aObject, void (T::*aTestStateFptr)(),TReal aMaxDurationIsSecs)
+ {
+ TStepState<T>* testState = new (ELeave)TStepState<T>;
+ CleanupStack::PushL(testState);
+ testState->iStateFptr = aTestStateFptr;
+ testState->iObject = aObject;
+ testState->iMaxDurationInSecs = aMaxDurationIsSecs;
+ iStepStates.AppendL(testState);
+ CleanupStack::Pop(testState);
+ }
+
+template <class T>
+void CHWRMTestBase::TStepState<T>::ExecuteTestState()
+ {
+ (iObject->*iStateFptr)();
+ }
+
+inline CHWRMVibra& CHWRMTestBase::GetVibraSessionL(TInt aIndex)
+ {
+ if(!iVibraSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iVibraSessions[aIndex];
+ }
+inline CHWRMLight& CHWRMTestBase::GetLightSessionL(TInt aIndex)
+ {
+ if(!iLightSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iLightSessions[aIndex];
+ }
+
+inline CHWRMFmTx& CHWRMTestBase::GetFmTxSessionL(TInt aIndex)
+ {
+ if(!iFmTxSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iFmTxSessions[aIndex];
+ }
+
+inline CHWRMExtendedLight& CHWRMTestBase::GetExtLightSessionL(TInt aIndex)
+ {
+ if(!iExtLightSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iExtLightSessions[aIndex];
+ }
+
+inline CHWRMEnhancedLight& CHWRMTestBase::GetEnhancedLightSessionL(TInt aIndex)
+ {
+ if(!iEnhancedLightSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iEnhancedLightSessions[aIndex];
+ }
+
+inline CHWRMPower& CHWRMTestBase::GetPowerSessionL(TInt aIndex)
+{
+ if(!iPowerSessions[aIndex])
+ User::Leave(KErrNotFound);
+
+ return *iPowerSessions[aIndex];
+}
+
+inline CHWRMVibra& CHWRMTestBase::GetVibraSessionWithCallbackRegisteredL()
+ {
+ if(!iVibraSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iVibraSessions[0];
+ }
+
+inline CHWRMLight& CHWRMTestBase::GetLightSessionWithCallbackRegisteredL()
+ {
+ if(!iLightSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iLightSessions[0];
+ }
+
+inline CHWRMExtendedLight& CHWRMTestBase::GetExtLightSessionWithCallbackRegisteredL()
+ {
+ if(!iExtLightSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iExtLightSessions[0];
+ }
+
+inline CHWRMEnhancedLight& CHWRMTestBase::GetEnhancedLightSessionWithCallbackRegisteredL()
+ {
+ if(!iEnhancedLightSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iEnhancedLightSessions[0];
+ }
+
+inline CHWRMPower& CHWRMTestBase::GetPowerSessionWithCallbackRegisteredL()
+ {
+ if(!iPowerSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iPowerSessions[0];
+ }
+
+inline CHWRMFmTx& CHWRMTestBase::GetFmTxSessionWithCallbackRegisteredL()
+ {
+ if(!iFmTxSessions[0]) //its always @ idx = 0
+ User::Leave(KErrNotFound);
+
+ return *iFmTxSessions[0];
+ }
+
+inline RMockLight& CHWRMTestBase::GetMockLight()
+ {
+ return iMockLight;
+ }
+
+inline RMockVibra& CHWRMTestBase::GetMockVibra()
+ {
+ return iMockVibra;
+ }
+
+inline RMockPowerState& CHWRMTestBase::GetMockPowerState()
+ {
+ return iMockPowerState;
+ }
+
+inline RMockPower& CHWRMTestBase::GetMockPower()
+ {
+ return iMockPower;
+ }
+
+inline RMockFmTx& CHWRMTestBase::GetMockFmTx()
+ {
+ return iMockFmTx;
+ }
+
+inline void CHWRMTestBase::SetTestFail()
+ {
+ if(!iTestResult)
+ {
+ iTestResult = KErrTEFUnitFail;
+ }
+ }
+
+inline void CHWRMTestBase::ExpectLeave(TInt aError)
+ {
+ iExpectedLeaveCode = aError;
+ }
+
+inline void CHWRMTestBase::SetIgnoreStatusNotifications(TBool aIgnore)
+ {
+ iIgnoreStatusNotifications = aIgnore;
+ }
+
+inline TBool CHWRMTestBase::IgnoringStatusNotifications() const
+ {
+ return iIgnoreStatusNotifications;
+ }
+
+#endif // hwrmtest_h