/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  
*
*/

#include <StifParser.h>
#include <StifTestInterface.h>

#include <liwservicehandler.h>
#include <liwcommon.h>


#include "tconstants.h"
#include "tprovidertest.h"
#include "tprovidercallback.h"
#include "serviceerrno.h"

void Ctprovidertest :: tdeleteTestL(TInt aExpected)
{
  if(aExpected != KErrNone)
  	{
  	 _LIT(KLog , "Negative test case for delete api") ;
  	 iLog->Log(KLog) ;
  tdeleteNegativeL();
  	  
  	}
  	
  else 
  	{
  	 _LIT(KLog , "Functional test for the delete api")  ;
  	 iLog->Log(KLog)  ;	
  	 tdeleteFunctionalL() ;
  	}  	
}


//----------------------------------------------------------------------
// internal utility function which tests the functionality of delete api
//
//----------------------------------------------------------------------

void Ctprovidertest :: tdeleteFunctionalL()
	{
	  
	_LIT(KOwnEventSubject, "RandomLogEvent");
	_LIT(KOwnEventRemoteParty, "OwnContact");

    CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0;
	
   
 
	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
	
	if(!genericparm)
	{
	 _LIT(KLog , "Logging interface not found") ;
	 iLog->Log(KLog) ;
	 
	 User :: Leave(KErrArgument) ;
	}
	
   MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
   
   //Add an event and then delete this added event ;
   
   CLiwDefaultMap *EventDetails = CLiwDefaultMap :: NewL() ;	
   
   EventDetails->InsertL(KEventTypeKey ,TLiwVariant((TInt32)KLogShortMessageEvent)) ;
   
   
   TBufC16<10> contentType(KContentType) ;
   
   //Insert the contenttype to inputlist
   inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
 
   
   inputlist->AppendL(TLiwGenericParam(KEventDetails , TLiwVariant(EventDetails))) ;
   
   EventDetails->DecRef();
   TBufC8<20>CmdBuf(KCmdAdd) ;
   
   LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist) ;
   
   //Now get the id to deleted
   
   pos = 0 ;
   
   const TLiwGenericParam *outparm1 = outputlist->FindFirst(pos , KResponse) ; 
   
   if(!outparm1)
   	{
   	 _LIT8(KLog , "Log id of the delete item not found") ;
   	 iLog->Log(KLog) ;
   	 User :: Leave(KErrArgument) ;
   	}
  	
  //Now delete the added item
  
