/*

* 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:

*

*/

#include "eunittools.h"

#include <ecom/ecom.h>

#include <badesca.h>

#include <presencefeatures.h>

#include <presenceauthorization.h>

#include <presenceblocklistevent.h>

#include <presenceblockinfo.h>

#include <ximpclient.h>

#include <ximpcontext.h>

#include <presencefeatures.h>

#include "t_presenceblocking.h"

// blocking includes

#include "presenceblockinfoimp.h"

#include "presenceblocklisteventimp.h"

// other datamodel and utils includes

#include "ximpidentityimp.h"

#include "ximpobjecthelpers.h"

// testing tool includes

#include "prfwtestpresencedatautils.h"

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestcontextwrappermgr.h"

#include "prfwtestcontextwrapper.h"

#include "prfwtestfilesrvmsg.h"

#include "prfwtestfiletool.h"

#include "prfwtestlistener.h"

#include "ximprequestcompleteeventimp.h"

#include "prfwtestrobustnesstools.h"

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

// CONSTRUCTION

T_PresenceBlocking* T_PresenceBlocking::NewL()

    {

    T_PresenceBlocking* self = new( ELeave ) T_PresenceBlocking;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

T_PresenceBlocking::~T_PresenceBlocking()

    {

    PrfwTestRobustness::DoPreCleaning();

    }

void T_PresenceBlocking::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

T_PresenceBlocking::T_PresenceBlocking()

    {

    }

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

// TEST CASE SETUP & TEARDOWN METHODS

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

//

void T_PresenceBlocking::Setup_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresenceBlocking::SetupMultiple_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresenceBlocking::BindL()

    {

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

    wrapper0->BindL( 0 );

    }

void T_PresenceBlocking::BindAllL()

    {

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

        {

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

        wrapper->BindL( 0 );

        }

    }

void T_PresenceBlocking::Teardown()

    {

    delete iWrapperMgr;

    iWrapperMgr = NULL;

    REComSession::FinalClose();

    PrfwTestRobustness::DoPreCleaning();

    }

void T_PresenceBlocking::UnbindL()

    {

    // Do unbind

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

    wrapper0->UnbindL();

    }

void T_PresenceBlocking::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_PresenceBlocking::T_SubscribeBlockList_Single_L()

    {

    EUNIT_PRINT( _L("Single presence block 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();

    MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

    // 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 = presAuth.SubscribePresenceBlockListL();

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

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

    // verify that SubscribeBlockListL was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceBlockListCalled, "SubscribeBlockListL was not called", ETrue, NULL );

    // Setup status event listener for RequestComplete

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

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

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

    // unsubscribe

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

    reqId = presAuth.UnsubscribePresenceBlockListL();

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

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

    // verify that UnsubscribeBlockListL was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceBlockListCalled, "UnsubscribeBlockListL was not called", ETrue, NULL );

    // Deinitiliaze event source from listener.

    listener2->SetEventSourceL( NULL );

    UnbindL();

    //CleanupStack::Pop(presFeat);

    //delete presFeat;

    //CleanupStack::PopAndDestroy();

    CleanupStack::PopAndDestroy( listener2 );

    }

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

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

// Single client, empty filter

void T_PresenceBlocking::T_SubscribeBlockListRefresh_Single_L()

    {

    EUNIT_PRINT( _L("Single presence block list subscription refresh") );

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

    MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

    // 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 = presAuth.SubscribePresenceBlockListL();

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

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

    // verify that SubscribeBlockListL was called

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceBlockListCalled, "SubscribeBlockListL was not called", ETrue, NULL );

    // Setup status event listener for RequestComplete

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

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    RPrBlockInfoImpArray* currentList(NULL);

    CPresenceBlockListEventImp* event = CreateBlockListEventLCX(

        KNullDesC, KNullDesC,

        MXIMPDataSubscriptionState::ESubscriptionActive,

        MXIMPDataSubscriptionState::EDataUnavailable,

        ETestPBlCurrent, currentList );

    listener2->ExpectL( event );

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

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

    // subscribe again

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

    reqId = presAuth.SubscribePresenceBlockListL();

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

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

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

    // Setup status event listener for RequestComplete

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

    listener2->Reset();

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

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

    // unsubscribe

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

    reqId = presAuth.UnsubscribePresenceBlockListL();

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

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

    // verify that UnsubscribeBlockListL was called

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceBlockListCalled, "UnsubscribeBlockListL was not called", ETrue, NULL );

    listener2->SetEventSourceL( NULL );

    UnbindL();

    CleanupStack::PopAndDestroy( listener2 );

    }

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

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

// Single client, empty filter

void T_PresenceBlocking::T_SubscribeBlockList_Multiple_L()

    {

    EUNIT_PRINT( _L("Multiple presence block list subscription") );

    BindAllL();

    TInt countOfWrappers = iWrapperMgr->WrapperCount();

    TInt a(0);

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

        {

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

        MXIMPContext* context = wrapper->GetContext();

        CXIMPTestMessenger* messenger = wrapper->GetMessenger();

        // Get the interfaces

        MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

        MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

        CleanupStack::PushL( listener2 );

        // Tell the protocol it should act normally

        messenger->SetNoError();

        // expect normal request complete

        TXIMPRequestId reqIdDummy;  // not checked

        CXIMPRequestCompleteEventImp* evReqComplete =

                                CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        listener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        // subscribe

        TXIMPRequestId reqId = presAuth.SubscribePresenceBlockListL();

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

        // verify that SubscribePresenceBlockListL was called

        COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceBlockListCalled, "SubscribePresenceBlockListL was not called", ETrue, NULL );

        CleanupStack::PopAndDestroy( listener2 );

        }

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

        {

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

        MXIMPContext* context = wrapper->GetContext();

        CXIMPTestMessenger* messenger = wrapper->GetMessenger();

        // Get the interfaces

        MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

        MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

        CleanupStack::PushL( listener2 );

        // Tell the protocol it should act normally

        messenger->SetNoError();

        // expect normal request complete

        TXIMPRequestId reqIdDummy;  // not checked

        CXIMPRequestCompleteEventImp* evReqComplete =

                            CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        listener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        // unsubscribe

        TXIMPRequestId reqId = presAuth.UnsubscribePresenceBlockListL();

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

        // verify that EXIMPPlgTestUnsubscribeBlockListCalled was called

        COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceBlockListCalled,

                "UnsubscribePresenceBlockListL was not called",

                ( a < 2 ) ? EFalse : ETrue,

                "UnsubscribePresenceBlockListL was called" );

        CleanupStack::PopAndDestroy( listener2 );

        }

    UnbindAllL();

    }

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

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

