/*

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

#include <ximpobjectfactory.h>

#include <presencepublishing.h>

#include <presentitypresenceevent.h>

#include <presenceobjectfactory.h>

#include <presencefeatures.h>

#include <presenceinfofield.h>

#include <presenceinfofieldcollection.h>

#include <servicepresenceinfo.h>

#include <devicepresenceinfo.h>

#include <personpresenceinfo.h>

#include <presenceinfofieldvalueenum.h>

#include <presenceinfofieldvaluetext.h>

#include <presenceinfo.h>

#include "t_presencepublishing.h"

#include "prfwtestmessaging.h"

#include "prfwtestmessenger.h"

#include "prfwtestcontextwrappermgr.h"

#include "prfwtestcontextwrapper.h"

#include "prfwtestpresencedatautils.h"

#include "ximprequestcompleteeventimp.h"

#include "ximpcontextstateeventimp.h"

#include "ximpcontextstateimp.h"

#include "ximpstatusimp.h"

#include "ownpresenceeventimp.h"

// new test stuff

#include "prfwtestlistener.h"

#include "prfwtestfilesrvmsg.h"

#include "prfwtestfiletool.h"

#include "prfwtestrobustnesstools.h"

_LIT8( KPrefix1, "PreA_" );

_LIT8( KPrefix2, "PreB_" );

_LIT8( KPrefix3, "PreC_" );

_LIT8( KPrefix4, "PreD_" );

_LIT8( KServiceType, "test_service" );

_LIT(  KStatusMsg, "This is my status." );

const TInt KTestAvailability = 1;

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

// CONSTRUCTION

T_PresencePublishing* T_PresencePublishing::NewL()

    {

    T_PresencePublishing* self = new( ELeave ) T_PresencePublishing;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

T_PresencePublishing::~T_PresencePublishing()

    {

    }

void T_PresencePublishing::ConstructL()

    {

    CEUnitTestSuiteClass::ConstructL();

    }

T_PresencePublishing::T_PresencePublishing()

    {

    }

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

// TEST CASE SETUP & TEARDOWN METHODS

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

//

void T_PresencePublishing::Setup_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresencePublishing::SetupMultiple_L()

    {

    PrfwTestRobustness::DoPreCleaning();

    iWrapperMgr = CXIMPTestContextWrapperMgr::NewL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    iWrapperMgr->CreateWrapperL();

    }

void T_PresencePublishing::BindL()

    {

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

    wrapper0->BindL( 0 );

    }

void T_PresencePublishing::Bind2L()

    {

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

    wrapper0->BindWithSettingsL( 0 );

    }

void T_PresencePublishing::BindAllL()

    {

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

        {

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

        wrapper->BindL( 0 );

        }

    }

void T_PresencePublishing::Teardown()

    {

    delete iWrapperMgr;

    iWrapperMgr = NULL;

    REComSession::FinalClose();

    PrfwTestRobustness::DoPreCleaning();

    }

void T_PresencePublishing::UnbindL()

    {

    // Do unbind

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

    wrapper0->UnbindL();

    }

void T_PresencePublishing::UnbindAllL()

    {

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

        {

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

        wrapper->UnbindL();

        }

    }

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

// TEST CASES for presence publish

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

void T_PresencePublishing::T_Publish_Single_L()

    {

    EUNIT_PRINT( _L("Single Presence Publish test") );

    BindL();

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

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

    // Generate a doc

    CPresenceInfoImp* presInfo =

            XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

    // Tell the protocol it should act normally

    messenger->SetNoError();

    // Publish the presence

    TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presInfo );

    // Setup status event listener

    CXIMPRequestCompleteEventImp* evReqComplete =

                            CXIMPRequestCompleteEventImp::NewLC( reqId );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // Wait for events on the request

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

    COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );

    CleanupStack::PopAndDestroy( presInfo );

    CleanupStack::PopAndDestroy( listener2 );

    UnbindL();

    }

void T_PresencePublishing::T_NetworkUnplugError_L()

	{

    EUNIT_PRINT( _L("Error from plug-in in publish own presence") );

    // Creating the error which comes from KErrTimedOut and protocol sends Connection terminated.

// BIND AND SETUP

    Bind2L();

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

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

// PUBLISH OWN

    //messenger->SetLeave( KErrAbort );

	messenger->SetError(KErrTimedOut);

    // publish own presence in here

    MPresenceInfo* info = CreateInfoLC();

    TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *info );

    // Setup status event listener for RequestComplete

    listener2->Reset();

    // request complete with KErrAbort

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

    evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );

    listener2->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();

    evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

    listener2->ExpectL( evContextEvent );

    CleanupStack::Pop( evContextEvent );

    CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();

    evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

    listener2->ExpectL( evContextEvent2 );

    CleanupStack::Pop( evContextEvent2 );

    listener2->WaitAndAssertL();

// UNBIND

    CleanupStack::PopAndDestroy(1);//info

    CleanupStack::PopAndDestroy( listener2 );

    messenger->SetError( KErrNone );

    UnbindL();

	}    

void T_PresencePublishing::T_NetworkUnplugErrorMultiple_L()

	{

    EUNIT_PRINT( _L("Network disconnect from plug-in in publish own presence, multiple contexts") );

	// Bind 2 contexts

	BindAllL();

	/* 

	 * Make the 1st client publish someting and then the disconnect would happen 

	 */

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

    MXIMPContext* context0 = wrapper0->GetContext();

    CXIMPTestMessenger* messenger0 = wrapper0->GetMessenger();

    CXIMPTestListener* listener0 = CXIMPTestListener::NewL( context0);

    CleanupStack::PushL( listener0);

    MPresenceFeatures* presFeat0 = wrapper0->GetPresenceFeatures();

    MPresencePublishing& presPub0 = presFeat0->PresencePublishing();

    //messenger->SetLeave( KErrAbort );

	messenger0->SetError(KErrTimedOut);

    // publish own presence in here

    MPresenceInfo* info = CreateInfoLC();

    TXIMPRequestId reqId = presPub0.PublishOwnPresenceL( *info );

    /* Setup status event listener for RequestComplete for client 1 */

    listener0->Reset();

    // request complete with KErrTimedOut

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

    evReqComplete->CompletionResultImp().SetResultCode( KErrTimedOut );

    listener0->ExpectL( evReqComplete );

    CleanupStack::Pop( evReqComplete );

    // Create the context state events for unbinding

    CXIMPContextStateEventImp* evContextEvent = CXIMPContextStateEventImp::NewLC();

    evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

    listener0->ExpectL( evContextEvent );

    CleanupStack::Pop( evContextEvent );

    CXIMPContextStateEventImp* evContextEvent2 = CXIMPContextStateEventImp::NewLC();

    evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

    listener0->ExpectL( evContextEvent2 );

    CleanupStack::Pop( evContextEvent2 );

   	/* 

   	 * Create a request for client 2, this will not be processed by the protocol plug-in 

   	 */

	CXIMPTestContextWrapper* wrapper1 = iWrapperMgr->GetWrapperL( 1 );

    MXIMPContext* context1 = wrapper1->GetContext();

    MPresenceFeatures* presFeat1 = wrapper1->GetPresenceFeatures();

    MPresencePublishing& presPub1 = presFeat1->PresencePublishing();

    // Create the empty presence info filter

    CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();

    TXIMPRequestId reqId1 = presPub1.SubscribeOwnPresenceL( *pif );

	CleanupStack::PopAndDestroy(pif);

    // Setup status event listener for RequestComplete

    CXIMPTestListener* listener1 = CXIMPTestListener::NewL( context1);

    CleanupStack::PushL( listener1);

    listener1->Reset();

    // normal request complete

    CXIMPRequestCompleteEventImp* evReqComplete1 = CXIMPRequestCompleteEventImp::NewLC( reqId1 );

    evReqComplete1->CompletionResultImp().SetResultCode( KErrTimedOut );

    listener1->ExpectL( evReqComplete1 );

    CleanupStack::Pop( evReqComplete1 );

    // Create the context state events for unbinding

    evContextEvent = CXIMPContextStateEventImp::NewLC();

    evContextEvent->ContextStateImp().SetStateValue( MXIMPContextState::EUnbinding);

    listener1->ExpectL( evContextEvent );

    CleanupStack::Pop( evContextEvent );

    evContextEvent2 = CXIMPContextStateEventImp::NewLC();

    evContextEvent2->ContextStateImp().SetStateValue( MXIMPContextState::EInactive);

    listener1->ExpectL( evContextEvent2 );

    CleanupStack::Pop( evContextEvent2 );

    // Wait for events on the request

    EUNIT_ASSERT_DESC( KErrNone == listener0->WaitAndAssertL(), "Publish own presence failed in client 1");

    EUNIT_ASSERT_DESC( KErrNone == listener1->WaitAndAssertL(), "SubscribeOwnPresence failed in client 2" );

    CleanupStack::PopAndDestroy( listener1 );

    CleanupStack::PopAndDestroy(1);//info

    CleanupStack::PopAndDestroy( listener0 );

	// Finish the test case	

	UnbindAllL();	

	}

