/*

* Copyright (c) 2006 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: XIMP Framework Test Code 

*

*/

#include "eunittools.h"

#include <ecom/ecom.h>

#include <badesca.h>

#include <ximpbase.h>

#include <ximpclient.h>

#include <ximpcontext.h>

#include <ximpcontextstateevent.h>

#include <ximprequestcompleteevent.h>

#include <ximpstatus.h>

#include <presencefeatures.h>

#include <presencewatching.h>

#include <presencepublishing.h>

#include <presentitypresenceevent.h>

#include <ximpobjectfactory.h>

#include "t_presencewatching.h"

#include "prfwteststatuseventlistener.h"

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestcontextwrappermgr.h"

#include "prfwtestcontextwrapper.h"

#include "presenceinfoimp.h"

#include "presenceinfofilterimp.h"

#include "prfwtestpresencedatautils.h"

#include "ximpidentityimp.h"

#include "presentitygroupmemberinfoimp.h"

#include "ximpobjecthelpers.h"

#include "prfwtestfilesrvmsg.h"

#include "prfwtestwaithelper.h"

#include "prfwtestrobustnesstools.h"

#include "presenceinfofieldimp.h"

#include "presenceinfofieldcollectionimp.h"

#include "presenceinfofieldvaluetextimp.h"

#include "personpresenceinfoimp.h"

#include <presencecachereader.h>

// For the protocol UID

#include "prfwtestprotocols.h"

_LIT8( KPrefix1, "PreA_" );

_LIT8( KPrefix2, "PreB_" );

_LIT8( KPrefix3, "PreC_" );

_LIT8( KPrefix4, "PreD_" );

_LIT( KIdentity, "TestId@hello.world" );

_LIT8( KIdentity8, "TestId@hello.world" );

_LIT( KText, "Hello World" );

const TUid KTestProtocolUid = { K_PRFW_TST_PROTOCOL_1_IMPLEMENTATION_UID };  // hardcoded...

// ============================ MEMBER FUNCTIONS ===============================

// CONSTRUCTION

T_PresenceWatching* T_PresenceWatching::NewL()

    {

    T_PresenceWatching* self = new( ELeave ) T_PresenceWatching;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

T_PresenceWatching::~T_PresenceWatching()

    {

    }

void T_PresenceWatching::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

T_PresenceWatching::T_PresenceWatching()

    {

    }

// ===========================================================================

// TEST CASE SETUP & TEARDOWN METHODS

// ===========================================================================

//

void T_PresenceWatching::Setup_L()

    {

    __UHEAP_MARK;

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iMPresenceCacheReader = MPresenceCacheReader::NewL();

    }

void T_PresenceWatching::SetupMultiple_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresenceWatching::BindL()

    {

    CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );

    wrapper0->BindL( 0 );

    }

void T_PresenceWatching::BindAllL()

    {

    for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )

        {

        CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

        wrapper->BindL( 0 );

        }

    }

void T_PresenceWatching::Teardown()

    {

    delete iWrapperMgr;

    iWrapperMgr = NULL;

    delete iMPresenceCacheReader;

    REComSession::FinalClose();

    PrfwTestRobustness::DoPreCleaning();

    __UHEAP_MARKEND;

    }

void T_PresenceWatching::UnbindL()

    {

    // Do unbind

    CXIMPTestContextWrapper* wrapper0 = iWrapperMgr->GetWrapperL( 0 );

    wrapper0->UnbindL();

    }

void T_PresenceWatching::UnbindAllL()

    {

    for( TInt a = 0; a < iWrapperMgr->WrapperCount(); ++a )

        {

        CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

        wrapper->UnbindL();

        }

    }

// ===========================================================================

// TEST CASES for presentity presence subscription

// ===========================================================================

// Single client, empty filter

