/*

* Copyright (c) 2004 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: EUnit unit test class for CAiStateProvider

*

*/

// System includes

#include <e32base.h>

#include <e32cmn.h> 

#include <digia/eunit/eunitmacros.h>

#include <digia/eunit/teunitassertioninfo.h>

#include <liwservicehandler.h>

// User includes

#include "ut_aicpsexecuteparam.h"

#include "aicpsexecuteparam.h"

// Constants

_LIT8( KPublisherId, "publisher" );

_LIT8( KContentType,   "content_type" );

_LIT8( KContentId,   "content_id" );

_LIT( KWRTPublisher, "wrt_publisher");

_LIT( KTemplateWidget,"ai3templatedwidget");

_LIT( KContentIdValue,   "com.accuweather.widget.touchNG" );

_LIT8( KAction,   "active" );

_LIT( KAction16,   "active" );

_LIT( KPubData,        "publisher" );

_LIT8( KFilter, "filter" );

_LIT8( KActionTrigger, "action_trigger" );

_LIT8( KType,          "type");

// ======== LOCAL FUNCTIONS ========

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

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

// UT_AiCpsExecuteParam::NewL()

//

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

//

UT_AiCpsExecuteParam* UT_AiCpsExecuteParam::NewL()

    {

    UT_AiCpsExecuteParam* self = UT_AiCpsExecuteParam::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// UT_AiCpsExecuteParam::NewLC()

//

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

//

UT_AiCpsExecuteParam* UT_AiCpsExecuteParam::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// UT_AiCpsExecuteParam::~UT_AiCpsExecuteParam()

//

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

//

UT_AiCpsExecuteParam::~UT_AiCpsExecuteParam()

    {    

    }

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

// UT_AiCpsExecuteParam::UT_AiCpsExecuteParam()

//

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

//

UT_AiCpsExecuteParam::UT_AiCpsExecuteParam()

    {

    }

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

// UT_AiCpsExecuteParam::ConstructL()

//

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

//

void UT_AiCpsExecuteParam::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

// UT_AiCpsExecuteParam::SetupL()

//

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

//

void UT_AiCpsExecuteParam::SetupL()

    {

    iExecuteParam = CAiCpsExecuteParam::NewL();

    }

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

// UT_AiCpsExecuteParam::Teardown()

//

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

//

void UT_AiCpsExecuteParam::Teardown()

    {

    delete iExecuteParam;

    iExecuteParam = NULL;

    }

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

// UT_AiCpsExecuteParam::PluginId()

//

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

//

void UT_AiCpsExecuteParam::PluginId()

    {

    _LIT( KPluginId, "123" );

    iExecuteParam->SetPluginIdL( KPluginId );

    EUNIT_ASSERT_EQUALS( iExecuteParam->PluginId(), KPluginId );

    }

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

// UT_AiCpsExecuteParam::InParamMapL()

//

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

//

void UT_AiCpsExecuteParam::InParamMapL()

    {

    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();

    iExecuteParam->SetFilterL(filter);

    filter->InsertL( KPublisherId, TLiwVariant( KWRTPublisher ));

    filter->InsertL( KContentType, TLiwVariant( KTemplateWidget ));

    filter->InsertL( KContentId, TLiwVariant( KContentIdValue ));

    iExecuteParam->SetPluginIdL(_L("1"));

    iExecuteParam->SetRegistryTypeL( KPubData );

    iExecuteParam->SetFilterL(filter);

    iExecuteParam->AddActionL( KAction );

    CLiwDefaultMap* map = iExecuteParam->InParamMapLC();

    TLiwVariant tempVariant;

    tempVariant.PushL();

    // check map

    if ( map->FindL( KType, tempVariant ) )

        {

        EUNIT_ASSERT_EQUALS( tempVariant.AsDes(), KPubData );

        map->Remove( KType );

        }

    if ( map->FindL( KFilter, tempVariant ) )

        {

        CLiwDefaultMap* filter2 = CLiwDefaultMap::NewLC();

        if ( tempVariant.Get( *filter2 ) )

            {

            if ( filter2->FindL( KPublisherId, tempVariant ) )

                {

                EUNIT_ASSERT_EQUALS( tempVariant.AsDes(), KWRTPublisher );

                filter2->Remove( KPublisherId );

                }

            if ( filter2->FindL( KContentType, tempVariant ) )

                {

                EUNIT_ASSERT_EQUALS( tempVariant.AsDes(), KTemplateWidget );

                filter2->Remove( KContentType );

                }

            if ( filter2->FindL( KContentId, tempVariant ) )

                {

                EUNIT_ASSERT_EQUALS( tempVariant.AsDes(), KContentIdValue );

                filter2->Remove( KContentId );

                }

            if ( filter2->FindL( KActionTrigger, tempVariant ) )

               {

               CLiwDefaultList* actionsToLaunch = CLiwDefaultList::NewLC();

               if ( tempVariant.Get( *actionsToLaunch ) )

                   {

                   if ( actionsToLaunch->AtL( 0, tempVariant ) )

                       {

                       EUNIT_ASSERT_EQUALS( tempVariant.AsData(), KAction );

                       actionsToLaunch->Remove( 0 );

                       //make sure actionsToLaunch is empty

                       EUNIT_ASSERT_EQUALS ( actionsToLaunch->Count(), 0 );

                       }

                   }

               CleanupStack::PopAndDestroy( actionsToLaunch );

               filter2->Remove( KActionTrigger );

               }

            }

        //make sure filter is empty

        EUNIT_ASSERT_EQUALS ( filter2->Count(), 0 );

        CleanupStack::PopAndDestroy( filter2 );

        map->Remove( KFilter );

        }

    //make sure map is empty

    EUNIT_ASSERT_EQUALS ( map->Count(), 0 );

    CleanupStack::Pop(&tempVariant);

    tempVariant.Reset();

    CleanupStack::PopAndDestroy( 2,filter );

    }

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

// Test case table

//

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

//

EUNIT_BEGIN_TEST_TABLE(

    UT_AiCpsExecuteParam,

    "Unit test suite for CAiCpsExecuteParam",

    "UNIT" )

    EUNIT_TEST(

        "PluginId",

        "CAiCpsExecuteParam",

        "",

        "FUNCTIONALITY",

        SetupL, PluginId, Teardown )

    EUNIT_TEST(

        "InParamMap",

        "CAiCpsExecuteParam",

        "",

        "FUNCTIONALITY",

        SetupL, InParamMapL, Teardown )

EUNIT_END_TEST_TABLE

// End of file