--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_calendar/tsrc/dev/tcalendarprovidertest/tcalendarupdateiter3/src/tcalendarupdatetestblocks.cpp Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,1715 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: ?Description
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+//#include <SAPI_TEST\testprg.h>
+#include <Stiftestinterface.h>
+#include<LiwCommon.h>
+#include<LiwVariant.h>
+#include<LiwServiceHandler.h>
+
+#include "tcalendarupdatetest.h"
+#include "calendarheader.h"
+#include "calendarconstants.h"
+
+_LIT8(KTestInterface, "IDataSource");
+_LIT8(KTestContent, "Service.Calendar");
+_LIT(KKCalFileName11,"C:CalendarFileA");
+
+/*TInt RemoveCalendarFile(void* aInterfaceptr, const wchar_t* aCalname);
+TInt AddCalendarFile(void* aInterfaceptr, const wchar_t* aCalname);
+TInt AddAnniversary(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+TInt AddDayEvent(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+TInt AddReminder(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+TInt AddTodoEntry(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+TInt AddAppointmentWithoutRepeat(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+TInt AddAppointmentWithDailyRepeat(void* aInterfaceptr, const wchar_t* aCalname, TUIDSet*& uids);
+void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );
+void GetGlobalUid( const TDesC& aGlobalUid, TDes8& aOutGlobalUid );
+
+
+wchar_t KCalFileName1[20] = L"C:CalendarFile1";*/
+TInt doAddTest();
+void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );
+TInt AddProvAppointmentDailyRepeatAndAttendees(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);
+TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar);
+TInt AddProvToDo(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvDayEvent(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvAppointmentDailyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvAppointmentWeeklyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvAppointmentMonthlyRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvAppointmentWithoutRepeat(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvAnni(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddProvReminder(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar, TUIDSet*& uidset);
+TInt AddNewCalendar();
+class CTestUpdateSync : public CBase
+{
+public:
+ static CTestUpdateSync* NewL();
+ int UpdateAppointmentEntryL();
+ int UpdateAppointmentEntryWithNewTimeL();
+ int UpdateAppointmentEntryWithNewAttendeesL();
+ int UpdateAppointmentEntryWithNewRepeatL();
+ int UpdateAnniversaryL();
+ int UpdateDayEventL();
+ int UpdateReminderL();
+ int UpdateTodoEntryL();
+ TDesC& GetEntry(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, TPtrC globaluid, const TDesC& calname);
+ CTestUpdateSync();
+ ~CTestUpdateSync();
+
+private:
+ void ConstructL();
+
+
+
+private:
+ CLiwServiceHandler* iServiceHandler;
+ TInt iResult;
+ MLiwInterface* interface ;
+};
+
+
+CTestUpdateSync* CTestUpdateSync::NewL()
+ {
+ CTestUpdateSync* self = new (ELeave) CTestUpdateSync();
+ self->ConstructL();
+ return self;
+ }
+
+CTestUpdateSync::~CTestUpdateSync()
+ {
+ if( interface )
+ interface->Close();
+
+ delete iServiceHandler;
+ }
+
+
+void CTestUpdateSync::ConstructL()
+ {
+ }
+
+
+CTestUpdateSync::CTestUpdateSync()
+ {
+ interface = NULL ;
+ }
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CTCalendarUpdateTest::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void CTCalendarUpdateTest::Delete()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// CTChangeStatusTest::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt CTCalendarUpdateTest::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ //TRY( "SendMessage", CTDeleteMessageTest::SendMessage ),
+ ENTRY( "UpdateAppointmentEntry", CTCalendarUpdateTest::UpdateAppointmentEntryL),
+ ENTRY( "UpdateAppointmentEntryWithNewTime", CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL ),
+ ENTRY( "UpdateAppointmentEntryWithNewAttendees", CTCalendarUpdateTest::UpdateAppointmentEntryWithNewAttendeesL),
+ ENTRY( "UpdateAppointmentEntryWithNewRepeat", CTCalendarUpdateTest::UpdateAppointmentEntryWithNewRepeatL),
+ ENTRY( "UpdateAnniversary", CTCalendarUpdateTest::UpdateAnniversaryL),
+ ENTRY( "UpdateDayEvent", CTCalendarUpdateTest::UpdateDayEventL),
+ ENTRY( "UpdateReminder", CTCalendarUpdateTest::UpdateReminderL),
+ ENTRY( "UpdateTodoEntry", CTCalendarUpdateTest::UpdateTodoEntryL),
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTCalendarUpdateTest::ImportAsync
+// Test Method to test the ImportAsync(ASynchronous)
+// Functionality of CalenderService
+// -----------------------------------------------------------------------------
+//
+TInt CTCalendarUpdateTest::UpdateAppointmentEntryL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateAppointmentEntryL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateAppointmentEntryWithNewTimeL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTCalendarUpdateTest::UpdateAppointmentEntryWithNewAttendeesL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateAppointmentEntryWithNewAttendeesL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+
+TInt CTCalendarUpdateTest::UpdateAnniversaryL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateAnniversaryL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTCalendarUpdateTest::UpdateDayEventL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateDayEventL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTCalendarUpdateTest::UpdateReminderL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateReminderL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+TInt CTCalendarUpdateTest::UpdateTodoEntryL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateReminderL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTCalendarUpdateTest::UpdateAppointmentEntryWithNewRepeatL(CStifItemParser& /*aItem*/)
+ {
+ //__UHEAP_MARK;
+
+ TInt result=KErrNone;
+
+ __UHEAP_MARK;
+ CTestUpdateSync* test = CTestUpdateSync::NewL();
+ int res = test->UpdateAppointmentEntryWithNewRepeatL();
+ delete test;
+ __UHEAP_MARKEND;
+ return res;
+
+
+// __UHEAP_MARKEND;
+ return result;
+ }
+
+TInt CTestUpdateSync::UpdateAppointmentEntryL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvAppointmentWithoutRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,0,0,0))));
+ map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,30,0,0))));
+ map1->InsertL(_L8("AlarmTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,9,30,0,0))));
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EOctober,3,10,0,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ if(res->FindL(_L8("EndTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EOctober,3,10,30,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+
+TInt CTestUpdateSync::UpdateAppointmentEntryWithNewTimeL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvAppointmentDailyRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,14,30,0,0))));
+ map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,15,30,0,0))));
+ map1->InsertL(_L8("InstanceStartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,10,0,0,0))));
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ TBuf<50> uidg;
+ uidg.Copy(uidval);
+ local = GetEntry( inparam, outparam, uidg, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EOctober,25,14,30,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ if(res->FindL(_L8("EndTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EOctober,25,15,30,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+
+TInt CTestUpdateSync::UpdateAppointmentEntryWithNewAttendeesL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvAppointmentDailyRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,23,14,30,0,0))));
+ map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,23,15,30,0,0))));
+ map1->InsertL(_L8("InstanceStartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,10,0,0,0))));
+
+ CLiwDefaultList* attlist = CLiwDefaultList::NewL();
+ CleanupStack::PushL(attlist);
+
+ CLiwDefaultMap* attmap = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(attmap);
+ attmap->InsertL(_L8("CommonName"), TLiwVariant(_L("sapi")));
+ attmap->InsertL(_L8("Address"), TLiwVariant(_L("h2s@nokia.com")));
+ attlist->AppendL( TLiwVariant(attmap));
+ CleanupStack::Pop(attmap);
+ attmap->DecRef();
+ map1->InsertL(_L8("Attendees"), TLiwVariant(attlist));
+ map1->InsertL(_L8("PhoneOwner"), TLiwVariant(_L("h2s@nokia.com")));
+ CLiwDefaultMap* orgmap = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(orgmap);
+ orgmap->InsertL(_L8("CommonName"), TLiwVariant(_L("sapi")));
+ orgmap->InsertL(_L8("Address"), TLiwVariant(_L("mdc@nokia.com")));
+ map1->InsertL(_L8("Organizer"), TLiwVariant(orgmap));
+ CleanupStack::Pop(orgmap);
+ orgmap->DecRef();
+
+ CleanupStack::Pop(attlist);
+ attlist->DecRef();
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ local = GetEntry( inparam, outparam, uidval, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("Organizer"), data))
+ {
+ const CLiwMap* map = data.AsMap();
+ TLiwVariant rdata;
+ if(map->FindL(_L8("CommonName"), rdata))
+ {
+ TPtrC cn = rdata.AsDes();
+ if( cn.CompareF(_L("sapi")) != 0 )
+ {
+ retvalue = KErrGeneral;
+ rdata.Reset();
+ break;
+ }
+ }
+ if(map->FindL(_L8("Address"), rdata))
+ {
+ TPtrC add = rdata.AsDes();
+ if( add.CompareF(_L("mdc@nokia.com")) != 0 )
+ {
+ retvalue = KErrGeneral;
+ rdata.Reset();
+ break;
+ }
+ }
+ rdata.Reset();
+ }
+
+ if(res->FindL(_L8("PhoneOwner"), data))
+ {
+ TPtrC rep = data.AsDes();
+ if(rep.CompareF(_L("h2s@nokia.com")) != 0 )
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ if(res->FindL(_L8("Attendees"), data))
+ {
+ const CLiwList* list = data.AsList();
+ if ( list )
+ {
+ TInt count = list->Count();
+ for ( int index = 0; index < count; index++ )
+ {
+ TLiwVariant element;
+ list->AtL(index, element);
+ const CLiwMap* map = element.AsMap();
+ TLiwVariant attParam;
+ if ( map && map->FindL(_L8("Address"), attParam) )
+ {
+ TPtrC address = attParam.AsDes();
+ if( address.CompareF(_L("h2s@nokia.com")) != 0 )
+ {
+ retvalue = KErrGeneral;
+ attParam.Reset();
+ element.Reset();
+ break;
+ }
+ }
+ if ( map->FindL( _L8("CommonName"), attParam ) )
+ {
+ TPtrC cn = attParam.AsDes();
+ if( cn.CompareF(_L("sapi")) != 0 )
+ {
+ retvalue = KErrGeneral;
+ attParam.Reset();
+ element.Reset();
+ break;
+ }
+ }
+ attParam.Reset();
+ element.Reset();
+ }
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+TInt CTestUpdateSync::UpdateAppointmentEntryWithNewRepeatL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvAppointmentDailyRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+
+ CLiwDefaultMap* repeatmap = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(repeatmap);
+ repeatmap->InsertL(_L8("Type"), TLiwVariant(TInt32(3)));
+ //repeatmap->InsertL(_L8("StartDate"), TLiwVariant(TTime(TDateTime(2007,EAugust,23,10,0,0,0))));
+ repeatmap->InsertL(_L8("UntilDate"), TLiwVariant(TTime(TDateTime(2009,EDecember,30,10,0,0,0))));
+
+ CLiwDefaultList* daysofmonthlist = CLiwDefaultList::NewL();
+ CLiwDefaultMap* map3 = CLiwDefaultMap::NewL();
+ map3->InsertL(_L8("Day"), TLiwVariant(TInt32(0)) );
+ map3->InsertL(_L8("WeekNum"), TLiwVariant( TInt32(1)));
+ daysofmonthlist->AppendL(TLiwVariant(map3));
+ map3->DecRef();
+
+ CLiwDefaultMap* map2 = CLiwDefaultMap::NewL();
+ map2->InsertL(_L8("Day"), TLiwVariant(TInt32(2)) );
+ map2->InsertL(_L8("WeekNum"), TLiwVariant( TInt32(3)));
+ daysofmonthlist->AppendL(TLiwVariant(map2));
+ map2->DecRef();
+
+ repeatmap->InsertL(_L8("DaysOfMonth"),TLiwVariant(daysofmonthlist));
+ daysofmonthlist->DecRef();
+
+ map1->InsertL(_L8("RepeatRule"), TLiwVariant(repeatmap));
+ CleanupStack::Pop(repeatmap);
+ repeatmap->DecRef();
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ CleanupStack::Pop(map1);
+ map1->DecRef();
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ TBuf<50> uidg;
+ uidg.Copy( uidval );
+ local = GetEntry( inparam, outparam, uidg, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("RepeatRule"), data))
+ {
+ const CLiwMap* map = data.AsMap();
+ TLiwVariant rdata;
+ if(map->FindL(_L8("Type"), rdata))
+ {
+ TInt type = rdata.AsTInt32();
+ if( type != 3 )
+ {
+ retvalue = KErrGeneral;
+ rdata.Reset();
+ break;
+ }
+ }
+ if(map->FindL(_L8("StartDate"), rdata))
+ {
+ TTime sdate = rdata.AsTTime();
+ TDateTime stime = sdate.DateTime();
+ TTime ostime(TDateTime(2007,ENovember,4,10,0,0,0));
+ if( sdate != ostime)
+ {
+ retvalue = KErrGeneral;
+ rdata.Reset();
+ break;
+ }
+ }
+ rdata.Reset();
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+
+
+TInt CTestUpdateSync::UpdateAnniversaryL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvAnni(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EDecember,28,0,0,0,0))));
+ map1->InsertL(_L8("Replication"), TLiwVariant(_L("Open")));
+ map1->InsertL(_L8("Priority"), TLiwVariant(TInt32(1)));
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ local = GetEntry( inparam, outparam, uidval, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EDecember,28,0,0,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+
+TInt CTestUpdateSync::UpdateTodoEntryL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvToDo(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EAugust,19,0,0,0,0))));
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ local = GetEntry( inparam, outparam, uidval, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EAugust,19,0,0,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+ }
+TInt CTestUpdateSync::UpdateDayEventL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvReminder(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+
+
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EJuly,22,11,30,0,0))));
+ map1->InsertL(_L8("Description"), TLiwVariant(_L("New reminder created")));
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ local = GetEntry( inparam, outparam, uidval, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ //TBuf<10> localuid1;
+ //localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EJuly,22,11,30,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+
+ }
+
+TInt CTestUpdateSync::UpdateReminderL()
+ {
+ iServiceHandler = CLiwServiceHandler::NewL();
+
+ CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());
+ CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());
+
+
+ TInt err;
+ RCriteriaArray interest;
+ CleanupClosePushL(interest);
+
+ CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);
+ crit->SetServiceClass(TUid::Uid(KLiwClassBase));
+ CleanupStack::PushL(crit);
+ interest.AppendL(crit);
+
+ iServiceHandler->AttachL(interest);
+ iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam);
+
+ TInt pos = 0;
+
+ outparam->FindFirst( pos, KTestInterface );
+ if(pos != KErrNotFound)
+ {
+ interface = (*outparam)[pos].Value().AsInterface();
+ }
+ CleanupStack::PopAndDestroy(crit);
+ CleanupStack::PopAndDestroy(&interest);
+
+ outparam->Reset();
+ inparam->Reset();
+
+ AddProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ TUIDSet* uidset1;
+ TBuf<50> globaluid;
+ TBuf<10> localuid;
+ //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );
+ AddProvDayEvent(inparam, outparam, interface, KKCalFileName11 ,uidset1);
+ //localuid.Num(TInt64(uidset1->iLocalUID));
+ globaluid.Copy(uidset1->iGlobalUID->Des());
+ localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);
+
+ CLiwDefaultMap* map1 = CLiwDefaultMap::NewL();
+ CleanupStack::PushL(map1);
+
+ TLiwVariant content(_L("CalendarEntry"));
+ TLiwGenericParam element1;
+ element1.SetNameAndValueL(_L8("Type"),content);
+ inparam->AppendL(element1);
+ content.Reset();
+ element1.Reset();
+
+
+ map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) );
+ map1->InsertL(_L8("LocalId"),TLiwVariant(localuid));
+ map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EJuly,26,8,0,0,0))));
+ map1->InsertL(_L8("Replication"), TLiwVariant(_L("Open")));
+
+ TLiwGenericParam element;
+ element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));
+
+ inparam->AppendL(element);
+ element.Reset();
+ map1->DecRef();
+ CleanupStack::Pop(map1);
+
+ TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));
+ TInt pos1 = 0 ;
+
+ const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));
+ TBuf<10> local;
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if ( err == KErrNone )
+ {
+ output = outparam->FindFirst( pos1,_L8("ReturnValue"));
+ if(output)
+ {
+ TPtrC uidval = (TPtrC)(output->Value().AsDes());
+ local = GetEntry( inparam, outparam, uidval, KKCalFileName11);
+ }
+ else
+ err = -1;
+ }
+ }
+ // TBuf<10> localuid1;
+ // localuid1.Num(TInt64(local));
+
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));
+ filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));
+
+ TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+
+ pos = 0 ;
+
+ const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));
+ TInt count = 0;
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+ if ( finaloutput )
+ {
+ CLiwIterable* iterlist = finaloutput->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("StartTime"), data))
+ {
+ TTime ostime(TDateTime(2007,EJuly,26,8,0,0,0));
+ TTime stime = data.AsTTime();
+ if( ostime != stime)
+ {
+ retvalue = KErrGeneral;
+ break;
+ }
+ }
+
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+ delete uidset1;
+ RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);
+ return retvalue;
+
+ }
+
+TDesC& CTestUpdateSync::GetEntry(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, TPtrC globaluid, const TDesC& calname)
+ {
+ inparam->Reset();
+ outparam->Reset();
+
+ TLiwGenericParam dsNameParam(KContentType, TLiwVariant(_L("CalendarEntry")));
+ inparam->AppendL(dsNameParam);
+
+ CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();
+ TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));
+ inparam->AppendL(filterParam);
+ filterMap->DecRef();
+
+ if(calname.Length())
+ filterMap->InsertL(KCalendarName,TLiwVariant(calname));
+ filterMap->InsertL(_L8("id"),TLiwVariant(globaluid));
+
+ TRAPD(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));
+ TInt pos = 0 ;
+ TBuf<10> result;
+ const TLiwGenericParam* output = outparam->FindFirst( pos,_L8("ErrorCode"));
+
+ if(output)
+ {
+ err = output->Value().AsTInt32();
+ if( err == KErrNone )
+ {
+ pos = 0;
+ output = outparam->FindFirst( pos,_L8("ReturnValue"));
+ CLiwMap* map;
+ TInt retvalue = KErrNone;
+
+ if ( output )
+ {
+ CLiwIterable* iterlist = output->Value().AsIterable();
+ if(iterlist)
+ {
+ TLiwVariant data1;
+ while(iterlist->NextL(data1) )
+ {
+ result.Zero();
+ const CLiwMap* res = data1.AsMap();
+ if ( res )
+ {
+ TLiwVariant data;
+ if(res->FindL(_L8("LocalId"), data))
+ result.Copy( data.AsDes() );
+ data.Reset();
+ }
+ }
+ data1.Reset();
+ }
+ }
+ }
+ }
+
+ inparam->Reset();
+ outparam->Reset();
+
+ return result;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CTCalendarUpdateTest::ICALImportAsync
+// Test Method to test the ICALImportAsync(ASynchronous)
+// Functionality of CalenderService
+// -----------------------------------------------------------------------------
+//
+
+
+
+
+