// 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 "caltestlib.h"

#include <e32std.h>

#include <e32test.h>

#include <asclisession.h>

#include <asshdalarm.h>

#include <tz.h>

#include <calalarm.h>

#include <calentry.h>

#include <calentryview.h>

#include <calrrule.h>

#include <centralrepository.h>

#include <e32property.h>

#include <asshdalarm.h>

#include <calrrule.h>

#include <coreappstest/utilities.h>

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

#include <calinstanceview.h>

#include <calsession.h>

#include <calinstance.h>

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <asshdalarmcal.h>

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

RTest test(_L("tcal_alarm"));

_LIT8(KGUID,  "A_Global_UID");

_LIT8(KGUID1, "A_Global_UID1");

_LIT8(KGUID2, "A_Global_UID2");

_LIT8(KGUID3, "A_Global_UID3");

_LIT8(KGUID4, "A_Global_UID4");

_LIT8(KGUID5, "A_Global_UID5");

_LIT(KCalendarFile, "tcal_alarm");

_LIT(KCalendarFileLoc, "c:tcal_alarm");

_LIT(KCalendarFile2, "tcal_alarm_secondFile");

// Timezone constants

_LIT8(KEuropeBerlin, "Europe/Berlin");

_LIT8(KAsiaTokyo,    "Asia/Tokyo");

_LIT8(KEuropeLondon,    "Europe/London");

_LIT8(KEuropeParis,    "Europe/Paris");

_LIT8(KAtlanticStanley,    "Atlantic/Stanley");

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

_LIT8(KEuropeHelsinki, "Europe/Helsinki");

#endif

const TInt KAlarmOffset = 10;

//back off period. Used when setting the time just before alarm expiry.

const TTimeIntervalSeconds KAlarmExpiryBackOffPeriod(5);

// Central Repository Uid

const TUid KUidCentralRepositoryAgenda = { 0x10003a5b };

// Used for configuration of whether or not to notify missing alarms

const TUint KKeyQueueMissingAlarm = 100;

//Timeout period of 2 minutes

const TInt KTimeOutPeriod = 120000000;

enum TCenRepValue

	{

	// Skipped alarms will notify, but not be queued

	ESkippedAlarmsNotifySubscriber = 0,

	// Skipped alarms will queue and expire (default)

	ESkippedAlarmsQueueAndExpire = 1	

	};

enum TPubSubValue

	{

	ENoChange = 0, // There is no published data from the alarmserver

	ETzChanged = 1,//Time zone has been changed but there are no missing alarms

	EAlarmMissed = 2 // There are some missing alarms when system time has been put forward	

	};

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

enum TSystemTimeOrUTC

	{

	ESystemTime,

	EUTC

	};

#endif

struct TFloatingAndFixedEntryData

	{

	TCalTime iParentStartTime;

	TCalTime iChildStartTime;

	TTime iParentAlarmTimeLocal;

	TTime iChildAlarmTimeLocal;

	TCalLocalUid iParentLocalUid;

	TCalLocalUid iChildLocalUid;

	};

