// 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:

//

#include "hwrmtest.h"

#include "hwrmtestmacros.h"

#include <rmocklight.h>

#include <rmockvibra.h>

#include <rmockpower.h>

#include <e32property.h>

#include <hwrmvibrasdkcrkeys.h>

#include <hwrmpowerstatesdkpskeys.h>

#include <hwrmlightdomaincrkeys.h>

#include <hwrmpowerdomaincrkeys.h>

#include <hwrmdomainpskeys.h>

#include <hwrmextendedlight.h>

#include <hwrmlight.h>

#include "HWRMPrivateCRKeys.h"

const TReal KOneTimeUnit = 1.0;

const TReal KTwoTimeUnits = KOneTimeUnit*2.0;

const TInt KSupportedTargets= 	CHWRMLight::EPrimaryDisplayAndKeyboard

							|	CHWRMLight::ESecondaryDisplayAndKeyboard

							|	CHWRMLight::ECustomTarget2

							|	CHWRMLight::ECustomTarget4;

const TInt KSystemTargets = KSupportedTargets & (CHWRMLight::EPrimaryDisplayAndKeyboard | CHWRMLight::ESecondaryDisplayAndKeyboard);

const TInt KMaxSampleReportingPeriod = 20000; // 20sec as per the CenRep Key "KPowerMaxReportingPeriod" setting

const TInt KOneSecond = 1000000;

#ifdef INSECURE_AUDIO_POLICY_KEYS    

const TInt KTestCategory = 0x101FB3E7;

const TInt KTestKeyNotifyChange = 0x1;

#endif // INSECURE_AUDIO_POLICY_KEYS

static const TInt KDefaultStepSize = 50;

#define SETCOLORPARAM(var, r, g, b) \

	{ \

	var.iRed = r; \

	var.iGreen = g; \

	var.iBlue = b; \

	}

CTestSuite* CHWRMTest::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	// Setup resources. These tests have to be run before any other lights or vibra steps

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestSetupLightsL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnL);

	//PREQ 1944

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestStartVibraOverlapPulseL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestStartVibraOverlapPulsesL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPulseOverlapPulsesL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestSequentialPulsesL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestUnSupportedPulseIntensityL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestUnSupportedPulseDurationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPulseNotAllowedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestReserveStartPulseVibraL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestReserveVibraL);

	// Vibra testing

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnPluginResponseErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnWithIntensityL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnWithIntensityOutOfRangeL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnWithDurationOutOfRangeL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnDuringForcedOffPeriodL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnAfterForcedOffPeriodL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraGetStatusL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnInfiniteL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraProfileL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraOnLoopL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraReserveSessionsL);

 	// Vibra profile skipping tests (privileged client)

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraProfilePrivilegedClientL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestVibraProfilePrivilegedClient2L);

	//Light testing

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightSimpleL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkKeyboardL); // case 52, 62

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkComplexL); // case 53-59, 61

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkKeyboardInfiniteCutOffTimerL); // case 60-99

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightReserveSessionsL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightReserveSessions2L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightReserveDisplayL);	

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightGetSupportedTargetsL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightUnsupportedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightUnsupportedDurationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightUnsupportedIntensityL);

	// Custom target tests	

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightOnSimpleCustomTargetsL);

	// System target tests, using Target Modifier Plugin

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestModifyTargetL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestSystemLightsL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestDisplayLightsOnL);

	// PREQ 2615

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_ExtendedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightDefaultColorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightDefaultColor_ExtendedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_UnSupportedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_PluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFrozenStateRestoreLightColor_ExtendedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestBaseStateRestoreLightColor_ExtendedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_MultiClientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_MultiClient_ExtendedTargetL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightColor_WhenInUseL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightDefaultColor_WhenInUseL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightOnDurationRGBL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightOnDurationWithIntenistyRGBL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightOnDurationRGB_ExtendedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkDurationRGBL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkDurationWithIntensityRGBL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightBlinkDurationRGB_ExtendedL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightEnhancedLightLeaveL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestLightSetColorReserveL);

    // Power State tests

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerStatesL);

	// Extended Lights

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestExtendedLightSessionsL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestInvalidSessionsL);

	//Power

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerConnectL); 

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryInfoL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryInfoMultiClientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryInfoWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryVoltageInfoL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryVoltageInfoMultiClientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryVoltageInfoWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBaseTimeIntervalL);

	//Power - CR1833 

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotifyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_InfiniteL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriodL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_BigIntervalL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_MultiClient_SameIntervalL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_MultiClient_DiffIntervalL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_RedundantL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_Start_PluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_Stop_PluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_IntervalEqualL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_IntervalGreaterL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_WithoutRequestL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_ElapsedTimeLessL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_ElapsedTimeMoreL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_NonZeroToZeroL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_ZeroToNonZeroL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_SameValueL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_AdjustReportingPeriod_NegativeValueL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_All_AdjustReportingPeriod_NegativeValueL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_SlowClientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_WithoutCallbackL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_MultiClient_DiffInterval_SpecialCaseL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_Stop_WithoutStartL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_Stop_RedundantL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerNotify_Start_Set_PluginErrorL);

