--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappservices/calendar/tsrc/tcal_calendarinfo.cpp Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,960 @@
+// 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 "caltestoom.h"
+
+#include <calsession.h>
+#include <e32test.h>
+#include <calcalendarinfo.h>
+#include <calcalendariterator.h>
+#include <calentry.h>
+#include <calentryview.h>
+#include <calalarm.h>
+#include <asclisession.h>
+#include <asshdalarm.h>
+
+RTest test(_L("tcal_calendarinfo"));
+
+_LIT8(KGUID, "A_Global_UID");
+_LIT8(KGUID1, "A_Global_UID1");
+_LIT8(KGUID2, "A_Global_UID2");
+_LIT8(KGUID3, "A_Global_UID3");
+
+_LIT(KCalendarFile, "tcal_calendarinfo");
+_LIT(KCalendarFileExpected, "c:tcal_calendarinfo");
+_LIT(KCalendarFilePrivatePath, "c:\\private\\10003a5b\\tcal_calendarinfo");
+
+// calendar info values
+_LIT(KCalendarName, "Calendar");
+_LIT(KCalendarDescription, "This is a calendar");
+const TRgb KCalendarColor(0xD7, 0x10, 0x01, 0xFF);
+const TBool KCalendarEnabled(ETrue);
+
+_LIT8(KPropertyTimeKey, "time");
+const TTime KPropertyTimeValue(TDateTime(2007, EMarch, 5, 12, 30, 0, 0));
+_LIT8(KPropertyStringKey, "string");
+_LIT8(KPropertyStringValue, "Here is some 8 bit text.");
+_LIT8(KPropertyIntKey, "int");
+const TInt KPropertyIntValue(34);
+
+class CTestManager : public CBase, public MCalTestOomCallBack
+ {
+private:
+ enum
+ {
+ EOomTestCaseCreateCalFileWithInfo,
+ EOomTestCaseSetInfoOnFileWithoutInfo,
+ EOomTestCaseUpdateInfo,
+ EOomTestCaseFetchInfo,
+ EOomTestCaseIterateOverAllInfo,
+ EOomTestCaseLast
+ };
+
+public:
+ static CTestManager* NewLC();
+ ~CTestManager();
+
+ void RunTestsL();
+
+private:
+ CTestManager();
+ void ConstructL();
+
+ static void CleanupDeleteCalFile(TAny* aRef);
+
+private: // from MCalTestOomCallBack
+ void OomTestL(TType aType, TInt aFailAt);
+ void AddEntryWithAlarmL(const TTime& aStartTime, TInt aAlarmMinutes, HBufC8* aGuid, TBool aFloating);
+
+private: // tests ...
+ void TestCreateFileWithMetaDataL();
+ void TestSetMetaDataL();
+ void TestGetMetaDataL();
+ void TestGetAllMetaDataL();
+ void TestOomL();
+ void TestAlarmStatusChangeL();
+ void TestAlarmStatusWithAgendaShutDownL();
+ void TestSetAndUpdatePropertyL();
+ void TestGetPropertyL();
+ void TestRemovePropertyL();
+ void TestReplaceMetadataL();
+
+private:
+ CCalTestLibrary* iTestLibrary; // need a connection to a session to create a CCalEntry
+ TCalFileId iFileId;
+ RASCliSession iAlarmServer;
+ TInt iOomTestCase;
+ };
+
+CTestManager* CTestManager::NewLC()
+ {
+ CTestManager* self = new (ELeave) CTestManager;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ // CleanupStack::Pop(self);
+ return (self);
+ }
+
+CTestManager::CTestManager()
+ {
+ }
+
+void CTestManager::ConstructL()
+ {
+ iTestLibrary = CCalTestLibrary::NewL();
+
+ test.Printf(_L("Make sure the file is deleted when we start the test"));
+ TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));
+
+ User::LeaveIfError(iAlarmServer.Connect());
+ }
+
+CTestManager::~CTestManager()
+ {
+ delete iTestLibrary;
+ iAlarmServer.Close();
+ }
+
+void CTestManager::CleanupDeleteCalFile(TAny* aRef)
+ {
+ CCalSession* session = static_cast<CCalSession*>(aRef);
+
+ TRAPD(error, session->DeleteCalFileL(KCalendarFile));
+
+ if (error != KErrNone)
+ {
+ test.Printf(_L("There was a problem deleting the file! %d"), error);
+ }
+
+ delete session;
+ }
+
+void CTestManager::TestSetAndUpdatePropertyL()
+ {
+ test.Next(_L("Test setting some properties"));
+
+ test.Printf(_L("create some meta data"));
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Add some properties to the metadata"));
+ TTime now;
+ now.HomeTime();
+ TPckgC<TTime> timePckg1(now);
+ calendarInfo->SetPropertyL(KPropertyTimeKey, timePckg1);
+
+ TPckgC<TInt> intPckg1(KPropertyIntValue + 1);
+ calendarInfo->SetPropertyL(KPropertyIntKey, intPckg1);
+
+ calendarInfo->SetPropertyL(KPropertyStringKey, KPropertyStringValue);
+
+ test.Printf(_L("Create a calendar file with the metadata"));
+ iTestLibrary->GetSession().CreateCalFileL(KCalendarFile, *calendarInfo);
+
+ test.Next(_L("Test updating some of the metadata properties"));
+ TPckgC<TTime> timePckg2(KPropertyTimeValue);
+ calendarInfo->SetPropertyL(KPropertyTimeKey, timePckg2);
+
+ TPckgC<TTime> intPckg2(KPropertyIntValue);
+ calendarInfo->SetPropertyL(KPropertyIntKey, intPckg2);
+
+ test.Printf(_L("Open the file"));
+ iTestLibrary->GetSession().OpenL(KCalendarFile);
+
+ test.Printf(_L("Set the calendar info"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+void CTestManager::TestGetPropertyL()
+ {
+ test.Next(_L("Test fetching the metadata"));
+
+ // fetch the calendar info from the session
+ CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Fetch the property keys"));
+ CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();
+ CleanupStack::PushL(propertyKeys);
+
+ test.Printf(_L("Test that there are only three properties"));
+ test(propertyKeys->Count() == 3);
+
+ test.Printf(_L("Test that all three property keys are found"));
+ TInt pos(KErrNotFound);
+ test(propertyKeys->Find(KPropertyTimeKey, pos, ECmpNormal) != KErrNotFound);
+ test(propertyKeys->Find(KPropertyIntKey, pos, ECmpNormal) != KErrNotFound);
+ test(propertyKeys->Find(KPropertyStringKey, pos, ECmpNormal) != KErrNotFound);
+
+ CleanupStack::PopAndDestroy(propertyKeys);
+
+ test.Printf(_L("Test that the time property is set to the correct value"));
+ TTime time;
+ TPckgC<TTime> timeBuf(time);
+ timeBuf.Set(calendarInfo->PropertyValueL(KPropertyTimeKey));
+ time = timeBuf();
+ test(time == KPropertyTimeValue);
+
+ test.Printf(_L("Test that the int property is set to the correct value"));
+ TInt intVal;
+ TPckgC<TInt> intBuf(intVal);
+ intBuf.Set(calendarInfo->PropertyValueL(KPropertyIntKey));
+ intVal = intBuf();
+ test(intVal == KPropertyIntValue);
+
+ test.Printf(_L("Test that the string property is set to the correct value"));
+ test(calendarInfo->PropertyValueL(KPropertyStringKey).Compare(KPropertyStringValue) == 0);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+void CTestManager::TestRemovePropertyL()
+ {
+ test.Next(_L("Test that we can remove a property from the properties"));
+
+ test.Printf(_L("Fetch the calendar info"));
+ CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("We should have 3 property keys before removing one"));
+ CDesC8Array* array = calendarInfo->PropertyKeysL();
+ test(array->Count() == 3);
+ delete array;
+
+ test.Printf(_L("Remove the property by key"));
+ calendarInfo->RemovePropertyL(KPropertyTimeKey);
+
+ test.Printf(_L("We should now have 2 properties after removing one"));
+ array = calendarInfo->PropertyKeysL();
+ test(array->Count() == 2);
+ delete array;
+
+ test.Printf(_L("Set the calendar info"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+
+ calendarInfo = iTestLibrary->GetSession().CalendarInfoL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Test that there are now only two keys"));
+ CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();
+ CleanupStack::PushL(propertyKeys);
+
+ test(propertyKeys->Count() == 2);
+
+ test.Printf(_L("Test that the correct two property keys are found"));
+ TInt pos(KErrNotFound);
+ test(propertyKeys->Find(KPropertyIntKey, pos, ECmpNormal) != KErrNotFound);
+ test(propertyKeys->Find(KPropertyStringKey, pos, ECmpNormal) != KErrNotFound);
+
+ CleanupStack::PopAndDestroy(propertyKeys);
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+void CTestManager::TestReplaceMetadataL()
+ {
+ _LIT8(KDifferentKey, "different key");
+ _LIT8(KDifferentValue, "different value");
+
+ test.Next(_L("Test that we can replace the metadata"));
+
+ test.Printf(_L("create some new metadata"));
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Add a property to the metadata"));
+ calendarInfo->SetPropertyL(KDifferentKey, KDifferentValue);
+
+ test.Printf(_L("set the metadata"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+
+ test.Printf(_L("fetch the metadata"));
+ calendarInfo = iTestLibrary->GetSession().CalendarInfoL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Test that there is only the one new key"));
+ CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();
+ CleanupStack::PushL(propertyKeys);
+
+ test(propertyKeys->Count() == 1);
+
+ test.Printf(_L("Test that the correct two property keys are found"));
+ TInt pos(KErrNotFound);
+ test(propertyKeys->Find(KDifferentKey, pos, ECmpNormal) != KErrNotFound);
+
+ CleanupStack::PopAndDestroy(propertyKeys);
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0001
+@SYMPreq CR1985
+@SYMTestCaseDesc Test that we can create a file with metadata.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Create a calendar info instance and set some values on it
+ 2. Create a file and specify that the calendar info is associated with it
+
+@SYMTestExpectedResults The calendar file should be created and the metadata set on it.
+**/
+void CTestManager::TestCreateFileWithMetaDataL()
+ {
+ test.Next(_L("Test that a file can be created with meta data"));
+
+ test.Printf(_L("Make sure the file is deleted when we start the test"));
+ TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));
+
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Set some properties on the meta data"));
+ calendarInfo->SetNameL(KCalendarName);
+ calendarInfo->SetDescriptionL(KCalendarDescription);
+ calendarInfo->SetColor(KCalendarColor);
+ calendarInfo->SetEnabled(KCalendarEnabled);
+
+ test.Printf(_L("Use the create cal file overload method that takes calendar info"));
+ iTestLibrary->GetSession().CreateCalFileL(KCalendarFile, *calendarInfo);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0002
+@SYMPreq CR1985
+@SYMTestCaseDesc Test that we can set metadata on a file that already exists.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Create a file without metadata
+ 2. Create a calendar info instance and set some values on it
+ 2. Set the calendar info is associated with it
+
+@SYMTestExpectedResults The calendar file should be created and the metadata set on it.
+**/
+void CTestManager::TestSetMetaDataL()
+ {
+ test.Next(_L("Test that you can set meta data on a file that already exists"));
+
+ test.Printf(_L("Make sure the file is deleted when we start the test"));
+ TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));
+
+ test.Printf(_L("Create the cal file without meta data"));
+ iTestLibrary->GetSession().CreateCalFileL(KCalendarFile);
+
+ test.Printf(_L("open the file"));
+ iTestLibrary->GetSession().OpenL(KCalendarFile);
+ iTestLibrary->GetSession().FileIdL(iFileId);
+
+ test.Printf(_L("create the meta data object"));
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Set some properties on the meta data"));
+ calendarInfo->SetNameL(KCalendarName);
+ calendarInfo->SetDescriptionL(KCalendarDescription);
+ calendarInfo->SetColor(KCalendarColor);
+ calendarInfo->SetEnabled(KCalendarEnabled);
+
+ test.Printf(_L("Set the meta data on the file"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0003
+@SYMPreq CR1985
+@SYMTestCaseDesc Test that we are able to fetch metadata that has been set on a file.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Open a file with metadata
+ 2. fetch the properties of the metadata
+
+@SYMTestExpectedResults The metadata should be there and the properties should have the correct values.
+**/
+void CTestManager::TestGetMetaDataL()
+ {
+ test.Next(_L("Test that you can set meta data on a file that already exists"));
+
+ test.Printf(_L("open the file"));
+ iTestLibrary->GetSession().OpenL(KCalendarFile);
+ iTestLibrary->GetSession().FileIdL(iFileId);
+
+ test.Printf(_L("get the meta data"));
+ CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();
+
+ if (calendarInfo)
+ {
+ test.Printf(_L("There is meta data so test that is set correctly"));
+
+ CleanupStack::PushL(calendarInfo);
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(calendarInfo->NameL().Compare(KCalendarName) == 0);
+ test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(calendarInfo->Color() == KCalendarColor);
+ test(calendarInfo->Enabled() == KCalendarEnabled);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+ else
+ {
+ test.Printf(_L("There is no meta data"));
+ test(EFalse);
+ }
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0004
+@SYMPreq CR1985
+@SYMTestCaseDesc Test that we can fetch metadata for all files through the calendar iterator.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Have 1 file that has metadata set on it
+ 2. Have many other files that do not have metadata (calendar files from other tests).
+ 3. Create a calendar iterator
+ 4. iterate through all calendars fetching metadata of it exitsts
+
+@SYMTestExpectedResults Only one file should have valid metadata and it should have the correct values.
+**/
+void CTestManager::TestGetAllMetaDataL()
+ {
+ test.Next(_L("Test iterating through all meta data set on the calendar server"));
+
+ test.Printf(_L("create the iterator"));
+ CCalCalendarIterator* calendarIterator = CCalCalendarIterator::NewL(iTestLibrary->GetSession());
+ CleanupStack::PushL(calendarIterator);
+
+ CDesCArray* calFiles = iTestLibrary->GetSession().ListCalFilesL();
+ CleanupStack::PushL(calFiles);
+
+ test.Printf(_L("Test the meta data count is the same as the list calendar info count"));
+ const TInt KCalendarInfoCount = calendarIterator->Count();
+ const TInt KListFilesCount = calFiles->Count();
+ test(KCalendarInfoCount == KListFilesCount);
+
+ test.Printf(_L("Iterate through the calendar info collection"));
+
+ TInt validCount(0);
+ TInt totalCount(0);
+
+ for (CCalCalendarInfo* calendarInfo = calendarIterator->FirstL();
+ calendarInfo != NULL ;
+ calendarInfo = calendarIterator->NextL())
+ {
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("File %d = %S\n"), ++totalCount, &calendarInfo->FileNameL());
+
+ if (calendarInfo->IsValid())
+ {
+ test.Printf(_L("The file is valid so test that the properties are as expected"));
+
+ ++validCount;
+
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(calendarInfo->NameL().Compare(KCalendarName) == 0);
+ test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(calendarInfo->Color() == KCalendarColor);
+ test(calendarInfo->Enabled() == KCalendarEnabled);
+ }
+ else
+ {
+ test.Printf(_L("The file is invalid, but make sure it is one of the files from ListCalFilesL"));
+
+ TInt pos(KErrNotFound);
+ TInt findError = calFiles->Find(calendarInfo->FileNameL(), pos);
+
+ test(findError == KErrNone);
+
+ // Remove the file from the list so that we test we don't get duplicates
+ calFiles->Delete(pos);
+ }
+
+ test.Printf(_L("Test that the CurrentL API works"));
+ CCalCalendarInfo* currentCalendarInfo = calendarIterator->CurrentL();
+ CleanupStack::PushL(currentCalendarInfo);
+
+ test(currentCalendarInfo->IsValid() == calendarInfo->IsValid());
+ test(currentCalendarInfo->FileNameL().Compare(calendarInfo->FileNameL()) == 0 );
+
+ if (currentCalendarInfo->IsValid())
+ {
+ test.Printf(_L("The info is valid so test that all the other properties are the same"));
+
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(calendarInfo->NameL().Compare(KCalendarName) == 0);
+ test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(calendarInfo->Color() == KCalendarColor);
+ test(calendarInfo->Enabled() == KCalendarEnabled);
+ }
+
+ CleanupStack::PopAndDestroy(currentCalendarInfo);
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+ test.Printf(_L("Test that we only found one file with valid meta data"));
+ test(validCount == 1);
+
+ CleanupStack::PopAndDestroy(calFiles);
+ CleanupStack::PopAndDestroy(calendarIterator);
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0005
+@SYMPreq CR1985
+@SYMTestCaseDesc Test that all the metadata APIs work under OOM conditions.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Call all new APIs under OOM conditions
+
+@SYMTestExpectedResults APIs should be transactional and fail without panicking.
+**/
+void CTestManager::OomTestL(TType aType, TInt aFailAt)
+ {
+ test.Printf(_L("Oom test callback %d %d\n"), aType, aFailAt);
+
+ // create file with calendar info
+ CCalSession* session = CCalSession::NewL();
+ CleanupStack::PushL(TCleanupItem(CleanupDeleteCalFile, session));
+
+ TRAPD(err, session->DeleteCalFileL(KCalendarFile));
+ if (err != KErrNotFound)
+ {
+ User::LeaveIfError(err);
+ }
+
+ CCalCalendarInfo* info = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(info);
+
+ info->SetNameL(KCalendarName);
+ info->SetDescriptionL(KCalendarDescription);
+ info->SetColor(KCalendarColor);
+ info->SetEnabled(KCalendarEnabled);
+
+ switch (iOomTestCase)
+ {
+ case EOomTestCaseCreateCalFileWithInfo:
+ {
+ session->CreateCalFileL(KCalendarFile, *info);
+ }
+ break;
+ case EOomTestCaseSetInfoOnFileWithoutInfo:
+ {
+ // create file without calendar info and then set
+ session->CreateCalFileL(KCalendarFile);
+ session->OpenL(KCalendarFile);
+ session->SetCalendarInfoL(*info);
+ }
+ break;
+ case EOomTestCaseUpdateInfo:
+ {
+ // create cal file with impl and then update it
+ session->CreateCalFileL(KCalendarFile, *info);
+ session->OpenL(KCalendarFile);
+ session->SetCalendarInfoL(*info);
+ }
+ break;
+ case EOomTestCaseFetchInfo:
+ {
+ session->CreateCalFileL(KCalendarFile, *info);
+ session->OpenL(KCalendarFile);
+
+ // get calendar info
+
+ CCalCalendarInfo* fetchedInfo = session->CalendarInfoL();
+ CleanupStack::PushL(fetchedInfo);
+
+ // check that all the details are correct
+ test(fetchedInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(fetchedInfo->NameL().Compare(KCalendarName) == 0);
+ test(fetchedInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(fetchedInfo->Color() == KCalendarColor);
+ test(fetchedInfo->Enabled() == KCalendarEnabled);
+
+ CleanupStack::PopAndDestroy(fetchedInfo);
+ }
+ break;
+ case EOomTestCaseIterateOverAllInfo:
+ {
+ session->CreateCalFileL(KCalendarFile, *info);
+
+ // Iterate through the calendar info
+ CCalCalendarIterator* calendarIterator = CCalCalendarIterator::NewL(*session);
+ CleanupStack::PushL(calendarIterator);
+
+ for (CCalCalendarInfo* calendarInfo = calendarIterator->FirstL();
+ calendarInfo != NULL ;
+ calendarInfo = calendarIterator->NextL())
+ {
+ CleanupStack::PushL(calendarInfo);
+
+ if (calendarInfo->IsValid())
+ {
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(calendarInfo->NameL().Compare(KCalendarName) == 0);
+ test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(calendarInfo->Color() == KCalendarColor);
+ test(calendarInfo->Enabled() == KCalendarEnabled);
+ }
+ else
+ {
+ // the filename should not be that of the file we expect to have metadata
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) != 0);
+ }
+
+ CCalCalendarInfo* currentCalendarInfo = calendarIterator->CurrentL();
+ CleanupStack::PushL(currentCalendarInfo);
+
+ test(currentCalendarInfo->IsValid() == calendarInfo->IsValid());
+ test(currentCalendarInfo->FileNameL().Compare(calendarInfo->FileNameL()) == 0 );
+
+ if (currentCalendarInfo->IsValid())
+ {
+ test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);
+ test(calendarInfo->NameL().Compare(KCalendarName) == 0);
+ test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);
+ test(calendarInfo->Color() == KCalendarColor);
+ test(calendarInfo->Enabled() == KCalendarEnabled);
+ }
+
+ CleanupStack::PopAndDestroy(currentCalendarInfo);
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+ CleanupStack::PopAndDestroy(calendarIterator);
+ }
+ break;
+ default:
+ break;
+ };
+
+ CleanupStack::PopAndDestroy(info);
+ CleanupStack::PopAndDestroy(session);
+ }
+
+void CTestManager::TestOomL()
+ {
+ // make sure the agenda is not running when we start
+ iTestLibrary->CloseAgendaServer();
+ iTestLibrary->ConnectAgendaServerL();
+
+ for (iOomTestCase = 0 ; iOomTestCase < EOomTestCaseLast ; ++iOomTestCase)
+ {
+ test.Printf(_L("Oom test case %d"), iOomTestCase);
+
+ test.Printf(_L("Test the client side"));
+ TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));
+ CalTestOom::OutOfMemoryTestL(*this, MCalTestOomCallBack::EClient, iTestLibrary->GetSession());
+
+ test.Printf(_L("Test the server side"));
+ TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));
+ CalTestOom::OutOfMemoryTestL(*this, MCalTestOomCallBack::EServer, iTestLibrary->GetSession());
+ }
+ }
+
+void CTestManager::AddEntryWithAlarmL(const TTime& aStartTime, TInt aAlarmMinutes, HBufC8* aGuid, TBool aFloating)
+ {
+ TDateTime dt = (aStartTime - TTimeIntervalMinutes(aAlarmMinutes)).DateTime();
+ test.Printf(_L("Adding alarmed entry, alarm set to: %d/%d/%d, %d:%d\n"),
+ dt.Day()+1, dt.Month()+1, dt.Year(), dt.Hour(), dt.Minute());
+
+ HBufC8* guid = aGuid;
+ if (!guid)
+ {
+ guid = KGUID().AllocLC();
+ }
+
+ CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
+ CleanupStack::Pop(guid);
+ CleanupStack::PushL(entry);
+
+ TCalTime calStartTime;
+ TCalTime calEndTime;
+ if (aFloating)
+ {
+ calStartTime.SetTimeLocalFloatingL(aStartTime);
+ calEndTime.SetTimeLocalFloatingL(aStartTime + TTimeIntervalHours(1));
+ }
+ else
+ {
+ calStartTime.SetTimeLocalL(aStartTime);
+ calEndTime.SetTimeLocalL(aStartTime + TTimeIntervalHours(1));
+ }
+ entry->SetStartAndEndTimeL(calStartTime, calEndTime);
+ CCalAlarm* alarm = CCalAlarm::NewL();
+ CleanupStack::PushL(alarm);
+ alarm->SetTimeOffset(aAlarmMinutes);
+ entry->SetAlarmL(alarm);
+ CleanupStack::PopAndDestroy(alarm);
+ RPointerArray<CCalEntry> entriesToStore;
+ CleanupClosePushL(entriesToStore);
+ entriesToStore.AppendL(entry);
+ TInt entriesStored = 0;
+ iTestLibrary->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored);
+ test(entriesToStore.Count() == entriesStored);
+ CleanupStack::PopAndDestroy(2); //&entriesToStore, entry
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0006
+@SYMPreq CR2066
+@SYMTestCaseDesc Test that alarm status changes is consistent with agenda shut down.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Create a calendar file and set the metadata
+ 2. Create a few alarmed entries
+ 3. Get the alarm details
+ 4. Close agenda server
+ 5. Open agenda and check the alarm status
+ 6. Disable calendar and check the alarm status
+
+@SYMTestExpectedResults Alarms should be enabled when calendar metadata is enabled. Alarms
+ should be disabled when calendar metadata is disabled.
+**/
+void CTestManager::TestAlarmStatusWithAgendaShutDownL()
+ {
+ test.Next(_L("Test the alarm status while closing and re-opening agenda"));
+
+ test.Printf(_L("Make sure the file is deleted when we start the test"));
+ iTestLibrary->DeleteFileL(KCalendarFile);
+ iTestLibrary->CreateFileL(KCalendarFile);
+ iTestLibrary->OpenFileL(KCalendarFile);
+
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Set some properties on the meta data"));
+ calendarInfo->SetNameL(KCalendarFile);
+ calendarInfo->SetDescriptionL(KCalendarDescription);
+ calendarInfo->SetColor(KCalendarColor);
+ calendarInfo->SetEnabled(KCalendarEnabled);
+
+ test.Printf(_L("Set the meta data on the file"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ const TInt offSet = 30;// alarm offset is 30 seconds
+ TTime alarmTime(TDateTime(2009, EJuly, 5, 12, 0, 0, 0));
+ iTestLibrary->PIMTestServer().SetHomeTime(alarmTime - TTimeIntervalSeconds(offSet));
+
+ HBufC8* guid1 = KGUID1().AllocLC();
+ AddEntryWithAlarmL(alarmTime, 0, guid1, EFalse);
+
+ HBufC8* guid2 = KGUID2().AllocLC();
+ AddEntryWithAlarmL(alarmTime + TTimeIntervalSeconds(offSet), 0, guid2, EFalse);
+
+ HBufC8* guid3 = KGUID3().AllocLC();
+ AddEntryWithAlarmL(alarmTime + TTimeIntervalMinutes(offSet), 0, guid3, EFalse);
+
+ TAlarmId alarmId;
+ TASShdAlarm alarm;
+ iAlarmServer.GetNextDueAlarmId(alarmId);
+ iAlarmServer.GetAlarmDetails(alarmId, alarm);
+ test(iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 1);
+
+ test.Printf(_L("Calendar server shut down\n"));
+ iTestLibrary->CloseAgendaServer();
+
+ // Three alarm should be queued
+ test(iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 3);
+
+ iTestLibrary->OpenFileL(KCalendarFile());
+ test(iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 3);
+
+ iTestLibrary->SynCGetEntryViewL();//force the entry view is build so that the alarms will be deleted.
+ test(iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 1);
+
+ test.Printf(_L("Wait for an alarm to notify\n"));
+ test(iTestLibrary->WaitForAlarmEvent(KNullAlarmId, EAlarmChangeEventState, EAlarmStateNotifying, offSet*1000000));
+
+ // One alarm should be queued
+ test(iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 1);
+ iAlarmServer.GetNextDueAlarmId(alarmId);
+ iAlarmServer.GetAlarmDetails(alarmId, alarm);
+ TAlarmStatus status;
+ iAlarmServer.GetAlarmStatus(alarmId, status);
+ test.Printf(_L("Check the alarm status - it should be enabled\n"));
+ test(status == EAlarmStatusEnabled);
+
+ test.Printf(_L("Disable calendar metadata\n"));
+ calendarInfo->SetEnabled(EFalse);
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ iAlarmServer.GetAlarmDetails(alarmId, alarm);
+ iAlarmServer.GetAlarmStatus(alarmId, status);
+ test.Printf(_L("Check the alarm status - it should be disabled\n"));
+ test(status == EAlarmStatusDisabled);
+
+ // Restore settings back to how those were before start of the test
+ iTestLibrary->CleanDatabaseL();
+ TTime now;
+ now.HomeTime();
+ iTestLibrary->PIMTestServer().SetHomeTime(now);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+ }
+
+/*
+@SYMTestCaseID PIM-TCAL-CALENDAR-INFO-0007
+@SYMPreq CR2066
+@SYMTestCaseDesc Test that alarm status changes with calendar metadata.
+@SYMTestPriority 1
+@SYMTestType CIT
+@SYMTestStatus Implemented
+@SYMTestActions 1. Create a calendar file and add metadata to it
+ 2. Add an alarmed entry
+ 3. Check the status of the alarm
+ 4. Disable calendar and check alarm status
+
+@SYMTestExpectedResults Alarm status should be enabled/disabled depending on calendar metadata status.
+**/
+void CTestManager::TestAlarmStatusChangeL()
+ {
+ test.Next(_L("Test the change in alarm status with respect to calendar status"));
+
+ test.Printf(_L("Make sure the file is deleted when we start the test\n"));
+ iTestLibrary->DeleteFileL(KCalendarFile);
+ iTestLibrary->CreateFileL(KCalendarFile);
+ iTestLibrary->OpenFileL(KCalendarFile);
+
+ CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();
+ CleanupStack::PushL(calendarInfo);
+
+ test.Printf(_L("Set some properties on the meta data\n"));
+ calendarInfo->SetNameL(KCalendarFile);
+ calendarInfo->SetDescriptionL(KCalendarDescription);
+ calendarInfo->SetColor(KCalendarColor);
+ calendarInfo->SetEnabled(KCalendarEnabled);
+
+ test.Printf(_L("Set the meta data on the file\n"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ TTime time(TDateTime(2008, EJuly, 17, 0, 0, 0, 0));
+ iTestLibrary->PIMTestServer().SetHomeTime(time);
+
+ HBufC8* guid1 = KGUID1().AllocLC();
+ test.Printf(_L("Add an alarmed entry\n"));
+ AddEntryWithAlarmL(time + TTimeIntervalSeconds(2), 0, guid1, EFalse);
+
+ TAlarmId alarmId;
+ TASShdAlarm alarmDetails;
+ iAlarmServer.GetNextDueAlarmId(alarmId);
+ iAlarmServer.GetAlarmDetails(alarmId, alarmDetails);
+
+ TAlarmStatus status;
+ iAlarmServer.GetAlarmStatus(alarmId, status);
+ test.Printf(_L("Check if the status of the alarm is enabled\n"));
+ test(status == EAlarmStatusEnabled);
+
+ calendarInfo->SetEnabled(EFalse);
+ test.Printf(_L("Disable the meta data on the file\n"));
+ iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);
+
+ iAlarmServer.GetAlarmDetails(alarmId, alarmDetails);
+ test.Printf(_L("Get alarm status - alarm should be disabled\n"));
+ TRAPD(err, iAlarmServer.GetAlarmStatus(alarmId, status));
+ test(err == KErrNone);
+ test(status == EAlarmStatusDisabled);
+
+ CleanupStack::PopAndDestroy(calendarInfo);
+
+ time.HomeTime();
+ iTestLibrary->PIMTestServer().SetHomeTime(time);
+ iTestLibrary->CleanDatabaseL();
+ }
+
+void CTestManager::RunTestsL()
+ {
+ TestSetAndUpdatePropertyL();
+ TestGetPropertyL();
+ TestRemovePropertyL();
+ TestReplaceMetadataL();
+ TestCreateFileWithMetaDataL();
+ TestSetMetaDataL();
+ TestGetMetaDataL();
+ TestGetAllMetaDataL();
+ TestAlarmStatusChangeL();
+ TestAlarmStatusWithAgendaShutDownL();
+ TestOomL();
+ }
+
+static void DoTestL()
+ {
+ CTestManager* testManager = CTestManager::NewLC();
+
+ TPerformanceTimer timer(test);
+ timer.Start();
+
+ // Run the test suite
+ testManager->RunTestsL();
+
+ timer.Stop();
+ test.Printf(_L("Done\n"));
+ // printout performance time
+ timer.PrintOut();
+
+ CleanupStack::PopAndDestroy(testManager);
+ }
+
+TInt E32Main()
+ {
+ __UHEAP_MARK;
+
+ test.Start(KCalendarFile);
+ test.Title();
+
+ CTrapCleanup* trapCleanup = CTrapCleanup::New();
+ if (!trapCleanup)
+ {
+ return KErrNoMemory;
+ }
+
+ CActiveScheduler* scheduler = new CActiveScheduler();
+ if (!scheduler)
+ {
+ delete trapCleanup;
+ return KErrNoMemory;
+ }
+ CActiveScheduler::Install(scheduler);
+
+ TRAPD(ret, DoTestL());
+
+ if (ret != KErrNone)
+ {
+ test.Printf(_L("test failed with %d"), ret);
+ }
+ test(ret == KErrNone);
+
+ delete scheduler;
+ delete trapCleanup;
+
+ test.End();
+ test.Close();
+
+ __UHEAP_MARKEND;
+
+ return (KErrNone);
+ }