diff -r 000000000000 -r 5e5d6b214f4f uiservicetab/vimpstengine/tsrc/vimpstengine_ut/src/t_vimpstengineimsubservice.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiservicetab/vimpstengine/tsrc/vimpstengine_ut/src/t_vimpstengineimsubservice.cpp	Tue Feb 02 10:12:18 2010 +0200
@@ -0,0 +1,795 @@
+/*
+* t_vimpstengineimsubservice.cpp 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 "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:t_vimpstengineimsubservice.cpp
+*
+*/
+#include <EUnitMacros.h>
+#include <TEUnitAssertionInfo.h>
+#include <CEUnitAllocTestCaseDecorator.h>
+#include "t_vimpstengineimsubservice.h"
+
+#include <spentry.h>
+#include <spsettings.h>
+#include <spproperty.h>
+
+#include "cvimpstengineimsubservice.h"
+#include "cvimpstenginecchhandler.h"
+#include "cvimpstengineservicetablefetcher.h"
+
+#include "s_cch.h"
+
+extern MyCchService* myService;
+extern TBool createService ;
+extern TBool tryConnParamWithSuccess ;
+extern TBool gConversationExist;
+extern TBool gConversationUnreadCount;
+
+
+const TInt KTestServiceId = 5;
+
+_LIT( KTestBuddyId,"TEST_BUDDY_ID");
+//_LIT( KTestRequesterId,"TEST_REQUESTER_ID");
+
+T_VimpstEngineImSubService* T_VimpstEngineImSubService::NewLC()
+    {
+    T_VimpstEngineImSubService* self = new( ELeave ) T_VimpstEngineImSubService;
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    return self;
+    }
+
+T_VimpstEngineImSubService::~T_VimpstEngineImSubService()
+    {
+    }
+
+void T_VimpstEngineImSubService::ConstructL()
+    {
+    CEUnitTestSuiteClass::ConstructL();
+    }
+
+
+//  FROM OBSERVER INTERFACES
+void T_VimpstEngineImSubService::HandleChatMessageEventL( TVIMPSTEnums::TIMEventType aEventType ,
+    const TDesC& /*aSender*/)
+    {
+    iChatMsgReceived = ETrue;
+    }
+
+void T_VimpstEngineImSubService::HandleServceConnectionEventL()
+    {
+    }
+
+
+void T_VimpstEngineImSubService::SetupL()
+    {    
+    createService = ETrue;
+    tryConnParamWithSuccess = ETrue;
+    iTestServiceId = CreateSpEntryL( KTestServiceId );
+    
+    iCchHandler = CVIMPSTEngineCchHandler::NewL( iTestServiceId ,*iCchUiEventObserver );
+    
+    iServiceTableFetcher = CVIMPSTEngineServiceTableFetcher::NewL(); 
+    
+    
+    iImSubService = CVIMPSTEngineIMSubService::NewL( 
+        iTestServiceId,
+        *iCchHandler,
+        *iServiceTableFetcher,
+        *this );
+    }
+
+void T_VimpstEngineImSubService::Teardown()
+    {
+    if ( iCchHandler )
+        {
+        delete iCchHandler;
+        iCchHandler = NULL;
+        }
+    if ( iServiceTableFetcher )
+        {
+        delete iServiceTableFetcher;
+        iServiceTableFetcher = NULL;
+        }
+    
+    if ( iImSubService )
+        {
+        delete iImSubService;
+        iImSubService = NULL;
+        }
+    
+    if ( myService )
+        {
+        delete myService;
+        myService = NULL;
+        }  
+    gConversationExist = EFalse;
+    gConversationUnreadCount = EFalse;
+    
+    }
+
+TInt T_VimpstEngineImSubService::CreateSpEntryL( TInt aServiceId )
+    {
+    CSPSettings* settings = CSPSettings::NewLC();
+    
+    CSPEntry* entry = CSPEntry::NewLC();
+    entry->SetServiceId( aServiceId );
+    
+    CSPEntry* testEntry = CSPEntry::NewLC();
+    TInt result = settings->FindEntryL( entry->GetServiceId(), *testEntry );
+    
+    if( result == KErrNone )
+        {
+        settings->UpdateEntryL( *entry );
+        }
+    else
+        {
+        settings->AddEntryL( *entry );
+        }
+    
+    TInt createdServiceId = entry->GetServiceId();
+    
+    CleanupStack::PopAndDestroy( testEntry );
+    CleanupStack::PopAndDestroy( entry );
+    CleanupStack::PopAndDestroy( settings );
+    
+    return createdServiceId;
+    }   
+
+void T_VimpstEngineImSubService::T_NewLL()
+    {
+    CVIMPSTEngineIMSubService* imSubService = NULL;
+    imSubService = CVIMPSTEngineIMSubService::NewLC(
+        iTestServiceId,
+        *iCchHandler,
+        *iServiceTableFetcher,
+        *this);
+       
+    EUNIT_ASSERT( imSubService != NULL );      
+    CleanupStack::PopAndDestroy( imSubService );
+    }
+
+void T_VimpstEngineImSubService::T_RegisterChatObserverL()
+    {
+    iImSubService->RegisterChatObserver( this );
+    EUNIT_ASSERT( 1 == iImSubService->iChatObserver.Count() );
+    }
+
+void T_VimpstEngineImSubService::T_UnRegisterChatObserverL()
+    {
+    iImSubService->RegisterChatObserver( this );
+    iImSubService->UnRegisterChatObserver( this );
+    EUNIT_ASSERT( 0 == iImSubService->iChatObserver.Count() );
+    }
+
+void T_VimpstEngineImSubService::T_HandleIMCacheEventLL()
+    {
+    TInt error( KErrNone );
+        
+    RArray<TIMCacheEventType> cacheEventTypes;
+    CleanupClosePushL( cacheEventTypes );
+        
+    // Add all cache events to array
+    cacheEventTypes.AppendL( EIMCacheRequestCompleted );
+    cacheEventTypes.AppendL( EIMCacheNewMessage );
+    cacheEventTypes.AppendL( EIMCacheUnreadMessage );
+    cacheEventTypes.AppendL( EIMCacheUnreadChange );
+    cacheEventTypes.AppendL( EIMCacheChatStarted );
+    cacheEventTypes.AppendL( EIMCacheAllChatClosed );
+    cacheEventTypes.AppendL( EIMCacheNewChat );
+    cacheEventTypes.AppendL( EIMCacheChatClosed );
+    
+
+    // go through all cache events with NULL pointer
+    for ( TInt i( 0 ) ; i < cacheEventTypes.Count() ; i++ )
+        {
+        TRAP( error, iImSubService->HandleIMCacheEventL( 
+            cacheEventTypes[ i ], NULL ) );
+            
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+        EUNIT_ASSERT( KErrNone == error );
+        }
+        
+    // go through all cache events with chatData
+    SIMCacheMessageData chatData = 
+        {
+        TIMCacheMessageType(0),
+        };
+          
+    chatData.iBuddyId = HBufC::NewLC( KTestBuddyId().Length() );
+    chatData.iBuddyId->Des().Copy( KTestBuddyId );
+
+	//for add request
+	/*SIMCacheContactData contactData = {0};
+	
+	contactData.iServiceId = iTestServiceId;
+	contactData.iRequesterId = HBufC::NewLC( KTestBuddyId().Length() );
+    contactData.iRequesterId->Des().Copy( KTestBuddyId );    
+	*/
+    for ( TInt i( 0 ) ; i < cacheEventTypes.Count() ; i++ )
+        {
+        
+        if (cacheEventTypes[ i ] == EIMCacheChatStarted || 
+        			cacheEventTypes[ i ] == EIMCacheAllChatClosed)
+	        {
+	        TRAP( error, iImSubService->HandleIMCacheEventL( 
+	            cacheEventTypes[ i ]) );	
+	        }
+        else
+	        {	        	
+	        TRAP( error, iImSubService->HandleIMCacheEventL( 
+	            cacheEventTypes[ i ], &chatData ) );
+	        }
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+        EUNIT_ASSERT( KErrNone == error );
+        }
+    
+  //  CleanupStack::PopAndDestroy(contactData.iRequesterId);
+    CleanupStack::PopAndDestroy(chatData.iBuddyId);
+    
+    EUNIT_ASSERT( EFalse == iChatMsgReceived );
+    
+    CleanupStack::PopAndDestroy( &cacheEventTypes );
+    }
+
+void T_VimpstEngineImSubService::T_SubServiceStateL()
+    {
+    RArray<TVIMPSTEnums::TVIMPSTRegistrationState> states;
+    CleanupClosePushL( states );
+    states.AppendL( TVIMPSTEnums::ESVCENotRegistered );
+    states.AppendL( TVIMPSTEnums::ESVCERegistered );
+    states.AppendL( TVIMPSTEnums::ESVCENetworkConnecting );
+    states.AppendL( TVIMPSTEnums::ESVCEWaitingForNetwork );
+    states.AppendL( TVIMPSTEnums::ESVCENetworkDisConnecting );
+    states.AppendL( TVIMPSTEnums::ESVCEUpdatingContacts );
+       
+    for ( TInt i( 0 ) ; i < states.Count() ; i++ )
+        {
+        iImSubService->iServiceState = states[ i ];
+        EUNIT_ASSERT( states[ i ] == iImSubService->SubServiceState() );
+        }
+       
+    CleanupStack::PopAndDestroy( &states );
+    }
+
+void T_VimpstEngineImSubService::T_IsConversationExistLL()
+    {
+    gConversationExist = ETrue;
+    iImSubService->CreateIMCacheAccessorL();
+    EUNIT_ASSERT( ETrue == iImSubService->IsConversationExistL(KTestBuddyId()) );
+    iImSubService->ReleaseIMCacheAccessor();    
+    }
+
+
+void T_VimpstEngineImSubService::T_IsConversationDoesntExistLL()
+    {
+    iImSubService->CreateIMCacheAccessorL();    
+    EUNIT_ASSERT( EFalse == iImSubService->IsConversationExistL(KTestBuddyId()) );
+    iImSubService->ReleaseIMCacheAccessor();
+    }
+
+
+    
+void T_VimpstEngineImSubService::T_CloseConversationExisitingConversationLL()
+    {
+    gConversationExist = ETrue;
+    iImSubService->CreateIMCacheAccessorL();
+    
+    TRAPD( err, iImSubService->CloseConversationL( KTestBuddyId() ) );
+        
+    EUNIT_ASSERT( KErrNone == err );
+    iImSubService->ReleaseIMCacheAccessor();
+    }
+    
+void T_VimpstEngineImSubService::T_CloseConversationNonExisitingConversationLL()
+    {
+    iImSubService->CreateIMCacheAccessorL();
+    TRAPD( err, iImSubService->CloseConversationL( KTestBuddyId() ) );
+        
+    EUNIT_ASSERT( KErrNone == err );
+    iImSubService->ReleaseIMCacheAccessor();
+    }  
+    
+void T_VimpstEngineImSubService::T_IsConversationExistNoIMCacheAccessorL()
+    {
+    
+    iImSubService->ReleaseIMCacheAccessor();
+    EUNIT_ASSERT( EFalse == iImSubService->IsConversationExistL(KTestBuddyId()) );
+    
+    }
+         
+
+void T_VimpstEngineImSubService::T_CloseConversationNoIMCacheAccessorL()
+    {
+    iImSubService->ReleaseIMCacheAccessor();
+    
+    TRAPD( err, iImSubService->CloseConversationL( KTestBuddyId() ) );
+        
+    EUNIT_ASSERT( KErrNone == err );
+    }
+
+
+void T_VimpstEngineImSubService::T_GetUnreadCountL()
+    {
+    gConversationUnreadCount = ETrue;
+    iImSubService->CreateIMCacheAccessorL();
+    TInt count = -1;
+    
+    TRAPD( err, count = iImSubService->GetUnreadCountL( KTestBuddyId() ) );
+    
+    EUNIT_ASSERT( 1 == count ); 
+	        
+    EUNIT_ASSERT( KErrNone == err );
+    iImSubService->ReleaseIMCacheAccessor();
+    }
+    
+    
+void T_VimpstEngineImSubService::T_GetUnreadCountNoIMCacheAccessorL()
+    {    
+    TInt count = -1;
+    
+    TRAPD( err, count = iImSubService->GetUnreadCountL( KTestBuddyId() ) );
+    
+    EUNIT_ASSERT( 0 == count ); 
+        
+    EUNIT_ASSERT( KErrNone == err );
+    }
+   
+    
+void T_VimpstEngineImSubService::T_ResolveServiceStateLL()
+    {
+    TInt error( KErrNone );
+        
+    RArray<TCCHSubserviceState> subServiceStates;   
+    CleanupClosePushL( subServiceStates );
+    subServiceStates.AppendL( ECCHUninitialized );
+    subServiceStates.AppendL( ECCHDisabled );
+    subServiceStates.AppendL( ECCHConnecting );
+    subServiceStates.AppendL( ECCHEnabled );
+    subServiceStates.AppendL( ECCHDisconnecting );
+    
+    // Test with service error: KErrNone and all subservice states.
+    TInt serviceError( KErrNone );
+            
+    for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )
+        {
+        TRAP( error, iImSubService->ResolveServiceStateL( 
+            subServiceStates[ i ], serviceError ) );
+                
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+                
+        EUNIT_ASSERT( KErrNone == error );
+        }
+              
+    // Test with service error: KErrNotFound and all subservice states.
+    serviceError = KErrNotFound;
+    for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )
+        {
+        TRAP( error, iImSubService->ResolveServiceStateL( 
+            subServiceStates[ j ], serviceError ) );
+                
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+                       
+        EUNIT_ASSERT( KErrNone == error );
+        }
+        
+    CleanupStack::PopAndDestroy( &subServiceStates );
+    }
+
+void T_VimpstEngineImSubService::T_TypeL()
+    {
+    EUNIT_ASSERT( TVIMPSTEnums::EIM == iImSubService->Type() );
+    }
+
+void T_VimpstEngineImSubService::T_CchEventOccuredLL()
+    {
+    TInt error( KErrNone );
+        
+    RArray<TCCHSubserviceState> subServiceStates;   
+    CleanupClosePushL( subServiceStates );
+    subServiceStates.AppendL( ECCHUninitialized );
+    subServiceStates.AppendL( ECCHDisabled );
+    subServiceStates.AppendL( ECCHConnecting );
+    subServiceStates.AppendL( ECCHEnabled );
+    subServiceStates.AppendL( ECCHDisconnecting );
+
+    // Test with service error: KErrNone and all subservice states.
+    TInt serviceError( KErrNone );
+        
+    for ( TInt i( 0 ) ; i < subServiceStates.Count() ; i++ )
+        {
+        TRAP( error, iImSubService->CchEventOccuredL( 
+            iTestServiceId, subServiceStates[ i ], serviceError ) );
+            
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+            
+        EUNIT_ASSERT( KErrNone == error );
+        }
+          
+    // Test with service error: KErrNotFound and all subservice states.
+    serviceError = KErrNotFound;
+    for ( TInt j( 0 ) ; j < subServiceStates.Count() ; j++ )
+        {
+        TRAP( error, iImSubService->CchEventOccuredL( 
+            iTestServiceId, subServiceStates[ j ], serviceError ) );
+            
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+                   
+        EUNIT_ASSERT( KErrNone == error );
+        }
+        
+    CleanupStack::PopAndDestroy( &subServiceStates );
+    }
+
+void T_VimpstEngineImSubService::T_DoHandleCchErrorLL()
+    {
+    RArray<TInt> serviceErrors;
+    CleanupClosePushL( serviceErrors );
+    
+    serviceErrors.AppendL( KErrGeneral ); // Tests default case
+    serviceErrors.AppendL( KCCHErrorBandwidthInsufficient );
+    serviceErrors.AppendL( KCCHErrorInvalidIap );
+    serviceErrors.AppendL( KCCHErrorAuthenticationFailed );
+    serviceErrors.AppendL( KCCHErrorNetworkLost );
+    serviceErrors.AppendL( KCCHErrorLoginFailed );
+    serviceErrors.AppendL( KCCHErrorServiceNotResponding );
+    serviceErrors.AppendL( KCCHErrorInvalidSettings );
+    serviceErrors.AppendL( KCCHErrorAccessPointNotDefined );
+    
+    for ( TInt i( 0 ) ; i < serviceErrors.Count() ; i++ )
+        {
+        TRAPD( err, iImSubService->DoHandleCchErrorL( 
+            serviceErrors[ i ] ) );
+        
+        if ( KErrNoMemory == err )
+            {
+            User::Leave( err );
+            }
+                      
+        EUNIT_ASSERT( KErrNone == err );
+        }
+    
+    CleanupStack::PopAndDestroy( &serviceErrors );
+    }
+
+void T_VimpstEngineImSubService::T_CreateIMCacheAccessorLL()
+    {
+    
+    iImSubService->CreateIMCacheAccessorL();
+    EUNIT_ASSERT(iImSubService->iIMCacheFactory);
+    EUNIT_ASSERT(iImSubService->iIMCacheAccessor)
+    
+    }
+
+void T_VimpstEngineImSubService::T_ReleaseIMCacheAccessorL()
+    {
+    iImSubService->CreateIMCacheAccessorL();    
+    iImSubService->ReleaseIMCacheAccessor();
+    
+    EUNIT_ASSERT(NULL == iImSubService->iIMCacheFactory);
+    EUNIT_ASSERT(NULL == iImSubService->iIMCacheAccessor);
+    
+    }
+
+
+void T_VimpstEngineImSubService::T_RegisterNULLChatObserverL()
+    {
+    iImSubService->RegisterChatObserver( NULL );
+    EUNIT_ASSERT( 0 == iImSubService->iChatObserver.Count() );
+    }
+
+void T_VimpstEngineImSubService::T_UnRegisterNULLChatObserverL()
+    {
+    iImSubService->RegisterChatObserver( NULL );
+    iImSubService->UnRegisterChatObserver( NULL );
+    EUNIT_ASSERT( 0 == iImSubService->iChatObserver.Count() );
+    }
+
+void T_VimpstEngineImSubService::T_RegisterChatObserverTwiceL()
+    {
+    iImSubService->RegisterChatObserver( this );
+    iImSubService->RegisterChatObserver( this );
+    EUNIT_ASSERT( 1 == iImSubService->iChatObserver.Count() );
+    }
+
+void T_VimpstEngineImSubService::T_UnRegisterChatObserverTwiceL()
+    {
+    iImSubService->RegisterChatObserver( this );
+    iImSubService->UnRegisterChatObserver( this );
+    iImSubService->UnRegisterChatObserver( this );
+    EUNIT_ASSERT( 0 == iImSubService->iChatObserver.Count() );
+    }    
+
+
+void T_VimpstEngineImSubService::T_HandleIMCacheEventWithRegisteredObserverL()
+    {
+    TInt error( KErrNone );
+        
+    RArray<TIMCacheEventType> cacheEventTypes;
+    CleanupClosePushL( cacheEventTypes );
+	
+	iImSubService->RegisterChatObserver( this );    
+            
+    // Add all cache events to array
+	   cacheEventTypes.AppendL( EIMCacheRequestCompleted );
+	    cacheEventTypes.AppendL( EIMCacheNewMessage );
+	    cacheEventTypes.AppendL( EIMCacheUnreadMessage );
+	    cacheEventTypes.AppendL( EIMCacheUnreadChange );
+	    cacheEventTypes.AppendL( EIMCacheChatStarted );
+	    cacheEventTypes.AppendL( EIMCacheAllChatClosed );
+	    cacheEventTypes.AppendL( EIMCacheNewChat );
+	    cacheEventTypes.AppendL( EIMCacheChatClosed );
+        
+    // go through all cache events with NULL pointer
+    for ( TInt i( 0 ) ; i < cacheEventTypes.Count() ; i++ )
+        {
+        TRAP( error, iImSubService->HandleIMCacheEventL( 
+            cacheEventTypes[ i ], NULL ) );
+            
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+        EUNIT_ASSERT( KErrNone == error );
+        }
+        
+    // go through all cache events with chatData
+    SIMCacheMessageData chatData = 
+        {
+        TIMCacheMessageType(0),
+        };
+          
+    chatData.iBuddyId = HBufC::NewLC( KTestBuddyId().Length() );
+    chatData.iBuddyId->Des().Copy( KTestBuddyId );
+
+	//for add request
+	/*SIMCacheContactData contactData = {0,};
+	
+	contactData.iServiceId = iTestServiceId;
+	contactData.iRequesterId = HBufC::NewLC( KTestBuddyId().Length() );
+    contactData.iRequesterId->Des().Copy( KTestBuddyId );   
+    */ 
+	
+    for ( TInt i( 0 ) ; i < cacheEventTypes.Count() ; i++ )
+        {
+        if (cacheEventTypes[ i ] == EIMCacheChatStarted || 
+        			cacheEventTypes[ i ] == EIMCacheAllChatClosed)
+	        {
+	        TRAP( error, iImSubService->HandleIMCacheEventL( 
+	            cacheEventTypes[ i ] ) );	
+	        }
+        else
+	        {	        	
+	        TRAP( error, iImSubService->HandleIMCacheEventL( 
+	            cacheEventTypes[ i ], &chatData ) );
+	        }
+        if ( KErrNoMemory == error )
+            {
+            User::Leave( error );
+            }
+        EUNIT_ASSERT( KErrNone == error );
+        }
+    
+    //CleanupStack::PopAndDestroy(contactData.iRequesterId);
+    CleanupStack::PopAndDestroy(chatData.iBuddyId);
+    
+    iImSubService->UnRegisterChatObserver( this );
+    
+    EUNIT_ASSERT( ETrue == iChatMsgReceived );
+    
+    CleanupStack::PopAndDestroy( &cacheEventTypes );
+    }
+        
+
+EUNIT_BEGIN_TEST_TABLE( T_VimpstEngineImSubService, "T_VimpstEngineImSubService", "" )
+
+EUNIT_TEST(
+    "NewL - test ",
+    "T_VimpstEngineImSubService",
+    "NewL",
+    "FUNCTIONALITY",
+    SetupL, T_NewLL, Teardown)
+    
+EUNIT_TEST(
+    "RegisterChatObserver - test ",
+    "T_VimpstEngineImSubService",
+    "RegisterChatObserver",
+    "FUNCTIONALITY",
+    SetupL, T_RegisterChatObserverL, Teardown)
+    
+EUNIT_TEST(
+    "UnRegisterChatObserver - test ",
+    "T_VimpstEngineImSubService",
+    "UnRegisterChatObserver",
+    "FUNCTIONALITY",
+    SetupL, T_UnRegisterChatObserverL, Teardown)
+    
+EUNIT_TEST(
+    "HandleIMCacheEventL - without RegisteredObservers ",
+    "T_VimpstEngineImSubService",
+    "HandleIMCacheEventL without RegisteredObservers",
+    "FUNCTIONALITY",
+    SetupL, T_HandleIMCacheEventLL, Teardown)
+    
+EUNIT_TEST(
+    "GetUnreadCountL - test ",
+    "T_VimpstEngineImSubService",
+    "GetUnreadCountL",
+    "FUNCTIONALITY",
+    SetupL, T_GetUnreadCountL, Teardown)
+
+EUNIT_TEST(
+    "GetUnreadCountL - IMCacheAccessor Not Created ",
+    "T_VimpstEngineImSubService",
+    "GetUnreadCountL - IMCacheAccessor Not Created",
+    "FUNCTIONALITY",
+    SetupL, T_GetUnreadCountNoIMCacheAccessorL, Teardown)
+    
+
+    
+EUNIT_TEST(
+    "SubServiceState - test ",
+    "T_VimpstEngineImSubService",
+    "SubServiceState",
+    "FUNCTIONALITY",
+    SetupL, T_SubServiceStateL, Teardown)
+    
+EUNIT_TEST(
+    "IsConversationExistL - test ",
+    "T_VimpstEngineImSubService",
+    "IsConversationExistL",
+    "FUNCTIONALITY",
+    SetupL, T_IsConversationExistLL, Teardown)
+
+EUNIT_TEST(
+    "IsConversationDoesntExistL - test ",
+    "T_VimpstEngineImSubService",
+    "T_IsConversationDoesntExistLL",
+    "FUNCTIONALITY",
+    SetupL, T_IsConversationDoesntExistLL, Teardown)
+
+
+EUNIT_TEST(
+    "CloseExisitingConversationL - test ",
+    "T_VimpstEngineImSubService",
+    "CloseExisitingConversationL",
+    "FUNCTIONALITY",
+    SetupL, T_CloseConversationExisitingConversationLL, Teardown)
+        
+EUNIT_TEST(
+    "CloseNonExisitingConversationL - test ",
+    "T_VimpstEngineImSubService",
+    "CloseNonExisitingConversationL",
+    "FUNCTIONALITY",
+    SetupL, T_CloseConversationNonExisitingConversationLL, Teardown)
+
+EUNIT_TEST(
+    "IsConversationExistL - IMCacheAccessor Not Created",
+    "T_VimpstEngineImSubService",
+    "IsConversationExistL - IMCacheAccessor Not Created",
+    "FUNCTIONALITY",
+    SetupL, T_IsConversationExistNoIMCacheAccessorL, Teardown)
+
+
+EUNIT_TEST(
+    "CloseConversationL - IMCacheAccessor Not Created ",
+    "T_VimpstEngineImSubService",
+    "CloseConversationL - - IMCacheAccessor Not Created",
+    "FUNCTIONALITY",
+    SetupL, T_CloseConversationNoIMCacheAccessorL, Teardown)
+
+
+    
+EUNIT_TEST(
+    "ResolveServiceStateL - test ",
+    "T_VimpstEngineImSubService",
+    "ResolveServiceStateL",
+    "FUNCTIONALITY",
+    SetupL, T_ResolveServiceStateLL, Teardown)
+    
+EUNIT_TEST(
+    "Type - test ",
+    "T_VimpstEngineImSubService",
+    "Type",
+    "FUNCTIONALITY",
+    SetupL, T_TypeL, Teardown)
+    
+EUNIT_TEST(
+    "CchEventOccuredL - test ",
+    "T_VimpstEngineImSubService",
+    "CchEventOccuredL",
+    "FUNCTIONALITY",
+    SetupL, T_CchEventOccuredLL, Teardown)
+    
+EUNIT_TEST(
+    "DoHandleCchErrorL - test ",
+    "T_VimpstEngineImSubService",
+    "DoHandleCchErrorL",
+    "FUNCTIONALITY",
+    SetupL, T_DoHandleCchErrorLL, Teardown)
+    
+EUNIT_TEST(
+    "CreateIMCacheAccessorL - test ",
+    "T_VimpstEngineImSubService",
+    "CreateIMCacheAccessorL",
+    "FUNCTIONALITY",
+    SetupL, T_CreateIMCacheAccessorLL, Teardown)
+    
+EUNIT_TEST(
+    "ReleaseIMCacheAccessor - test ",
+    "T_VimpstEngineImSubService",
+    "ReleaseIMCacheAccessor",
+    "FUNCTIONALITY",
+    SetupL, T_ReleaseIMCacheAccessorL, Teardown)
+    
+
+EUNIT_TEST(
+    "RegisterChatObserver - NULL Observer ",
+    "T_VimpstEngineImSubService",
+    "RegisterChatObserver - NULL Observer",
+    "FUNCTIONALITY",
+    SetupL, T_RegisterNULLChatObserverL, Teardown)
+    
+EUNIT_TEST(
+    "UnRegisterChatObserver - NULL Observer",
+    "T_VimpstEngineImSubService",
+    "UnRegisterChatObserver - NULL Observer",
+    "FUNCTIONALITY",
+    SetupL, T_UnRegisterNULLChatObserverL, Teardown)  
+
+EUNIT_TEST(
+    "RegisterChatObserver - Twice Same Observer",
+    "T_VimpstEngineImSubService",
+    "RegisterChatObserver - Twice Same Observer",
+    "FUNCTIONALITY",
+    SetupL, T_RegisterChatObserverTwiceL, Teardown)  
+
+
+EUNIT_TEST(
+    "UnRegisterChatObserver - Twice Same Observer",
+    "T_VimpstEngineImSubService",
+    "UnRegisterChatObserver - Twice Same Observer",
+    "FUNCTIONALITY",
+    SetupL, T_UnRegisterChatObserverTwiceL, Teardown)  
+
+
+EUNIT_TEST(
+    "HandleIMCacheEventL - with RegisteredObserver ",
+    "T_VimpstEngineImSubService",
+    "HandleIMCacheEventL with RegisteredObserver",
+    "FUNCTIONALITY",
+    SetupL, T_HandleIMCacheEventWithRegisteredObserverL, Teardown)
+        
+    
+    
+EUNIT_END_TESTCASE_TABLE
+
+//  END OF FILE