#ifdef SYMBIAN_HWRM_EXTPOWERINFO

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryChargingStatusL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryChargingStatusMultiClient3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingStatusNotificationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingStatusNotificationMultiClient3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerRemainingChargingTimeNotificationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerRemainingChargingTimeWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerStopRemainingChargingTimeWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerRemainingChargingTimeNotificationErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerRemainingChargingTimeWhenStartedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerRemainingChargingTimeNotificationMulticlient3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingTimeNotificationWhenChargingCompleteL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingTimeNotificationWhenDisconnectedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingTimeNotificationWhenChargingComplete3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingTimeNotificationWhenDisconnected3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentWhenStartedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationMulticlient3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationWhenChargingCompleteL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationWhenDisconnectedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationWhenChargingComplete3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationWhenDisconnected3L);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerStopChargingCurrentWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryChargerType);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryChargerTypeMulticlientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerGetBatteryChargerTypeWithPluginErrorL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerCancelChargingTimeWithoutStart);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerCancelChargingCurrentWithoutStart);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationMaxPeriodReachedL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationSameIntervalL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationDifferentIntervalL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentandRemainingChargingTimeNotificationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingandVoltageNotificationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationSlowClientL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationSlowClientsL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingTimeNotificationWithoutCallbackL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationWithoutCallbackL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerClientSetCallBackL);

    ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestPowerChargingCurrentNotificationMaxPeriodReachedMCL);

#endif //SYMBIAN_HWRM_EXTPOWERINFO

	// FM Tx testing	

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxConnectL); // Always run this test before the rest in order to set the Inactivity time out.

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxStatusOffL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableInvalidFreqL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableNewFreqL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableInvalidFreqWhenOnL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxReserveL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableDuringReservationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxDisableL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxDisableDuringReservationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxReserveDuringReservationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetFrequencyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetFrequencyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetFrequencyInvalidL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetFrequencyDuringReservationL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetFrequencyRangeL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetJapanFrequencyRangeL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetNextClearFrequencyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetNextClearFrequencyAsyncL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetNextClearFrequencyAsyncCancelL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetNextClearFrequencyArrayL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxGetNextClearFrequencyAsyncArrayL);	

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetNextClearFrequencyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetNextClearFrequencyAsyncL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetNextClearFrequencyAsyncCancelL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxAutoFrequencyL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetRdsDataL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetRadiotextL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetRadiotextContentL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetRadiotextTagL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxSetRadiotextTagsL);

#ifdef INSECURE_AUDIO_POLICY_KEYS    

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxAudioRoutingOnAndOffL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxPowerSaveOnAccessoryL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxPowerSaveOnOffStateL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxPowerSaveOnInactivityStateL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxPowerSaveOffL);

	ADD_TEST_STEP_ISO_CPP(CHWRMTest, TestFmTxEnableDuringPowersaveL);