class CAlarmTestManager : public CActive

	{

public:

	static CAlarmTestManager* NewLC();

	~CAlarmTestManager();	

	//Set the value in central repository to test different behaviour. An application is normally 

	//not able to do so since it is constrained by their security policy.

	void SetCenRepValuseL(TCenRepValue aValue);

	void Start();

private:

	// avoid any method but NewL instancing the class

	CAlarmTestManager();

	// no copy constructor and assignment operator

	CAlarmTestManager(CAlarmTestManager& );

	CAlarmTestManager& operator = (const CAlarmTestManager& );

	void ConstructL();

	void SetupTestAppL();

	void TestUpdateAlarmL(TBool aFloating = EFalse);

	void TestMultipleAlarmsL(TBool aFloating = EFalse);

	void TestDEF079490L(TBool aFloating = EFalse);

	void SetTimeZoneL(const TDesC8& aTimeZone);

	void SetupAlarmsBeforeTzChangeL();

	void CheckAlarmsBeforeTzChangeL();

	void CheckNonStopTodoAlarmL();

	void TestAlarmEntryL();

	void TestAlarmOffsetL();

	void SnoozeAlarmAndUpdateEntryL();

	// Test suite

	void TestAddAlarmL(const TBool aFloating = EFalse);

	void TestAddAlarmsSummerWinterL(const TBool aFloating = EFalse);

	void TestDeleteAlarmsSummerWinterL(const TBool aFloating = EFalse);

	void TestFloatingAndFixedEntryAlarmTimeSetupL(TBool aIsFloatingEntry);

	void TestFloatingAndFixedEntryAlarmTimeCheckL(TBool aIsFloatingEntry);

	void TestFloatingAndFixedEntryAlarmTimeReopenAndCheckL(TBool aIsFloatingEntry);

	void TestFloatingAndFixedEntryAlarmTimeCheckAgainL(const TBool aIsFloatingEntry);

	void CreateAndStoreEntriesWithAlarmAttachmentsLC(TBool aIsFloatingEntry, CCalEntry*&aParentEntry, CCalEntry*& aChildEntry);

	void TestAddAlarmL(const TTime& aStartTime, const TInt aAlarmMinutes, HBufC8* aGuid = NULL, const TBool aFloating = EFalse);

	void TestAddAlarmInTodoL(const TTime& aStartTime, const TTime& aEndTime, const TBool aFloating = EFalse);

	void TestDeleteAlarmL(const TTime& aStartTime, const TInt aAlarmMinutes, const TBool aFloating = EFalse);

	CCalEntry* CreateAlarmedEntryLC(CCalEntry::TType aType, const TTime& aStartTimeLocal, 

								    const TTime& aEndTimeLocal, TInt aTimeOffset, HBufC8* aGuid = NULL, TBool aFloating = EFalse);

	TAlarmId CheckAlarmL(const TTime& aAlarmTime, TCalLocalUid aLocalUid, const TDesC8& aGuid = KNullDesC8, const TBool aFloating=EFalse);

	void CheckAndSnoozeAlarmL(const TTime& aAlarmTime, TCalLocalUid aLocalUid, const TDesC8& aGuid, const TBool aFloating=EFalse);

	void CheckNoAlarmWentOffL(const TTime& aAlarmTime);

	void ClearAllAlarmsL();

	TCalLocalUid AddEntryWithAlarmL(const TTime& aStartTime, TInt aAlarmMinutes, HBufC8* aGuid = NULL, TBool aFloating = EFalse);

	void TestPubSubValue(TPubSubValue aValue);

	void TestChangeSystemTimeL(TBool aIsFloating, TBool aChangeSysTimeSameAsAlarmTime);

	void AddFourEntriesWithAlarmsL();

	void TestFloatingAlarmNotificationL();

	void CheckAlarmAttachmentSizeL();

	void TestNotifiedAlarmL();

	void TestAlarmNotDeletedInDiffFileL();

	void TestAlarmDeletedInSameFileL();

	void TestAlarmDeletedWhenFileDeletedL();

	void TestRetrieveSkippedAlarmsAfterSystemTimeChangeL();

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS	

	void CheckNextQueuedAlarmL(const TTime& aAlarmTime);	

	void RetrieveAlarmedInstancesLC(RPointerArray<CCalInstance>& aInstances);

	void RetrieveAlarmedInstancesLC(RPointerArray<CCalInstance>& aInstances, TPckgBuf<TASShdAlarmedInstanceParams>& aParamsBuf);

	void WaitForAlarmAdditionL();

	void CreateAndAddEntriesL(TBool aFloating1, const TTime& aTime1, TBool aFloating2, const TTime& aTime2);

	void CreateAndAddEntryL(TBool aFloating, const TTime& aTime);

	void NotifySubscriberWithCalendarRunningL();

	void NotifySubscriberWithoutCalendarRunningL();

	void RetrieveSkippedAlarmsAfterRestartL(TSystemTimeOrUTC aSystemTimeOrUTC);

	void TestFloatingAlarmWithPositiveUtcOffsetL();

	void TestFloatingAlarmWithNegativeUtcOffsetL();

	void TestTimeAndUtcChangeL();

	void TestFixedAndFloatingWithUtcChangeL();

	void TestTimeChangeWithNoSkippedAlarmL();

#endif	

	// from CActive

	void RunL();

	void DoCancel();

private:

	CCalTestLibrary*	iTestLibrary;	

	RASCliSession		iAlarmServer;

	TTime				iExpectedInstanceTime;

	TBuf8<256>			iCurrentTimeZone;

	TInt				iTestStep;

	TFloatingAndFixedEntryData	iFloatingAndFixedData;

	TCenRepValue iQueueAlarm;

	TTime iTimeSysTimeChanged;

 	};

