/*

* 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 <eunitmacros.h>

#include <ecom/ecom.h>

#include <badesca.h>

#include <ximpbase.h>

#include <ximpclient.h>

#include <presencefeatures.h>

#include <presencepublishing.h>

#include <ximpdatasubscriptionstate.h>

#include <presentitygroups.h>

#include <ximpobjectfactory.h>

#include <presencewatching.h>

#include <presenceobjectfactory.h>

#include <ximpcontext.h>

#include <ximpcontextstateevent.h>

#include <ximprequestcompleteevent.h>

#include <ximpstatus.h>

#include <presentitypresenceevent.h>

#include "prfwtestpresencedatautils.h"

#include "t_presencewatcherlistmngt.h"

// watcher list related includes

#include "presencewatcherinfoimp.h"

#include "presencewatcherlisteventimp.h"

// other data model includes

#include "ximpidentityimp.h"

#include "ximpdatasubscriptionstateimp.h"

#include "presentitygroupmemberinfoimp.h"

#include "presenceinfofilterimp.h"

// utils includes

#include "ximpobjecthelpers.h"

#include "ximprequestcompleteeventimp.h"

// testing tool includes

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestcontextwrappermgr.h"

#include "prfwtestcontextwrapper.h"

#include "prfwtestwaithelper.h"

#include "prfwtestfilesrvmsg.h"

#include "prfwtestfiletool.h"

#include "prfwtestlistener.h"

#include "prfwtestrobustnesstools.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"*/

_LIT8( KPrefix1, "PreA_" );

_LIT8( KPrefix2, "PreB_" );

_LIT8( KPrefix3, "PreC_" );

_LIT8( KPrefix4, "PreD_" );

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

// CONSTRUCTION

