// Copyright (c) 1997-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 "ASTstAlarmTest.h"#include "ASSrvDefs.h"#include <f32file.h>#include <s32file.h>#include <asclisoundplay.h>#include <connect/sbeclient.h>#include <tz.h>// Type definitionstypedef CArrayFixFlat<TASCliSoundPlayDefinition> CPlayIntervalArray;// Literal constants_LIT(KAlarmServerTestBackupFile, "C:\\AlarmServer.bak");_LIT8(KSomeAlarmData, "This is some 8-bit data");//Temp fix for wk37, main updates for wk40_LIT(KAlarmServerBackupFileFullPath, "C:\\private\\101F5027\\AlarmServer.ini");static const TTimeIntervalMicroSeconds32 KTenSeconds = 10000000;#define KNewAlarmCycleStartOffsetMinutes {0,10,20,30,50,100,200,300,450,600,900,1200,1800,2400, 3000, 4000, 5000, 10000,KErrNotFound};static RFs FsSession;static conn::CSBEClient* BackupClient;static TDriveList DriveList;///* Try to give a fairly thorough test of the Alarm Server * during Startup Internalize, backup and restore *///// building block test Helper functions//static void Helper_StartBackupL() { // Use the Secure Backup Engine API to "start" a backup. Ultimate effect // is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called. // This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/ // BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods. // These methods are implementations for MBackupRestoreNotificatioObserver // which monitors changes in the P&S property conn::KUidBackupRestoreKey. // This P&S property is changed by calling the Secure Backup Engine API // below. BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase); }static void Helper_EndBackupL() { // Use the Secure Backup Engine API to "end" a backup. Ultimate effect // is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called. // This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/ // BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods. // These methods are implementations for MBackupRestoreNotificatioObserver // which monitors changes in the P&S property conn::KUidBackupRestoreKey. // This P&S property is changed by calling the Secure Backup Engine API // below. BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup); // allow Alarm Server observers to be notified User::After(1000); }static void Helper_StartRestoreL() { // Use the Secure Backup Engine API to "start" a restore. Ultimate effect // is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called. // This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/ // BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods. // These methods are implementations for MBackupRestoreNotificatioObserver // which monitors changes in the P&S property conn::KUidBackupRestoreKey. // This P&S property is changed by calling the Secure Backup Engine API // below. BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase); // allow Alarm Server observers to be notified User::After(100000); }static void Helper_EndRestoreL(TBool aSuccess) { // Use the Secure Backup Engine API to "end" a restore. Ultimate effect // is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called. // This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/ // BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods. // These methods are implementations for MBackupRestoreNotificatioObserver // which monitors changes in the P&S property conn::KUidBackupRestoreKey. // This P&S property is changed by calling the Secure Backup Engine API // below. if (aSuccess) { BackupClient->SetBURModeL(DriveList, conn::EBURNormal, conn::ENoBackup); } else { // starting a backup before a restore has completed. BackupClient->SetBURModeL(DriveList, conn::EBURBackupFull, conn::EBackupBase); } // allow Alarm Server observers to be notified User::After(1000000); }static CDirectFileStore* Helper_StartRestoreAndOpenL() { Helper_StartRestoreL(); TheAlarmTest.Test().Printf(_L("- Open and Lock Exclusive AlarmServer.Ini file\r\n")); // actually lock the file C:\System\Data\AlarmServer.ini - CDirectFileStore* store = NULL; for(TUint i=0; i < 10; i++) { TRAPD(err, store = CDirectFileStore::OpenL(FsSession, KAlarmServerBackupFileFullPath, EFileRead | EFileShareExclusive)); // success? if (err == KErrNone) break; if (err != KErrInUse) User::Leave(err); // wait a little (10ms) & try again User::After(10000); } return store; }static CDirectFileStore* Helper_StartBackupAndOpenL() { Helper_StartBackupL(); TheAlarmTest.Test().Printf(_L("- Open and Lock Share Readers AlarmServer.Ini file\r\n")); // actually lock the file C:\System\Data\AlarmServer.ini - CDirectFileStore* store = NULL; for(TUint i=0; i < 10; i++) { TRAPD(err, store = CDirectFileStore::OpenL(FsSession, KAlarmServerBackupFileFullPath, EFileRead | EFileShareReadersOnly)); // success? if (err == KErrNone) break; if (err != KErrInUse) User::Leave(err); // wait a little (10ms) & try again User::After(10000); } return store; }////// Backup & Restore support functions/* * Makes a Backup of the Alarm Server ini file: * 1. Asks for Read Only lock for the AlarmServer.ini file * 2. Copies AlarmServer.ini to c:\AlarmServer.bak * 3. Hands back the file lock */static void BackupAlarmServerIniFileL() { TheAlarmTest.Test().Printf(_L("- Backup AlarmServer Ini file\r\n")); Helper_StartBackupL(); // make Backup CFileMan* fm=CFileMan::NewL(FsSession); FsSession.Delete(KAlarmServerTestBackupFile); // no old file // keep on trying to copy AlarmServer.ini file, until it will be released by alarm server const TInt maxNumOfAttempts = 50; TInt numOfAttempts = 0; for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts) { if (KErrNone == fm->Copy(KAlarmServerBackupFileFullPath,KAlarmServerTestBackupFile)) break; User::After(200000); //Wait for file to be released } TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts delete fm; Helper_EndBackupL(); }/* * Restores from a Backup of the Alarm Server ini file: * 1. Asks for full access file lock for the AlarmServer.ini file * 2. Copies c:\AlarmServer.bak to the AlarmServer.ini file * 3. Hands back the file lock */static void RestoreAlarmServerIniFileL() { TheAlarmTest.Test().Printf(_L("- Restore AlarmServer Ini file\r\n")); // variables used to check Alarm Server notifications of Restore TAlarmId alarmId; TRequestStatus status; TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); Helper_StartRestoreL(); TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreStarted, status, alarmId); CFileMan* fm=CFileMan::NewL(FsSession); // didn't leave yet so: FsSession.Delete(KAlarmServerBackupFileFullPath); // zap current file fm->Copy(KAlarmServerTestBackupFile,KAlarmServerBackupFileFullPath); delete fm; Helper_EndRestoreL(ETrue); }/* * Pretends to start to make a Backup of the Alarm Server ini file: * 1. Asks for Read Only lock for the AlarmServer.ini file * Must delete store object and call SimulateBackupServerBackup_CompleteL() * after calling this! */static CStreamStore* SimulateBackupServerBackup_StartL() { TheAlarmTest.Test().Printf(_L("- Claim AlarmServer Ini file for Backup\r\n")); // want to start a Backup and open the AlarmServer Ini file return Helper_StartBackupAndOpenL(); }/* * Ends pretend Backup of the Alarm Server ini file: * 1. Hands back the file lock * Must be preceded by a call to SimulateBackupServerBackup_StartL * and delete of the store object. */static void SimulateBackupServerBackup_CompleteL() { TheAlarmTest.Test().Printf(_L("- ... Backup finished, return AlarmServer file lock\r\n")); Helper_EndBackupL(); }/* * Pretends to Restore the Alarm Server ini file: * 1. Asks for full access file lock for the AlarmServer.ini file * 2. Pauses briefly. * 3. Hands back the file lock * Alarm Server should re-Internalize existing alarms; * Session alarms should become orphaned. */static void SimulateBackupServerRestorationL() { TheAlarmTest.Test().Printf(_L("- 'Restore' AlarmServer Ini file, (open and release)\r\n")); // want to start a Restore and open AlarmServer Ini file CDirectFileStore* store = Helper_StartRestoreAndOpenL(); // take a little time for the Restore (.5s) User::After(500000); // now release file lock - TheAlarmTest.Test().Printf(_L("- Unlock AlarmServer.Ini file\r\n")); delete store; // restore success Helper_EndRestoreL(ETrue); }/* * Pretends to start to Restore the Alarm Server ini file: * 1. Asks for full access file lock for the AlarmServer.ini file * Must be followed by a call to SimulateBackupServerRestore_Complete! */static CStreamStore* SimulateBackupServerRestore_StartL() { CStreamStore* store = NULL; TInt err = KErrNone; TheAlarmTest.Test().Printf(_L("- Access AlarmServer Ini file, as if Restoring\r\n")); // Use this Secure Backup Engine API to "start" a restore. Ultimate effect // is to cause CASSrvAlarmQueue::StartAlarmStoreOperation() to be called. // This happens indirectly through CASSrvAlarmStore::BackupBeginningL()/ // BackupCompletedL()/RestoreBeginningL()/RestoreCompletedL() methods. // These methods are implementations for MBackupRestoreNotificatioObserver // which monitors changes in the P&S property conn::KUidBackupRestoreKey. // This P&S property is changed by calling the Secure Backup Engine API // below. BackupClient->SetBURModeL(DriveList, conn::EBURRestoreFull, conn::EBackupBase); // actually lock the file C:\System\Data\AlarmServer.ini const TInt maxNumOfAttempts = 50; TInt numOfAttempts = 0; for (;numOfAttempts < maxNumOfAttempts; ++numOfAttempts) { TRAP(err,store = CDirectFileStore::OpenL(FsSession, KAlarmServerBackupFileFullPath, EFileRead | EFileShareExclusive)); RDebug::Print(_L("CDirectFileStore::OpenL %S, err: %d"), &KAlarmServerBackupFileFullPath, err); if (err == KErrNone) break; User::After(200000); //Wait for file to be released } TheAlarmTest(numOfAttempts < maxNumOfAttempts, __LINE__); //File was not locked after 50 attempts return store; }/* * Ends pretend Restore of the Alarm Server ini file: * 1. Hands back the file lock * Alarm Server should re-Initernalize existing alarms; * Session alarms should become orphaned. * Must be preceded by acall to SimulateBackupServerRestore_StartLC */static void SimulateBackupServerRestore_CompleteL() { TheAlarmTest.Test().Printf(_L("- Restore finished, release AlarmServer Ini file\r\n")); Helper_EndRestoreL(ETrue); }/* * Ends pretend Restore of the Alarm Server ini file: * 1. Hands back the file lock * Alarm Server should re-Initernalize existing alarms; * Session alarms should become orphaned. * Must be preceded by a call to SimulateBackupServerRestore_StartL * and delete of the store object. *///// Shutdown & Restart of Alarm Server only possibly in Windows Udeb builds#if defined(_DEBUG) && defined (__WINSCW__)static void closeServers() { TInt r=TheAlarmTest.Session().Connect(); TheAlarmTest(r==KErrNone, __LINE__); TheAlarmTest.Test().Printf(_L("Server shut down\r\n")); TheAlarmTest.Test().Printf(_L("now closing server...\r\n")); TheAlarmTest.Session().__DbgShutDownServer(); TheAlarmTest.Session().Close(); }static void shutDownAndStartUpServers() { closeServers(); User::After(5000000); TheAlarmTest.Test().Printf(_L("now restarting server...\r\n")); TheAlarmTest.TestStartServers(); }#endifstatic TAlarmId addUtcAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce) { TBuf<200> testTitle; testTitle.Format(_L("- Adding alarm set with UTC time to expire in %d minutes"), aMinutesFromNow); TheAlarmTest.Test().Next(testTitle); // TASShdAlarm alarm; alarm.Category()=KASCliCategoryClock; alarm.RepeatDefinition()=aRepeatDefinition; TTime time; time.UniversalTime(); time += TTimeIntervalMinutes(aMinutesFromNow); alarm.SetUtcNextDueTime(time); // TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__); const TAlarmId id = alarm.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); // allow servers to catch up User::After(1000000); return id; }static TAlarmId addAlarm(TInt aMinutesFromNow, TAlarmRepeatDefinition aRepeatDefinition = EAlarmRepeatDefintionRepeatOnce) { TBuf<200> testTitle; testTitle.Format(_L("- Adding alarm set with local wall-clock time to expire in %d minutes"), aMinutesFromNow); TheAlarmTest.Test().Next(testTitle); // TASShdAlarm alarm; alarm.Category() = KASCliCategoryClock; alarm.RepeatDefinition() = aRepeatDefinition; alarm.NextDueTime().HomeTime(); alarm.NextDueTime() += TTimeIntervalMinutes(aMinutesFromNow); // TDateTime date=alarm.NextDueTime().DateTime(); TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__); const TAlarmId id = alarm.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"), id,date.Hour(), date.Minute(), date.Second()); // allow servers to catch up User::After(1000000); return id; }///////***************************************************************************** */static void doTestAlarmQueueOrderShutdownStartupL() { TheAlarmTest.Test().Next(_L("* Test alarms set using local wall-clock time order stable over server shutdown/startup"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else TheAlarmTest.TestClearStoreL(); //add alarms TheAlarmTest.Test().Next(_L("add 5 alarms")); RArray<TAlarmId> alarmIds; for (TInt ii=2; ii<=6; ii++) { TAlarmId id = addAlarm(ii); alarmIds.Append(id); } TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server")); shutDownAndStartUpServers(); //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); TheAlarmTest(count == serverAlarmIds.Count(), __LINE__); for (TInt jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); } serverAlarmIds.Close(); alarmIds.Close();#endif }/***************************************************************************** */static void doTestAlarmQueueOrderBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test alarm order across Backup and Restore")); TheAlarmTest.TestClearStoreL(); //add alarms TheAlarmTest.Test().Next(_L("add 5 alarms")); RArray<TAlarmId> alarmIds; for (TInt ii=2; ii<=6; ii++) { TAlarmId id = addAlarm(ii); alarmIds.AppendL(id); } // brief pause before backup (.5s) User::After(500000); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // delete alarms TheAlarmTest.Test().Next(_L("delete alarms")); TInt jj; for (jj=0; jj<5; jj++) { TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmIds[jj]) == KErrNone, __LINE__); } // pause before restore (5s) User::After(5000000); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("check restored alarms")); //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); TInt serverCount = serverAlarmIds.Count(); TheAlarmTest.Test().Printf(_L("[Added Alarms count = %i, server Count = %i]\r\n"), count, serverCount); TheAlarmTest(count == serverCount, __LINE__); for (jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); } serverAlarmIds.Close(); alarmIds.Close(); }/***************************************************************************** */static void doTestAlarmQueueBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test correct alarms in queue after backup and restore")); TheAlarmTest.TestClearStoreL(); // add an alarm to expire in 2 minutes TAlarmId id2 = addAlarm(2); // add an alarm to expire in 3 minutes TAlarmId id3 = addAlarm(3); // brief pause before backup (.5s) User::After(500000); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // delete alarms User::After(1000000); TheAlarmTest.Test().Next(_L("delete alarms")); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id2) == KErrNone, __LINE__); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id3) == KErrNone, __LINE__); User::After(1000000); // add alarms TheAlarmTest.Test().Next(_L("add alarms")); // add alarms to expire now TAlarmId id0 = addAlarm(0); TAlarmId id1 = addAlarm(1); TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNone, __LINE__); // first alarm (id0) should be notifying TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); // pause briefly before restore (2s) User::After(2000000); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("check correct alarms after restore")); // alarms should now be gone TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNotFound, __LINE__); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm) == KErrNotFound, __LINE__); // alarms should be restored TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm) == KErrNone, __LINE__); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id3, alarm) == KErrNone, __LINE__); }/***************************************************************************** */static void doTestAlarmSoundIntervalsBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test correct Sound Intervals after backup and restore")); TheAlarmTest.TestClearStoreL(); // Fetch the Alarm Sound Intervals CPlayIntervalArray* originalSoundArray = new(ELeave) CPlayIntervalArray(20); CleanupStack::PushL(originalSoundArray); TheAlarmTest.Session().GetAlarmPlayIntervalsL(*originalSoundArray); TheAlarmTest.Test().Next(_L("set non-default sound intervals")); // Initialise sound array with default values CPlayIntervalArray* newSoundArray = new(ELeave) CPlayIntervalArray(20); CleanupStack::PushL(newSoundArray); // Populate the new array to replace the default const TInt minuteCycle[]=KNewAlarmCycleStartOffsetMinutes; TInt i = 0; TInt offset = minuteCycle[i]; while (offset != KErrNotFound) { const TASCliSoundPlayDefinition item(offset, KDefaultSoundPlayDurationInSeconds); newSoundArray->AppendL(item); offset = minuteCycle[++i]; } // Try setting the sound details TheAlarmTest.Session().SetAlarmPlayIntervalsL(*newSoundArray); // brief pause before backup (.5s) User::After(500000); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("reset default sound intervals")); TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray); // pause briefly before restore (2s) User::After(2000000); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("check correct sound intervals after restore")); // Fetch the details back again. CPlayIntervalArray* restoreSoundArray = new(ELeave) CPlayIntervalArray(20); CleanupStack::PushL(restoreSoundArray); TheAlarmTest.Session().GetAlarmPlayIntervalsL(*restoreSoundArray); // Test that there are the same number of entries TheAlarmTest(newSoundArray->Count() == restoreSoundArray->Count(), __LINE__); // Test entries are the same TInt count = newSoundArray->Count(); for(TInt j=0; j<count; j++) { const TASCliSoundPlayDefinition& item = newSoundArray->At(j); const TASCliSoundPlayDefinition& item2 = restoreSoundArray->At(j); TheAlarmTest(item.Offset().Int() == item2.Offset().Int(), __LINE__); TheAlarmTest(item.Duration().Int() == item2.Duration().Int(), __LINE__); } TheAlarmTest.Test().Next(_L("reset default sound intervals")); TheAlarmTest.Session().SetAlarmPlayIntervalsL(*originalSoundArray); CleanupStack::PopAndDestroy(3);// originalSoundArray, newSoundArray, restoreSoundArray }/***************************************************************************** */static void doTestAlarmAddDuringBackupL() { TheAlarmTest.Test().Next(_L("* Test alarm changes during backup")); TheAlarmTest.TestClearStoreL(); // Attempt to add an alarm while the backup server is backing up the alarms CStreamStore* store = NULL; TRAPD(err, store = SimulateBackupServerBackup_StartL()); TheAlarmTest(err==KErrNone, __LINE__); CleanupStack::PushL(store); TheAlarmTest.Test().Next(_L("adding alarm should work")); TASShdAlarm alm; TheAlarmTest(addAlarm(0, alm.RepeatDefinition()) != KNullAlarmId, __LINE__); TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize")); // Locale change (time) x2 (INC038240 regression) // Exercise CASSrvAlarmStore queue an Externalize TTime time; time.UniversalTime(); time += TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); time -= TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); // release file lock - CleanupStack::PopAndDestroy(store); // store // backup complete TRAP(err, SimulateBackupServerBackup_CompleteL()); TheAlarmTest(err==KErrNone, __LINE__); // wait for AlarmServer to catch-up User::After(1000000); TheAlarmTest.Test().Next(_L("check we can now add alarm")); // re-try alarm add after backup complete - should be successful TAlarmId id = addAlarm(0); TheAlarmTest(id != KNullAlarmId, __LINE__); // wait for AlarmServer to catch-up User::After(1000000); // make Alarm Server re-Internalize TheAlarmTest.Test().Next(_L("now simulating restore...")); TRAP(err, SimulateBackupServerRestorationL()); TheAlarmTest(err==KErrNone, __LINE__); // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm has gone")); TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__); }/***************************************************************************** */static void doTestAlarmAddDuringRestoreL() { // variables used to check Alarm Server notifications of Restore TAlarmId alarmId; TRequestStatus status; TheAlarmTest.Test().Next(_L("* Test alarm changes during restore")); TheAlarmTest.TestClearStoreL(); // Attempt to add an alarm while the backup server is restoring up the alarms TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); CStreamStore* store = NULL; TRAPD(err, store = SimulateBackupServerRestore_StartL()); CleanupStack::PushL(store); TheAlarmTest(err==KErrNone, __LINE__); // check Restore Start notification received TheAlarmTest.Test().Next(_L("check for Alarm Restore Start notification")); User::After(1000000); TheAlarmTest(status == EAlarmChangeEventRestoreStarted, __LINE__); TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); TheAlarmTest(alarmId==KNullAlarmId, __LINE__); TheAlarmTest.Test().Next(_L("adding alarm should fail")); TASShdAlarm alm; alm.NextDueTime().HomeTime(); TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrLocked, __LINE__); // allow servers to catch up User::After(1000000); TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize")); // Locale change (time) x2 (INC038240 regression) // Exercise CASSrvAlarmStore TTime time; time.UniversalTime(); time += TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); time -= TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); CleanupStack::PopAndDestroy(store); // restore complete TRAP(err, SimulateBackupServerRestore_CompleteL()); TheAlarmTest(err==KErrNone, __LINE__); // check Restore Complete notification received TheAlarmTest.Test().Next(_L("check for Alarm Restore Complete notification")); TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreCompleted, status, alarmId); TheAlarmTest(alarmId==KNullAlarmId, __LINE__); // wait for AlarmServer to catch-up User::After(1000000); TheAlarmTest.Test().Next(_L("check we can now add alarm")); // re-try alarm add after restore complete - should be successful TAlarmId id = addAlarm(0); TheAlarmTest(id != KNullAlarmId, __LINE__); // wait for Alarm Server to externalize User::After(3000000); }/***************************************************************************** *//***************************************************************************** */static void doTestNotifyingAlarmShutdownStartupL() { TheAlarmTest.Test().Next(_L("* Test Notifying alarm across shutdown / startup")); TheAlarmTest.TestClearStoreL(); TheAlarmTest.Test().Next(_L("add an alarm")); // add an alarm to expire in 15 minutes TAlarmId id = addAlarm(15); // get alarm expiry time TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TTime time = alarm.NextDueTime();#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n")); TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n")); // target Alternative: wait until after alarm due time User::SetHomeTime(time - TTimeIntervalSeconds(3)); User::After(KTenSeconds);#else // UDEB: // shut down the server closeServers(); // re-start server after alarm expires User::SetHomeTime(time - TTimeIntervalSeconds(3)); User::After(KTenSeconds); TheAlarmTest.Test().Next(_L("now restarting server...\r\n")); TheAlarmTest.TestStartServers(); User::After(1000000);#endif // Internalise on startup has a 59s window for recent alarms TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying")); //check status of alarm TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id) == KErrNone, __LINE__); }/***************************************************************************** */static void doTestNotifyingAlarmBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test Notifying alarm removed by backup / restore")); TheAlarmTest.TestClearStoreL(); TheAlarmTest.Test().Next(_L("add an alarm")); // add an alarm to expire in 15 minutes TAlarmId id = addAlarm(15); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // get alarm expiry time TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TTime time = alarm.NextDueTime(); TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n")); // wait until after alarm due time User::SetHomeTime(time - TTimeIntervalSeconds(3)); User::After(KTenSeconds); // Internalise on startup has a 59s window for recent alarms TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying")); //check status of alarm TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // allow Alarm server to notice file lock has been released User::After(1000000); // Internalise after Restore has a 0s window for recent alarms // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm has gone\r\n")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__); }/***************************************************************************** */static void doTestSessionAlarmShutdownRestartL() { TheAlarmTest.Test().Next(_L("* Test that Session alarm is removed by shutdown"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else TheAlarmTest.TestClearStoreL(); // Set the session alarm TheAlarmTest.Test().Next(_L("set session alarm in 2 minutes")); TASShdAlarm alarm; alarm.Category() = KASCliCategoryClock; alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce; alarm.NextDueTime().HomeTime(); alarm.NextDueTime() += TTimeIntervalMinutes(2); // session specific alarm (has a TRequestStatus to complete) alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific); TRequestStatus status; TheAlarmTest.Session().AlarmAddWithNotification(status, alarm); const TAlarmId id = alarm.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); // status should be pending TheAlarmTest.Test().Next(_L("checking request is pending")); TheAlarmTest(status == KRequestPending, __LINE__); TheAlarmTest.Test().Next(_L("Shutdown Alarm Server")); closeServers(); User::After(10000000); // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm notification has been aborted")); TheAlarmTest(status != KRequestPending, __LINE__); // Get the abort // (Probably KErrDied though KErrServerTerminated should be okay too) User::WaitForRequest(status); TInt stat = status.Int(); TheAlarmTest((stat == KErrDied) || (stat == KErrServerTerminated), __LINE__); // now restart Alarm Server TheAlarmTest.Test().Next(_L("restart Alarm Server")); TheAlarmTest.TestStartServers(); // check presence of alarm TheAlarmTest.Test().Next(_L("check shutdown deleted alarm")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);#endif }/***************************************************************************** */static void doTestSessionAlarmBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test that Session alarm is orphaned by restore")); TheAlarmTest.TestClearStoreL(); // Set the session alarm TheAlarmTest.Test().Next(_L("set session alarm in 20 minutes")); TASShdAlarm alarmWrite; alarmWrite.Category() = KASCliCategoryClock; alarmWrite.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce; alarmWrite.NextDueTime().HomeTime(); alarmWrite.NextDueTime() += TTimeIntervalMinutes(20); // session specific alarm (has a TRequestStatus to complete) alarmWrite.Characteristics().Set(EAlarmCharacteristicsSessionSpecific); TRequestStatus status; TheAlarmTest.Session().AlarmAddWithNotification(status, alarmWrite); // check that alarm was set okay const TAlarmId id = alarmWrite.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); // status should be pending TheAlarmTest.Test().Next(_L("checking request is pending")); TheAlarmTest(status == KRequestPending, __LINE__); // remember the alarm time TTime alarmTime = alarmWrite.NextDueTime(); // make the Alarm server re-internlize .... TheAlarmTest.Test().Next(_L("now simulating restore...")); TRAPD(err, SimulateBackupServerRestorationL()); TheAlarmTest(err==KErrNone, __LINE__); // allow Alarm server to Internalize... User::After(1000000); // 1s // check old alarm queue has been cleared TheAlarmTest.Test().Next(_L("check alarm notification has been aborted")); TheAlarmTest(status != KRequestPending, __LINE__); // Get the abort result User::WaitForRequest(status); TheAlarmTest(status.Int() == KErrCancel, __LINE__); // check presence of alarm TASShdAlarm alarmRead; TheAlarmTest.Test().Next(_L("check alarm is no longer a session alarm")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__); TheAlarmTest(!alarmRead.HasOwningSession(), __LINE__); TheAlarmTest(alarmRead.HasBecomeOrphaned(), __LINE__); // advance clock, wait for alarm User::SetHomeTime(alarmWrite.NextDueTime() - TTimeIntervalSeconds(3)); TheAlarmTest.Test().Next(_L("waiting for alarm to notify")); // wait until after alarm due time User::After(KTenSeconds); // alarm should be notifying // if Alarm Server server tries to access the TRequestStatus // there will be an Access Violation TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__); //TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); const TAlarmState alarmState = alarmRead.State(); TheAlarmTest(alarmState == EAlarmStateNotifying, __LINE__); }/***************************************************************************** * Test adapted from TAlarmData, checks alarm data across Backup & Restore. * (Original tested across Alarm Server shutdown & re-start.) */static void doTestRestoreValidAlarmDataL() { TheAlarmTest.Test().Next(_L("Data API test")); TheAlarmTest.TestClearStoreL(); TInt r; TAlarmId alarmId; TASShdAlarm alarm; TRequestStatus status; // alarm.Message() = _L("Alarm with data"); alarm.NextDueTime().HomeTime(); alarm.NextDueTime() += TTimeIntervalMinutes(2); // r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); TheAlarmTest(status == KRequestPending, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size()); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // alarm.NextDueTime().HomeTime(); alarm.NextDueTime() += TTimeIntervalMinutes(2); r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // HBufC8* buf = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pBuf(buf->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pBuf); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*buf == KSomeAlarmData, __LINE__); // TheAlarmTest.Test().Next(_L("Waiting for alarm to expire")); // advance clock to 3s before alarm due User::SetHomeTime(alarm.NextDueTime() - TTimeIntervalSeconds(3)); TheAlarmTest.WaitForEvent(EAlarmChangeEventTimerExpired, status, alarmId); TheAlarmTest(alarmId == alarm.Id(), __LINE__); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__); // r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // TheAlarmTest.Session().AlarmAddWithNotification(status, alarm, KSomeAlarmData); TheAlarmTest(alarmId = alarm.Id(), __LINE__); HBufC8* alarmdata = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pAlarmdata(alarmdata->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*alarmdata == KSomeAlarmData, __LINE__); TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(alarmId); CleanupStack::PopAndDestroy(alarmdata); // alarm.Reset(); alarm.Message() = _L("Alarm with data"); alarm.NextDueTime().HomeTime(); alarm.NextDueTime() += TTimeIntervalMinutes(2); // r = TheAlarmTest.Session().AlarmAdd(alarm, KSomeAlarmData); TheAlarmTest(alarmId = alarm.Id(), __LINE__); HBufC8* alarmdata1 = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pAlarmdata1(alarmdata1->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata1); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*alarmdata1 == KSomeAlarmData, __LINE__); CleanupStack::PopAndDestroy(alarmdata1); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); User::After(1000000); // 1s BackupAlarmServerIniFileL(); User::After(1000000); // 1s TheAlarmTest.Test().Next(_L("Delete Alarm")); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmId) == KErrNone, __LINE__); User::After(1000000); // 1s TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); RestoreAlarmServerIniFileL(); User::After(1000000); // 1s // TheAlarmTest.Test().Next(_L("testing data restoration")); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__); // r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); CleanupStack::PopAndDestroy(buf); }//////static void doTestUtcAlarmQueueOrderShutdownStartupL() { TheAlarmTest.Test().Next(_L("* Test alarms set with UTC time order stable over server shutdown/startup"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else TheAlarmTest.TestClearStoreL(); //add alarms TheAlarmTest.Test().Next(_L("add 5 alarms")); RArray<TAlarmId> alarmIds; for (TInt ii=2; ii<=6; ii++) { TAlarmId id = addUtcAlarm(ii); alarmIds.Append(id); } TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server")); shutDownAndStartUpServers(); //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); TheAlarmTest(count == serverAlarmIds.Count(), __LINE__); for (TInt jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); } serverAlarmIds.Close(); alarmIds.Close();#endif }static void doTestUtcAlarmDSTShutdownStartupL() { TheAlarmTest.Test().Next(_L("* Test alarms set stable over server shutdown in DST off/startup in DST on"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else _LIT(KDSTON,"DST is on\r\n"); _LIT(KDSTOFF,"DST is off\r\n"); _LIT8(KTzEuropeLondon, "Europe/London"); TheAlarmTest.TestClearStoreL(); //Set time zone and system time at first const TInt currYear = 2007; TTime oldTime; oldTime.HomeTime(); RTz tz; User::LeaveIfError(tz.Connect()); CleanupClosePushL(tz); CTzId* oldTz=tz.GetTimeZoneIdL(); CleanupStack::PushL(oldTz); CTzId* zoneId = CTzId::NewL(KTzEuropeLondon); CleanupStack::PushL(zoneId); tz.SetTimeZoneL(*zoneId); tz.SetHomeTime(TDateTime(currYear, EMarch, 24, 00, 58, 0, 0)); tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn); //add alarms TheAlarmTest.Test().Next(_L("add 2 alarms")); RArray<TAlarmId> alarmIds; //Create an alarm at 5.00 am TAlarmId id = addAlarm(242); alarmIds.Append(id); //Create an alarm at 6.00 am id = addAlarm(302); alarmIds.Append(id); //Get the due time of the returned back alarms RArray<TTime> dueTimes; TASShdAlarm orginalAlarm; TheAlarmTest.Session().GetAlarmDetails(alarmIds[0], orginalAlarm); dueTimes.Append(orginalAlarm.NextDueTime()); TheAlarmTest.Session().GetAlarmDetails(alarmIds[1], orginalAlarm); dueTimes.Append(orginalAlarm.NextDueTime()); TTime curTime; curTime.HomeTime(); TDateTime date=curTime.DateTime(); TBool onDST=tz.IsDaylightSavingOnL(*zoneId); TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second()); if (onDST) { TheAlarmTest.Test().Printf(KDSTON); } else { TheAlarmTest.Test().Printf(KDSTOFF); } TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server")); closeServers(); User::After(1000000*60*3); //wait three minutes TheAlarmTest.Test().Printf(_L("now restarting server...\r\n")); TheAlarmTest.TestStartServers(); curTime.HomeTime(); date=curTime.DateTime(); onDST=tz.IsDaylightSavingOnL(*zoneId); CleanupStack::PopAndDestroy(zoneId); TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second()); if (onDST) { TheAlarmTest.Test().Printf(KDSTON); } else { TheAlarmTest.Test().Printf(KDSTOFF); } //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); TheAlarmTest(count == serverAlarmIds.Count(), __LINE__); TASShdAlarm alarm; for (TInt jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); TheAlarmTest.Session().GetAlarmDetails(alarmIds[jj], alarm); TheAlarmTest(alarm.NextDueTime() == dueTimes[jj], __LINE__); date = alarm.NextDueTime().DateTime(); TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"), alarmIds[jj],date.Hour(), date.Minute(), date.Second()); } serverAlarmIds.Close(); alarmIds.Close(); dueTimes.Close(); tz.SetTimeZoneL(*oldTz); CleanupStack::PopAndDestroy(oldTz); tz.SetHomeTime(oldTime); CleanupStack::PopAndDestroy(&tz);#endif }static void doTestFloatingAlarmDSTShutdownStartupHelsinkiL() { TheAlarmTest.Test().Next(_L("* Test alarms set stable over server shutdown in DST on/startup in DST off"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else _LIT8(KTzEuropeHelsinki, "Europe/Helsinki"); _LIT(KDSTON,"DST is on\r\n"); _LIT(KDSTOFF,"DST is off\r\n"); TheAlarmTest.TestClearStoreL(); //Set time zone and system time at first const TInt currYear = 2007; TTime oldTime; oldTime.HomeTime(); RTz tz; User::LeaveIfError(tz.Connect()); CleanupClosePushL(tz); CTzId* oldTz=tz.GetTimeZoneIdL(); CleanupStack::PushL(oldTz); CTzId* zoneId = CTzId::NewL(KTzEuropeHelsinki); CleanupStack::PushL(zoneId); tz.SetTimeZoneL(*zoneId); tz.SetHomeTime(TDateTime(currYear, EOctober, 27, 03, 58, 0, 0)); tz.SetAutoUpdateBehaviorL(RTz::ETZAutoDSTUpdateOn); //add alarms TheAlarmTest.Test().Next(_L("add alarms")); RArray<TAlarmId> alarmIds; //Create an alarm at 4.02 am TAlarmId id = addAlarm(4); alarmIds.Append(id); id = addAlarm(7); alarmIds.Append(id); id = addAlarm(10); alarmIds.Append(id); //Get the due time of the returned back alarms RArray<TTime> dueTimes; TASShdAlarm floatingAlarm; TheAlarmTest.Session().GetAlarmDetails(alarmIds[0], floatingAlarm); dueTimes.Append(floatingAlarm.NextDueTime()); TheAlarmTest.Session().GetAlarmDetails(alarmIds[1], floatingAlarm); dueTimes.Append(floatingAlarm.NextDueTime()); TheAlarmTest.Session().GetAlarmDetails(alarmIds[2], floatingAlarm); dueTimes.Append(floatingAlarm.NextDueTime()); TTime curTime; curTime.HomeTime(); TDateTime date=curTime.DateTime(); TBool onDST=tz.IsDaylightSavingOnL(*zoneId); TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second()); if (onDST) { TheAlarmTest.Test().Printf(KDSTON); } else { TheAlarmTest.Test().Printf(KDSTOFF); } TheAlarmTest.Test().Next(_L("shutdown then restart Alarm Server")); closeServers(); User::After(1000000*60*4); //wait for 4 mins tz.SetHomeTime(TDateTime(currYear, EOctober, 27, 04, 02, 0, 0)); TheAlarmTest.Test().Printf(_L("now restarting server...\r\n")); TheAlarmTest.TestStartServers(); curTime.HomeTime(); date=curTime.DateTime(); onDST=tz.IsDaylightSavingOnL(*zoneId); CleanupStack::PopAndDestroy(zoneId); TheAlarmTest.Test().Printf(_L("system time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), date.Hour(), date.Minute(), date.Second()); if (onDST) { TheAlarmTest.Test().Printf(KDSTON); } else { TheAlarmTest.Test().Printf(KDSTOFF); } //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); if(count != serverAlarmIds.Count()) { TheAlarmTest.Test().Printf(_L("No alarms found after DST change \r\n")); } else { TASShdAlarm alarm; for (TInt jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); TheAlarmTest.Session().GetAlarmDetails(alarmIds[jj], alarm); TheAlarmTest(alarm.NextDueTime() == dueTimes[jj], __LINE__); date = alarm.NextDueTime().DateTime(); TheAlarmTest.Test().Printf(_L("alarm %d due time is : hours: %d, minutes: %d, seconds: %d.\r\n"), alarmIds[jj],date.Hour(), date.Minute(), date.Second()); } } serverAlarmIds.Close(); alarmIds.Close(); dueTimes.Close(); tz.SetTimeZoneL(*oldTz); CleanupStack::PopAndDestroy(oldTz); tz.SetHomeTime(oldTime); CleanupStack::PopAndDestroy(&tz);#endif }static void doTestUtcAlarmQueueOrderBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test alarm set with UTC time order across Backup and Restore")); TheAlarmTest.TestClearStoreL(); //add alarms TheAlarmTest.Test().Next(_L("add 5 alarms")); RArray<TAlarmId> alarmIds; for (TInt ii=2; ii<=6; ii++) { TAlarmId id = addUtcAlarm(ii); alarmIds.AppendL(id); } // brief pause before backup (1s) User::After(1000000); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // delete alarms TheAlarmTest.Test().Next(_L("delete alarms")); TInt jj; for (jj=0; jj<5; jj++) { TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmIds[jj]) == KErrNone, __LINE__); } // pause before restore (10s) User::After(10000000); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("check restored alarms")); //get server alarms RArray<TAlarmId> serverAlarmIds; TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, serverAlarmIds); alarmIds.Sort(); serverAlarmIds.Sort(); TInt count = alarmIds.Count(); TInt serverCount = serverAlarmIds.Count(); TheAlarmTest.Test().Printf(_L("[Added Alarms count = %i, server Count = %i]\r\n"), count, serverCount); TheAlarmTest(count == serverCount, __LINE__); for (jj=0; jj<count; jj++) { TheAlarmTest(alarmIds[jj] == serverAlarmIds[jj], __LINE__); } serverAlarmIds.Close(); alarmIds.Close(); }static void doTestUtcAlarmQueueBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test correct alarms set with UTC time in queue after backup and restore")); TheAlarmTest.TestClearStoreL(); // add an alarm to expire in 2 minutes TAlarmId id2 = addUtcAlarm(2); // add an alarm to expire in 3 minutes TAlarmId id3 = addUtcAlarm(3); // brief pause before backup (.5s) User::After(500000); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // delete alarms TheAlarmTest.Test().Next(_L("delete alarms")); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id2) == KErrNone, __LINE__); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id3) == KErrNone, __LINE__); // add alarms TheAlarmTest.Test().Next(_L("add alarms")); // add alarms to expire now TAlarmId id0 = addUtcAlarm(0); TAlarmId id1 = addUtcAlarm(1); // first alarm (id0) should be notifying TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNone, __LINE__); TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); // pause briefly before restore (2s) User::After(2000000); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("check correct alarms after restore")); // alarms should now be gone TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id0, alarm) == KErrNotFound, __LINE__); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id1, alarm) == KErrNotFound, __LINE__); // alarms should be restored TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id2, alarm) == KErrNone, __LINE__); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id3, alarm) == KErrNone, __LINE__); }static void doTestUtcAlarmAddDuringBackupL() { TheAlarmTest.Test().Next(_L("* Test alarm changes during backup")); TheAlarmTest.TestClearStoreL(); // Attempt to add an alarm while the backup server is backing up the alarms CStreamStore* store = NULL; TRAPD(err, store = SimulateBackupServerBackup_StartL()); TheAlarmTest(err==KErrNone, __LINE__); CleanupStack::PushL(store); TheAlarmTest.Test().Next(_L("adding alarm should work")); TASShdAlarm alm; TTime time; time.UniversalTime(); alm.SetUtcNextDueTime(time); TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrNone, __LINE__); TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize")); // Locale change (time) x2 (INC038240 regression) // Exercise CASSrvAlarmStore queue an Externalize time.UniversalTime(); time += TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); time -= TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); // release file lock - CleanupStack::PopAndDestroy(store); // store // backup complete TRAP(err, SimulateBackupServerBackup_CompleteL()); TheAlarmTest(err==KErrNone, __LINE__); // wait for AlarmServer to catch-up User::After(1000000); TheAlarmTest.Test().Next(_L("check we can now add alarm")); // re-try alarm add after backup complete - should be successful TAlarmId id = addUtcAlarm(0); TheAlarmTest(id != KNullAlarmId, __LINE__); // make Alarm Server re-Internalize User::After(1000000); TheAlarmTest.Test().Next(_L("now simulating restore...")); TRAP(err, SimulateBackupServerRestorationL()); TheAlarmTest(err==KErrNone, __LINE__); TASShdAlarm alarm; // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm has gone")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__); }static void doTestUtcAlarmAddDuringRestoreL() { // variables used to check Alarm Server notifications of Restore TAlarmId alarmId; TRequestStatus status; TheAlarmTest.Test().Next(_L("* Test alarm changes during restore")); TheAlarmTest.TestClearStoreL(); // Attempt to add an alarm while the backup server is restoring up the alarms TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); CStreamStore* store = NULL; TRAPD(err, store = SimulateBackupServerRestore_StartL()); CleanupStack::PushL(store); TheAlarmTest(err==KErrNone, __LINE__); // check Restore Start notification received TheAlarmTest.Test().Next(_L("check for Alarm Restore Start notification")); User::After(1000000); TheAlarmTest(status == EAlarmChangeEventRestoreStarted, __LINE__); TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); TheAlarmTest(alarmId==KNullAlarmId, __LINE__); TheAlarmTest.Test().Next(_L("adding alarm should fail")); TASShdAlarm alm; TTime time; time.UniversalTime(); alm.SetUtcNextDueTime(time); TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alm) == KErrLocked, __LINE__); TheAlarmTest.Test().Next(_L("changing time forces Alarm Store class to queue Externalize")); // Locale change (time) x2 (INC038240 regression) // Exercise CASSrvAlarmStore time.UniversalTime(); time += TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); time -= TTimeIntervalSeconds(10); User::SetUTCTime(time); User::After(1000000); CleanupStack::PopAndDestroy(store); // restore complete TRAP(err, SimulateBackupServerRestore_CompleteL()); TheAlarmTest(err==KErrNone, __LINE__); // check Restore Complete notification received TheAlarmTest.Test().Next(_L("check for Alarm Restore Complete notification")); TheAlarmTest.TestEventBuffer(EAlarmChangeEventRestoreCompleted, status, alarmId); TheAlarmTest(alarmId==KNullAlarmId, __LINE__); // wait for AlarmServer to catch-up User::After(1000000); TheAlarmTest.Test().Next(_L("check we can now add alarm")); // re-try alarm add after restore complete - should be successful TAlarmId id = addUtcAlarm(0); TheAlarmTest(id != KNullAlarmId, __LINE__); // wait for Alarm Server to externalize User::After(3000000); }static void doTestNotifyingUtcAlarmShutdownStartupL() { TheAlarmTest.Test().Next(_L("* Test Notifying alarm across shutdown / startup")); TheAlarmTest.TestClearStoreL(); TheAlarmTest.Test().Next(_L("add an alarm")); // add an alarm to expire in 15 minutes TAlarmId id = addUtcAlarm(15); // get alarm expiry time TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TTime time = alarm.NextDueTime();#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n")); TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n"));#if defined(_DEBUG) // UREL Alternative: wait until after alarm due time User::SetUTCTime(time - TTimeIntervalSeconds(3)); User::After(KTenSeconds);#endif#else // UDEB: // shut down the server closeServers(); // re-start server after alarm expires User::SetUTCTime(time - TTimeIntervalSeconds(3)); User::After(KTenSeconds); TheAlarmTest.Test().Next(_L("now restarting server...\r\n")); TheAlarmTest.TestStartServers(); User::After(1000000);#endif TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__);#if defined(_DEBUG) //check status of alarm // Internalise on startup has a 59s window for recent alarms TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying")); TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);#else // Test only possible if in _DEBUG build. TheAlarmTest.Test().Printf(_L("THIS TEST IS A DEBUG TEST ONLY\r\n"));#endif TheAlarmTest(TheAlarmTest.Session().AlarmDelete(id) == KErrNone, __LINE__); }static void doTestNotifyingUtcAlarmBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test Notifying alarm removed by backup / restore")); TheAlarmTest.TestClearStoreL(); TheAlarmTest.Test().Next(_L("add an alarm")); // add an alarm to expire in 15 minutes TAlarmId id = addUtcAlarm(15); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); TRAPD(err, BackupAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // get alarm expiry time TASShdAlarm alarm; TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TTime time = alarm.NextDueTime(); TheAlarmTest.Test().Printf(_L("Waiting for Alarm to expire\r\n")); TheAlarmTest.Test().Printf(_L("Alarm set to expire at: hours: %d, minutes: %d, seconds: %d.\r\n"), time.DateTime().Hour(), time.DateTime().Minute(), time.DateTime().Second()); // wait until after alarm due time User::SetUTCTime(time - TTimeIntervalSeconds(3)); TTime now; now.UniversalTime(); TheAlarmTest.Test().Printf(_L("System UTC time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), now.DateTime().Hour(), now.DateTime().Minute(), now.DateTime().Second()); TheAlarmTest.Test().Printf(_L("Wait for approximately 10 seconds for alarm to expire...\r\n")); User::After(KTenSeconds); now.UniversalTime(); TheAlarmTest.Test().Printf(_L("System UTC time is now: hours: %d, minutes: %d, seconds: %d.\r\n"), now.DateTime().Hour(), now.DateTime().Minute(), now.DateTime().Second()); // Internalise on startup has a 59s window for recent alarms TheAlarmTest.Test().Next(_L("check that alarm is now set and notifying")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNone, __LINE__); TheAlarmTest.Test().Printf(_L("Alarm state: %d.\r\n"), alarm.State()); TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); TRAP(err, RestoreAlarmServerIniFileL()); TheAlarmTest(err==KErrNone, __LINE__); // allow Alarm server to notice file lock has been released User::After(1000000); // Internalise after Restore has a 0s window for recent alarms // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm has gone\r\n")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__); }static void doTestSessionUtcAlarmShutdownRestartL() { TheAlarmTest.Test().Next(_L("* Test that Session alarm is removed by shutdown"));#if !defined(_DEBUG) || !defined(__WINSCW__) // Can't shutdown Alarm Server on UREL or target builds TheAlarmTest.Test().Printf(_L("THIS TEST IS A WINS - DEBUG TEST ONLY\r\n"));#else TheAlarmTest.TestClearStoreL(); // Set the session alarm TheAlarmTest.Test().Next(_L("set session alarm in 2 minutes")); TASShdAlarm alarm; alarm.Category()=(KASCliCategoryClock); alarm.RepeatDefinition()=(EAlarmRepeatDefintionRepeatOnce); TTime time; time.UniversalTime(); time += TTimeIntervalMinutes(2); alarm.SetUtcNextDueTime(time); // session specific alarm (has a TRequestStatus to complete) alarm.Characteristics().Set(EAlarmCharacteristicsSessionSpecific); TRequestStatus status; TheAlarmTest.Session().AlarmAddWithNotification(status, alarm); const TAlarmId id = alarm.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); // status should be pending TheAlarmTest.Test().Next(_L("checking request is pending")); TheAlarmTest(status == KRequestPending, __LINE__); TheAlarmTest.Test().Next(_L("Shutdown Alarm Server")); closeServers(); User::After(10000000); // check absence of alarm TheAlarmTest.Test().Next(_L("check alarm notification has been aborted")); TheAlarmTest(status != KRequestPending, __LINE__); // Get the abort // (Probably KErrDied though KErrServerTerminated should be okay too) User::WaitForRequest(status); TInt stat = status.Int(); TheAlarmTest((stat == KErrDied) || (stat == KErrServerTerminated), __LINE__); // now restart Alarm Server TheAlarmTest.Test().Next(_L("restart Alarm Server")); TheAlarmTest.TestStartServers(); // check presence of alarm TheAlarmTest.Test().Next(_L("check shutdown deleted alarm")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarm) == KErrNotFound, __LINE__);#endif }static void doTestSessionUtcAlarmBackupRestoreL() { TheAlarmTest.Test().Next(_L("* Test that Session alarm is orphaned by restore")); TheAlarmTest.TestClearStoreL(); // Set the session alarm TheAlarmTest.Test().Next(_L("set session alarm in 20 minutes")); TASShdAlarm alarmWrite; alarmWrite.Category()=(KASCliCategoryClock); alarmWrite.RepeatDefinition()=EAlarmRepeatDefintionRepeatOnce; TTime time; time.UniversalTime(); time += TTimeIntervalMinutes(20); alarmWrite.SetUtcNextDueTime(time); // session specific alarm (has a TRequestStatus to complete) alarmWrite.Characteristics().Set(EAlarmCharacteristicsSessionSpecific); TRequestStatus status; TheAlarmTest.Session().AlarmAddWithNotification(status, alarmWrite); // check that alarm was set okay const TAlarmId id = alarmWrite.Id(); TheAlarmTest(id != KNullAlarmId, __LINE__); // status should be pending TheAlarmTest.Test().Next(_L("checking request is pending")); TheAlarmTest(status == KRequestPending, __LINE__); // remember the alarm time TTime alarmTime = alarmWrite.NextDueTime(); // make the Alarm server re-internlize .... TheAlarmTest.Test().Next(_L("now simulating restore...")); TRAPD(err, SimulateBackupServerRestorationL()); TheAlarmTest(err==KErrNone, __LINE__); // allow Alarm server to Internalize... User::After(1000000); // 1s // check old alarm queue has been cleared TheAlarmTest.Test().Next(_L("check alarm notification has been aborted")); TheAlarmTest(status != KRequestPending, __LINE__); // Get the abort result User::WaitForRequest(status); TheAlarmTest(status.Int() == KErrCancel, __LINE__); // check presence of alarm TASShdAlarm alarmRead; TheAlarmTest.Test().Next(_L("check alarm is no longer a session alarm")); TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__); TheAlarmTest(!alarmRead.HasOwningSession(), __LINE__); TheAlarmTest(alarmRead.HasBecomeOrphaned(), __LINE__); // advance clock, wait for alarm User::SetUTCTime(alarmWrite.NextDueTime() - TTimeIntervalSeconds(3)); TheAlarmTest.Test().Next(_L("waiting for alarm to notify")); // wait until after alarm due time User::After(KTenSeconds); // alarm should be notifying // if Alarm Server server tries to access the TRequestStatus // there will be an Access Violation TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(id, alarmRead) == KErrNone, __LINE__); //TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__); const TAlarmState alarmState = alarmRead.State(); TheAlarmTest(alarmState == EAlarmStateNotifying, __LINE__); }static void doTestRestoreValidUtcAlarmDataL() { TheAlarmTest.Test().Next(_L("Data API test")); TheAlarmTest.TestClearStoreL(); TInt r; TAlarmId alarmId; TASShdAlarm alarm; TRequestStatus status; // alarm.Message()=(_L("Alarm with data")); TTime time; time.UniversalTime(); time += TTimeIntervalMinutes(2); alarm.SetUtcNextDueTime(time); // r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); TheAlarmTest(status == KRequestPending, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size()); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // time.UniversalTime(); time += TTimeIntervalMinutes(2); alarm.SetUtcNextDueTime(time); r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest.TestEventBuffer(EAlarmChangeEventAlarmData, status, alarmId); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // TheAlarmTest.WaitForNotificationBufferToBeEmptied(status, alarmId); r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(status == EAlarmChangeEventAlarmData, __LINE__); TheAlarmTest(alarmId = alarm.Id(), __LINE__); User::WaitForRequest(status); // HBufC8* buf = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pBuf(buf->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pBuf); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*buf == KSomeAlarmData, __LINE__); // TheAlarmTest.Test().Next(_L("Waiting for alarm to expire")); // advance clock to 3s before alarm due User::SetUTCTime(alarm.NextDueTime() - TTimeIntervalSeconds(3)); TheAlarmTest.WaitForEvent(EAlarmChangeEventTimerExpired, status, alarmId); TheAlarmTest(alarmId == alarm.Id(), __LINE__); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__); // r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // TheAlarmTest.Session().AlarmAddWithNotification(status, alarm, KSomeAlarmData); TheAlarmTest(alarmId = alarm.Id(), __LINE__); HBufC8* alarmdata = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pAlarmdata(alarmdata->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*alarmdata == KSomeAlarmData, __LINE__); TheAlarmTest.Session().AlarmNotificationCancelAndDequeue(alarmId); CleanupStack::PopAndDestroy(alarmdata); // alarm.Reset(); alarm.Message()=(_L("Alarm with data")); time.UniversalTime(); time += TTimeIntervalMinutes(2); alarm.SetUtcNextDueTime(time); // r = TheAlarmTest.Session().AlarmAdd(alarm, KSomeAlarmData); TheAlarmTest(alarmId = alarm.Id(), __LINE__); HBufC8* alarmdata1 = HBufC8::NewLC(KSomeAlarmData().Size()); TPtr8 pAlarmdata1(alarmdata1->Des()); r = TheAlarmTest.Session().GetAlarmData(alarm.Id(), pAlarmdata1); TheAlarmTest(r == KErrNone, __LINE__); TheAlarmTest(*alarmdata1 == KSomeAlarmData, __LINE__); CleanupStack::PopAndDestroy(alarmdata1); TheAlarmTest.Test().Next(_L("make real backup of alarmserver ini file")); User::After(1000000); // 1s BackupAlarmServerIniFileL(); User::After(1000000); // 1s TheAlarmTest.Test().Next(_L("Delete Alarm")); TheAlarmTest(TheAlarmTest.Session().AlarmDelete(alarmId) == KErrNone, __LINE__); User::After(1000000); // 1s TheAlarmTest.Test().Next(_L("restore alarmserver ini file")); RestoreAlarmServerIniFileL(); User::After(1000000); // 1s // TheAlarmTest.Test().Next(_L("testing data restoration")); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrInUse, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KSomeAlarmData().Size(), __LINE__); // r = TheAlarmTest.Session().AlarmDelete(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); // r = TheAlarmTest.Session().AlarmAdd(alarm); TheAlarmTest(r==KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataAttachL(alarm.Id(), KSomeAlarmData); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataDetach(alarm.Id()); TheAlarmTest(r == KErrNone, __LINE__); // r = TheAlarmTest.Session().AlarmDataSize(alarm.Id()); TheAlarmTest(r == KErrNotFound, __LINE__); CleanupStack::PopAndDestroy(buf); }//static void doTestsL() { // Initialise the drive list to empty and then get drive list data from // File Server. DriveList.FillZ(); User::LeaveIfError(FsSession.DriveList(DriveList)); BackupClient = conn::CSBEClient::NewL(); CleanupStack::PushL(BackupClient); CActiveScheduler* scheduler = new (ELeave) CActiveScheduler; CleanupStack::PushL(scheduler); CActiveScheduler::Install(scheduler); TheAlarmTest.TestStartServers(); TheAlarmTest(TheAlarmTest.Session().Connect() == KErrNone, __LINE__); TheAlarmTest.TestClearStoreL(); User::After(100000); // delete AlarmServer.ini file FsSession.Delete(KAlarmServerBackupFileFullPath); User::After(1000000); // 1. // Baseline for Internalize behaviour // [add alarms, shutdown, re-start alarm server, check alarms still queued] doTestAlarmQueueOrderShutdownStartupL(); // 2. // Backup, Restore Internalize behaviour // [add alarms, pretend backup/restore, check alarms queued again] doTestAlarmQueueOrderBackupRestoreL(); // 3. // Correct Alarms are Backed up and Restored // [add alarms, backup, delete alarms, add different alarms, restore, check queued alarms] doTestAlarmQueueBackupRestoreL(); // 4. // Alarm Sound Intervals are Backed up and Restored. doTestAlarmSoundIntervalsBackupRestoreL(); /* 5. * Should be able to add alarm or change Locale during Backup */ doTestAlarmAddDuringBackupL(); /* 6. * Testing Restore behaviour * a) Should not be able to add alarm during Restore * b) Should get Notifications at Start & End of Restore * c) Locale (time) changes during Restore should be processed, * (but Externalize happens when Restore ends). */ doTestAlarmAddDuringRestoreL(); /* 7. * Testing Failed Restore behaviour * a) Should get Notifications at Start & End of Restore * b) Alarm Queue should not change * c) Alarm Server should perform a new Externalize */ /* 8, 9. * Handling of Notifying alarm across Shutdown/Startup and Backup/Restore */ doTestNotifyingAlarmShutdownStartupL(); doTestNotifyingAlarmBackupRestoreL(); /* 10, 11. * Handling of Session alarm */ doTestSessionAlarmShutdownRestartL(); doTestSessionAlarmBackupRestoreL(); /* 12. * Test restore of alarm with attached data * [create alarm with data, backup, delete alarm, restore, check alarm & data] * (Based on test case in TAlarmData.) */ doTestRestoreValidAlarmDataL(); // UTC Tests // 13. // Baseline for Internalize behaviour // [add alarms, shutdown, re-start alarm server, check alarms still queued] doTestUtcAlarmQueueOrderShutdownStartupL(); // 14. // Backup, Restore Internalize behaviour // [add utc alarms, pretend backup/restore, check alarms queued again] doTestUtcAlarmQueueOrderBackupRestoreL(); // 15. // Correct UTC Alarms are Backed up and Restored // [add utc alarms, backup, delete alarms, add different alarms, restore, check queued alarms] doTestUtcAlarmQueueBackupRestoreL(); /* 16. * Should be able to add utc alarm or change Locale during Backup */ doTestUtcAlarmAddDuringBackupL(); /* 17. * Testing Restore behaviour * a) Should not be able to add utc alarm during Restore * b) Should get Notifications at Start & End of Restore * c) Locale (time) changes during Restore should be processed, * (but Externalize happens when Restore ends). */ doTestUtcAlarmAddDuringRestoreL(); /* 18. * Testing Failed Restore behaviour * a) Should get Notifications at Start & End of Restore * b) Alarm Queue should not change * c) Alarm Server should perform a new Externalize */ /* 19, 20. * Handling of Notifying UTC alarm across Shutdown/Startup and Backup/Restore */ doTestNotifyingUtcAlarmShutdownStartupL(); doTestNotifyingUtcAlarmBackupRestoreL(); /* 21, 22. * Handling of Session UTC alarm */ doTestSessionUtcAlarmShutdownRestartL(); doTestSessionUtcAlarmBackupRestoreL(); /* 23. * Test restore of alarm with attached data * [create utc alarm with data, backup, delete alarm, restore, check alarm & data] * (Based on test case in TAlarmData.) */ doTestRestoreValidUtcAlarmDataL(); /* 24. * Baseline for Internalize behaviour * [add alarms, shutdown, re-start alarm server, check local due time is unchanged] */ doTestUtcAlarmDSTShutdownStartupL(); doTestFloatingAlarmDSTShutdownStartupHelsinkiL(); // cleanup CleanupStack::PopAndDestroy(scheduler); CleanupStack::PopAndDestroy(BackupClient); TheAlarmTest.TestClearStoreL(); }///**@SYMTestCaseID PIM-TBACKUPALARMS-0001*/GLDEF_C TInt E32Main() { __UHEAP_MARK; CTrapCleanup* cleanup = CTrapCleanup::New(); if (!cleanup) return KErrNoMemory; TheAlarmTest.Test().Title(); TheAlarmTest.Test().Start(_L("@SYMTestCaseID:PIM-TBACKUPALARMS-0001 Backup Alarms")); // initialise globals FsSession.Connect(); TheAlarmTest.Test().Next(_L("SECURE_DATA mode")); // actually do tests TRAPD(error, doTestsL()); // Cleanup files // delete test file FsSession.Delete(KAlarmServerTestBackupFile); // delete AlarmServer.ini file FsSession.Delete(KAlarmServerBackupFileFullPath); FsSession.Close(); // did any test Leave? TheAlarmTest(error == KErrNone, __LINE__); // TheAlarmTest.Test().End(); TheAlarmTest.Test().Close(); ASTstAlarmTest::Close(); delete cleanup; __UHEAP_MARKEND; return KErrNone; }