void T_PresenceBlocking::SubscribeL()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

    CleanupStack::PushL( listener2 );

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

    // expect normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

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

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

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

    // subscribe

    TXIMPRequestId reqId = presAuth.SubscribePresenceBlockListL();

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

    COMMONASSERT( messenger, EXIMPPlgTestSubscribePresenceBlockListCalled, "SubscribeBlockListL was not called", ETrue, NULL );

    CleanupStack::PopAndDestroy( listener2 );

    }

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

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

void T_PresenceBlocking::UnsubscribeL()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresenceAuthorization& presAuth = presFeat->PresenceAuthorization();

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

    CleanupStack::PushL( listener2 );

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

    // expect normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

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

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

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

    // unsubscribe

    TXIMPRequestId reqId = presAuth.UnsubscribePresenceBlockListL();

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

    COMMONASSERT( messenger, EXIMPPlgTestUnsubscribePresenceBlockListCalled, "UnsubscribeBlockListL was not called", ETrue, NULL );

    CleanupStack::PopAndDestroy( listener2 );

    }

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

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

void T_PresenceBlocking::T_HandlePresenceBlockList_L()

    {

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

    // log in and subscribe a block 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 block list

    SendSrvMsgL( CXIMPTestFileSrvMsg::ETestSrvMsgPresenceBlockList );

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

    // expect current(empty) MPresenceBlockList event.

    RPrBlockInfoImpArray* currentList(NULL);

    CPresenceBlockListEventImp* event = CreateBlockListEventLCX(

            KNullDesC, KNullDesC,

            MXIMPDataSubscriptionState::ESubscriptionActive,

            MXIMPDataSubscriptionState::EDataAvailable,

            ETestPBlCurrent, currentList);

    listener2->ExpectL( event );

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

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

    CleanupStack::PopAndDestroy( 4 ); // lists

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