void T_PresenceWatching::T_SubscribePresentityPresence_Single_L()

    {

    EUNIT_PRINT( _L("Single presentity subscription") );

// BIND AND SETUP

    BindL();

    CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceWatching& presWatch = presFeat->PresenceWatching();

// SUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

    CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

    CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

    // register interest

    TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

// REFRESH

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

    messenger->SetValueFor( EXIMPPlgTestSubscribePresentityPresesenceCalled, 0 );

    // register interest

    reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

    // Wait for event because refresh happened

    SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_HandlePresentityPresencePending );

    // Wait for events

    wrapper->WaitAnyEvent();

    wrapper->VerifyEventStackL( _L8("Handle presence watcher list. Wrong event occurred.") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, 

                 "SubscribePresentityPresenceL was not called", EFalse,

                 "SubscribePresentityPresenceL was called" );

// UNSUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

    // register interest

    reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", ETrue, NULL );

// UNBIND    

    CleanupStack::PopAndDestroy( pif );

    CleanupStack::PopAndDestroy( identity );

    UnbindL();

    }

// Single client, empty filter, presence cache checking

void T_PresenceWatching::T_SubscribeHandlePresentityPresence_Single_L()

    {

    EUNIT_PRINT( _L("Single presentity subscription") );

// BIND AND SETUP

    BindL();

    CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceWatching& presWatch = presFeat->PresenceWatching();

// SUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

    CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KIdentity8 );

    CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

    // register interest

    TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

// SEND DATA

    // Create some meaningful data

    CPresenceInfoImp* presenceInfo = CPresenceInfoImp::NewLC();

    MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();

    value->SetTextValueL(KText);

    MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();

    infoField->SetFieldTypeL(NPresenceInfo::NFieldType::KStatusMessage);

    infoField->SetFieldValue(value);    

    MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();

    MPresenceInfoFieldCollection& fieldCol = personPres->Fields();

    fieldCol.AddOrReplaceFieldL(infoField);

    TInt fieldCount= fieldCol.FieldCount();

    presenceInfo->SetPersonPresenceL(personPres);

    CleanupStack::Pop(3); // value, infoField, personPres

    // Pack the data for FileTool

    HBufC8* packedInfo = TXIMPObjectPacker< CPresenceInfoImp >::PackL( *presenceInfo );

    CleanupStack::PushL( packedInfo );

    HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *identity );

    CleanupStack::PushL( packedId );

    RPointerArray< HBufC8 > bufferArray;

    CleanupClosePushL( bufferArray );

    bufferArray.AppendL( packedId );

    bufferArray.AppendL( packedInfo );

    HBufC8* packedBufferArray = TXIMPHBuf8Packer::PackArrayL( bufferArray );

    CleanupStack::PopAndDestroy( 3, packedInfo ); // packedId, packedInfo, bufferArray

    CleanupStack::PushL( packedBufferArray );

    // Use filetool to send it for plugin.

    CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( CXIMPTestFileSrvMsg::ETestSrvMsgPresentityPresence, 

                                                             *packedBufferArray );

    CleanupStack::PopAndDestroy( packedBufferArray );

    CleanupStack::PushL( srvMsg );

    wrapper->FileTool().SrvMsgStoreL( srvMsg );

    CleanupStack::PopAndDestroy( srvMsg );

    // Wait for event

    SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_HandlePresentityPresence );

    // Wait for events

    wrapper->WaitAnyEvent();

    wrapper->VerifyEventStackL( _L8("Handle presentity presence. Wrong event occurred.") );

    // Verify the cache

    MPresenceInfo* presInfoRead = iMPresenceCacheReader->PresenceInfoLC(*identity);

    CPresenceInfoImp* readInfo = 

        TXIMPGetImpClassOrPanic<CPresenceInfoImp>::From(*presInfoRead);    

    EUNIT_ASSERT( presenceInfo->EqualsContent(*readInfo) );

    CleanupStack::PopAndDestroy( 2 ); // readInfo, presenceInfo

// UNSUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

    // unsubscribe

    reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", ETrue, NULL );

// UNBIND    

    CleanupStack::PopAndDestroy( pif );

    CleanupStack::PopAndDestroy( identity );

    UnbindL();

    }

// Single client, empty filter

