/*

* 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() );