/*
* Copyright (c) 2002 - 2007 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:  hgtestbase class member functions
*
*/



// INCLUDE FILES
#include <Stiftestinterface.h>
#include "hgtestbase.h"
#include <e32math.h>
#include <e32math.h>
#include <aknappui.h>

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

// -----------------------------------------------------------------------------
// CHgTestBase::CHgTestBase
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CHgTestBase::CHgTestBase()
    {
    }

// -----------------------------------------------------------------------------
// CHgTestBase::ConstructL
// Symbian 2nd phase constructor can leave.
//
// Note: If OOM test case uses STIF Logger, then STIF Logger must be created
// with static buffer size parameter (aStaticBufferSize). Otherwise Logger 
// allocates memory from heap and therefore causes error situations with OOM 
// testing. For more information about STIF Logger construction, see STIF Users 
// Guide.
// -----------------------------------------------------------------------------
//
void CHgTestBase::BaseConstructL( const TDesC& aTestPath,
                                            const TDesC& aTestFile )
    {
    iLog = CStifLogger::NewL( aTestPath, 
                          aTestFile);

    // Sample how to use logging
    _LIT( KLogStart, "Logging starts!" );
    iLog->Log( KLogStart );

    iVersionLogged = EFalse;
    iNumberOfTestCases = 0;

    // Construct active scheduler
    iActiveScheduler = new ( ELeave ) CActiveScheduler;

    // Install active scheduler
    // We don't need to check whether an active scheduler is already installed
    // as this is a new thread, so there won't be one
    CActiveScheduler::Install ( iActiveScheduler );
    }

// Destructor
CHgTestBase::~CHgTestBase()
    {
    
    delete iTestDllName;
    delete iLog;
    //delete ENV_cleanup;
    delete iActiveScheduler;
    }

// -----------------------------------------------------------------------------
// CHgTestBase::InitL
// InitL is used to initialize the Test Module.
// -----------------------------------------------------------------------------
//
TInt CHgTestBase::InitL( 
    TFileName& /*aIniFile*/, 
    TBool /*aFirstTime*/ )
    {
    return KErrNone;

    }

// -----------------------------------------------------------------------------
// CHgTestBase::GetTestCasesL
// GetTestCases is used to inquire test cases from the Test Module. Test
// cases are stored to array of test cases. The Test Framework will be 
// the owner of the data in the RPointerArray after GetTestCases return
// and it does the memory deallocation. 
// -----------------------------------------------------------------------------
//
TInt CHgTestBase::GetTestCasesL( 
    const TFileName& /*aConfig*/, 
    RPointerArray<TTestCaseInfo>& aTestCases )
    {
    TTestResult dummyResult;
    return MainTestL(CHgTestBase::EEnumerateTestCases, -1, aTestCases, dummyResult); 
    }

// -----------------------------------------------------------------------------
// CHgTestBase::OOMTestQueryL
// Used to check if a particular test case should be run in OOM conditions and 
// which memory allocations should fail.    
// -----------------------------------------------------------------------------
//
TBool CHgTestBase::OOMTestQueryL( 
                                const TFileName& /* aTestCaseFile */, 
                                const TInt /*aCaseNumber*/, 
                                TOOMFailureType& /* aFailureType */, 
                                TInt& /*aFirstMemFailure*/, 
                                TInt& /*aLastMemFailure*/ ) 
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CHgTestBase::OOMTestInitializeL
// Used to perform the test environment setup for a particular OOM test case. 
// Test Modules may use the initialization file to read parameters for Test 
// Module initialization but they can also have their own configure file or 
// some other routine to initialize themselves.  
//
// NOTE: User may add implementation for OOM test environment initialization.
// Usually no implementation is required.
// -----------------------------------------------------------------------------
//
void CHgTestBase::OOMTestInitializeL( 
                                const TFileName& /* aTestCaseFile */, 
                                const TInt /* aCaseNumber */ )
    {
    }

// -----------------------------------------------------------------------------
// CHgTestBase::OOMHandleWarningL
// In some cases the heap memory allocation should be skipped, either due to
// problems in the OS code or components used by the code being tested, or even 
// inside the tested components which are implemented this way on purpose (by 
// design), so it is important to give the tester a way to bypass allocation 
// failures.
//
// NOTE: User may add implementation for OOM test warning handling. Usually no
// implementation is required.
// -----------------------------------------------------------------------------
//
void CHgTestBase::OOMHandleWarningL( 
                                const TFileName& /* aTestCaseFile */,
                                const TInt /* aCaseNumber */, 
                                TInt& /* aFailNextValue */ )
    {
    }