// Constructor/Destructor

CAlarmTestManager* CAlarmTestManager::NewLC()

	{

	CAlarmTestManager* self = new (ELeave) CAlarmTestManager;

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CAlarmTestManager::CAlarmTestManager() : CActive(EPriorityIdle)

	{

	CActiveScheduler::Add(this);

	}

void CAlarmTestManager::ConstructL()

	{	

	iTestLibrary = CCalTestLibrary::NewL(EFalse);

	iTestLibrary->PIMTestServer().GetTimeZoneL(iCurrentTimeZone);

	SetTimeZoneL(KEuropeBerlin);

	iTestLibrary->ReplaceFileL(KCalendarFile());

	iTestLibrary->OpenFileL(KCalendarFile());

	// Connect to the alarm server

	User::LeaveIfError(iAlarmServer.Connect());

	// Make sure that the alarm queue is empty.

	ClearAllAlarmsL();

	}

CAlarmTestManager::~CAlarmTestManager()

	{

	SetCenRepValuseL(ESkippedAlarmsQueueAndExpire);//default behaviour

	if ( iTestLibrary && iCurrentTimeZone.Length() )

		{

		TRAP_IGNORE(SetTimeZoneL(iCurrentTimeZone));

		}	

	iAlarmServer.Close();

	TRAP_IGNORE( iTestLibrary->DeleteFileL(KCalendarFile) );

	delete iTestLibrary;

	}

void CAlarmTestManager::SetTimeZoneL(const TDesC8& aTimeZone)

	{

	iTestLibrary->SetTimeZoneL(aTimeZone);

	User::After(500000);

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Test cases forming the Alarm test suite

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

// case 0

// case 1

void CAlarmTestManager::TestAddAlarmL(const TBool aFloating)

	{

	TTime startTime(TDateTime(2005, EJanuary, 7, 10, 0, 0, 0));

	TestAddAlarmInTodoL(startTime, startTime + TTimeIntervalDays(1), aFloating);	// alarm on 9th Jan at 9:50

	TestAddAlarmInTodoL(startTime, Time::NullTTime(), aFloating);	// alarm on 8th Jan at 9:50

	}	

// case 2

void CAlarmTestManager::TestAddAlarmsSummerWinterL(const TBool aFloating)

	{

	// test adding alarms in summer and winter time zones with "when entry is set to floating" option

	TestAddAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), 0, NULL, aFloating); 		// alarm on 8th Mar at 10:00

	TestAddAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), 1000, NULL, aFloating);	// alarm on 7th Mar at 17:20

	TestAddAlarmL(TDateTime(2005, EJuly, 7, 10, 0, 0, 0), 0, NULL, aFloating); 		// alarm on 8th Jul at 10:00

	TestAddAlarmL(TDateTime(2005, EJuly, 7, 10, 0, 0, 0), 1000, NULL, aFloating);	// alarm on 7th Jul at 17:20

	// test negative alarms

	TestAddAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), -10); 	// alarm on 8th Mar at 10:10

	TestAddAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), -839); 	// alarm on 8th Mar at 23:59

	}	

// case 3