void T_PresencePublishing::T_Publish_ErrFromPlg_Leave_L()

    {

    EUNIT_PRINT( _L("Single Presence Publish test") );

    EUNIT_PRINT( _L("Plugin leaves from PublishOwnPresenceL") );

    BindL();

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

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

    // Generate a doc

    CPresenceInfoImp* presDoc =

                XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

    // Setup status event listener

    SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

    // Tell the test protocol to leave on next operation

    messenger->SetLeave( KErrAbort );

    // Publish the presence

    TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Publishing single presence, leave with error: ") );

    // Verify that plugin left and didn't go through the PublishOwnPresenceL.

    COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called",

                                                EFalse, "PublishPresenceL was called." );

    // TODO wait and verify the events

    EUNIT_FAIL_TEST( "Under construction." );

    CleanupStack::PopAndDestroy( presDoc );

    CleanupStack::PopAndDestroy( listener2 );

    UnbindL();

    }

void T_PresencePublishing::T_Publish_ErrFromPlg_CompleteWithError_L()

    {

    EUNIT_PRINT( _L("Single Presence Publish test") );

    EUNIT_PRINT( _L("Plugin completes PublishOwnPresenceL with error") );

    BindL();

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

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

    // Generate a doc

    CPresenceInfoImp* presDoc =

                XIMPTestPresenceDataUtils::GenerateInfoLC( &KPrefix1 );

    // Setup status event listener:

    //TODO  Setup presence event listener

    SetupListenerReqCompleteL( wrapper, EXIMPTestStatusEvents_RequestOk );

    // Tell the test protocol to return with error on next operation

    messenger->SetError( KErrAbort );

    // Publish the presence

    TXIMPRequestId reqId = presPub.PublishOwnPresenceL( *presDoc );

    // Wait for events on the request

    wrapper->WaitRequestAndStackEvents( reqId );

    wrapper->VerifyEventStackL( _L8("Publishing single presence, complete with error: ") );

    // Verify that we did go through PublishOwnPresenceL.

    COMMONASSERT( messenger, EXIMPPlgTestPublishPresenceCalled, "PublishPresenceL was not called", ETrue, NULL );

    // TODO wait and verify presence events

    EUNIT_FAIL_TEST( "Under construction." );

    CleanupStack::PopAndDestroy( presDoc );

    CleanupStack::PopAndDestroy( listener2 );

    UnbindL();

    }

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

// TEST CASES for presence interest registration

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

// Single client, empty filter

void T_PresencePublishing::T_SubscribeOwnPresence_Single_Empty_L()

    {

    EUNIT_PRINT( _L("Single interest registration") );

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

    // Create the empty presence info filter

    CPresenceInfoFilterImp* pif = CPresenceInfoFilterImp::NewLC();

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