/*

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

*

*/

// CLASS HEADER

#include "MT_CFServices.h"

// EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <S32MEM.H>

// INTERNAL INCLUDES

#include "CFActionIndicationImpl.h"

#include "CFActionSubscriptionImpl.h"

#include "CFContextIndicationImpl.h"

#include "cfcontextobjectimpl.h"

#include "CFContextQueryImpl.h"

#include "CFContextSubscriptionImpl.h"

#include "CFKeyValuePair.h"

#include "cfserviceutils.h"

#include "cfcontextdataproxy.h"

// CONSTANTS

_LIT( KKey, "Key_%d" );

_LIT( KValue, "Value_%d" );

_LIT( KActionId, "ActionID" );

_LIT( KShortActionId, "ActID" );

_LIT( KLongActionId, "LongActionIdentifier" );

static const TInt KParamCount = 10;

_LIT( KContextSource, "ContextSource" );

_LIT( KContextSourceLong, "ContextSourceQuiteABitLonger" );

_LIT( KContextType, "ContextType" );

_LIT( KContextTypeLong, "ContextTypeQuiteABitLonger" );

_LIT( KContextValue, "ContextValue" );

_LIT( KContextValueLong, "ContextValueQuiteABitLonger" );

// CONSTRUCTION

MT_CFServices* MT_CFServices::NewL()

    {

    MT_CFServices* self = MT_CFServices::NewLC();

    CleanupStack::Pop();

    return self;

    }

