/*
* 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 "modifierkeytracker.h"

#include "ut_modifierkeytracker.h"


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

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

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::NewL()
//
// -----------------------------------------------------------------------------
//
UT_MofifierKeyTracker* UT_MofifierKeyTracker::NewL()
    {
    UT_MofifierKeyTracker* self = UT_MofifierKeyTracker::NewLC();
    CleanupStack::Pop();

    return self;
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::NewLC()
//
// -----------------------------------------------------------------------------
//
UT_MofifierKeyTracker* UT_MofifierKeyTracker::NewLC()
    {
    UT_MofifierKeyTracker* self = new( ELeave ) UT_MofifierKeyTracker();
    CleanupStack::PushL( self );

    self->ConstructL();

    return self;
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::~UT_MofifierKeyTracker()
//
// -----------------------------------------------------------------------------
//
UT_MofifierKeyTracker::~UT_MofifierKeyTracker()
    {
    delete iTModifierKeyTracker;
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::UT_MofifierKeyTracker()
//
// -----------------------------------------------------------------------------
//
UT_MofifierKeyTracker::UT_MofifierKeyTracker()
    {
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::ConstructL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::SetupL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::SetupL()
    {
    iTModifierKeyTracker = new( ELeave ) AiWsPlugin::TModifierKeyTracker;
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::Teardown()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::Teardown()
    {
    delete iTModifierKeyTracker; 
    iTModifierKeyTracker = NULL; 
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_ConstructL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_ConstructL()
    {
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), 0 );
    }    

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_NonModiferUpdateL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_NonModiferUpdateL()
    {
    TRawEvent testEvent;
    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice0 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), 0 );
    testEvent.Set( TRawEvent::EKeyUp, EStdKeyDevice0 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    }    

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_TestModifierKeyDownL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_TestModifierKeyDownL(
    TInt aScanCode, TUint aExcpectedStatus )
    {
    TRawEvent testEvent;
    testEvent.Set( TRawEvent::EKeyDown, aScanCode );
    EUNIT_ASSERT( iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), aExcpectedStatus );
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_TestModifierKeyUpL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_TestModifierKeyUpL(
    TInt aScanCode, TUint aExcpectedStatus )
    {
    TRawEvent testEvent;
    testEvent.Set( TRawEvent::EKeyUp, aScanCode );
    EUNIT_ASSERT( iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), aExcpectedStatus );
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_SingleModiferUpdateL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_SingleModiferUpdateL(
    TInt aScanCode, TUint aExcpectedStatus  )
    {
    T_TModifierKeyTracker_TestModifierKeyDownL( aScanCode, aExcpectedStatus );
    T_TModifierKeyTracker_TestModifierKeyUpL( aScanCode, 0 );
    }

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_SingleModiferUpdateL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_SingleModiferUpdateL()
    {
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyLeftShift, EModifierLeftShift | EModifierShift );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyRightShift, EModifierRightShift | EModifierShift );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyLeftCtrl, EModifierLeftCtrl | EModifierCtrl );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyRightCtrl, EModifierRightCtrl | EModifierCtrl );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyLeftAlt, EModifierLeftAlt | EModifierAlt );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyRightAlt, EModifierRightAlt | EModifierAlt );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyLeftFunc, EModifierLeftFunc | EModifierFunc );
    
    T_TModifierKeyTracker_SingleModiferUpdateL( 
            EStdKeyRightFunc, EModifierRightFunc | EModifierFunc );
    }    

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_MultiModiferUpdateL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_MultiModiferUpdateL()
    {
    TUint expectedStatus = EModifierLeftShift | EModifierShift ;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftShift, expectedStatus );
    expectedStatus |= EModifierRightShift;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyRightShift, expectedStatus );

    expectedStatus |= EModifierLeftCtrl | EModifierCtrl;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftCtrl, expectedStatus );
    expectedStatus |= EModifierRightCtrl;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyRightCtrl, expectedStatus );

    expectedStatus |= EModifierLeftAlt | EModifierAlt;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftAlt, expectedStatus );
    expectedStatus |= EModifierRightAlt;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyRightAlt, expectedStatus );

    expectedStatus |= EModifierLeftFunc | EModifierFunc;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftFunc, expectedStatus );
    expectedStatus |= EModifierRightFunc;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyRightFunc, expectedStatus );

    expectedStatus &= ~EModifierLeftShift;
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyLeftShift, expectedStatus );
    expectedStatus &= ~(EModifierRightShift | EModifierShift);
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyRightShift, expectedStatus );

    expectedStatus &= ~EModifierLeftCtrl;
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyLeftCtrl, expectedStatus );
    expectedStatus &= ~(EModifierRightCtrl | EModifierCtrl);
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyRightCtrl, expectedStatus );

    expectedStatus &= ~EModifierLeftAlt;
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyLeftAlt, expectedStatus );
    expectedStatus &= ~(EModifierRightAlt | EModifierAlt);
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyRightAlt, expectedStatus );

    expectedStatus &= ~EModifierLeftFunc;
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyLeftFunc, expectedStatus );
    expectedStatus &= ~(EModifierRightFunc | EModifierFunc);
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyRightFunc, expectedStatus );
    
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), 0 );
    }    

// -----------------------------------------------------------------------------
// UT_MofifierKeyTracker::T_TModifierKeyTracker_MixedModiferNonModiferUpdateL()
//
// -----------------------------------------------------------------------------
//
void UT_MofifierKeyTracker::T_TModifierKeyTracker_MixedModiferNonModiferUpdateL()
    {
    TUint expectedStatus = EModifierLeftShift | EModifierShift ;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftShift, expectedStatus );
    
    TRawEvent testEvent;
    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice0 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    testEvent.Set( TRawEvent::EKeyUp, EStdKeyDevice0 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    
    expectedStatus |= EModifierLeftCtrl | EModifierCtrl;
    T_TModifierKeyTracker_TestModifierKeyDownL( EStdKeyLeftCtrl, expectedStatus );
    
    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice1 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    testEvent.Set( TRawEvent::EKeyUp, EStdKeyDevice1 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    
    expectedStatus &= ~(EModifierLeftShift | EModifierShift);
    T_TModifierKeyTracker_TestModifierKeyUpL( EStdKeyLeftShift, expectedStatus );

    testEvent.Set( TRawEvent::EKeyDown, EStdKeyDevice2 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    testEvent.Set( TRawEvent::EKeyUp, EStdKeyDevice2 );
    EUNIT_ASSERT( !iTModifierKeyTracker->Update( testEvent ) );
    EUNIT_ASSERT_EQUALS( iTModifierKeyTracker->Status( ), expectedStatus );
    }    

// -----------------------------------------------------------------------------
// Test case table
//
// -----------------------------------------------------------------------------
//
EUNIT_BEGIN_TEST_TABLE(
    UT_MofifierKeyTracker,
    "Add test suite description here.",
    "UNIT" )

    EUNIT_TEST(
        "Constructor",
        "TModifierKeyTracker",
        "Constructor",
        "FUNCTIONALITY",
        SetupL, T_TModifierKeyTracker_ConstructL, Teardown)
        
    EUNIT_TEST(
        "Update - Single active modifier key",
        "TModifierKeyTracker",
        "Update",
        "FUNCTIONALITY",
        SetupL, T_TModifierKeyTracker_SingleModiferUpdateL, Teardown)
    
    EUNIT_TEST(
        "Update - Multiple active modifier keys",
        "TModifierKeyTracker",
        "Update",
        "FUNCTIONALITY",
        SetupL, T_TModifierKeyTracker_MultiModiferUpdateL, Teardown)
        
    EUNIT_TEST(
        "Update - Mixed modfier and other keys",
        "TModifierKeyTracker",
        "Update",
        "FUNCTIONALITY",
        SetupL, T_TModifierKeyTracker_MixedModiferNonModiferUpdateL, Teardown)
           
EUNIT_END_TEST_TABLE

// End of file