/*

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

#include <ximpclient.h>

#include <ximpcontext.h>

#include <ximpobjectfactory.h>

#include <ximpcontextstateevent.h>

#include <ximprequestcompleteevent.h>

#include <ximpstatus.h>

#include <presencefeatures.h>

#include <presentitygroups.h>

#include <presentitygroupmemberinfo.h>

#include <presentitygroupcontentevent.h>

#include "ximpeventcodec.h"

#include "t_presencegroupmembermngt.h"

#include "prfwteststatuseventlistener.h"

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestlistener.h"

#include "prfwtestcontextwrappermgr.h"

#include "prfwtestcontextwrapper.h"

#include "ximpcontextstateeventimp.h"

#include "ximpcontextstateevent.h"

#include "presenceinfoimp.h"

#include "presenceinfofilterimp.h"

#include "prfwtestpresencedatautils.h"

#include "ximpidentityimp.h"

#include "presentitygroupcontenteventimp.h"

#include "ximprequestcompleteeventimp.h"

#include "presentitygroupinfoimp.h"

#include "presentitygrouplisteventimp.h"

#include "presentitygroupmemberinfoimp.h"

#include "ximprequestcompleteeventimp.h"

#include "ximprestrictedobjectcollection.h"

#include "ximpobjectfactoryimp.h"

#include "prfwtestrobustnesstools.h"

#include "ximpobjecthelpers.h"

#include "prfwtestfilesrvmsg.h"

#include "prfwtestfiletool.h"

#include "prfwtestwaithelper.h"

#include "prfwtesteventfactory.h"

_LIT( KGroupId,   "wv:group/member@imps.com" );

_LIT( KGroupId2,  "wv:group2/chutney@naan.com" );

_LIT( KGroupDisplayName, "Salamapartio Z" );

_LIT( KMemberId, "wv:member@imps.com" );

_LIT( KMemberDisplayName,  "Stroustrup" );

_LIT( KMemberDisplayName2, "Bjarne" );

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

// CONSTRUCTION

T_PresenceGroupMemberManagement* T_PresenceGroupMemberManagement::NewL()

    {

    T_PresenceGroupMemberManagement* self = new( ELeave ) T_PresenceGroupMemberManagement;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

T_PresenceGroupMemberManagement::~T_PresenceGroupMemberManagement()

    {

    delete iLastEvent;

    if ( iASWait && iASWait->IsStarted() )

        {

        iASWait->AsyncStop();

        }

    delete iASWait;

    delete iListener2;

    delete iCurrentGrId;

    }

void T_PresenceGroupMemberManagement::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    iASWait = new ( ELeave ) CActiveSchedulerWait();

    }

T_PresenceGroupMemberManagement::T_PresenceGroupMemberManagement()

    {

    }

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

// TEST CASE SETUP & TEARDOWN METHODS

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

//

void T_PresenceGroupMemberManagement::Setup_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    // must reset these to EFalse

    iSkipSubscribe = EFalse;

    iSkipUnsubscribe = EFalse;

    }

void T_PresenceGroupMemberManagement::SetupMultiple_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    // must reset these to EFalse

    iSkipSubscribe = EFalse;

    iSkipUnsubscribe = EFalse;

    }

// bind helper

void T_PresenceGroupMemberManagement::BindAllL()

    {

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

        {

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

        wrapper->BindL( 0 );

        }

    }

// unbind helper

void T_PresenceGroupMemberManagement::UnbindAllL()

    {

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

        {

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

        wrapper->UnbindL();

        }

    }

void T_PresenceGroupMemberManagement::TeardownTestSupport()

    {

    // anything NOT initialized by test case Setup method,

    // but initialized in the test case itself, goes here

    delete iCurrentGrId;

    iCurrentGrId = NULL;

    delete iListener2;

    iListener2 = NULL;

    delete iLastEvent;

    iLastEvent = NULL;

    }

void T_PresenceGroupMemberManagement::Teardown()

    {

    TeardownTestSupport();

    // just in case to avoid memleaks. should not have anything to

    // delete anyway

    delete iWrapperMgr;

    iWrapperMgr = NULL;

    REComSession::FinalClose();

    // must reset these to EFalse

    iSkipSubscribe = EFalse;

    iSkipUnsubscribe = EFalse;

    // it's best to nuke the servers during exit too.

    PrfwTestRobustness::DoPreCleaning();

    }

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

// TEST CASES for presentity presence subscription

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

// General test case for single member

void T_PresenceGroupMemberManagement::T_GenericSubAndUnsubL(

        TXIMPCallBack& aCbFuncL )

    {

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

    wrapper->BindL( 0 );

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

    // some startup stuff

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresentityGroups& presGroup = presFeat->PresentityGroups();

    iListener2 = CXIMPTestListener::NewL( context );

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

    // Tell the protocol it should act normally

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

    iCurrentGrId = context->ObjectFactory().NewIdentityLC();

    CleanupStack::Pop(); // iCurrentGrId

    iCurrentGrId->SetIdentityL( KGroupId );

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

    // create presentity group

    //

    // expect events:

    // - request complete.

    // NOTE: no presentitygrouplistevent as we've not subscribed the group lists

    // normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

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

    // identity + displayname

    CPresentityGroupInfoImp* infoImp = CPresentityGroupInfoImp::NewLC( *iCurrentGrId, KGroupDisplayName );

    evReqComplete->AppendParamL( infoImp );

    CleanupStack::Pop( infoImp );

    iListener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    TXIMPRequestId reqId = presGroup.CreatePresentityGroupL( *iCurrentGrId, KGroupDisplayName );

    // and wait

    EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "CreatePresentityGroupL failed" );

    messenger->AssertCreatePresentityGroupCalled( ETrue );

    if ( ! iSkipSubscribe )

        {

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

        // subscribe presentity group CONTENT

        //

        // expect events:

        // - request complete

        evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        iListener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        // do the call

        reqId = presGroup.SubscribePresentityGroupContentL( *iCurrentGrId );

        // and wait

        EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "SubscribePresentityGroupContentL failed" );

        // verify that subscribe was called

        messenger->AssertSubscribePresentityGroupContentCalled( ETrue );

        }

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

    // do the actual test. this is a function pointer because the

    // "red tape" of each test is similar (create group, subscribe content, do

    // actual test, unsubscribe content, delete group) - this is the variable

    // part, the "do actual test".

    (this->*aCbFuncL)();

    if ( ! iSkipUnsubscribe )

        {

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

        // unsubscribe presentity group content

        //

        // expect events:

        // - request complete

        // - presentity group content event

        evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

        iListener2->ExpectL( evReqComplete );

        CleanupStack::Pop( evReqComplete );

        CPresentityGroupContentEventImp* groupCntEvent =

            XIMPTestEventFactory::CreateGroupContentEventLCX(

                    KGroupId,

                    KNullDesC,

                    KNullDesC,

                    XIMPTestEventFactory::ETestPGLCntRemoved,

                    KNullDesC,

                    KNullDesC,

                    MXIMPDataSubscriptionState::ESubscriptionInactive,

                    MXIMPDataSubscriptionState::EDataUnavailable

                    );

        iListener2->ExpectL( groupCntEvent );

        CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

        // do the call

        reqId = presGroup.UnsubscribePresentityGroupContentL( *iCurrentGrId );

        // and wait

        EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "UnsubscribePresentityGroupContentL failed" );

        CleanupStack::PopAndDestroy( 5 ); // lists

        // verify that unsubscribe was called

        messenger->AssertUnsubscribePresentityGroupContentCalled( ETrue );

        }

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

    // delete presentity group

    //

    // expect events:

    // - request complete

    // NO presentity group content event as we've just unsubscribed it.

    evReqComplete = CXIMPRequestCompleteEventImp::NewLC( reqIdDummy );

    iListener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // do the call

    reqId = presGroup.DeletePresentityGroupL( *iCurrentGrId );

    // and wait

    EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "DeletePresentityGroupL failed" );

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

    // make sure the new listener is not listening for events!

    iListener2->SetEventSourceL( NULL );

    wrapper->UnbindL();

    TeardownTestSupport();

    }

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

// Variant methods, this is where the actual testing happens.

// Called by the generic subscribe and unsubscribe -method

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

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

// empty test variant method

// test only the creation, subscribe and unsubcscribe

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

//

void T_PresenceGroupMemberManagement::T_EmptyFunc()

    {

    // nothing

    }

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

// test adding members

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

//

void T_PresenceGroupMemberManagement::T_TestAddMembersL()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresentityGroups& presGroup = presFeat->PresentityGroups();

    // Tell the protocol it should act normally

    messenger->SetNoError();

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

    // add presentity group member

    //

    // expect events:

    // - request complete,

    // - presentitygroupcontentevent

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

    member->SetIdentityL( KMemberId );

    // normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

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

    // group id

    CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

    evReqComplete->AppendParamL( identity );

    CleanupStack::Pop(); // identity

    // id for member info

    CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId );

    // member info

    CPresentityGroupMemberInfoImp* memInfoImp =

        CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName );

    evReqComplete->AppendParamL( memInfoImp );

    CleanupStack::Pop(); // memInfoImp owned by AppendParamL

    CleanupStack::PopAndDestroy( miId ); // copy was made

    iListener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // group content event

    CPresentityGroupContentEventImp* groupCntEvent =

        XIMPTestEventFactory::CreateGroupContentEventLCX(

                iCurrentGrId->Identity(),

                KMemberId,

                KMemberDisplayName,

                XIMPTestEventFactory::ETestPGLCntAdded,

                KMemberId,

                KMemberDisplayName,

                MXIMPDataSubscriptionState::ESubscriptionActive,

                MXIMPDataSubscriptionState::EDataAvailable

                );

    iListener2->ExpectL( groupCntEvent );

    CleanupStack::Pop( groupCntEvent ); // 5 more items in cleanupstack

    // do the call

    TXIMPRequestId reqId = presGroup.AddPresentityGroupMemberL(

            *iCurrentGrId, *member, KMemberDisplayName );

    // and wait

    EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "AddPresentityGroupMemberL failed" );

    CleanupStack::PopAndDestroy( 5 ); // lists from groupCntEvent

    messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

    CleanupStack::PopAndDestroy(); // member

    }

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

// test adding members when not subscribed

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

//

void T_PresenceGroupMemberManagement::T_TestAddMembers_NonSub_L()

    {

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresentityGroups& presGroup = presFeat->PresentityGroups();

    // Tell the protocol it should act normally

    messenger->SetNoError();

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

    // add presentity group member

    //

    // expect events:

    // - request complete,

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

    member->SetIdentityL( KMemberId );

    // normal request complete

    TXIMPRequestId reqIdDummy;  // not checked

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

    // group id

    CXIMPIdentityImp* identity = CXIMPIdentityImp::NewLC( iCurrentGrId->Identity() );

    evReqComplete->AppendParamL( identity );

    CleanupStack::Pop(); // identity

    // id for member info

    CXIMPIdentityImp* miId = CXIMPIdentityImp::NewLC( KMemberId );

    // member info

    CPresentityGroupMemberInfoImp* memInfoImp =

        CPresentityGroupMemberInfoImp::NewLC( *miId, KMemberDisplayName );

    evReqComplete->AppendParamL( memInfoImp );

    CleanupStack::Pop(); // memInfoImp owned by AppendParamL

    CleanupStack::PopAndDestroy( miId ); // copy was made

    iListener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // do the call

    TXIMPRequestId reqId = presGroup.AddPresentityGroupMemberL(

            *iCurrentGrId, *member, KMemberDisplayName );

    // and wait

    EUNIT_ASSERT_DESC( KErrNone == iListener2->WaitAndAssertL(), "AddPresentityGroupMemberL failed" );

    messenger->AssertAddPresentityGroupMemberCalled( ETrue );

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

    CleanupStack::PopAndDestroy(); // member

    }

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

// test removing members

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

//

void T_PresenceGroupMemberManagement::T_TestRemoveMembersL()

    {

    // add a member

    T_TestAddMembersL();

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

    MXIMPContext* context = wrapper->GetContext();

    CXIMPTestMessenger* messenger = wrapper->GetMessenger();

    // Get the interfaces

    MPresenceFeatures* presFeat = wrapper->GetPresenceFeatures();

    MPresentityGroups& presGroup = presFeat->PresentityGroups();

    // Tell the protocol it should act normally

    messenger->SetNoError();

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

    // remove presentity group member

    //

    // expect events:

    // - request complete,