1 /*

     2 * t_vimpstenginepresencesubservice.cpp ::Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:t_vimpstenginepresencesubservice.cpp

    15 *

    16 */

    17 #include <EUnitMacros.h>

    18 #include <TEUnitAssertionInfo.h>

    19 #include <CEUnitAllocTestCaseDecorator.h>

    20 #include "t_vimpstenginepresencesubservice.h"

    21 

    22 #include <spentry.h>

    23 #include <spsettings.h>

    24 #include <spproperty.h>

    25 #include <avabilitytext.h>

    26 //#include "vimpstcustomcleanupapi.h"

    27 #include <cntdb.h>

    28 

    29 #include "s_ximpclient.h"

    30 #include "s_ximpcontext.h"

    31 #include "s_presencefeatures.h"

    32 #include "s_presentitygroups.h"

    33 #include "s_ximprequestcompleteevent.h"

    34 #include "s_ximppresensitypresenceevent.h"

    35 #include "s_ximppresencegrantrequestlistevent.h"

    36 #include "s_ximppresensitygroupcontentevent.h"

    37 #include "s_ximpcontextstateevent.h"

    38 #include "s_ximpidentity.h"

    39 #include "s_presenceinfo.h"

    40 #include "s_presencebuddyinfo2.h"

    41 #include "s_presenceblockinfo.h"

    42 

    43 //#include "s_presencebuddyinfolist.h"

    44 

    45 #include "s_ximppresensitypresenceevent.h"

    46 #include "s_presencesubserviceeventobserver.h"

    47 #include "cvimpstenginepresencesubservice.h"

    48 #include "cvimpstenginecchhandler.h"

    49 #include "cvimpstengineservicetablefetcher.h"

    50 #include "cvimpstenginesessioncntxtobserver.h"

    51 #include "cvimpstblockedlistmanager.h"

    52 

    53 //extern MyCchService* myService;

    54 extern TBool createService;

    55 extern TBool tryPresenceSubServiceAvailable;

    56 extern TBool tryAllSubserviceAvailable;

    57 

    58 extern TInt32 gMXIMPRequestCompleteEventStubInterfaceId;

    59 extern TInt32 gMXIMPContextStateEventStubInterfaceId;

    60 extern TInt32 gMXIMPPresentityPresenceEventStubInterfaceId;

    61 extern TInt32 gMXIMPPresenceGrantRequestListEventStubInterfaceId;

    62 extern TInt32 gMXIMPPresenceBlockInfoStubInterfaceId;

    63 extern TInt32 gMXIMPPresentityGroupEventStubInterfaceId;

    64 extern TBool gRequestCompleteEventResultCodeKerrNotSupported;

    65 extern TXIMPRequestId gMXIMPRequestCompleteEventStubRequestId;

    66 extern TBool gCreateXIMPIdentity;

    67 extern TInt gNewRequestsCountValue;

    68 extern TInt gCurrentRequestsCountValue;

    69 extern TBool gPersonPresenceInfoAvailable;

    70 extern TBool tryConnParamWithSuccess;

    71 extern TBool tryParamTomatchOwnId;

    72 //extern MPresenceInfoStub* gMPresenceInfoStub;

    73 // cache error 

    74 extern TInt gAllBuddiesPresenceInServiceError;

    75 const TInt KTestServiceId = 5;

    76 

    77 //_LIT( KTestDb, "contacts.cdb" );

    78 

    79 //_LIT( KTestContactList, "TEST_CONTACT_LIST" );

    80 //_LIT( KTestUserId, "TEST_USER_ID" );

    81 //_LIT( KTestNickName, "TEST_NICKNAME" );

    82 _LIT( KTestContactId, "TEST_CONTACT_ID" );

    83 _LIT( KTestStatusText, "TEST_STATUS" );

    84 //_LIT( KTestPresenceUri, "test@test.com" );

    85 

    86 //availability status text

    87 _LIT(KBlockedState,"BlockedState");

    88 //_LIT(KInvisibleState,"InvisibleState");

    89 //_LIT(KAwayState,"AwayState");

    90 //_LIT(KOnPhoneState,"OnPhoneState");

    91 //_LIT(KDndState,"DoNotDisturb");

    92 //_LIT(KPendingRequestState,"PendingRequestState");

    93 

    94 //extern RPointerArray<MPresenceBuddyInfo> gPresenceArry;

    95 

    96 

    97 T_VimpstEnginePresenceSubService* T_VimpstEnginePresenceSubService::NewLC()

    98     {

    99     T_VimpstEnginePresenceSubService* self = new( ELeave ) T_VimpstEnginePresenceSubService;

   100     CleanupStack::PushL( self );

   101     self->ConstructL();

   102     return self;

   103     }

   104 

   105 T_VimpstEnginePresenceSubService::~T_VimpstEnginePresenceSubService()

   106     {

   107     }

   108 

   109 void T_VimpstEnginePresenceSubService::ConstructL()

   110     {

   111     CEUnitTestSuiteClass::ConstructL();

   112     }

   113 

   114 

   115 //  FROM OBSERVER INTERFACES

   116 void T_VimpstEnginePresenceSubService::HandleServceConnectionEventL()

   117     {

   118     }

   119 

   120 

   121 void T_VimpstEnginePresenceSubService::SetupL()

   122     {

   123  	createService = ETrue;

   124     tryPresenceSubServiceAvailable = ETrue;

   125     

   126     iTestServiceId = CreateSpEntryL( KTestServiceId );

   127    

   128     iCchHandler = CVIMPSTEngineCchHandler::NewL( iTestServiceId, *iCchUiEventObserver);

   129    

   130     iServiceTableFetcher = CVIMPSTEngineServiceTableFetcher::NewL();

   131     

   132   

   133     iSessionCntxtObserver = CVIMPSTEngineSessionCntxtObserver::NewL( iTestServiceId );

   134     

   135     delete iSessionCntxtObserver->iFeatures;

   136     iSessionCntxtObserver->iFeatures = NULL;

   137     delete iSessionCntxtObserver->iPresenceCtx;

   138     iSessionCntxtObserver->iPresenceCtx = NULL;

   139     delete iSessionCntxtObserver->iClient;

   140     iSessionCntxtObserver->iClient = NULL;

   141   

   142     iSessionCntxtObserver->iClient = MXIMPClientStub::NewClientL();

   143     iSessionCntxtObserver->iPresenceCtx = 

   144         iSessionCntxtObserver->iClient->NewPresenceContextLC();    

   145     CleanupStack::Pop();// because of LC method

   146     iSessionCntxtObserver->iFeatures =  MyMPresenceFeatureStub::NewStubL( iSessionCntxtObserver->iPresenceCtx);

   147     

   148        

   149     iPresenceSubService = CVIMPSTEnginePresenceSubService::NewL( 

   150 												        iTestServiceId,

   151 												        *iCchHandler,

   152 												        *iServiceTableFetcher,

   153 												        *iSessionCntxtObserver,

   154 												        *this );

   155     }

   156 

   157 void T_VimpstEnginePresenceSubService::Teardown()

   158     {

   159     tryPresenceSubServiceAvailable = EFalse;

   160    // tryAllSubserviceAvailable = EFalse;

   161     createService = EFalse;

   162     

   163    // gCreateXIMPIdentity = EFalse;

   164    // gPersonPresenceInfoAvailable = EFalse;

   165     

   166     if ( iSessionCntxtObserver )

   167         {

   168         delete iSessionCntxtObserver->iFeatures;

   169 	    iSessionCntxtObserver->iFeatures = NULL;

   170 	    

   171 	    delete iSessionCntxtObserver->iPresenceCtx;

   172 	    iSessionCntxtObserver->iPresenceCtx = NULL;

   173 	    

   174 	    delete iSessionCntxtObserver->iClient;

   175 	    iSessionCntxtObserver->iClient = NULL;

   176 	    

   177 	    delete iSessionCntxtObserver;

   178         iSessionCntxtObserver = NULL;

   179         }

   180    

   181     if ( iPresenceSubService )

   182         {

   183         delete iPresenceSubService;

   184         iPresenceSubService = NULL;

   185         } 

   186     if ( iCchHandler )

   187         {

   188         delete iCchHandler;

   189         iCchHandler = NULL;

   190         }

   191     if ( iServiceTableFetcher )

   192         {

   193         delete iServiceTableFetcher;

   194         iServiceTableFetcher = NULL;

   195         }

   196     

   197    /* if ( gMPresenceInfoStub )

   198         {

   199         delete gMPresenceInfoStub;

   200         gMPresenceInfoStub = NULL;

   201         }*/

   202     }

   203 

   204 TInt T_VimpstEnginePresenceSubService::CreateSpEntryL( TInt aServiceId )

   205     {

   206     CSPSettings* settings = CSPSettings::NewLC();

   207     CSPEntry* entry = CSPEntry::NewLC();

   208     entry->SetServiceId( aServiceId );

   209     CSPEntry* testEntry = CSPEntry::NewLC();

   210     TInt result = settings->FindEntryL( entry->GetServiceId(), *testEntry );

   211     if( result == KErrNone )

   212         {

   213         settings->UpdateEntryL( *entry );

   214         }

   215     else

   216         {

   217         settings->AddEntryL( *entry );

   218         }

   219     TInt createdServiceId = entry->GetServiceId();

   220     CleanupStack::PopAndDestroy( testEntry );

   221     CleanupStack::PopAndDestroy( entry );

   222     CleanupStack::PopAndDestroy( settings );

   223     return createdServiceId;

   224     }   

   225 

   226 void T_VimpstEnginePresenceSubService::T_NewLL()

   227     {

   228     CVIMPSTEnginePresenceSubService* presenceSubService = NULL;

   229     presenceSubService = CVIMPSTEnginePresenceSubService::NewL(

   230         iTestServiceId,

   231         *iCchHandler,

   232         *iServiceTableFetcher,

   233         *iSessionCntxtObserver,

   234         *this);

   235        

   236     EUNIT_ASSERT( presenceSubService != NULL );

   237     delete presenceSubService;

   238     presenceSubService = NULL;

   239     }

   240 

   241 void T_VimpstEnginePresenceSubService::T_SubServiceStateL()

   242     {

   243     RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;

   244     CleanupClosePushL( states );

   245     states.AppendL( TVIMPSTEnums::ESVCENotRegistered );

   246     states.AppendL( TVIMPSTEnums::ESVCERegistered );

   247     states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );

   248     states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );

   249     states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );

   250     states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );

   251     for ( TInt i( 0 ) ; i < states.Count() ; i++ )

   252         {

   253         iPresenceSubService->iServiceState = states[ i ];

   254         EUNIT_ASSERT( states[ i ] == iPresenceSubService->SubServiceState() );

   255         }

   256        

   257     CleanupStack::PopAndDestroy( &states );

   258     }

   259 

   260 void T_VimpstEnginePresenceSubService::T_TypeL()

   261     {    

   262     EUNIT_ASSERT( TVIMPSTEnums::EPresence == iPresenceSubService->Type() );

   263     }

   264 

   265 void T_VimpstEnginePresenceSubService::T_Enabled()

   266     {

   267     // failed

   268     iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCERegistered;

   269     TBool enabled = iPresenceSubService->Enabled();

   270     EUNIT_ASSERT( enabled == ETrue );

   271     

   272     iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCENotRegistered;

   273     enabled = iPresenceSubService->Enabled();

   274     EUNIT_ASSERT( enabled == EFalse );

   275     }

   276 

   277 void T_VimpstEnginePresenceSubService::T_RetrieveSubscribedListLL()

   278     {

   279     TInt error( KErrNone );

   280     gCreateXIMPIdentity = EFalse;

   281     TRAP( error, iPresenceSubService->RetrieveSubscribedListL( ) );

   282     EUNIT_ASSERT( KErrNoMemory == error );

   283     

   284     gCreateXIMPIdentity = ETrue;

   285     TRAP( error, iPresenceSubService->RetrieveSubscribedListL( ) );

   286     EUNIT_ASSERT( KErrNone == error );

   287     }

   288 

   289 void T_VimpstEnginePresenceSubService::T_SubscribePresenceOfSingleContactL()

   290     {

   291     gCreateXIMPIdentity = ETrue;

   292     TRAPD( err, iPresenceSubService->SubscribePresenceOfSingleContactL( KNullDesC ) );

   293     EUNIT_ASSERT( err == KErrArgument );

   294    

   295    	gCreateXIMPIdentity = ETrue;

   296     TRAP( err, iPresenceSubService->SubscribePresenceOfSingleContactL(KTestContactId ) );

   297     EUNIT_ASSERT( KErrNone == err );

   298     }

   299 

   300 void T_VimpstEnginePresenceSubService::T_UnSubscribePresenceOfSingleContactLL()

   301     {

   302     gCreateXIMPIdentity = ETrue;

   303     TRAPD( err, iPresenceSubService->UnSubscribePresenceOfSingleContactL( KTestContactId ) );

   304     EUNIT_ASSERT( KErrNone == err );

   305     }

   306 

   307 void T_VimpstEnginePresenceSubService::T_DoHandlePresentityGroupContentEventLL()

   308 	{

   309 	TInt error( KErrNone );

   310 	MXIMPContext* context = NULL;

   311 	MPresentityGroupContentEventStub presentityGroupContentEvent;

   312 	TRAP( error, iPresenceSubService->DoHandlePresentityGroupContentEventL( 

   313 	 								*context, presentityGroupContentEvent ) );

   314 	EUNIT_ASSERT( KErrNone == error );

   315 

   316 	iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCEUpdatingContacts;

   317 	TRAP( error, iPresenceSubService->DoHandlePresentityGroupContentEventL( 

   318 	 								*context, presentityGroupContentEvent ) );

   319 	EUNIT_ASSERT( KErrNone == error );

   320 	}

   321 

   322 void T_VimpstEnginePresenceSubService::T_DoHandlePresenceBlockListEventL()

   323     {

   324     TInt error( KErrNone );

   325     MXIMPContext* context = NULL;

   326     MPresenceBlockInfoStub presenceblockinfo;

   327   

   328     TRAP( error, iPresenceSubService->DoHandlePresenceBlockListEventL( 

   329                                     *context, presenceblockinfo ) );

   330     

   331     

   332     EUNIT_ASSERT( KErrNone == error );

   333 

   334     iPresenceSubService->iServiceState = TVIMPSTEnums::ESVCEUpdatingContacts;

   335     TRAP( error, iPresenceSubService->DoHandlePresenceBlockListEventL( 

   336                                     *context, presenceblockinfo ) );

   337     

   338  

   339     EUNIT_ASSERT( KErrNone == error );

   340     }

   341 

   342 void T_VimpstEnginePresenceSubService::T_DoHandlePresenceGrantRequestListEventLL()

   343     {

   344     TInt error( KErrNone );

   345     MXIMPContext* context = NULL;

   346     MPresenceGrantRequestListEventStub presenceGrantRequestListEventStub;

   347     ::gNewRequestsCountValue = 1;

   348     ::gCurrentRequestsCountValue = 1;

   349     

   350     TRAP( error, iPresenceSubService->DoHandlePresenceGrantRequestListEventL( 

   351         *context, presenceGrantRequestListEventStub ) );

   352     ::gNewRequestsCountValue = KErrNone;

   353     ::gCurrentRequestsCountValue = KErrNone;

   354     EUNIT_ASSERT( KErrNone == error );

   355     }

   356 

   357 

   358 void T_VimpstEnginePresenceSubService::T_ResolveServiceStateLL()

   359     {

   360     TInt error( KErrNotFound );

   361     RArray<TCCHSubserviceState> subServiceStates;   

   362     CleanupClosePushL( subServiceStates );

   363     subServiceStates.AppendL( ECCHUninitialized );

   364     subServiceStates.AppendL( ECCHDisabled );

   365     subServiceStates.AppendL( ECCHConnecting );

   366     subServiceStates.AppendL( ECCHEnabled );

   367     subServiceStates.AppendL( ECCHDisconnecting );

   368     // Test with service error: KErrNone and all subservice states.

   369     TInt serviceError( KErrNone );

   370     for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

   371         {

   372         TRAP( error, iPresenceSubService->ResolveServiceStateL( 

   373             	subServiceStates[ i ], serviceError ) );

   374         EUNIT_ASSERT( KErrNone == error );

   375         }

   376               

   377     // Test with service error: KErrNotFound and all subservice states.

   378     serviceError = KErrNotFound;

   379     TRAP( error, iPresenceSubService->ResolveServiceStateL( 

   380             	ECCHDisconnecting, serviceError ) );

   381     EUNIT_ASSERT( KErrNone == error );

   382            

   383     CleanupStack::PopAndDestroy( &subServiceStates );

   384     }

   385 

   386 void T_VimpstEnginePresenceSubService::T_CchEventOccuredLL()

   387     {

   388     TInt error( KErrNotFound );

   389     RArray<TCCHSubserviceState> subServiceStates;   

   390     CleanupClosePushL( subServiceStates );

   391     subServiceStates.AppendL( ECCHUninitialized );

   392     subServiceStates.AppendL( ECCHDisabled );

   393     subServiceStates.AppendL( ECCHConnecting );

   394     subServiceStates.AppendL( ECCHEnabled );

   395     subServiceStates.AppendL( ECCHDisconnecting );

   396    // Test with service error: KErrNone and all subservice states.

   397     TInt serviceError( KErrNone );

   398     for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )

   399         {

   400         TRAP( error, iPresenceSubService->CchEventOccuredL( 

   401             iTestServiceId, subServiceStates[ i ], serviceError ) );

   402         EUNIT_ASSERT( KErrNone == error );

   403         }

   404     // Test with service error: KErrNotFound and all subservice states.

   405     serviceError = KErrNotFound;

   406     for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )

   407         {

   408         TRAP( error, iPresenceSubService->CchEventOccuredL( 

   409             iTestServiceId, subServiceStates[ j ], serviceError ) );

   410         EUNIT_ASSERT( KErrNone == error );

   411         }

   412     CleanupStack::PopAndDestroy( &subServiceStates );

   413     EUNIT_ASSERT( KErrNone == error );

   414     }

   415 

   416 void T_VimpstEnginePresenceSubService::T_DoHandleCchErrorLL()

   417     {

   418     RArray<TInt> serviceErrors;

   419     CleanupClosePushL( serviceErrors );

   420     serviceErrors.AppendL( KErrGeneral ); // Tests default case

   421     serviceErrors.AppendL( KCCHErrorBandwidthInsufficient );

   422     serviceErrors.AppendL( KCCHErrorInvalidIap );

   423     serviceErrors.AppendL( KCCHErrorAuthenticationFailed );

   424     serviceErrors.AppendL( KCCHErrorNetworkLost );

   425     serviceErrors.AppendL( KCCHErrorLoginFailed );

   426     serviceErrors.AppendL( KCCHErrorServiceNotResponding );

   427     serviceErrors.AppendL( KCCHErrorInvalidSettings );

   428     serviceErrors.AppendL( KCCHErrorAccessPointNotDefined );

   429     for ( TInt i( 0 ) ; i < serviceErrors.Count() ; i++ )

   430         {

   431         TRAPD( err, iPresenceSubService->DoHandleCchErrorL( 

   432             serviceErrors[ i ] ) );

   433         EUNIT_ASSERT( KErrNone == err );

   434         }

   435     CleanupStack::PopAndDestroy( &serviceErrors );

   436     }

   437 

   438 

   439 void T_VimpstEnginePresenceSubService::T_PublishOwnPresenceLL()

   440     {

   441     RArray<TVIMPSTEnums::TOnlineStatus> onlineStatusArray;

   442     CleanupClosePushL( onlineStatusArray );

   443     onlineStatusArray.AppendL( TVIMPSTEnums::EUnknown );

   444  //   onlineStatusArray.AppendL( TVIMPSTEnums::EOffline );

   445  //   onlineStatusArray.AppendL( TVIMPSTEnums::EOnline );

   446  //   onlineStatusArray.AppendL( TVIMPSTEnums::EInvisible );

   447  //   onlineStatusArray.AppendL( TVIMPSTEnums::EAway );

   448  //   onlineStatusArray.AppendL( TVIMPSTEnums::EBusy );

   449     for ( TInt i( 0 ); i < onlineStatusArray.Count() ; i++ )

   450         {

   451         TRAPD( err, iPresenceSubService->PublishOwnPresenceL( 

   452             onlineStatusArray[ i ], KTestStatusText ) );

   453         EUNIT_ASSERT( KErrNone == err );

   454         }

   455     CleanupStack::PopAndDestroy( &onlineStatusArray );

   456     }

   457 

   458 void T_VimpstEnginePresenceSubService::T_ConvertPresenceStatus()

   459     {

   460     EUNIT_ASSERT( NPresenceInfo::ENotAvailable == 

   461         iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EOffline ) );

   462     

   463     EUNIT_ASSERT( NPresenceInfo::EAvailable == 

   464             iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EOnline ) );

   465     

   466     EUNIT_ASSERT( NPresenceInfo::EHidden == 

   467             iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EInvisible ) );

   468     

   469     EUNIT_ASSERT( NPresenceInfo::EAway == 

   470             iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EAway ) );

   471     

   472     EUNIT_ASSERT( NPresenceInfo::EBusy == 

   473             iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EBusy ) );

   474     

   475     EUNIT_ASSERT( NPresenceInfo::ENotAvailable == 

   476                 iPresenceSubService->ConvertPresenceStatus( TVIMPSTEnums::EUnknown ) );

   477     }

   478 /*

   479 void T_VimpstEnginePresenceSubService::T_FetchPresenceFormCacheL()

   480     {

   481     TInt error = iPresenceSubService->FetchPresenceFormCache();

   482     EUNIT_ASSERT( KErrNone == error );

   483     

   484     gAllBuddiesPresenceInServiceError = KErrBadHandle;

   485     error = iPresenceSubService->FetchPresenceFormCache();

   486     EUNIT_ASSERT( KErrBadHandle == error );

   487     

   488     delete iPresenceSubService->iServiceName;

   489     iPresenceSubService->iServiceName = NULL;

   490     error = iPresenceSubService->FetchPresenceFormCache();

   491     EUNIT_ASSERT( KErrArgument == error );

   492    

   493     }

   494 */

   495 void T_VimpstEnginePresenceSubService::T_HandlePresenceReadLL()

   496     {

   497     TInt error( KErrNone );

   498     TInt testError( KErrGeneral );

   499     

   500     tryConnParamWithSuccess = ETrue;

   501     

   502     RPointerArray< MPresenceBuddyInfo2> buddyInfoList;

   503     TRAP( error, iPresenceSubService->HandlePresenceReadL( 

   504         testError, buddyInfoList ) );

   505     EUNIT_ASSERT( KErrNone == error );

   506     

   507     CleanupClosePushL( buddyInfoList );

   508     MPresenceBuddyInfo2Stub* buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

   509     CleanupDeletePushL( buddyInfo1 );

   510     MPresenceBuddyInfo2Stub* buddyInfo2 = MPresenceBuddyInfo2Stub::NewStubL();

   511     CleanupDeletePushL( buddyInfo2 );

   512     MPresenceBuddyInfo2Stub* buddyInfo3 = MPresenceBuddyInfo2Stub::NewStubL();

   513     CleanupDeletePushL( buddyInfo3 );

   514     

   515     buddyInfoList.AppendL( buddyInfo1 );

   516     buddyInfoList.AppendL( buddyInfo2 );

   517     buddyInfoList.AppendL( buddyInfo3 );

   518     testError = KErrNone;

   519     TRAP( error, iPresenceSubService->HandlePresenceReadL( 

   520         testError, buddyInfoList ) );

   521     EUNIT_ASSERT( KErrNone == error );

   522   

   523     CleanupStack::Pop(3); //buddyInfo1,2,3 just pop since ownership is tranferred

   524     

   525     tryConnParamWithSuccess = EFalse;

   526     tryParamTomatchOwnId = ETrue;

   527 

   528     testError = KErrNone;

   529     buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

   530     CleanupDeletePushL( buddyInfo1 );

   531     buddyInfoList.AppendL( buddyInfo1 );

   532    

   533     TRAP( error, iPresenceSubService->HandlePresenceReadL( 

   534             testError, buddyInfoList ) ); // buddyInfo : ownership transferred 

   535     EUNIT_ASSERT( KErrNone == error );

   536     CleanupStack::Pop(2); //buddyInfoList,buddyInfo1

   537     }

   538 /*

   539 void T_VimpstEnginePresenceSubService::T_SubscribeToPresenceCacheLL()

   540     {

   541     TRAPD( err, iPresenceSubService->SubscribeToPresenceCacheL( 

   542         KTestContactId ) );

   543     EUNIT_ASSERT( KErrNone == err );

   544     

   545     TRAP( err, iPresenceSubService->SubscribeToPresenceCacheL( 

   546         KNullDesC ) );

   547     EUNIT_ASSERT( KErrArgument == err );

   548    

   549     }*/

   550 

   551 

   552 void T_VimpstEnginePresenceSubService::T_HandlePresenceNotificationLL()

   553     {

   554     tryConnParamWithSuccess = ETrue;

   555     TInt error( KErrNone );

   556     MPresenceBuddyInfo2Stub* buddyInfo = NULL;

   557     TInt testError( KErrGeneral );

   558     TRAP( error, iPresenceSubService->HandlePresenceNotificationL( 

   559         testError, buddyInfo ) );

   560     EUNIT_ASSERT( KErrNone == error );

   561      

   562     testError = KErrNone;

   563     buddyInfo = MPresenceBuddyInfo2Stub::NewStubL();

   564     TRAP( error, iPresenceSubService->HandlePresenceNotificationL( 

   565         testError, buddyInfo ) ); // buddyInfo : ownership transferred 

   566     EUNIT_ASSERT( KErrNone == error );

   567     tryConnParamWithSuccess = EFalse;

   568     tryParamTomatchOwnId = ETrue;

   569     

   570     testError = KErrNone;

   571     buddyInfo = MPresenceBuddyInfo2Stub::NewStubL();

   572     TRAP( error, iPresenceSubService->HandlePresenceNotificationL( 

   573             testError, buddyInfo ) ); // buddyInfo : ownership transferred 

   574     EUNIT_ASSERT( KErrNone == error );

   575    

   576     }

   577 

   578 void T_VimpstEnginePresenceSubService::T_UnSubscribeForAuthorizationLL()

   579     {

   580     TRAPD( err, iPresenceSubService->UnsubscribeListsL() );

   581     EUNIT_ASSERT( KErrNone == err );

   582     }

   583 

   584 void T_VimpstEnginePresenceSubService::T_SubscribeForAuthorizationLL()

   585     {

   586     TRAPD( err, iPresenceSubService->SubscribeForAuthorizationL() );

   587     EUNIT_ASSERT( KErrNone == err );

   588     }

   589 

   590 void T_VimpstEnginePresenceSubService::T_SendPresenceGrantPresentityLL()

   591     {

   592     gCreateXIMPIdentity = EFalse;

   593     TInt error( KErrNone );

   594     TRAP( error, iPresenceSubService->SendPresenceGrantPresentityL( 

   595         KTestContactId, EFalse ) );

   596     EUNIT_ASSERT( KErrNoMemory == error );

   597     

   598     gCreateXIMPIdentity = ETrue;

   599     TRAP( error, iPresenceSubService->SendPresenceGrantPresentityL( 

   600         KNullDesC, EFalse ) );

   601     EUNIT_ASSERT( KErrArgument == error );

   602     

   603 	TRAP( error, iPresenceSubService->SendPresenceGrantPresentityL( 

   604         KTestContactId, EFalse ) );

   605     EUNIT_ASSERT( KErrNone == error );

   606     

   607     TRAP( error, iPresenceSubService->SendPresenceGrantPresentityL( 

   608         KTestContactId, ETrue ) );

   609     EUNIT_ASSERT( KErrNone == error );

   610     }

   611 

   612 void T_VimpstEnginePresenceSubService::T_HandleSessionContextEventLL()

   613     {

   614     // failed

   615     gCreateXIMPIdentity = ETrue;

   616     MXIMPContext* context = NULL;

   617     //Test with MXIMPRequestCompleteEvent: HandleXimpRequestCompleteL

   618     MXIMPRequestCompleteEventStub requestCompleteEvent;

   619     ::gMXIMPRequestCompleteEventStubInterfaceId = MXIMPRequestCompleteEvent::KInterfaceId;

   620     TInt error( KErrNone );

   621   

   622     RArray<TXimpOperation> ximpOperation;   

   623     CleanupClosePushL( ximpOperation );

   624     ximpOperation.AppendL( EVIMPSTXimpOperationNoOperation );

   625     ximpOperation.AppendL( EVIMPSTXimpOperationBind );

   626     ximpOperation.AppendL( EVIMPSTXimpOperationUnBind );

   627     ximpOperation.AppendL( EVIMPSTXimpOperationGetSubscribedList );

   628     ximpOperation.AppendL( EVIMPSTXimpOperationGetBlockList );

   629     ximpOperation.AppendL( EVIMPSTXimpOperationGetPresenceGrantList );

   630     ximpOperation.AppendL( EVIMPSTXimpOperationGetWatcherList );

   631     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeWatcherList );

   632     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeGrantRequestList );

   633     ximpOperation.AppendL( EVIMPSTXimpOperationSubcribeGrantRequestList );

   634     ximpOperation.AppendL( EVIMPSTXimpOperationWithdrawPresenceGrant );

   635     ximpOperation.AppendL( EVIMPSTXimpOperationGrantPresenceForPresentity );

   636     ximpOperation.AppendL( EVIMPSTXimpOperationCancelPresenceBlockFromPresentity );

   637     ximpOperation.AppendL( EVIMPSTXimpOperationBlockPresenceForPresentity );

   638     ximpOperation.AppendL( EVIMPSTXimpOperationPublisOwnPresence );

   639     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribe );

   640     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubscribe );

   641     ximpOperation.AppendL( EVIMPSTXimpOperationAddContact );

   642     ximpOperation.AppendL( EVIMPSTXimpOperationDeleteContact );

   643     ximpOperation.AppendL( EVIMPSTXimpOperationSearchContact );

   644     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribeSearchKeys );

   645     

   646     // Test with error code: KErrNone and all operations.

   647     ::gRequestCompleteEventResultCodeKerrNotSupported = ETrue;

   648      for ( TInt i( 0 ) ; i < ximpOperation.Count() ; i++ )

   649         {

   650         TRAP( error, iPresenceSubService->HandleSessionContextEventL(

   651                 *context, requestCompleteEvent, ximpOperation[ i ] ) );

   652         EUNIT_ASSERT( KErrNone == error );

   653         }

   654               

   655     ::gRequestCompleteEventResultCodeKerrNotSupported = EFalse;

   656     for ( TInt j( 0 ) ; j < ximpOperation.Count() ; j++ )

   657         {

   658         TRAP( error, iPresenceSubService->HandleSessionContextEventL( 

   659                 *context, requestCompleteEvent, ximpOperation[ j ] ) );

   660         EUNIT_ASSERT( KErrNone == error );

   661         }

   662     //Test with MXIMPContextStateEvent

   663     MXIMPContextStateEventStub contextStateEvent;

   664     ::gMXIMPContextStateEventStubInterfaceId = MXIMPContextStateEvent::KInterfaceId;

   665     TRAP( error, iPresenceSubService->HandleSessionContextEventL( 

   666             *context, contextStateEvent, ximpOperation[ 0 ] ) );

   667      EUNIT_ASSERT( KErrNone == error );  

   668        

   669     //Test with MPresentityGroupContentEvent: DoHandlePresentityGroupContentEventL( aContext, aEvent )

   670     MPresentityGroupContentEventStub presentityGroupContentEvent;

   671     ::gMXIMPPresentityGroupEventStubInterfaceId = 

   672             MPresentityGroupContentEvent::KInterfaceId;

   673     TRAP( error, iPresenceSubService->HandleSessionContextEventL( 

   674             *context, presentityGroupContentEvent, ximpOperation[ 0 ] ) );

   675     EUNIT_ASSERT( KErrNone == error );

   676     

   677     //Test with MPresenceGrantRequestListEvent: DoHandlePresenceGrantRequestListEventL( aContext, aEvent )

   678     MPresenceGrantRequestListEventStub presenceGrantRequestListEventStub;

   679     ::gMXIMPPresenceGrantRequestListEventStubInterfaceId = 

   680             MPresenceGrantRequestListEvent::KInterfaceId;

   681     TRAP( error, iPresenceSubService->HandleSessionContextEventL( 

   682             *context, presenceGrantRequestListEventStub, ximpOperation[ 0 ] ) );

   683     EUNIT_ASSERT( KErrNone == error );

   684     

   685     CleanupStack::PopAndDestroy( &ximpOperation );

   686     }

   687 

   688 void T_VimpstEnginePresenceSubService::T_HandleListEventCompleteLL()

   689     {

   690     // failed

   691     gCreateXIMPIdentity = ETrue;

   692     TInt error( KErrNone );

   693     RArray<TXimpOperation> ximpOperation;   

   694     CleanupClosePushL( ximpOperation );

   695     

   696     ximpOperation.AppendL( EVIMPSTXimpOperationNoOperation );

   697     ximpOperation.AppendL( EVIMPSTXimpOperationBind );

   698     ximpOperation.AppendL( EVIMPSTXimpOperationUnBind );

   699     ximpOperation.AppendL( EVIMPSTXimpOperationGetSubscribedList );

   700     ximpOperation.AppendL( EVIMPSTXimpOperationGetBlockList );

   701     ximpOperation.AppendL( EVIMPSTXimpOperationGetPresenceGrantList );

   702     ximpOperation.AppendL( EVIMPSTXimpOperationGetWatcherList );

   703     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeWatcherList );

   704     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeGrantRequestList );

   705     ximpOperation.AppendL( EVIMPSTXimpOperationSubcribeGrantRequestList );

   706     ximpOperation.AppendL( EVIMPSTXimpOperationWithdrawPresenceGrant );

   707     ximpOperation.AppendL( EVIMPSTXimpOperationGrantPresenceForPresentity );

   708     ximpOperation.AppendL( EVIMPSTXimpOperationCancelPresenceBlockFromPresentity );

   709     ximpOperation.AppendL( EVIMPSTXimpOperationBlockPresenceForPresentity );

   710     ximpOperation.AppendL( EVIMPSTXimpOperationPublisOwnPresence );

   711     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribe );

   712     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubscribe );

   713     ximpOperation.AppendL( EVIMPSTXimpOperationAddContact );

   714     ximpOperation.AppendL( EVIMPSTXimpOperationDeleteContact );

   715     ximpOperation.AppendL( EVIMPSTXimpOperationSearchContact );

   716     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribeSearchKeys );

   717     

   718     MXIMPRequestCompleteEventStub requestCompleteEvent;

   719      // Test with error code: KErrNone and all operations.

   720     TInt errorCode( KErrNone );

   721     for ( TInt i( 0 ) ; i < ximpOperation.Count() ; i++ )

   722         {

   723         TRAP( error, iPresenceSubService->HandleListEventCompleteL( 

   724                 ximpOperation[ i ], errorCode, requestCompleteEvent ) );

   725         EUNIT_ASSERT( KErrNone == error );

   726         }

   727      // Test with random error code

   728     errorCode = KErrGeneral;

   729     for ( TInt j( 0 ) ; j < ximpOperation.Count() ; j++ )

   730         {

   731         TRAP( error, iPresenceSubService->HandleListEventCompleteL( 

   732                 ximpOperation[ j ], errorCode, requestCompleteEvent ) );

   733         EUNIT_ASSERT( KErrNone == error );

   734         }

   735     CleanupStack::PopAndDestroy( &ximpOperation );

   736     EUNIT_ASSERT( KErrNone == error );

   737     }

   738 

   739 void T_VimpstEnginePresenceSubService::T_HandleXimpRequestCompleteLL()

   740     {

   741     // failed

   742     gCreateXIMPIdentity = ETrue;

   743      //Test with MXIMPRequestCompleteEvent: HandleXimpRequestCompleteL

   744     MXIMPRequestCompleteEventStub requestCompleteEvent;

   745     ::gMXIMPRequestCompleteEventStubInterfaceId = MXIMPRequestCompleteEvent::KInterfaceId;

   746     TInt error( KErrNone );

   747     RArray<TXimpOperation> ximpOperation;   

   748     CleanupClosePushL( ximpOperation );

   749     

   750     ximpOperation.AppendL( EVIMPSTXimpOperationNoOperation );

   751     ximpOperation.AppendL( EVIMPSTXimpOperationBind );

   752     ximpOperation.AppendL( EVIMPSTXimpOperationUnBind );

   753     ximpOperation.AppendL( EVIMPSTXimpOperationGetSubscribedList );

   754     ximpOperation.AppendL( EVIMPSTXimpOperationGetBlockList );

   755     ximpOperation.AppendL( EVIMPSTXimpOperationGetPresenceGrantList );

   756     ximpOperation.AppendL( EVIMPSTXimpOperationGetWatcherList );

   757     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeWatcherList );

   758     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubcribeGrantRequestList );

   759     ximpOperation.AppendL( EVIMPSTXimpOperationSubcribeGrantRequestList );

   760     ximpOperation.AppendL( EVIMPSTXimpOperationWithdrawPresenceGrant );

   761     ximpOperation.AppendL( EVIMPSTXimpOperationGrantPresenceForPresentity );

   762     ximpOperation.AppendL( EVIMPSTXimpOperationCancelPresenceBlockFromPresentity );

   763     ximpOperation.AppendL( EVIMPSTXimpOperationBlockPresenceForPresentity );

   764     ximpOperation.AppendL( EVIMPSTXimpOperationPublisOwnPresence );

   765     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribe );

   766     ximpOperation.AppendL( EVIMPSTXimpOperationUnsubscribe );

   767     ximpOperation.AppendL( EVIMPSTXimpOperationAddContact );

   768     ximpOperation.AppendL( EVIMPSTXimpOperationDeleteContact );

   769     ximpOperation.AppendL( EVIMPSTXimpOperationSearchContact );

   770     ximpOperation.AppendL( EVIMPSTXimpOperationSubscribeSearchKeys );

   771       

   772     // Test with error code: KErrNone and all operations.

   773     ::gRequestCompleteEventResultCodeKerrNotSupported = ETrue;

   774      // Test with KErrNone

   775     TInt testError( KErrNone ); 

   776     for ( TInt i( 0 ) ; i < ximpOperation.Count() ; i++ )

   777           {

   778           TRAP( error, iPresenceSubService->HandleXimpRequestCompleteL(

   779                   ximpOperation[ i ], testError, requestCompleteEvent ) );

   780           EUNIT_ASSERT( KErrNone == error );

   781           }

   782                 

   783     // Test with random error code

   784     testError = KErrGeneral;

   785     for ( TInt j( 0 ) ; j < ximpOperation.Count() ; j++ )

   786         {

   787         TRAP( error, iPresenceSubService->HandleXimpRequestCompleteL(

   788             ximpOperation[ j ], testError, requestCompleteEvent ) );

   789         EUNIT_ASSERT( KErrNone == error );

   790         }

   791      CleanupStack::PopAndDestroy( &ximpOperation );

   792      EUNIT_ASSERT( KErrNone == error );

   793     }

   794 

   795 void T_VimpstEnginePresenceSubService::T_StoreToVirtualStoreLL()

   796     {

   797     MPresentityGroupContentEventStub presentityGroupContentEvent;

   798     TRAPD( err, iPresenceSubService->StoreToVirtualStoreL( presentityGroupContentEvent ) );

   799     EUNIT_ASSERT( KErrNone == err );

   800     }

   801 

   802 void T_VimpstEnginePresenceSubService::T_IsChangeOwnStatusSupportedL()

   803     {

   804     iPresenceSubService->iChangeStatusSupported = EFalse;

   805     TBool supported =

   806         iPresenceSubService->IsChangeOwnStatusSupported();

   807     EUNIT_ASSERT( EFalse == supported );

   808     

   809     iPresenceSubService->iChangeStatusSupported = ETrue;

   810     supported =

   811         iPresenceSubService->IsChangeOwnStatusSupported();

   812     EUNIT_ASSERT( ETrue == supported );

   813     }

   814 

   815 void T_VimpstEnginePresenceSubService::T_IsStatusMsgSupportedL()

   816     {

   817     iPresenceSubService->iChangeStatusMsgSupported = EFalse;

   818     TBool supported =

   819         iPresenceSubService->IsStatusMsgSupported();

   820     EUNIT_ASSERT( EFalse == supported );

   821     

   822     iPresenceSubService->iChangeStatusMsgSupported = ETrue;

   823     supported =

   824         iPresenceSubService->IsStatusMsgSupported();

   825     EUNIT_ASSERT( ETrue == supported );

   826     }

   827 

   828 void T_VimpstEnginePresenceSubService::T_ConvertXimpToClientPresenceStatusL()

   829     {

   830     RArray<MPresenceBuddyInfo2::TAvailabilityValues> presenceInfo;

   831    // CleanupStack::PushL(&presenceInfo);

   832     CleanupClosePushL( presenceInfo );

   833     presenceInfo.AppendL( MPresenceBuddyInfo2::EUnknownAvailability );

   834     presenceInfo.AppendL( MPresenceBuddyInfo2::ENotAvailable );

   835     presenceInfo.AppendL( MPresenceBuddyInfo2::EBusy );

   836     presenceInfo.AppendL( MPresenceBuddyInfo2::EAvailable );

   837     

   838     RPointerArray<HBufC>    availabilityTextArray; 

   839    // CleanupStack::PushL(&availabilityTextArray);

   840     CleanupClosePushL( availabilityTextArray );

   841 

   842     availabilityTextArray.Append(KBlockedState().AllocL());

   843     availabilityTextArray.Append(KInvisibleState().AllocL());

   844     availabilityTextArray.Append(KAwayState().AllocL());

   845     availabilityTextArray.Append(KOnPhoneState().AllocL());

   846     availabilityTextArray.Append(KDndState().AllocL());

   847     

   848     TInt error( KErrNone );

   849     for ( TInt i( 0 ) ; i < presenceInfo.Count() ; i++ )

   850         {

   851         if(MPresenceBuddyInfo2::EBusy == presenceInfo[i])

   852             {

   853             for(TInt j = 0; j < availabilityTextArray.Count(); j++)

   854                 {

   855                 TRAP( error, iPresenceSubService->ConvertPresenceCacheEnums( 

   856                                presenceInfo[ i ], availabilityTextArray[i]->Des()));

   857                 }

   858             }

   859         else

   860             {

   861             TRAP( error, iPresenceSubService->ConvertPresenceCacheEnums( 

   862                             presenceInfo[ i ], KNullDesC()));

   863             }

   864         

   865         EUNIT_ASSERT( KErrNone == error );

   866         }

   867     //CleanupStack::PopAndDestroy(&availabilityTextArray);

   868     //CleanupStack::PopAndDestroy( &presenceInfo );

   869     CleanupStack::PopAndDestroy();

   870     CleanupStack::PopAndDestroy();

   871     EUNIT_ASSERT( KErrNone == error );

   872     }

   873 /*

   874 void T_VimpstEnginePresenceSubService::T_RegisterPresenceEventObserverL()

   875     {

   876     MyPresenceSubServiceEventObserverStub* observerNull = NULL ;

   877     TRAPD( error, iPresenceSubService->RegisterPresenceEventObserverL( observerNull ) );    

   878     EUNIT_ASSERT( KErrArgument == error );

   879    

   880    	MyPresenceSubServiceEventObserverStub* observer = MyPresenceSubServiceEventObserverStub::NewL() ;

   881     TRAP( error, iPresenceSubService->RegisterPresenceEventObserverL( observer ) );    

   882     EUNIT_ASSERT( KErrNone == error );

   883     EUNIT_ASSERT( iPresenceSubService->iObserverArray.Count() == 1 );

   884     // Try to register same observer again

   885     iPresenceSubService->RegisterPresenceEventObserverL( observer );    

   886     EUNIT_ASSERT( iPresenceSubService->iObserverArray.Count() == 1 );

   887     delete observer;

   888     }

   889 */

   890 /*

   891 void T_VimpstEnginePresenceSubService::T_UnRegisterPresenceEventObserverL()

   892     {

   893     MyPresenceSubServiceEventObserverStub* observerNull = NULL ;

   894     TRAPD( error, iPresenceSubService->RegisterPresenceEventObserverL( observerNull ) );

   895     EUNIT_ASSERT( KErrArgument == error );

   896     

   897     MyPresenceSubServiceEventObserverStub* observer  = MyPresenceSubServiceEventObserverStub::NewL() ;

   898     TRAP( error, iPresenceSubService->RegisterPresenceEventObserverL( observer ) );    

   899     EUNIT_ASSERT( KErrNone == error );

   900     TRAP(error, iPresenceSubService->RegisterPresenceEventObserverL( observer ) );

   901     EUNIT_ASSERT( KErrNone == error );

   902   

   903     iPresenceSubService->UnRegisterPresenceEventObserver( observer );

   904     EUNIT_ASSERT( iPresenceSubService->iObserverArray.Count() == 0 ); 

   905     

   906     // Try to unregister same observer again

   907     iPresenceSubService->UnRegisterPresenceEventObserver ( observer );

   908     EUNIT_ASSERT( iPresenceSubService->iObserverArray.Count() == 0 );

   909     delete observer; 

   910     }

   911 */

   912 void T_VimpstEnginePresenceSubService::T_AddToBlockListL()

   913     {

   914     _LIT(KDummyUserID,"dummy@domian.com");

   915     TRAPD( err, iPresenceSubService->AddToBlockListL(KDummyUserID) );

   916            EUNIT_ASSERT( KErrNone == err );

   917     }

   918 

   919 void T_VimpstEnginePresenceSubService::T_AddToBlockListL_NoUserid()

   920     {

   921        TRAPD( err, iPresenceSubService->AddToBlockListL(KNullDesC()) );

   922               EUNIT_ASSERT( KErrNone == err );

   923     }

   924 

   925 void T_VimpstEnginePresenceSubService::T_AddToBlockListL_NoDomainNameL()

   926     {

   927     _LIT(KDummyUserID,"dummy");

   928     TRAPD( err, iPresenceSubService->AddToBlockListL(KDummyUserID) );

   929                   EUNIT_ASSERT( KErrNone == err );

   930     }

   931 

   932 void T_VimpstEnginePresenceSubService::T_RemoveFromBlockListL()

   933     {

   934     _LIT(KDummyUserID,"dummy@domian.com");

   935       TRAPD( err, iPresenceSubService->RemoveFromBlockListL(KDummyUserID) );

   936              EUNIT_ASSERT( KErrNone == err );

   937     }

   938 

   939 void T_VimpstEnginePresenceSubService::T_RemoveFromBlockListMgr()

   940     {

   941     _LIT(KID1,"id1@xyz.com");

   942     _LIT(KID2,"id2@xyz.com");

   943     _LIT(KID3,"id3@xyz.com");

   944     _LIT(KID4,"id4@xyz.com");

   945     iPresenceSubService->ResetBlockedListManagerL();

   946     if(iPresenceSubService->iBlockedListMgr)

   947 	    {

   948 	    iPresenceSubService->iBlockedListMgr->AddToBlockedListL(KID1);

   949 	    iPresenceSubService->iBlockedListMgr->AddToBlockedListL(KID2);

   950 	    iPresenceSubService->iBlockedListMgr->AddToBlockedListL(KID3);

   951 	    iPresenceSubService->iBlockedListMgr->AddToBlockedListL(KID4);

   952 		EUNIT_ASSERT( 4 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   953 		iPresenceSubService->iBlockedListMgr->RemoveFromBlockListL(KID2);

   954 		EUNIT_ASSERT( 3 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   955 		iPresenceSubService->iBlockedListMgr->RemoveFromBlockListL(KID1);

   956 		EUNIT_ASSERT( 2 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   957 		iPresenceSubService->iBlockedListMgr->RemoveFromBlockListL(KID3);

   958 		EUNIT_ASSERT( 1 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   959 		iPresenceSubService->iBlockedListMgr->RemoveFromBlockListL(KID4);

   960 		EUNIT_ASSERT( 0 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   961 		iPresenceSubService->iBlockedListMgr->RemoveFromBlockListL(KID4);

   962 		EUNIT_ASSERT( 0 == iPresenceSubService->iBlockedListMgr->iBlockedList.Count() );

   963 	    }

   964     }

   965     

   966 void T_VimpstEnginePresenceSubService::T_FetchBlockedListFromServer()

   967 	{

   968 	iPresenceSubService->FetchBlockedListFromServerL(NULL);

   969 	EUNIT_ASSERT(iPresenceSubService->iBlockListFetchReqPending == ETrue );

   970 	EUNIT_ASSERT(iPresenceSubService->iBlockedListObserver == NULL)

   971 	}

   972 	

   973 void T_VimpstEnginePresenceSubService::T_RemoveFromBlockList_NoUseridL()

   974     {

   975       TRAPD( err, iPresenceSubService->RemoveFromBlockListL(KNullDesC()) );

   976              EUNIT_ASSERT( KErrNone == err );

   977     }

   978 

   979 void T_VimpstEnginePresenceSubService::T_RemoveFromBlockList_NoDomainNameL()

   980     {

   981     _LIT(KDummyUserID,"dummy");

   982       TRAPD( err, iPresenceSubService->RemoveFromBlockListL(KDummyUserID) );

   983              EUNIT_ASSERT( KErrNone == err );

   984     }

   985 

   986 void T_VimpstEnginePresenceSubService::T_GetKeyFiledsAndValuesStatusPendingL()

   987     {

   988     TVIMPSTEnums::TOnlineStatus status = TVIMPSTEnums::EUnknown;

   989     MPresenceBuddyInfo2Stub* buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

   990     buddyInfo1->SetAnyFieldL(KExtensionKey,KPendingRequestExtensionValue);

   991     //set the setanyfield to pending and get that status 

   992     TRAPD( error, iPresenceSubService->GetKeyFieldsAndValuesL(*buddyInfo1,status) ); 

   993     EUNIT_ASSERT(TVIMPSTEnums::EPending  == status  ) ;

   994     

   995     }

   996 

   997 void T_VimpstEnginePresenceSubService::T_GetKeyFiledsAndValuesStatusBlockedL()

   998     {

   999     TVIMPSTEnums::TOnlineStatus status = TVIMPSTEnums::EUnknown;

  1000     MPresenceBuddyInfo2Stub* buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

  1001     buddyInfo1->SetAnyFieldL(KExtensionKey,KBlockedExtensionValue);

  1002     //set the setanyfield to pending and get that status 

  1003     TRAPD( error, iPresenceSubService->GetKeyFieldsAndValuesL(*buddyInfo1,status) ); 

  1004     EUNIT_ASSERT(TVIMPSTEnums::EBlocked  == status  ) ;

  1005     

  1006     }

  1007 

  1008 void T_VimpstEnginePresenceSubService::T_GetKeyFiledsAndValuesStatusUnknownL()

  1009     {

  1010     TVIMPSTEnums::TOnlineStatus status = TVIMPSTEnums::EUnknown;

  1011     MPresenceBuddyInfo2Stub* buddyInfo1 = MPresenceBuddyInfo2Stub::NewStubL();

  1012     //set the setanyfield to pending and get that status 

  1013     TRAPD( error, iPresenceSubService->GetKeyFieldsAndValuesL(*buddyInfo1,status ) ); 

  1014     EUNIT_ASSERT(TVIMPSTEnums::EUnknown == status  ) ;

  1015     

  1016     }

  1017 EUNIT_BEGIN_TEST_TABLE( T_VimpstEnginePresenceSubService, "T_VimpstEnginePresenceSubService", "" )

  1018 

  1019 EUNIT_TEST(

  1020     "NewL - test ",

  1021     "T_VimpstEnginePresenceSubService",

  1022     "NewL",

  1023     "FUNCTIONALITY",

  1024     SetupL, T_NewLL, Teardown)

  1025 

  1026 EUNIT_TEST(

  1027     "SubServiceStateL - test ",

  1028     "T_VimpstEnginePresenceSubService",

  1029     "SubServiceStateL",

  1030     "FUNCTIONALITY",

  1031     SetupL, T_SubServiceStateL, Teardown)

  1032 

  1033 EUNIT_TEST(

  1034     "Type - test ",

  1035     "T_VimpstEnginePresenceSubService",

  1036     "Type",

  1037     "FUNCTIONALITY",

  1038     SetupL, T_TypeL, Teardown)

  1039 

  1040 EUNIT_TEST(

  1041     "Enabled - test ",

  1042     "T_VimpstEnginePresenceSubService",

  1043     "Enabled",

  1044     "FUNCTIONALITY",

  1045     SetupL, T_Enabled, Teardown)

  1046 

  1047 EUNIT_TEST(

  1048     "RetrieveSubscribedListL - test ",

  1049     "T_VimpstEnginePresenceSubService",

  1050     "RetrieveSubscribedListL",

  1051     "FUNCTIONALITY",

  1052     SetupL, T_RetrieveSubscribedListLL, Teardown)

  1053     

  1054 EUNIT_TEST(

  1055     "SubscribePresenceOfSingleContact - test ",

  1056     "T_VimpstEnginePresenceSubService",

  1057     "SubscribePresenceOfSingleContact",

  1058     "FUNCTIONALITY",

  1059     SetupL, T_SubscribePresenceOfSingleContactL, Teardown)

  1060     

  1061 EUNIT_TEST(

  1062     "UnSubscribePresenceOfSingleContactL - test ",

  1063     "T_VimpstEnginePresenceSubService",

  1064     "UnSubscribePresenceOfSingleContactL",

  1065     "FUNCTIONALITY",

  1066     SetupL, T_UnSubscribePresenceOfSingleContactLL, Teardown)

  1067 

  1068 

  1069 EUNIT_TEST(

  1070     "DoHandlePresentityGroupContentEventL - test ",

  1071     "T_VimpstEnginePresenceSubService",

  1072     "DoHandlePresentityGroupContentEventL",

  1073     "FUNCTIONALITY",

  1074     SetupL, T_DoHandlePresentityGroupContentEventLL, Teardown)

  1075 

  1076 EUNIT_TEST(

  1077     "DoHandlePresenceGrantRequestListEventL - test ",

  1078     "T_VimpstEnginePresenceSubService",

  1079     "DoHandlePresenceGrantRequestListEventL",

  1080     "FUNCTIONALITY",

  1081     SetupL, T_DoHandlePresenceGrantRequestListEventLL, Teardown)

  1082  

  1083 EUNIT_TEST(

  1084     "T_DoHandlePresenceBlockListEventL - test ",

  1085     "T_VimpstEnginePresenceSubService",

  1086     "T_DoHandlePresenceBlockListEventL",

  1087     "FUNCTIONALITY",

  1088     SetupL, T_DoHandlePresenceBlockListEventL, Teardown)

  1089 

  1090 

  1091 EUNIT_TEST(

  1092     "ResolveServiceStateL - test ",

  1093     "T_VimpstEnginePresenceSubService",

  1094     "ResolveServiceStateL",

  1095     "FUNCTIONALITY",

  1096     SetupL, T_ResolveServiceStateLL, Teardown)

  1097     

  1098 EUNIT_TEST(

  1099     "CchEventOccuredL - test ",

  1100     "T_VimpstEnginePresenceSubService",

  1101     "CchEventOccuredL",

  1102     "FUNCTIONALITY",

  1103     SetupL, T_CchEventOccuredLL, Teardown)

  1104 

  1105 EUNIT_TEST(

  1106     "DoHandleCchErrorL - test ",

  1107     "T_VimpstEnginePresenceSubService",

  1108     "DoHandleCchErrorL",

  1109     "FUNCTIONALITY",

  1110     SetupL, T_DoHandleCchErrorLL, Teardown)

  1111     

  1112 EUNIT_TEST(

  1113     "PublishOwnPresenceL - test ",

  1114     "T_VimpstEnginePresenceSubService",

  1115     "PublishOwnPresenceL",

  1116     "FUNCTIONALITY",

  1117     SetupL, T_PublishOwnPresenceLL, Teardown)

  1118     

  1119 EUNIT_TEST(

  1120     "ConvertPresenceStatus - test ",

  1121     "T_VimpstEnginePresenceSubService",

  1122     "ConvertPresenceStatus",

  1123     "FUNCTIONALITY",

  1124     SetupL, T_ConvertPresenceStatus, Teardown)

  1125 /*

  1126 EUNIT_TEST(

  1127     "FetchPresenceFormCache - test ",

  1128     "T_VimpstEnginePresenceSubService",

  1129     "FetchPresenceFormCache",

  1130     "FUNCTIONALITY",

  1131     SetupL, T_FetchPresenceFormCacheL, Teardown)

  1132  */   

  1133 EUNIT_TEST(

  1134     "HandlePresenceReadL - test ",

  1135     "T_VimpstEnginePresenceSubService",