/*

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

*

*/

// INCLUDES

#include "MT_CFClient.h"

#include <EUnitMacros.h>

#include <cfclient.h>

#include <cfcontextsubscription.h>

#include <cfcontextindication.h>

#include <cfactionsubscription.h>

#include <cfactionindication.h>

#include <cfcontextsourcecommand.h>

#include <f32file.h>

#include <S32MEM.h>

#include <e32property.h>

#include <BAUTILS.H>

#include "cfcommon.h"

#include "testcontextdata.h"

#include "cfcontextobjectimpl.h"

#include "testcontextsourceplugin.h"

#include "testcontextsourcepluginconst.hrh"

#include "CFTestDelay.h"

// CONSTANTS

_LIT_SECURITY_POLICY_PASS( KPassSec );

_LIT_SECURITY_POLICY_FAIL( KFailSec );

_LIT( KContextSourceA, "TestSourceA" );

_LIT( KContextTypeA, "TestTypeA" );

_LIT( KContextValueA, "TestValueA" );

_LIT( KContextValueB, "TestValueB" );

_LIT( KContextSourceFormatWild, "Source" );

_LIT( KContextTypeFormatWild, "Type" );

_LIT( KContextSourceFormat, "Source.%d" );

_LIT( KContextTypeFormat, "Type.%d" );

_LIT( KContextValueFormat, "Value.%d" );

_LIT( KActionIdFormat, "AcionId.%d" );

_LIT( KActionA, "TestActionA" );

_LIT( KActionAParamA1, "ParamA1" );

_LIT( KActionAValueA1, "ValueA1" );

_LIT( KActionB, "TestActionB" );

_LIT( KActionBParamB1, "ParamB1" );

_LIT( KActionBValueB1, "ValueB1" );

_LIT( KActionBParamB2, "ParamB2" );

_LIT( KActionBValueB2, "ValueB2" );

_LIT( KActionC, "TestActionC" );

_LIT( KTestContextSource, "TestContextSource" );

_LIT( KTestContextType, "SubsNoSubsTest" );

_LIT( KTestContextType2, "SubsNoSubsTest2" );

_LIT( KTestContextValueType, "TestValue" );

_LIT( KTestContextValueSubsOk, "SubsOk" );

_LIT( KTestContextValueNosubsOk, "NoSubsOk" );

_LIT( KTestContextValueNok, "Nok" );

const TUid KTestContextSourcePluginImplUid =

    {

        KTestContextSourcePluginImplementationUid

    };

const TUid KBogusContextSourcePluginImplUid =

    {

        0xBAD50BAD

    };

const TInt KSecond = 1000000;

_LIT( KSourceCommandId, "sourceCommand" );

_LIT( KSourceCommandUidId, "uid" );

_LIT( KSourceCommandParamCmd, "cmd" );

_LIT( KSourceCommandParamCmdParam, "cmdParam" );

_LIT( KSourceCommandParamCmdInfo, "cmdInfo" );

_LIT( KSourceCommandParamModifiers, "modifiers" );

_LIT( KSourceCommandAttributeType, "type" );

_LIT( KSourceCommandAttributeMode, "mode" );

_LIT( KSourceCommandAttributeOverride, "override" );

_LIT( KSourceCommandAttributeText, "text" );

_LIT( KSourceCommandAttributeValueText, "activate from really clean state" );

_LIT( KSourceCommandAttributeValue, "value" );

_LIT( KSourceCommandAttributeValueYes, "yes" );

_LIT( KSourceCommandAttributeValueActivate, "Activate" );

_LIT( KSourceCommandAttributeValueDeactivate, "Deactivate" );

_LIT( KSourceCommandAttributeValueClean, "clean" );

_LIT( KSourceCommandAttributeValueReally, "really" );

_LIT( KSourceCommandAttributeValueFull, "full" );

_LIT( KSourceCommandAttributeValueNoException, "noException" );

_LIT( KSourceCommandPluginScriptContextSource, "TestSourcePlugIn" );

_LIT( KSourceCommandClientScriptContextSource, "TestSourceClient" );

_LIT( KSourceCommandScriptContextType, "SendSourceCommand" );

_LIT( KSourceCommandScript1ContextValueActivate, "A" );

_LIT( KSourceCommandScript1ContextValueDeactivate, "B" );

_LIT( KSourceCommandScript2ContextValueActivate, "A2" );

