/*

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

// User includes

#include "aifw_stub.h"

#include "aiuicontroller_stub.h"

#include "ut_aiuicontrollermanager.h"

#include "aiuicontrollermanager.h"

// Constants

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

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

// CAiUiControllerStub

//

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

//

CAiUiControllerStub* AsCAiUiControllerStub( CAiUiController* aController )

    {

    return static_cast< CAiUiControllerStub* >( aController );

    }

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

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

// UT_AiUiControllerManager::NewL()

//

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

//

UT_AiUiControllerManager* UT_AiUiControllerManager::NewL()

    {

    UT_AiUiControllerManager* self = UT_AiUiControllerManager::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// UT_AiUiControllerManager::NewLC()

//

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

//

UT_AiUiControllerManager* UT_AiUiControllerManager::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// UT_AiUiControllerManager::~UT_AiUiControllerManager()

//

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

//

UT_AiUiControllerManager::~UT_AiUiControllerManager()

    {    

    }

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

// UT_AiUiControllerManager::UT_AiUiControllerManager()

//

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

//

UT_AiUiControllerManager::UT_AiUiControllerManager()

    {

    }

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

// UT_AiUiControllerManager::ConstructL()

//

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

//

void UT_AiUiControllerManager::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

// UT_AiUiControllerManager::SetupL()

//

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

//

void UT_AiUiControllerManager::SetupL()

    {

    iAiFw = CAiFw::NewL();

    iUiMgr = CAiUiControllerManager::NewL( iAiFw );

    // Get rid of real UI controllers

    iUiMgr->UiControllers().ResetAndDestroy();

    CAiUiControllerStub* stub1 = CAiUiControllerStub::NewL();

    iUiMgr->UiControllers().Append( stub1 );

    CAiUiControllerStub* stub2 = CAiUiControllerStub::NewL();

    iUiMgr->UiControllers().Append( stub2 );

    stub1->iMain = ETrue;

    iUiMgr->iMainUiController = stub1;    

    }

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

// UT_AiUiControllerManager::Teardown()

//

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

//

void UT_AiUiControllerManager::Teardown()

    {

    delete iUiMgr;

    iUiMgr = NULL;

    delete iAiFw;

    iAiFw = NULL;

    }

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

// UT_AiUiControllerManager::TestGetUiControllersL()

//

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

//

void UT_AiUiControllerManager::TestGetUiControllersL()

    {

    EUNIT_ASSERT_EQUALS( iUiMgr->UiControllers().Count() == 2, ETrue );    

    }

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

// UT_AiUiControllerManager::TestActivateUIL()

//

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

//

void UT_AiUiControllerManager::TestActivateUIL()

    {

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iActive, EFalse );

        }

    iUiMgr->ActivateUI();

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub =

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iActive, ETrue );

        }    

    }

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

// UT_AiUiControllerManager::TestGetMainUiControllerL()

//

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

//

void UT_AiUiControllerManager::TestGetMainUiControllerL()

    {    

    MAiMainUiController* main( &iUiMgr->MainUiController() );

    CAiUiControllerStub* stub( NULL );

    TInt count( 0 );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* temp = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( temp->iMain )

            {

            stub = temp; 

            count++;

            }

        }

    EUNIT_ASSERT_EQUALS( count, 1 );

    EUNIT_ASSERT_EQUALS( stub == main, ETrue );    

    }

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

// UT_AiUiControllerManager::TestIsMainUiControllerL()

//

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

//

void UT_AiUiControllerManager::TestIsMainUiControllerL()

    {

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( stub->iMain )

            {

            EUNIT_ASSERT_EQUALS( iUiMgr->IsMainUiController( *stub ), ETrue );

            }

        else

            {

            EUNIT_ASSERT_EQUALS( iUiMgr->IsMainUiController( *stub ), EFalse );

            }

        }                 

    }

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

// UT_AiUiControllerManager::TestRunApplicationL()

//

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

//

void UT_AiUiControllerManager::TestRunApplicationL()

    {

    iUiMgr->RunApplicationL();

    TInt count( 0 );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( stub->iRunning )

            {

            count++;

            }               

        }    

    EUNIT_ASSERT_EQUALS( count, 1 );

    CAiUiControllerStub* main = 

        static_cast< CAiUiControllerStub* >( &iUiMgr->MainUiController() );

    CAiUiControllerStub* running( NULL );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub =

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( stub->iRunning )

            {

            running = stub;

            break;                       

            }               

        }    

    EUNIT_ASSERT_EQUALS( running != NULL, ETrue );

    EUNIT_ASSERT_EQUALS( main != NULL, ETrue );

    EUNIT_ASSERT_EQUALS( running == main, ETrue );                 

    }

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

// UT_AiUiControllerManager::TestLoadUIDefinitionL()

//

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

//

void UT_AiUiControllerManager::TestLoadUIDefinitionL()

    {

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub =

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iUiDefinition, EFalse );

        }        

    iUiMgr->LoadUIDefinition();

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub =

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iUiDefinition, ETrue );

        }        

    }

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

// UT_AiUiControllerManager::TestGetCoeEnvL()

//

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

//

void UT_AiUiControllerManager::TestGetCoeEnvL()

    {

    CCoeEnv* env( &iUiMgr->CoeEnv() );

    EUNIT_ASSERT_EQUALS( env != NULL, ETrue );

    }

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

// UT_AiUiControllerManager::TestDestroySecondaryUiControllersL()

//

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

//

void UT_AiUiControllerManager::TestDestroySecondaryUiControllersL()

    {

    TInt count( 0 );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( !stub->iMain )

            {

            count++;

            }

        }    

    EUNIT_ASSERT_EQUALS( count > 0, ETrue );

    iUiMgr->DestroySecondaryUiControllers();

    count = 0;

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( !stub->iMain )

            {

            count++;

            }        

        }    

    EUNIT_ASSERT_EQUALS( count == 0, ETrue );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iMain, ETrue );

        }        

    }

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

// UT_AiUiControllerManager::TestExitMainControllerL()

//

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

//

void UT_AiUiControllerManager::TestExitMainControllerL()

    {

    TInt count( 0 );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( stub->iMain )

            {

            count++;

            EUNIT_ASSERT_EQUALS( stub->iExit, EFalse );

            }

        }

    EUNIT_ASSERT_EQUALS( count > 0, ETrue );

    TInt count2( 0 );

    iUiMgr->ExitMainController();

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        if ( stub->iMain )

            {

            count2++;

            EUNIT_ASSERT_EQUALS( stub->iExit, ETrue );

            }

        }    

    EUNIT_ASSERT_EQUALS( count == count2, ETrue );

    }

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

// UT_AiUiControllerManager::TestSetStateHandlerL()

//

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

//

void UT_AiUiControllerManager::TestSetStateHandlerL()

    {

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iStateHandler, EFalse );

        }

    MAiFwStateHandler* handler = reinterpret_cast< MAiFwStateHandler* >( this );

    iUiMgr->SetStateHandler( *handler );

    for ( TInt i = 0; i < iUiMgr->UiControllers().Count(); i++ )

        {

        CAiUiControllerStub* stub = 

            AsCAiUiControllerStub( iUiMgr->UiControllers()[i] );

        EUNIT_ASSERT_EQUALS( stub->iStateHandler, ETrue );

        }        

    }

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

// Test case table

//

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

//

EUNIT_BEGIN_TEST_TABLE(

    UT_AiUiControllerManager,

    "Unit test suite for CAiUiControllerManager",

    "UNIT" )

    EUNIT_TEST(

        "GetUiControllers",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestGetUiControllersL, Teardown )

    EUNIT_TEST(

        "ActivateUi",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestActivateUIL, Teardown )

    EUNIT_TEST(

        "GetMainUiController",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestGetMainUiControllerL, Teardown )

    EUNIT_TEST(

        "IsMainUiController",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestIsMainUiControllerL, Teardown )

    EUNIT_TEST(

        "RunApplication",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestRunApplicationL, Teardown )

    EUNIT_TEST(

        "LoadUiDefinition",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestLoadUIDefinitionL, Teardown )

    EUNIT_TEST(

        "GetCoeEnv",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestGetCoeEnvL, Teardown )

    EUNIT_TEST(

        "DestroySecondaryUiControllers",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestDestroySecondaryUiControllersL, Teardown )

    EUNIT_TEST(

        "ExitMainController",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestExitMainControllerL, Teardown )

    EUNIT_TEST(

        "SetStateHandler",

        "CAiUiControllerManager",

        "",

        "FUNCTIONALITY",

        SetupL, TestSetStateHandlerL, Teardown )

EUNIT_END_TEST_TABLE

// End of file