void CAlarmTestManager::TestMultipleAlarmsL(const TBool aFloating)

	{

	TTime alarm1(TDateTime(2005, EFebruary, 3, 9, 0, 0, 0));

	TTime alarm2(TDateTime(2005, EFebruary, 3, 9, 5, 0, 0));

	TTime alarm3(TDateTime(2005, EFebruary, 3, 9, 6, 0, 0));

	TTime alarm4(TDateTime(2005, EFebruary, 3, 9, 10, 0, 0));

	iTestLibrary->PIMTestServer().SetHomeTime(alarm1 - TTimeIntervalHours(1)); // alarm must be in the future when store entry

	CCalEntry* entry1 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm1, alarm1, 0, KGUID1().AllocLC(), aFloating); // 09:00 on 4 Feb 05, alm at 9:00

	CCalEntry* entry2 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm2, alarm2, 1, KGUID2().AllocLC(), aFloating); // 09:05 on 4 Feb 05, alm at 9:04

	CCalEntry* entry3 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm3, alarm3, 1, KGUID3().AllocLC(), aFloating); // 09:06 on 4 Feb 05, alm at 9:05

	CCalEntry* entry4 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm4, alarm4, 5, KGUID4().AllocLC(), aFloating); // 09:10 on 4 Feb 05, alm at 9:05

	RPointerArray<CCalEntry> entriesToStore;

	CleanupClosePushL(entriesToStore);

	entriesToStore.AppendL(entry1);

	entriesToStore.AppendL(entry2);

	entriesToStore.AppendL(entry3);

	entriesToStore.AppendL(entry4);

	test.Printf(_L("Adding alarmed entries at 9:00, 9:04, 9:05 and 9:05\n"));

	TInt entriesStored = 0;

	iTestLibrary->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored);

	test(entriesToStore.Count() == entriesStored);	

	TCalLocalUid localUid1 = entry1->LocalUidL();

	TCalLocalUid localUid2 = entry2->LocalUidL();

	TCalLocalUid localUid3 = entry3->LocalUidL();

	TCalLocalUid localUid4 = entry4->LocalUidL();

	CleanupStack::PopAndDestroy(5);	//&entriesToStore, entry4, entry3, entry2, entry1

	iExpectedInstanceTime = alarm1;

	CheckAlarmL(alarm1, localUid1, KGUID1(), aFloating );

	iExpectedInstanceTime = alarm2;

	CheckAlarmL(alarm2 - TTimeIntervalMinutes(1), localUid2, KGUID2(), aFloating);

	iExpectedInstanceTime = alarm3;

	CheckAlarmL(alarm3 - TTimeIntervalMinutes(1), localUid3, KGUID3(), aFloating);

	// The alarms for entry3 and entry4 are set for the same time.

	// This means the next test will receive the details for entry3.

	iExpectedInstanceTime = alarm3;

	CheckAlarmL(alarm4 - TTimeIntervalMinutes(5), localUid3, KGUID3(), aFloating);

	}

// case 4

/* removed, was SetTimeZoneL(KAsiaTokyo) */

// case 5

void CAlarmTestManager::TestDeleteAlarmsSummerWinterL(const TBool aFloating)

	{

	// Make sure that the alarm queue is empty.

	ClearAllAlarmsL();	

	// test deleting alarms in summer and winter time zones with "when entry is set to floating" option		

	TestDeleteAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), 0, aFloating); 	// alarm on 8th Mar at 10:00

	TestDeleteAlarmL(TDateTime(2005, EMarch, 7, 10, 0, 0, 0), 1000, aFloating);	// alarm on 7th Mar at 17:20

	TestDeleteAlarmL(TDateTime(2005, EJuly, 7, 10, 0, 0, 0), 0, aFloating); 	// alarm on 8th Jul at 10:00

	TestDeleteAlarmL(TDateTime(2005, EJuly, 7, 10, 0, 0, 0), 1000, aFloating);	// alarm on 7th Jul at 17:20

	}

// case 6