_LIT( KSourceCommandScript2ContextValueDeactivate, "B2" );

_LIT( KSourceCommandSignalContextSource, "TestSourcePlugin" );

_LIT( KSourceCommandSignalContextType, "SourceCommand" );

_LIT( KSourceCommandSignalContextValueActivated, "Activated" );

_LIT( KSourceCommandSignalContextValueDeactivated, "Deactivated" );

_LIT( KSourceCommandSignalContextValueActiveReqActivate, "ActiveReqActivate" );

_LIT( KSourceCommandSignalContextValueActiveReqDeactivate, "ActiveReqDeactivate" );

_LIT( KSourceCommandSignalContextValueDeactiveReqDeactivate, "DeactiveReqDeactivate" );

_LIT( KSourceCommandSignalContextValueError, "Error" );

_LIT( KContextValueTriggerForSourceCommandClient, "SourceCommandClient" );

_LIT( KReservedActionPublishContext, "publishContext" );

_LIT( KReservedActionPublishContext2, "PUBLISHCONTEXT" );

_LIT( KReservedActionSourceCommand, "sourceCommand" );

_LIT( KReservedActionSourceCommand2, "SOURCECOMMAND" );

_LIT( KRomScriptAutoDefineContextSource, "RomScript" );

_LIT( KRomScriptAutoDefineContextType, "NewContext" );

_LIT( KRomScriptAutoDefineContextValue, "AutoDefined" );

_LIT( KRomScriptTriggerAutoDefineContextSource, "TestRomScript" );

_LIT( KRomScriptTriggerAutoDefineContextType, "PublishContext" );

_LIT( KRomScriptTriggerAutoDefineContextValue, "AutoDefine" );

_LIT( KRomScriptDetectedAutoDefinedContextSource, "AutoDefined" );

_LIT( KRomScriptDetectedAutoDefinedContextType, "RomScriptContext" );

_LIT( KRomScriptDetectedAutoDefinedContextValue, "Detected" );

// LOCAL DEFINITIONS

/**

 * Clean up item for RContextObjectArray

 */

LOCAL_C void CleanupContextObjectArray( TAny* aArray )

    {

    RContextObjectArray* array = static_cast<RContextObjectArray*>( aArray );

    array->ResetAndDestroy();

    }

/**

 * Clean up function for RContextObjectArray

 */

LOCAL_C void CleanupResetAndDestroyPushL( RContextObjectArray& aArray )

    {

    TCleanupItem item( CleanupContextObjectArray, &aArray );

    CleanupStack::PushL( item );

    }

/**

 * Clean up item for RContextQueryArray

 */

LOCAL_C void CleanupContextQueryArray( TAny* aArray )

    {

    RContextQueryArray* array = static_cast<RContextQueryArray*>( aArray );

    array->ResetAndDestroy();

    }

/**

 * Clean up function for RContextQueryArray

 */

LOCAL_C void CleanupResetAndDestroyPushL( RContextQueryArray& aArray )

    {

    TCleanupItem item( CleanupContextQueryArray, &aArray );

    CleanupStack::PushL( item );

    }

/**

 * Wait info.

 */

NONSHARABLE_CLASS( TWaitInfo )

    {

public:

    CPeriodic* iPeriodic;

    CActiveSchedulerWait* iWait;

    };

/**

 * Call back method when we need to stop active scheduler wait.

 */

LOCAL_C TInt WaitCallBack( TAny* aSelf )

    {

    if( aSelf )

        {

        TWaitInfo* info = static_cast<TWaitInfo*>( aSelf );

        if( info->iPeriodic )

            {

            info->iPeriodic->Cancel();

            }

        if( info->iWait )

            {

            if( info->iWait->IsStarted() )

                {

                info->iWait->AsyncStop();

                }

            }

        }

    return KErrNone;

    }

/**

 * Helper method to wait current scheduler before teardown is completed.

 */

LOCAL_C void Wait( TInt aIntervalInMicorseconds )

    {

    TWaitInfo info;

    // Construct periodic

    CPeriodic* periodic = CPeriodic::NewL( CActive::EPriorityStandard );

    CleanupStack::PushL( periodic );

    info.iPeriodic = periodic;

    // Construct active scheduler wait

    CActiveSchedulerWait* wait = new( ELeave ) CActiveSchedulerWait;

    CleanupStack::PushL( wait );

    info.iWait = wait;

    // Start timer and wait

    TCallBack cb( WaitCallBack, &info );

    periodic->Start( aIntervalInMicorseconds, aIntervalInMicorseconds, cb );

    wait->Start();

    // Cleanup

    CleanupStack::PopAndDestroy( wait );

    CleanupStack::PopAndDestroy( periodic );

    }

