--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/pimappservices/calendar/tsrc/TestCalIndexFile/src/TestCalIndexFileStepBase.cpp Tue Feb 02 10:12:19 2010 +0200
@@ -0,0 +1,937 @@
+// Copyright (c) 2006-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 "TestCalIndexFileStepBase.h"
+#include "TestCalIndexFileDefs.h"
+#include <f32file.h>
+#include <bautils.h>
+
+#include <calsession.h>
+#include <calentryview.h>
+#include <calinstanceview.h>
+#include <calinstance.h>
+#include "caltestlib.h"
+
+// Constant Literals used.
+_LIT(KInfoPercentageCompleted, "Percentage Completed %d");
+_LIT(KErrPercentageCompleted, "Error progress not required");
+_LIT(KErrCompleted, "Error Completed %d");
+
+_LIT(KDefaultDir, "private\\10003a5b");
+_LIT(KDefaultFile, "calendar");
+_LIT(KDefaultIdx, "calendaridx");
+_LIT(KDrive, "drive");
+_LIT(KCalendarName, "calendarname");
+_LIT(KIndexName, "indexname");
+_LIT(KIndexFileDataDir, "\\CalIndexFileTestData\\");
+_LIT(KDefaultTestDrive, "C:");
+_LIT(KDoubleBackslash, "\\");
+
+
+TFileName GetFullFileName(const TDesC& aPath)
+ {
+ TFileName fileName;
+#ifdef __WINS__
+ fileName.Append(_L("c:"));
+#else
+ TFileName fullName = RProcess().FileName();
+ TParsePtrC parse(fullName);
+ fileName.Append(parse.Drive());
+#endif
+ fileName.Append(aPath);
+ return fileName;
+ }
+
+/*@}*/
+
+CTestCalIndexFileStepBase::CTestCalIndexFileStepBase()
+: CTestStep()
+, iNotifyProgress(ETrue)
+, iActiveScheduler(NULL)
+, iFsSessionConnected(EFalse)
+, iSession(NULL)
+ {
+ }
+
+CTestCalIndexFileStepBase::~CTestCalIndexFileStepBase()
+ {
+ delete iSession;
+ delete iActiveScheduler;
+ iFsSession.Close();
+ }
+
+void CTestCalIndexFileStepBase::Progress(TInt aPercentageCompleted)
+ {
+ if ( iNotifyProgress )
+ {
+ INFO_PRINTF2(KInfoPercentageCompleted, aPercentageCompleted);
+ }
+ else
+ {
+ ERR_PRINTF1(KErrPercentageCompleted);
+ SetTestStepResult(EFail);
+ }
+ }
+
+void CTestCalIndexFileStepBase::Completed(TInt aError)
+ {
+ if ( aError!=KErrNone )
+ {
+ ERR_PRINTF2(KErrCompleted, aError);
+ SetTestStepResult(EFail);
+ SetTestStepError(aError);
+ }
+ CActiveScheduler::Stop();
+ }
+
+TBool CTestCalIndexFileStepBase::NotifyProgress()
+ {
+ return iNotifyProgress;
+ }
+
+TVerdict CTestCalIndexFileStepBase::doTestStepPreambleL()
+/**
+ * @return - TVerdict
+*/
+ {
+ INFO_PRINTF1(_L("enter CTestCalIndexFileStepBase::doTestStepPreambleL()"));
+ iActiveScheduler = new(ELeave)CActiveScheduler;
+ CActiveScheduler::Install(iActiveScheduler);
+ INFO_PRINTF1(_L("exit CTestCalIndexFileStepBase::doTestStepPreambleL()"));
+ return (EPass);
+ }
+
+TVerdict CTestCalIndexFileStepBase::doTestStepPostambleL()
+/**
+ * @return - TVerdict
+ */
+ {
+ return (EPass);
+ }
+
+
+void CTestCalIndexFileStepBase::SetUpCalDirL()
+ {
+ // determine calendar directory from ini
+ // if not present use default
+
+ TPtrC drive;
+ TBool readRes = EFalse;
+ TFileName driveName;
+ readRes = GetStringFromConfig(ConfigSection(), KDrive, drive);
+ if (readRes)
+ {
+ iDriveName = drive;
+ }
+ else
+ {
+ iDriveName = KDefaultTestDrive();
+ }
+
+ iDir = iDriveName;
+ iDir.Append(KDoubleBackslash());
+ iDir.Append(KDefaultDir());
+ iDir.Append(KDoubleBackslash());
+
+ // store the relevant file names for the calendar and
+ // index and delete them from the directory if they already
+ // exist
+ if (!iFsSessionConnected)
+ {
+ iFsSession.Connect();
+ iFsSessionConnected = ETrue;
+ }
+
+ // calendar file
+ TPtrC calendarName;
+
+ readRes = GetStringFromConfig(ConfigSection(), KCalendarName, calendarName);
+ if (readRes)
+ {
+ iCalendarName = calendarName;
+ }
+ else
+ {
+ iCalendarName = KDefaultFile();
+ }
+
+ TFileName fName;
+ fName = iDir;
+ fName.Append(iCalendarName);
+ if (BaflUtils::FileExists(iFsSession, fName))
+ {
+ iFsSession.Delete(fName);
+ }
+
+ // index file
+ TPtrC indexName;
+ readRes = EFalse;
+ readRes = GetStringFromConfig(ConfigSection(), KIndexName, indexName);
+ if (readRes)
+ {
+ iIndexName = indexName;
+ }
+ else
+ {
+ iIndexName = KDefaultIdx();
+ }
+
+ fName = iDir;
+ fName.Append(iIndexName);
+ if (BaflUtils::FileExists(iFsSession, fName))
+ {
+ iFsSession.Delete(fName);
+ }
+
+ iFsSession.Close();
+ iFsSessionConnected = EFalse;
+ INFO_PRINTF1(_L("exit CTestCalIndexFileStepBase::SetUpCalDirL()"));
+ }
+
+void CTestCalIndexFileStepBase::MakeCalendarFileName(TFileName& aCalFile)
+ {
+ aCalFile = iDriveName;
+ aCalFile.Append(iCalendarName);
+ }
+
+void CTestCalIndexFileStepBase::AddCalendarFileL()
+ {
+ // copy file from stored data area to target directory
+ TFileName trgtName;
+ trgtName = iDir;
+ trgtName.Append(iCalendarName);
+
+ TFileName srcName = GetFullFileName(KIndexFileDataDir);
+ srcName.Append(iCalendarName);
+
+ if (!iFsSessionConnected)
+ {
+ iFsSession.Connect();
+ iFsSessionConnected = ETrue;
+ }
+ CFileMan* fileman = CFileMan::NewL(iFsSession);
+ CleanupStack::PushL(fileman);
+ fileman->Copy(srcName, trgtName);
+ CleanupStack::PopAndDestroy(fileman);
+ iFsSession.Close();
+ iFsSessionConnected = EFalse;
+ }
+
+void CTestCalIndexFileStepBase::AddIndexFileL()
+ {
+ // copy file from stored data area to target directory
+ TFileName trgtName;
+ trgtName = iDir;
+ trgtName.Append(iIndexName);
+
+ TFileName srcName = GetFullFileName(KIndexFileDataDir);
+ srcName.Append(iIndexName);
+
+ if (!iFsSessionConnected)
+ {
+ iFsSession.Connect();
+ iFsSessionConnected = ETrue;
+ }
+ CFileMan* fileman = CFileMan::NewL(iFsSession);
+ CleanupStack::PushL(fileman);
+ fileman->Copy(srcName, trgtName);
+ CleanupStack::PopAndDestroy(fileman);
+ iFsSession.Close();
+ iFsSessionConnected = EFalse;
+ }
+
+void CTestCalIndexFileStepBase::OpenAgendaL()
+ {
+ // create a calendar session using the filename & directory
+ // retrieved earlier
+
+ iSession = CCalSession::NewL();
+
+ TFileName calName;
+ MakeCalendarFileName(calName);
+ iSession->OpenL(calName);
+ }
+
+void CTestCalIndexFileStepBase::CloseAgendaL()
+ {
+ // close the session to which we have a pointer
+ delete iSession;
+ iSession = NULL;
+
+ // a little pause to let the index file get written
+ TTimeIntervalMicroSeconds32 delay = 7000000; // 7 s - we need to wait more than 5s due to the delay introduced by CR0979.
+ User::After(delay);
+ }
+
+
+TBool CTestCalIndexFileStepBase::CheckIndexFilePresentL()
+ {
+ // check if indexfile is in directory
+ TFileName idxName;
+ idxName = iDir;
+ idxName.Append(iIndexName);
+
+ if (!iFsSessionConnected)
+ {
+ iFsSession.Connect();
+ iFsSessionConnected = ETrue;
+ }
+ RFile idxFile;
+
+ TBool result = BaflUtils::FileExists(iFsSession, idxName);
+ iFsSession.Close();
+ iFsSessionConnected = EFalse;
+ return result;
+ }
+
+
+TBool CTestCalIndexFileStepBase::CheckCalendarFilePresentL()
+ {
+ // check if calendar file is in directory
+ TFileName calName;
+ calName = iDir;
+ calName.Append(iCalendarName);
+
+ if (!iFsSessionConnected)
+ {
+ iFsSession.Connect();
+ iFsSessionConnected = ETrue;
+ }
+ RFile calFile;
+
+ TBool result = BaflUtils::FileExists(iFsSession, calName);
+ iFsSession.Close();
+ iFsSessionConnected = EFalse;
+ return result;
+ }
+
+void CTestCalIndexFileStepBase::GetEntryInfoFromConfigL(RPointerArray<CConfigTestEntryInfo>& aEntriesInfo, TInt& aNumEntries, TBool aPerformCrudOps)
+ {
+ // for the base class we don't care about CRUD operations
+ aPerformCrudOps = aPerformCrudOps;
+
+ for (TInt i = 0; i < aNumEntries; i++)
+ {
+ HBufC* entryBuf = HBufC::NewL(KTCIEntry().Length()+ 4); // add 4 to allow for 4 digits of entries
+ CleanupStack::PushL(entryBuf);
+ *entryBuf = KTCIEntry();
+ TPtr ptr(entryBuf->Des());
+ ptr.AppendNum(i+1);
+ TPtrC entryString;
+ TBool readRes = EFalse;
+ readRes = GetStringFromConfig(ConfigSection(), ptr, entryString);
+ if (!readRes)
+ {
+ INFO_PRINTF2(_L("Error in CTestCalIndexFileStepBase::GetEntryInfoFromConfigL - entry%d not found in config file"),(i+1));
+ User::Leave(KErrNotFound);
+ }
+ CConfigTestEntryInfo* inf = new(ELeave)CConfigTestEntryInfo();
+ CleanupStack::PushL(inf);
+ ParseEntryStringL(*inf, entryString);
+ aEntriesInfo.Append(inf);
+ CleanupStack::Pop(inf); // now in array to be cleaned up
+ CleanupStack::PopAndDestroy(entryBuf);
+ }
+
+ }
+
+
+TBool CTestCalIndexFileStepBase::ValidateDbContentsL(TBool aPerformCrudOps)
+ {
+ // for each entry in the database validate ALL relevant
+ // fields against info for the entry in the ini file
+ TInt numEntries;
+ TBool readRes = EFalse;
+ readRes = GetIntFromConfig(ConfigSection(),KTCINumEntries, numEntries);
+ if (!readRes)
+ {
+ INFO_PRINTF1(_L("Error in CTestCalIndexFileStepBase::ValidateDbContentsL - numentriespresent not found in config file"));
+ User::Leave(KErrNotFound);
+ }
+
+ if (numEntries == 0)
+ {
+ return ETrue;
+ }
+
+ RPointerArray<CConfigTestEntryInfo> entriesInfo;
+ CleanupResetAndDestroyPushL(entriesInfo);
+
+ GetEntryInfoFromConfigL(entriesInfo, numEntries, aPerformCrudOps);
+
+ // for each entry in the list of entries, see if we can find a
+ // match in the database using an instance view
+ for (TInt j = 0; j < numEntries; j++)
+ {
+ INFO_PRINTF2(_L("Trying to validate entry info - %d"),(j+1));
+ CConfigTestEntryInfo* infoToUse = entriesInfo[j];
+
+ CCalProgress* progress = new(ELeave)CCalProgress;
+ CleanupStack::PushL(progress); //1
+
+ CCalInstanceView* view = CCalInstanceView::NewL(*iSession, *progress);
+ CleanupStack::PushL(view); //2
+
+ CActiveScheduler::Start();
+
+ CalCommon::TCalViewFilter filter = CalCommon::EIncludeAppts;
+ switch (infoToUse->iType)
+ {
+ case (CCalEntry::EAppt):
+ filter = CalCommon::EIncludeAppts;
+ break;
+ case (CCalEntry::ETodo):
+ filter = CalCommon::EIncludeCompletedTodos | CalCommon::EIncludeIncompletedTodos;
+ break;
+ case (CCalEntry::EEvent):
+ filter = CalCommon::EIncludeEvents;
+ break;
+ case (CCalEntry::EReminder):
+ filter = CalCommon::EIncludeReminder;
+ break;
+ case (CCalEntry::EAnniv):
+ filter = CalCommon::EIncludeAnnivs;
+ break;
+ default:
+ User::Leave(KErrCorrupt);
+ break;
+ }
+ RPointerArray<CCalInstance> instances;
+ CleanupResetAndDestroyPushL(instances);
+
+ // look for instances between (startdate -1 day) and
+ // (enddate + 1 day)
+ TTimeIntervalDays oneDay(1);
+ TTime beginTTime = (infoToUse->iStartTime) - oneDay;
+ TTime endTTime = (infoToUse->iEndTime) + oneDay;
+ TCalTime begin;
+ begin.SetTimeUtcL(beginTTime);
+ TCalTime end;
+ end.SetTimeUtcL(endTTime);
+ CalCommon::TCalTimeRange timerange(begin, end);
+
+ view->FindInstanceL(instances, filter, timerange);
+
+ TInt counter = 0;
+ TInt max = instances.Count();
+ INFO_PRINTF2(_L("%d instances to compare against"),max);
+ TBool found = EFalse;
+ while ((found == EFalse) && (counter < max))
+ {
+ INFO_PRINTF3(_L("compare info %d to entry %d"),(j+1), (counter+1));
+ if (infoToUse->CompareToEntryL((instances[counter])->Entry()))
+ {
+ INFO_PRINTF3(_L("Entry info %d matched instance %d"),(j+1), (counter+1));
+ found = ETrue;
+ }
+ else
+ {
+ counter++;
+ }
+ }
+ CleanupStack::PopAndDestroy(&instances);
+ CleanupStack::PopAndDestroy(view);
+ CleanupStack::PopAndDestroy(progress);
+
+ if (!found)
+ {
+ CleanupStack::PopAndDestroy(&entriesInfo);
+ INFO_PRINTF2(_L("Could not validate entry info - %d"),(j+1));
+ return EFalse;
+ }
+ }
+ CleanupStack::PopAndDestroy(&entriesInfo);
+ return ETrue;
+ }
+
+
+void CTestCalIndexFileStepBase::AddEntryL()
+ {
+ TPtrC entryString;
+ TBool readRes = EFalse;
+ readRes = GetStringFromConfig(ConfigSection(), KAddEntry, entryString);
+
+ if (!readRes)
+ {
+ INFO_PRINTF1(_L("Error in CTestCalIndexFileStepBase::AddEntryL - section not found in config file"));
+ User::Leave(KErrNotFound);
+ }
+
+ CConfigTestEntryInfo* entryInf = new(ELeave)CConfigTestEntryInfo();
+ CleanupStack::PushL(entryInf);
+ ParseEntryStringL(*entryInf, entryString);
+ CCalEntry* newEntry = CreateEntryL(*entryInf);
+ CleanupStack::PushL(newEntry);
+
+ CCalProgress* progress = new(ELeave)CCalProgress;
+ CleanupStack::PushL(progress);
+
+ CCalEntryView* view = CCalEntryView::NewL(*iSession, *progress);
+ CleanupStack::PushL(view);
+
+ CActiveScheduler::Start();
+
+
+ TInt cnt;
+ RPointerArray<CCalEntry> entries;
+ entries.Append(newEntry);
+ view->StoreL(entries, cnt);
+
+ CleanupStack::PopAndDestroy(4); //entryInf, newEntry, progress, view
+ }
+
+CCalEntry* CTestCalIndexFileStepBase::CreateEntryL(CConfigTestEntryInfo& aInfo)
+ {
+ // build the uid from the constant we always use here
+ TInt len = KTCIUid().Length();
+
+ HBufC8* uId = HBufC8::NewLC(len);
+ *uId = KTCIUid;
+
+ CCalEntry* retEntry = CCalEntry::NewL(aInfo.iType, uId, aInfo.iMethod, 0);
+ CleanupStack::Pop(uId); // entry takes ownership
+ CleanupStack::PushL(retEntry);
+
+
+ TCalTime start;
+ start.SetTimeUtcL(aInfo.iStartTime);
+ TCalTime end;
+ end.SetTimeUtcL(aInfo.iEndTime);
+ retEntry->SetStartAndEndTimeL(start, end);
+
+ retEntry->SetSummaryL(*(aInfo.iSummary));
+ retEntry->SetDescriptionL(*(aInfo.iDescription));
+ retEntry->SetLocationL(*(aInfo.iLocation));
+
+ if (aInfo.iRepeats)
+ {
+ TCalRRule rRule(aInfo.iRptType);
+ rRule.SetCount(aInfo.iRptCount);
+ rRule.SetDtStart(start);
+ rRule.SetInterval(1);
+ retEntry->SetRRuleL(rRule);
+ }
+ CleanupStack::Pop(retEntry);
+ return (retEntry);
+ }
+
+const TUint KMaxEntryStringLen = 250; // arbitrary size, can be chanegd to match needs
+ // of format described below
+
+const TUint KMaxEntryPartStringLen = 50; // arbitrary size, can be chanegd to match needs
+ // of format described below
+ // The string in the config file for the entry has one of the following
+ // formats:
+ // (1) type;starttime;endtime;summary;description;location;method
+ // (2) type;starttime;endtime;summary;description;location;method;repeating;rpttype;rptnum
+ // where
+ // type = string that fits with one of the entry types
+ // starttime, endtime = TDateTime string
+ // summary, description, location = any string
+ // method = string that fits with one of the method types
+ // repeating = bool string
+ // rpttype = string that fits with one of the repeat types
+ // rptnum = integer string for number of repeats
+ //
+ // example1: appt;20050622:122500;20050623:154500;a summary;a description;a location;none;true;weekly;5;
+ // example2: appt;20050622:122500;20050623:154500;a summary;a description;a location;none;false;
+ //
+ // Refer to TestCalIndexFileDefs.h for the constants for type, method, and rpttype
+
+void CTestCalIndexFileStepBase::ParseEntryStringL(CConfigTestEntryInfo& aInfo, TPtrC& aString)
+ {
+ TBuf<KMaxEntryStringLen> data(aString);
+
+ TBuf<KMaxEntryPartStringLen> item;
+
+ GoToNextEntryItem(data, item);
+
+ // get the entry type
+ if (0 == item.Compare(KTCIEntryTypeAppt))
+ {
+ aInfo.iType = CCalEntry::EAppt;
+ }
+ else if (0 == item.Compare(KTCIEntryTypeToDo))
+ {
+ aInfo.iType = CCalEntry::ETodo;
+ }
+ else if (0 == item.Compare(KTCIEntryTypeEvent))
+ {
+ aInfo.iType = CCalEntry::EEvent;
+ }
+ else if (0 == item.Compare(KTCIEntryTypeRemind))
+ {
+ aInfo.iType = CCalEntry::EReminder;
+ }
+ else if (0 == item.Compare(KTCIEntryTypeAnniv))
+ {
+ aInfo.iType = CCalEntry::EAnniv;
+ }
+ else
+ {
+ User::Leave(KErrArgument);
+ }
+
+ // get the start time
+ GoToNextEntryItem(data, item);
+ TTime start(item);
+ aInfo.iStartTime = start;
+
+ // get the end time
+ GoToNextEntryItem(data, item);
+ TTime end(item);
+ aInfo.iEndTime = end;
+
+
+ // use this integer length for all pure strings to be stored
+ TInt len = 0;
+
+ // get the summary
+ GoToNextEntryItem(data, item);
+ len = item.Length();
+ if (aInfo.iSummary)
+ {
+ delete aInfo.iSummary;
+ aInfo.iSummary = NULL;
+ }
+ aInfo.iSummary = HBufC::NewL(len);
+ *(aInfo.iSummary) = item;
+
+ // get the description
+ GoToNextEntryItem(data, item);
+ len = item.Length();
+ if (aInfo.iDescription)
+ {
+ delete aInfo.iDescription;
+ aInfo.iDescription = NULL;
+ }
+ aInfo.iDescription = HBufC::NewL(len);
+ *(aInfo.iDescription) = item;
+
+ // get the location
+ GoToNextEntryItem(data, item);
+ len = item.Length();
+ if (aInfo.iLocation)
+ {
+ delete aInfo.iLocation;
+ aInfo.iLocation = NULL;
+ }
+ aInfo.iLocation = HBufC::NewL(len);
+ *(aInfo.iLocation) = item;
+
+ // get the method
+ GoToNextEntryItem(data, item);
+ if (0 == item.Compare(KTCIEntryMethodNone))
+ {
+ aInfo.iMethod = CCalEntry::EMethodNone;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodPub))
+ {
+ aInfo.iMethod = CCalEntry::EMethodPublish;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodReq))
+ {
+ aInfo.iMethod = CCalEntry::EMethodRequest;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodReply))
+ {
+ aInfo.iMethod = CCalEntry::EMethodReply;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodAdd))
+ {
+ aInfo.iMethod = CCalEntry::EMethodAdd;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodCancel))
+ {
+ aInfo.iMethod = CCalEntry::EMethodCancel;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodRefresh))
+ {
+ aInfo.iMethod = CCalEntry::EMethodRefresh;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodCounter))
+ {
+ aInfo.iMethod = CCalEntry::EMethodCounter;
+ }
+ else if (0 == item.Compare(KTCIEntryMethodDeclineCounter))
+ {
+ aInfo.iMethod = CCalEntry::EMethodDeclineCounter;
+ }
+ else
+ {
+ User::Leave(KErrArgument);
+ }
+
+ // check if repeating
+ GoToNextEntryItem(data, item);
+ if (0 == item.Compare(KTCIEntryTrue))
+ {
+ aInfo.iRepeats = ETrue;
+
+ // get rpttype
+ GoToNextEntryItem(data, item);
+ if (0 == item.Compare(KTCIEntryRptDaily))
+ {
+ aInfo.iRptType = TCalRRule::EDaily;
+ }
+ else if (0 == item.Compare(KTCIEntryRptWeekly))
+ {
+ aInfo.iRptType = TCalRRule::EWeekly;
+ }
+ else if (0 == item.Compare(KTCIEntryRptMonthly))
+ {
+ aInfo.iRptType = TCalRRule::EMonthly;
+ }
+ else if (0 == item.Compare(KTCIEntryRptYearly))
+ {
+ aInfo.iRptType = TCalRRule::EYearly;
+ }
+ else
+ {
+ User::Leave(KErrArgument);
+ }
+
+ // get rptnum
+ GoToNextEntryItem(data, item);
+ TLex mylex(item);
+ TInt lexErr = mylex.Val(aInfo.iRptCount);
+ User::LeaveIfError(lexErr);
+ }
+ else
+ {
+ aInfo.iRepeats = EFalse;
+ }
+ }
+
+
+void CTestCalIndexFileStepBase::GoToNextEntryItem(TDes& aData, TDes& aItem)
+ {
+ TInt pos;
+ pos = aData.Locate(';');
+ aItem = aData.Left(pos);
+ aData.Delete(0, pos+1);
+ }
+
+
+
+
+
+// CConfigTestEntryInfo
+//
+CConfigTestEntryInfo::CConfigTestEntryInfo()
+ {
+ iSummary = NULL;
+ iDescription = NULL;
+ iLocation = NULL;
+ }
+
+CConfigTestEntryInfo::~CConfigTestEntryInfo()
+ {
+ if (iSummary)
+ {
+ delete iSummary;
+ iSummary = NULL;
+ }
+ if (iDescription)
+ {
+ delete iDescription;
+ iDescription = NULL;
+ }
+ if (iLocation)
+ {
+ delete iLocation;
+ iLocation = NULL;
+ }
+ }
+
+TBool CConfigTestEntryInfo::CompareToEntryL(CCalEntry& aEntry)
+ {
+ // This method assumes a pass.
+ // If any check fails, it immediately returns EFalse since
+ // there is no sense checking any further.
+
+ // NB: Implementers of any future test checks should be sure
+ // to include appropriate debug print information about
+ // the failure within the check method itself.
+ if (!CheckTypeL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry type"));
+ RDebug::Print(_L("Expected %d, Actual %d"),iType, aEntry.EntryTypeL());
+ return EFalse;
+ }
+
+ if (!CheckTimesL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry times"));
+ return EFalse;
+ }
+
+ if (!CheckSummaryL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry summary"));
+ return EFalse;
+ }
+
+ if (!CheckLocationL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry location"));
+ return EFalse;
+ }
+
+ if (!CheckMethodL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry method"));
+ return EFalse;
+ }
+
+ if (!CheckRRuleL(aEntry))
+ {
+ RDebug::Print(_L("Failed checking Entry repeat rule"));
+ return EFalse;
+ }
+
+ // all checks passed, return true
+ return ETrue;
+ }
+
+TBool CConfigTestEntryInfo::CheckTypeL(CCalEntry& aEntry)
+ {
+ return (iType == aEntry.EntryTypeL());
+ }
+
+TBool CConfigTestEntryInfo::CheckTimesL(CCalEntry& aEntry)
+ {
+ if (iType == CCalEntry::EReminder)
+ {
+ return (iStartTime == aEntry.StartTimeL().TimeUtcL());
+ }
+ else
+ {
+ return ((iStartTime == aEntry.StartTimeL().TimeUtcL()) &&
+ (iEndTime == aEntry.EndTimeL().TimeUtcL()));
+ }
+ }
+
+TBool CConfigTestEntryInfo::CheckSummaryL(CCalEntry& aEntry)
+ {
+ return (*iSummary == aEntry.SummaryL());
+ }
+
+TBool CConfigTestEntryInfo::CheckDescriptionL(CCalEntry& aEntry)
+ {
+ return (*iDescription == aEntry.DescriptionL());
+ }
+
+TBool CConfigTestEntryInfo::CheckLocationL(CCalEntry& aEntry)
+ {
+ return (*iLocation == aEntry.LocationL());
+ }
+
+TBool CConfigTestEntryInfo::CheckMethodL(CCalEntry& aEntry)
+ {
+ return (iMethod == aEntry.MethodL());
+ }
+
+TBool CConfigTestEntryInfo::CheckRRuleL(CCalEntry& aEntry)
+ {
+ if (!iRepeats)
+ {
+ // no repeats, so check is superfluous
+ // we keep the logic in here, therefore we don't
+ // fail the check.
+ return ETrue;
+ }
+
+ TCalRRule theRule;
+ if (!aEntry.GetRRuleL(theRule))
+ {
+ return EFalse; // no rule present, should not have got here
+ }
+
+ return ((iRptType == theRule.Type()) && (iRptCount == theRule.Count()));
+ }
+
+
+
+CCalProgress::CCalProgress()
+:CActive(EPriorityStandard), iProgress(0),iCompleted(EFalse)
+ {
+ CActiveScheduler::Add(this);
+ }
+
+CCalProgress::~CCalProgress()
+ {
+ Cancel();
+ }
+
+
+void CCalProgress::Progress(TInt aPercentageCompleted)
+ {
+ iProgress = aPercentageCompleted;
+ if (aPercentageCompleted<100)
+ iCompleted = EFalse;
+ }
+
+void CCalProgress::Completed(TInt /* aError*/)
+ {
+ iCompleted = ETrue;
+ Start();
+ }
+
+TBool CCalProgress::NotifyProgress()
+ {
+ return ETrue;
+ }
+
+TBool CCalProgress::Completed()
+ {
+ return iCompleted;
+ }
+
+TInt CCalProgress::Progress()
+ {
+ return iProgress;
+ }
+
+void CCalProgress::Reset()
+ {
+ iCompleted=EFalse;
+ }
+
+void CCalProgress::Start()
+ {
+ if (!IsActive())
+ {
+ SetActive();
+ }
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete(status, KErrNone);
+ }
+
+void CCalProgress::DoCancel()
+ {
+ Close();
+ }
+
+void CCalProgress::RunL()
+ {
+ Close();
+ }
+
+void CCalProgress::Close()
+ {
+ CActiveScheduler::Stop();
+ }
+