void CAlarmTestManager::TestUpdateAlarmL(const TBool aFloating)

	{

	TTime alarm1(TDateTime(2005, EJanuary, 20, 9, 0, 0, 0));

	TTime alarm2(TDateTime(2005, EJanuary, 20, 9, 1, 0, 0));

	TTime alarm3(TDateTime(2005, EJanuary, 20, 9, 5, 0, 0));

	iTestLibrary->PIMTestServer().SetHomeTime(alarm1 - TTimeIntervalHours(1)); // alarm must be in the future when store entry

	CCalEntry* entry1 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm1, alarm1, 0, KGUID1().AllocLC(), aFloating); // 09:00 on 21 Jan 05, alm at 9:00

	CCalEntry* entry2 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm2, alarm2, 0, KGUID2().AllocLC(), aFloating); // 09:01 on 21 Jan 05, alm at 9:01

	CCalEntry* entry3 = CreateAlarmedEntryLC(CCalEntry::EAppt, alarm3, alarm3, 0, KGUID3().AllocLC(), aFloating); // 09:05 on 21 Jan 05, alm at 9:05

	RPointerArray<CCalEntry> entriesToStore;

	CleanupClosePushL(entriesToStore);

	entriesToStore.AppendL(entry1);

	entriesToStore.AppendL(entry2);

	entriesToStore.AppendL(entry3);

	test.Printf(_L("Adding alarmed entries at 9:00, 9:01, 9:05\n"));

	TInt entriesStored = 0;	

	iTestLibrary->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored);

	test(entriesToStore.Count() == entriesStored);	

	test.Printf(_L("Deleting entry at 9:00\n"));

	iTestLibrary->SynCGetEntryViewL().DeleteL(*entry1);

	test.Printf(_L("Moving entry from 9:05 to 9:03\n"));

	CCalAlarm* almEntry3 = entry3->AlarmL();

	CleanupStack::PushL(almEntry3);

	almEntry3->SetTimeOffset(TTimeIntervalMinutes(2));

	entry3->SetAlarmL(almEntry3);

	entriesToStore.Reset();

	entriesToStore.AppendL(entry3);

	iTestLibrary->SynCGetEntryViewL().UpdateL(entriesToStore, entriesStored);

	CleanupStack::PopAndDestroy(almEntry3);

	CleanupStack::PopAndDestroy(&entriesToStore);

	CleanupStack::PopAndDestroy(entry3);

	CleanupStack::PopAndDestroy(entry2);

	CleanupStack::PopAndDestroy(entry1);

	// Connect to the alarm server

	User::LeaveIfError(iAlarmServer.Connect());

	}

// case 7

/* removed, was "Start floating entry test" */

// case 8

/* removed, was TestAddAlarmL(ETrue) */

// case 9

/* removed, was TestAddAlarmsSummerWinterL(ETrue) */

// case 10

/* removed, was TestMultipleAlarmsL(ETrue) */

// case 11

/* removed, was SetTimeZoneL(KAsiaTokyo) */

// case 12

/* removed, was TestDeleteAlarmsSummerWinterL(ETrue) */

// case 13

/* removed, was TestUpdateAlarmL(ETrue) */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