#endif // INSECURE_AUDIO_POLICY_KEYS

	END_SUITE;

	}

// actual test cases

// -----------------

void CHWRMTest::TestVibraOnL()

	{

	/*test procedure

	1. Queue expected callback notifications

	2. Execute a command (that is supposed to trigger the callbacks)

	3. Start timer

	4. Wait for callbacks

	5. If timeout expires and all expected callbacks have not been triggered then test fails	

	*/

	INFO_PRINTF1(_L("Start test step: TestVibraOnL"));

	AddTestStateL(this, &CHWRMTest::VibraSetMinTimeOffL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraSetMaxTime10SecsOnL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOffL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraFeedbackSettingsL, KTwoTimeUnits);

	ExecuteTestL();

	}

// -----------------------------------------------------------------------------

// StartVibraOverlapPulse.

// Try to request vibration and overlapping pulse request.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestStartVibraOverlapPulseL()

	{

	INFO_PRINTF1(_L("Start test step: TestStartVibraOverlapPulseL"));

	//test states are NOT self contained - they must be used in correct sequence

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);	

	AddTestStateL(this, &CHWRMTest::StartVibra5L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::PulseVibraWithNoStatusUpdate0L, KTwoTimeUnits);	    	    	

	AddTestStateL(this, &CHWRMTest::CheckForVibraStatusStoppedL, KTwoTimeUnits * 2);

	ExecuteTestL();

	}

// -----------------------------------------------------------------------------

// StartVibraOverlapPulses.

// Try to request vibration and overlapping pulse requests.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestStartVibraOverlapPulsesL()

	{

	INFO_PRINTF1(_L("Start test step: TestStartVibraOverlapPulses"));

	//test states are NOT self contained - they must be used in correct sequence

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::MultVibraPulsesL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::CheckForVibraStatusStoppedL, KTwoTimeUnits * 3);

	ExecuteTestL();

	}

// ----------------------------------------------------------------------------- 

// PulseOverlapPulses.

// Try to request vibra pulse and overlapping pulses with it.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestPulseOverlapPulsesL()

	{

	INFO_PRINTF1(_L("Start test step: TestPulseOverlapPulsesL"));

	//test states are NOT self contained - they must be used in correct sequence

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::StartVibra5L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::PulsesOverlapPulsesL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::CheckForVibraStatusStoppedL, KTwoTimeUnits * 3);

	ExecuteTestL();

	}

// -----------------------------------------------------------------------------

// SequentialPulses.

// Try to request vibra pulses frequently in sequence.

// -----------------------------------------------------------------------------	

void CHWRMTest::TestSequentialPulsesL()

	{

	INFO_PRINTF1(_L("Start test step: TestSequentialPulsesL"));

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::SequentialPulsesL, KTwoTimeUnits);	

	ExecuteTestL();

	}				

// -----------------------------------------------------------------------------

// UnSupportedPulseIntensity.

// Try to request vibra pulse with incorrect intensity.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestUnSupportedPulseIntensityL()

	{

	INFO_PRINTF1(_L("Start test step: TestUnSupportedPulseIntensity"));

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseIntensity1L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseIntensity2L, KTwoTimeUnits);		

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseIntensity3L, KTwoTimeUnits);		

	ExecuteTestL();

	}

// -----------------------------------------------------------------------------

// UnSupportedPulseIntensity.

// Try to request vibra pulse with incorrect intensity.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestUnSupportedPulseDurationL()

	{

	INFO_PRINTF1(_L("Start test step: TestUnSupportedPulseDurationL"));

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseDuration1L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseDuration2L, KTwoTimeUnits);		

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseDuration3L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::UnSupportedPulseDuration4L, KTwoTimeUnits);	

	ExecuteTestL();

	}

// -----------------------------------------------------------------------------

// PulseNotAllowed.

