1 /*

     2 * Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <e32svr.h>

    23 #include <StifParser.h>

    24 #include <Stiftestinterface.h>

    25 #include "tcal_providertest.h"

    26 #include <LiwCommon.h>

    27 #include <LiwVariant.h>

    28 #include <LiwServiceHandler.h>

    29 #include "calendarheader.h"

    30 #include "calendarconstants.h"

    31 #include <BADESCA.H>

    32 #include "notify.h"

    33 //#include <SendUiConsts.h>

    34 #include "messaginginterface.h"

    35 #include "sendmessage.h"

    36 #include <f32file.h>

    37 #include "messageheader.h"

    38 #include "serviceerrno.h"

    39 

    40 using namespace LIW;

    41 

    42 // EXTERNAL DATA STRUCTURES

    43 //extern  ?external_data;

    44 

    45 // EXTERNAL FUNCTION PROTOTYPES

    46 //extern ?external_function( ?arg_type,?arg_type );

    47 

    48 // CONSTANTS

    49 //const ?type ?constant_var = ?constant;

    50 

    51 // MACROS

    52 //#define ?macro ?macro_def

    53 

    54 // LOCAL CONSTANTS AND MACROS

    55 //const ?type ?constant_var = ?constant;

    56 //#define ?macro_name ?macro_def

    57 

    58 // MODULE DATA STRUCTURES

    59 //enum ?declaration

    60 //typedef ?declaration

    61 

    62 // LOCAL FUNCTION PROTOTYPES

    63 //?type ?function_name( ?arg_type, ?arg_type );

    64 

    65 // FORWARD DECLARATIONS

    66 //class ?FORWARD_CLASSNAME;

    67 

    68 // ============================= LOCAL FUNCTIONS ===============================

    69 

    70 // -----------------------------------------------------------------------------

    71 // ?function_name ?description.

    72 // ?description

    73 // Returns: ?value_1: ?description

    74 //          ?value_n: ?description_line1

    75 //                    ?description_line2

    76 // -----------------------------------------------------------------------------

    77 //

    78 /*

    79 ?type ?function_name(

    80     ?arg_type arg,  // ?description

    81     ?arg_type arg)  // ?description

    82     {

    83 

    84     ?code  // ?comment

    85 

    86     // ?comment

    87     ?code

    88     }

    89 */

    90 

    91 

    92 /*TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

    93 TInt AddProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);

    94 TInt AddProvAppointmentDailyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

    95 TInt AddProvEvent(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

    96 TInt AddProvToDo(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

    97 TInt AddAppointmentProvLocal(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);

    98 

    99 //void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );

   100 //TInt GetLocalUid( CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar,const TDesC& type, TCalLocalUid& aOutLocalUid );

   101 TInt GetLocalUid( CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar,TCalLocalUid& aOutLocalUid );

   102 void GetGlobalUid( const TDesC& aGlobalUid, TDes8& aOutGlobalUid );*/

   103 TInt ReqNotification( TInt aChangeType, TBool aLocalUid );

   104 

   105 TBuf<100> gid;

   106 _LIT8(KIDataSource, "IDataSource");

   107 _LIT8(KService, "Service.Calendar");

   108 _LIT8(KMsgService, 		"Service.Messaging");

   109 _LIT8(KMsgIDataSource,		"IMessaging");

   110 _LIT8(KMsgSendCmd,				"Send");

   111 _LIT8(KMsgDelete,				"Delete");

   112 _LIT8(KErrCode,"ErrorCode");

   113 _LIT8(KMsgGetListCmd,"GetList");

   114 _LIT(KSearchTexttest                 ,"Meeting");

   115 _LIT(KDefaultCalendar                ,"C:Calendar");

   116 _LIT(KTestCal1File, "C:getlistcal1");

   117 _LIT(KTestCalFile, "C:ccc");

   118 _LIT(KTestCal2File, "C:getlistcal2");

   119 

   120 // ============================ MEMBER FUNCTIONS ===============================

   121 

   122 // -----------------------------------------------------------------------------

   123 // Ctcal_providertest::Delete

   124 // Delete here all resources allocated and opened from test methods.

   125 // Called from destructor.

   126 // -----------------------------------------------------------------------------

   127 //

   128 void Ctcal_providertest::Delete()

   129     {

   130 

   131     }

   132 

   133 // -----------------------------------------------------------------------------

   134 // Ctcal_providertest::RunMethodL

   135 // Run specified method. Contains also table of test mothods and their names.

   136 // -----------------------------------------------------------------------------

   137 //

   138 TInt Ctcal_providertest::RunMethodL(

   139     CStifItemParser& aItem )

   140     {

   141 

   142     static TStifFunctionInfo const KFunctions[] =

   143         {

   144         // Copy this line for every implemented function.

   145         // First string is the function name used in TestScripter script file.

   146         // Second is the actual implementation member function.

   147         ENTRY( "Calendar_ops1", Ctcal_providertest::Calendar_ops1 ),

   148         ENTRY( "Calendar_ops2", Ctcal_providertest::Calendar_ops2 ),

   149         ENTRY( "Calendar_ops3", Ctcal_providertest::Calendar_ops3 ),

   150         ENTRY( "Calendar_ops4", Ctcal_providertest::Calendar_ops4 ),

   151         ENTRY( "Calendar_ops5", Ctcal_providertest::Calendar_ops5 ),

   152         ENTRY( "Calendar_ops6", Ctcal_providertest::Calendar_ops6 ),

   153         ENTRY( "Calendar_ops7", Ctcal_providertest::Calendar_ops7 ),

   154         ENTRY( "Calendar_ops8", Ctcal_providertest::Calendar_ops8 ),

   155         ENTRY( "Calendar_ops9", Ctcal_providertest::Calendar_ops9 ),

   156         ENTRY( "Calendar_ops10", Ctcal_providertest::Calendar_ops10 ),

   157         ENTRY( "Calendar_ops11", Ctcal_providertest::Calendar_ops11 ),

   158         ENTRY( "Calendar_ops12", Ctcal_providertest::Calendar_ops12 ),

   159         ENTRY( "Calendar_ops13", Ctcal_providertest::Calendar_ops13 ),

   160         ENTRY( "Calendar_ops14", Ctcal_providertest::Calendar_ops14 ),

   161         ENTRY( "Calendar_ops15", Ctcal_providertest::Calendar_ops15 ),

   162         ENTRY( "Calendar_ops16", Ctcal_providertest::Calendar_ops16 ),

   163         ENTRY( "Calendar_ops17", Ctcal_providertest::Calendar_ops17 ),

   164 

   165         ENTRY( "RemoveFile", Ctcal_providertest::RemoveFile ),

   166         //ADD NEW ENTRY HERE

   167 

   168         };

   169 

   170     const TInt count = sizeof( KFunctions ) /

   171                         sizeof( TStifFunctionInfo );

   172 

   173     return RunInternalL( KFunctions, count, aItem );

   174 

   175     }

   176 

   177 // Function to remove a file

   178 TInt Ctcal_providertest::RemoveFile( CStifItemParser& aItem )

   179     {

   180 		TPtrC16 file;

   181     	aItem.GetNextString(file);

   182   		RFile LogResult;

   183     	RFs LogResultSession;

   184     	User::LeaveIfError(LogResultSession.Connect());

   185     	if(LogResult.Open(LogResultSession ,file , EFileWrite | EFileShareAny )  != KErrNotFound)

   186         {

   187         	LogResult.Close();

   188 

   189 			LogResultSession.Delete(file);

   190 

   191         	LogResultSession.Close();

   192         }

   193 

   194     	LogResult.Close();

   195     	LogResultSession.Close();

   196 		return KErrNone;

   197 

   198     }

   199 

   200 

   201 // -----------------------------------------------------------------------------

   202 // Ctcal_providertest::Calendar_ops1

   203 // Example test method function to combine Add/Update operations on calendar entries.

   204 // (other items were commented in a header).

   205 // -----------------------------------------------------------------------------

   206 //

   207 TInt Ctcal_providertest::Calendar_ops1( CStifItemParser& aItem )

   208     {

   209 

   210     	TInt32 result=KErrNone;

   211     TLiwGenericParam param;

   212 	__UHEAP_MARK;

   213 

   214 	CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();

   215 

   216     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());

   217     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());

   218 

   219     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

   220     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   221 

   222     RCriteriaArray a;

   223 

   224     a.AppendL(crit);

   225 

   226     iServiceHandler->AttachL(a);

   227 

   228 	iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList);

   229 

   230 	delete crit;

   231 	crit = NULL;

   232 	a.Reset();

   233 

   234 	TInt pos = 0;

   235     MLiwInterface* interface = NULL;

   236     outParamList->FindFirst(pos,KIDataSource );

   237     if(pos != KErrNotFound)

   238         {

   239         interface = (*outParamList)[pos].Value().AsInterface();

   240         }

   241 

   242 	inParamList->Reset();

   243 	outParamList->Reset();

   244 

   245 	iLog->Log(_L("interface created for calendar_ops1"));

   246 

   247 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   248 

   249 	AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   250 

   251 	RPointerArray<TUIDSet> arruids(5);

   252 

   253 	TUIDSet* uids = NULL;

   254 

   255 	if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   256 		{

   257 		arruids.Append(uids);

   258 		uids = NULL;

   259 		}

   260 

   261 	if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   262 		{

   263 		arruids.Append(uids);

   264 		uids = NULL;

   265 		}

   266 

   267 	if ( arruids.Count() > 0 )

   268 		{

   269 			iLog->Log(_L("cal entries added for calendar_ops1"));

   270 

   271 		   	CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   272 			CleanupStack::PushL(map);

   273 

   274 		    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) );

   275 

   276 		    gid.Copy( arruids[0]->iGlobalUID->Des() );

   277 		    TInt lid_fetch_err = GetLocalUid(inParamList,outParamList,interface,KTestCal1File,arruids[0]->iLocalUID)	;

   278 		    if(lid_fetch_err)

   279 		    {

   280 		    	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   281 				interface->Close();

   282 				iServiceHandler->Reset();

   283 				delete iServiceHandler;

   284 				__UHEAP_MARKEND;

   285 				return lid_fetch_err;

   286 		    }

   287 

   288 			TBuf<10> localuid;

   289 			localuid.Num(TInt64(arruids[0]->iLocalUID));

   290 

   291 		    map->InsertL(_L8("LocalId"),TLiwVariant(localuid));

   292 		    map->InsertL(_L8("Summary"), TLiwVariant(_L("test")));

   293 

   294 

   295 		    param.SetNameAndValueL(KContentType,TLiwVariant(_L("CalendarEntry")));

   296    			inParamList->AppendL(param);

   297    			param.Reset();

   298 

   299 		    param.SetNameAndValueL(_L8("Item"),TLiwVariant(map));

   300    			inParamList->AppendL(param);

   301    			param.Reset();

   302 

   303 			map->DecRef();

   304 		    CleanupStack::Pop(map);

   305 

   306 			interface->ExecuteCmdL( KCmdAdd, *inParamList ,*outParamList );

   307 			pos=0;

   308 

   309 			const TLiwGenericParam* update_err = outParamList->FindFirst(pos,KErrorCode);

   310    			if(update_err)

   311    			result = update_err->Value().AsTInt32();

   312 

   313 

   314 			if(!result)

   315 			{

   316 				inParamList->Reset();

   317 				outParamList->Reset();

   318 

   319 				TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));

   320 				inParamList->AppendL(dsNameParam);

   321 

   322 				CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();

   323 				CleanupStack::PushL(map1);

   324 

   325 		    	map1->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) );

   326 		    	map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));

   327 

   328 				TLiwVariant filterparam1(map1);

   329 				TLiwGenericParam element2 ;

   330 				element2.SetNameAndValueL(_L8("Filter"),filterparam1);

   331 				filterparam1.Reset();

   332 

   333 				inParamList->AppendL(element2);

   334 				element2.Reset();

   335 

   336 				map1->DecRef();

   337 		    	CleanupStack::Pop(map1);

   338 

   339 				interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList);

   340 

   341 		    	pos = 0 ;

   342 		    	const TLiwGenericParam* getlist_err = outParamList->FindFirst(pos,KErrorCode);

   343    				if(getlist_err)

   344    				result = getlist_err->Value().AsTInt32();

   345    				pos=0;

   346 		    	const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("ReturnValue"));

   347 				TInt item_found = 0;

   348 

   349 				if(!result && output )

   350 				{

   351 					CLiwIterable* iterlist = output->Value().AsIterable();

   352 

   353 			    	TLiwVariant data;

   354 

   355 		        	while( iterlist->NextL(data))

   356 					{

   357 						const CLiwMap* res = data.AsMap();

   358 						if ( res )

   359 						{

   360 							TLiwVariant new_data;

   361 							if(res->FindL(_L8("Summary"), new_data))

   362 							{

   363 								TPtrC loc = new_data.AsDes();

   364 								TBuf<40> buf;

   365 								buf.Copy(loc);

   366 								iLog->Log(buf);

   367 								iLog->Log(_L("found entry whose summary field is being examined"));

   368 

   369 								if( loc.CompareF(_L("test")) != 0 )

   370 								{

   371 									result = KErrGeneral;

   372 									new_data.Reset();

   373 									break;

   374 								}

   375 								else

   376 									iLog->Log(_L("summar is test"));

   377 

   378 							}

   379 							new_data.Reset();

   380 						}

   381 			  		}

   382 

   383 			  		data.Reset();

   384 				}

   385 			}

   386 			inParamList->Reset();

   387 			outParamList->Reset();

   388 

   389 	    arruids.ResetAndDestroy();

   390 		}

   391 	else

   392 		result = KErrGeneral;

   393 

   394 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   395 

   396 	interface->Close();

   397 	iServiceHandler->Reset();

   398 	delete iServiceHandler;

   399 

   400     __UHEAP_MARKEND;

   401 	return result;

   402 

   403     }

   404 

   405 

   406 // -----------------------------------------------------------------------------

   407 // Ctcal_providertest::Calendar_ops2

   408 // Example test method function to combine import/export/Delete operations on calendar entries.

   409 // (other items were commented in a header).

   410 // -----------------------------------------------------------------------------

   411 //

   412 TInt Ctcal_providertest::Calendar_ops2( CStifItemParser& aItem )

   413     {

   414 

   415     	TInt32 result=KErrNone;

   416 

   417 	__UHEAP_MARK;

   418 

   419 	CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();

   420 

   421     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());

   422     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());

   423 

   424     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

   425     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   426 

   427     RCriteriaArray a;

   428 

   429     a.AppendL(crit);

   430 

   431     iServiceHandler->AttachL(a);

   432 

   433 	iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList);

   434 

   435 	delete crit;

   436 	crit = NULL;

   437 	a.Reset();

   438 

   439 	TInt pos = 0;

   440     MLiwInterface* interface = NULL;

   441     outParamList->FindFirst(pos,KIDataSource );

   442     if(pos != KErrNotFound)

   443         {

   444         interface = (*outParamList)[pos].Value().AsInterface();

   445         }

   446 

   447 	inParamList->Reset();

   448 	outParamList->Reset();

   449 

   450 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   451 

   452 	AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   453 

   454 

   455 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   456 

   457 	AddProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   458 

   459 

   460 	RPointerArray<TUIDSet> arruids(5);

   461 

   462 	TUIDSet* uids = NULL;

   463 

   464 	if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   465 		{

   466 		arruids.Append(uids);

   467 		uids = NULL;

   468 		}

   469 

   470 	if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   471 		{

   472 		arruids.Append(uids);

   473 		uids = NULL;

   474 		}

   475 	TInt count = 0;

   476 

   477 	if ( arruids.Count() > 0 )

   478 		{

   479 			CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   480 			CleanupStack::PushL(map);

   481 

   482 		    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) );

   483 

   484 		    gid.Copy( arruids[0]->iGlobalUID->Des() );

   485 		    TInt lid_fetch_err = GetLocalUid(inParamList,outParamList,interface,KTestCal1File,arruids[0]->iLocalUID)	;

   486 		    if(lid_fetch_err)

   487 		    {

   488 		    	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   489 		    	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   490 				interface->Close();

   491 				iServiceHandler->Reset();

   492 				delete iServiceHandler;

   493 				__UHEAP_MARKEND;

   494 				return lid_fetch_err;

   495 		    }

   496 

   497 			TBuf<10> localuid;

   498 			localuid.Num(TInt64(arruids[0]->iLocalUID));

   499 

   500 		    map->InsertL(_L8("Format"), TLiwVariant(_L("VCal")) );

   501 		    map->InsertL(_L8("FileName"), TLiwVariant(_L("c:\\exportall.txt")));

   502 

   503 		    TLiwVariant content(_L("CalendarEntry"));

   504 			TLiwGenericParam element1;

   505 			element1.SetNameAndValueL(_L8("Type"),content);

   506 			inParamList->AppendL(element1);

   507 			content.Reset();

   508 			element1.Reset();

   509 

   510 		    TLiwVariant filterparam(map);

   511 			TLiwGenericParam element ;

   512 			element.SetNameAndValueL(_L8("Data"),filterparam);

   513 			filterparam.Reset();

   514 

   515 			inParamList->AppendL(element);

   516 			element.Reset();

   517 		    map->DecRef();

   518 		    CleanupStack::Pop(map);

   519 

   520 			interface->ExecuteCmdL( KCmdExport, *inParamList ,*outParamList );

   521 			pos=0;

   522 			const TLiwGenericParam* export_err = outParamList->FindFirst(pos,KErrorCode);

   523    			if(export_err)

   524    			result = export_err->Value().AsTInt32();

   525 

   526 			if(!result)

   527 			{

   528 				inParamList->Reset();

   529 				outParamList->Reset();

   530 

   531 				// Do an Import.

   532 

   533 				TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));

   534 				inParamList->AppendL(dsNameParam);

   535 

   536 				CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();

   537 				CleanupStack::PushL(map1);

   538 

   539 		   		map1->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   540 		    	map1->InsertL(_L8("Format"), TLiwVariant(_L("VCal")) );

   541 				map1->InsertL(_L8("FileName"), TLiwVariant(_L("c:\\exportall.txt")));

   542 

   543 				TLiwVariant filterparam1(map1);

   544 				TLiwGenericParam element2 ;

   545 				element2.SetNameAndValueL(_L8("Data"),filterparam1);

   546 				filterparam1.Reset();

   547 

   548 				inParamList->AppendL(element2);

   549 				element2.Reset();

   550 

   551 				map1->DecRef();

   552 		    	CleanupStack::Pop(map1);

   553 

   554 				interface->ExecuteCmdL( KCmdImport ,*inParamList ,*outParamList);

   555 		    	pos = 0 ;

   556 		    	const TLiwGenericParam* import_err = outParamList->FindFirst(pos,KErrorCode);

   557    				if(import_err)

   558    					result = import_err->Value().AsTInt32();

   559 

   560 				if(!result)

   561 				{

   562 					inParamList->Reset();

   563 					outParamList->Reset();

   564 

   565 					TLiwGenericParam dsNameParam1(KContentType, TLiwVariant(_L("CalendarEntry")));

   566 					inParamList->AppendL(dsNameParam1);

   567 

   568 					CLiwDefaultMap* map2 = CLiwDefaultMap::NewL();

   569 					CleanupStack::PushL(map2);

   570 

   571 		    		map2->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   572 		    		map2->InsertL(_L8("DeleteAll"), TLiwVariant(TBool(ETrue)) );

   573 

   574 					TLiwVariant filterparam2(map2);

   575 					TLiwGenericParam element3 ;

   576 					element3.SetNameAndValueL(_L8("Data"),filterparam2);

   577 					filterparam2.Reset();

   578 

   579 					inParamList->AppendL(element3);

   580 					element3.Reset();

   581 

   582 					map2->DecRef();

   583 		   			 CleanupStack::Pop(map2);

   584 

   585 		    		interface->ExecuteCmdL( KCmdDelete ,*inParamList ,*outParamList);

   586 		   			const TLiwGenericParam* delete_err = outParamList->FindFirst(pos,KErrorCode);

   587    					if(delete_err)

   588    						result = delete_err->Value().AsTInt32();

   589 

   590    					if(!result)

   591    					{

   592    						inParamList->Reset();

   593 						outParamList->Reset();

   594 

   595 						TLiwGenericParam dsNameParam2(KContentType, TLiwVariant(_L("CalendarEntry")));

   596 						inParamList->AppendL(dsNameParam2);

   597 

   598 						CLiwDefaultMap* map3 = CLiwDefaultMap::NewL();

   599 						CleanupStack::PushL(map3);

   600 

   601 		    			map3->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   602 		    			map3->InsertL(_L8("LocalUid"),TLiwVariant(localuid));

   603 

   604 						TLiwVariant filterparam3(map3);

   605 						TLiwGenericParam element4 ;

   606 						element4.SetNameAndValueL(_L8("Filter"),filterparam3);

   607 						filterparam3.Reset();

   608 

   609 						inParamList->AppendL(element4);

   610 						element4.Reset();

   611 

   612 						map3->DecRef();

   613 		    			CleanupStack::Pop(map3);

   614 

   615 						interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList);

   616 		    			pos = 0 ;

   617 		    			const TLiwGenericParam* getlist_err = outParamList->FindFirst(pos,KErrorCode);

   618    						if(getlist_err)

   619    						result = getlist_err->Value().AsTInt32();

   620    						pos=0;

   621 		    			const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("ReturnValue"));

   622 						if(!result && output)

   623 						{

   624 							CLiwIterable* iterlist = output->Value().AsIterable();

   625 			    			TLiwVariant data;

   626 		        			while( iterlist->NextL(data))

   627 							{

   628 								count ++;

   629 			  				}

   630 			  				data.Reset();

   631 						}

   632    					}

   633 				}

   634 			}

   635 

   636 	    inParamList->Reset();

   637 		outParamList->Reset();

   638 	    arruids.ResetAndDestroy();

   639 		}

   640 	else

   641 		result = KErrGeneral;

   642 

   643 	if(!result && count != 0)

   644 		result = KErrGeneral;

   645 	else

   646 		iLog->Log(_L("result pass in calendar_ops2"));

   647 

   648 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   649 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   650 

   651 	interface->Close();

   652 	iServiceHandler->Reset();

   653 	delete iServiceHandler;

   654 

   655     __UHEAP_MARKEND;

   656 

   657 	return result;

   658 

   659     }

   660 

   661 // -----------------------------------------------------------------------------

   662 // Ctcal_providertest::Calendar_ops3

   663 // Example test method function to combine import/export/Update operations on calendar entries.

   664 // (other items were commented in a header).

   665 // -----------------------------------------------------------------------------

   666 //

   667 TInt Ctcal_providertest::Calendar_ops3( CStifItemParser& aItem )

   668     {

   669 

   670     	TInt32 result=KErrNone;

   671 

   672 	__UHEAP_MARK;

   673 

   674 	CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();

   675 

   676     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());

   677     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());

   678 

   679     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

   680     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   681 

   682     RCriteriaArray a;

   683 

   684     a.AppendL(crit);

   685 

   686     iServiceHandler->AttachL(a);

   687 

   688 	iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList);

   689 

   690 	delete crit;

   691 	crit = NULL;

   692 	a.Reset();

   693 

   694 	TInt pos = 0;

   695     MLiwInterface* interface = NULL;

   696     outParamList->FindFirst(pos,KIDataSource );

   697     if(pos != KErrNotFound)

   698         {

   699         interface = (*outParamList)[pos].Value().AsInterface();

   700         }

   701 

   702 	inParamList->Reset();

   703 	outParamList->Reset();

   704 

   705 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   706 

   707 	AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   708 

   709 

   710 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   711 

   712 	AddProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   713 

   714 

   715 	RPointerArray<TUIDSet> arruids(5);

   716 

   717 	TUIDSet* uids = NULL;

   718 

   719 	if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   720 		{

   721 		arruids.Append(uids);

   722 		uids = NULL;

   723 		}

   724 

   725 	if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

   726 		{

   727 		arruids.Append(uids);

   728 		uids = NULL;

   729 		}

   730 	TInt count = 0;

   731 

   732 	if ( arruids.Count() > 0 )

   733 		{

   734 			CLiwDefaultMap* map = CLiwDefaultMap::NewL();

   735 			CleanupStack::PushL(map);

   736 		    map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) );

   737 

   738 		    gid.Copy( arruids[0]->iGlobalUID->Des() );

   739 		    TInt lid_fetch_err = GetLocalUid(inParamList,outParamList,interface,KTestCal1File,arruids[0]->iLocalUID)	;

   740 		    if(lid_fetch_err)

   741 		    {

   742 		    	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   743 		    	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   744 				interface->Close();

   745 				iServiceHandler->Reset();

   746 				delete iServiceHandler;

   747 				__UHEAP_MARKEND;

   748 				return lid_fetch_err;

   749 		    }

   750 

   751 			TBuf<10> localuid;

   752 			localuid.Num(TInt64(arruids[0]->iLocalUID));

   753 

   754 			TLiwVariant content(_L("CalendarEntry"));

   755 			TLiwGenericParam element1;

   756 			element1.SetNameAndValueL(_L8("Type"),content);

   757 			inParamList->AppendL(element1);

   758 			content.Reset();

   759 			element1.Reset();

   760 

   761 			map->InsertL(_L8("Format"), TLiwVariant(_L("VCal")) );

   762 		    map->InsertL(_L8("FileName"), TLiwVariant(_L("c:\\exportall.txt")));

   763 

   764 		    TLiwVariant filterparam(map);

   765 			TLiwGenericParam element ;

   766 			element.SetNameAndValueL(_L8("Data"),filterparam);

   767 			filterparam.Reset();

   768 

   769 			inParamList->AppendL(element);

   770 			element.Reset();

   771 		    map->DecRef();

   772 		    CleanupStack::Pop(map);

   773 

   774 			interface->ExecuteCmdL( KCmdExport, *inParamList ,*outParamList );

   775 			pos = 0 ;

   776 		    const TLiwGenericParam* export_err = outParamList->FindFirst(pos,KErrorCode);

   777    			if(export_err)

   778    				result = export_err->Value().AsTInt32();

   779 

   780    			if(!result)

   781    			{

   782    				inParamList->Reset();

   783 				outParamList->Reset();

   784 

   785 				// Do an Import.

   786 

   787 				TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));

   788 				inParamList->AppendL(dsNameParam);

   789 

   790 				CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();

   791 				CleanupStack::PushL(map1);

   792 

   793 		    	map1->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   794 		    	map1->InsertL(_L8("Format"), TLiwVariant(_L("VCal")) );

   795 				map1->InsertL(_L8("FileName"), TLiwVariant(_L("c:\\exportall.txt")));

   796 

   797 				TLiwVariant filterparam1(map1);

   798 				TLiwGenericParam element2 ;

   799 				element2.SetNameAndValueL(_L8("Data"),filterparam1);

   800 				filterparam1.Reset();

   801 

   802 				inParamList->AppendL(element2);

   803 				element2.Reset();

   804 

   805 				map1->DecRef();

   806 		    	CleanupStack::Pop(map1);

   807 

   808 				interface->ExecuteCmdL( KCmdImport ,*inParamList ,*outParamList);

   809 				pos=0;

   810 				const TLiwGenericParam* import_err = outParamList->FindFirst(pos,KErrorCode);

   811    				if(import_err)

   812    					result = import_err->Value().AsTInt32();

   813 

   814    				if(!result)

   815    				{

   816    					inParamList->Reset();

   817 					outParamList->Reset();

   818 

   819 					TLiwGenericParam dsNameParam1(KContentType, TLiwVariant(_L("CalendarEntry")));

   820 					inParamList->AppendL(dsNameParam1);

   821 

   822 					CLiwDefaultMap* map2 = CLiwDefaultMap::NewL();

   823 					CleanupStack::PushL(map2);

   824 

   825 		    		map2->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   826 		    		map2->InsertL(_L8("Summary"), TLiwVariant(_L("meeting")) );

   827 		    		map2->InsertL(_L8("LocalId"),TLiwVariant(localuid));

   828 

   829 					TLiwVariant filterparam2(map2);

   830 					TLiwGenericParam element3 ;

   831 					element3.SetNameAndValueL(_L8("Item"),filterparam2);

   832 					filterparam2.Reset();

   833 

   834 					inParamList->AppendL(element3);

   835 					element3.Reset();

   836 

   837 					map2->DecRef();

   838 		    		CleanupStack::Pop(map2);

   839 

   840 		    		interface->ExecuteCmdL( KCmdAdd ,*inParamList ,*outParamList);

   841 		    		pos=0;

   842 		    		const TLiwGenericParam* update_err = outParamList->FindFirst(pos,KErrorCode);

   843    					if(update_err)

   844    						result = update_err->Value().AsTInt32();

   845 

   846    					if(!result)

   847    					{

   848    						inParamList->Reset();

   849 						outParamList->Reset();

   850 

   851 						TLiwGenericParam dsNameParam2(KContentType, TLiwVariant(_L("CalendarEntry")));

   852 						inParamList->AppendL(dsNameParam2);

   853 

   854 						CLiwDefaultMap* map3 = CLiwDefaultMap::NewL();

   855 						CleanupStack::PushL(map3);

   856 

   857 		    			map3->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal2File) );

   858 		    			map3->InsertL(_L8("LocalId"),TLiwVariant(localuid));

   859 

   860 						TLiwVariant filterparam3(map3);

   861 						TLiwGenericParam element4 ;

   862 						element4.SetNameAndValueL(_L8("Filter"),filterparam3);

   863 						filterparam3.Reset();

   864 

   865 						inParamList->AppendL(element4);

   866 						element4.Reset();

   867 

   868 						map3->DecRef();

   869 		    			CleanupStack::Pop(map3);

   870 

   871 						interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList);

   872 		    			pos = 0 ;

   873 		    			const TLiwGenericParam* getlist_err = outParamList->FindFirst(pos,KErrorCode);

   874    						if(getlist_err)

   875    							result = getlist_err->Value().AsTInt32();

   876    						pos=0;

   877 		    			const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("ReturnValue"));

   878 

   879 		    			if(!result && output)

   880 						{

   881 							CLiwIterable* iterlist = output->Value().AsIterable();

   882 			    			TLiwVariant data;

   883 	    	    			while( iterlist->NextL(data))

   884 							{

   885 								const CLiwMap* res = data.AsMap();

   886 								if ( res )

   887 								{

   888 									TLiwVariant new_data;

   889 									if(res->FindL(_L8("Summary"), new_data))

   890 									{

   891 										TPtrC p_owner = new_data.AsDes();

   892 										if( p_owner.CompareF(_L("meeting")) != 0 )

   893 										{

   894 											result = KErrGeneral;

   895 											new_data.Reset();

   896 											break;

   897 										}

   898 									}

   899 									else

   900 										result = KErrGeneral;

   901 									new_data.Reset();

   902 								}

   903 								else

   904 									result = KErrGeneral;

   905 			  				}

   906 			  				data.Reset();

   907 						}

   908    					}

   909    				}

   910    			}

   911 

   912 	    inParamList->Reset();

   913 		outParamList->Reset();

   914 	    arruids.ResetAndDestroy();

   915 		}

   916 	else

   917 		result = KErrGeneral;

   918 

   919 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

   920 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

   921 

   922 	interface->Close();

   923 	iServiceHandler->Reset();

   924 	delete iServiceHandler;

   925 

   926     __UHEAP_MARKEND;

   927 	return result;

   928     }

   929 

   930 // -----------------------------------------------------------------------------

   931 // Ctcal_providertest::Calendar_ops4

   932 // Example test method function to combine notify/add ops on calendar entries.

   933 // (other items were commented in a header).

   934 // -----------------------------------------------------------------------------

   935 //

   936 TInt Ctcal_providertest::Calendar_ops4( CStifItemParser& aItem )

   937 	{

   938 	TInt32 result = KErrNone;

   939 	__UHEAP_MARK;

   940 

   941 	result = ReqNotification(1, EFalse);

   942 

   943 	__UHEAP_MARKEND;

   944 	return result;

   945 

   946     }

   947 

   948 // -----------------------------------------------------------------------------

   949 // Ctcal_providertest::Calendar_ops5

   950 // Example test method function to combine notify/update/delete operations on calendar entries.

   951 // (other items were commented in a header).

   952 // -----------------------------------------------------------------------------

   953 //

   954 TInt Ctcal_providertest::Calendar_ops5( CStifItemParser& aItem )

   955 	{

   956 	TInt32 result = KErrNone;

   957 	__UHEAP_MARK;

   958 

   959 	result = ReqNotification(2, EFalse);

   960 

   961 	__UHEAP_MARKEND;

   962 	return result;

   963 

   964     }

   965 

   966 

   967  // -----------------------------------------------------------------------------

   968 // Ctcal_providertest::Calendar_ops6

   969 // Example test method function to combine add/notify/update operations on calendar entries.

   970 // (other items were commented in a header).

   971 // -----------------------------------------------------------------------------

   972 //

   973 TInt Ctcal_providertest::Calendar_ops6( CStifItemParser& aItem )

   974 	{

   975 

   976 	TInt32 result = KErrNone;

   977 	__UHEAP_MARK;

   978 

   979 	CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();

   980 

   981     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());

   982     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());

   983 

   984     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

   985     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

   986 

   987     RCriteriaArray a;

   988 

   989     a.AppendL(crit);

   990 

   991     iServiceHandler->AttachL(a);

   992 

   993 	iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList);

   994 

   995 	delete crit;

   996 	crit = NULL;

   997 	a.Reset();

   998 

   999 	TInt pos = 0;

  1000     MLiwInterface* interface = NULL;

  1001     outParamList->FindFirst(pos,KIDataSource );

  1002     if(pos != KErrNotFound)

  1003         {

  1004         interface = (*outParamList)[pos].Value().AsInterface();

  1005         }

  1006 

  1007 	inParamList->Reset();

  1008 	outParamList->Reset();

  1009 

  1010 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

  1011 

  1012 	AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);

  1013 

  1014 	RPointerArray<TUIDSet> arruids(5);

  1015 

  1016 	TUIDSet* uids = NULL;

  1017 

  1018 	if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

  1019 		{

  1020 		arruids.Append(uids);

  1021 		uids = NULL;

  1022 		}

  1023 

  1024 	if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

  1025 		{

  1026 		arruids.Append(uids);

  1027 		uids = NULL;

  1028 		}

  1029 

  1030 

  1031 	CTestAsync* test = CTestAsync::NewL();

  1032 	test->Start( 3, EFalse );

  1033 	result = test->Result();

  1034 	test->CancelNotification();

  1035 	delete test;

  1036 

  1037 

  1038 	inParamList->Reset();

  1039 	outParamList->Reset();

  1040 

  1041 	arruids.ResetAndDestroy();

  1042 

  1043 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

  1044 

  1045 

  1046 	interface->Close();

  1047 	iServiceHandler->Reset();

  1048 	delete iServiceHandler;

  1049 	__UHEAP_MARKEND;

  1050 	return result;

  1051 

  1052     }

  1053 

  1054 

  1055 // -----------------------------------------------------------------------------

  1056 // Ctcal_providertest::Calendar_ops7

  1057 // Example test method function to combine add/export/notify/update ops on calendar entries.

  1058 // (other items were commented in a header).

  1059 // -----------------------------------------------------------------------------

  1060 //

  1061 TInt Ctcal_providertest::Calendar_ops7( CStifItemParser& aItem )

  1062 	{

  1063 	TInt32 result = KErrNone;

  1064 	__UHEAP_MARK;

  1065 

  1066 	result = ReqNotification(4, EFalse);

  1067 

  1068 	__UHEAP_MARKEND;

  1069 	return result;

  1070 

  1071     }

  1072 

  1073   // -----------------------------------------------------------------------------

  1074 // Ctcal_providertest::Calendar_ops8

  1075 // Example test method function to combine add/update/exp-upd/imp/getlist ops on calendar entries.

  1076 // (other items were commented in a header).

  1077 // -----------------------------------------------------------------------------

  1078 //

  1079 TInt Ctcal_providertest::Calendar_ops8( CStifItemParser& aItem )

  1080 	{

  1081 		TInt32 result=KErrNone;

  1082 

  1083 	__UHEAP_MARK;

  1084 

  1085 	CLiwServiceHandler* iServiceHandler = CLiwServiceHandler::NewL();

  1086 

  1087     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());

  1088     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());

  1089 

  1090     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);

  1091     crit->SetServiceClass(TUid::Uid(KLiwClassBase));

  1092 

  1093     RCriteriaArray a;

  1094 

  1095     a.AppendL(crit);

  1096 

  1097     iServiceHandler->AttachL(a);

  1098 

  1099 	iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList);

  1100 

  1101 	delete crit;

  1102 	crit = NULL;

  1103 	a.Reset();

  1104 

  1105 	TInt pos = 0;

  1106     MLiwInterface* interface = NULL;

  1107     outParamList->FindFirst(pos,KIDataSource );

  1108     if(pos != KErrNotFound)

  1109         {

  1110         interface = (*outParamList)[pos].Value().AsInterface();

  1111         }

  1112 

  1113 	inParamList->Reset();

  1114 	outParamList->Reset();

  1115 

  1116 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);

  1117 

  1118 	AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);

  1119 

  1120 

  1121 	RemoveProvCalendar(inParamList, outParamList, interface, KTestCal2File);

  1122 

  1123 	AddProvCalendar(inParamList, outParamList, interface, KTestCal2File);

  1124 

  1125 

  1126 	RPointerArray<TUIDSet> arruids(5);

  1127 

  1128 	TUIDSet* uids = NULL;

  1129 

  1130 	if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)

  1131 		{

  1132 		arruids.Append(uids);

  1133 		uids = NULL;

  1134 		}