const TInt KDelay = 2000000; // 2 seconds

const TInt KConfigDelay = 4000;

/**

 * Orders source command sender identities.

 * @param aFirst First source command sender id.

 * @param aSecond Second source command sender id.

 * @return Zero if the uid and the script id of the first and second are equal.

 *   Negative value if the uid of the first is less than the uid of the second

 *   or script id of the first is less than second's when uid are equal.

 *   Positive value if the uid of the first is greater than the uid of the

 *   second or script id of the first is greater than second's when uid are

 *   equal.

 */

 LOCAL_C TInt SourceCommandSenderIdOrder(

     const TCFSourceCommandSenderId& aFirst,

     const TCFSourceCommandSenderId& aSecond )

     {

     TInt orderValue = 1;

     if ( aFirst.iSender == aSecond.iSender )

         {

         if ( aFirst.iScriptId == aSecond.iScriptId )

             {

             orderValue = 0;

             }

         else if ( aFirst.iScriptId < aSecond.iScriptId )

             {

             orderValue = -1;

             }

         }

     else if ( aFirst.iSender < aSecond.iSender )

         {

         orderValue = -1;

         }

     return orderValue;

     }

// CONSTRUCTION

MT_CFClient* MT_CFClient::NewL( )

    {

    MT_CFClient* self = MT_CFClient::NewLC ( );

    CleanupStack::Pop ( );

    return self;

    }

MT_CFClient* MT_CFClient::NewLC( )

    {

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

    CleanupStack::PushL ( self );

    self->ConstructL ( );

    return self;

    }

// Destructor (virtual by CBase)

MT_CFClient::~MT_CFClient( )

    {

    Teardown();

    }

// Default constructor

MT_CFClient::MT_CFClient( )

    {

    }

// Second phase construct

void MT_CFClient::ConstructL( )

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL ( );

    }

//  METHODS

void MT_CFClient::ContextIndicationL(const CCFContextIndication& aChangedContext )

    {

    if ( iCheckContextData )

        {

        CheckContextDataIndicationL ( aChangedContext );

        }

    else

        {

        CheckContextIndicationL ( aChangedContext );

        }

    // Common for both indications

    if ( iWait && !iCheckA && !iCheckB )

        {

        if ( iWait->IsStarted ( ) )

            {

            iWait->AsyncStop ( );

            }

        }

    if ( iDeleteClient )

        {

        delete iClient;

        iClient = NULL;

        iDeleteClient = EFalse;

        }

    }

