1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include "tcal_gsentry_testdata.h"

    17 	

    18 #include <calentryview.h>

    19 #include <calinstance.h>

    20 #include <calrrule.h>

    21 #include <calalarm.h>

    22 

    23 template <class T>

    24 class CleanupResetAndDestroy

    25 	{

    26 public:

    27 	inline static void PushL(T& aRef);

    28 private:

    29 	static void ResetAndDestroy(TAny *aPtr);

    30 	};

    31 	

    32 template <class T> inline void CleanupResetAndDestroyPushL(T& aRef);

    33 

    34 

    35 template <class T> inline void CleanupResetAndDestroy<T>::PushL(T& aRef)

    36 	{

    37 	CleanupStack::PushL(TCleanupItem(&ResetAndDestroy,&aRef));

    38 	}

    39 	

    40 template <class T> void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)

    41 	{

    42 	(static_cast<T*>(aPtr))->ResetAndDestroy();

    43 	}

    44 

    45 

    46 template <class T> inline void CleanupResetAndDestroyPushL(T& aRef)

    47 	{

    48 	CleanupResetAndDestroy<T>::PushL(aRef);

    49 	}

    50 	

    51 

    52 TTestDataStruct::TTestDataStruct()

    53 	{

    54 	iFilter = CalCommon::EIncludeAll;

    55 	iSearchBehaviour = CalCommon::EExactTextSearch;

    56 	iFunction = NULL;

    57 	iSearchString = NULL;

    58 	}

    59 	

    60 TTestDataStruct::~TTestDataStruct()

    61 	{

    62 	iTimes.Reset();

    63 	delete iFunction;

    64 	delete iSearchString;

    65 	iGuidsToExtract.Close();

    66 	iRecIds.Reset();

    67 	}

    68 	

    69 TTestDataStruct* CTestData::GetTestDataL(TTestNumber aTestNumber, CCalInstanceView* aInstanceView, CCalEntryView* aEntryView, TBool aFloating, TBool aSummerTime)

    70 	{

    71 	TTestDataStruct* testData = new (ELeave) TTestDataStruct();

    72 	testData->iTimes.Reset();

    73 	testData->iRecIds.Reset();

    74 	switch (aTestNumber)

    75 		{

    76 		

    77 		case ECreateParent:

    78 			{

    79 			testData->iGuidsToExtract.AppendL(KGUID1());

    80 			testData->iDescription.Copy(_L("Entry Test: ECreateParent\n"));

    81 			testData->iTestType = TTestDataStruct::EEntryTest;		

    82 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

    83 			}

    84 			break;		

    85 		case ECreateAndDeleteParent:

    86 			{

    87 			testData->iGuidsToExtract.AppendL(KGUID1());

    88 			testData->iDescription.Copy(_L("Entry Test: ECreateAndDeleteParent, delete using DeleteL(const CDesC8Array&)\n"));

    89 			testData->iTestType = TTestDataStruct::EEntryTest;

    90 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

    91 			DeleteParentGsEntryL(aEntryView, KGUID1());

    92 			}

    93 			break;

    94 		case ECreateSameParentTwice:

    95 			{

    96 			testData->iGuidsToExtract.AppendL(KGUID1());

    97 			testData->iDescription.Copy(_L("Entry Test: ECreateSameParentTwice, create another Parent with the same Guid - 2nd should replace 1st\n"));

    98 			testData->iTestType = TTestDataStruct::EEntryTest;

    99 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   100 			

   101 			delete testData;

   102 			TTestDataStruct* testData1 = new (ELeave) TTestDataStruct();

   103 			testData1->iTimes.Reset();

   104 			testData1->iRecIds.Reset();

   105 			testData1->iGuidsToExtract.AppendL(KGUID1());

   106 			testData1->iDescription.Copy(_L("Entry Test: ECreateSameParentTwice, Create Parent, then create another with the same Guid - 2nd should replace 1st\n"));

   107 			testData1->iTestType = TTestDataStruct::EEntryTest;

   108 			CreateParentGsEntryL(GetDailyTestData1L(*testData1), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   109 			testData = testData1;

   110 			}

   111 			break;

   112 

   113 		case ECreateAndSingleDeleteParent:

   114 			{

   115 			testData->iGuidsToExtract.AppendL(KGUID1());

   116 			testData->iDescription.Copy(_L("Entry Test: ECreateAndSingleDeleteParent, delete using DeleteL(CCalEntry&)\n"));

   117 			testData->iTestType = TTestDataStruct::EEntryTest;

   118 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   119 			SingleDeleteParentGsEntryL(aEntryView, KGUID1());

   120 			}

   121 			break;

   122 			

   123 		case ECreateParentAnd1Child: 

   124 			{

   125 			testData->iGuidsToExtract.AppendL(KGUID1());

   126 			testData->iDescription.Copy(_L("Entry Test: ECreateParentAnd1Child\n"));

   127 			testData->iTestType = TTestDataStruct::EEntryTest;

   128 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   129 			CreateChildGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   130 			}

   131 			break;

   132 

   133 

   134 		case ECreateParentAnd2Child:

   135 			{

   136 			testData->iGuidsToExtract.AppendL(KGUID2());

   137 			testData->iDescription.Copy(_L("Entry Test: ECreateParentAnd2Child\n"));

   138 			testData->iTestType = TTestDataStruct::EEntryTest;

   139 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   140 			CreateChildGsEntryL(testData, 4, aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   141 			CreateChildGsEntryL(testData, 7, aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   142 			}

   143 			break;

   144 

   145 		case EAddMultipleEntries:

   146 			{

   147 			testData->iGuidsToExtract.AppendL(KGUID1());

   148 			testData->iGuidsToExtract.AppendL(KGUID2());

   149 			testData->iGuidsToExtract.AppendL(KGUID3());

   150 			testData->iDescription.Copy(_L("Entry Test: EAddMultipleEntries, create multiple Parent GS entries\n"));

   151 			testData->iTestType = TTestDataStruct::EEntryTest;

   152 			AddMultipleEntriesL(GetDailyTestData1L(*testData), aEntryView, CCalEntry::EAppt, aFloating);

   153 			}

   154 			break;

   155 			

   156 			

   157 		case EReplaceExistingChild:

   158 			{				

   159 			testData->iGuidsToExtract.AppendL(KGUID2());

   160 			testData->iDescription.Copy(_L("Entry Test: EReplaceExistingChild, Add an already existing child (should replace it)\n"));

   161 			testData->iTestType = TTestDataStruct::EEntryTest;

   162             CreateParentGsEntryL(GetDailyTestData1L(*testData, aSummerTime), aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   163 			CreateChildGsEntryL(testData, 4, aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   164 			CreateChildGsEntryL(testData, 7, aEntryView, KGUID2(), CCalEntry::EAppt, aFloating);

   165 			CreateChildGsEntryL(testData, 4, aEntryView, KGUID2(), CCalEntry::EAppt, aFloating); // Adding identical child should replace the existing one

   166 			}

   167 			break;

   168 			

   169 		case EGetInstancesParentOnly:

   170 			{

   171 			testData->iGuidsToExtract.AppendL(KGUID1());

   172 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentOnly\n"));

   173 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   174 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   175 			

   176 			// expected times:

   177 			testData->iTimes.Reset();

   178 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 5, 0, 0, 0, 0)));		//  6 March

   179 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   180 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   181 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 8, 0, 0, 0, 0)));		//  9 March

   182 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   183 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   184 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 11, 0, 0, 0, 0)));	// 12 March

   185 			}

   186 			break;

   187 

   188 		case EGetInstancesParentWithExceptionDates:

   189 		// Set some exception dates on the parent

   190 			{

   191 			testData->iGuidsToExtract.AppendL(KGUID1());

   192 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionDates, Parent with some exception dates\n"));

   193 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   194 			CreateParentGsEntryWithExceptionsL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   195 			

   196 			// expected times:

   197 			testData->iTimes.Reset();

   198 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   199 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   200 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   201 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   202 			}

   203 			break;

   204 				

   205 		case EGetInstancesParentWithSporadicDates:

   206 		// Set some sporadic dates on the parent

   207 			{

   208 			testData->iGuidsToExtract.AppendL(KGUID1());

   209 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithSporadicDates, Parent with some sporadic dates\n"));

   210 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   211 			CreateParentGsEntryWithSporadicsL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   212 			

   213 			// expected times:

   214 			testData->iTimes.Reset();

   215 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 2, 0, 0, 0, 0)));		//  3 March

   216 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 5, 0, 0, 0, 0)));		//  6 March

   217 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   218 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   219 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 8, 0, 0, 0, 0)));		//  9 March

   220 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   221 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   222 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 11, 0, 0, 0, 0)));	// 12 March

   223 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 12, 0, 0, 0, 0)));	// 13 March

   224 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 18, 0, 0, 0, 0)));	// 19 March

   225 			}

   226 			break;

   227 				

   228 		case EGetInstancesParentAnd1ChildException:

   229 		// Child specifies a modification to a date using RecId and Start/End date

   230 			{

   231 			testData->iGuidsToExtract.AppendL(KGUID1());

   232 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentAnd1ChildException, Parent and 1 Child exception\n"));

   233 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   234 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   235 			CreateChildExceptionGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   236 			

   237 			// expected times:

   238 			testData->iTimes.Reset();

   239 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 5, 0, 0, 0, 0)));		//  6 March

   240 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   241 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   242 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   243 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   244 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 11, 0, 0, 0, 0)));	// 12 March

   245 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 18, 0, 0, 0, 0)));	// 19 March

   246 			}

   247 			break;

   248 		

   249 		case EGetInstancesParentAnd1ChildRule:

   250 		// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef

   251 			{

   252 			testData->iGuidsToExtract.AppendL(KGUID1());

   253 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentAnd1ChildRule, Parent weekly RRule and Child with RRule (range=This+Future)\n"));

   254 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   255 			if (aFloating)

   256 				{

   257 				CreateParentGsEntryL(GetWeeklyTestData1FloatingL(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   258 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   259 				}

   260 			else

   261 				{

   262 				CreateParentGsEntryL(GetWeeklyTestData1L(*testData), aEntryView, KGUID1());

   263 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   264 				}

   265 			

   266 			// expected times:

   267 			testData->iTimes.Reset();

   268 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 8, 0, 0, 0, 0)));		//  9 March

   269 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   270 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   271 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   272 			}

   273 			break;

   274 			

   275 		case EGetInstancesParentAnd1ChildRuleMultiFetch:

   276 		// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef

   277 			{

   278 			testData->iGuidsToExtract.AppendL(KGUID1());

   279 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentAnd1ChildRuleMultiFetch, Parent weekly RRule and Child with RRule (range=This+Future)\n"));

   280 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   281 			if (aFloating)

   282 				{

   283 				CreateParentGsEntryL(GetWeeklyTestData1FloatingL(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   284 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   285 				}

   286 			else

   287 				{

   288 				CreateParentGsEntryL(GetWeeklyTestData1L(*testData), aEntryView, KGUID1());

   289 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   290 				}

   291 			

   292 			DoMultipleFetchAndStoreTestRuleChildL(testData, aEntryView, KGUID1(), 2);

   293 			 

   294 			// expected times:

   295 			testData->iTimes.Reset();

   296 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 8, 0, 0, 0, 0)));		//  9 March

   297 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   298 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   299 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   300 			}

   301 			break;

   302 		

   303 		case ETestGetSetMethods:

   304 			{

   305 			testData->iGuidsToExtract.AppendL(KGUID1());

   306 			testData->iTestType = TTestDataStruct::EEntryTest;

   307 			testData->iDescription.Copy(_L("Entry Test: ETestGetSetMethods\n"));

   308 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   309 			CreateChildGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   310 			if (aFloating)

   311 				{

   312 				TestSetGetMethodsFloatingL(aEntryView,KGUID1());

   313 				}

   314 			else

   315 				{

   316 				TestSetGetMethodsL(aEntryView,KGUID1());

   317 				}

   318 			}

   319 			break;

   320 			

   321 		case ETestUpdate:

   322 			{

   323 			testData->iGuidsToExtract.AppendL(KGUID1());

   324 			testData->iTestType = TTestDataStruct::EEntryTest;

   325 			testData->iDescription.Copy(_L("Entry Test: ETestUpdate\n"));

   326 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   327 			CreateChildGsEntryL(testData, 7, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   328 			TRAP_IGNORE(TestUpdateL(aEntryView,KGUID1()));

   329 			}

   330 			break;

   331 	

   332 		case EGetInstancesParentWithExceptionsAnd1ChildRuleThisAndFuture:

   333 			{

   334 			// Parent has rpt rule plus exceptions.

   335 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   336 			testData->iGuidsToExtract.Reset();

   337 			testData->iGuidsToExtract.AppendL(KGUID1());

   338 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsAnd1ChildRuleThisAndFuture, Parent,weekly rpt rule plus some exception and 1 Child with RRule (This+Future)\n"));

   339 			testData->iTestType = TTestDataStruct::EInstanceTest;

   340 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EException, CCalEntry::EAppt, aFloating);

   341 			if (aFloating)

   342 				{

   343 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   344 				}

   345 			else

   346 				{

   347 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   348 				}

   349 			

   350 			// Expected Instances if no parameters are changed: 8 April, 15, 22

   351 			testData->iTimes.Reset();

   352 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   353 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   354 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   355 			}

   356 			break;

   357 			

   358 		case EGetInstancesParentWithExceptionsRDatesAnd1ChildRuleThisAndFuture:

   359 			{

   360 			// Parent has rpt rule plus exceptions and sporadic rdates.

   361 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   362 			testData->iGuidsToExtract.AppendL(KGUID1());

   363 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsRDatesAnd1ChildRuleThisAndFuture, Parent,weekly rpt rule, some exceptions & rdates and 1 Child with RRule (This+Future)\n"));

   364 			testData->iTestType = TTestDataStruct::EInstanceTest;

   365 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EExceptionAndRDate, CCalEntry::EAppt, aFloating);

   366 			if (aFloating)

   367 				{

   368 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 5, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   369 				}

   370 			else

   371 				{

   372 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 5, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   373 				}

   374 			

   375 			// Expected Instances if no parameters are changed: 16March, 17, 24, 8April, 15, 22

   376 			testData->iTimes.Reset();

   377 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 15, 0, 0, 0, 0)));	// 16 March

   378 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 16, 0, 0, 0, 0)));	// 17 March

   379 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 23, 0, 0, 0, 0)));	// 24 March

   380 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   381 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   382 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   383 			}

   384 			break;

   385 			

   386 		case EGetInstancesParentWithExceptionsRDatesNonRptChildsAnd1ChildRuleThisAndFuture:

   387 			{

   388 			// Parent has rpt rule plus exceptions, sporadic rdates and non-repeating child entry.

   389 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   390 			testData->iGuidsToExtract.AppendL(KGUID1());

   391 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsRDatesNonRptChildsAnd1ChildRuleThisAndFuture, Parent,weekly rpt rule, some exceptions & rdates and 1 Child with RRule (This+Future)\n"));

   392 			testData->iTestType = TTestDataStruct::EInstanceTest;

   393 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EExceptionAndRDate, CCalEntry::EAppt, aFloating);

   394 			CreateChildExceptionGsEntryL(testData, 2, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   395 			if (aFloating)

   396 				{

   397 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 5, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   398 				}

   399 			else

   400 				{

   401 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 5, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   402 				}

   403 			

   404 			// Expected Instances if no parameters are changed: 17March, 19, 24, 8April, 15, 22

   405 			testData->iTimes.Reset();

   406 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 16, 0, 0, 0, 0)));	// 17 March

   407 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 18, 0, 0, 0, 0)));	// 19 March

   408 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 23, 0, 0, 0, 0)));	// 24 March

   409 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   410 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   411 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   412 			}

   413 			break;

   414 			

   415 		case EGetInstancesParentWithExceptionsAnd1ChildRuleThisAndPrior:

   416 			{

   417 			// Parent has rpt rule plus exceptions.

   418 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   419 			testData->iGuidsToExtract.Reset();

   420 			testData->iGuidsToExtract.AppendL(KGUID1());

   421 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsAnd1ChildRuleThisAndPrior, Parent,weekly rpt rule plus some exception and 1 Child with RRule (This+Prior)\n"));

   422 			testData->iTestType = TTestDataStruct::EInstanceTest;

   423 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EException, CCalEntry::EAppt, aFloating);

   424 			if (aFloating)

   425 				{

   426 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndPrior, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   427 				}

   428 			else

   429 				{

   430 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndPrior, aEntryView, KGUID1());

   431 				}

   432 			

   433 			// Expected Instances if no parameters are changed: 6April, 8, 13, 15, 20, 22

   434 			testData->iTimes.Reset();

   435 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 5, 0, 0, 0, 0)));		//  6 April

   436 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   437 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 12, 0, 0, 0, 0)));	// 13 April

   438 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   439 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 19, 0, 0, 0, 0)));	// 20 April

   440 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   441 			}

   442 			break;

   443 			

   444 		case EGetInstancesParentWithExceptionsRDatesAnd1ChildRuleThisAndPrior:

   445 			{

   446 			// Parent has rpt rule plus exceptions and sporadic rdates.

   447 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   448 			testData->iGuidsToExtract.AppendL(KGUID1());

   449 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsRDatesAnd1ChildRuleThisAndPrior, Parent,weekly rpt rule, some exceptions & rdates and 1 Child with RRule (This+Prior)\n"));

   450 			testData->iTestType = TTestDataStruct::EInstanceTest;

   451 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EExceptionAndRDate, CCalEntry::EAppt, aFloating);

   452 			if (aFloating)

   453 				{

   454 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 5, CalCommon::EThisAndPrior, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   455 				}

   456 			else

   457 				{

   458 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 5, CalCommon::EThisAndPrior, aEntryView, KGUID1());

   459 				}

   460 

   461 			// Expected Instances if no parameters are changed: 8April, 13, 15, 20, 22

   462 			testData->iTimes.Reset();

   463 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   464 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 12, 0, 0, 0, 0)));	// 13 April

   465 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   466 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 19, 0, 0, 0, 0)));	// 20 April

   467 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   468 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 23, 0, 0, 0, 0)));	// 24 April

   469 			}

   470 			break;

   471 			

   472 		case EGetInstancesParentWithExceptionsRDatesNonRptChildsAnd1ChildRuleThisAndPrior:

   473 			{

   474 			// Parent has rpt rule plus exceptions, sporadic rdates and non-repeating child entry.

   475 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   476 			testData->iGuidsToExtract.AppendL(KGUID1());

   477 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsRDatesNonRptChildsAnd1ChildRuleThisAndPrior, Parent,weekly rpt rule, some exceptions & rdates and 1 Child with RRule (This+Prior)\n"));

   478 			testData->iTestType = TTestDataStruct::EInstanceTest;

   479 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EExceptionAndRDate, CCalEntry::EAppt, aFloating);

   480 			CreateChildExceptionGsEntryL(testData, 2, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   481 			CreateChildExceptionGsEntry_1L(testData, 7, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   482 			if (aFloating)

   483 				{

   484 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 5, CalCommon::EThisAndPrior, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   485 				}

   486 			else

   487 				{

   488 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 5, CalCommon::EThisAndPrior, aEntryView, KGUID1());

   489 				}

   490 			

   491 			// Expected Instances if no parameters are changed: 8April, 13, 15, 18, 22

   492 			testData->iTimes.Reset();

   493 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   494 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 12, 0, 0, 0, 0)));	// 13 April

   495 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   496 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 17, 0, 0, 0, 0)));	// 18 April

   497 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   498 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 23, 0, 0, 0, 0)));	// 24 April

   499 			}

   500 			break;	

   501 			

   502 		/* 

   503 		 * This tests adding a second child-rule entry to a parent.

   504 		 * Adding a second child-rule entry is dis-allowed and causes a Leave.

   505 		 * However this test is commented out as the TRAPD below was for some reason not catching the Leave.

   506 		 */

   507 		case EGetInstancesParentWithExceptionsAnd2ChildRuleThisAndFuture:

   508 			{

   509 			// Parent has rpt rule plus exceptions.

   510 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   511 			testData->iGuidsToExtract.Reset();

   512 			testData->iGuidsToExtract.AppendL(KGUID1());

   513 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithExceptionsAnd2ChildRuleThisAndFuture, Parent,weekly rpt rule plus some exception and 2 Child with RRule\n"));

   514 			testData->iTestType = TTestDataStruct::EInstanceTest;

   515 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EException, CCalEntry::EAppt, aFloating);

   516 			if (aFloating)

   517 				{

   518 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndPrior, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   519 				}

   520 			else

   521 				{

   522 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndPrior, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);	

   523 				}

   524 

   525 

   526 			// CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 4, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   527 			TCalRRule* rule = NULL;

   528 			if (aFloating)

   529 				{

   530 				rule = GetWeeklyTestDataModification1FloatingL(*testData);

   531 				}

   532 			else

   533 				{

   534 				rule = GetWeeklyTestDataModification1L(*testData);

   535 				}

   536 			TRAP_IGNORE(

   537 				CreateChildRRuleGsEntryL(rule, testData, 4, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   538 				);

   539 

   540 			// Expected Instances if no parameters are changed: 6April, 8, 13, 15, 20, 22

   541 			testData->iTimes.Reset();

   542 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 5, 0, 0, 0, 0)));		//  6 April

   543 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 7, 0, 0, 0, 0)));		//  8 April

   544 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 12, 0, 0, 0, 0)));	// 13 April

   545 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 14, 0, 0, 0, 0)));	// 15 April

   546 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 19, 0, 0, 0, 0)));	// 20 April

   547 			testData->iTimes.Append(TTime(TDateTime(2005, EApril, 21, 0, 0, 0, 0)));	// 22 April

   548 	

   549 			}

   550 			break;

   551 

   552 		case EGetInstancesParentWithRDateBeforeRRule:

   553 			{

   554 			testData->iGuidsToExtract.Reset();

   555 			testData->iGuidsToExtract.AppendL(KGUID1());

   556 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithRDateBeforeRRule\n"));

   557 			testData->iTestType = TTestDataStruct::EInstanceTest;

   558 			CreateWeeklyParentGsEntryWithRDateRRuleL(*testData, aEntryView, KGUID1(), ERDateBeforeRRule, CCalEntry::EAppt, aFloating);

   559 			

   560 			// Expected Instances

   561 			testData->iTimes.Reset();

   562 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 11, 9, 0, 0, 0)));		// 12 Dec

   563 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 13, 10, 0, 0, 0)));		// 14 Dec

   564 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 14, 10, 0, 0, 0)));		// 15 Dec

   565 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 15, 10, 0, 0, 0)));		// 16 Dec

   566 			}

   567 			break;

   568 

   569 		case EGetInstancesParentWithRDateAfterRRule:

   570 			{

   571 			testData->iGuidsToExtract.Reset();

   572 			testData->iGuidsToExtract.AppendL(KGUID1());

   573 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentWithRDateAfterRRule\n"));

   574 			testData->iTestType = TTestDataStruct::EInstanceTest;

   575 			CreateWeeklyParentGsEntryWithRDateRRuleL(*testData, aEntryView, KGUID1(), ERDateAfterRRule, CCalEntry::EAppt, aFloating);

   576 			

   577 			// Expected Instances

   578 			testData->iTimes.Reset();

   579 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 13, 10, 0, 0, 0)));		// 14 Dec

   580 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 14, 10, 0, 0, 0)));		// 15 Dec

   581 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 15, 10, 0, 0, 0)));		// 16 Dec

   582 			testData->iTimes.Append(TTime(TDateTime(2005, EDecember, 19, 9, 0, 0, 0)));		// 20 Dec

   583 			}

   584 			break;

   585 			

   586 		case EDeleteAllChildExceptions:

   587 			{

   588 			// Parent has rpt rule plus exceptions, sporadic rdates and non-repeating child entry.

   589 			// Child specifies a change to parent's repeat rule by defining a RecId and new RptDef.	

   590 			testData->iGuidsToExtract.AppendL(KGUID1());

   591 			testData->iDescription.Copy(_L("Entry Test: EDeleteAllChildExceptions, Delete all child exceptions and see what happens\n"));

   592 			testData->iTestType = TTestDataStruct::EEntryTest;

   593 			CreateParentGsEntryL(GetWeeklyTestData2L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   594 			CreateChildExceptionGsEntryL(testData, 1, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   595 			CreateChildExceptionGsEntryL(testData, 2, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   596 			TestDeletionOfChildExceptionsL(aEntryView, aInstanceView, KGUID1());

   597 			}

   598 			break;

   599 			

   600 		case ECreateParentInvalidChildFloating: 

   601 			{

   602 			testData->iGuidsToExtract.AppendL(KGUID1());

   603 			testData->iDescription.Copy(_L("Entry Test: ECreateParentInvalidChildFloating\n"));

   604 			testData->iTestType = TTestDataStruct::EEntryTest;

   605 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   606 			TRAPD(err, CreateChildGsEntryL(testData, 4, aEntryView, KGUID1()));

   607 			test(err == KErrArgument);

   608 			}

   609 			break;

   610 			

   611 		case ECreateParentInvalidChildFloating2:

   612 			{

   613 			testData->iGuidsToExtract.AppendL(KGUID1());

   614 			testData->iDescription.Copy(_L("Entry Test: ECreateParentInvalidChildFloating2\n"));

   615 			testData->iTestType = TTestDataStruct::EEntryTest;

   616 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1());

   617 			TRAPD(err, CreateChildGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue));

   618 			test(err == KErrArgument);

   619 			}

   620 			break;

   621 			

   622 		case EGetInstancesParentAnd1ChildExceptionMultiFetch:

   623 			// Child specifies a modification to a date using RecId and Start/End date

   624 			{

   625 			testData->iGuidsToExtract.AppendL(KGUID1());

   626 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentAnd1ChildExceptionMultiFetch, Parent and 1 Child exception\n"));

   627 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   628 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   629 			CreateChildExceptionGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt, aFloating);

   630 			

   631 			DoMultipleFetchAndStoreTestExceptionChildL(testData, aEntryView, KGUID1(), 4);

   632 			

   633 			// expected times:

   634 			testData->iTimes.Reset();

   635 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 5, 0, 0, 0, 0)));		//  6 March

   636 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   637 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   638 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   639 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   640 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 11, 0, 0, 0, 0)));	// 12 March

   641 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 18, 0, 0, 0, 0)));	// 19 March

   642 			}

   643 			break;

   644 

   645 		case EDeleteEntryThatHasNoInstances:

   646 			{

   647 			testData->iTestType = TTestDataStruct::EInstanceTest;

   648 			testData->iDescription.Copy(_L("Instance Test: EDeleteEntryThatHasNoInstances\n"));

   649 			testData->iGuidsToExtract.AppendL(KGUID1());	

   650 			TestDeletionOfEntryThatHasNoInstancesL(GetDailyTestData1L(*testData), *testData, aEntryView, aInstanceView,

   651 												   KGUID1(), CCalEntry::EAppt, aFloating);

   652 			}

   653 			break;

   654 			

   655 		case EStoreRestoreParentWithAChild:

   656 			{

   657 			testData->iGuidsToExtract.Reset();

   658 			testData->iGuidsToExtract.AppendL(KGUID1());

   659 			testData->iDescription.Copy(_L("Instance Test: EStoreRestoreParentWithAChild, Update parent who had one child\n"));

   660 			testData->iTestType = TTestDataStruct::EInstanceTest;

   661 			CreateWeeklyParentGsEntryWithExceptionsRdatesL(*testData, aEntryView, KGUID1(), EException, CCalEntry::EAppt, aFloating);

   662 			if (aFloating)

   663 				{

   664 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1FloatingL(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1(), CCalEntry::EAppt, ETrue);

   665 				}

   666 			else

   667 				{

   668 				CreateChildRRuleGsEntryL(GetWeeklyTestDataModification1L(*testData), testData, 2, CalCommon::EThisAndFuture, aEntryView, KGUID1());

   669 				}

   670 			

   671 			StoreRestoreL(aEntryView, KGUID1());

   672 			

   673 			// Expected Instances - none. 

   674 			// because child entry was deleted when parent was updated and only child held actual instances

   675 			testData->iTimes.Reset();

   676 			}

   677 			break;

   678 			

   679 		case EGetInstancesParentAnd1ChildExceptionModify:

   680 		// Child specifies a modification to a date using RecId and Start/End date

   681 		// Try to modify this child entry, by getting it from the instance.

   682 			{

   683 			testData->iGuidsToExtract.AppendL(KGUID1());

   684 			testData->iDescription.Copy(_L("Instance Test: EGetInstancesParentAnd1ChildExceptionModify, Parent and 1 Child exception modify\n"));

   685 			testData->iTestType = TTestDataStruct::EInstanceTest;		

   686 			CreateParentGsEntryL(GetDailyTestData1L(*testData), aEntryView, KGUID1(), CCalEntry::EAppt);

   687 			

   688 			// here 4 means array offset ie 5+4 = 9 march

   689 			CreateChildExceptionGsEntryL(testData, 4, aEntryView, KGUID1(), CCalEntry::EAppt);

   690 			TestEntryFromInstanceAndModifyL(testData, aEntryView, aInstanceView, KGUID1(), 4);

   691 			

   692 			// expected times:

   693 			testData->iTimes.Reset();

   694 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 5, 0, 0, 0, 0)));		//  6 March

   695 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 6, 0, 0, 0, 0)));		//  7 March

   696 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 7, 0, 0, 0, 0)));		//  8 March

   697 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 9, 0, 0, 0, 0)));		// 10 March

   698 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 10, 0, 0, 0, 0)));	// 11 March

   699 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 11, 0, 0, 0, 0)));	// 12 March

   700 			testData->iTimes.Append(TTime(TDateTime(2005, EMarch, 21, 0, 0, 0, 0)));	// 19 March

   701 			}

   702 			break;

   703 		case EStoreParentHaveNoInstanceAndChildren:	

   704 			{

   705 			testData->iGuidsToExtract.AppendL(KGUID1());

   706 			testData->iDescription.Copy(_L("Entry Test: EStoreParentHaveNoInstanceAndChildren"));

   707 			testData->iTestType = TTestDataStruct::EEntryTest;

   708 			StoreParentHaveNoInstanceAndChildrenL(aEntryView, KGUID1());

   709 			}

   710 			break;

   711 

   712 		default:

   713 			ASSERT(0);

   714 			break;

   715 		}

   716 		

   717 	return testData;

   718 	}

   719 

   720 void CTestData::StoreParentHaveNoInstanceAndChildrenL(CCalEntryView* aEntryView, const TDesC8& aGuid)

   721     {// Add an entry

   722 	RPointerArray<CCalEntry> entries;

   723 	CleanupResetAndDestroyPushL(entries);

   724 

   725 //create an simple entry and store it to the file

   726 	TBuf<50> summary;

   727 	

   728 	HBufC8* guid = aGuid.AllocLC();

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

   730 	CleanupStack::Pop(guid);

   731 	CleanupStack::PushL(entry);

   732 	

   733 	entry->SetSummaryL(_L( "Parent Entry" ));

   734 

   735     TTime startTime = TDateTime( 2006, EMay, 24, 13, 0, 0, 0 );

   736     TTime endTime = TDateTime( 2006, EMay, 24, 14, 0, 0, 0 );

   737 

   738 	TCalTime calStartTime;

   739 	calStartTime.SetTimeUtcL(startTime);

   740 	TCalTime calEndTime;

   741 	calEndTime.SetTimeUtcL(endTime);

   742 	entry->SetStartAndEndTimeL(calStartTime, calEndTime);

   743 

   744 	TCalRRule rptRule;

   745     

   746     RArray<TDay> daysArray;

   747     CleanupClosePushL( daysArray );

   748     daysArray.AppendL( calStartTime.TimeLocalL().DayNoInWeek() );

   749     

   750     TCalTime untilCalTime;

   751    	TTime untilTime = TDateTime( 2006, EJune, 0, 14, 0, 0, 0 );

   752     untilCalTime.SetTimeUtcL( untilTime );

   753     

   754     rptRule.SetDtStart( calStartTime );

   755     rptRule.SetType( TCalRRule::EWeekly );

   756     rptRule.SetByDay(  daysArray );

   757     rptRule.SetUntil( untilCalTime );

   758     rptRule.SetInterval( 1 );

   759 	

   760 	CleanupStack::PopAndDestroy( &daysArray );

   761 	

   762 	entry->SetRRuleL(rptRule);

   763    

   764 	entries.AppendL(entry);

   765 	CleanupStack::Pop(entry);

   766 	

   767 	TInt entriesStored = 0;

   768 	aEntryView->StoreL(entries, entriesStored);

   769 	TInt localuid = entries[0]->LocalUidL();

   770 	test(entriesStored ==1);

   771 	entries.ResetAndDestroy();

   772 

   773 //update the first instance

   774     guid = aGuid.AllocLC();

   775     entry = CCalEntry::NewL( CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0, calStartTime, CalCommon::EThisOnly );

   776     CleanupStack::Pop( guid );

   777     

   778 	entries.AppendL( entry );

   779 	

   780     entry->SetStartAndEndTimeL( calStartTime, calEndTime );

   781 	entry->SetSummaryL( _L("Repeating Entry") );

   782 	entry->SetLocationL( _L( "Prague" ) );

   783 	

   784     aEntryView->StoreL(entries, entriesStored);

   785     localuid = entries[0]->LocalUidL();

   786 	entries.ResetAndDestroy();

   787 	

   788 //update the sencond instance

   789 

   790     TTime recTime;

   791     TCalTime startCalTimeChanged; 

   792     TCalTime endCalTimeChanged;

   793     TCalTime recCalTime;

   794     startTime = calStartTime.TimeUtcL();

   795     recTime = startTime + TTimeIntervalDays( 7 );

   796     recCalTime.SetTimeUtcL( recTime );

   797     

   798     guid = aGuid.AllocLC();

   799     entry = CCalEntry::NewL( CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0, recCalTime, CalCommon::EThisOnly );

   800     CleanupStack::Pop( guid );

   801     

   802 	entries.AppendL( entry );

   803 	

   804 	startTime = recTime + TTimeIntervalHours( 1 );

   805 	endTime = startTime + TTimeIntervalHours( 1 );

   806 	

   807 	startCalTimeChanged.SetTimeUtcL( startTime );

   808 	endCalTimeChanged.SetTimeUtcL( endTime );

   809 	

   810     entry->SetStartAndEndTimeL( startCalTimeChanged, endCalTimeChanged );

   811 	entry->SetSummaryL( _L("Repeating Entry") );

   812 	entry->SetLocationL( _L( "Dallas" ) );

   813 	

   814     aEntryView->StoreL(entries, entriesStored);

   815     localuid = entries[0]->LocalUidL();

   816     entries.ResetAndDestroy();

   817    

   818 //Fetch the entry

   819     aEntryView->FetchL(aGuid, entries);

   820    

   821 //store again

   822 	aEntryView->StoreL(entries, entriesStored);

   823    

   824   	CleanupStack::PopAndDestroy(&entries);

   825 	}

   826 

   827 // Sub-routine that tests fetching and storing of a parent and child multiple times making sure the child's recId is correct.

   828 // This should only be called for a Parent and a single non-repeating child.

   829 void CTestData::DoMultipleFetchAndStoreTestExceptionChildL(TTestDataStruct* aTestData, CCalEntryView* aEntryView, const TDesC8& aGuid, TInt aRecIdToUse)

   830 	{

   831 	--aRecIdToUse;

   832 	

   833 	// Fetch both parent and child which have been stored

   834 	RPointerArray<CCalEntry> entryArray;

   835 	CleanupResetAndDestroyPushL(entryArray);

   836 	HBufC8* guid = aGuid.AllocLC();

   837 	aEntryView->FetchL(*guid, entryArray);

   838 	test(entryArray.Count() == 2);

   839 	// Check RecId of child entry

   840 	TCalTime recId = entryArray[1]->RecurrenceIdL();

   841 	test(recId.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   842 	

   843 	// Fetch only the child	(via its local id)

   844 	TCalLocalUid luid = entryArray[1]->LocalUidL();

   845 	CCalEntry* child = aEntryView->FetchL(luid);

   846 	CleanupStack::PushL(child);

   847 	TCalTime recId2 = child->RecurrenceIdL();

   848 	test(recId2.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   849 	test(child->UidL() == aGuid);

   850 	

   851 	// Edit child in some way

   852 	child->SetLastModifiedDateL();

   853 	

   854 	// Store only the child

   855 	RPointerArray<CCalEntry> arrayCh;

   856 	CleanupClosePushL(arrayCh);

   857 	arrayCh.Append(child);

   858 	TInt successCh(0);

   859 	aEntryView->StoreL(arrayCh, successCh);

   860 	test(successCh == 1);

   861 	CleanupStack::Pop(&arrayCh);

   862 	arrayCh.Reset();

   863 	

   864 	CleanupStack::PopAndDestroy(child);

   865 

   866 	// Fetch both parent & child again

   867 	RPointerArray<CCalEntry> entryArray2;

   868 	CleanupResetAndDestroyPushL(entryArray2);

   869 	aEntryView->FetchL(*guid, entryArray2);

   870 	test(entryArray2.Count() == 2);

   871 	// Test RecId of Child

   872 	recId = entryArray2[1]->RecurrenceIdL();

   873 	test(recId.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   874 		

   875 	// Store child only

   876 	RPointerArray<CCalEntry> arrayCh2;

   877 	CleanupClosePushL(arrayCh2);

   878 	arrayCh2.Append(entryArray2[1]);

   879 	TInt successCh2(0);

   880 	aEntryView->StoreL(arrayCh2, successCh2);

   881 	test(successCh2 == 1);

   882 

   883 	// Fetch only the child	(via its local id)

   884 	luid = arrayCh2[0]->LocalUidL();

   885 	CCalEntry* child2 = aEntryView->FetchL(luid);

   886 	CleanupStack::PushL(child2);

   887 	recId2 = child2->RecurrenceIdL();

   888 	test(recId2.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);	

   889 	

   890 	// Store both the parent & child again

   891 	RPointerArray<CCalEntry> arrayS;

   892 	CleanupClosePushL(arrayS);

   893 	arrayS.Append(entryArray2[0]);

   894 	arrayS.Append(child2);

   895 	TInt success(0);

   896 	aEntryView->StoreL(arrayS, success);

   897 	CleanupStack::Pop(&arrayS);

   898 	arrayS.Reset();	

   899 

   900 	CleanupStack::PopAndDestroy(child2);

   901 	CleanupStack::Pop(&arrayCh2);

   902 	arrayCh2.Reset();

   903 	CleanupStack::Pop(&entryArray2);

   904 	entryArray2.ResetAndDestroy();

   905 	

   906 	// Fetch both parent & child again

   907 	RPointerArray<CCalEntry> entryArray3;

   908 	CleanupResetAndDestroyPushL(entryArray3);

   909 	aEntryView->FetchL(*guid, entryArray3);

   910 	test(entryArray3.Count() == 2);

   911 	// Test RecId of Child

   912 	recId = entryArray3[1]->RecurrenceIdL();

   913 	test(recId.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   914 	CleanupStack::Pop(&entryArray3);

   915 	

   916 	// Finally store both again

   917 	success = 0;

   918 	aEntryView->StoreL(entryArray3, success);

   919 	

   920 	entryArray3.ResetAndDestroy();

   921 		

   922 	CleanupStack::PopAndDestroy(guid);

   923 	CleanupStack::Pop(&entryArray);

   924 	entryArray.ResetAndDestroy();

   925 	}

   926 

   927 

   928 // Sub-routine that tests fetching of a parent and child making sure the child's recId is correct.

   929 // This should only be called for a Parent and a single repeating child.

   930 // Note we can not re-store the fetched child object as it will not contain its recId range value.

   931 void CTestData::DoMultipleFetchAndStoreTestRuleChildL(TTestDataStruct* aTestData, CCalEntryView* aEntryView, const TDesC8& aGuid, TInt aRecIdToUse)

   932 	{

   933 	--aRecIdToUse;

   934 	

   935 	// Fetch both parent and child which have been stored

   936 	RPointerArray<CCalEntry> entryArray;

   937 	CleanupResetAndDestroyPushL(entryArray);

   938 	HBufC8* guid = aGuid.AllocLC();

   939 	aEntryView->FetchL(*guid, entryArray);

   940 	test(entryArray.Count() == 2);

   941 	// Check RecId of child entry

   942 	TCalTime recId = entryArray[1]->RecurrenceIdL();

   943 	test(recId.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   944 	

   945 	// Fetch only the child	(via its local id)

   946 	TCalLocalUid luid = entryArray[1]->LocalUidL();

   947 	CCalEntry* child = aEntryView->FetchL(luid);

   948 	CleanupStack::PushL(child);

   949 	TCalTime recId2 = child->RecurrenceIdL();

   950 	test(recId2.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   951 	test(child->UidL() == aGuid);

   952 	

   953 	CleanupStack::PopAndDestroy(child);

   954 	CleanupStack::PopAndDestroy(guid);

   955 	CleanupStack::Pop(&entryArray);

   956 	entryArray.ResetAndDestroy();

   957 	}

   958 

   959 // Fetch a child using the instance method, and then modify the same.	

   960 void CTestData::TestEntryFromInstanceAndModifyL(TTestDataStruct* aTestData, CCalEntryView* aEntryView, CCalInstanceView* aInstanceView, const TDesC8& aGuid, TInt aRecIdToUse)

   961 	{

   962 		--aRecIdToUse;

   963 	

   964 		// The exception child was created on 19 march.

   965 		TTime filterStartTime(TDateTime(2005, EMarch, 18, 0, 0, 0, 0));

   966 		TTime filterEndTime(TDateTime(2005, EMarch, 18, 23, 0, 0, 0));

   967 		TCalTime filterStartTimeCal;

   968 		TCalTime filterEndTimeCal;

   969 		filterStartTimeCal.SetTimeLocalL(filterStartTime);

   970 		filterEndTimeCal.SetTimeLocalL(filterEndTime);

   971 	

   972 		// Fetch the instance 

   973 		RPointerArray< CCalInstance > instanceList;

   974 		CalCommon::TCalTimeRange aTimeRange(filterStartTimeCal,filterEndTimeCal) ;

   975 		aInstanceView->FindInstanceL( instanceList, CalCommon::EIncludeAppts, aTimeRange);

   976 		test(1 == instanceList.Count());

   977 		

   978 		// Get the recurrance id from the instance.

   979 		CCalEntry & entryFromIns = instanceList[0]->Entry();

   980 		TCalTime recId = entryFromIns.RecurrenceIdL();

   981 		test(recId.TimeLocalL() == aTestData->iRecIds[aRecIdToUse]);

   982 		instanceList.ResetAndDestroy();

   983 		

   984 		// Using this rec id obtained from instanceL, create a new modifying entry 

   985 		HBufC8* guid = aGuid.AllocLC();

   986 		CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 2, recId, CalCommon::EThisOnly);

   987 		CleanupStack::Pop(guid);

   988 		CleanupStack::PushL(entry);

   989 		TTime secondModStartTime(TDateTime(2005, EMarch, 21, 0, 0, 0, 0)); 

   990 		TTime secondModEndTime(secondModStartTime + TTimeIntervalHours(1));

   991 		TCalTime startTimeCal;

   992 		startTimeCal.SetTimeLocalL(secondModStartTime);

   993 		TCalTime endTimeCal;

   994 		endTimeCal.SetTimeLocalL(secondModEndTime);

   995 		entry->SetStartAndEndTimeL(startTimeCal, endTimeCal);

   996 	

   997 		RPointerArray<CCalEntry> entries;

   998 		CleanupClosePushL(entries);

   999 		entries.AppendL(entry);

  1000 		TInt success(0);

  1001 		aEntryView->StoreL(entries, success);

  1002 		test(success == entries.Count());

  1003 		CleanupStack::Pop(&entries);

  1004 		entries.Reset();

  1005 		CleanupStack::PopAndDestroy(entry);

  1006 	}

  1007 

  1008 

  1009 CCalEntry* CTestData::CreateParentLC(TCalRRule* aRpt, const TDesC8& aGuid, CCalEntry::TType aType, TBool aFloating)

  1010 	{

  1011 

  1012 	HBufC8* guid = aGuid.AllocLC();  // Create GUID on heap

  1013 

  1014 	// Below takes ownership of guid

  1015 	CCalEntry* entry = CCalEntry::NewL(aType, guid, CCalEntry::EMethodRequest, (TUint)0);

  1016 	

  1017 	CleanupStack::Pop(guid);

  1018 	CleanupStack::PushL(entry);

  1019 	

  1020 	TCalTime startTime;

  1021 	TCalTime calEndTime;

  1022 	if (aFloating)

  1023 		{

  1024 		startTime.SetTimeLocalFloatingL(aRpt->DtStart().TimeLocalL());

  1025 		

  1026 		// Set the start time to be same as repeat def's start time

  1027 		// and the end time to be 1 hour after start time.

  1028 		TTime endTime = aRpt->DtStart().TimeLocalL() + TTimeIntervalHours(1);

  1029 		calEndTime.SetTimeLocalFloatingL(endTime);

  1030 		}

  1031 	else

  1032 		{

  1033 		startTime = aRpt->DtStart();

  1034 

  1035 		// Set the start time to be same as repeat def's start time

  1036 		// and the end time to be 1 hour after start time.

  1037 		TTime endTime = aRpt->DtStart().TimeUtcL() + TTimeIntervalHours(1);

  1038 		calEndTime.SetTimeUtcL(endTime);

  1039 		}

  1040 	entry->SetStartAndEndTimeL(startTime, calEndTime);

  1041 	entry->SetRRuleL(*aRpt); // doesn't take ownership

  1042 	

  1043 	return entry;

  1044 	}

  1045 

  1046 

  1047 void CTestData::CreateParentGsEntryL(TCalRRule* aRpt, CCalEntryView* aEntryView, const TDesC8& aGuid, CCalEntry::TType aType, TBool aFloating)

  1048 	{

  1049 	CleanupStack::PushL(aRpt);

  1050 	

  1051 	CCalEntry* entry = CreateParentLC(aRpt, aGuid, aType, aFloating);

  1052 	

  1053 	RPointerArray<CCalEntry> array;

  1054 	CleanupClosePushL(array);

  1055 	array.Append(entry);

  1056 	TInt success(0);

  1057 	aEntryView->StoreL(array, success);

  1058 	CleanupStack::Pop(&array);

  1059 	array.Reset();

  1060 	

  1061 	CleanupStack::PopAndDestroy(entry);

  1062 	CleanupStack::PopAndDestroy(aRpt);

  1063 	}

  1064 

  1065 

  1066 // Creates a parent entry with a weekly rpt rule (GetWeeklyTestData1L())

  1067 // and adds exceptions and/or rdates to the parent entry. 

  1068 void CTestData::CreateWeeklyParentGsEntryWithExceptionsRdatesL(TTestDataStruct& aTestData, CCalEntryView* aEntryView, const TDesC8& aGuid, TExceptionRDate aExcpnRDate, CCalEntry::TType aType, TBool aFloating)

  1069 	{

  1070 	TCalRRule* rptRule;

  1071 	if (aFloating)

  1072 		{

  1073 		rptRule = GetWeeklyTestData1FloatingL(aTestData);

  1074 		}

  1075 	else

  1076 		{

  1077 		rptRule = GetWeeklyTestData1L(aTestData);

  1078 		}

  1079 	CleanupStack::PushL(rptRule);

  1080 	

  1081 	CCalEntry* entry = CreateParentLC(rptRule, aGuid, aType, aFloating);

  1082 	

  1083 	RArray<TCalTime> exArray;

  1084 	RArray<TCalTime> rDateArray;

  1085 	

  1086 	// Add exceptions or rdates to parent rpt rule

  1087 

  1088 	if ((aExcpnRDate == EException) || (aExcpnRDate == EExceptionAndRDate))

  1089 		{ 

  1090 		// Set 3 exceptions on the parent rpt rule (GetWeeklyTestData1L()) of 6,13,20 April 2005

  1091 		TCalTime exTime1;

  1092 		TCalTime exTime2;

  1093 		TCalTime exTime3;

  1094 		if (aFloating)

  1095 			{

  1096 			exTime1.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 8, 0, 0, 0, 0));  // 9 March

  1097 			exTime2.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 22, 0, 0, 0, 0)); // 23 March

  1098 			exTime3.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 29, 0, 0, 0, 0)); // 30 March

  1099 			}

  1100 		else

  1101 			{

  1102 			exTime1.SetTimeLocalL(TDateTime(2005, EMarch, 8, 0, 0, 0, 0));  // 9 March

  1103 			exTime2.SetTimeLocalL(TDateTime(2005, EMarch, 22, 0, 0, 0, 0)); // 23 March

  1104 			exTime3.SetTimeLocalL(TDateTime(2005, EMarch, 29, 0, 0, 0, 0)); // 30 March

  1105 			}

  1106 		exArray.Append(exTime1);

  1107 		exArray.Append(exTime2);

  1108 		exArray.Append(exTime3);

  1109 		

  1110 		entry->SetExceptionDatesL(exArray);

  1111 		}

  1112 

  1113 	if ((aExcpnRDate == ERDate) || (aExcpnRDate == EExceptionAndRDate))

  1114 		{

  1115 		// Set 3 sporadic dates on the parent (3, 24 March & 24 April 2005)

  1116 	

  1117 		TCalTime rDate1;

  1118 		TCalTime rDate2;

  1119 		TCalTime rDate3;

  1120 

  1121 		if (aFloating)

  1122 			{

  1123 			rDate1.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 16, 0, 0, 0, 0));  // 17 March

  1124 			rDate2.SetTimeLocalFloatingL(TDateTime(2005, EMarch, 23, 0, 0, 0, 0)); // 24 March

  1125 			rDate3.SetTimeLocalFloatingL(TDateTime(2005, EApril, 23, 0, 0, 0, 0)); // 24 April

  1126 			}

  1127 		else

  1128 			{

  1129 			rDate1.SetTimeLocalL(TDateTime(2005, EMarch, 16, 0, 0, 0, 0));  // 17 March

  1130 			rDate2.SetTimeLocalL(TDateTime(2005, EMarch, 23, 0, 0, 0, 0)); // 24 March

  1131 			rDate3.SetTimeLocalL(TDateTime(2005, EApril, 23, 0, 0, 0, 0)); // 24 April

  1132 			}

  1133 

  1134 		rDateArray.Append(rDate1);

  1135 		rDateArray.Append(rDate2);