CCalEntry* CAlarmTestManager::CreateAlarmedEntryLC(CCalEntry::TType aType, const TTime& aStartTimeLocal, 

								const TTime& aEndTimeLocal, TInt aTimeOffset, HBufC8* const aGuid, const TBool aFloating)

	{

	HBufC8* guid = aGuid;

	if ( ! guid )

		{

		guid = KGUID().AllocLC();

		}

	CCalEntry* entry = CCalEntry::NewL(aType, guid, CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	TCalTime calStartTime;

	TCalTime calEndTime;

	if (aFloating)

		{

		calStartTime.SetTimeLocalFloatingL(aStartTimeLocal);

		calEndTime.SetTimeLocalFloatingL(aEndTimeLocal);

		}

	else

		{

		calStartTime.SetTimeLocalL(aStartTimeLocal);

		calEndTime.SetTimeLocalL(aEndTimeLocal);

		}

	entry->SetStartAndEndTimeL(calStartTime, calEndTime);

	CCalAlarm* alarm = CCalAlarm::NewL();

	CleanupStack::PushL(alarm);

	alarm->SetTimeOffset(aTimeOffset);

	entry->SetAlarmL(alarm);

	CleanupStack::PopAndDestroy(alarm);

	return ( entry );

	}

void CAlarmTestManager::CheckAlarmsBeforeTzChangeL() 

    { 

    // expecting 4 alarms at UTC times given in above function. 

    // current time zone is Helsinki 

    iExpectedInstanceTime = TDateTime(2006, EMarch, 9, 2, 0, 0, 0); 

    CheckAlarmL(TDateTime(2006, EMarch, 9, 1, 50, 0, 0), 0, _L8("SetupAlarmsBeforeTzChangeL_1")); 

    CheckAlarmL(TDateTime(2006, EMarch, 9, 2, 0, 0, 0), 0, _L8("SetupAlarmsBeforeTzChangeL_2")); 

    CheckAlarmL(TDateTime(2006, EMarch, 8, 17, 00, 0, 0), 0, _L8("SetupAlarmsBeforeTzChangeL_3")); 

    } 

TAlarmId CAlarmTestManager::CheckAlarmL(const TTime& aAlarmTime, const TCalLocalUid aLocalUid, const TDesC8& aGuid, const TBool aFloating)

	{

	const TInt KQueuedAlarms = iAlarmServer.AlarmCountByState(EAlarmStateQueued);

	iTestLibrary->PIMTestServer().SetHomeTime(aAlarmTime - KAlarmExpiryBackOffPeriod);

	CAlarmEventWatcher* alarmwatcher = CAlarmEventWatcher::NewL(iAlarmServer);

	CleanupStack::PushL(alarmwatcher);

	alarmwatcher->StartWaitingForEventL(EAlarmChangeEventSystemDateTimeChanged, KTimeOutPeriod);

	alarmwatcher->StartWaitingForEventL(EAlarmChangeEventAlarmAddition, KTimeOutPeriod);

	CleanupStack::PopAndDestroy(alarmwatcher);

	TTime homeTime;

	homeTime.HomeTime();

	_LIT(KFormatTime,"%D %H:%T:%S.   ");

	TBuf<128> timeTxt;

	homeTime.FormatL(timeTxt, KFormatTime);

	TDateTime dt = aAlarmTime.DateTime();

	test.Printf(_L("CheckAlarmL: Expecting the next due alarm at = %d/%d/%d, %d:%d"), 

					dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute());

	TAlarmId almId;

	TASShdAlarm alarmData;

	if (iAlarmServer.GetNextDueAlarmId(almId) == KErrNone)

		{ 

		if (iAlarmServer.GetAlarmDetails(almId, alarmData) == KErrNone)

			{

			test(alarmData.IsFloating()==aFloating);

			test.Printf(_L("CheckAlarmL: Next Due Alarm Id = %d "), almId);

			test.Printf(_L("CheckAlarmL: No of alarms queued at the beginning = %d"), KQueuedAlarms);

			test.Printf(_L("CheckAlarmL: Entry localuid = %d"), aLocalUid);

			TTime alarmNextDueTime = alarmData.NextDueTime();

			if(!alarmData.IsFloating())

				{

				//The alarm next due time is in UTC

				//add the UTC offset to find teh local time of the alarm

				alarmNextDueTime+=User::UTCOffset();

				}

			TDateTime dueDt = alarmNextDueTime.DateTime();

			alarmNextDueTime.FormatL(timeTxt, KFormatTime);	

			test.Printf(_L("CheckAlarmL: Next Due Alarm Time = %d/%d/%d, %d:%d"), 

					dueDt.Day()+1, dueDt.Month()+1, dueDt.Year(), dueDt.Hour(), dueDt.Minute());