// Try to request pulse when not allowed.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestPulseNotAllowedL()

	{

	INFO_PRINTF1(_L("Start test step: TestPulseNotAllowedL"));

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenL, KTwoTimeUnits);	

	AddTestStateL(this, &CHWRMTest::VibraPulseDisableProfileL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::PulseOnWhileDisabledL, KTwoTimeUnits);	

	AddTestStateL(this, &CHWRMTest::VibraPulseEnableProfileL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::PulseVibraL, KTwoTimeUnits);

	ExecuteTestL();	

	}

// -----------------------------------------------------------------------------

// ReserveStartPulseVibra.

// Try to reserver vibra and concurrently request normal and pulse vibration.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestReserveStartPulseVibraL()

	{

	INFO_PRINTF1(_L("Start test step: TestReserveStartPulseVibraL"));

	//test states are NOT self contained - they must be used in correct sequence

	AddTestStateL(this, &CHWRMTest::VibraPulseOpenSessionsL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraReserveL, KTwoTimeUnits);	

	AddTestStateL(this, &CHWRMTest::StartVibra5L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::PulseVibraWithNoStatusUpdateL, KTwoTimeUnits);

	//check that vibra status update (stopped) has been received after 4 secs.

	AddTestStateL(this, &CHWRMTest::CheckForVibraStatusStoppedL, KTwoTimeUnits * 2);

	ExecuteTestL();	

	}

// -----------------------------------------------------------------------------

// Reserve_Vibra.

// Try to reserve vibra.

// -----------------------------------------------------------------------------

//

void CHWRMTest::TestReserveVibraL()

	{

	INFO_PRINTF1(_L("Start test step: TestReserveVibraL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenSessionsL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraReserveDefaultParamsL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraReserveL, KTwoTimeUnits);	

	AddTestStateL(this, &CHWRMTest::Vibra2ReserveL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraReleaseL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::Vibra2ReleaseL, KTwoTimeUnits);

	ExecuteTestL();	

	}

void CHWRMTest::TestVibraOnPluginResponseErrorL()

	{

	INFO_PRINTF1(_L("Start test step: TestVibraOnPluginResponseErrorL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithResponseErrL, KTwoTimeUnits);

	ExecuteTestL();

	}

void CHWRMTest::TestVibraOnWithIntensityL()

	{

	INFO_PRINTF1(_L("Start test step: TestVibraOnWithIntensityL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithIntensityL, KTwoTimeUnits);

	ExecuteTestL();

	}

void CHWRMTest::TestVibraOnWithIntensityOutOfRangeL()

	{

	INFO_PRINTF1(_L("Start test step: TestVibraOnWithIntensityOutOfRangeL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithIntensityOutOfRangeL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithIntensityOutOfRangeL, KTwoTimeUnits);

	ExecuteTestL();

	}

void CHWRMTest::TestVibraOnWithDurationOutOfRangeL()

	{

	INFO_PRINTF1(_L("Start test step: TestVibraOnWithDurationOutOfRangeL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithDurationOutOfRangeL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithDurationOutOfRange2L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithDurationOutOfRange3L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithDurationOutOfRange4L, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnWithDurationGreaterThanMaximumL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraWaitForCutOffL, KOneTimeUnit*20);

	AddTestStateL(this, &CHWRMTest::VibraWaitForCoolOffL, KOneTimeUnit*20);

	ExecuteTestL();

	}

void CHWRMTest::TestVibraOnDuringForcedOffPeriodL()

	{

	INFO_PRINTF1(_L("Start test step: TestVibraOnDuringForcedOffPeriodL"));

	AddTestStateL(this, &CHWRMTest::VibraOpenL, KTwoTimeUnits);

	AddTestStateL(this, &CHWRMTest::VibraOnInfiniteL, KTwoTimeUnits);

	// wait for cut off

	AddTestStateL(this, &CHWRMTest::VibraWaitForCutOffL, KOneTimeUnit*20);

	AddTestStateL(this, &CHWRMTest::VibraOnDuringForcedOffPeriodL, KTwoTimeUnits);

	// wait for cool off to leave vibra ready for next step