void T_PresenceWatching::T_SubscribePresentityPresenceChangeId_Single_L()

    {

    EUNIT_PRINT( _L("Single presentity subscription") );

// BIND AND SETUP

    BindL();

    CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceWatching& presWatch = presFeat->PresenceWatching();

// ID CHANGE REQUEST TO ADAPTATION

    MXIMPIdentity* identityParam = context->ObjectFactory().NewIdentityLC();

    identityParam->SetIdentityL( KIdentity );

    CXIMPIdentityImp* identityParamImp =

             ( CXIMPIdentityImp* ) identityParam->GetInterface(

                                        CXIMPIdentityImp::KClassId,

                                        MXIMPBase::EPanicIfUnknown );

    HBufC8* packedId = TXIMPObjectPacker< CXIMPIdentityImp >::PackL( *identityParamImp );

    CleanupStack::PopAndDestroy(); // identityParam

    CleanupStack::PushL( packedId );

    CXIMPTestFileSrvMsg* srvMsg = CXIMPTestFileSrvMsg::NewL( CXIMPTestFileSrvMsg::ETestSrvMsgReqParamIdentity, 

                                                             *packedId );

    CleanupStack::PopAndDestroy( packedId );

    CleanupStack::PushL( srvMsg );

    wrapper->FileTool().SrvMsgStoreL( srvMsg );

    CleanupStack::PopAndDestroy( srvMsg );

    // Wait for server to handle srvmsg.

    CXIMPTestWaitHelper* wait = CXIMPTestWaitHelper::NewL();

    CleanupStack::PushL( wait );

    wait->WaitForL( 2 );

    CleanupStack::PopAndDestroy( wait );

// SUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk );

    CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

    CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

    // register interest

    TXIMPRequestId reqId = presWatch.SubscribePresentityPresenceL( *identity, *pif );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Subscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresentityPresesenceCalled, "SubscribePresentityPresenceL was not called", ETrue, NULL );

// UNBIND    

    CleanupStack::PopAndDestroy( pif );

    CleanupStack::PopAndDestroy( identity );

    UnbindL();

    }

void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityPresence_Single_L()

    {

    EUNIT_PRINT( _L("Unsubscribe not subscribed presentity presence") );

// BIND AND SETUP

    BindL();

    CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( 0 );

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceWatching& presWatch = presFeat->PresenceWatching();

    CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

    CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

// UNSUBSCRIBE

    // Setup status event listener for RequestComplete

    SetupListenerReqCompleteAllowEventsL( wrapper, EXIMPTestStatusEvents_RequestOk ); // allow events after reqcomplete

    // register interest

    TXIMPRequestId reqId = presWatch.UnsubscribePresentityPresenceL( *identity );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("UnSubscribing presentity presence, complete with error: ") );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresentityPresesenceCalled, "UnsubscribePresentityPresenceL was not called", EFalse, 

                                                                                "UnsbuscribePresentityPresenceL was called." );

// UNBIND    

    CleanupStack::PopAndDestroy( pif );

    CleanupStack::PopAndDestroy( identity );

    UnbindL();

    }

void T_PresenceWatching::T_UnsubscribeNotSubscribedPresentityPresence_Multiple_L()

    {

    EUNIT_PRINT( _L("Multiple client filter registration") );

    BindAllL();

    CXIMPIdentityImp* identity = XIMPTestPresenceDataUtils::GenerateIdentityLC( &KNullDesC8 );

    CPresenceInfoFilterImp* pif = XIMPTestPresenceDataUtils::GenerateInfoFilterLC( &KPrefix1 );

    TInt countOfWrappers = iWrapperMgr->WrapperCount();

    for( TInt a = countOfWrappers - 1; a >= 1 ; --a ) // Don't subscribe the first one.

        {

        CXIMPTestContextWrapper* wrapper = iWrapperMgr->GetWrapperL( a );

        MXIMPContext* context = wrapper->GetContext();

        CXIMPTestMessenger* messenger = wrapper->GetMessenger();

        // Tell the protocol it should act normally

        messenger->SetNoError();

        // Get the interfaces

        MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

        MPresenceWatching& presWatch = presFeat->PresenceWatching();