/*

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

*

*/

// System includes

#include <e32base.h>

#include <e32cmn.h> 

#include <digia/eunit/eunitmacros.h>

#include <digia/eunit/teunitassertioninfo.h>

#include <digia/eunit/eunitdecorators.h>

// User includes

#include "aiwspluginanim.h"

#include "animgeneralfunctions_stub.h"

#include "numerickeyhandler_stub.h"

#include "wsanim_stub.h"

#include "testeventhandler_stub.h"

#include "ut_aiwspluginanimtls.h"

#include "ut_aiwspluginanim.h"

// Constants

namespace 

    {

    const TInt KAiWgId = 42;

    const TInt KTargetWgId = KAiWgId + 1;

    const TAiWsPluginAnimInitData KWsPluginInitData = 

        { KAiWgId, KTargetWgId };

    const TBool KNoFocus = EFalse;

    }

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

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

// ResetEvent()

//

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

//

void ResetEvent( TRawEvent& aEvent )

    {

    Mem::FillZ( &aEvent, sizeof( TRawEvent ) );

    }

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

// operator==()

//

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

//

TBool operator==( const TRawEvent& aLhs, const TRawEvent& aRhs )

    {

    const TUint8* lhs = reinterpret_cast<const TUint8*>( &aLhs );

    const TUint8* rhs = reinterpret_cast<const TUint8*>( &aRhs );

    return ( Mem::Compare( lhs, sizeof(TRawEvent), rhs, sizeof(TRawEvent) ) == 0 );

    }

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

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

// UT_AiWsPluginAnim::NewL()

//

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

//