void MT_CFClient::ActionIndicationL(const CCFActionIndication& aActionToExecute )

    {

    TPtrC actionId( aActionToExecute.Identifier() );

    if ( iLastActionId )

        {

        delete iLastActionId;

        iLastActionId = NULL;

        }

    iLastActionId = actionId.AllocL();

    if ( iCheckA )

        {

        const RKeyValueArray& params = aActionToExecute.Parameters ( );

        EUNIT_ASSERT_DESC( actionId == KActionA,

            "Incorrect action identifier!" );

        EUNIT_ASSERT_DESC( params.Count() == 1,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Key() == KActionAParamA1,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Value() == KActionAValueA1,

            "Incorrect action param count!" )

        if ( iCountActionAIndications )

            {

            --iExpectedActionAIndicationCount;

            if ( !iExpectedActionAIndicationCount )

                {

                iCheckA = EFalse;

                }

            }

        else

            {

            iCheckA = EFalse;

            }

        }

    else if ( iCheckB )

        {

        const RKeyValueArray& params = aActionToExecute.Parameters ( );

        EUNIT_ASSERT_DESC( actionId == KActionB,

            "Incorrect action identifier!" );

        EUNIT_ASSERT_DESC( params.Count() == 2,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Key() == KActionBParamB1,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Value() == KActionBValueB1,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[1]->Key() == KActionBParamB2,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[1]->Value() == KActionBValueB2,

            "Incorrect action param count!" )

        iCheckB = EFalse;

        }

    else if ( iCheckRegisterScriptAction )

        {

        const RKeyValueArray& params = aActionToExecute.Parameters ( );

        EUNIT_ASSERT_DESC( actionId == _L("RegisterScriptAction"),

            "Incorrect action identifier!" );

        EUNIT_ASSERT_DESC( params.Count() == 1,

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Key() == _L("ParamA1"),

            "Incorrect action param count!" )

        EUNIT_ASSERT_DESC( params[0]->Value() == _L("ValueA1"),

            "Incorrect action param count!" )

        iCheckRegisterScriptAction = EFalse;

        }

    else if ( iCheckCustomAction )

        {

        EUNIT_ASSERT_DESC( iCustomActionId == actionId,

            "Incorrect action id" );

        const RKeyValueArray

            & params = aActionToExecute.Parameters ( );

        EUNIT_ASSERT_DESC( params.Count() == iCustomActionParams.Count(),

            "Invalid amount of action parameters" );

        for (TInt i = 0; i < iCustomActionParams.Count ( ); i++ )

            {

            CCFKeyValuePair* pair1 = iCustomActionParams[i];

            CCFKeyValuePair* pair2 = params[i];

            EUNIT_ASSERT_DESC( pair2->Key() == pair1->Key(),

                "Invalid key" );

            EUNIT_ASSERT_DESC( pair2->Value() == pair1->Value(),

                "Invalid value" );

            }

        iCheckCustomAction = EFalse;

        iCustomActionId.Zero ( );

        iCustomActionParams.ResetAndDestroy ( );

        }

    if ( iWait && !iCheckA && !iCheckB && !iCheckRegisterScriptAction &&!iCheckCustomAction )

        {

        if ( iWait->IsStarted ( ) )

            {

            iWait->AsyncStop ( );

            }

        }

    if ( iDeleteClient )

        {

        delete iClient;

        iClient = NULL;

        iDeleteClient = EFalse;

        }

    }

void MT_CFClient::HandleContextFrameworkError( TCFError aError,

    const TDesC& aSource, const TDesC& aType )

    {

    if ( iCheckB )

        {

        EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

            "Incorrect HandleContextFrameworkError error code!" );

        EUNIT_ASSERT_DESC( aSource == iContextB->Source(),

            "Incorrect HandleContextFrameworkError context source!" );

        EUNIT_ASSERT_DESC( aType == iContextB->Type(),

            "Incorrect HandleContextFrameworkError context type!" );

        iCheckB = EFalse;

        }

    else if ( iCheckC )

        {

        EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

            "Incorrect HandleContextFrameworkError error code!" );

        EUNIT_ASSERT_DESC( aSource == iContextC->Source(),

            "Incorrect HandleContextFrameworkError context source!" );

        EUNIT_ASSERT_DESC( aType == iContextC->Type(),

            "Incorrect HandleContextFrameworkError context type!" );

        iCheckC = EFalse;

        }

    else if ( iCheckRomScriptContextAutoDefine )

        {

        EUNIT_ASSERT_DESC( aError == MCFListener::ESecurityCheckErrorForContextSubscription,

            "Incorrect HandleContextFrameworkError error code!" );

        EUNIT_ASSERT_DESC( aSource == KRomScriptAutoDefineContextSource,

            "Incorrect HandleContextFrameworkError context source!" );

        EUNIT_ASSERT_DESC( aType == KRomScriptAutoDefineContextType,

            "Incorrect HandleContextFrameworkError context type!" );

        iCheckRomScriptContextAutoDefine = EFalse;

        if ( iTestDelay )

            {

            iTestDelay->Stop();

            }

        }

    if ( iWait && !iCheckA && !iCheckB && !iCheckC && !iCheckRomScriptContextAutoDefine )

        {

        if ( iWait->IsStarted ( ) )

            {

            iWait->AsyncStop ( );

            }

        }

    }

TAny* MT_CFClient::Extension( const TUid& aExtensionUid ) const

    {

    switch ( aExtensionUid.iUid )

        {

        case KCFContextSourceInterfaceUidValue:

            {

            if ( iReturnContextSourceInterface )

                {

                MCFContextSource* csinterface = (MCFContextSource*) this;

                return (TAny*) csinterface;

                }

            break;

            }

        default:

            {

            return NULL;

            }

        }

    return NULL;

    }

// from MCFContextSource

void MT_CFClient::Subscribers( const TDesC& aContextSource,

    const TDesC& aContextType )

    {

    if ( iCheckSubscribersNoSubscribersCalled )

        {

        iCheckSubscribersNoSubscribersCalled = EFalse;