// TInt itemid = (outparm1->Value()).AsTInt32() ;

  TBufC<20> itemid = (outparm1->Value()).AsDes() ;
  
 /* if(itemid  < 0 )
   {
   _LIT(KLog , "Invalid item id ") ;
   iLog->Log(KLog) ;
   User :: Leave(KErrArgument) ;	
   }*/
   
  inputlist->Reset() ; outputlist->Reset() ;
  
   CLiwDefaultMap *Idmap = CLiwDefaultMap :: NewL() ;
   Idmap->InsertL(KLogId ,TLiwVariant(itemid)) ;
   
   //Insert the contenttype to inputlist
   inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
 
   
 // inputlist->AppendL(TLiwGenericParam(KLogId , TLiwVariant((TInt32)itemid))) ;
    inputlist->AppendL(TLiwGenericParam(KData , TLiwVariant(Idmap))) ; 
    Idmap->DecRef();
  CmdBuf = KCmdDelete ;
  LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist) ;
  
  pos = 0 ;
  const TLiwGenericParam *Errprm = outputlist->FindFirst(pos , KErrCode ) ;
  
  if(!Errprm)
  	{
  	 _LIT(KLog , "Generic error param missing form the outputlist of delete" ) ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
  TInt retval  = Errprm->Value().AsTInt32() ;
  
  if(retval != SErrNone )
  	{
  	 _LIT(KLog , "Functionality test of delete call failed ") ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	  LogInterface->Close() ;
  	 delete ServiceHandler;
 
      
   	 a.ResetAndDestroy();
   	 a.Close();
    
   
   
     
  }
  
  
  //----------------------------------------------------------------------
// Negative testcase for delete api
//
//----------------------------------------------------------------------

void Ctprovidertest :: tdeleteNegativeL()
	{
	

    CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	TBufC16<10> contentType(KContentType) ;
   
   //Insert the contenttype to inputlist
   inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
 
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0;
	
 
	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
	
	if(!genericparm)
	{
	 _LIT(KLog , "Logging interface not found") ;
	 iLog->Log(KLog) ;
	 
	 User :: Leave(KErrArgument) ;
	}
	
   MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
   
   
  
  	
  
  
  TInt itemid = -1;
  TBuf<8> des;
  des.Num(itemid);
 
   
   inputlist->Reset() ;
   outputlist->Reset() ;
   
   CLiwDefaultMap *Idmap = CLiwDefaultMap :: NewL() ;
   Idmap->InsertL(KLogId ,TLiwVariant(des)) ;
   
  inputlist->AppendL(TLiwGenericParam(KData , TLiwVariant(Idmap))) ;
  Idmap->DecRef();
  TBufC8<20>CmdBuf(KCmdDelete) ;
  //CmdBuf = KCmdDelete ;
  LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist) ;
  
  pos = 0 ;
  const TLiwGenericParam *Errprm = outputlist->FindFirst(pos , KErrCode ) ;
  
  if(!Errprm)
  	{
  	 _LIT(KLog , "Generic error param missing form the outputlist of delete" ) ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
  TInt retval  = Errprm->Value().AsTInt32() ;
  
  if(retval != SErrNone )
  	{
  	     LogInterface->Close() ;
  	   delete ServiceHandler;
 
      
   	 a.ResetAndDestroy();
   	 a.Close();
    
  
   
  	 _LIT(KLog , "Functionality test of delete call failed ") ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
	LogInterface->Close() ;
	delete ServiceHandler;
 
   
   	 a.ResetAndDestroy();
   	 a.Close();
    
   
  }


//-----------------------------------------------------------------------------
// Functionality test for delete async call
//-----------------------------------------------------------------------------
void Ctprovidertest :: tdeleteTestasyncL(TInt aExpected)
{
  if(aExpected != KErrNone)
  	{
  	 _LIT(KLog , "Negative test case for delete api") ;
  	 iLog->Log(KLog) ;
  	 tdeleteNegativeasyncL();
  	  
  	}
  	
  else 
  	{
  	 _LIT(KLog , "Functional test for the delete async api")  ;
  	 iLog->Log(KLog)  ;	
  	 tdeleteFunctionalAsyncL() ;
  	}  	
}

//----------------------------------------------------------------------
// positive test case for delete async
//
//----------------------------------------------------------------------


void Ctprovidertest :: tdeleteFunctionalAsyncL(void)
{
		
	NotifyCB Callback ;
		
	_LIT(KOwnEventSubject, "RandomLogEvent");
	_LIT(KOwnEventRemoteParty, "OwnContact");

    CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0;
	
 
	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
	
	if(!genericparm)
	{
	 _LIT(KLog , "Logging interface not found") ;
	 iLog->Log(KLog) ;
	 
	 User :: Leave(KErrArgument) ;
	}
	
   MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
   
   //Add an event and then delete this added event ;
   
   CLiwDefaultMap *EventDetails = CLiwDefaultMap :: NewL() ;	
   
   EventDetails->InsertL(KEventTypeKey ,TLiwVariant((TInt32)KLogShortMessageEvent)) ;
   
   
   /**
    * First append content type
    */
    
    TBufC16<10> contentType(KContentType) ;
   
   //Insert the contenttype to inputlist
   inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
 
   
   inputlist->AppendL(TLiwGenericParam(KEventDetails , TLiwVariant(EventDetails))) ;
   
   EventDetails->DecRef();
   TBufC8<20>CmdBuf(KCmdAdd) ;
   
   LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist) ;
   
   //Now get the id to deleted
   
   pos = 0 ;
   
   const TLiwGenericParam *outparm1 = outputlist->FindFirst(pos , KResponse) ; 
   
   if(!outparm1)
   	{
   	 _LIT8(KLog , "Log id of the delete item not found") ;
   	 iLog->Log(KLog) ;
   	 User :: Leave(KErrArgument) ;
   	}
  	
  //Now delete the added item
  
  TBufC<20> itemid = (outparm1->Value()).AsDes();
// TInt itemid = (outparm1->Value()).AsTInt32() ;
  
  /*if(itemid  < 0 )
   {
   _LIT(KLog , "Invalid item id ") ;
   iLog->Log(KLog) ;
   User :: Leave(KErrArgument) ;	
   }*/
   
  inputlist->Reset() ; outputlist->Reset() ;
    CLiwDefaultMap *Idmap = CLiwDefaultMap :: NewL() ;
   Idmap->InsertL(KLogId ,TLiwVariant(itemid)) ;
  
   //Insert the contenttype to inputlist
   inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
 
   
  inputlist->AppendL(TLiwGenericParam(KData , TLiwVariant(Idmap))) ;
   Idmap->DecRef();
  CmdBuf = KCmdDelete ;
  LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist ,KLiwOptASyncronous, &Callback) ;
  
  pos = 0 ;
  const TLiwGenericParam *Errprm = outputlist->FindFirst(pos , KErrCode ) ;
  
  if(!Errprm)
  	{
  	 _LIT(KLog , "Generic error param missing form the outputlist of delete" ) ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
  TInt retval  = Errprm->Value().AsTInt32() ;
  
  if(retval != SErrNone )
  	{
  	 _LIT(KLog , "Functionality test of delete call failed ") ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
 Callback.Start() ;
 
 if(Callback.Status() != KErrNone) 
 	{
 	 _LIT(KLog , "Async status error ") ;
 	 iLog->Log(KLog) ;
 	 User :: Leave (Callback.Status()) ;
 	}
 	LogInterface->Close() ;
    delete ServiceHandler;
 
   
   	 a.ResetAndDestroy();
   	 a.Close();
   
    
}

//----------------------------------------------------------------------
// negative test case for delete async
//
//----------------------------------------------------------------------



void Ctprovidertest :: tdeleteNegativeasyncL(void)
{
		
	NotifyCB Callback ;
		
	
    CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0;
	
 
	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
	
	if(!genericparm)
	{
	 _LIT(KLog , "Logging interface not found") ;
	 iLog->Log(KLog) ;
	 
	 User :: Leave(KErrArgument) ;
	}
	
   MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
   
   
  
  
 TInt itemid = -1;
  TBuf<8> des;
  des.Num(itemid);
  
  inputlist->Reset() ; 
  outputlist->Reset() ;
   
   CLiwDefaultMap *Idmap = CLiwDefaultMap :: NewL() ;
   Idmap->InsertL(KLogId ,TLiwVariant(des)) ;
   
	TBufC16<10> contentType(KContentType) ;

	//Insert the contenttype to inputlist
	inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;

	inputlist->AppendL(TLiwGenericParam(KData , TLiwVariant(Idmap))) ;
	TBufC8<20>CmdBuf(KCmdDelete) ;
	Idmap->DecRef();
 //CmdBuf = KCmdDelete ;
  LogInterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist ,KLiwOptASyncronous , &Callback) ;
  
  pos = 0 ;
  const TLiwGenericParam *Errprm = outputlist->FindFirst(pos , KErrCode ) ;
  
  if(!Errprm)
  	{
  	 _LIT(KLog , "Generic error param missing form the outputlist of delete" ) ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
  TInt retval  = Errprm->Value().AsTInt32() ;
  
  if(retval != SErrNone )
  	{
  	 _LIT(KLog , "Functionality test of delete call failed ") ;
  	 iLog->Log(KLog) ;
  	 User :: Leave(KErrArgument) ;
  	}
  	
 Callback.Start() ;
 
 if(Callback.Status() != KErrNone) 
 	{
 	 _LIT(KLog , "Async status error ") ;
 	 iLog->Log(KLog) ;
 	 User :: Leave (Callback.Status()) ;
 	}
 	  LogInterface->Close() ;
     delete ServiceHandler;
 
   
   	 a.ResetAndDestroy();
   	 a.Close();
    
   
}

/**
 * Delete testcase for deleting all events
 */
 
 void Ctprovidertest :: tdeleteAllEventsL(TInt aSync)
	{
	if(aSync)
		{
		tdeleteAllEventsAsyncL() ;
		}
	else
		{
		tdeleteAllEventsSyncL() ;
		}	
	}
	

/**
 * Synchronously delete all events
 */
 
 void Ctprovidertest ::	tdeleteAllEventsSyncL()
 	{
 	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0; 
    const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
    
    if(!genericparm)
		{
		_LIT(KLog , "Logging interface not found") ;
		iLog->Log(KLog) ;

		User :: Leave(KErrArgument) ;
		}

	MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
	
	

	// set the identity information
    TBufC8<20>CmdBufSet(KCmdGetList) ;
    
    outputlist->Reset() ;
  
    inputlist->Reset() ;
  
    CLiwDefaultMap *EventFilter = CLiwDefaultMap :: NewL() ;
    
  //if(aDetails->GetEventId()!=0)  
   
  	EventFilter->InsertL(KAllEvents , TLiwVariant(TRUE)) ;
  
  
	TBufC16<10> contentType(KContentType) ;

	//Insert the contenttype to inputlist
	inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
	inputlist->AppendL(TLiwGenericParam(KFilter , TLiwVariant(EventFilter))) ;
    EventFilter->DecRef() ;
    
    LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ); 
  
  
  
	/** 
	* Extract the error param, and check the status of the call
	*/
	TInt index = 0 ;

	const TLiwGenericParam *ErrCode  = outputlist->FindFirst(index , KErrCode) ;

	if(!ErrCode )
		{
		 _LIT(KLog , "Generic error param missing form the outputlist of add" ) ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}

	TInt retval  = ErrCode->Value().AsTInt32() ;

	if(retval != SErrNone )
		{
		 _LIT(KLog , "Functionality test of add call failed ") ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}



	pos = 0 ;

	const TLiwGenericParam *LogIterParam = outputlist->FindFirst(pos , KLogIter)  ;



	 CLiwIterable *LogIter = (LogIterParam->Value()).AsIterable() ;
	 
	 if(!LogIter)
	 	{
	 	 _LIT(KLog , "LogIterator not found \n") ;
	 	 iLog->Log(KLog) ;
	 	 User :: Leave (KErrGeneral) ;
	 	}
	 TLiwVariant   Events ;
	 TLiwVariant   EventDetails ;
	 
	 
	 
	 CmdBufSet = KCmdDelete ;
	 
	 while(LogIter->NextL(EventDetails))
	 	{
	 	 const CLiwMap *eventDetails = EventDetails.AsMap() ;
	 	 
	 	 if(eventDetails->FindL(KLogId , Events) == KErrNotFound)
	 	 	{
	 	 	 _LIT(KLog , "Item_id not found") ;
	 	 	 iLog->Log(KLog) ;
	 	 	 User :: Leave(KErrArgument) ;
	 	 	}
	 	 
	 	 
	 	 
	 	 TInt32 eventid =  Events.AsTInt32() ;
	 	 
	 	 inputlist->Reset() ;
	 	 
	 	 inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(KContentType))) ;
	 	 inputlist->AppendL(TLiwGenericParam(KLogId , TLiwVariant(eventid))) ;
	 	 
	 	 
	 	 LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ) ;
	 	 
	 	 (const_cast<CLiwMap *>(eventDetails))->DecRef() ;
	 	}
	 	
	 	EventDetails.Reset() ;
	 	Events.Reset() ;
	 	
	CmdBufSet = KCmdGetList ;
	
	
	inputlist->Reset() ;
	inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(KContentType))) ;
	LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ); 
	
	
	index = 0 ;
	ErrCode  = outputlist->FindFirst(index , KErrCode) ;
	
	if(!ErrCode )
		{
		 _LIT(KLog , "Generic error param missing form the outputlist of add" ) ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}

    retval  = ErrCode->Value().AsTInt32() ;

	if(retval != SErrNone )
		{
		 _LIT(KLog , "Functionality test of add call failed ") ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}

  
   LogIterParam = outputlist->FindFirst(pos , KLogIter)  ;	
   LogIter = (LogIterParam->Value()).AsIterable() ; 
   
   TInt totalCnt ;
  
  for( totalCnt = 0 ; LogIter->NextL(EventDetails) ;  ++totalCnt)
  	{
  	 const CLiwMap *eventDetails = EventDetails.AsMap() ;
	 	 
	 	 if(eventDetails->FindL(KLogId , Events) == KErrNotFound)
	 	 	{
	 	 	 _LIT(KLog , "Item_id not found") ;
	 	 	 iLog->Log(KLog) ;
	 	 	 User :: Leave(KErrArgument) ;
	 	 	}
	 	 
	 	 
	 	 
	 	 TInt32 eventid =  Events.AsTInt32() ;
	 	 
	 	 inputlist->Reset() ;
	 	 
	 	 inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(KContentType))) ;
	 	 inputlist->AppendL(TLiwGenericParam(KLogId , TLiwVariant(eventid))) ;
	 	 
	 	 LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ) ;
	 	 
	 	 (const_cast<CLiwMap *>(eventDetails))->DecRef() ;
  	}
  	
	Events.Reset() ;
	EventDetails.Reset() ;
	LogInterface->Close() ;
	delete  ServiceHandler ;
	a.ResetAndDestroy() ;
	a.Close() ;
	
	if(totalCnt > 0)
		{
		 _LIT(KLog , "Total count is still greater than zero") ;
		 iLog->Log(KLog) ;
		 User :: Leave (KErrGeneral) ;
		}

 	}
	