UT_AiWsPluginAnim* UT_AiWsPluginAnim::NewL()

    {

    UT_AiWsPluginAnim* self = UT_AiWsPluginAnim::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// UT_AiWsPluginAnim::NewLC()

//

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

//

UT_AiWsPluginAnim* UT_AiWsPluginAnim::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// UT_AiWsPluginAnim::~UT_AiWsPluginAnim()

//

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

//

UT_AiWsPluginAnim::~UT_AiWsPluginAnim()

    {

    delete iCAiWsPluginAnim;

    delete iAnimGeneralFunctions;

    UT_AiWsPluginAnimTls::Destroy();

    }

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

// UT_AiWsPluginAnim::UT_AiWsPluginAnim()

//

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

//

UT_AiWsPluginAnim::UT_AiWsPluginAnim()

    {

    }

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

// UT_AiWsPluginAnim::ConstructL()

//

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

//

void UT_AiWsPluginAnim::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

// UT_AiWsPluginAnim::EmptySetup()

//

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

//

void UT_AiWsPluginAnim::EmptySetup()

    {

    }

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

// UT_AiWsPluginAnim::SetupTlsL()

//

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

//

void UT_AiWsPluginAnim::SetupTlsL()

    {

    if ( !iTls )

        {

        UT_AiWsPluginAnimTls::CreateL();

        iTls = UT_AiWsPluginAnimTls::Instance();

        }

    }

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

// UT_AiWsPluginAnim::SetupDependenciesL()

//

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

//

void UT_AiWsPluginAnim::SetupDependenciesL()

    {

    if ( !iAnimGeneralFunctions )

        {

        iAnimGeneralFunctions = CAnimGeneralFunctionsStub::NewL();

        }

    }

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

// UT_AiWsPluginAnim::SetupTestObjL()

//

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

//

void UT_AiWsPluginAnim::SetupTestObjL( TBool aHasFocus )

    {

    CAiWsPluginAnim* obj = new (ELeave) CAiWsPluginAnim;

    CleanupStack::PushL( obj );

    CWsAnim::SetFunctions( *obj, iAnimGeneralFunctions );

    obj->ConstructL( const_cast<TAiWsPluginAnimInitData*>

        (&KWsPluginInitData), aHasFocus );

    CleanupStack::Pop( obj );

    iCAiWsPluginAnim = obj;

    }

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

// UT_AiWsPluginAnim::SetupL()

//

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

//

void UT_AiWsPluginAnim::UT_AiWsPluginAnim::SetupL( TBool aHasFocus )

    {

    SetupTlsL();

    SetupDependenciesL();

    SetupTestObjL( aHasFocus );

    }

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

// UT_AiWsPluginAnim::SetupL()

//

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

//

void UT_AiWsPluginAnim::SetupL()

    {

    SetupL( KNoFocus );

    }

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

// UT_AiWsPluginAnim::SetupNoSliderL()

//

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

//

void UT_AiWsPluginAnim::SetupNoSliderL( TBool aHasFocus )

    {

    SetupTlsL();

    iTls->SetFeatureSupportedL( KFeatureIdKeypadNoSlider, ETrue );

    SetupDependenciesL();

    SetupTestObjL( aHasFocus );

    }

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

// UT_AiWsPluginAnim::SetupNoSliderL()

//

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

//

void UT_AiWsPluginAnim::SetupNoSliderL()

    {

    SetupNoSliderL( KNoFocus );

    }

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

// UT_AiWsPluginAnim::Teardown()

//

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

//

void UT_AiWsPluginAnim::Teardown()

    {

    delete iCAiWsPluginAnim; 

    iCAiWsPluginAnim = NULL;

    delete iAnimGeneralFunctions;

    iAnimGeneralFunctions = NULL;

    if ( iTls )

        {

        // Store feature manager ref count for testing in T_ConstructL

        iFeatMgrCount = iTls->FeatMgrCount();

        }

    UT_AiWsPluginAnimTls::Destroy();

    iTls = NULL;

    }

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

// UT_AiWsPluginAnim::T_ConstructL()

//

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

//

void UT_AiWsPluginAnim::T_ConstructL( TBool aHasFocus )

    {

    // Test that iCAiWsPluginAnim is in the correct state

    EUNIT_ASSERT_EQUALS( iCAiWsPluginAnim->HasFocus(), aHasFocus );

    EUNIT_ASSERT_EQUALS( iCAiWsPluginAnim->Modifiers(), 0 );

    // Test that event handlers are initialized to correct state

    TArray<T_AiWsPlugin::CTestEventHandler*> 

        eventHandlers( iTls->EventHandlers() );

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

        {

        T_AiWsPlugin::CTestEventHandler* handler = eventHandlers[i];

        EUNIT_ASSERT_EQUALS( handler->Focus(), aHasFocus );

        EUNIT_ASSERT( handler->UiState() );

        EUNIT_ASSERT_EQUALS( handler->UiState()->HasFocus(), aHasFocus );

        EUNIT_ASSERT_EQUALS( handler->UiState()->Modifiers(), 0 );

        }

    // Test that numeric key handler is correctly set up

    AiWsPlugin::CNumericKeyHandler* numKeyHandler = 

        iTls->FindEventHandler< AiWsPlugin::CNumericKeyHandler >();

    EUNIT_ASSERT( numKeyHandler );

    EUNIT_ASSERT_EQUALS( numKeyHandler->iTargetWgId, KTargetWgId );

    MAnimGeneralFunctionsWindowExtension* ext = 

        static_cast<MAnimGeneralFunctionsWindowExtension*>( 

            iAnimGeneralFunctions->ExtendedInterface

                ( MAnimGeneralFunctions::EWindowExtensionInterface ) );

    EUNIT_ASSERT_EQUALS( numKeyHandler->iWindowExt, ext );

    }

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

// UT_AiWsPluginAnim::T_ConstructL()

//

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

//

void UT_AiWsPluginAnim::T_ConstructL()

    {

    // Test construction with no focus

    SetupL( EFalse );

    EUNIT_ASSERT_EQUALS( iFeatMgrCount, 0 );

    T_ConstructL( EFalse );

    Teardown();

    SetupNoSliderL( EFalse );

    T_ConstructL( EFalse );

    Teardown();

    EUNIT_ASSERT_EQUALS( iFeatMgrCount, 0 );

    // Test construction with focus

    SetupL( ETrue );

    T_ConstructL( ETrue );

    Teardown();

    EUNIT_ASSERT_EQUALS( iFeatMgrCount, 0 );

    SetupNoSliderL( ETrue );

    T_ConstructL( ETrue );

    Teardown();

    EUNIT_ASSERT_EQUALS( iFeatMgrCount, 0 );

    }

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

// UT_AiWsPluginAnim::T_CAiWsPluginAnim_EmptyFunctionsL()

//

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

//

void UT_AiWsPluginAnim::T_CAiWsPluginAnim_EmptyFunctionsL()

    {

    // Call empty functions to ensure coverage targets are reached

    TInt result = KErrNotFound;

    EUNIT_ASSERT_NO_LEAVE( result = iCAiWsPluginAnim->CommandReplyL( 0, NULL ) );

    EUNIT_ASSERT_EQUALS( result, KErrNone );

    EUNIT_ASSERT_NO_LEAVE( iCAiWsPluginAnim->Command( 0, NULL ) );

    EUNIT_ASSERT_NO_LEAVE( iCAiWsPluginAnim->Animate( NULL ) );

    EUNIT_ASSERT_NO_LEAVE( iCAiWsPluginAnim->Redraw() );

    }

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

// UT_AiWsPluginAnim::T_CAiWsPluginAnim_FocusChangedL()

//

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

//

void UT_AiWsPluginAnim::T_CAiWsPluginAnim_FocusChangedL( TBool aFocus )

    {

    iCAiWsPluginAnim->FocusChanged( aFocus );

    EUNIT_ASSERT_EQUALS( iCAiWsPluginAnim->HasFocus(), aFocus );

    TArray<T_AiWsPlugin::CTestEventHandler*> 

        eventHandlers( iTls->EventHandlers() );

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

        {

        T_AiWsPlugin::CTestEventHandler* handler = eventHandlers[i];

        EUNIT_ASSERT_EQUALS( handler->Focus(), aFocus );

        EUNIT_ASSERT( handler->UiState() );

        EUNIT_ASSERT_EQUALS( handler->UiState()->HasFocus(), aFocus );

        }

    }

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

// UT_AiWsPluginAnim::T_CAiWsPluginAnim_FocusChangedL()

//

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

//

void UT_AiWsPluginAnim::T_CAiWsPluginAnim_FocusChangedL()

    {

    T_CAiWsPluginAnim_FocusChangedL( ETrue );

    T_CAiWsPluginAnim_FocusChangedL( EFalse );

    T_CAiWsPluginAnim_FocusChangedL( !iCAiWsPluginAnim->HasFocus() );

    T_CAiWsPluginAnim_FocusChangedL( !iCAiWsPluginAnim->HasFocus() );

    }

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

// UT_AiWsPluginAnim::TestLastEventsL()

//

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

//

void TestLastEventsL(  

    const TArray<T_AiWsPlugin::CTestEventHandler*>& aEventHandlers,

    const TRawEvent& aRefEvent )

    {

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

        {

        T_AiWsPlugin::CTestEventHandler* handler = aEventHandlers[i];

        EUNIT_ASSERT_EQUALS( handler->LastEvent(), aRefEvent );

        handler->ResetLastEvent();

        }

    }        

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

// UT_AiWsPluginAnim::T_CAiWsPluginAnim_OfferRawEventL()

//

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

//

void UT_AiWsPluginAnim::T_CAiWsPluginAnim_OfferRawEventL()

    {

    TRawEvent nullEvent;

    ResetEvent( nullEvent );

    TRawEvent testEvent( nullEvent );

    TArray<T_AiWsPlugin::CTestEventHandler*> eventHandlers( iTls->EventHandlers() );

    // Check initial state

    TestLastEventsL( eventHandlers, nullEvent );

    // Test modifier key event

    testEvent.Set( TRawEvent::EKeyDown, EStdKeyLeftShift );

    EUNIT_ASSERT( !iCAiWsPluginAnim->OfferRawEvent( testEvent ) );

    // Modifier key events should not be forwarded to event handlers

    TestLastEventsL( eventHandlers, nullEvent );

    testEvent.Set( TRawEvent::EKeyUp, EStdKeyLeftShift );

    EUNIT_ASSERT( !iCAiWsPluginAnim->OfferRawEvent( testEvent ) );

    // Modifier key events should not be forwarded to event handlers

    TestLastEventsL( eventHandlers, nullEvent );

    // Test non-modifier key event

    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice0 );

    EUNIT_ASSERT( !iCAiWsPluginAnim->OfferRawEvent( testEvent ) );

    // Non-modifier key events should be forwarded to event handlers

    TestLastEventsL( eventHandlers, nullEvent );

    testEvent.Set( TRawEvent::EKeyUp, EStdKeyDevice0 );

    EUNIT_ASSERT( !iCAiWsPluginAnim->OfferRawEvent( testEvent ) );

    // Non-modifier key events should be forwarded to event handlers

    TestLastEventsL( eventHandlers, nullEvent );

    // Test event consuming

    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice1 );

    // Make the first event handler consume the event

    eventHandlers[0]->RespondToEvent( testEvent );

    // OfferRawEvent should return true because the event is consumed

    EUNIT_ASSERT( iCAiWsPluginAnim->OfferRawEvent( testEvent ) );    

    }

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

// Test case table

//

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

//

EUNIT_BEGIN_TEST_TABLE(

    UT_AiWsPluginAnim,

    "Test suite for class CAiWsPluginAnim",

    "UNIT" )

    EUNIT_TEST(

        "Construction",

        "CAiWsPluginAnim",

        "ConstructL",

        "FUNCTIONALITY",

        EmptySetup, T_ConstructL, Teardown)

    EUNIT_TEST(

        "Test empty pure virtual overloads",

        "CAiWsPluginAnim",

        "CommandReplyL - test0",

        "FUNCTIONALITY",

        SetupL, T_CAiWsPluginAnim_EmptyFunctionsL, Teardown)

    EUNIT_TEST(

        "FocusChanged",

        "CAiWsPluginAnim",

        "FocusChanged",

        "FUNCTIONALITY",

        SetupL, T_CAiWsPluginAnim_FocusChangedL, Teardown)

    EUNIT_TEST(

        "OfferRawEvent",

        "CAiWsPluginAnim",

        "OfferRawEvent",

        "FUNCTIONALITY",

        SetupL, T_CAiWsPluginAnim_OfferRawEventL, Teardown)

EUNIT_END_TEST_TABLE