MT_CFServices* MT_CFServices::NewLC()

    {

    MT_CFServices* self = new( ELeave ) MT_CFServices();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

MT_CFServices::~MT_CFServices()

    {

    Teardown();

    }

// Default constructor

MT_CFServices::MT_CFServices()

    {

    }

// Second phase construct

void MT_CFServices::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

// METHODS

void MT_CFServices::ActionIndicationL( CCFActionIndication* /*aIndication*/ )

    {

    }

void MT_CFServices::ContextIndicationL( CCFContextIndication* aIndication )

    {

    delete iIndicatedContext;

    iIndicatedContext = NULL;

    iIndicatedContext = CCFContextObject::NewL();

    iIndicatedContext->CopyL( aIndication->Context() );

    delete aIndication;

    }

TInt MT_CFServices::Client( RThread& /*aThread*/ ) const

    {

    return KErrNone;

    }

void MT_CFServices::HandleContextSubscriptionError( TInt /*aError*/,

    const TDesC& /*aSource*/,

    const TDesC& /*aType*/ )

    {

    }

void MT_CFServices::SetupL(  )

    {

    }

void MT_CFServices::SetupActionIndicationL(  )

    {

    iActionIndication = CCFActionIndicationImpl::NewL();

    }

void MT_CFServices::Teardown(  )

    {

    delete iActionIndication;

    iActionIndication = NULL;

    delete iIndicatedContext;

    iIndicatedContext = NULL;

    }

CCFActionIndicationImpl* MT_CFServices::ConfigureActionIndicationL(

    const TDesC& aActionId,

    TInt aNumOfParams )

    {

    TBuf<20> key( KNullDesC );

    TBuf<20> value( KNullDesC );

    CCFActionIndicationImpl* actionIndication = CCFActionIndicationImpl::NewLC();

    if( aActionId.Length() )

        {

        actionIndication->SetIdentifierL( aActionId );

        }

    for( TInt i = 0; i < aNumOfParams; i++ )

        {

        key.Format( KKey, i );

        value.Format( KValue, i );

        actionIndication->AddParameterL( key, value );

        }

    CleanupStack::Pop( actionIndication );

    return actionIndication;

    }

CCFActionSubscriptionImpl* MT_CFServices::ConfigureActionSubscriptionL(

    const TDesC& aActionId )

    {

    CCFActionSubscriptionImpl* actionSubscription =

        CCFActionSubscriptionImpl::NewLC();

    if( aActionId.Length() )

        {

        actionSubscription->SetActionIdentifierL( aActionId );

        }

    CleanupStack::Pop( actionSubscription );

    return actionSubscription;

    }

CCFContextObjectImpl* MT_CFServices::ConfigureContextObjectLC(

    const TDesC& aSource,

    const TDesC& aType,

    const TDesC& aValue,

    TUint aConfidence,

    const TTime& aTime )

    {

    CCFContextObjectImpl* context = CCFContextObjectImpl::NewLC();

    if( aSource.Length() )

        {

        context->SetSourceL( aSource );

        }

    if( aType.Length() )

        {

        context->SetTypeL( aType );

        }

    if( aValue.Length() )

        {

        context->SetValueL( aValue );

        }

    context->SetConfidence( aConfidence );

    context->SetTimestamp( aTime );

    return context;

    }

CCFContextSubscriptionImpl* MT_CFServices::ConfigureContextSubscriptionLC(

    const TDesC& aSource,

    const TDesC& aType,

    TBool aSubTypeMatch,

    TBool aIndicateOnlyChanges )

    {

    CCFContextSubscriptionImpl* subscription = CCFContextSubscriptionImpl::NewLC();

    if( aSource.Length() )

        {

        subscription->SetContextSourceL( aSource );

        }

    if( aType.Length() )

        {

        subscription->SetContextTypeL( aType );

        }

    subscription->SetSubTypeMatch( aSubTypeMatch );

    subscription->SetOnlyChangesIndicated( aIndicateOnlyChanges );

    return subscription;

    }

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

// CCFActionIndication class unit test cases

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

//

void MT_CFServices::MT_CCFActionIndication_NewLL(  )

    {

    CCFActionIndication* instance = CCFActionIndication::NewL();

    CleanupStack::PushL( instance );

    EUNIT_ASSERT_DESC( instance, "CCFActionIndication class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionIndication_NewLCL(  )

    {

    CCFActionIndication* instance = CCFActionIndication::NewLC();

    EUNIT_ASSERT_DESC( instance, "CCFActionIndication class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

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

// CCFActionIndicationImpl class unit test cases

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

//

void MT_CFServices::MT_CCFActionIndicationImpl_NewLL(  )

    {

    CCFActionIndicationImpl* instance = CCFActionIndicationImpl::NewL();

    CleanupStack::PushL( instance );

    EUNIT_ASSERT_DESC( instance, "CCFActionIndicationImpl class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionIndicationImpl_NewLCL(  )

    {

    CCFActionIndicationImpl* instance = CCFActionIndicationImpl::NewLC();

    EUNIT_ASSERT_DESC( instance, "CCFActionIndicationImpl class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionIndicationImpl_SetIdentifierLL(  )

    {

    TPtrC id( KNullDesC );

    id.Set( iActionIndication->Identifier() );

    EUNIT_ASSERT_DESC( id == KNullDesC, "Invalid action ID!" );

    iActionIndication->SetIdentifierL( KActionId );

    id.Set( iActionIndication->Identifier() );

    EUNIT_ASSERT_DESC( id == KActionId, "Invalid action ID!" );

    iActionIndication->SetIdentifierL( KShortActionId );

    id.Set( iActionIndication->Identifier() );

    EUNIT_ASSERT_DESC( id == KShortActionId, "Invalid action ID!" );

    iActionIndication->SetIdentifierL( KLongActionId );

    id.Set( iActionIndication->Identifier() );

    EUNIT_ASSERT_DESC( id == KLongActionId, "Invalid action ID!" );

    }

void MT_CFServices::MT_CCFActionIndicationImpl_AddParameterLL(  )

    {

    TInt count = 0;

    TBuf<20> key( KNullDesC );

    TBuf<20> value( KNullDesC );

    count = iActionIndication->Parameters().Count();

    EUNIT_ASSERT_DESC( !count, "Invalid parameter count!" );

    delete iActionIndication;

    iActionIndication = NULL;

    iActionIndication = ConfigureActionIndicationL( KActionId, KParamCount );

    count = iActionIndication->Parameters().Count();

    EUNIT_ASSERT_DESC( count == KParamCount, "Invalid parameter count!" );

    const RKeyValueArray& params = iActionIndication->Parameters();

    for( TInt i = 0; i < KParamCount; i++ )

        {

        key.Format( KKey, i );

        EUNIT_ASSERT_DESC( key == params[i]->Key(), "Invalid key!" );

        value.Format( KValue, i );

        EUNIT_ASSERT_DESC( value == params[i]->Value(), "Invalid value!" );

        }

    }

void MT_CFServices::MT_CCFActionIndicationImpl_ExternalizeLL(  )

    {

    TInt size = 0;

    CCFActionIndicationImpl* actionIndication = NULL;

    static const TInt KCount = 2;

    for( TInt i = 0; i < KCount; i++ )

        {

        switch( i )

            {

            case 0:

                {

                // Create action indication

                actionIndication = ConfigureActionIndicationL( KActionId, KParamCount );

                CleanupStack::PushL( actionIndication );

                break;

                }

            case 1:

            default:

                {

                // Create action indication

                actionIndication = ConfigureActionIndicationL( KNullDesC, KParamCount * 2 );

                CleanupStack::PushL( actionIndication );

                break;

                }

            }

        // Externalize

        size = actionIndication->Size();

        HBufC8* buffer = HBufC8::NewLC( size );

        TPtr8 bufferPtr = buffer->Des();

        RDesWriteStream writeStream( bufferPtr );

        writeStream.PushL();

        actionIndication->ExternalizeL( writeStream );

        CleanupStack::PopAndDestroy( &writeStream );

        // Internalize

        CCFActionIndicationImpl* newActionIndication = CCFActionIndicationImpl::NewLC();

        RDesReadStream readStream( bufferPtr );

        readStream.PushL();

        newActionIndication->InternalizeL( readStream );

        // Clean up

        CleanupStack::PopAndDestroy( &readStream );

        // Check result

        EUNIT_ASSERT_DESC(

            actionIndication->Identifier() == newActionIndication->Identifier(),

                "Invalid identifier!" );

        EUNIT_ASSERT_DESC(

            actionIndication->Parameters().Count() == newActionIndication->Parameters().Count(),

                "Invalid parameter count!");

        TInt count = actionIndication->Parameters().Count();

        for( TInt i = 0; i < count; i++ )

            {

            EUNIT_ASSERT_DESC(

                actionIndication->Parameters()[i]->Key() == newActionIndication->Parameters()[i]->Key(),

                    "Invalid key!" );

            EUNIT_ASSERT_DESC(

                actionIndication->Parameters()[i]->Value() == newActionIndication->Parameters()[i]->Value(),

                    "Invalid value!" );

            }

        // Clean up

        CleanupStack::PopAndDestroy( newActionIndication );

        CleanupStack::PopAndDestroy( buffer );

        CleanupStack::PopAndDestroy( actionIndication );

        }

    }

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

// CCFActionSubscription class unit test cases

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

//

void MT_CFServices::MT_CCFActionSubscription_NewLL(  )

    {

    CCFActionSubscription* instance = CCFActionSubscription::NewL();

    CleanupStack::PushL( instance );

    EUNIT_ASSERT_DESC( instance, "CCFActionSubscription class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionSubscription_NewLCL(  )

    {

    CCFActionSubscription* instance = CCFActionSubscription::NewLC();

    EUNIT_ASSERT_DESC( instance, "CCFActionSubscription class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

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

// CCFActionSubscriptionImpl class unit test cases

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

//

void MT_CFServices::MT_CCFActionSubscriptionImpl_NewLL(  )

    {

    CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewL();

    CleanupStack::PushL( instance );

    EUNIT_ASSERT_DESC( instance, "CCFActionSubscriptionImpl class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionSubscriptionImpl_NewLCL(  )

    {

    CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

    EUNIT_ASSERT_DESC( instance, "CCFActionSubscriptionImpl class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionSubscriptionImpl_SetActionIdentifierLL(  )

    {

    CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

    EUNIT_ASSERT_DESC( instance->ActionIdentifier() == KNullDesC,

        "Incorrect action identifier!" );

    instance->SetActionIdentifierL( KActionId );

    EUNIT_ASSERT_DESC( instance->ActionIdentifier() == KActionId,

        "Incorrect action identifier!" );

    // Clean up

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFActionSubscriptionImpl_ExternalizeLL(  )

    {

    static const TInt KCount = 2;

    CCFActionSubscriptionImpl* instance = NULL;

    for( TInt i = 0; i < KCount; i++ )

        {

        switch( i )

            {

            case 0:

                {

                instance = ConfigureActionSubscriptionL( KActionId );

                CleanupStack::PushL( instance );

                break;

                }

            case 1:

            default:

                {

                instance = ConfigureActionSubscriptionL( KNullDesC );

                CleanupStack::PushL( instance );

                break;

                }

            }

        // Externalize

        HBufC8* buffer = HBufC8::NewLC( instance->Size() );

        TPtr8 bufferPtr = buffer->Des();

        RDesWriteStream writeStream( bufferPtr );

        writeStream.PushL();

        instance->ExternalizeL( writeStream );

        CleanupStack::PopAndDestroy( &writeStream );

        // Internalize

        CCFActionSubscriptionImpl* newInstance = CCFActionSubscriptionImpl::NewLC();

        RDesReadStream readStream( bufferPtr );

        readStream.PushL();

        newInstance->InternalizeL( readStream );

        CleanupStack::PopAndDestroy( &readStream );

        // Check result

        EUNIT_ASSERT_DESC(

            instance->ActionIdentifier() == newInstance->ActionIdentifier(),

                "Incorrect action identifier!" );

        // Clean up

        CleanupStack::PopAndDestroy( newInstance );

        CleanupStack::PopAndDestroy( buffer );

        CleanupStack::PopAndDestroy( instance );

        }

    }

void MT_CFServices::MT_CCFActionSubscriptionImpl_SetListenerL(  )

    {

    CCFActionSubscriptionImpl* instance = CCFActionSubscriptionImpl::NewLC();

    EUNIT_ASSERT_DESC( !( &instance->Listener() ), "Invalid listener!" );

    instance->SetListener( this );

    EUNIT_ASSERT_DESC( ( &instance->Listener() ), "Invalid listener!" );

    CleanupStack::PopAndDestroy( instance );

    }

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

// CCFContextIndication class unit test cases

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

//

void MT_CFServices::MT_CCFContextIndication_NewLL(  )

    {

    CCFContextIndication* instance = CCFContextIndication::NewL( KNullUid );

    CleanupStack::PushL( instance );

    EUNIT_ASSERT_DESC( instance, "CCFContextIndication class instance not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void MT_CFServices::MT_CCFContextIndication_NewLCL(  )

    {

    CCFContextIndication* instance = CCFContextIndication::NewLC( KNullUid );