/**
 * Synchronously delete all events
 */
 
 void Ctprovidertest ::	tdeleteAllEventsAsyncL(void)
 	{
 	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();
     // Input and output parameter list
    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());
    
    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());
    
    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDsInterfaceName , KLoggingContents) ;
    
    crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;
	
	a.AppendL(crit);
	
	ServiceHandler->AttachL(a) ;
	
	
	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);
    
    TInt pos = 0; 
    const TLiwGenericParam *genericparm = outputlist->FindFirst(pos  , KDsInterfaceName);
    
    if(!genericparm)
		{
		_LIT(KLog , "Logging interface not found") ;
		iLog->Log(KLog) ;

		User :: Leave(KErrArgument) ;
		}

	MLiwInterface* LogInterface = (genericparm->Value()).AsInterface();
	
	

	// set the identity information
    TBufC8<20>CmdBufSet(KCmdGetList) ;
    
    outputlist->Reset() ;
  
    inputlist->Reset() ;
  
    CLiwDefaultMap *EventFilter = CLiwDefaultMap :: NewL() ;
    
  //if(aDetails->GetEventId()!=0)  
   
  	EventFilter->InsertL(KAllEvents , TLiwVariant(TRUE)) ;
  
  
	TBufC16<10> contentType(KContentType) ;

	//Insert the contenttype to inputlist
	inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(contentType))) ;
	inputlist->AppendL(TLiwGenericParam(KFilter , TLiwVariant(EventFilter))) ;
    EventFilter->DecRef() ;
    
    LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ); 
  
  
  
	/** 
	* Extract the error param, and check the status of the call
	*/
	TInt index = 0 ;

	const TLiwGenericParam *ErrCode  = outputlist->FindFirst(index , KErrCode) ;

	if(!ErrCode )
		{
		 _LIT(KLog , "Generic error param missing form the outputlist of add" ) ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}

	TInt retval  = ErrCode->Value().AsTInt32() ;

	if(retval != SErrNone )
		{
		 _LIT(KLog , "Functionality test of add call failed ") ;
		 iLog->Log(KLog) ;
		 User :: Leave(KErrArgument) ;
		}



	pos = 0 ;

	const TLiwGenericParam *LogIterParam = outputlist->FindFirst(pos , KLogIter)  ;



	 CLiwIterable *LogIter = (LogIterParam->Value()).AsIterable() ;
	 TLiwVariant   Events ;
	 TLiwVariant   EventDetails ;
	 
	 
	 
	 CmdBufSet = KCmdDelete ;
	 NotifyCB Callback ;
	 
	 while(LogIter->NextL(EventDetails))
	 	{
	 	 const CLiwMap *eventDetails = EventDetails.AsMap() ;
	 	 
	 	 if(eventDetails->FindL(KLogId , Events) == KErrNotFound)
	 	 	{
	 	 	 _LIT(KLog , "Item_id not found") ;
	 	 	 iLog->Log(KLog) ;
	 	 	 User :: Leave(KErrArgument) ;
	 	 	}
	 	 
	 	 
	 	 
	 	 TUid eventid =  Events.AsTUid() ;
	 	 
	 	 inputlist->Reset() ;
	 	 
	 	 inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(KContentType))) ;
	 	 inputlist->AppendL(TLiwGenericParam(KLogId , TLiwVariant(eventid))) ;
	 	 
	 	 
	 	 
	 	 LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist , 0 , &Callback ) ;
	 	 Callback.Start() ;
	 	 
	 	 (const_cast<CLiwMap *>(eventDetails))->DecRef() ;
	 	 
	 	 if(Callback.Status() != KErrNone)
	 	 	{
	 	 	 _LIT(KLog , "Callback status not KErrNone") ;
	 	 	 iLog->Log(KLog) ;
	 	 	 User :: Leave(KErrArgument) ;
	 	 	}
	 	 
	 	}
	 	
   Events.Reset() ;
   EventDetails.Reset() ;
   
    LogIterParam = outputlist->FindFirst(pos , KLogIter)  ;	
   LogIter = (LogIterParam->Value()).AsIterable() ; 
   
   TInt totalCnt ;
  
  for( totalCnt = 0 ; LogIter->NextL(EventDetails) ;  ++totalCnt)
  	{
  	 const CLiwMap *eventDetails = EventDetails.AsMap() ;
	 	 
	 	 if(eventDetails->FindL(KLogId , Events) == KErrNotFound)
	 	 	{
	 	 	 _LIT(KLog , "Item_id not found") ;
	 	 	 iLog->Log(KLog) ;
	 	 	 User :: Leave(KErrArgument) ;
	 	 	}
	 	 
	 	 
	 	 
	 	 TInt32 eventid =  Events.AsTInt32() ;
	 	 
	 	 inputlist->Reset() ;
	 	 
	 	 inputlist->AppendL(TLiwGenericParam(KContentTypeKey , TLiwVariant(KContentType))) ;
	 	 inputlist->AppendL(TLiwGenericParam(KLogId , TLiwVariant(eventid))) ;
	 	 
	 	 LogInterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist ) ;
	 	 
	 	 (const_cast<CLiwMap *>(eventDetails))->DecRef() ;
  	}
  	
	Events.Reset() ;
	EventDetails.Reset() ;
	LogInterface->Close() ;
	delete  ServiceHandler ;
	a.ResetAndDestroy() ;
	a.Close() ;
	
	if(totalCnt > 0)
		{
		 _LIT(KLog , "Total count is still greater than zero") ;
		 iLog->Log(KLog) ;
		 User :: Leave (KErrGeneral) ;
		}

  



	LogInterface->Close() ;
	delete  ServiceHandler ;
	a.ResetAndDestroy() ;
	a.Close() ;
  
 	}
	
