diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmserver/Test/unit/src/TEAlarmTestAlarmPlayConfig.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmserver/Test/unit/src/TEAlarmTestAlarmPlayConfig.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,526 @@ +// Copyright (c) 2005-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 "TEAlarmTestAlarmPlayConfig.h" +#include +#include "consoleantestclient.h" + +CTEAlarmTestAlarmPlayConfigStep::~CTEAlarmTestAlarmPlayConfigStep() + { + iSoundIntervals->Reset(); + delete iSoundIntervals; + } + +CTEAlarmTestAlarmPlayConfigStep::CTEAlarmTestAlarmPlayConfigStep() + { + SetTestStepName(KTEAlarmTestAlarmPlayConfigStep); + } + + +TVerdict CTEAlarmTestAlarmPlayConfigStep::doTestStepL() + { + TESTL(GetAndCheckAlarmPlayIntervalsL()); + + __UHEAP_MARK; + // Get Alarm(s) from Config + CArrayFixFlat* alarmArray = new(ELeave) CArrayFixFlat(1); + CleanupStack::PushL(alarmArray); + + TESTL(GetAlarmsFromConfigL(ConfigSection(), *alarmArray)); + + TInt alarmCount = alarmArray->Count(); + + for(TInt i = 0; i < alarmCount; i++) + { + // Add the Alarm + TESTL((iSession.AlarmAdd(alarmArray->At(i))==KErrNone)); + INFO_PRINTF5(_L("Alarm[%d] Added: Id=%d, State=%d, Status=%d"), i, alarmArray->At(i).Id(), alarmArray->At(i).State(), alarmArray->At(i).Status()); + } + + if( alarmArray->Count() > 0 ) + { + TESTL(StartIntervalVerifierL(alarmArray->At(0).Id())); + } + else + { + INFO_PRINTF1(_L("AlarmPlayConfig: No Alarms specified; skipping Alarm Play Interval Tests")); + } + CleanupStack::PopAndDestroy(alarmArray); + __UHEAP_MARKEND; + return TestStepResult(); + } + + +TBool CTEAlarmTestAlarmPlayConfigStep::GetAndCheckAlarmPlayIntervalsL() + { + // Get Alarm Play Interval from Config, and Verify that it matches what the client has. + iSoundIntervals = new(ELeave) CArrayFixFlat(5); + + // Get Interval info from Config + TESTL(GetIntervalsFromConfigL(ConfigSection(),*iSoundIntervals)); + + // Verify that Interval info matches GetAlarmPlayIntervalsL(). + CArrayFixFlat* intervalArrayFromClient = new(ELeave) CArrayFixFlat(5); + CleanupStack::PushL(intervalArrayFromClient); + iSession.GetAlarmPlayIntervalsL(*intervalArrayFromClient); + INFO_PRINTF2(_L("AlarmPlayConfig: NumIntervals from Client=%d"), intervalArrayFromClient->Count()); + + TESTL(CompareAlarmPlayIntervals(*iSoundIntervals, *intervalArrayFromClient)); + + CleanupStack::PopAndDestroy(intervalArrayFromClient); + return ETrue; + } + + +TBool CTEAlarmTestAlarmPlayConfigStep::StartIntervalVerifierL(TAlarmId aAlarmId) + { + TESTL(GetIntervalRepeatFromConfig(ConfigSection(), iRepeatSetting)); + TESTL(GetTimerContingencyFromConfig(ConfigSection(), iTimerContingency)); + + // Instantiate the various objects we need: + CActiveScheduler* scheduler = new(ELeave) CActiveScheduler(); + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + CActiveAlertListener* alarmListener = new(ELeave) CActiveAlertListener(*this, iCAASClient); + CleanupStack::PushL(alarmListener); + CActiveAlertListener* soundStartListener = new(ELeave) CActiveAlertListener(*this, iCAASClient); + CleanupStack::PushL(soundStartListener); + CActiveAlertListener* soundStopListener = new(ELeave) CActiveAlertListener(*this, iCAASClient); + CleanupStack::PushL(soundStopListener); + CInactivityTimer* inactivityTimer = CInactivityTimer::NewLC(*this); + + INFO_PRINTF3(_L("IntervalVerifier::Verify %d Intervals, with AlarmId %d"), (iSoundIntervals->Count()), (aAlarmId)); + + TInt timeout; + if ( iRepeatSetting == EAlarmSoundRepeatSettingStop && + GetIntFromConfig(ConfigSection(), _L("Timeout"), timeout) ) + { + INFO_PRINTF2(_L("IntervalVerifier::InactivyTimer set for %d seconds."), (timeout)); + inactivityTimer->After(timeout* 1000000); + } + + if (iCAASClient.SetExtendedMode() != KErrNone) + { + INFO_PRINTF1(_L("IntervalVerifier::iCAASClient.SetExtendedMode() failed")); + return EFalse; + } + + // Setup the control variables + iExpectedAlarmId = aAlarmId; + iExpectedEventType = MAlarmEventHandler::EAlarmExpired; + iExpectedInterval = 0; + + // Start the Active Listeners. + INFO_PRINTF1(_L("IntervalVerifier::Start Listeners")); + alarmListener->Start(MAlarmEventHandler::EAlarmExpired); + soundStartListener->Start(MAlarmEventHandler::ESoundStarted); + soundStopListener->Start(MAlarmEventHandler::ESoundStopped); + + // Start the Active Scheduler. The HandleAlarmEvent is responsible for stopping it. + INFO_PRINTF1(_L("IntervalVerifier::Start Scheduler")); + CActiveScheduler::Start(); + + INFO_PRINTF1(_L("IntervalVerifier::Scheduler Completed")); + + // Cleanup after yourself. + CleanupStack::PopAndDestroy(inactivityTimer); + CleanupStack::PopAndDestroy(soundStopListener); + CleanupStack::PopAndDestroy(soundStartListener); + CleanupStack::PopAndDestroy(alarmListener); + + CActiveScheduler::Install(NULL); + CleanupStack::PopAndDestroy(scheduler); + + if (TestStepResult()==EPass) + { + return ETrue; + } + else + { + INFO_PRINTF1(_L("IntervalVerifier::TestStepResult() != EPass")); + return EFalse; + } + } + +void CTEAlarmTestAlarmPlayConfigStep::HandleAlertEvent(MAlarmEventHandler::TAlertEvent aEventType, TAlarmId aAlarmId) + { + INFO_PRINTF4(_L("IntervalVerifier::AlertEvent Type=%d, AlarmId=%d, Interval=%d"), aEventType, aAlarmId, iExpectedInterval); + + if (aAlarmId != iExpectedAlarmId) + { + return; + } + + if (aEventType != iExpectedEventType) + { + INFO_PRINTF3(_L("IntervalVerifier::AlertEvent Type Mismatch (%d != %d)"), aEventType, iExpectedEventType); + SetTestStepResult(EFail); + StopIntervalVerifier(); + } + else if (TimeDiff(aAlarmId, aEventType) > iTimerContingency) // seconds + { + INFO_PRINTF2(_L("IntervalVerifier::EventTime exceeds contingency (%d seconds) "), iTimerContingency.Int()); + SetTestStepResult(EFail); + StopIntervalVerifier(); + } + else + { + switch(aEventType) + { + case(MAlarmEventHandler::EAlarmExpired): + iExpectedEventType = ESoundStarted; + break; + case(MAlarmEventHandler::ESoundStarted): + iExpectedEventType = ESoundStopped; + break; + case(MAlarmEventHandler::ESoundStopped): + iExpectedEventType = ESoundStarted; + // To complete the test, we want to make sure that we get an + // "extra" interval. + if (++iExpectedInterval > iSoundIntervals->Count()) + { + StopIntervalVerifier(); + } + break; + } + } + } + +TTimeIntervalSeconds CTEAlarmTestAlarmPlayConfigStep::TimeDiff(TAlarmId aAlarmId, MAlarmEventHandler::TAlertEvent aEventType) + { + // Get the current time: + TTime timeNow; + timeNow.UniversalTime(); + + // Determine original expiry time for alarm + TASShdAlarm alarm; + if (iSession.GetAlarmDetails(aAlarmId, alarm) != KErrNone) + // We didn't find the currently expired alarm. This should never happen. + { + INFO_PRINTF2(_L("IntervalVerifier::TimeDiff failed to find alarm with Id=%d"), aAlarmId); + return iTimerContingency.Int() + 1; // Forces the test to fail. + } + + TTime expectedTime; + expectedTime = alarm.OriginalExpiryTime(); + TInt err = GetExpectedEventTime(expectedTime, aEventType); + if(err != KErrNone) + { + INFO_PRINTF2(_L("IntervalVerifier::TimeDiff->GetExpectedEventTime() returned %d"), err); + return iTimerContingency.Int() + 1; // Forces the test to fail. + } + + TDateTime expTimeDT = expectedTime.DateTime(); + TDateTime timeNowDT = timeNow.DateTime(); + // Displayed date => DD/MM/YYYY HH:MM:SS + INFO_PRINTF7(_L("IntervalVerifier::TimeDiff - Expected Time=%02d:%02d:%02d, Event Time=%02d:%02d:%02d"), + expTimeDT.Hour(), expTimeDT.Minute(), expTimeDT.Second(), + timeNowDT.Hour(), timeNowDT.Minute(), timeNowDT.Second()); + + TTimeIntervalSeconds diff; + (timeNow > expectedTime)? + timeNow.SecondsFrom(expectedTime, diff): + expectedTime.SecondsFrom(timeNow, diff); + return diff; + } + +TInt CTEAlarmTestAlarmPlayConfigStep::GetExpectedEventTime(TTime& aExpectedTime, MAlarmEventHandler::TAlertEvent aEventType) + { + if ( iSoundIntervals->Count() == 0 ) + { + // We only expect one event: EAlarmExpired, so don't change aExpectedTime: + return KErrNone; + } + + if ( iExpectedInterval < iSoundIntervals->Count() ) + { + // Get original expiry time + if (aEventType != EAlarmExpired) + { + aExpectedTime += TTimeIntervalMinutes(iSoundIntervals->At(iExpectedInterval).Offset().Int()); + if (aEventType != ESoundStarted) + { + // Only event left is ESoundStopped. + aExpectedTime += TTimeIntervalSeconds(iSoundIntervals->At(iExpectedInterval).Duration().Int()); + } + } + } + else + { + // we've exceeded the intervals; our test depends on the repeat setting + switch (iRepeatSetting) + { + case(EAlarmSoundRepeatSettingLoop): + { + TASCliSoundPlayDefinition lastInterval = iSoundIntervals->At(iSoundIntervals->Count()-1); + + // How many times have we been around? + TInt loopCount = (iExpectedInterval) / (iSoundIntervals->Count()); + // Restart time is offset by (last Offset + last Duration) * loopCount. + aExpectedTime += TTimeIntervalMinutes(lastInterval.Offset().Int() * loopCount); + aExpectedTime += TTimeIntervalSeconds(lastInterval.Duration().Int() * loopCount); + + TInt adjustedInterval = (iExpectedInterval) % (iSoundIntervals->Count()); + // We can safely assume that the aEventType is *not* EAlarmExpired + aExpectedTime += TTimeIntervalMinutes(iSoundIntervals->At(adjustedInterval).Offset().Int()); + if (aEventType == ESoundStopped) + { + aExpectedTime += TTimeIntervalSeconds(iSoundIntervals->At(adjustedInterval).Duration().Int()); + } + } + break; + case(EAlarmSoundRepeatSettingRepeatLast): + { + TASCliSoundPlayDefinition secondToLastInterval = iSoundIntervals->At(iSoundIntervals->Count()-2); + TASCliSoundPlayDefinition lastInterval = iSoundIntervals->At(iSoundIntervals->Count()-1); + + TTimeIntervalMinutes lastOffsetDuration = lastInterval.Offset().Int() - secondToLastInterval.Offset().Int(); + + + // Determine the time that the last interval's sound stopped: + TInt repeatCount = 1 + iExpectedInterval - (iSoundIntervals->Count()); + + aExpectedTime += TTimeIntervalMinutes(lastOffsetDuration.Int() * repeatCount ); + + // We can safely assume that the aEventType is *not* EAlarmExpired + aExpectedTime += TTimeIntervalMinutes(lastInterval.Offset().Int()); + if (aEventType == ESoundStopped) + { + aExpectedTime += TTimeIntervalSeconds(lastInterval.Duration().Int()); + } + } + break; + case(EAlarmSoundRepeatSettingStop): + INFO_PRINTF3(_L("IntervalVerifier::Interval Index(%d) >= Interval Count(%d). RepeatSetting=Stop"), + iExpectedInterval, iSoundIntervals->Count()); + return KErrGeneral; + default: + INFO_PRINTF3(_L("IntervalVerifier::Unexpected RepeatSetting(%d) with Interval Index(%d)"), + iRepeatSetting, iExpectedInterval); + return KErrCorrupt; + } + } + return KErrNone; + } + +void CTEAlarmTestAlarmPlayConfigStep::InactivityTimerExpired() + { + INFO_PRINTF1(_L("IntervalVerifier::InactivityTimerExpired.")); + TEST(iRepeatSetting == EAlarmSoundRepeatSettingStop); + TEST(iExpectedInterval <= iSoundIntervals->Count() ); + StopIntervalVerifier(); + } + +void CTEAlarmTestAlarmPlayConfigStep::StopIntervalVerifier() + { + INFO_PRINTF1(_L("IntervalVerifier::Stop Scheduler")); + CActiveScheduler::Stop(); + } + +/* + * Initializes the Active Object and adds itself to the Scheduler. + */ +CActiveAlertListener::CActiveAlertListener(MAlarmEventHandler& aHandler, RANTestClient& aClient) : CActive(EPriorityStandard), iHandler(aHandler), iClient(aClient) + { + CActiveScheduler::Add(this); + } + +/* + * Cleanups after the Active Object. + */ +CActiveAlertListener::~CActiveAlertListener() + { + Deque(); + } + +/* + * Starts the Active Objects by regitering for a asynchronous notification + * Called by the test step. + */ +TBool CActiveAlertListener::Start(MAlarmEventHandler::TAlertEvent aEventTypeToWaitFor) + { + if (IsActive()) + { + return EFalse; + } + + switch(aEventTypeToWaitFor) + { + case(MAlarmEventHandler::EAlarmExpired): + case(MAlarmEventHandler::ESoundStarted): + case(MAlarmEventHandler::ESoundStopped): + iEventType = aEventTypeToWaitFor; + break; + default: + return EFalse; + } + RegisterForNextEvent(); + return ETrue; + } + +void CActiveAlertListener::DoCancel() + { + iClient.CancelNotifications(); + } + +/* + * We've receive an event, be sure to pass it along to the test step for proper handling... + */ +void CActiveAlertListener::RunL() + { + if (iStatus == KErrNone) + { + if (iEventType == MAlarmEventHandler::EAlarmExpired) + { + iAlarmId = iExpiredAlarm.Id(); + } + RegisterForNextEvent(); + } + iHandler.HandleAlertEvent(iEventType, iAlarmId); + } + +/* + * Register For the next event. + */ +void CActiveAlertListener::RegisterForNextEvent() + { + switch(iEventType) + { + case(MAlarmEventHandler::EAlarmExpired): + iClient.NotifyOnAlarm(iExpiredAlarm, iStatus); + break; + case(MAlarmEventHandler::ESoundStarted): + iClient.NotifyOnSoundStart(iAlarmId, iFileName, iStatus); + break; + case(MAlarmEventHandler::ESoundStopped): + iClient.NotifyOnSoundStop(iAlarmId, iStatus); + break; + default: + // We should have never gotten to here: + User::Invariant(); + } + SetActive(); + } + +/* + * This object is used for verifying the RepeatSetting=Stop behavior. + */ +CInactivityTimer* CInactivityTimer::NewLC(MAlarmEventHandler& aHandler) + { + CInactivityTimer* timer = new(ELeave) CInactivityTimer(aHandler); + CleanupStack::PushL(timer); + timer->ConstructL(); + return timer; + } + +/* + * Let's the test step know that the timer expired. + */ +void CInactivityTimer::RunL() + { + iHandler.InactivityTimerExpired(); + } + +/* + * Initializes the object + */ +CInactivityTimer::CInactivityTimer(MAlarmEventHandler& aHandler) : CTimer(EPriorityStandard), iHandler(aHandler) + { + CActiveScheduler::Add(this); + } + +CTEAlarmTestAPCSetIntervalsStep::~CTEAlarmTestAPCSetIntervalsStep() + { + } + +CTEAlarmTestAPCSetIntervalsStep::CTEAlarmTestAPCSetIntervalsStep() + { + SetTestStepName(KTEAlarmTestAPCSetIntervalsStep); + } + +TVerdict CTEAlarmTestAPCSetIntervalsStep::doTestStepL() + { + // Check result from preamble and setup test step result. + if(TestStepResult() != EPass) + { + return TestStepResult(); + } + + __UHEAP_MARK; + // Get Alarm Play Interval from Config, and Verify that it matches what the client has. + CArrayFixFlat* intervalsFromConfig = new(ELeave) CArrayFixFlat(5); + CleanupStack::PushL(intervalsFromConfig); + + // Get Interval info from Config + TESTL(GetIntervalsFromConfigL(ConfigSection(),*intervalsFromConfig)); + + INFO_PRINTF2(_L("Loaded Intervals From Config - Count=%d"), intervalsFromConfig->Count()); + + // Verify that Interval info matches GetAlarmPlayIntervalsL(). + CArrayFixFlat* origIntervalsFromClient = new(ELeave) CArrayFixFlat(5); + CleanupStack::PushL(origIntervalsFromClient); + + iSession.GetAlarmPlayIntervalsL(*origIntervalsFromClient); + INFO_PRINTF2(_L("Loaded Intervals From Client - Count=%d"), origIntervalsFromClient->Count()); + + INFO_PRINTF1(_L("Make sure there are differences between the current and new intervals:")); + TESTL(!CompareAlarmPlayIntervals(*intervalsFromConfig, *origIntervalsFromClient)); + + INFO_PRINTF2(_L("Setting AlarmPlayIntervals, Count = %d"), intervalsFromConfig->Count()); + + if( 0 == intervalsFromConfig->Count() ) + { + TRAPD(err, iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig)); + TESTL(err == KErrArgument || err == KErrGeneral); + } + else if ( 0 == origIntervalsFromClient->Count() ) + { + TRAPD(err, iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig)); + TESTL(err == KErrNotSupported ); + } + else + { + iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig); + } + + CArrayFixFlat* updatedIntervalsFromClient = new(ELeave) CArrayFixFlat(5); + CleanupStack::PushL(updatedIntervalsFromClient); + + iSession.GetAlarmPlayIntervalsL(*updatedIntervalsFromClient); + INFO_PRINTF2(_L("Loaded Intervals From Client - Count=%d"), updatedIntervalsFromClient->Count()); + + if (origIntervalsFromClient->Count() == 0) + { + INFO_PRINTF1(_L("SoundIntervals are disabled in Client - Setting should have failed")); + TESTL(CompareAlarmPlayIntervals(*origIntervalsFromClient, *updatedIntervalsFromClient)); + } + else if (intervalsFromConfig->Count() == 0) + { + INFO_PRINTF1(_L("SoundIntervals are enabled in Client - Disabling should have failed")); + TESTL(CompareAlarmPlayIntervals(*origIntervalsFromClient, *updatedIntervalsFromClient)); + } + else + { + TESTL(CompareAlarmPlayIntervals(*intervalsFromConfig, *updatedIntervalsFromClient)); + } + + CleanupStack::PopAndDestroy(updatedIntervalsFromClient); + CleanupStack::PopAndDestroy(origIntervalsFromClient); + CleanupStack::PopAndDestroy(intervalsFromConfig); + __UHEAP_MARKEND; + return TestStepResult(); + } +