Mercurial Mercurial > oss > FCL > sf > mw > serviceapi / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
serviceproviders/sapi_calendar/tsrc/dev/tcalendarprovidertest/tcalendargetlistiter3/src/tcalendargetlisttestblocks.cpp
changeset 22 fc9cf246af83
parent 19 989d2f495d90
child 33 50974a8b132e
equal deleted inserted replaced
19:989d2f495d90 22:fc9cf246af83 
    43 
    43 
    44 void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );
 
    44 void GetLocalUid( const TDesC& aLocalUid, TCalLocalUid& aOutLocalUid );
 
    45 void GetGlobalUid( const TDesC& aGlobalUid, TDes8& aOutGlobalUid );
 
    45 void GetGlobalUid( const TDesC& aGlobalUid, TDes8& aOutGlobalUid );
 
    46 TDesC& GetEntry(MLiwInterface* interface, CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, TPtrC globaluid, const TDesC& calname);
 
    46 TDesC& GetEntry(MLiwInterface* interface, CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, TPtrC globaluid, const TDesC& calname);
 
    47 
    47 
       
    48 class CCalGetListCallback : public MLiwNotifyCallback
 
       
    49     {
 
       
    50     public:
 
       
    51         
       
    52         static CCalGetListCallback* NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult );
 
       
    53         
       
    54         virtual ~CCalGetListCallback(){}
 
       
    55         
       
    56         TInt HandleNotifyL(TInt aCmdId,
 
       
    57                 TInt aEventId,
 
       
    58                 CLiwGenericParamList& aEventParamList,
 
       
    59                 const CLiwGenericParamList& aInParamList);
 
       
    60         TInt            iEntryAdded;
 
       
    61         
       
    62     private:
 
       
    63     
       
    64         CCalGetListCallback(CActiveSchedulerWait* aWaitSchedular, TInt& aResult ):iWaitSchedular(aWaitSchedular), iResult(aResult){ }
 
       
    65 
       
    66         CActiveSchedulerWait*   iWaitSchedular;
 
       
    67         TInt&           iResult;
 
       
    68         
       
    69             
       
    70     };
 
       
    71 
       
    72 class CTestAsync : public CActive
 
       
    73 {
 
       
    74 enum TTestCaseType
 
       
    75         {
 
       
    76         KGetlistGuidFilterAsync,
 
       
    77         KGetlistLuidFilterAsync,
 
       
    78         KGetlistTmRgFilterAsync,
 
       
    79         KGetlistTextFilterAsync,
 
       
    80         KGetlistTypeFilterAsync,
 
       
    81         KGetlistInvalidGuidFilterAsync,
 
       
    82         KGetlistInvalidLuidFilterAsync,
 
       
    83         KGetlistGuidFilterCancelAsync,
 
       
    84         KGetlistLuidFilterCancelAsync,
 
       
    85         KGetlistTmRgFilterCancelAsync,
 
       
    86         KGetlistTextFilterCancelAsync,
 
       
    87         KGetlistTypeFilterCancelAsync,
 
       
    88         };
 
       
    89 
       
    90 public:
 
       
    91     static CTestAsync* NewL();
 
       
    92     ~CTestAsync();
 
       
    93     void Start();
 
       
    94 
       
    95     void TestGetlistGuidFilterAsyncL();
 
       
    96     void TestGetlistLuidFilterAsyncL();
 
       
    97     void TestGetlistTmRgFilterAsyncL();
 
       
    98     void TestGetlistTextFilterAsyncL();
 
       
    99     void TestGetlistTypeFilterAsyncL();
 
       
   100     void TestGetlistInvalidGuidFilterAsyncL();
 
       
   101     void TestGetlistInvalidLuidFilterAsyncL();
 
       
   102 
       
   103     void TestGetlistGuidFilterCancelAsyncL();
 
       
   104     void TestGetlistLuidFilterCancelAsyncL();
 
       
   105     void TestGetlistTmRgFilterCancelAsyncL();
 
       
   106     void TestGetlistTextFilterCancelAsyncL();
 
       
   107     void TestGetlistTypeFilterCancelAsyncL();
 
       
   108     
       
   109     void GuidAsyncL();
 
       
   110     void LuidAsyncL();
 
       
   111     void TmRgFilterAsyncL();
 
       
   112     void TextFilterAsyncL();
 
       
   113     void TypeFilterAsyncL();
 
       
   114     void InvalidGuidAsyncL();
 
       
   115     void InvalidLuidAsyncL();
 
       
   116 
       
   117     void GuidCancelAsyncL();
 
       
   118     void LuidCancelAsyncL();
 
       
   119     void TmRgFilterCancelAsyncL();
 
       
   120     void TextFilterCancelAsyncL();
 
       
   121     void TypeFilterCancelAsyncL();
 
       
   122     
       
   123     TInt Result();
 
       
   124     
       
   125 private:
 
       
   126     void ConstructL();
 
       
   127     CTestAsync();
 
       
   128     
       
   129     virtual void DoCancel();
 
       
   130     virtual void RunL();
 
       
   131     
       
   132     void TestFunc();
 
       
   133 
       
   134     
       
   135 private:    
       
   136     CLiwServiceHandler*     iServiceHandler;
 
       
   137     CActiveSchedulerWait*   iWaitSchedular;
 
       
   138     TInt                    iResult;
 
       
   139     TInt                    iEntryAdded;    
       
   140     CCalGetListCallback*    iCallback;
 
       
   141     MLiwInterface*          interface;
 
       
   142     TInt32                  iTransactionId;
 
       
   143     TBool                   iEntryArray;
 
       
   144     TTestCaseType           iTestCaseType;
 
       
   145 };
 
       
   146 
       
   147 _LIT8(KCmdCancel,       "Cancel");
 
    48 _LIT8(KIDataSource, "IDataSource");
 
   148 _LIT8(KIDataSource, "IDataSource");
 
    49 _LIT8(KService, "Service.Calendar");
 
   149 _LIT8(KService, "Service.Calendar");
 
    50 
   150 
    51 _LIT8(KCmdGetList,"GetList");
 
   151 _LIT8(KCmdGetList,"GetList");
 
    52 _LIT8(KCmdDelete,"Delete");
 
   152 _LIT8(KCmdDelete,"Delete");
 
    91         ENTRY( "GetListTextFilter",    	CTCalendarGetListTest::GetListTextFilter ),
 
   191         ENTRY( "GetListTextFilter",    	CTCalendarGetListTest::GetListTextFilter ),
 
    92         ENTRY( "GetListTypeFilter",    	CTCalendarGetListTest::GetListTypeFilter ),
 
   192         ENTRY( "GetListTypeFilter",    	CTCalendarGetListTest::GetListTypeFilter ),
 
    93 		ENTRY( "GetListInvalidCalName", CTCalendarGetListTest::GetListInvalidCalName ),
 
   193 		ENTRY( "GetListInvalidCalName", CTCalendarGetListTest::GetListInvalidCalName ),
 
    94 		ENTRY( "GetListInvalidGUID"   , CTCalendarGetListTest::GetListInvalidGUID ),
 
   194 		ENTRY( "GetListInvalidGUID"   , CTCalendarGetListTest::GetListInvalidGUID ),
 
    95 		ENTRY( "GetListInvalidLUID"   , CTCalendarGetListTest::GetListInvalidLUID ),
 
   195 		ENTRY( "GetListInvalidLUID"   , CTCalendarGetListTest::GetListInvalidLUID ),
 
       
   196 		
       
   197 		ENTRY( "GetListGUidFilterAsync",       CTCalendarGetListTest::GetListGUidFilterAsync ),
 
       
   198         ENTRY( "GetListLocalUidFilterAsync", CTCalendarGetListTest::GetListLocalUidFilterAsync ),
 
       
   199         ENTRY( "GetListTimeRangeFilterAsync",CTCalendarGetListTest::GetListTimeRangeFilterAsync ),
 
       
   200         ENTRY( "GetListTextFilterAsync",     CTCalendarGetListTest::GetListTextFilterAsync ),
 
       
   201         ENTRY( "GetListTypeFilterAsync",     CTCalendarGetListTest::GetListTypeFilterAsync ),
 
       
   202         ENTRY( "GetListInvalidGUidFilterAsync",       CTCalendarGetListTest::GetListInvalidGUidFilterAsync ),
 
       
   203         ENTRY( "GetListInvalidLocalUidFilterAsync", CTCalendarGetListTest::GetListInvalidLocalUidFilterAsync ),
 
       
   204 
       
   205         ENTRY( "GetListGUidFilterCancelAsync",       CTCalendarGetListTest::GetListGUidFilterCancelAsync ),
 
       
   206         ENTRY( "GetListLocalUidFilterCancelAsync", CTCalendarGetListTest::GetListLocalUidFilterCancelAsync ),
 
       
   207         ENTRY( "GetListTimeRangeFilterCancelAsync",CTCalendarGetListTest::GetListTimeRangeFilterCancelAsync ),
 
       
   208         ENTRY( "GetListTextFilterCancelAsync",     CTCalendarGetListTest::GetListTextFilterCancelAsync ),
 
       
   209         ENTRY( "GetListTypeFilterCancelAsync",     CTCalendarGetListTest::GetListTypeFilterCancelAsync ),
 
    96         };
 
   210         };
 
    97 
   211 
    98     const TInt count = sizeof( KFunctions ) / 
   212     const TInt count = sizeof( KFunctions ) / 
    99                         sizeof( TStifFunctionInfo );
 
   213                         sizeof( TStifFunctionInfo );
 
   100 
   214 
  1402     __UHEAP_MARKEND;	
  1516     __UHEAP_MARKEND;	
  1403 
  1517 
  1404 	return result;
 
  1518 	return result;
 
  1405 
  1519 
  1406 	}		
  1520 	}		
  1407 
  1521 //_LIT8(KErrorCode,"ErrorCode");
 
       
  1522 TInt CTCalendarGetListTest::GetListGUidFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1523     {
 
       
  1524     TInt result=KErrNone;     
       
  1525     
       
  1526     __UHEAP_MARK;
 
       
  1527     
       
  1528     CTestAsync* test = CTestAsync::NewL();
 
       
  1529     test->TestGetlistGuidFilterAsyncL();
 
       
  1530     result = test->Result();
 
       
  1531     delete test;
 
       
  1532     
       
  1533     __UHEAP_MARKEND;    
       
  1534 
       
  1535     return result;
 
       
  1536 
       
  1537     }
 
       
  1538 TInt CTCalendarGetListTest::GetListLocalUidFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1539     {
 
       
  1540     TInt result=KErrNone;     
       
  1541     
       
  1542     __UHEAP_MARK;
 
       
  1543  
       
  1544     CTestAsync* test = CTestAsync::NewL();
 
       
  1545     test->TestGetlistLuidFilterAsyncL();
 
       
  1546     result = test->Result();
 
       
  1547     delete test;
 
       
  1548      
       
  1549     __UHEAP_MARKEND;    
       
  1550 
       
  1551     return result;
 
       
  1552     }
 
       
  1553 
       
  1554 TInt CTCalendarGetListTest::GetListTimeRangeFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1555     {
 
       
  1556     TInt result=KErrNone;     
       
  1557     
       
  1558     __UHEAP_MARK;
 
       
  1559     
       
  1560     CTestAsync* test = CTestAsync::NewL();
 
       
  1561     test->TestGetlistTmRgFilterAsyncL();
 
       
  1562     result = test->Result();
 
       
  1563     delete test;
 
       
  1564     
       
  1565     __UHEAP_MARKEND;    
       
  1566 
       
  1567     return result;
 
       
  1568     
       
  1569     }
 
       
  1570 
       
  1571   
       
  1572 //  
       
  1573 //Whats done here? 
       
  1574 //  Get the default system Calendar using GetList of CCalendarService and output that to GetListdefaultCalendar.txt
 
       
  1575 //       
       
  1576 TInt CTCalendarGetListTest::GetListTextFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1577     {
 
       
  1578     TInt result=KErrNone;     
       
  1579     
       
  1580     __UHEAP_MARK;
 
       
  1581     
       
  1582     CTestAsync* test = CTestAsync::NewL();
 
       
  1583     test->TestGetlistTextFilterAsyncL();
 
       
  1584     result = test->Result();
 
       
  1585     delete test;
 
       
  1586    
       
  1587     __UHEAP_MARKEND;    
       
  1588 
       
  1589     return result;
 
       
  1590     
       
  1591     
       
  1592     }
 
       
  1593     
       
  1594 
       
  1595 //  
       
  1596 //Whats done here? 
       
  1597 //  Get the default system Calendar using GetList of CCalendarService and output that to GetListdefaultCalendar.txt
 
       
  1598 //           
       
  1599 TInt CTCalendarGetListTest::GetListTypeFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1600     {
 
       
  1601 
       
  1602     TInt result=KErrNone;     
       
  1603     
       
  1604     __UHEAP_MARK;
 
       
  1605     
       
  1606     CTestAsync* test = CTestAsync::NewL();
 
       
  1607     test->TestGetlistTypeFilterAsyncL();
 
       
  1608     result = test->Result();
 
       
  1609     delete test;
 
       
  1610     
       
  1611     __UHEAP_MARKEND;    
       
  1612 
       
  1613     return result;
 
       
  1614     
       
  1615     }
 
       
  1616 TInt CTCalendarGetListTest::GetListInvalidGUidFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1617     {
 
       
  1618     TInt result=KErrNone;     
       
  1619     
       
  1620     __UHEAP_MARK;
 
       
  1621     
       
  1622     CTestAsync* test = CTestAsync::NewL();
 
       
  1623     test->TestGetlistInvalidGuidFilterAsyncL();
 
       
  1624     result = test->Result();
 
       
  1625     if(result == KErrGeneral)
 
       
  1626         {
 
       
  1627         result = KErrNone;
 
       
  1628         }
 
       
  1629     delete test;
 
       
  1630     
       
  1631     __UHEAP_MARKEND;    
       
  1632 
       
  1633     return result;
 
       
  1634 
       
  1635     }
 
       
  1636 TInt CTCalendarGetListTest::GetListInvalidLocalUidFilterAsync(CStifItemParser& /*aItem*/ )
 
       
  1637     {
 
       
  1638     TInt result=KErrNone;     
       
  1639     
       
  1640     __UHEAP_MARK;
 
       
  1641  
       
  1642     CTestAsync* test = CTestAsync::NewL();
 
       
  1643     test->TestGetlistInvalidLuidFilterAsyncL();
 
       
  1644     result = test->Result();
 
       
  1645     if(result == KErrGeneral)
 
       
  1646         {
 
       
  1647         result = KErrNone;
 
       
  1648         }
 
       
  1649     delete test;
 
       
  1650      
       
  1651     __UHEAP_MARKEND;    
       
  1652 
       
  1653     return result;
 
       
  1654     }
 
       
  1655 
       
  1656 TInt CTCalendarGetListTest::GetListGUidFilterCancelAsync(CStifItemParser& /*aItem*/ )
 
       
  1657     {
 
       
  1658     TInt result=KErrNone;     
       
  1659     
       
  1660     __UHEAP_MARK;
 
       
  1661     
       
  1662     CTestAsync* test = CTestAsync::NewL();
 
       
  1663     test->TestGetlistGuidFilterCancelAsyncL();
 
       
  1664     result = test->Result();
 
       
  1665    // test->CancelNotification();
 
       
  1666     delete test;
 
       
  1667     
       
  1668     __UHEAP_MARKEND;    
       
  1669 
       
  1670     return result;
 
       
  1671 
       
  1672     }
 
       
  1673 TInt CTCalendarGetListTest::GetListLocalUidFilterCancelAsync(CStifItemParser& /*aItem*/ )
 
       
  1674     {
 
       
  1675     TInt result=KErrNone;     
       
  1676     
       
  1677     __UHEAP_MARK;
 
       
  1678  
       
  1679     CTestAsync* test = CTestAsync::NewL();
 
       
  1680     test->TestGetlistLuidFilterCancelAsyncL();
 
       
  1681     result = test->Result();
 
       
  1682     delete test;
 
       
  1683      
       
  1684     __UHEAP_MARKEND;    
       
  1685 
       
  1686     return result;
 
       
  1687     }
 
       
  1688 
       
  1689 TInt CTCalendarGetListTest::GetListTimeRangeFilterCancelAsync(CStifItemParser& /*aItem*/ )
 
       
  1690     {
 
       
  1691     TInt result=KErrNone;     
       
  1692     
       
  1693     __UHEAP_MARK;
 
       
  1694     
       
  1695     CTestAsync* test = CTestAsync::NewL();
 
       
  1696     test->TestGetlistTmRgFilterCancelAsyncL();
 
       
  1697     result = test->Result();
 
       
  1698     delete test;
 
       
  1699     
       
  1700     __UHEAP_MARKEND;    
       
  1701 
       
  1702     return result;
 
       
  1703     
       
  1704     }
 
       
  1705 
       
  1706   
       
  1707 //  
       
  1708 //Whats done here? 
       
  1709 //  Get the default system Calendar using GetList of CCalendarService and output that to GetListdefaultCalendar.txt
 
       
  1710 //       
       
  1711 TInt CTCalendarGetListTest::GetListTextFilterCancelAsync(CStifItemParser& /*aItem*/ )
 
       
  1712     {
 
       
  1713     TInt result=KErrNone;     
       
  1714     
       
  1715     __UHEAP_MARK;
 
       
  1716     
       
  1717     CTestAsync* test = CTestAsync::NewL();
 
       
  1718     test->TestGetlistTextFilterCancelAsyncL();
 
       
  1719     result = test->Result();
 
       
  1720     delete test;
 
       
  1721    
       
  1722     __UHEAP_MARKEND;    
       
  1723 
       
  1724     return result;
 
       
  1725     
       
  1726     
       
  1727     }
 
       
  1728     
       
  1729 
       
  1730 //  
       
  1731 //Whats done here? 
       
  1732 //  Get the default system Calendar using GetList of CCalendarService and output that to GetListdefaultCalendar.txt
 
       
  1733 //           
       
  1734 TInt CTCalendarGetListTest::GetListTypeFilterCancelAsync(CStifItemParser& /*aItem*/ )
 
       
  1735     {
 
       
  1736 
       
  1737     TInt result=KErrNone;     
       
  1738     
       
  1739     __UHEAP_MARK;
 
       
  1740     
       
  1741     CTestAsync* test = CTestAsync::NewL();
 
       
  1742     test->TestGetlistTypeFilterCancelAsyncL();
 
       
  1743     result = test->Result();
 
       
  1744     delete test;
 
       
  1745     
       
  1746     __UHEAP_MARKEND;    
       
  1747 
       
  1748     return result;
 
       
  1749     
       
  1750     }
 
  1408 
  1751 
  1409 TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar)
 
  1752 TInt RemoveProvCalendar(CLiwGenericParamList* inparam, CLiwGenericParamList* outparam, MLiwInterface* interface, const TDesC& aCalendar)
 
  1410 	{
 
  1753 	{
 
  1411 	inparam->Reset();
 
  1754 	inparam->Reset();
 
  1412 	outparam->Reset();
 
  1755 	outparam->Reset();
 
  1920 
  2263 
  1921 	return err;
 
  2264 	return err;
 
  1922 	};
 
  2265 	};
 
  1923 				
  2266 				
  1924 				
  2267 				
       
  2268 /**
 
       
  2269  * Callback class for asynchronous SAPI message header
 
       
  2270 */  
       
  2271 CCalGetListCallback* CCalGetListCallback::NewL(CActiveSchedulerWait* aWaitSchedular, TInt& aResult)
 
       
  2272     {
 
       
  2273     return new (ELeave) CCalGetListCallback(aWaitSchedular, aResult);
 
       
  2274     }
 
       
  2275         
       
  2276 TInt CCalGetListCallback::HandleNotifyL(TInt aCmdId,
 
       
  2277                                             TInt aEventId,
 
       
  2278                                             CLiwGenericParamList& aEventParamList,
 
       
  2279                                             const CLiwGenericParamList& aInParamList)
 
       
  2280     {
 
       
  2281     TInt pos = 0;
 
       
  2282     TInt result = KErrNone;
 
       
  2283     const TLiwGenericParam* output = aEventParamList.FindFirst( pos,_L8("ReturnValue"));
 
       
  2284     
       
  2285     if(output)
 
       
  2286         {
 
       
  2287         CLiwIterable* iterlist = output->Value().AsIterable();
 
       
  2288         
       
  2289         TInt returnItems = 0;
 
       
  2290 
       
  2291         if(iterlist)
 
       
  2292             {
 
       
  2293             TLiwVariant data;
 
       
  2294 
       
  2295             while ( iterlist->NextL(data) )
 
       
  2296                 returnItems++;  
       
  2297             
       
  2298             data.Reset();  
       
  2299             }
 
       
  2300         if ( iWaitSchedular && iWaitSchedular->IsStarted())
 
       
  2301         {
 
       
  2302              iWaitSchedular->AsyncStop();
 
       
  2303         }
 
       
  2304         
       
  2305         if(returnItems == 0)
 
       
  2306             {
 
       
  2307             return KErrGeneral;
 
       
  2308             }
 
       
  2309          }
 
       
  2310    
       
  2311         return 0;
 
       
  2312     }
 
       
  2313 CTestAsync* CTestAsync::NewL()
 
       
  2314     {
 
       
  2315     CTestAsync* self = new (ELeave) CTestAsync();
 
       
  2316     self->ConstructL();
 
       
  2317     return self;
 
       
  2318     }
 
       
  2319 
       
  2320 CTestAsync::~CTestAsync()
 
       
  2321     {
 
       
  2322     Cancel();
 
       
  2323     
       
  2324     interface->Close();
 
       
  2325     
       
  2326     delete iServiceHandler;
 
       
  2327     
       
  2328     delete iCallback;
 
       
  2329 
       
  2330     if(iWaitSchedular->IsStarted())
 
       
  2331         iWaitSchedular->AsyncStop();
 
       
  2332 
       
  2333     delete iWaitSchedular;
 
       
  2334     }
 
       
  2335 
       
  2336 
       
  2337 void CTestAsync::ConstructL()
 
       
  2338     {
 
       
  2339     CActiveScheduler::Add(this);
 
       
  2340     iWaitSchedular = new(ELeave) CActiveSchedulerWait();
 
       
  2341     }
 
       
  2342 
       
  2343 
       
  2344 CTestAsync::CTestAsync() :
 
       
  2345 CActive(EPriorityStandard)
 
       
  2346         {
 
       
  2347         interface = NULL ;
 
       
  2348         iResult = KErrNone;
 
       
  2349       //  iResult = KErrGeneral;
 
       
  2350         }
 
       
  2351 
       
  2352 void CTestAsync::DoCancel()
 
       
  2353     {
 
       
  2354 
       
  2355     }
 
       
  2356     
       
  2357 void CTestAsync::TestGetlistGuidFilterAsyncL()    
       
  2358     {
 
       
  2359     iTestCaseType = KGetlistGuidFilterAsync;
 
       
  2360         
       
  2361     if(iResult == KErrNone)
 
       
  2362         Start();
 
       
  2363     }   
       
  2364 
       
  2365 void CTestAsync::TestGetlistLuidFilterAsyncL()    
       
  2366     {
 
       
  2367     iTestCaseType = KGetlistLuidFilterAsync;
 
       
  2368     
       
  2369     if(iResult == KErrNone)
 
       
  2370         Start();
 
       
  2371     }   
       
  2372 
       
  2373 void CTestAsync::TestGetlistTmRgFilterAsyncL()    
       
  2374     {
 
       
  2375     iTestCaseType = KGetlistTmRgFilterAsync;
 
       
  2376 
       
  2377     if(iResult == KErrNone)
 
       
  2378         Start();
 
       
  2379     }   
       
  2380 
       
  2381 void CTestAsync::TestGetlistTextFilterAsyncL()    
       
  2382     {
 
       
  2383     iTestCaseType = KGetlistTextFilterAsync;
 
       
  2384 
       
  2385     if(iResult == KErrNone)
 
       
  2386         Start();
 
       
  2387     }   
       
  2388 
       
  2389 void CTestAsync::TestGetlistTypeFilterAsyncL()    
       
  2390     {
 
       
  2391     iTestCaseType = KGetlistTypeFilterAsync;
 
       
  2392 
       
  2393     if(iResult == KErrNone)
 
       
  2394         Start();
 
       
  2395     }  
       
  2396 
       
  2397 void CTestAsync::TestGetlistInvalidGuidFilterAsyncL()    
       
  2398     {
 
       
  2399     iTestCaseType = KGetlistInvalidGuidFilterAsync;
 
       
  2400 
       
  2401     if(iResult == KErrNone)
 
       
  2402         Start();
 
       
  2403     }   
       
  2404 
       
  2405 void CTestAsync::TestGetlistInvalidLuidFilterAsyncL()    
       
  2406     {
 
       
  2407     iTestCaseType = KGetlistInvalidLuidFilterAsync;
 
       
  2408 
       
  2409     if(iResult == KErrNone)
 
       
  2410         Start();
 
       
  2411     }   
       
  2412 
       
  2413 void CTestAsync::TestGetlistGuidFilterCancelAsyncL()    
       
  2414     {
 
       
  2415     iTestCaseType = KGetlistGuidFilterAsync;
 
       
  2416         
       
  2417     if(iResult == KErrNone)
 
       
  2418         Start();
 
       
  2419     }   
       
  2420 
       
  2421 void CTestAsync::TestGetlistLuidFilterCancelAsyncL()    
       
  2422     {
 
       
  2423     iTestCaseType = KGetlistLuidFilterAsync;
 
       
  2424     
       
  2425     if(iResult == KErrNone)
 
       
  2426         Start();
 
       
  2427     }   
       
  2428 
       
  2429 void CTestAsync::TestGetlistTmRgFilterCancelAsyncL()    
       
  2430     {
 
       
  2431     iTestCaseType = KGetlistTmRgFilterAsync;
 
       
  2432 
       
  2433     if(iResult == KErrNone)
 
       
  2434         Start();
 
       
  2435     }   
       
  2436 
       
  2437 void CTestAsync::TestGetlistTextFilterCancelAsyncL()    
       
  2438     {
 
       
  2439     iTestCaseType = KGetlistTextFilterAsync;
 
       
  2440 
       
  2441     if(iResult == KErrNone)
 
       
  2442         Start();
 
       
  2443     }   
       
  2444 
       
  2445 void CTestAsync::TestGetlistTypeFilterCancelAsyncL()    
       
  2446     {
 
       
  2447     iTestCaseType = KGetlistTypeFilterCancelAsync;
 
       
  2448 
       
  2449     if(iResult == KErrNone)
 
       
  2450         Start();
 
       
  2451     }  
       
  2452 
       
  2453 void CTestAsync::RunL()
 
       
  2454     {
 
       
  2455     switch( iTestCaseType )
 
       
  2456         {
 
       
  2457         case KGetlistGuidFilterAsync :
 
       
  2458             GuidAsyncL();
 
       
  2459             break;
 
       
  2460         case KGetlistLuidFilterAsync :
 
       
  2461             LuidAsyncL();
 
       
  2462             break;
 
       
  2463         case KGetlistTmRgFilterAsync :
 
       
  2464             TmRgFilterAsyncL();
 
       
  2465             break;
 
       
  2466         case KGetlistTextFilterAsync :
 
       
  2467             TextFilterAsyncL();
 
       
  2468             break;
 
       
  2469         case KGetlistTypeFilterAsync :
 
       
  2470             TypeFilterAsyncL();
 
       
  2471             break;
 
       
  2472         case KGetlistInvalidGuidFilterAsync :
 
       
  2473             InvalidGuidAsyncL();
 
       
  2474             break;
 
       
  2475         case KGetlistInvalidLuidFilterAsync :
 
       
  2476             InvalidLuidAsyncL();
 
       
  2477             break;
 
       
  2478         case KGetlistGuidFilterCancelAsync :
 
       
  2479             GuidCancelAsyncL();
 
       
  2480             break;
 
       
  2481         case KGetlistLuidFilterCancelAsync :
 
       
  2482             LuidCancelAsyncL();
 
       
  2483             break;
 
       
  2484         case KGetlistTmRgFilterCancelAsync :
 
       
  2485             TmRgFilterCancelAsyncL();
 
       
  2486             break;
 
       
  2487         case KGetlistTextFilterCancelAsync :
 
       
  2488             TextFilterCancelAsyncL();
 
       
  2489             break;
 
       
  2490         case KGetlistTypeFilterCancelAsync :
 
       
  2491             TypeFilterCancelAsyncL();
 
       
  2492             break;
 
       
  2493              
       
  2494         }
 
       
  2495     }
 
       
  2496 TInt CTestAsync::Result()
 
       
  2497     {
 
       
  2498     return iResult;
 
       
  2499     }
 
       
  2500 void CTestAsync::Start()
 
       
  2501     {
 
       
  2502         SetActive();
 
       
  2503         TRequestStatus* temp = &iStatus;
 
       
  2504         User::RequestComplete(temp, KErrNone);
 
       
  2505         iWaitSchedular->Start();    
       
  2506    }
 
       
  2507 
       
  2508 void CTestAsync::GuidAsyncL()
 
       
  2509     {
 
       
  2510     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  2511 
       
  2512     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  2513     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  2514     
       
  2515     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  2516     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  2517     
       
  2518     RCriteriaArray a;
 
       
  2519     
       
  2520     a.AppendL(crit);    
       
  2521     
       
  2522     iServiceHandler->AttachL(a);
 
       
  2523     
       
  2524     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  2525     
       
  2526     delete crit;
 
       
  2527     crit = NULL;
 
       
  2528     a.Reset();
 
       
  2529     
       
  2530     TInt pos = 0;
 
       
  2531     
       
  2532     outParamList->FindFirst(pos,KIDataSource );
 
       
  2533     if(pos != KErrNotFound)
 
       
  2534         {
 
       
  2535         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  2536         }
 
       
  2537 
       
  2538     inParamList->Reset();
 
       
  2539     outParamList->Reset();
 
       
  2540     
       
  2541     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2542     
       
  2543     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2544     
       
  2545     RPointerArray<TUIDSet> arruids(5);
 
       
  2546     
       
  2547     TUIDSet* uids = NULL;
 
       
  2548     
       
  2549     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2550         {
 
       
  2551         arruids.Append(uids);
 
       
  2552         uids = NULL;
 
       
  2553         }
 
       
  2554 
       
  2555     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2556         {
 
       
  2557         arruids.Append(uids);
 
       
  2558         uids = NULL;
 
       
  2559         }
 
       
  2560     
       
  2561     if ( arruids.Count() > 0 )
 
       
  2562         {
 
       
  2563             TLiwVariant content(_L("CalendarEntry"));
 
       
  2564             TLiwGenericParam element1;  
       
  2565             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  2566             inParamList->AppendL(element1);
 
       
  2567             content.Reset();
 
       
  2568             element1.Reset();
 
       
  2569             
       
  2570             
       
  2571             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  2572             CleanupStack::PushL(map);
 
       
  2573 
       
  2574             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  2575             
       
  2576             TBuf<100> gid;
 
       
  2577             gid.Copy( arruids[0]->iGlobalUID->Des() );
 
       
  2578             map->InsertL(_L8("id"), TLiwVariant(gid) ); 
       
  2579             
       
  2580             TLiwVariant filterparam(map);
 
       
  2581             TLiwGenericParam element ;  
       
  2582             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  2583             filterparam.Reset();
 
       
  2584             
       
  2585             inParamList->AppendL(element);
 
       
  2586             element.Reset();
 
       
  2587             map->DecRef();
 
       
  2588             CleanupStack::Pop(map);
 
       
  2589 
       
  2590             TInt err =0 ;
 
       
  2591             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  2592 
       
  2593             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  2594             pos = 0;
 
       
  2595             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  2596             
       
  2597             if(output)
 
       
  2598                 {
 
       
  2599                 iTransactionId = output->Value().AsTInt32();
 
       
  2600                 }
 
       
  2601             else
 
       
  2602                 {
 
       
  2603                 if(iWaitSchedular->IsStarted())
 
       
  2604                     iWaitSchedular->AsyncStop();
 
       
  2605                 }   
       
  2606             inParamList->Reset();
 
       
  2607             outParamList->Reset();
 
       
  2608         
       
  2609         arruids.ResetAndDestroy();
 
       
  2610         }
 
       
  2611     else
 
       
  2612         iResult = KErrGeneral;   
       
  2613 
       
  2614     }
 
       
  2615 void CTestAsync::LuidAsyncL()
 
       
  2616     {
 
       
  2617     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  2618 
       
  2619     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  2620     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  2621     
       
  2622     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  2623     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  2624     
       
  2625     RCriteriaArray a;
 
       
  2626     
       
  2627     a.AppendL(crit);    
       
  2628     
       
  2629     iServiceHandler->AttachL(a);
 
       
  2630     
       
  2631     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  2632     
       
  2633     delete crit;
 
       
  2634     crit = NULL;
 
       
  2635     a.Reset();
 
       
  2636     
       
  2637     TInt pos = 0;
 
       
  2638     
       
  2639     outParamList->FindFirst(pos,KIDataSource );
 
       
  2640     if(pos != KErrNotFound)
 
       
  2641         {
 
       
  2642         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  2643         }
 
       
  2644 
       
  2645     inParamList->Reset();
 
       
  2646     outParamList->Reset();
 
       
  2647     
       
  2648     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2649     
       
  2650     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2651     
       
  2652     RPointerArray<TUIDSet> arruids(5);
 
       
  2653     
       
  2654     TUIDSet* uids = NULL;
 
       
  2655     
       
  2656     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2657         {
 
       
  2658         arruids.Append(uids);
 
       
  2659         uids = NULL;
 
       
  2660         }
 
       
  2661 
       
  2662     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2663         {
 
       
  2664         arruids.Append(uids);
 
       
  2665         uids = NULL;
 
       
  2666         }
 
       
  2667     
       
  2668     if ( arruids.Count() > 0 )
 
       
  2669         {
 
       
  2670             TLiwVariant content(_L("CalendarEntry"));
 
       
  2671             TLiwGenericParam element1;  
       
  2672             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  2673             inParamList->AppendL(element1);
 
       
  2674             content.Reset();
 
       
  2675             element1.Reset();
 
       
  2676             
       
  2677             
       
  2678             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  2679             CleanupStack::PushL(map);
 
       
  2680         
       
  2681             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  2682             TBuf<50> globaluid;
 
       
  2683             TBuf<10> luid;
 
       
  2684             //luid.Num(TInt64(arruids[0]->iLocalUID));
 
       
  2685             globaluid.Copy(arruids[0]->iGlobalUID->Des());
 
       
  2686             luid.Num(TInt64(arruids[0]->iLocalUID));
 
       
  2687          //   luid = GetEntry(interface, inParamList, outParamList, globaluid, KTestCal1File);
 
       
  2688             map->InsertL(_L8("LocalId"), TLiwVariant(luid)); 
       
  2689             
       
  2690             TLiwVariant filterparam(map);
 
       
  2691             TLiwGenericParam element ;  
       
  2692             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  2693             filterparam.Reset();
 
       
  2694             
       
  2695             inParamList->AppendL(element);
 
       
  2696             element.Reset();
 
       
  2697             map->DecRef();
 
       
  2698             CleanupStack::Pop(map);
 
       
  2699 
       
  2700             TInt err =0 ;
 
       
  2701             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  2702 
       
  2703             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  2704             pos = 0;
 
       
  2705             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  2706             
       
  2707             if(output)
 
       
  2708                 {
 
       
  2709                 iTransactionId = output->Value().AsTInt32();
 
       
  2710                 }
 
       
  2711             else
 
       
  2712                 {
 
       
  2713                 if(iWaitSchedular->IsStarted())
 
       
  2714                     iWaitSchedular->AsyncStop();
 
       
  2715                 }   
       
  2716             inParamList->Reset();
 
       
  2717             outParamList->Reset();
 
       
  2718         
       
  2719         arruids.ResetAndDestroy();
 
       
  2720         }
 
       
  2721     else
 
       
  2722         iResult = KErrGeneral;   
       
  2723 
       
  2724     }
 
       
  2725 void CTestAsync::TmRgFilterAsyncL()
 
       
  2726     {
 
       
  2727     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  2728 
       
  2729     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  2730     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  2731     
       
  2732     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  2733     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  2734     
       
  2735     RCriteriaArray a;
 
       
  2736     
       
  2737     a.AppendL(crit);    
       
  2738     
       
  2739     iServiceHandler->AttachL(a);
 
       
  2740     
       
  2741     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  2742     
       
  2743     delete crit;
 
       
  2744     crit = NULL;
 
       
  2745     a.Reset();
 
       
  2746     
       
  2747     TInt pos = 0;
 
       
  2748     
       
  2749     outParamList->FindFirst(pos,KIDataSource );
 
       
  2750     if(pos != KErrNotFound)
 
       
  2751         {
 
       
  2752         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  2753         }
 
       
  2754 
       
  2755     inParamList->Reset();
 
       
  2756     outParamList->Reset();
 
       
  2757     
       
  2758     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2759     
       
  2760     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2761     
       
  2762     RPointerArray<TUIDSet> arruids(5);
 
       
  2763     
       
  2764     TUIDSet* uids = NULL;
 
       
  2765     
       
  2766     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2767         {
 
       
  2768         arruids.Append(uids);
 
       
  2769         uids = NULL;
 
       
  2770         }
 
       
  2771 
       
  2772     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2773         {
 
       
  2774         arruids.Append(uids);
 
       
  2775         uids = NULL;
 
       
  2776         }
 
       
  2777     
       
  2778     if ( arruids.Count() > 0 )
 
       
  2779         {
 
       
  2780             TLiwVariant content(_L("CalendarEntry"));
 
       
  2781             TLiwGenericParam element1;  
       
  2782             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  2783             inParamList->AppendL(element1);
 
       
  2784             content.Reset();
 
       
  2785             element1.Reset();
 
       
  2786             
       
  2787             
       
  2788             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  2789             CleanupStack::PushL(map);
 
       
  2790     
       
  2791             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  2792             map->InsertL(_L8("StartRange"), TLiwVariant(TTime(TDateTime(2007,EOctober,23,10,0,0,0))) ); 
       
  2793             map->InsertL(_L8("EndRange"), TLiwVariant(TTime(TDateTime(2007,EOctober,30,10,30,0,0))) ); 
       
  2794             
       
  2795             TLiwVariant filterparam(map);
 
       
  2796             TLiwGenericParam element ;  
       
  2797             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  2798             filterparam.Reset();
 
       
  2799             
       
  2800             inParamList->AppendL(element);
 
       
  2801             element.Reset();
 
       
  2802             map->DecRef();
 
       
  2803             CleanupStack::Pop(map);
 
       
  2804 
       
  2805             TInt err =0 ;
 
       
  2806             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  2807 
       
  2808             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  2809             pos = 0;
 
       
  2810             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  2811             
       
  2812             if(output)
 
       
  2813                 {
 
       
  2814                 iTransactionId = output->Value().AsTInt32();
 
       
  2815                 }
 
       
  2816             else
 
       
  2817                 {
 
       
  2818                 if(iWaitSchedular->IsStarted())
 
       
  2819                     iWaitSchedular->AsyncStop();
 
       
  2820                 }   
       
  2821             inParamList->Reset();
 
       
  2822             outParamList->Reset();
 
       
  2823         
       
  2824         arruids.ResetAndDestroy();
 
       
  2825         }
 
       
  2826     else
 
       
  2827         iResult = KErrGeneral;   
       
  2828 
       
  2829     }
 
       
  2830 void CTestAsync::TextFilterAsyncL()
 
       
  2831     {
 
       
  2832     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  2833 
       
  2834     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  2835     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  2836     
       
  2837     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  2838     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  2839     
       
  2840     RCriteriaArray a;
 
       
  2841     
       
  2842     a.AppendL(crit);    
       
  2843     
       
  2844     iServiceHandler->AttachL(a);
 
       
  2845     
       
  2846     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  2847     
       
  2848     delete crit;
 
       
  2849     crit = NULL;
 
       
  2850     a.Reset();
 
       
  2851     
       
  2852     TInt pos = 0;
 
       
  2853     
       
  2854     outParamList->FindFirst(pos,KIDataSource );
 
       
  2855     if(pos != KErrNotFound)
 
       
  2856         {
 
       
  2857         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  2858         }
 
       
  2859 
       
  2860     inParamList->Reset();
 
       
  2861     outParamList->Reset();
 
       
  2862     
       
  2863     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2864     
       
  2865     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2866     
       
  2867     RPointerArray<TUIDSet> arruids(5);
 
       
  2868     
       
  2869     TUIDSet* uids = NULL;
 
       
  2870     
       
  2871     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2872         {
 
       
  2873         arruids.Append(uids);
 
       
  2874         uids = NULL;
 
       
  2875         }
 
       
  2876 
       
  2877     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2878         {
 
       
  2879         arruids.Append(uids);
 
       
  2880         uids = NULL;
 
       
  2881         }
 
       
  2882     
       
  2883     if ( arruids.Count() > 0 )
 
       
  2884         {
 
       
  2885             TLiwVariant content(_L("CalendarEntry"));
 
       
  2886             TLiwGenericParam element1;  
       
  2887             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  2888             inParamList->AppendL(element1);
 
       
  2889             content.Reset();
 
       
  2890             element1.Reset();
 
       
  2891             
       
  2892             
       
  2893             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  2894             CleanupStack::PushL(map);
 
       
  2895     
       
  2896             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  2897             map->InsertL(_L8("SearchText"), TLiwVariant(_L("Meeting")) ); 
       
  2898             
       
  2899             TLiwVariant filterparam(map);
 
       
  2900             TLiwGenericParam element ;  
       
  2901             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  2902             filterparam.Reset();
 
       
  2903             
       
  2904             inParamList->AppendL(element);
 
       
  2905             element.Reset();
 
       
  2906             map->DecRef();
 
       
  2907             CleanupStack::Pop(map);
 
       
  2908 
       
  2909             TInt err =0 ;
 
       
  2910             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  2911 
       
  2912             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  2913             pos = 0;
 
       
  2914             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  2915             
       
  2916             if(output)
 
       
  2917                 {
 
       
  2918                 iTransactionId = output->Value().AsTInt32();
 
       
  2919                 }
 
       
  2920             else
 
       
  2921                 {
 
       
  2922                 if(iWaitSchedular->IsStarted())
 
       
  2923                     iWaitSchedular->AsyncStop();
 
       
  2924                 }   
       
  2925             inParamList->Reset();
 
       
  2926             outParamList->Reset();
 
       
  2927         
       
  2928         arruids.ResetAndDestroy();
 
       
  2929         }
 
       
  2930     else
 
       
  2931         iResult = KErrGeneral;   
       
  2932 
       
  2933     }
 
       
  2934 void CTestAsync::TypeFilterAsyncL()
 
       
  2935     {
 
       
  2936     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  2937 
       
  2938     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  2939     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  2940     
       
  2941     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  2942     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  2943     
       
  2944     RCriteriaArray a;
 
       
  2945     
       
  2946     a.AppendL(crit);    
       
  2947     
       
  2948     iServiceHandler->AttachL(a);
 
       
  2949     
       
  2950     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  2951     
       
  2952     delete crit;
 
       
  2953     crit = NULL;
 
       
  2954     a.Reset();
 
       
  2955     
       
  2956     TInt pos = 0;
 
       
  2957     
       
  2958     outParamList->FindFirst(pos,KIDataSource );
 
       
  2959     if(pos != KErrNotFound)
 
       
  2960         {
 
       
  2961         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  2962         }
 
       
  2963 
       
  2964     inParamList->Reset();
 
       
  2965     outParamList->Reset();
 
       
  2966     
       
  2967     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2968     
       
  2969     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  2970     
       
  2971     RPointerArray<TUIDSet> arruids(5);
 
       
  2972     
       
  2973     TUIDSet* uids = NULL;
 
       
  2974     
       
  2975     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2976         {
 
       
  2977         arruids.Append(uids);
 
       
  2978         uids = NULL;
 
       
  2979         }
 
       
  2980 
       
  2981     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  2982         {
 
       
  2983         arruids.Append(uids);
 
       
  2984         uids = NULL;
 
       
  2985         }
 
       
  2986     
       
  2987     if ( arruids.Count() > 0 )
 
       
  2988         {
 
       
  2989             TLiwVariant content(_L("CalendarEntry"));
 
       
  2990             TLiwGenericParam element1;  
       
  2991             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  2992             inParamList->AppendL(element1);
 
       
  2993             content.Reset();
 
       
  2994             element1.Reset();
 
       
  2995             
       
  2996             
       
  2997             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  2998             CleanupStack::PushL(map);
 
       
  2999     
       
  3000             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3001             map->InsertL(_L8("Type"), TLiwVariant(_L("Meeting")) ); 
       
  3002             
       
  3003             TLiwVariant filterparam(map);
 
       
  3004             TLiwGenericParam element ;  
       
  3005             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3006             filterparam.Reset();
 
       
  3007             
       
  3008             inParamList->AppendL(element);
 
       
  3009             element.Reset();
 
       
  3010             map->DecRef();
 
       
  3011             CleanupStack::Pop(map);
 
       
  3012 
       
  3013             TInt err =0 ;
 
       
  3014             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3015 
       
  3016             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3017             pos = 0;
 
       
  3018             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3019             
       
  3020             if(output)
 
       
  3021                 {
 
       
  3022                 iTransactionId = output->Value().AsTInt32();
 
       
  3023                 }
 
       
  3024             else
 
       
  3025                 {
 
       
  3026                 if(iWaitSchedular->IsStarted())
 
       
  3027                     iWaitSchedular->AsyncStop();
 
       
  3028                 }   
       
  3029             inParamList->Reset();
 
       
  3030             outParamList->Reset();
 
       
  3031         
       
  3032         arruids.ResetAndDestroy();
 
       
  3033         }
 
       
  3034     else
 
       
  3035         iResult = KErrGeneral;   
       
  3036 
       
  3037     }
 
       
  3038 void CTestAsync::InvalidGuidAsyncL()
 
       
  3039     {
 
       
  3040     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3041 
       
  3042     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3043     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3044     
       
  3045     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3046     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3047     
       
  3048     RCriteriaArray a;
 
       
  3049     
       
  3050     a.AppendL(crit);    
       
  3051     
       
  3052     iServiceHandler->AttachL(a);
 
       
  3053     
       
  3054     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3055     
       
  3056     delete crit;
 
       
  3057     crit = NULL;
 
       
  3058     a.Reset();
 
       
  3059     
       
  3060     TInt pos = 0;
 
       
  3061     
       
  3062     outParamList->FindFirst(pos,KIDataSource );
 
       
  3063     if(pos != KErrNotFound)
 
       
  3064         {
 
       
  3065         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3066         }
 
       
  3067 
       
  3068     inParamList->Reset();
 
       
  3069     outParamList->Reset();
 
       
  3070     
       
  3071     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3072     
       
  3073     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3074     
       
  3075     RPointerArray<TUIDSet> arruids(5);
 
       
  3076     
       
  3077     TUIDSet* uids = NULL;
 
       
  3078     
       
  3079     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3080         {
 
       
  3081         arruids.Append(uids);
 
       
  3082         uids = NULL;
 
       
  3083         }
 
       
  3084 
       
  3085     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3086         {
 
       
  3087         arruids.Append(uids);
 
       
  3088         uids = NULL;
 
       
  3089         }
 
       
  3090     
       
  3091     if ( arruids.Count() > 0 )
 
       
  3092         {
 
       
  3093             TLiwVariant content(_L("CalendarEntry"));
 
       
  3094             TLiwGenericParam element1;  
       
  3095             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3096             inParamList->AppendL(element1);
 
       
  3097             content.Reset();
 
       
  3098             element1.Reset();
 
       
  3099             
       
  3100             
       
  3101             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3102             CleanupStack::PushL(map);
 
       
  3103     
       
  3104             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3105             map->InsertL(_L8("id"), TLiwVariant(_L("abc")) ); 
       
  3106             
       
  3107             TLiwVariant filterparam(map);
 
       
  3108             TLiwGenericParam element ;  
       
  3109             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3110             filterparam.Reset();
 
       
  3111             
       
  3112             inParamList->AppendL(element);
 
       
  3113             element.Reset();
 
       
  3114             map->DecRef();
 
       
  3115             CleanupStack::Pop(map);
 
       
  3116 
       
  3117             TInt err =0 ;
 
       
  3118             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3119 
       
  3120             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3121             pos = 0;
 
       
  3122             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3123             
       
  3124             if(output)
 
       
  3125                 {
 
       
  3126                 iTransactionId = output->Value().AsTInt32();
 
       
  3127                 }
 
       
  3128             else
 
       
  3129                 {
 
       
  3130                 if(iWaitSchedular->IsStarted())
 
       
  3131                     iWaitSchedular->AsyncStop();
 
       
  3132                 }   
       
  3133             inParamList->Reset();
 
       
  3134             outParamList->Reset();
 
       
  3135         
       
  3136         arruids.ResetAndDestroy();
 
       
  3137         }
 
       
  3138     else
 
       
  3139         iResult = KErrGeneral;   
       
  3140 
       
  3141     }
 
       
  3142 void CTestAsync::InvalidLuidAsyncL()
 
       
  3143     {
 
       
  3144     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3145 
       
  3146     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3147     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3148     
       
  3149     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3150     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3151     
       
  3152     RCriteriaArray a;
 
       
  3153     
       
  3154     a.AppendL(crit);    
       
  3155     
       
  3156     iServiceHandler->AttachL(a);
 
       
  3157     
       
  3158     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3159     
       
  3160     delete crit;
 
       
  3161     crit = NULL;
 
       
  3162     a.Reset();
 
       
  3163     
       
  3164     TInt pos = 0;
 
       
  3165     
       
  3166     outParamList->FindFirst(pos,KIDataSource );
 
       
  3167     if(pos != KErrNotFound)
 
       
  3168         {
 
       
  3169         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3170         }
 
       
  3171 
       
  3172     inParamList->Reset();
 
       
  3173     outParamList->Reset();
 
       
  3174     
       
  3175     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3176     
       
  3177     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3178     
       
  3179     RPointerArray<TUIDSet> arruids(5);
 
       
  3180     
       
  3181     TUIDSet* uids = NULL;
 
       
  3182     
       
  3183     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3184         {
 
       
  3185         arruids.Append(uids);
 
       
  3186         uids = NULL;
 
       
  3187         }
 
       
  3188 
       
  3189     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3190         {
 
       
  3191         arruids.Append(uids);
 
       
  3192         uids = NULL;
 
       
  3193         }
 
       
  3194     
       
  3195     if ( arruids.Count() > 0 )
 
       
  3196         {
 
       
  3197             TLiwVariant content(_L("CalendarEntry"));
 
       
  3198             TLiwGenericParam element1;  
       
  3199             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3200             inParamList->AppendL(element1);
 
       
  3201             content.Reset();
 
       
  3202             element1.Reset();
 
       
  3203             
       
  3204             
       
  3205             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3206             CleanupStack::PushL(map);
 
       
  3207     
       
  3208             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3209             map->InsertL(_L8("LocalId"), TLiwVariant(_L("0")) ); 
       
  3210             
       
  3211             TLiwVariant filterparam(map);
 
       
  3212             TLiwGenericParam element ;  
       
  3213             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3214             filterparam.Reset();
 
       
  3215             
       
  3216             inParamList->AppendL(element);
 
       
  3217             element.Reset();
 
       
  3218             map->DecRef();
 
       
  3219             CleanupStack::Pop(map);
 
       
  3220 
       
  3221             TInt err =0 ;
 
       
  3222             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3223 
       
  3224             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3225             pos = 0;
 
       
  3226             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3227             
       
  3228             if(output)
 
       
  3229                 {
 
       
  3230                 iTransactionId = output->Value().AsTInt32();
 
       
  3231                 }
 
       
  3232             else
 
       
  3233                 {
 
       
  3234                 if(iWaitSchedular->IsStarted())
 
       
  3235                     iWaitSchedular->AsyncStop();
 
       
  3236                 }   
       
  3237             inParamList->Reset();
 
       
  3238             outParamList->Reset();
 
       
  3239         
       
  3240         arruids.ResetAndDestroy();
 
       
  3241         }
 
       
  3242     else
 
       
  3243         iResult = KErrGeneral;   
       
  3244 
       
  3245     }
 
       
  3246 
       
  3247 void CTestAsync::GuidCancelAsyncL()
 
       
  3248     {
 
       
  3249     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3250 
       
  3251     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3252     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3253     
       
  3254     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3255     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3256     
       
  3257     RCriteriaArray a;
 
       
  3258     
       
  3259     a.AppendL(crit);    
       
  3260     
       
  3261     iServiceHandler->AttachL(a);
 
       
  3262     
       
  3263     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3264     
       
  3265     delete crit;
 
       
  3266     crit = NULL;
 
       
  3267     a.Reset();
 
       
  3268     
       
  3269     TInt pos = 0;
 
       
  3270     
       
  3271     outParamList->FindFirst(pos,KIDataSource );
 
       
  3272     if(pos != KErrNotFound)
 
       
  3273         {
 
       
  3274         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3275         }
 
       
  3276 
       
  3277     inParamList->Reset();
 
       
  3278     outParamList->Reset();
 
       
  3279     
       
  3280     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3281     
       
  3282     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3283     
       
  3284     RPointerArray<TUIDSet> arruids(5);
 
       
  3285     
       
  3286     TUIDSet* uids = NULL;
 
       
  3287     
       
  3288     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3289         {
 
       
  3290         arruids.Append(uids);
 
       
  3291         uids = NULL;
 
       
  3292         }
 
       
  3293 
       
  3294     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3295         {
 
       
  3296         arruids.Append(uids);
 
       
  3297         uids = NULL;
 
       
  3298         }
 
       
  3299     
       
  3300     if ( arruids.Count() > 0 )
 
       
  3301         {
 
       
  3302             TLiwVariant content(_L("CalendarEntry"));
 
       
  3303             TLiwGenericParam element1;  
       
  3304             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3305             inParamList->AppendL(element1);
 
       
  3306             content.Reset();
 
       
  3307             element1.Reset();
 
       
  3308             
       
  3309             
       
  3310             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3311             CleanupStack::PushL(map);
 
       
  3312 
       
  3313             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3314             
       
  3315             TBuf<100> gid;
 
       
  3316             gid.Copy( arruids[0]->iGlobalUID->Des() );
 
       
  3317             map->InsertL(_L8("id"), TLiwVariant(gid) ); 
       
  3318             
       
  3319             TLiwVariant filterparam(map);
 
       
  3320             TLiwGenericParam element ;  
       
  3321             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3322             filterparam.Reset();
 
       
  3323             
       
  3324             inParamList->AppendL(element);
 
       
  3325             element.Reset();
 
       
  3326             map->DecRef();
 
       
  3327             CleanupStack::Pop(map);
 
       
  3328 
       
  3329             TInt err =0 ;
 
       
  3330             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3331 
       
  3332             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3333             pos = 0;
 
       
  3334             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3335             
       
  3336             if(output)
 
       
  3337                 {
 
       
  3338                 iTransactionId = output->Value().AsTInt32();
 
       
  3339                 inParamList->AppendL(iTransactionId);
 
       
  3340                 TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inParamList, *outParamList, KLiwOptCancel ));
 
       
  3341                 }
 
       
  3342             else
 
       
  3343                 {
 
       
  3344                 if(iWaitSchedular->IsStarted())
 
       
  3345                     iWaitSchedular->AsyncStop();
 
       
  3346                 }   
       
  3347             inParamList->Reset();
 
       
  3348             outParamList->Reset();
 
       
  3349         
       
  3350         arruids.ResetAndDestroy();
 
       
  3351         }
 
       
  3352     else
 
       
  3353         iResult = KErrGeneral;   
       
  3354 
       
  3355     }
 
       
  3356 void CTestAsync::LuidCancelAsyncL()
 
       
  3357     {
 
       
  3358     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3359 
       
  3360     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3361     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3362     
       
  3363     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3364     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3365     
       
  3366     RCriteriaArray a;
 
       
  3367     
       
  3368     a.AppendL(crit);    
       
  3369     
       
  3370     iServiceHandler->AttachL(a);
 
       
  3371     
       
  3372     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3373     
       
  3374     delete crit;
 
       
  3375     crit = NULL;
 
       
  3376     a.Reset();
 
       
  3377     
       
  3378     TInt pos = 0;
 
       
  3379     
       
  3380     outParamList->FindFirst(pos,KIDataSource );
 
       
  3381     if(pos != KErrNotFound)
 
       
  3382         {
 
       
  3383         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3384         }
 
       
  3385 
       
  3386     inParamList->Reset();
 
       
  3387     outParamList->Reset();
 
       
  3388     
       
  3389     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3390     
       
  3391     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3392     
       
  3393     RPointerArray<TUIDSet> arruids(5);
 
       
  3394     
       
  3395     TUIDSet* uids = NULL;
 
       
  3396     
       
  3397     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3398         {
 
       
  3399         arruids.Append(uids);
 
       
  3400         uids = NULL;
 
       
  3401         }
 
       
  3402 
       
  3403     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3404         {
 
       
  3405         arruids.Append(uids);
 
       
  3406         uids = NULL;
 
       
  3407         }
 
       
  3408     
       
  3409     if ( arruids.Count() > 0 )
 
       
  3410         {
 
       
  3411             TLiwVariant content(_L("CalendarEntry"));
 
       
  3412             TLiwGenericParam element1;  
       
  3413             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3414             inParamList->AppendL(element1);
 
       
  3415             content.Reset();
 
       
  3416             element1.Reset();
 
       
  3417             
       
  3418             
       
  3419             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3420             CleanupStack::PushL(map);
 
       
  3421         
       
  3422             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3423             TBuf<50> globaluid;
 
       
  3424             TBuf<10> luid;
 
       
  3425             //luid.Num(TInt64(arruids[0]->iLocalUID));
 
       
  3426             globaluid.Copy(arruids[0]->iGlobalUID->Des());
 
       
  3427             luid.Num(TInt64(arruids[0]->iLocalUID));
 
       
  3428          //   luid = GetEntry(interface, inParamList, outParamList, globaluid, KTestCal1File);
 
       
  3429             map->InsertL(_L8("LocalId"), TLiwVariant(luid)); 
       
  3430             
       
  3431             TLiwVariant filterparam(map);
 
       
  3432             TLiwGenericParam element ;  
       
  3433             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3434             filterparam.Reset();
 
       
  3435             
       
  3436             inParamList->AppendL(element);
 
       
  3437             element.Reset();
 
       
  3438             map->DecRef();
 
       
  3439             CleanupStack::Pop(map);
 
       
  3440 
       
  3441             TInt err =0 ;
 
       
  3442             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3443 
       
  3444             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3445             pos = 0;
 
       
  3446             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3447             
       
  3448             if(output)
 
       
  3449                 {
 
       
  3450                 iTransactionId = output->Value().AsTInt32();
 
       
  3451                 inParamList->AppendL(iTransactionId);
 
       
  3452                 TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inParamList, *outParamList, KLiwOptCancel ));
 
       
  3453                 }
 
       
  3454             else
 
       
  3455                 {
 
       
  3456                 if(iWaitSchedular->IsStarted())
 
       
  3457                     iWaitSchedular->AsyncStop();
 
       
  3458                 }   
       
  3459             inParamList->Reset();
 
       
  3460             outParamList->Reset();
 
       
  3461         
       
  3462         arruids.ResetAndDestroy();
 
       
  3463         }
 
       
  3464     else
 
       
  3465         iResult = KErrGeneral;   
       
  3466 
       
  3467     }
 
       
  3468 void CTestAsync::TmRgFilterCancelAsyncL()
 
       
  3469     {
 
       
  3470     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3471 
       
  3472     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3473     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3474     
       
  3475     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3476     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3477     
       
  3478     RCriteriaArray a;
 
       
  3479     
       
  3480     a.AppendL(crit);    
       
  3481     
       
  3482     iServiceHandler->AttachL(a);
 
       
  3483     
       
  3484     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3485     
       
  3486     delete crit;
 
       
  3487     crit = NULL;
 
       
  3488     a.Reset();
 
       
  3489     
       
  3490     TInt pos = 0;
 
       
  3491     
       
  3492     outParamList->FindFirst(pos,KIDataSource );
 
       
  3493     if(pos != KErrNotFound)
 
       
  3494         {
 
       
  3495         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3496         }
 
       
  3497 
       
  3498     inParamList->Reset();
 
       
  3499     outParamList->Reset();
 
       
  3500     
       
  3501     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3502     
       
  3503     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3504     
       
  3505     RPointerArray<TUIDSet> arruids(5);
 
       
  3506     
       
  3507     TUIDSet* uids = NULL;
 
       
  3508     
       
  3509     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3510         {
 
       
  3511         arruids.Append(uids);
 
       
  3512         uids = NULL;
 
       
  3513         }
 
       
  3514 
       
  3515     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3516         {
 
       
  3517         arruids.Append(uids);
 
       
  3518         uids = NULL;
 
       
  3519         }
 
       
  3520     
       
  3521     if ( arruids.Count() > 0 )
 
       
  3522         {
 
       
  3523             TLiwVariant content(_L("CalendarEntry"));
 
       
  3524             TLiwGenericParam element1;  
       
  3525             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3526             inParamList->AppendL(element1);
 
       
  3527             content.Reset();
 
       
  3528             element1.Reset();
 
       
  3529             
       
  3530             
       
  3531             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3532             CleanupStack::PushL(map);
 
       
  3533     
       
  3534             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3535             map->InsertL(_L8("StartRange"), TLiwVariant(TTime(TDateTime(2007,EOctober,23,10,0,0,0))) ); 
       
  3536             map->InsertL(_L8("EndRange"), TLiwVariant(TTime(TDateTime(2007,EOctober,30,10,30,0,0))) ); 
       
  3537             
       
  3538             TLiwVariant filterparam(map);
 
       
  3539             TLiwGenericParam element ;  
       
  3540             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3541             filterparam.Reset();
 
       
  3542             
       
  3543             inParamList->AppendL(element);
 
       
  3544             element.Reset();
 
       
  3545             map->DecRef();
 
       
  3546             CleanupStack::Pop(map);
 
       
  3547 
       
  3548             TInt err =0 ;
 
       
  3549             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3550 
       
  3551             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3552             pos = 0;
 
       
  3553             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3554             
       
  3555             if(output)
 
       
  3556                 {
 
       
  3557                 iTransactionId = output->Value().AsTInt32();
 
       
  3558                 inParamList->AppendL(iTransactionId);
 
       
  3559                 TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inParamList, *outParamList, KLiwOptCancel ));
 
       
  3560                 }
 
       
  3561             else
 
       
  3562                 {
 
       
  3563                 if(iWaitSchedular->IsStarted())
 
       
  3564                     iWaitSchedular->AsyncStop();
 
       
  3565                 }   
       
  3566             inParamList->Reset();
 
       
  3567             outParamList->Reset();
 
       
  3568         
       
  3569         arruids.ResetAndDestroy();
 
       
  3570         }
 
       
  3571     else
 
       
  3572         iResult = KErrGeneral;   
       
  3573 
       
  3574     }
 
       
  3575 void CTestAsync::TextFilterCancelAsyncL()
 
       
  3576     {
 
       
  3577     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3578 
       
  3579     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3580     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3581     
       
  3582     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3583     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3584     
       
  3585     RCriteriaArray a;
 
       
  3586     
       
  3587     a.AppendL(crit);    
       
  3588     
       
  3589     iServiceHandler->AttachL(a);
 
       
  3590     
       
  3591     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3592     
       
  3593     delete crit;
 
       
  3594     crit = NULL;
 
       
  3595     a.Reset();
 
       
  3596     
       
  3597     TInt pos = 0;
 
       
  3598     
       
  3599     outParamList->FindFirst(pos,KIDataSource );
 
       
  3600     if(pos != KErrNotFound)
 
       
  3601         {
 
       
  3602         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3603         }
 
       
  3604 
       
  3605     inParamList->Reset();
 
       
  3606     outParamList->Reset();
 
       
  3607     
       
  3608     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3609     
       
  3610     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3611     
       
  3612     RPointerArray<TUIDSet> arruids(5);
 
       
  3613     
       
  3614     TUIDSet* uids = NULL;
 
       
  3615     
       
  3616     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3617         {
 
       
  3618         arruids.Append(uids);
 
       
  3619         uids = NULL;
 
       
  3620         }
 
       
  3621 
       
  3622     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3623         {
 
       
  3624         arruids.Append(uids);
 
       
  3625         uids = NULL;
 
       
  3626         }
 
       
  3627     
       
  3628     if ( arruids.Count() > 0 )
 
       
  3629         {
 
       
  3630             TLiwVariant content(_L("CalendarEntry"));
 
       
  3631             TLiwGenericParam element1;  
       
  3632             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3633             inParamList->AppendL(element1);
 
       
  3634             content.Reset();
 
       
  3635             element1.Reset();
 
       
  3636             
       
  3637             
       
  3638             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3639             CleanupStack::PushL(map);
 
       
  3640     
       
  3641             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3642             map->InsertL(_L8("SearchText"), TLiwVariant(_L("Meeting")) ); 
       
  3643             
       
  3644             TLiwVariant filterparam(map);
 
       
  3645             TLiwGenericParam element ;  
       
  3646             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3647             filterparam.Reset();
 
       
  3648             
       
  3649             inParamList->AppendL(element);
 
       
  3650             element.Reset();
 
       
  3651             map->DecRef();
 
       
  3652             CleanupStack::Pop(map);
 
       
  3653 
       
  3654             TInt err =0 ;
 
       
  3655             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3656 
       
  3657             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3658             pos = 0;
 
       
  3659             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3660             
       
  3661             if(output)
 
       
  3662                 {
 
       
  3663                 iTransactionId = output->Value().AsTInt32();
 
       
  3664                 inParamList->AppendL(iTransactionId);
 
       
  3665                 TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inParamList, *outParamList, KLiwOptCancel ));
 
       
  3666                 }
 
       
  3667             else
 
       
  3668                 {
 
       
  3669                 if(iWaitSchedular->IsStarted())
 
       
  3670                     iWaitSchedular->AsyncStop();
 
       
  3671                 }   
       
  3672             inParamList->Reset();
 
       
  3673             outParamList->Reset();
 
       
  3674         
       
  3675         arruids.ResetAndDestroy();
 
       
  3676         }
 
       
  3677     else
 
       
  3678         iResult = KErrGeneral;   
       
  3679 
       
  3680     }
 
       
  3681 void CTestAsync::TypeFilterCancelAsyncL()
 
       
  3682     {
 
       
  3683     iServiceHandler = CLiwServiceHandler::NewL();
 
       
  3684 
       
  3685     CLiwGenericParamList* inParamList = &(iServiceHandler->InParamListL());
 
       
  3686     CLiwGenericParamList* outParamList = &(iServiceHandler->OutParamListL());
 
       
  3687     
       
  3688     CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KIDataSource,KService);
 
       
  3689     crit->SetServiceClass(TUid::Uid(KLiwClassBase));
 
       
  3690     
       
  3691     RCriteriaArray a;
 
       
  3692     
       
  3693     a.AppendL(crit);    
       
  3694     
       
  3695     iServiceHandler->AttachL(a);
 
       
  3696     
       
  3697     iServiceHandler->ExecuteServiceCmdL(*crit, *inParamList, *outParamList); 
       
  3698     
       
  3699     delete crit;
 
       
  3700     crit = NULL;
 
       
  3701     a.Reset();
 
       
  3702     
       
  3703     TInt pos = 0;
 
       
  3704     
       
  3705     outParamList->FindFirst(pos,KIDataSource );
 
       
  3706     if(pos != KErrNotFound)
 
       
  3707         {
 
       
  3708         interface = (*outParamList)[pos].Value().AsInterface(); 
       
  3709         }
 
       
  3710 
       
  3711     inParamList->Reset();
 
       
  3712     outParamList->Reset();
 
       
  3713     
       
  3714     RemoveProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3715     
       
  3716     AddProvCalendar(inParamList, outParamList, interface, KTestCal1File);
 
       
  3717     
       
  3718     RPointerArray<TUIDSet> arruids(5);
 
       
  3719     
       
  3720     TUIDSet* uids = NULL;
 
       
  3721     
       
  3722     if(AddProvAppointmentDailyRepeat(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3723         {
 
       
  3724         arruids.Append(uids);
 
       
  3725         uids = NULL;
 
       
  3726         }
 
       
  3727 
       
  3728     if(AddProvEvent(inParamList, outParamList, interface, KTestCal1File, uids) == KErrNone && uids)
 
       
  3729         {
 
       
  3730         arruids.Append(uids);
 
       
  3731         uids = NULL;
 
       
  3732         }
 
       
  3733     
       
  3734     if ( arruids.Count() > 0 )
 
       
  3735         {
 
       
  3736             TLiwVariant content(_L("CalendarEntry"));
 
       
  3737             TLiwGenericParam element1;  
       
  3738             element1.SetNameAndValueL(_L8("Type"),content);
 
       
  3739             inParamList->AppendL(element1);
 
       
  3740             content.Reset();
 
       
  3741             element1.Reset();
 
       
  3742             
       
  3743             
       
  3744             CLiwDefaultMap* map = CLiwDefaultMap::NewL();
 
       
  3745             CleanupStack::PushL(map);
 
       
  3746     
       
  3747             map->InsertL(_L8("CalendarName"), TLiwVariant(KTestCal1File) ); 
       
  3748             map->InsertL(_L8("Type"), TLiwVariant(_L("Meeting")) ); 
       
  3749             
       
  3750             TLiwVariant filterparam(map);
 
       
  3751             TLiwGenericParam element ;  
       
  3752             element.SetNameAndValueL(_L8("Filter"),filterparam);
 
       
  3753             filterparam.Reset();
 
       
  3754             
       
  3755             inParamList->AppendL(element);
 
       
  3756             element.Reset();
 
       
  3757             map->DecRef();
 
       
  3758             CleanupStack::Pop(map);
 
       
  3759 
       
  3760             TInt err =0 ;
 
       
  3761             iCallback = CCalGetListCallback::NewL(iWaitSchedular, iResult);
 
       
  3762 
       
  3763             TRAP(err, interface->ExecuteCmdL( KCmdGetList ,*inParamList ,*outParamList,KLiwOptASyncronous,iCallback));
 
       
  3764             pos = 0;
 
       
  3765             const TLiwGenericParam* output = outParamList->FindFirst( pos,_L8("TransactionID"));
 
       
  3766             
       
  3767             if(output)
 
       
  3768                 {
 
       
  3769                 iTransactionId = output->Value().AsTInt32();
 
       
  3770                 inParamList->AppendL(iTransactionId);
 
       
  3771                 TRAPD(err1, interface->ExecuteCmdL(KCmdCancel, *inParamList, *outParamList, KLiwOptCancel ));
 
       
  3772                 }
 
       
  3773             else
 
       
  3774                 {
 
       
  3775                 if(iWaitSchedular->IsStarted())
 
       
  3776                     iWaitSchedular->AsyncStop();
 
       
  3777                 }   
       
  3778             inParamList->Reset();
 
       
  3779             outParamList->Reset();
 
       
  3780         
       
  3781         arruids.ResetAndDestroy();
 
       
  3782         }
 
       
  3783     else
 
       
  3784         iResult = KErrGeneral;   
       
  3785 
       
  3786     }
FCL/sf/mw/serviceapi