/*

* Copyright (c) 2008 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:  ?Description

*  %version:  bh1dsgas#3 %, % date_modified: % by %derived_by: ravindrr %

*

*/

// INCLUDE FILES

#include <stiftestinterface.h>

#include "hwrmtargetmodifierplugintest.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// CHwrmTargetModifierPluginTests::CHwrmTargetModifierPluginTests

// Returns: KErrNone

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

CHwrmTargetModifierPluginTests::CHwrmTargetModifierPluginTests()

    {

    }

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

// CHwrmTargetModifierPluginTests::ConstructL

// Returns: KErrNone

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

void CHwrmTargetModifierPluginTests::ConstructL()

    {

    }

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

// CHwrmTargetModifierPluginTests::NewL

// Returns: KErrNone

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

CHwrmTargetModifierPluginTests* CHwrmTargetModifierPluginTests::NewL()

    {        

    CHwrmTargetModifierPluginTests* self = new (ELeave) CHwrmTargetModifierPluginTests;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CHwrmTargetModifierPluginTests::CHwrmTargetModifierPluginTests

// Returns: KErrNone

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

CHwrmTargetModifierPluginTests::~CHwrmTargetModifierPluginTests()

    {

    }

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

// CHwrmTargetModifierPluginTests::InitL

// Returns: KErrNone

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

TInt CHwrmTargetModifierPluginTests::InitL( TFileName& /*aIniFile*/, TBool /*aFirstTime*/ )

    {

    return KErrNone;

    }

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

// CHwrmTargetModifierPluginTests::Case

// Returns: KErrNone

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

const TCaseInfo CHwrmTargetModifierPluginTests::Case ( const TInt aCaseNumber ) const

     {

    // To add new test cases, implement new test case function and add new

    // line to KCases array specify the name of the case and the function

    // doing the test case

    // In practice, do following

    // 1) Make copy of existing function and change it name

    // 2) Duplicate the last line in cases array

    // 3) Change case name and function name in case array

    static TCaseInfoInternal const KCases[] =

        {

		// To add new test cases, add new items to this array

		{ (TText*) L"HWRM Target Modifier Plugin [CreateAndDestroy]",

		        GETPTR CHwrmTargetModifierPluginTests::CreateAndDestroy },

		{ (TText*) L"HWRM Target Modifier Plugin [GetFullSystemTarget]",

		        GETPTR CHwrmTargetModifierPluginTests::GetFullSystemTarget },

		{ (TText*) L"HWRM Target Modifier Plugin [ModifyTarget]",

		        GETPTR CHwrmTargetModifierPluginTests::ModifyTarget }

        };

    // Verify that case number is valid

    if( (TUint) aCaseNumber >= sizeof( KCases ) /

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

        TCaseInfo null( (const TText*) L"" );

        null.iMethod = NULL;

        return null;

        }

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    return tmp;

    }

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

// CHwrmTargetModifierPluginTests::GetTestCasesL

// Returns: KErrNone

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

TInt CHwrmTargetModifierPluginTests::GetTestCasesL( const TFileName& /*aConfigFile*/,

                                  RPointerArray<TTestCaseInfo>& aTestCases )

    {

    // Loop through all test cases and create new

    // TTestCaseInfo items and append items to aTestCase array

    for( TInt i = 0; Case(i).iMethod != NULL; i++ )

        {

	    // Allocate new TTestCaseInfo from heap for a testcase definition.

        TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo();

	    // PushL TTestCaseInfo to CleanupStack.

        CleanupStack::PushL( newCase );

	    // Set number for the testcase.

	    // When the testcase is run, this comes as a parameter to RunTestCaseL.

        newCase->iCaseNumber = i;

	    // Set title for the test case. This is shown in UI to user.

        newCase->iTitle.Copy( Case(i).iCaseName );

	    // Append TTestCaseInfo to the testcase array. After appended

	    // successfully the TTestCaseInfo object is owned (and freed)

	    // by the TestServer.

        User::LeaveIfError(aTestCases.Append ( newCase ) );

	    // Pop TTestCaseInfo from the CleanupStack.

        CleanupStack::Pop( newCase );

        }

    return KErrNone;

    }

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

// CHwrmTargetModifierPluginTests::RunTestCaseL

// Returns: KErrNone

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

TInt CHwrmTargetModifierPluginTests::RunTestCaseL( const TInt aCaseNumber,

                                    const TFileName& /*aConfig*/,

                                    TTestResult& aResult )

    {

    // Return value

    TInt execStatus = KErrNone;

    // Get the pointer to test case function

    TCaseInfo tmp = Case ( aCaseNumber );

    // Check that case number was valid

    if ( tmp.iMethod != NULL )

        {

        // Valid case was found, call it via function pointer

        iMethod = tmp.iMethod;

        execStatus  = ( this->*iMethod )( aResult );

        }

    else

        {

        // Valid case was not found, return error.

        execStatus = KErrNotFound;

        }

    // Return case execution status (not the result of the case execution)

    return execStatus;

    }

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

// CHwrmTargetModifierPluginTests::LibEntryL

// Returns: Poiter to CHwrmTargetModifierPluginTests class

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

EXPORT_C CHwrmTargetModifierPluginTests* LibEntryL()

    {

    return CHwrmTargetModifierPluginTests::NewL();

    }