diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/TestCalIndexFile/src/TestCalIndexFileStepBase.cpp
--- /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();
+	}
+