// -----------------------------------------------------------------------------
// CHgTestBase::OOMTestFinalizeL
// Used to perform the test environment cleanup for a particular OOM test case.
//
// NOTE: User may add implementation for OOM test environment finalization.
// Usually no implementation is required.
// -----------------------------------------------------------------------------
//
void CHgTestBase::OOMTestFinalizeL( 
                                const TFileName& /* aTestCaseFile */, 
                                const TInt /* aCaseNumber */ )
    {
    }

void CHgTestBase::SendTestModuleVersion( const TDesC& aModuleName )
    {
    TVersion moduleVersion;
    moduleVersion.iMajor = TEST_MODULE_VERSION_MAJOR;
    moduleVersion.iMinor = TEST_MODULE_VERSION_MINOR;
    moduleVersion.iBuild = TEST_MODULE_VERSION_BUILD;
    
    TBool newVersionOfMethod = ETrue;
    TestModuleIf().SendTestModuleVersion(moduleVersion, aModuleName, newVersionOfMethod);
    }
    
// -----------------------------------------------------------------------------
// CHgTestBase::RunTestCaseL
// RunTestCaseL is used to run an individual test case specified
// by aTestCase. Test cases that can be run may be requested from
// Test Module by GetTestCases method before calling RunTestCase.
// -----------------------------------------------------------------------------
//
TInt CHgTestBase::RunTestCaseL(
    const TInt aCaseNumber,
    const TFileName& /*aConfig*/,
    TTestResult& aResult )
    {
    if(!iVersionLogged)
        {
        CHgTestBase::SendTestModuleVersion( *iTestDllName );
        iVersionLogged = ETrue;
        }

    RPointerArray<TTestCaseInfo> aTestCases; //temporary

    /**
     * SetupL is responsible for inicialization of all fields (etc.) common for all testcases
     * MainTestL starts required testcase
     * TeardownL destroys all data that was created by SetupL
     */
    TInt errSetup = KErrNone;
    TInt errTestcase = KErrNone;

    if(aCaseNumber > iNumberOfTestCases)
        return KErrNotFound;

    __UHEAP_MARK;

    //TRAP(errSetup, MainTestL(CHgTestBase::ERunTestCase, STIF_RUN_SETUP, aTestCases, aResult);
    TRAP(errTestcase, MainTestL(CHgTestBase::ERunTestCase, aCaseNumber, aTestCases, aResult));
      //      MainTestL(CHgTestBase::ERunTestCase, STIF_RUN_TEARDOWN, aTestCases, aResult));

    __UHEAP_MARKEND;

    if(errTestcase != KErrNone)
        {
        aResult.SetResult(errTestcase, _L("Testcase failed"));
        }
    if(errSetup != KErrNone)
        {
        aResult.SetResult(errSetup, _L("Setup or teardown failed"));
        }

    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CHgTestBase::MainTestL
// Method responsible for enumerating and running test cases (and also setup and teardown activities before
// and after each test case).
// -----------------------------------------------------------------------------
//
TInt CHgTestBase::MainTestL(CHgTestBase::TCallReason aRunReason,
                             TInt aTestToRun,
                             RPointerArray<TTestCaseInfo>& aTestCases,
                             TTestResult& aResult )
    {
    if(aRunReason == CHgTestBase::ERunTestCase)
        {
        if(aTestToRun < 0)
            {
            iLog->Log(_L("Running setup or teardown"));
            }
        else
            {
            iLog->Log(_L("Running test case #%d"), aTestToRun);
            }
        }
    else
        {
        iLog->Log(_L("Enumerating test cases."));
        }

    TInt result = -1;

    // this method must be implemented in the test case
    result = RunTestL( aRunReason, aTestToRun, aTestCases, aResult );

    if(aRunReason != CHgTestBase::ERunTestCase)
        {
        iNumberOfTestCases = result;
        iLog->Log(_L("Enumeration completed."));
        }

    // Test case was executed
    return KErrNone;
    }    
    
//  End of File