diff -r 000000000000 -r 4e1aa6a622a0 resourcemgmt/hwresourcesmgr/test/te_hwrm/hwrmtestbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/resourcemgmt/hwresourcesmgr/test/te_hwrm/hwrmtestbase.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,1639 @@ +// 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: +// te_hwrm.exe +// +// + +#include +#include +#include +#include +#include +#include +#include "HWRMFmTxInternalCRKeys.h" +#include "hwrmtestbase.h" +#include "hwrmtestmacros.h" +#include "HWRMPrivatePSKeys.h" + +_LIT(KVibraModeON, "EVibraModeON"); +_LIT(KVibraModeOFF, "EVibraModeOFF"); +_LIT(KVibraModeUnknown, "EVibraModeUnknown"); + +_LIT(KVibraStatusUnknown, "EVibraStatusUnknown"); +_LIT(KVibraStatusNotAllowed, "EVibraStatusNotAllowed"); +_LIT(KVibraStatusStopped, "EVibraStatusStopped"); +_LIT(KVibraStatusOn, "EVibraStatusOn"); + +_LIT(KLightStatusUnknown, "ELightStatusUnknown"); +_LIT(KLightOn, "ELightOn"); +_LIT(KLightOff, "ELightOff"); +_LIT(KLightBlink, "ELightBlink"); + +_LIT(KFmTxStateOff, "EFmTxStateOff"); +_LIT(KFmTxStateActive, "EFmTxStateActive"); +_LIT(KFmTxStateInactive, "EFmTxStateInactive"); +_LIT(KFmTxStatePowerSaveInactivity, "EFmTxStatePowerSaveInactivity"); +_LIT(KFmTxStatePowerSaveAccessory, "EFmTxStatePowerSaveAccessory"); +_LIT(KFmTxStateScanning, "EFmTxStateScanning"); +_LIT(KFmTxStateUnknown, "EFmTxStateUnkown"); + + +void CHWRMTestBase::OpenSessionsL(TInt aNoLightSessionsToOpen, TInt aNoVibraSessionsToOpen, TInt aNoExtLightSessionsToOpen, TInt aNoFmTxSessionsToOpen, TInt aNoPowerSessionsToOpen) + { + INFO_PRINTF1(_L("--START CHWRMTestBase::OpenSessionsL")); + aNoLightSessionsToOpen = (aNoLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoLightSessionsToOpen; + aNoVibraSessionsToOpen = (aNoVibraSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoVibraSessionsToOpen; + aNoExtLightSessionsToOpen = (aNoExtLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoExtLightSessionsToOpen; + aNoPowerSessionsToOpen = (aNoPowerSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoPowerSessionsToOpen; + aNoFmTxSessionsToOpen = (aNoFmTxSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoFmTxSessionsToOpen; + + for(TInt i = 0; i < aNoVibraSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + iVibraSessions[i] = CHWRMVibra::NewL(this); + } + else + { + iVibraSessions[i] = CHWRMVibra::NewL(); + } + } + + for(TInt i = 0; i < aNoLightSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - BEFORE CREATING FIRST LIGHT SESSION")); + iLightSessions[i] = CHWRMLight::NewL(this); + INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - AFTER CREATING FIRST LIGHT SESSION")); + } + else + { + iLightSessions[i] = CHWRMLight::NewL(); + } + } + + for(TInt i = 0; i < aNoExtLightSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + iExtLightSessions[i] = CHWRMExtendedLight::NewL(this); + } + else + { + iExtLightSessions[i] = CHWRMExtendedLight::NewL(); + } + } + + for(TInt i = 0; i < aNoPowerSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + iPowerSessions[i] = CHWRMPower::NewL(); + } + else + { + iPowerSessions[i] = CHWRMPower::NewL(); + } + } + + for(TInt i = 0; i < aNoFmTxSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + iFmTxSessions[i] = CHWRMFmTx::NewL(this); + } + else + { + iFmTxSessions[i] = CHWRMFmTx::NewL(); + } + } + + INFO_PRINTF1(_L("CHWRMTestBase::OpenSessionsL - BEFORE OPENING MOCKSY SESSIONS")); + // Open sessions to MockSY + if (aNoLightSessionsToOpen > 0 && !iIsMockLightSessionOpen) + { + User::LeaveIfError(iMockLight.Connect()); + iIsMockLightSessionOpen = ETrue; + } + if (aNoVibraSessionsToOpen > 0 && !iIsMockVibraSessionOpen) + { + User::LeaveIfError(iMockVibra.Connect()); + iIsMockVibraSessionOpen = ETrue; + } + if (aNoExtLightSessionsToOpen > 0 && !iIsMockLightSessionOpen) + { + User::LeaveIfError(iMockLight.Connect()); + iIsMockLightSessionOpen = ETrue; + } + if (aNoPowerSessionsToOpen > 0 && !iIsMockPowerSessionOpen) + { + User::LeaveIfError(iMockPower.Connect()); + iIsMockPowerSessionOpen = ETrue; + } + if (aNoFmTxSessionsToOpen > 0 && !iIsMockFmTxSessionOpen) + { + User::LeaveIfError(iMockFmTx.Connect()); + iIsMockFmTxSessionOpen = ETrue; + } + + INFO_PRINTF1(_L("--END CHWRMTestBase::OpenSessionsL")); + } + +void CHWRMTestBase::OpenLightSessionEnhancedL(TInt aNoEnhancedLightSessionsToOpen) + { + INFO_PRINTF1(_L("--START CHWRMTestBase::OpenEnhancedLightSessionL")); + aNoEnhancedLightSessionsToOpen = (aNoEnhancedLightSessionsToOpen>KMaxNoOpenSessionsForResource) ? KMaxNoOpenSessionsForResource: aNoEnhancedLightSessionsToOpen; + + for(TInt i = 0; i < aNoEnhancedLightSessionsToOpen; i++) + { + if(i==0) + { + //used first session as one listening for callbacks + iEnhancedLightSessions[i] = CHWRMEnhancedLight::NewL(this); + } + else + { + iEnhancedLightSessions[i] = CHWRMEnhancedLight::NewL(); + } + } + + INFO_PRINTF1(_L("CHWRMTestBase::OpenEnhancedLightSessionL - BEFORE OPENING MOCKSY SESSIONS")); + // Open sessions to MockSY + if (aNoEnhancedLightSessionsToOpen > 0 && !iIsMockLightSessionOpen) + { + User::LeaveIfError(iMockLight.Connect()); + iIsMockLightSessionOpen = ETrue; + } + INFO_PRINTF1(_L("--END CHWRMTestBase::OpenSessionsL")); + } + +void CHWRMTestBase::OpenPowerStateSessionL() + { + if (!iIsMockPowerStateSessionOpen) + { + User::LeaveIfError(iMockPowerState.Connect()); + iIsMockPowerStateSessionOpen = ETrue; + } + + // P&S property observers + CleanupPropertyObservers(); + + iBatteryLevelObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMBatteryLevel,*this); + iBatteryStatusObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMBatteryStatus,*this); + iChargingStatusObserver = CPsPropertyObserver::NewL(KPSUidHWRMPowerState, KHWRMChargingStatus,*this); + } + +void CHWRMTestBase::CleanupPropertyObservers() + { + delete iBatteryLevelObserver; + iBatteryLevelObserver = NULL; + delete iBatteryStatusObserver; + iBatteryLevelObserver = NULL; + delete iChargingStatusObserver; + iBatteryLevelObserver = NULL; + } + +void CHWRMTestBase::GetCRVibraAttributeL(TUint32 aVibraKey, TInt &aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidVibraCtrl); + User::LeaveIfError(rep->Get(aVibraKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + + +void CHWRMTestBase::GetVibraTimeAttributesL() + { + GetCRVibraAttributeL(KVibraMinOffTime, iVibraMinOffTime); + if ( iVibraMinOffTime < 0 ) + { + iVibraMinOffTime = 0; // do not allow negative value + } + + GetCRVibraAttributeL(KVibraCtrlMaxTime, iVibraMaxOnTime); + if ( iVibraMaxOnTime < 0 ) + { + iVibraMaxOnTime = 0; // do not allow negative value + } + + GetCRVibraAttributeL(KVibraCtrlFeedbackIntensity, iPulseMaxIntensity); + if ( iPulseMaxIntensity < 0 ) + { + iPulseMaxIntensity = 0; // do not allow negative value + } + + GetCRVibraAttributeL(KVibraCtrlFeedbackDuration, iPulseMaxDuration); + if ( iPulseMaxDuration < 0 ) + { + iPulseMaxDuration = 0; // do not allow negative value + } + } + + +void CHWRMTestBase::SetCRVibraAttributeL(TUint32 aVibraKey, TInt aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidVibraCtrl); + User::LeaveIfError(rep->Set(aVibraKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +TInt CHWRMTestBase::SetCRVibraAttribute(TUint32 aVibraKey, TInt aValue) + { + CRepository* rep = CRepository::NewL(KCRUidVibraCtrl); + TInt err = rep->Set(aVibraKey, aValue); + return err; + } + +void CHWRMTestBase::SetCRLightAttributes(TUint32 aLightKey, TInt aValue) + { + + CRepository* rep = CRepository::NewLC(KCRUidLightSettings); + User::LeaveIfError(rep->Set(aLightKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::GetCRLightAttributes(TUint32 aLightKey, TInt &aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidLightSettings); + User::LeaveIfError(rep->Get(aLightKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::SetLightControlAttributes(TInt aIntensity, TInt aSensitivity, TInt aInUse) + { + iLightDefaultIntensity = aIntensity; + iLightDefaultSensitivity = aSensitivity; + iLightSensorEnabled = aInUse; + + SetCRLightAttributes(KLightIntensity, iLightDefaultIntensity); + SetCRLightAttributes(KLightSensorSensitivity, iLightDefaultSensitivity); + SetCRLightAttributes(KLightSensorInUse, iLightSensorEnabled); + } + +void CHWRMTestBase::GetLightControlAttributes() + { + GetCRVibraAttributeL(KLightIntensity, iLightDefaultIntensity); + GetCRVibraAttributeL(KLightSensorSensitivity, iLightDefaultSensitivity); + GetCRVibraAttributeL(KLightSensorInUse, iLightSensorEnabled); + } + +void CHWRMTestBase::GetCRPowerAttributeL(TUint32 aPowerKey, TInt &aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidPowerSettings); + User::LeaveIfError(rep->Get(aPowerKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::GetPowerAttributesL() + { + TInt value; + GetCRVibraAttributeL(KPowerBaseTimeInterval, value); + iPowerBaseIntervalMicroSeconds = 1000 * value; //from milli to microseconds + GetCRVibraAttributeL(KPowerMaxReportingPeriod, value); //from milli to microseconds + iPowerMaxReportingPeriodMicroSeconds = 1000 * value; + } + +void CHWRMTestBase::SetCRPowerAttributeL(TUint32 aPowerKey, TInt aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidPowerSettings); + User::LeaveIfError(rep->Set(aPowerKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::SetCRFmTxAttributeL(TUint32 aFmTxKey, TInt aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidFmTxCenRes); + User::LeaveIfError(rep->Set(aFmTxKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::GetCRFmTxAttributeL(TUint32 aFmTxKey, TInt &aValue) + { + CRepository* rep = CRepository::NewLC(KCRUidFmTxCenRes); + User::LeaveIfError(rep->Get(aFmTxKey, aValue)); + CleanupStack::PopAndDestroy(rep); + } + +void CHWRMTestBase::GetFmTxFrequencyStepSizeL() + { + GetCRFmTxAttributeL(KFmTxCenResKeyStepSize, iFmTxFrequencyStepSize); + } + +void CHWRMTestBase::SetFmTxFrequencyRangeEuropeL() + { + SetCRFmTxAttributeL(KFmTxCenResKeyMinFrequency, 88100); + SetCRFmTxAttributeL(KFmTxCenResKeyMaxFrequency, 107900); + SetCRFmTxAttributeL(KFmTxCenResKeyStepSize, 50); + } + +void CHWRMTestBase::SetFmTxFrequencyRangeJapanL() + { + SetCRFmTxAttributeL(KFmTxCenResKeyMinFrequency, 88100); + SetCRFmTxAttributeL(KFmTxCenResKeyMaxFrequency, 90000); + SetCRFmTxAttributeL(KFmTxCenResKeyStepSize, 50); + } + +void CHWRMTestBase::SetFmTxInactivityTimeOutL(TUint aInactivityTimeOut) + { + SetCRFmTxAttributeL(KFmTxCenResKeyPowerSaveTimerLength, aInactivityTimeOut); + } + +void CHWRMTestBase::ExpectBatteryLevelNotificationL(EPSHWRMBatteryLevel aBatteryLevel) + { + iExpectedBatteryLevelNotifications.AppendL(aBatteryLevel); + } + +void CHWRMTestBase::ExpectBatteryStatusNotificationL(EPSHWRMBatteryStatus aStatus) + { + iExpectedBatteryStatusNotifications.AppendL(aStatus); + } + +void CHWRMTestBase::ExpectedChargingStatusNotificationsL(EPSHWRMChargingStatus aStatus) + { + iExpectedChargingStatusNotifications.AppendL(aStatus); + } + +void CHWRMTestBase::ExpectVibraStatusNotificationL(CHWRMVibra::TVibraStatus aStatus) + { + iExpectedVibraStatusNotifications.AppendL(aStatus); + } + +void CHWRMTestBase::ExpectLightStatusNotificationL(TInt aTarget, CHWRMLight::TLightStatus aStatus) + { + if (IgnoringStatusNotifications()) + { + return; + } + + TLightNotification notification; + notification.iTarget = aTarget; + notification.iStatus = aStatus; + iExpectedLightNotifications.AppendL(notification); + } + +void CHWRMTestBase::ExpectExtLightStatusNotificationL(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus) + { + if (IgnoringStatusNotifications()) + { + return; + } + + TExtLightNotification notification; + notification.iTarget = aTarget; + notification.iStatus = aStatus; + iExpectedExtLightNotifications.AppendL(notification); + } + +void CHWRMTestBase::ExpectFmTxStatusNotificationL(TFmTxState aStatus1,TFmTxState aStatus2) + { + TFmTxNotification notification; + + notification.iState1=aStatus1; + notification.iState2=aStatus2; + + iExpectedFmTxStatusNotifications.AppendL(notification); + } + +void CHWRMTestBase::ExpectFmTxStatusNotificationL(TFmTxState aStatus) + { + ExpectFmTxStatusNotificationL(aStatus, aStatus); + } + +void CHWRMTestBase::ExpectFmTxFrequencyNotificationL(TInt aFrequency) + { + iExpectedFmTxFrequencyNotifications.AppendL(aFrequency); + } + +void CHWRMTestBase::ExpectVibraModeNotificationL() + { + TInt value(-1); + GetCRVibraAttributeL(KVibraCtrlProfileVibraEnabled,value); + + + CHWRMVibra::TVibraModeState expectedVibraMode = + (value == 0) ? CHWRMVibra::EVibraModeOFF : CHWRMVibra::EVibraModeON; + + + ExpectVibraModeNotificationL(expectedVibraMode); + } + +void CHWRMTestBase::ExpectVibraModeNotificationL(CHWRMVibra::TVibraModeState aState) + { + iExpectedVibraModeNotifications.AppendL(aState); + } + +void CHWRMTestBase::ExpectVibraFeedbackModeNotificationL(CHWRMVibra::TVibraFeedbackModeState aState) + { + iExpectedVibraFeedbackModeNotifications.AppendL(aState); + } + +//callbacks of state change + void CHWRMTestBase::VibraModeChanged(CHWRMVibra::TVibraModeState aStatus) + { + switch (aStatus) + { + case CHWRMVibra::EVibraModeUnknown: + INFO_PRINTF1(_L("Vibra mode changed: EVibraModeUnknown")); + break; + case CHWRMVibra::EVibraModeON: + INFO_PRINTF1(_L("Vibra mode changed: EVibraModeON")); + break; + case CHWRMVibra::EVibraModeOFF: + INFO_PRINTF1(_L("Vibra mode changed: EVibraModeOFF")); + break; + default: + INFO_PRINTF1(_L("Vibra mode changed: UNDEFINED ! ")); + break; + } + + if (iExpectedVibraModeNotifications.Count() > 0) + { + if (aStatus != iExpectedVibraModeNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: VibraModeChanged, expected:%d, actual:%d"),iExpectedVibraModeNotifications[0],aStatus); + SetTestFail(); + } + iExpectedVibraModeNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: VibraModeChanged, expected:NONE, actual:%d"),aStatus); + SetTestFail(); + } + CheckForEndOfTransition(); + } + +void CHWRMTestBase::VibraStatusChanged(CHWRMVibra::TVibraStatus aStatus) + { + switch (aStatus) + { + case CHWRMVibra::EVibraStatusUnknown: + INFO_PRINTF1(_L("Vibra state changed: EVibraStatusUnknown")); + break; + case CHWRMVibra::EVibraStatusNotAllowed: + INFO_PRINTF1(_L("Vibra state changed: EVibraStatusNotAllowed")); + break; + case CHWRMVibra::EVibraStatusStopped: + INFO_PRINTF1(_L("Vibra state changed: EVibraStatusStopped")); + break; + case CHWRMVibra::EVibraStatusOn: + INFO_PRINTF1(_L("Vibra state changed: EVibraStatusOn")); + break; + default: + INFO_PRINTF1(_L("Vibra state changed: UNDEFINED !")); + break; + } + + if (iExpectedVibraStatusNotifications.Count() > 0) + { + if (aStatus != iExpectedVibraStatusNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: VibraStatusChanged, expected:%d, actual:%d"),iExpectedVibraStatusNotifications[0],aStatus); + SetTestFail(); + } + iExpectedVibraStatusNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: VibraStatusChanged, expected:NONE, actual:%d"),aStatus); + SetTestFail(); + } + CheckForEndOfTransition(); + } + +void CHWRMTestBase::VibraFeedbackModeChanged(CHWRMVibra::TVibraFeedbackModeState aMode) + { + switch(aMode) + { + case CHWRMVibra::EVibraFeedbackModeUnknown: + INFO_PRINTF1(_L("Vibra Feedback Mode changed to EVibraFeedbackModeUnknown")); + break; + case CHWRMVibra::EVibraFeedbackModeON: + INFO_PRINTF1(_L("Vibra Feedback Mode changed to EVibraFeedbackModeON")); + break; + case CHWRMVibra::EVibraFeedbackModeOFF: + INFO_PRINTF1(_L("Vibra Feedback Mode changed to EVibraFeedbackModeOFF")); + break; + default: + INFO_PRINTF2(_L("Vibra Feedback Mode changed to %d"), aMode); + } + if (iExpectedVibraFeedbackModeNotifications.Count() > 0) + { + if (aMode != iExpectedVibraFeedbackModeNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: VibraFeedbackModeChanged, expected:%d, actual:%d"),iExpectedVibraModeNotifications[0],aMode); + SetTestFail(); + } + iExpectedVibraFeedbackModeNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: VibraFeedbackModeChanged, expected:NONE, actual:%d"), aMode); + SetTestFail(); + } + CheckForEndOfTransition(); + } + +void CHWRMTestBase::LightStatusChanged(TInt aTarget, CHWRMLight::TLightStatus aStatus) + { + switch (aStatus) + { + case CHWRMLight::ELightOn: + INFO_PRINTF2(_L("Light state changed: ELightOn, target:%d"),aTarget); + break; + case CHWRMLight::ELightOff: + INFO_PRINTF2(_L("Light state changed: ELightOff, target:%d"),aTarget); + break; + case CHWRMLight::ELightBlink: + INFO_PRINTF2(_L("Light state changed: ELightBlink, target:%d"),aTarget); + break; + case CHWRMLight::ELightStatusUnknown: + INFO_PRINTF2(_L("Light state changed: ELightStatusUnknown, target:%d"),aTarget); + break; + default: + INFO_PRINTF1(_L("Light state changed: UNDEFINED !")); + break; + } + + if (iExpectedLightNotifications.Count() > 0) + { + if ( + (aStatus != iExpectedLightNotifications[0].iStatus || aTarget != iExpectedLightNotifications[0].iTarget) + && (IgnoringStatusNotifications() == EFalse) && (iTearingDown == EFalse) + ) + { + INFO_PRINTF5(_L("### ERROR: LightStatusChanged, expected: target=%d, status=%d, actual: target=%d, status=%d"), + iExpectedLightNotifications[0].iTarget,iExpectedLightNotifications[0].iStatus, aTarget, aStatus); + SetTestFail(); + } + else + { + INFO_PRINTF3(_L("INFO: LightStatusChanged, target=%d, status=%d"),aTarget,aStatus); + } + iExpectedLightNotifications.Remove(0); + } + + + // ignore notifications during teardown or if we have chosen to do so + else if ( (iTearingDown == EFalse) && (IgnoringStatusNotifications() == EFalse) ) + { + INFO_PRINTF3(_L("### ERROR: LightStatusChanged, expected:NONE, actual: target=%d, status=%d"),aTarget,aStatus); + SetTestFail(); + } + else + { + INFO_PRINTF3(_L("INFO: LightStatusChanged, target=%d, status=%d"),aTarget,aStatus); + } + + CheckForEndOfTransition(); + } + +void CHWRMTestBase::LightStatusChanged(TInt aTarget, CHWRMExtendedLight::TLightStatus aStatus) + { + switch (aStatus) + { + case CHWRMExtendedLight::ELightOn: + INFO_PRINTF2(_L("Light state changed: ELightOn, target:%d"),aTarget); + break; + case CHWRMExtendedLight::ELightOff: + INFO_PRINTF2(_L("Light state changed: ELightOff, target:%d"),aTarget); + break; + case CHWRMExtendedLight::ELightBlink: + INFO_PRINTF2(_L("Light state changed: ELightBlink, target:%d"),aTarget); + break; + case CHWRMExtendedLight::ELightStatusUnknown: + INFO_PRINTF2(_L("Light state changed: ELightStatusUnknown, target:%d"),aTarget); + break; + default: + INFO_PRINTF1(_L("Light state changed: UNDEFINED !")); + break; + } + + if (iExpectedExtLightNotifications.Count() > 0) + { + if ( + (aStatus != iExpectedExtLightNotifications[0].iStatus || aTarget != iExpectedExtLightNotifications[0].iTarget) + && (IgnoringStatusNotifications() == EFalse) && (iTearingDown == EFalse) + ) + { + INFO_PRINTF5(_L("### ERROR: LightStatusChanged, expected: target=%d, status=%d, actual: target=%d, status=%d"), + iExpectedLightNotifications[0].iTarget,iExpectedLightNotifications[0].iStatus, aTarget, aStatus); + SetTestFail(); + } + else + { + INFO_PRINTF3(_L("INFO: LightStatusChanged, target=%d, status=%d"),aTarget,aStatus); + } + iExpectedExtLightNotifications.Remove(0); + } + // ignore notifications during teardown or if we have chosen to do so + else if ( (iTearingDown == EFalse) && (IgnoringStatusNotifications() == EFalse) ) + { + INFO_PRINTF3(_L("### ERROR: LightStatusChanged, expected:NONE, actual: target=%d, status=%d"),aTarget,aStatus); + SetTestFail(); + } + else + { + INFO_PRINTF3(_L("INFO: LightStatusChanged, target=%d, status=%d"),aTarget,aStatus); + } + + CheckForEndOfTransition(); + } + +void CHWRMTestBase::FmTxStatusChanged(TFmTxState aStatus) + { + switch (aStatus) + { + case EFmTxStateUnknown: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStateUnknown")); + break; + case EFmTxStateOff: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStateOff")); + break; + case EFmTxStateActive: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStateActive")); + break; + case EFmTxStateInactive: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStateInactive")); + break; + case EFmTxStatePowerSaveInactivity: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStatePowerSaveInactivity")); + break; + case EFmTxStatePowerSaveAccessory: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStatePowerSaveAccessory")); + break; + case EFmTxStateScanning: + INFO_PRINTF1(_L("FmTx state changed: EFmTxStateScanning")); + break; + default: + INFO_PRINTF1(_L("FmTx state changed: UNDEFINED !")); + break; + } + + if (iExpectedFmTxStatusNotifications.Count() > 0) + { + if (aStatus != iExpectedFmTxStatusNotifications[0].iState1 && aStatus != iExpectedFmTxStatusNotifications[0].iState2) + { + INFO_PRINTF4(_L("### ERROR: FmTxStatusChanged, expected:%d OR %d, actual:%d"),iExpectedFmTxStatusNotifications[0].iState1, + iExpectedFmTxStatusNotifications[0].iState2,aStatus); + SetTestFail(); + } + iExpectedFmTxStatusNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: FmTxStatusChanged, expected:NONE, actual:%d"),aStatus); + SetTestFail(); + } + CheckForEndOfTransition(); + } + +void CHWRMTestBase::FmTxFrequencyChanged(TInt aFrequency) + { + INFO_PRINTF2(_L("FmTx Frequency Changed. New Frequency = %d "),aFrequency); + + if (iExpectedFmTxFrequencyNotifications.Count() > 0) + { + if (aFrequency != iExpectedFmTxFrequencyNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: FmTxFrequencyChanged, expected:%d OR %d, actual:%d"), + iExpectedFmTxFrequencyNotifications[0],aFrequency); + SetTestFail(); + } + iExpectedFmTxFrequencyNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: FmTxFrequencyChanged, expected:NONE, actual:%d"),aFrequency); + SetTestFail(); + } + + CheckForEndOfTransition(); + } + + +void CHWRMTestBase::PsPropertyChanged(TInt aKey, TInt aValue) + { + INFO_PRINTF3(_L("PsPropertyChanged: [key=%d, value=%d]"), aKey, aValue); + + switch (aKey) + { + case KHWRMBatteryLevel: + BatteryLevelChanged(aValue); + break; + case KHWRMBatteryStatus: + BatteryStatusChanged(aValue); + break; + case KHWRMChargingStatus: + ChargingStatusChanged(aValue); + break; + default: + break; + } + } + +void CHWRMTestBase::BatteryLevelChanged(TInt aBatteryLevel) + { + if (iExpectedBatteryLevelNotifications.Count() > 0) + { + if (aBatteryLevel != iExpectedBatteryLevelNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: BatteryLevelChanged, expected:%d, actual:%d"),iExpectedBatteryLevelNotifications[0],aBatteryLevel); + SetTestFail(); + } + iExpectedBatteryLevelNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: BatteryLevelChanged, expected:NONE, actual:%d"),aBatteryLevel); + SetTestFail(); + } + CheckForEndOfTransition(); + } + + void CHWRMTestBase::BatteryStatusChanged(TInt aBatteryStatus) + { + if (iExpectedBatteryStatusNotifications.Count() > 0) + { + if (aBatteryStatus != iExpectedBatteryStatusNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: BatteryStatusChanged, expected:%d, actual:%d"),iExpectedBatteryStatusNotifications[0],aBatteryStatus); + SetTestFail(); + } + iExpectedBatteryStatusNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: BatteryStatusChanged, expected:NONE, actual:%d"),aBatteryStatus); + SetTestFail(); + } + CheckForEndOfTransition(); + } + + void CHWRMTestBase::ChargingStatusChanged(TInt aChargingStatus) + { + if (iExpectedChargingStatusNotifications.Count() > 0) + { + if (aChargingStatus != iExpectedChargingStatusNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: BatteryStatusChanged, expected:%d, actual:%d"),iExpectedChargingStatusNotifications[0],aChargingStatus); + SetTestFail(); + } + iExpectedChargingStatusNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: ChargingStatusChanged, expected:NONE, actual:%d"),aChargingStatus); + SetTestFail(); + } + CheckForEndOfTransition(); + } + +void CHWRMTestBase::CheckPluginInsensitivity() + { + TInt value; + iLightIntensityProperty.Get(value); + if (value != iLightDefaultIntensity) + { + INFO_PRINTF3(_L("### FAILURE: Light plugin has invalid default intensity (%d != %d)"), iLightDefaultIntensity, value); + User::Leave(KErrGeneral); + } + + iLightSensitivityProperty.Get(value); + //if (iSensorSupported) + // { + if (value != iLightDefaultSensitivity) + { + INFO_PRINTF3(_L("### FAILURE: Light plugin has invalid default sensitivity (%d != %d)"), iLightDefaultSensitivity, value); + User::Leave(KErrGeneral); + } + // } + //else + // { + // Skipped as there is no sensor enabled in features + // INFO_PRINTF1(_L("### Skipped sensor sensitivity check, as sensor is not supported")); + // } + } + +void CHWRMTestBase::ExecuteTestL() + { + iEndStateTimer->Start(0); //start the test with an immmediate callback + CActiveScheduler::Start(); + + if (iTestResult) + { + TRAP_IGNORE(this->TearDownL()); // teardown is not called by TEFUnit if the test leave !! + User::Leave(iTestResult); + } + } + +void CHWRMTestBase::CheckForEndOfTransition() + { + TBool isDone = ETrue; + + // Check SY events + TBool SYHasWaitingEvent; + TBool SYHasPendingEvent; + TBool SYHasError; + if (iIsMockLightSessionOpen) + { + iMockLight.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasPendingEvent) + isDone = EFalse; + } + if (iIsMockVibraSessionOpen) + { + iMockVibra.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasPendingEvent) + isDone = EFalse; + } + + if (iIsMockPowerStateSessionOpen) + { + iMockPowerState.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasPendingEvent) + isDone = EFalse; + } + + if (iIsMockPowerSessionOpen) + { + iMockPower.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasPendingEvent) + isDone = EFalse; + } + + if (iIsMockFmTxSessionOpen) + { + iMockFmTx.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasPendingEvent) + isDone = EFalse; + } + + // Check if we are waiting for some notification + if( iExpectedVibraStatusNotifications.Count() !=0 + || iExpectedVibraModeNotifications.Count() !=0 + || iExpectedLightNotifications.Count() !=0 + || iExpectedBatteryLevelNotifications.Count() !=0 + || iExpectedBatteryStatusNotifications.Count() !=0 + || iExpectedChargingStatusNotifications.Count() !=0 + || iExpectedBatteryPowerMeasurementsError.Count() !=0 + || iExpectedFmTxStatusNotifications.Count() !=0 + || iExpectedFmTxFrequencyNotifications.Count() !=0 +#ifdef SYMBIAN_HWRM_EXTPOWERINFO + || iExpectedBatteryChargingTimeMeasurementsError.Count() !=0 + || iExpectedBatteryChargingCurrentMeasurementsError.Count() !=0 +#endif //SYMBIAN_HWRM_EXTPOWERINFO + ) + { + isDone = EFalse; + } + + // Stop the timer if everybody is done + if (isDone) + { + iEndStateTimer->DoCancel(); + } + } + + +void CHWRMTestBase::SetupL() + { + __UHEAP_MARK; + INFO_PRINTF1(_L("HWRM - Setup.")); + + //zero arrays + memset(&iVibraSessions, 0, KMaxNoOpenSessionsForResource*iVibraSessions.Length()); + memset(&iLightSessions, 0, KMaxNoOpenSessionsForResource*iLightSessions.Length()); + memset(&iPowerSessions, 0, KMaxNoOpenSessionsForResource*iPowerSessions.Length()); + memset(&iFmTxSessions, 0, KMaxNoOpenSessionsForResource*iFmTxSessions.Length()); + memset(&iExtLightSessions, 0, KMaxNoOpenSessionsForResource*iExtLightSessions.Length()); + memset(&iEnhancedLightSessions, 0, KMaxNoOpenSessionsForResource*iEnhancedLightSessions.Length()); + + + ResetDefaultsL(); + + //set default values + iLightDefaultIntensity = 50; + iLightDefaultSensitivity = 55; + iLightSensorEnabled = 0; + + iLightIntensityProperty.Attach(KPSUidHWResourceNotification, KHWRMTestLightIntensityValue); + iLightSensitivityProperty.Attach(KPSUidHWResourceNotification, KHWRMTestLightSensitivityValue); + + iPowerAttributesMeasurementProcessingTime = 0; + +#ifdef INSECURE_AUDIO_POLICY_KEYS + + // Test module mimics the behaviour of Audio Policy + // WARNING - HWRM must be built with INSECURE_AUDIO_POLICY_KEYS defined, else KErrPermissionDenied + iAudioRoutedProperty.Attach(KPSUidHWRMFmTx, KHWRMFmTxAudioRoutedFlag); + +#endif // INSECURE_AUDIO_POLICY_KEYS + + iScheduler = new CActiveScheduler; + + if ( iScheduler ) + { + CActiveScheduler::Install( iScheduler ); + } + iEndStateTimer = CEndStateTimer::NewL(*this); + } + +const TDesC& CHWRMTestBase::MapVibraModeState(CHWRMVibra::TVibraModeState aState) + { + switch(aState) + { + case CHWRMVibra::EVibraModeON: + return KVibraModeON; + case CHWRMVibra::EVibraModeOFF: + return KVibraModeOFF; + default: + return KVibraModeUnknown; + } + } + +const TDesC& CHWRMTestBase::MapVibraModeStatus(CHWRMVibra::TVibraStatus aStatus) + { + + switch(aStatus) + { + case CHWRMVibra::EVibraStatusNotAllowed: + return KVibraStatusNotAllowed; + case CHWRMVibra::EVibraStatusStopped: + return KVibraStatusStopped; + case CHWRMVibra::EVibraStatusOn: + return KVibraStatusOn; + default: + return KVibraStatusUnknown; + } + } + + + +const TDesC& CHWRMTestBase::MapLightStatus(CHWRMLight::TLightStatus aStatus) + { + + switch(aStatus) + { + case CHWRMLight::ELightOn: + return KLightOn; + case CHWRMLight::ELightOff: + return KLightOff; + case CHWRMLight::ELightBlink: + return KLightBlink; + default: + return KLightStatusUnknown; + } + } + +const TDesC& CHWRMTestBase::MapFmTxStatus(TFmTxState aStatus) + { + switch(aStatus) + { + case EFmTxStateOff: + return KFmTxStateOff; + case EFmTxStateActive: + return KFmTxStateActive; + case EFmTxStateInactive: + return KFmTxStateInactive; + case EFmTxStatePowerSaveInactivity: + return KFmTxStatePowerSaveInactivity; + case EFmTxStatePowerSaveAccessory: + return KFmTxStatePowerSaveAccessory; + case EFmTxStateScanning: + return KFmTxStateScanning; + default: + return KFmTxStateUnknown; + } + } + +void CHWRMTestBase::TearDownL() + { + iTearingDown = ETrue; + if (iIsMockLightSessionOpen) + { + iMockLight.Close(); + iIsMockLightSessionOpen = EFalse; + } + + if (iIsMockVibraSessionOpen) + { + iMockVibra.Close(); + iIsMockVibraSessionOpen = EFalse; + } + + if (iIsMockPowerStateSessionOpen) + { + iMockPowerState.Close(); + iIsMockPowerStateSessionOpen = EFalse; + } + + if (iIsMockPowerSessionOpen) + { + iMockPower.Close(); + iIsMockPowerSessionOpen = EFalse; + } + + if (iIsMockFmTxSessionOpen) + { + iMockFmTx.Close(); + iIsMockFmTxSessionOpen = EFalse; + } + + //log light and vibra states on tear down. + + if(iVibraSessions[0]) + { + CHWRMVibra& vibra = *iVibraSessions[0]; + CHWRMVibra::TVibraModeState state = vibra.VibraSettings(); + CHWRMVibra::TVibraStatus status = vibra.VibraStatus(); + INFO_PRINTF3(_L("Teardown - TVibraModeState=%S, TVibraStatus=%S"), &MapVibraModeState(state), &MapVibraModeStatus(status)); + } + + if(iLightSessions[0]) + { + CHWRMLight& light = *iLightSessions[0]; + TUint sup_targets = light.SupportedTargets(); + TUint targetsOnMask(0); + INFO_PRINTF2(_L("Teardown - Light supported targets bitmask=%d"), sup_targets); + TUint target = 0x00000001; + CHWRMLight::TLightStatus st; + do + { + if(target & sup_targets) + { + st = light.LightStatus(target); + INFO_PRINTF3(_L("Light target %d, state=%S"), target, &MapLightStatus(st)); + if (st == CHWRMLight::ELightOn) + { + targetsOnMask |= target; + } + } + if(target == CHWRMLight::ESystemTarget) + { + break; + } + + target = target << 1; + } + while(ETrue); + + if (targetsOnMask != 0) + { + INFO_PRINTF2(_L("Teardown - Going to switch off targets bitmask=%d"), targetsOnMask); + light.LightOffL(targetsOnMask); + } + } + + if(iFmTxSessions[0]) + { + CHWRMFmTx& fmTx = *iFmTxSessions[0]; + TInt frequency = fmTx.Frequency(); + TFmTxState status = fmTx.Status(); + INFO_PRINTF3(_L("Teardown - TFmTxState=%S, FmTxFrequency=%d"), &MapFmTxStatus(status), frequency); + } + + for(TInt i = 0; iExecuteTestState()); + + // Expected leave are not errors + if (err == iExpectedLeaveCode) + { + err = KErrNone; + iExpectedLeaveCode = KErrNone; + } + else + { + INFO_PRINTF3(_L("### ERROR Test step left with error %d, expected error %d"), err, iExpectedLeaveCode); + SetTestFail(); + } + if(err) + { + SetTestFail(); + } + else + { + //start timer to end test + iEndStateTimer->Start(iStepStates[iCurrentState]->iMaxDurationInSecs); + } + } + else + { + bFinished=ETrue; //no more transitions to go through, so finish step + } + + if(bFinished || iTestResult) + { + //test has finished so stop scheduler + CActiveScheduler::Stop(); + } + //move to next state + iCurrentState++; + + } + +/** +This method is called by the ASSERT_LEAVE macro. previous statement is expected to leave, so if it is executed +it's an error. +*/ +void CHWRMTestBase::EndExpectLeaveL(TInt aErr, const TText8* aFile,TInt aLine) + { + TPtrC8 fileNamePtrC8(aFile); + TBuf<100> fname; + fname.Copy(fileNamePtrC8); + INFO_PRINTF4(_L("### ERROR statement was expected to leave with error %d (File=%S, line=%d)"), aErr, &fname, aLine); + User::Leave(KErrTEFUnitFail); + } + + +void CHWRMTestBase::CheckAllExpectedNotificationsReceived() + { + /* + if (IgnoringStatusNotifications() == ETrue) + { + return; + } + */ + //if these arrays are non zero it implies that notifications were expected but not received which means a failure of the test + if (iExpectedVibraStatusNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Vibra Status Notification not received")); + } + if (iExpectedVibraModeNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Vibra Mode Notification not received")); + } + if (iExpectedVibraFeedbackModeNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Vibra Feedback Mode Notification not received")); + } + if (iExpectedLightNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Light Status Notification not received")); + } + if (iExpectedBatteryLevelNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Battery Level Notification not received")); + } + if (iExpectedBatteryStatusNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Battery Status Notification not received")); + } + if (iExpectedChargingStatusNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Charging Status Notification not received")); + } + if (iExpectedBatteryPowerMeasurementsError.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Battery Power Measurements Error not received")); + } + if (iExpectedFmTxFrequencyNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected FmTx Frequency Notification not received")); + } + if (iExpectedFmTxStatusNotifications.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected FmTx Status Notification not received")); + } +#ifdef SYMBIAN_HWRM_EXTPOWERINFO + if (iExpectedBatteryChargingTimeMeasurementsError.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Remaining charging time error notification not received")); + } + if (iExpectedBatteryChargingCurrentMeasurementsError.Count() != 0) + { + SetTestFail(); + INFO_PRINTF1(_L("### ERROR Expected Charging current error notification not received")); + } +#endif //SYMBIAN_HWRM_EXTPOWERINFO + } + +void CHWRMTestBase::CheckMockSYResultL() + { + TBool SYHasWaitingEvent; + TBool SYHasPendingEvent; + TBool SYHasError; + TBuf<255> log; + // Light + if (iIsMockLightSessionOpen) + { + iMockLight.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasWaitingEvent) + { + INFO_PRINTF1(_L("### ERROR MockLight SY didn't receive all expected commands")); + } + if (SYHasError || SYHasWaitingEvent) + { + SetTestFail(); + do { + iMockLight.GetNextLogLine(log); + INFO_PRINTF1(log); + } while(log.Length() > 0); + } + + } + // Vibra + if (iIsMockVibraSessionOpen) + { + iMockVibra.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasWaitingEvent) + { + INFO_PRINTF1(_L("### ERROR MockVibra SY didn't receive all expected commands")); + } + if (SYHasError || SYHasWaitingEvent) + { + SetTestFail(); + do { + iMockVibra.GetNextLogLine(log); + INFO_PRINTF1(log); + } while(log.Length() > 0); + } + } + // Power State + if (iIsMockPowerStateSessionOpen) + { + iMockPowerState.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasWaitingEvent) + { + INFO_PRINTF1(_L("### ERROR MockPowerState SY didn't receive all expected commands")); + } + if (SYHasError || SYHasWaitingEvent) + { + SetTestFail(); + do { + iMockPowerState.GetNextLogLine(log); + INFO_PRINTF1(log); + } while(log.Length() > 0); + } + } + // Power + if (iIsMockPowerSessionOpen) + { + iMockPower.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasWaitingEvent) + { + INFO_PRINTF1(_L("### ERROR MockPower SY didn't receive all expected commands")); + } + if (SYHasError || SYHasWaitingEvent) + { + SetTestFail(); + do { + iMockPower.GetNextLogLine(log); + INFO_PRINTF1(log); + } while(log.Length() > 0); + } + } + + // FmTx + if (iIsMockFmTxSessionOpen) + { + iMockFmTx.GetStatus(SYHasWaitingEvent,SYHasPendingEvent,SYHasError); + if (SYHasWaitingEvent) + { + INFO_PRINTF1(_L("### ERROR MockFmTx SY didn't receive all expected commands")); + } + if (SYHasError || SYHasWaitingEvent) + { + SetTestFail(); + do { + iMockFmTx.GetNextLogLine(log); + INFO_PRINTF1(log); + } while(log.Length() > 0); + } + } + } + +void CHWRMTestBase::GetTargetsOn(TInt& aTargetsOnMask) const + { + aTargetsOnMask = 0; + if(iLightSessions[0]) + { + CHWRMLight& light = *iLightSessions[0]; + TUint sup_targets = light.SupportedTargets(); + TUint target = 0x00000001; + CHWRMLight::TLightStatus st; + do + { + if(target & sup_targets) + { + st = light.LightStatus(target); + if (st == CHWRMLight::ELightOn) + { + aTargetsOnMask |= target; + } + } + if(target == CHWRMLight::ESystemTarget) + { + break; + } + + target = target << 1; + } + while(ETrue); + } + } + +#ifdef SYMBIAN_HWRM_EXTPOWERINFO +void CHWRMTestBase::OpenPowerStateSessionforChrgStatusL() + { + if (!iIsMockPowerStateSessionOpen) + { + User::LeaveIfError(iMockPowerState.Connect()); + iIsMockPowerStateSessionOpen = ETrue; + } + } + +void CHWRMTestBase::ChargingStatusChange(TInt aErrCode, CHWRMPower::TBatteryChargingStatus aChrgStatus) + { + if (aErrCode == KErrNone) + { + switch(aChrgStatus) + { + case EChargingStatusError: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusError")); + break; + } + case EChargingStatusNotConnected: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusNotConnected")); + break; + } + case EChargingStatusCharging: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusCharging")); + break; + } + case EChargingStatusNotCharging: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusNotCharging")); + break; + } + case EChargingStatusAlmostComplete: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusAlmostComplete")); + break; + } + case EChargingStatusChargingComplete: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusChargingComplete")); + break; + } + case EChargingStatusChargingContinued: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: EChargingStatusChargingContinued")); + break; + } + default: + { + INFO_PRINTF1(_L("INFO: Battery charging status changed: UNDEFINED!")); + } + } + + if (iExpectedChargingStatusNotifications.Count() > 0) + { + if (aChrgStatus != iExpectedChargingStatusNotifications[0]) + { + INFO_PRINTF3(_L("### ERROR: ChargingStatusChange, expected:%d, actual:%d"),iExpectedChargingStatusNotifications[0],aChrgStatus); + SetTestFail(); + } + iExpectedChargingStatusNotifications.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: ChargingStatusChange, expected:NONE, actual:%d"),aChrgStatus); + SetTestFail(); + } + } + } + +void CHWRMTestBase::ExpectBatteryChargingTimeMeasurementsErrorL(TInt aErrorCode) + { + iExpectedBatteryChargingTimeMeasurementsError.AppendL(aErrorCode); + } + +void CHWRMTestBase::BatteryFullChargingTimeChange(TInt aErrorCode, TUint aTime) + { + if (aErrorCode == KErrNone) + { + INFO_PRINTF2(_L("INFO: Remaining charging time received, Time=%d minutes"),aTime); + } + else + { + if (iExpectedBatteryChargingTimeMeasurementsError.Count() > 0) + { + if (aErrorCode != iExpectedBatteryChargingTimeMeasurementsError[0]) + { + INFO_PRINTF3(_L("### ERROR: BatteryFullChargingTimeChange, expected error:%d, actual:%d"),iExpectedBatteryChargingTimeMeasurementsError[0],aErrorCode); + SetTestFail(); + } + iExpectedBatteryChargingTimeMeasurementsError.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: BatteryFullChargingTimeChange, expected error:NONE, actual:%d"),aErrorCode); + SetTestFail(); + } + + INFO_PRINTF2(_L("INFO: Remaining charging time Error, error=%d"),aErrorCode); + } + } + +void CHWRMTestBase::SetPowerChargingCurrentMeasurementProcessingTime(TUint aCallbackProcessingTime) + { + iPowerChargingCurrentMeasurementProcessingTime = aCallbackProcessingTime; + } + +void CHWRMTestBase::ExpectBatteryChargingCurrentMeasurementsErrorL(TInt aErrorCode) + { + iExpectedBatteryChargingCurrentMeasurementsError.AppendL(aErrorCode); + } + +void CHWRMTestBase::AverageChargingCurrentChange(TInt aErrorCode, TInt aMeasurement) + { + if (aErrorCode == KErrNone) + { + INFO_PRINTF2(_L("INFO: Charging current Measurement Received, measurement=%d"),aMeasurement); + + // Simulate time spent on processing the response + if (iPowerChargingCurrentMeasurementProcessingTime > 0 ) + { + User::After(iPowerChargingCurrentMeasurementProcessingTime * 1000); + } + } + else + { + if (iExpectedBatteryChargingCurrentMeasurementsError.Count() > 0) + { + if (aErrorCode != iExpectedBatteryChargingCurrentMeasurementsError[0]) + { + INFO_PRINTF3(_L("### ERROR: ChargingCurrentChange, expected error:%d, actual:%d"),iExpectedBatteryChargingCurrentMeasurementsError[0],aErrorCode); + SetTestFail(); + } + iExpectedBatteryChargingCurrentMeasurementsError.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: ChargingCurrentChange, expected error:NONE, actual:%d"),aErrorCode); + SetTestFail(); + } + + INFO_PRINTF2(_L("INFO: Charging current Measurement Error, error=%d"),aErrorCode); + } + } +#endif //SYMBIAN_HWRM_EXTPOWERINFO + +void CHWRMTestBase::ExpectBatteryPowerMeasurementsErrorL(TInt aErrorCode) + { + iExpectedBatteryPowerMeasurementsError.AppendL(aErrorCode); + } + +void CHWRMTestBase::SetPowerAttributesMeasurementProcessingTime(TUint aCallbackProcessingTime) + { + iPowerAttributesMeasurementProcessingTime = aCallbackProcessingTime; + } + +void CHWRMTestBase::PowerMeasurement(TInt aErrorCode, CHWRMPower::TBatteryPowerMeasurementData& aMeasurement) + { + if (aErrorCode == KErrNone) + { + INFO_PRINTF3(_L("INFO: Power Attribute Measurement Received, measurement=(Voltage=%d, Current=%d)"),aMeasurement.iAverageVoltage, aMeasurement.iAverageCurrent); + + // Simulate time spent on processing the response + if (iPowerAttributesMeasurementProcessingTime > 0 ) + { + User::After(iPowerAttributesMeasurementProcessingTime * 1000); + } + if ((iExpectedBatteryPowerMeasurementsError.Count() > 0) && (iExpectedBatteryPowerMeasurementsError[0] == KErrNone)) + { + iExpectedBatteryPowerMeasurementsError.Remove(0); + } + } + else + { + if (iExpectedBatteryPowerMeasurementsError.Count() > 0) + { + if (aErrorCode != iExpectedBatteryPowerMeasurementsError[0]) + { + INFO_PRINTF3(_L("### ERROR: PowerMeasurement, expected error:%d, actual:%d"),iExpectedBatteryPowerMeasurementsError[0],aErrorCode); + SetTestFail(); + } + iExpectedBatteryPowerMeasurementsError.Remove(0); + } + else + { + INFO_PRINTF2(_L("### ERROR: PowerMeasurement, expected error:NONE, actual:%d"),aErrorCode); + SetTestFail(); + } + + INFO_PRINTF2(_L("INFO: Power Attributes Measurement Error, error=%d"),aErrorCode); + } + } +