166 // CTCalendarUpdateTest::ImportAsync

   180 // CTCalendarUpdateTest::UpdateAppointmentEntryL

   167 // Test Method to test the ImportAsync(ASynchronous)

   181 // Test Method to test the UpdateAsync(ASynchronous)

   314     

   328 TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithGlobalIdL(CStifItemParser& /*aItem*/)

   329     {

   330     //__UHEAP_MARK;

   331     

   332     TInt result=KErrNone;

   333     

   334     __UHEAP_MARK;

   335     CTestUpdateSync* test = CTestUpdateSync::NewL();

   336     int res =  test->UpdateAppointmentEntryWithGlobalIdL();

   337     delete test;

   338     __UHEAP_MARKEND;

   339     return res;

   340     

   341     

   342 //  __UHEAP_MARKEND;

   343     return result;

   344     }

   345 

   346 TInt  CTCalendarUpdateTest::UpdateAnniversaryWithGlobalIdL(CStifItemParser& /*aItem*/)

   347     {

   348     //__UHEAP_MARK;

   349     

   350     TInt result=KErrNone;

   351     

   352     __UHEAP_MARK;

   353     CTestUpdateSync* test = CTestUpdateSync::NewL();

   354     int res =  test->UpdateAnniversaryWithGlobalIdL();

   355     delete test;

   356     __UHEAP_MARKEND;

   357     return res;

   358     

   359     

   360 //  __UHEAP_MARKEND;

   361     return result;

   362     }

   363     

   364 TInt  CTCalendarUpdateTest::UpdateDayEventWithGlobalIdL(CStifItemParser& /*aItem*/)

   365     {

   366     //__UHEAP_MARK;

   367     

   368     TInt result=KErrNone;

   369     

   370     __UHEAP_MARK;

   371     CTestUpdateSync* test = CTestUpdateSync::NewL();

   372     int res =  test->UpdateDayEventWithGlobalIdL();

   373     delete test;

   374     __UHEAP_MARKEND;

   375     return res;

   376     

   377     

   378 //  __UHEAP_MARKEND;

   379     return result;

   380     }

   381     

   382 TInt  CTCalendarUpdateTest::UpdateReminderWithGlobalIdL(CStifItemParser& /*aItem*/)

   383     {

   384     //__UHEAP_MARK;

   385     

   386     TInt result=KErrNone;

   387     

   388     __UHEAP_MARK;

   389     CTestUpdateSync* test = CTestUpdateSync::NewL();

   390     int res =  test->UpdateReminderWithGlobalIdL();

   391     delete test;

   392     __UHEAP_MARKEND;

   393     return res;

   394     

   395     

   396 //  __UHEAP_MARKEND;

   397     return result;

   398     }   

   399 TInt  CTCalendarUpdateTest::UpdateTodoEntryWithGlobalIdL(CStifItemParser& /*aItem*/)

   400     {

   401     //__UHEAP_MARK;

   402     

   403     TInt result=KErrNone;

   404     

   405     __UHEAP_MARK;

   406     CTestUpdateSync* test = CTestUpdateSync::NewL();

   407     int res =  test->UpdateReminderWithGlobalIdL();

   408     delete test;

   409     __UHEAP_MARKEND;

   410     return res;

   411     

   412     

   413 //  __UHEAP_MARKEND;

   414     return result;

   415     }   

   416 TInt  CTCalendarUpdateTest::UpdateAppointmentEntryWithNewTimeAndGlobalIdL(CStifItemParser& /*aItem*/)

   417     {

   418     //__UHEAP_MARK;

   419     

   420     TInt result=KErrNone;

   421     

   422     __UHEAP_MARK;

   423     CTestUpdateSync* test = CTestUpdateSync::NewL();

   424     int res =  test->UpdateAppointmentEntryWithNewTimeAndGlobalIdL();

   425     delete test;

   426     __UHEAP_MARKEND;

   427     return res;

   428     

   429     

   430 //  __UHEAP_MARKEND;

   431     return result;

   432     }

   433 

  1641            

  1760  

  1761 TInt CTestUpdateSync::UpdateAppointmentEntryWithGlobalIdL()

  1762     {

  1763     iServiceHandler = CLiwServiceHandler::NewL();

  1764 

  1765     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  1766     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  1767 

  1768 

  1769     TInt err; 

  1770     RCriteriaArray interest;

  1771     CleanupClosePushL(interest);

  1772     

  1773     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  1775     CleanupStack::PushL(crit);

  1776     interest.AppendL(crit);    

  1777     

  1778     iServiceHandler->AttachL(interest);

  1779     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  1780 

  1781     TInt pos = 0;

  1782 

  1783     outparam->FindFirst( pos, KTestInterface );

  1784     if(pos != KErrNotFound)

  1785         {

  1786         interface = (*outparam)[pos].Value().AsInterface(); 

  1787         }

  1788     CleanupStack::PopAndDestroy(crit);

  1789     CleanupStack::PopAndDestroy(&interest); 

  1790 

  1791     outparam->Reset();

  1792     inparam->Reset();

  1793     

  1794     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  1795     TUIDSet* uidset1;

  1796     TBuf<50> globaluid;

  1797     TBuf<10> localuid;

  1798     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  1799     AddProvAppointmentWithoutRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  1800     //localuid.Num(TInt64(uidset1->iLocalUID));

  1801     globaluid.Copy(uidset1->iGlobalUID->Des());

  1802     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);

  1803     

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

  1805     CleanupStack::PushL(map1);

  1806 

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

  1808     TLiwGenericParam element1;  

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

  1810     inparam->AppendL(element1);

  1811     content.Reset();

  1812     element1.Reset();

  1813 

  1814 

  1815     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  1816     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  1817     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,0,0,0))));

  1818     map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,10,30,0,0))));

  1819     map1->InsertL(_L8("AlarmTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,3,9,30,0,0))));

  1820     TLiwGenericParam element;   

  1821     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  1822     

  1823     inparam->AppendL(element);

  1824     element.Reset();

  1825     map1->DecRef();

  1826     CleanupStack::Pop(map1);

  1827 

  1828     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  1829 

  1830     inparam->Reset();

  1831     outparam->Reset();

  1832     

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

  1834     inparam->AppendL(dsNameParam);

  1835     

  1836     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  1837     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  1838     inparam->AppendL(filterParam);

  1839     filterMap->DecRef();

  1840 

  1841     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  1842     filterMap->InsertL(_L8("LocalId"),TLiwVariant(localuid));

  1843 

  1844     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  1845     

  1846     pos = 0 ;

  1847     

  1848     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  1849     TInt count = 0;

  1850     CLiwMap* map;

  1851     TInt retvalue = KErrNone;

  1852     if ( finaloutput )     

  1853         {

  1854         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  1855         if(iterlist)

  1856             {

  1857             TLiwVariant data1;

  1858             while(iterlist->NextL(data1) )

  1859                 {

  1860                 const CLiwMap* res = data1.AsMap();

  1861                 if ( res )

  1862                     {

  1863                     TLiwVariant data;

  1864                     if(res->FindL(_L8("StartTime"), data))

  1865                         {

  1866                         TTime ostime(TDateTime(2007,EOctober,3,10,0,0,0));

  1867                         TTime stime = data.AsTTime();

  1868                         if( ostime != stime)

  1869                             {

  1870                             retvalue = KErrGeneral;

  1871                             break;

  1872                             }

  1873                         }

  1874 

  1875                     if(res->FindL(_L8("EndTime"), data))

  1876                         {

  1877                         TTime ostime(TDateTime(2007,EOctober,3,10,30,0,0));

  1878                         TTime stime = data.AsTTime();

  1879                         if( ostime != stime)

  1880                             {

  1881                             retvalue = KErrGeneral;

  1882                             break;

  1883                             }

  1884                         }

  1885 

  1886                     data.Reset();   

  1887                     }

  1888                 }

  1889             data1.Reset();  

  1890             }

  1891         }

  1892     

  1893     inparam->Reset();

  1894     outparam->Reset();

  1895     delete uidset1;

  1896     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  1897     return retvalue;

  1898     }

  1899 TInt CTestUpdateSync::UpdateAnniversaryWithGlobalIdL()

  1900     {

  1901     iServiceHandler = CLiwServiceHandler::NewL();

  1902 

  1903     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  1904     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  1905 

  1906 

  1907     TInt err; 

  1908     RCriteriaArray interest;

  1909     CleanupClosePushL(interest);

  1910     

  1911     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  1913     CleanupStack::PushL(crit);

  1914     interest.AppendL(crit);    

  1915     

  1916     iServiceHandler->AttachL(interest);

  1917     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  1918 

  1919     TInt pos = 0;

  1920 

  1921     outparam->FindFirst( pos, KTestInterface );

  1922     if(pos != KErrNotFound)

  1923         {

  1924         interface = (*outparam)[pos].Value().AsInterface(); 

  1925         }

  1926     CleanupStack::PopAndDestroy(crit);

  1927     CleanupStack::PopAndDestroy(&interest); 

  1928 

  1929     outparam->Reset();

  1930     inparam->Reset();

  1931     

  1932     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  1933     TUIDSet* uidset1;

  1934     TBuf<50> globaluid;

  1935     TBuf<10> localuid;

  1936     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  1937     AddProvAnni(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  1938     //localuid.Num(TInt64(uidset1->iLocalUID));

  1939     globaluid.Copy(uidset1->iGlobalUID->Des());

  1940     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11); 

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

  1942     CleanupStack::PushL(map1);

  1943 

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

  1945     TLiwGenericParam element1;  

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

  1947     inparam->AppendL(element1);

  1948     content.Reset();

  1949     element1.Reset();

  1950 

  1951 

  1952     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  1953     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  1954     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EDecember,28,0,0,0,0))));

  1955     map1->InsertL(_L8("Replication"), TLiwVariant(_L("Open")));

  1956     map1->InsertL(_L8("Priority"), TLiwVariant(TInt32(1)));

  1957     

  1958     TLiwGenericParam element;   

  1959     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  1960     

  1961     inparam->AppendL(element);

  1962     element.Reset();

  1963     map1->DecRef();

  1964     CleanupStack::Pop(map1);

  1965 

  1966     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  1967     TInt pos1 = 0 ;

  1968     

  1969     const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));

  1970     TBuf<10> local;

  1971     if(output)

  1972         {

  1973         err = output->Value().AsTInt32();

  1974         if ( err == KErrNone )

  1975             {

  1976             output = outparam->FindFirst( pos1,_L8("ReturnValue"));

  1977             if(output)

  1978                 {

  1979                 TPtrC uidval = (TPtrC)(output->Value().AsDes());

  1980                 local = GetEntry( inparam, outparam, uidval, KKCalFileName11);    

  1981                 }

  1982             else

  1983                 err = -1;

  1984             }

  1985         }

  1986     //TBuf<10> localuid1;

  1987     //localuid1.Num(TInt64(local));

  1988     

  1989     inparam->Reset();

  1990     outparam->Reset();

  1991     

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

  1993     inparam->AppendL(dsNameParam);

  1994     

  1995     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  1996     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  1997     inparam->AppendL(filterParam);

  1998     filterMap->DecRef();

  1999 

  2000     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  2001     filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));

  2002 

  2003     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  2004     

  2005     pos = 0 ;

  2006     

  2007     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  2008     TInt count = 0;

  2009     CLiwMap* map;

  2010     TInt retvalue = KErrNone;

  2011     if ( finaloutput )     

  2012         {

  2013         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  2014         if(iterlist)

  2015             {

  2016             TLiwVariant data1;

  2017             while(iterlist->NextL(data1) )

  2018                 {

  2019                 const CLiwMap* res = data1.AsMap();

  2020                 if ( res )

  2021                     {

  2022                     TLiwVariant data;

  2023                     if(res->FindL(_L8("StartTime"), data))

  2024                         {

  2025                         TTime ostime(TDateTime(2007,EDecember,28,0,0,0,0));

  2026                         TTime stime = data.AsTTime();

  2027                         if( ostime != stime)

  2028                             {

  2029                             retvalue = KErrGeneral;

  2030                             break;

  2031                             }

  2032                         }

  2033                         

  2034                     data.Reset();   

  2035                     }

  2036                 }

  2037             data1.Reset();  

  2038             }

  2039         }

  2040     

  2041     inparam->Reset();

  2042     outparam->Reset();

  2043     delete uidset1;

  2044     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2045     return retvalue;

  2046     }

  2047 

  2048 TInt CTestUpdateSync::UpdateTodoEntryWithGlobalIdL()

  2049     {

  2050     iServiceHandler = CLiwServiceHandler::NewL();

  2051 

  2052     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  2053     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  2054 

  2055 

  2056     TInt err; 

  2057     RCriteriaArray interest;

  2058     CleanupClosePushL(interest);

  2059     

  2060     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  2062     CleanupStack::PushL(crit);

  2063     interest.AppendL(crit);    

  2064     

  2065     iServiceHandler->AttachL(interest);

  2066     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  2067 

  2068     TInt pos = 0;

  2069 

  2070     outparam->FindFirst( pos, KTestInterface );

  2071     if(pos != KErrNotFound)

  2072         {

  2073         interface = (*outparam)[pos].Value().AsInterface(); 

  2074         }

  2075     CleanupStack::PopAndDestroy(crit);

  2076     CleanupStack::PopAndDestroy(&interest); 

  2077 

  2078     outparam->Reset();

  2079     inparam->Reset();

  2080     

  2081     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2082     TUIDSet* uidset1;

  2083     TBuf<50> globaluid;

  2084     TBuf<10> localuid;

  2085     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  2086     AddProvToDo(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  2087     //localuid.Num(TInt64(uidset1->iLocalUID));

  2088     globaluid.Copy(uidset1->iGlobalUID->Des());

  2089     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11); 

  2090     

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

  2092     CleanupStack::PushL(map1);

  2093 

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

  2095     TLiwGenericParam element1;  

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

  2097     inparam->AppendL(element1);

  2098     content.Reset();

  2099     element1.Reset();

  2100 

  2101 

  2102     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  2103     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  2104     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EAugust,19,0,0,0,0))));

  2105     

  2106     TLiwGenericParam element;   

  2107     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  2108     

  2109     inparam->AppendL(element);

  2110     element.Reset();

  2111     map1->DecRef();

  2112     CleanupStack::Pop(map1);

  2113 

  2114     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  2115     TInt pos1 = 0 ;

  2116     

  2117     const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));

  2118     TBuf<10> local;

  2119     if(output)

  2120         {

  2121         err = output->Value().AsTInt32();

  2122         if ( err == KErrNone )

  2123             {

  2124             output = outparam->FindFirst( pos1,_L8("ReturnValue"));

  2125             if(output)

  2126                 {

  2127                 TPtrC uidval = (TPtrC)(output->Value().AsDes());

  2128                 local = GetEntry( inparam, outparam, uidval, KKCalFileName11);    

  2129                 }

  2130             else

  2131                 err = -1;

  2132             }

  2133         }

  2134     //TBuf<10> localuid1;

  2135     //localuid1.Num(TInt64(local));

  2136     

  2137     inparam->Reset();

  2138     outparam->Reset();

  2139     

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

  2141     inparam->AppendL(dsNameParam);

  2142     

  2143     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  2144     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  2145     inparam->AppendL(filterParam);

  2146     filterMap->DecRef();

  2147 

  2148     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  2149     filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));

  2150 

  2151     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  2152     

  2153     pos = 0 ;

  2154     

  2155     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  2156     TInt count = 0;

  2157     CLiwMap* map;

  2158     TInt retvalue = KErrNone;

  2159     if ( finaloutput )     

  2160         {

  2161         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  2162         if(iterlist)

  2163             {

  2164             TLiwVariant data1;

  2165             while(iterlist->NextL(data1) )

  2166                 {

  2167                 const CLiwMap* res = data1.AsMap();

  2168                 if ( res )

  2169                     {

  2170                     TLiwVariant data;

  2171                     if(res->FindL(_L8("StartTime"), data))

  2172                         {

  2173                         TTime ostime(TDateTime(2007,EAugust,19,0,0,0,0));

  2174                         TTime stime = data.AsTTime();

  2175                         if( ostime != stime)

  2176                             {

  2177                             retvalue = KErrGeneral;

  2178                             break;

  2179                             }

  2180                         }

  2181                         

  2182                     data.Reset();   

  2183                     }

  2184                 }

  2185             data1.Reset();  

  2186             }

  2187         }

  2188     

  2189     inparam->Reset();

  2190     outparam->Reset();

  2191     delete uidset1;

  2192     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2193     return retvalue;

  2194     }

  2195 TInt CTestUpdateSync::UpdateDayEventWithGlobalIdL()

  2196     {

  2197     iServiceHandler = CLiwServiceHandler::NewL();

  2198 

  2199     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  2200     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  2201 

  2202 

  2203     TInt err; 

  2204     RCriteriaArray interest;

  2205     CleanupClosePushL(interest);

  2206     

  2207     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  2209     CleanupStack::PushL(crit);

  2210     interest.AppendL(crit);    

  2211     

  2212     iServiceHandler->AttachL(interest);

  2213     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  2214 

  2215     TInt pos = 0;

  2216 

  2217     outparam->FindFirst( pos, KTestInterface );

  2218     if(pos != KErrNotFound)

  2219         {

  2220         interface = (*outparam)[pos].Value().AsInterface(); 

  2221         }

  2222     CleanupStack::PopAndDestroy(crit);

  2223     CleanupStack::PopAndDestroy(&interest); 

  2224 

  2225     outparam->Reset();

  2226     inparam->Reset();

  2227     

  2228     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2229     TUIDSet* uidset1;

  2230     TBuf<50> globaluid;

  2231     TBuf<10> localuid;

  2232     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  2233     AddProvReminder(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  2234     //localuid.Num(TInt64(uidset1->iLocalUID));

  2235     globaluid.Copy(uidset1->iGlobalUID->Des());

  2236     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);    

  2237 

  2238     

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

  2240     CleanupStack::PushL(map1);

  2241 

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

  2243     TLiwGenericParam element1;  

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

  2245     inparam->AppendL(element1);

  2246     content.Reset();

  2247     element1.Reset();

  2248 

  2249 

  2250     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  2251     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  2252     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EJuly,22,11,30,0,0))));

  2253     map1->InsertL(_L8("Description"), TLiwVariant(_L("New reminder created")));

  2254     

  2255     TLiwGenericParam element;   

  2256     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  2257     

  2258     inparam->AppendL(element);

  2259     element.Reset();

  2260     map1->DecRef();

  2261     CleanupStack::Pop(map1);

  2262 

  2263     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  2264     TInt pos1 = 0 ;

  2265     

  2266     const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));

  2267     TBuf<10> local;

  2268     if(output)

  2269         {

  2270         err = output->Value().AsTInt32();

  2271         if ( err == KErrNone )

  2272             {

  2273             output = outparam->FindFirst( pos1,_L8("ReturnValue"));

  2274             if(output)

  2275                 {

  2276                 TPtrC uidval = (TPtrC)(output->Value().AsDes());

  2277                 local = GetEntry( inparam, outparam, uidval, KKCalFileName11);    

  2278                 }

  2279             else

  2280                 err = -1;

  2281             }

  2282         }

  2283     //TBuf<10> localuid1;

  2284     //localuid1.Num(TInt64(local));

  2285     

  2286     inparam->Reset();

  2287     outparam->Reset();

  2288     

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

  2290     inparam->AppendL(dsNameParam);

  2291     

  2292     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  2293     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  2294     inparam->AppendL(filterParam);

  2295     filterMap->DecRef();

  2296 

  2297     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  2298     filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));

  2299 

  2300     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  2301     

  2302     pos = 0 ;

  2303     

  2304     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  2305     TInt count = 0;

  2306     CLiwMap* map;

  2307     TInt retvalue = KErrNone;

  2308     if ( finaloutput )     

  2309         {

  2310         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  2311         if(iterlist)

  2312             {

  2313             TLiwVariant data1;

  2314             while(iterlist->NextL(data1) )

  2315                 {

  2316                 const CLiwMap* res = data1.AsMap();

  2317                 if ( res )

  2318                     {

  2319                     TLiwVariant data;

  2320                     if(res->FindL(_L8("StartTime"), data))

  2321                         {

  2322                         TTime ostime(TDateTime(2007,EJuly,22,11,30,0,0));

  2323                         TTime stime = data.AsTTime();

  2324                         if( ostime != stime)

  2325                             {

  2326                             retvalue = KErrGeneral;

  2327                             break;

  2328                             }

  2329                         }

  2330                         

  2331                     data.Reset();   

  2332                     }

  2333                 }

  2334             data1.Reset();  

  2335             }

  2336         }

  2337     

  2338     inparam->Reset();

  2339     outparam->Reset();

  2340     delete uidset1;

  2341     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2342     return retvalue;

  2343 

  2344     }

  2345 

  2346 TInt CTestUpdateSync::UpdateReminderWithGlobalIdL()  

  2347     {

  2348     iServiceHandler = CLiwServiceHandler::NewL();

  2349 

  2350     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  2351     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  2352 

  2353 

  2354     TInt err; 

  2355     RCriteriaArray interest;

  2356     CleanupClosePushL(interest);

  2357     

  2358     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  2360     CleanupStack::PushL(crit);

  2361     interest.AppendL(crit);    

  2362     

  2363     iServiceHandler->AttachL(interest);

  2364     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  2365 

  2366     TInt pos = 0;

  2367 

  2368     outparam->FindFirst( pos, KTestInterface );

  2369     if(pos != KErrNotFound)

  2370         {

  2371         interface = (*outparam)[pos].Value().AsInterface(); 

  2372         }

  2373     CleanupStack::PopAndDestroy(crit);

  2374     CleanupStack::PopAndDestroy(&interest); 

  2375 

  2376     outparam->Reset();

  2377     inparam->Reset();

  2378     

  2379     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2380     TUIDSet* uidset1;

  2381     TBuf<50> globaluid;

  2382     TBuf<10> localuid;

  2383     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  2384     AddProvDayEvent(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  2385     //localuid.Num(TInt64(uidset1->iLocalUID));

  2386     globaluid.Copy(uidset1->iGlobalUID->Des());

  2387     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11); 

  2388     

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

  2390     CleanupStack::PushL(map1);

  2391 

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

  2393     TLiwGenericParam element1;  

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

  2395     inparam->AppendL(element1);

  2396     content.Reset();

  2397     element1.Reset();

  2398 

  2399 

  2400     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  2401     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  2402     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EJuly,26,8,0,0,0))));

  2403     map1->InsertL(_L8("Replication"), TLiwVariant(_L("Open")));

  2404     

  2405     TLiwGenericParam element;   

  2406     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  2407     

  2408     inparam->AppendL(element);

  2409     element.Reset();

  2410     map1->DecRef();

  2411     CleanupStack::Pop(map1);

  2412 

  2413     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  2414     TInt pos1 = 0 ;

  2415     

  2416     const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));

  2417     TBuf<10> local;

  2418     if(output)

  2419         {

  2420         err = output->Value().AsTInt32();

  2421         if ( err == KErrNone )

  2422             {

  2423             output = outparam->FindFirst( pos1,_L8("ReturnValue"));

  2424             if(output)

  2425                 {

  2426                 TPtrC uidval = (TPtrC)(output->Value().AsDes());

  2427                 local = GetEntry( inparam, outparam, uidval, KKCalFileName11);    

  2428                 }

  2429             else

  2430                 err = -1;

  2431             }

  2432         }

  2433    // TBuf<10> localuid1;

  2434    // localuid1.Num(TInt64(local));

  2435     

  2436     inparam->Reset();

  2437     outparam->Reset();

  2438     

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

  2440     inparam->AppendL(dsNameParam);

  2441     

  2442     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  2443     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  2444     inparam->AppendL(filterParam);

  2445     filterMap->DecRef();

  2446 

  2447     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  2448     filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));

  2449 

  2450     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  2451     

  2452     pos = 0 ;

  2453     

  2454     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  2455     TInt count = 0;

  2456     CLiwMap* map;

  2457     TInt retvalue = KErrNone;

  2458     if ( finaloutput )     

  2459         {

  2460         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  2461         if(iterlist)

  2462             {

  2463             TLiwVariant data1;

  2464             while(iterlist->NextL(data1) )

  2465                 {

  2466                 const CLiwMap* res = data1.AsMap();

  2467                 if ( res )

  2468                     {

  2469                     TLiwVariant data;

  2470                     if(res->FindL(_L8("StartTime"), data))

  2471                         {

  2472                         TTime ostime(TDateTime(2007,EJuly,26,8,0,0,0));

  2473                         TTime stime = data.AsTTime();

  2474                         if( ostime != stime)

  2475                             {

  2476                             retvalue = KErrGeneral;

  2477                             break;

  2478                             }

  2479                         }

  2480                         

  2481                     data.Reset();   

  2482                     }

  2483                 }

  2484             data1.Reset();  

  2485             }

  2486         }

  2487     

  2488     inparam->Reset();

  2489     outparam->Reset();

  2490     delete uidset1;

  2491     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2492     return retvalue;

  2493 

  2494     }

  2495 TInt CTestUpdateSync::UpdateAppointmentEntryWithNewTimeAndGlobalIdL()

  2496     {

  2497     iServiceHandler = CLiwServiceHandler::NewL();

  2498 

  2499     CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL());

  2500     CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL());

  2501 

  2502 

  2503     TInt err; 

  2504     RCriteriaArray interest;

  2505     CleanupClosePushL(interest);

  2506     

  2507     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KTestInterface,KTestContent);

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

  2509     CleanupStack::PushL(crit);

  2510     interest.AppendL(crit);    

  2511     

  2512     iServiceHandler->AttachL(interest);

  2513     iServiceHandler->ExecuteServiceCmdL(*crit, *inparam, *outparam); 

  2514 

  2515     TInt pos = 0;

  2516 

  2517     outparam->FindFirst( pos, KTestInterface );

  2518     if(pos != KErrNotFound)

  2519         {

  2520         interface = (*outparam)[pos].Value().AsInterface(); 

  2521         }

  2522     CleanupStack::PopAndDestroy(crit);

  2523     CleanupStack::PopAndDestroy(&interest); 

  2524 

  2525     outparam->Reset();

  2526     inparam->Reset();

  2527     

  2528     AddProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2529     TUIDSet* uidset1;

  2530     TBuf<50> globaluid;

  2531     TBuf<10> localuid;

  2532     //AddProvAppointmentDailyRepeatAndAttendees(inparam, outparam, interface, KKCalFileName11 ,uidset1 );

  2533     AddProvAppointmentDailyRepeat(inparam, outparam, interface, KKCalFileName11 ,uidset1);

  2534     //localuid.Num(TInt64(uidset1->iLocalUID));

  2535     globaluid.Copy(uidset1->iGlobalUID->Des());

  2536     localuid = GetEntry( inparam, outparam, globaluid, KKCalFileName11);    

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

  2538     CleanupStack::PushL(map1);

  2539 

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

  2541     TLiwGenericParam element1;  

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

  2543     inparam->AppendL(element1);

  2544     content.Reset();

  2545     element1.Reset();

  2546 

  2547 

  2548     map1->InsertL(_L8("CalendarName"), TLiwVariant(KKCalFileName11) ); 

  2549     map1->InsertL(_L8("id"),TLiwVariant(globaluid));

  2550     map1->InsertL(_L8("StartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,14,30,0,0))));

  2551     map1->InsertL(_L8("EndTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,15,30,0,0))));

  2552     map1->InsertL(_L8("InstanceStartTime"), TLiwVariant(TTime(TDateTime(2007,EOctober,25,10,0,0,0))));

  2553     

  2554     TLiwGenericParam element;   

  2555     element.SetNameAndValueL(_L8("Item"),TLiwVariant(map1));

  2556     

  2557     inparam->AppendL(element);

  2558     element.Reset();

  2559     map1->DecRef();

  2560     CleanupStack::Pop(map1);

  2561 

  2562     TRAPD(err1, interface->ExecuteCmdL( KCmdAdd, *inparam,*outparam ));

  2563     TInt pos1 = 0 ;

  2564     

  2565     const TLiwGenericParam* output = outparam->FindFirst( pos1,_L8("ErrorCode"));

  2566     TBuf<10> local;

  2567     if(output)

  2568         {

  2569         err = output->Value().AsTInt32();

  2570         if ( err == KErrNone )

  2571             {

  2572             output = outparam->FindFirst( pos1,_L8("ReturnValue"));

  2573             if(output)

  2574                 {

  2575                 TPtrC uidval = (TPtrC)(output->Value().AsDes());

  2576                 TBuf<50> uidg;

  2577                 uidg.Copy(uidval);

  2578                 local = GetEntry( inparam, outparam, uidg, KKCalFileName11);    

  2579                 }

  2580             else

  2581                 err = -1;

  2582             }

  2583         }

  2584     //TBuf<10> localuid1;

  2585     //localuid1.Num(TInt64(local));

  2586     

  2587     inparam->Reset();

  2588     outparam->Reset();

  2589     

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

  2591     inparam->AppendL(dsNameParam);

  2592     

  2593     CLiwDefaultMap *filterMap = CLiwDefaultMap::NewL();

  2594     TLiwGenericParam filterParam(KFilter, TLiwVariant(filterMap));

  2595     inparam->AppendL(filterParam);

  2596     filterMap->DecRef();

  2597 

  2598     filterMap->InsertL(KCalendarName,TLiwVariant(_L("C:CalendarFileA")));

  2599     filterMap->InsertL(_L8("LocalId"),TLiwVariant(local));

  2600 

  2601     TRAP(err,interface->ExecuteCmdL( _L8("GetList") ,*inparam ,*outparam));

  2602     

  2603     pos = 0 ;

  2604     

  2605     const TLiwGenericParam* finaloutput = outparam->FindFirst( pos,_L8("ReturnValue"));

  2606     TInt count = 0;

  2607     CLiwMap* map;

  2608     TInt retvalue = KErrNone;

  2609     if ( finaloutput )     

  2610         {

  2611         CLiwIterable* iterlist = finaloutput->Value().AsIterable();

  2612         if(iterlist)

  2613             {

  2614             TLiwVariant data1;

  2615             while(iterlist->NextL(data1) )

  2616                 {

  2617                 const CLiwMap* res = data1.AsMap();

  2618                 if ( res )

  2619                     {

  2620                     TLiwVariant data;

  2621                     if(res->FindL(_L8("StartTime"), data))

  2622                         {

  2623                         TTime ostime(TDateTime(2007,EOctober,25,14,30,0,0));

  2624                         TTime stime = data.AsTTime();

  2625                         if( ostime != stime)

  2626                             {

  2627                             retvalue = KErrGeneral;

  2628                             break;

  2629                             }

  2630                         }

  2631 

  2632                     if(res->FindL(_L8("EndTime"), data))

  2633                         {

  2634                         TTime ostime(TDateTime(2007,EOctober,25,15,30,0,0));

  2635                         TTime stime = data.AsTTime();

  2636                         if( ostime != stime)

  2637                             {

  2638                             retvalue = KErrGeneral;

  2639                             break;

  2640                             }

  2641                         }

  2642 

  2643                     data.Reset();   

  2644                     }

  2645                 }

  2646             data1.Reset();  

  2647             }

  2648         }

  2649     

  2650     inparam->Reset();

  2651     outparam->Reset();

  2652     delete uidset1;

  2653     RemoveProvCalendar(inparam, outparam, interface, KKCalFileName11);

  2654     return retvalue;

  2655     }

  2656 

  2657