diff -r 000000000000 -r 4e1aa6a622a0 resourcemgmt/hwresourcesmgr/test/te_hwrm/hwrmtestbase.h
--- /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