T_PresenceWatcherListManagement* T_PresenceWatcherListManagement::NewL()

    {

    T_PresenceWatcherListManagement* self = new( ELeave ) T_PresenceWatcherListManagement;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

T_PresenceWatcherListManagement::~T_PresenceWatcherListManagement()

    {

    }

void T_PresenceWatcherListManagement::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

T_PresenceWatcherListManagement::T_PresenceWatcherListManagement()

    {

    }

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

// TEST CASE SETUP & TEARDOWN METHODS

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

//

void T_PresenceWatcherListManagement::Setup_L()

    {

    __UHEAP_MARK;

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresenceWatcherListManagement::SetupMultiple_L()

    {

    __UHEAP_MARK;

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresenceWatcherListManagement::BindL()

    {

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

    wrapper0->BindL( 0 );

    }

void T_PresenceWatcherListManagement::BindAllL()

    {

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

        {

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

        wrapper->BindL( 0 );

        }

    }

void T_PresenceWatcherListManagement::Teardown()

    {

    delete iWrapperMgr;

    iWrapperMgr = NULL;

    REComSession::FinalClose();

    PrfwTestRobustness::DoPreCleaning();

    __UHEAP_MARKEND;

    }

void T_PresenceWatcherListManagement::UnbindL()

    {

    // Do unbind

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

    wrapper0->UnbindL();

    }

void T_PresenceWatcherListManagement::UnbindAllL()

    {

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

        {

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

        wrapper->UnbindL();

        }

    }

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

// TEST CASES for presentity presence subscription

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

// Check that this don't leak memory

void T_PresenceWatcherListManagement::T_BindUnbind_L()

    {

    BindL();

    UnbindL();

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// Subscribe, unsubscribe - Single client

void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Single_L()

    {

    EUNIT_PRINT( _L("Single client presence watcher list subscription") );

    BindL();

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

    CleanupStack::PushL( listener2 );

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresencePublishing& presPub = presFeat->PresencePublishing();

    //-------------------------------------------------

    // subscribe

    // Setup status event listener for RequestComplete

    // ---------------------------------------------

    listener2->Reset();

    // normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

    CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // Subscribe

    TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

    // verify that SubscribePresenceWatcherListL was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

    //-------------------------------------------------

    // refresh subscribe

    // Setup status event listener for RequestComplete

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    RPrWatLstInfoImpArray* currentList(NULL);

    CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(

        KNullDesC, KNullDesC,

        MXIMPDataSubscriptionState::ESubscriptionActive,

        MXIMPDataSubscriptionState::EDataUnavailable,

        ETestPWlCurrent, currentList);

    listener2->ExpectL( event );

    CleanupStack::Pop(); //event 3 to go.

    // ---------------------------------------------

    // Subscribe second time

    reqId = presPub.SubscribePresenceWatcherListL();

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Refresh failed" );

    CleanupStack::PopAndDestroy( 3 ); // rest of the items.

    // verify that SubscribePresenceWatcherListL was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

    //-------------------------------------------------

    // unsubscribe

    // Setup status event listener for RequestComplete

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // register interest

    reqId = presPub.UnsubscribePresenceWatcherListL();

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

    // verify that UnsubscribePresenceWatcherListL was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );

    //-------------------------------------------------

    // unsubscribe nonsubscribed

    // Setup status event listener for RequestComplete

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // register interest

    reqId = presPub.UnsubscribePresenceWatcherListL();

    // Wait for events on the request

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

    // verify that UpdateInterest was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribePresenceWatcherListL was not called", ETrue, NULL );

    listener2->SetEventSourceL( NULL );

    UnbindL();

    CleanupStack::PopAndDestroy( listener2 );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

// Subscribe, Unsubscribe - Multiple clients

void T_PresenceWatcherListManagement::T_SubscribePresenceWatcherList_Multiple_L()

    {

    EUNIT_PRINT( _L("Multiple client presence watcher list subscription") );

    BindAllL();

    TInt countOfWrappers = iWrapperMgr->WrapperCount();

    for( TInt a = 0; a < countOfWrappers; ++a )

        {

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

        MXIMPContext* context = wrapper->GetContext();

        CXIMPTestMessenger* messenger = wrapper->GetMessenger();

        // Tell the protocol it should act normally

        messenger->SetNoError();

        CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

        CleanupStack::PushL( listener2 );

        // Get the interfaces

        MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

        MPresencePublishing& presPub = presFeat->PresencePublishing();

        // Setup status event listener for RequestComplete

        listener2->Reset();

        TXIMPRequestId reqIdDummy;  // not checked

        CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        listener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        // Subscribe

        TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

        // Wait for events on the request

        EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

        // verify that SubscribePresenceWatcherListL was called

        COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribePresenceWatcherListL was not called", ETrue, NULL );

        CleanupStack::PopAndDestroy( listener2 );

        }

    for( TInt a = 0; a < countOfWrappers; ++a )

        {

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

        MXIMPContext* context = wrapper->GetContext();

        CXIMPTestMessenger* messenger = wrapper->GetMessenger();

        CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

        CleanupStack::PushL( listener2 );

        // Get the interfaces

        MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

        MPresencePublishing& presPub = presFeat->PresencePublishing();

        // Setup status event listener for RequestComplete

        listener2->Reset();

        TXIMPRequestId reqIdDummy;  // not checked

        CXIMPRequestCompleteEventImp* evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        listener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        // Unsubscribe

        TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();

        // Wait for events on the request

        EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsubscribe failed" );

        // verify that unsubscribe was called

        COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled,

            "UnsubscribePresenceWatcherListL was not called",

            ( a < 2 ) ? EFalse : ETrue,

            "UnsubscribePresenceWatcherListL was called" );

        CleanupStack::PopAndDestroy( listener2 );

        }

    UnbindAllL();

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

void T_PresenceWatcherListManagement::SubscribeL()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresencePublishing& presPub = presFeat->PresencePublishing();

    CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

    CleanupStack::PushL( listener2 );

    // Setup status event listener for RequestComplete

    listener2->Reset();

    TXIMPRequestId reqIdDummy;  // not checked

    CXIMPRequestCompleteEventImp* evReqComplete =

                    CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // subscribe

    TXIMPRequestId reqId = presPub.SubscribePresenceWatcherListL();

    // Wait for events on the request

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Subscribe failed" );

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceWatcherListCalled, "SubscribeWatcherListL was not called", ETrue, NULL );

    CleanupStack::PopAndDestroy( listener2 );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

void T_PresenceWatcherListManagement::UnsubscribeL()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresencePublishing& presPub = presFeat->PresencePublishing();

    // Setup status event listener for RequestComplete

    CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

    CleanupStack::PushL( listener2 );

    // Setup status event listener for RequestComplete

    listener2->Reset();

    TXIMPRequestId reqIdDummy;  // not checked

    CXIMPRequestCompleteEventImp* evReqComplete =

                    CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // unsubscribe

    TXIMPRequestId reqId = presPub.UnsubscribePresenceWatcherListL();

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "Unsbscribe failed" );

    // verify that UnsubscribeWatcherListL was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceWatcherListCalled, "UnsubscribeWatcherListL was not called", ETrue, NULL );

    CleanupStack::PopAndDestroy( listener2 );

    }

// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------

void T_PresenceWatcherListManagement::T_HandlePresenceWatcherList_L()

    {

    EUNIT_PRINT( _L("Handle presence watcher list.") );

    BindL();

    SubscribeL();

    // ------------------------------------------------------

    // some startup stuff

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestListener* listener2 = CXIMPTestListener::NewL( context );

    CleanupStack::PushL( listener2 );

    // ------------------------------------------------------

    // Tell the protocol it should act normally

    wrapper->GetMessenger()->SetNoError();

    // ------------------------------------------------------

    // 1. Create faked server message about watcher list (empty)

    SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceWatcherList );

    // ------------------------------------------------------

    // expect empty MPresencewatcherList event.

    RPrWatLstInfoImpArray* currentList(NULL);

    CPresenceWatcherListEventImp* event = CreateWatcherListEventLCX(

            KNullDesC, KNullDesC,

        MXIMPDataSubscriptionState::ESubscriptionActive,

        MXIMPDataSubscriptionState::EDataAvailable,

        ETestPWlCurrent, currentList);

    listener2->ExpectL( event );

    CleanupStack::Pop( event ); // 3 more items in cleanupstack

    //Waqas: Fixed task Ticket#22

    EUNIT_ASSERT_DESC( KErrNone == listener2->WaitAndAssertL(), "HandlePresenceWatcherListL failed" );

    CleanupStack::PopAndDestroy( 3 ); // lists

    // ------------------------------------------------------

    // ------------------------------------------------------

    // 2. Create faked server message about watcher list (new)

    listener2->Reset();