/*

* Copyright (c) 2010 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: This file contains Hardcoded module implementation.

*

*/

#include <Stiftestinterface.h>

#include <SettingServerClient.h>

#include <sifui.h>                      // CSifUi

#include "SifUiTest.h"

const TInt KTestStackSize = 0x8000;     // 32K stack

const TInt KTestMinHeap = 0x4000;       // 16K heap min

const TInt KTestMaxHeap = 0x200000;     // 2M heap max

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

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

// CSifUiTest::NewL()

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

//

CSifUiTest* CSifUiTest::NewL()

    {

    CSifUiTest* self = new (ELeave) CSifUiTest;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CSifUiTest::~CSifUiTest()

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

//

CSifUiTest::~CSifUiTest()

    {

    iLog = NULL;

    delete iStdLog;

    delete iTCLog;

    iFs.Close();

    if( iScheduler )

        {

        CActiveScheduler::Install( NULL );

        delete iScheduler;

        }

    }

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

// CSifUiTest::InitL()

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

//

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

    {

    return KErrNone;

    }

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

// CSifUiTest::GetTestCasesL()

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

//

TInt CSifUiTest::GetTestCasesL( const TFileName& /*aConfig*/,

        RPointerArray<TTestCaseInfo>& aTestCases )

    {

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

        {

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

        CleanupStack::PushL( newCase );

        newCase->iCaseNumber = index;

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

        aTestCases.AppendL( newCase );

        CleanupStack::Pop( newCase );

        }

    return KErrNone;

    }

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

// CSifUiTest::RunTestCaseL

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

//

TInt CSifUiTest::RunTestCaseL( const TInt aCaseNumber,

        const TFileName& /*aConfig*/, TTestResult& aResult )

    {

    if( !iVersionLogged )

        {

        SendTestModuleVersion();

        iVersionLogged = ETrue;

        }

    TInt returnValue = KErrNone;

    TCaseInfo caseInfo = Case ( aCaseNumber );

    if( caseInfo.iMethod != NULL )

        {

        _LIT( KLogStartTC, "Starting testcase [%S]" );

        iLog->Log( KLogStartTC, &caseInfo.iCaseName );

        // Switch to use test case (TC) logger if necessary

        if( iAddTestCaseTitleToLogName )

            {

            if( iTCLog )

                {

                delete iTCLog;

                iTCLog = NULL;

                }

            TName title;

            TestModuleIf().GetTestCaseTitleL( title );

            TFileName logFileName;

            logFileName.Format( KSifUiTestLogFileWithTitle, &title );

            iTCLog = CStifLogger::NewL( KSifUiTestLogPath, logFileName );

            iLog = iTCLog;

            }

        // Run test case

        iMethod = caseInfo.iMethod;

        TRAPD( err, returnValue  = ( this->*iMethod )( aResult ) );

        // Restore standard log and close test case logger

        if( iAddTestCaseTitleToLogName )

            {

            iLog = iStdLog;

            delete iTCLog;

            iTCLog = NULL;

            }

        // Leave if the case execution failed

        User::LeaveIfError( err );

        }

    else

        {

        returnValue = KErrNotFound;

        }

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

    return returnValue;

    }

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

// CSifUiTest::SendTestModuleVersion

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

//

void CSifUiTest::SendTestModuleVersion()

    {

    TVersion moduleVersion;

    moduleVersion.iMajor = TEST_MODULE_VERSION_MAJOR;

    moduleVersion.iMinor = TEST_MODULE_VERSION_MINOR;

    moduleVersion.iBuild = TEST_MODULE_VERSION_BUILD;

    TFileName moduleName;

    moduleName = _L("SifUiTest.dll");

    TBool newVersionOfMethod = ETrue;

    TestModuleIf().SendTestModuleVersion( moduleVersion, moduleName, newVersionOfMethod );

    }

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

// CSifUiTest::CSifUiTest()

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

//

CSifUiTest::CSifUiTest()

    {

    }

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

// CSifUiTest::ConstructL()

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

//

void CSifUiTest::ConstructL()

    {

    User::LeaveIfError( iFs.Connect() );

    RSettingServer settingsServer;

    User::LeaveIfError( settingsServer.Connect() );

    CleanupClosePushL( settingsServer );

    TLoggerSettings loggerSettings;

    User::LeaveIfError( settingsServer.GetLoggerSettings( loggerSettings ) );

    CleanupStack::PopAndDestroy( &settingsServer );

    iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;

    iStdLog = CStifLogger::NewL( KSifUiTestLogPath, KSifUiTestLogFile );

    iLog = iStdLog;

    _LIT( KLogStart, "SifUiTest starts" );

    iLog->Log( KLogStart );

    iVersionLogged = EFalse;

    if( !CActiveScheduler::Current() )

        {

        iScheduler = new( ELeave ) CActiveScheduler;

        CActiveScheduler::Install( iScheduler );

        }

    }

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

// CSifUiTest::ErrorCodeString()

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

//

TPtrC CSifUiTest::ErrorCodeString( TInt aErrorCode ) const

    {

    switch( aErrorCode )

        {

        case KErrNone:

            return _L("KErrNone");

        case KErrNotFound:

            return _L("KErrNotFound");

        case KErrGeneral:

            return _L("KErrGeneral");

        case KErrCancel:

            return _L("KErrCancel");

        case KErrNoMemory:

            return _L("KErrNoMemory");

        case KErrNotSupported:

            return _L("KErrNotSupported");

        case KErrArgument:

            return _L("KErrArgument");

        case KErrTotalLossOfPrecision:

            return _L("KErrTotalLossOfPrecision");

        case KErrBadHandle:

            return _L("KErrBadHandle");

        case KErrOverflow:

            return _L("KErrOverflow");

        case KErrUnderflow:

            return _L("KErrUnderflow");

        case KErrAlreadyExists:

            return _L("KErrAlreadyExists");

        case KErrPathNotFound:

            return _L("KErrPathNotFound");

        case KErrDied:

            return _L("KErrDied");

        case KErrInUse:

            return _L("KErrInUse");

        case KErrServerTerminated:

            return _L("KErrServerTerminated");

        case KErrServerBusy:

            return _L("KErrServerBusy");

        case KErrCompletion:

            return _L("KErrCompletion");

        case KErrNotReady:

            return _L("KErrNotReady");

        case KErrUnknown:

            return _L("KErrUnknown");

        case KErrCorrupt:

            return _L("KErrCorrupt");

        case KErrAccessDenied:

            return _L("KErrAccessDenied");

        case KErrLocked:

            return _L("KErrLocked");

        case KErrWrite:

            return _L("KErrWrite");

        case KErrDisMounted:

            return _L("KErrDisMounted");

        case KErrEof:

            return _L("KErrEof");

        case KErrDiskFull:

            return _L("KErrDiskFull");

        case KErrBadDriver:

            return _L("KErrBadDriver");

        case KErrBadName:

            return _L("KErrBadName");

        case KErrCommsLineFail:

            return _L("KErrCommsLineFail");

        case KErrCommsFrame:

            return _L("KErrCommsFrame");

        case KErrCommsOverrun:

            return _L("KErrCommsOverrun");

        case KErrCommsParity:

            return _L("KErrCommsParity");

        case KErrTimedOut:

            return _L("KErrTimedOut");

        case KErrCouldNotConnect:

            return _L("KErrCouldNotConnect");

        case KErrCouldNotDisconnect:

            return _L("KErrCouldNotDisconnect");

        case KErrDisconnected:

            return _L("KErrDisconnected");

        case KErrBadLibraryEntryPoint:

            return _L("KErrBadLibraryEntryPoint");

        case KErrBadDescriptor:

            return _L("KErrBadDescriptor");

        case KErrAbort:

            return _L("KErrAbort");

        case KErrTooBig:

            return _L("KErrTooBig");

        case KErrDivideByZero:

            return _L("KErrDivideByZero");

        case KErrBadPower:

            return _L("KErrBadPower");

        case KErrDirFull:

            return _L("KErrDirFull");

        case KErrHardwareNotAvailable:

            return _L("KErrHardwareNotAvailable");

        case KErrSessionClosed:

            return _L("KErrSessionClosed");

        case KErrPermissionDenied:

            return _L("KErrPermissionDenied");

        case KErrExtensionNotSupported:

            return _L("KErrExtensionNotSupported");

        case KErrCommsBreak:

            return _L("KErrCommsBreak");

        case KErrNoSecureTime:

            return _L("KErrNoSecureTime");

        }

    return _L("UNKNOWN ERROR CODE");

    }

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

// CSifUiTest::SetResult()

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

//

void CSifUiTest::SetResult( TTestResult& aResult, const TInt aReturnCode ) const

    {

    aResult.SetResult( aReturnCode, ErrorCodeString( aReturnCode ) );

    }

// ==== OTHER EXPORTED FUNCTIONS ====

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

// LibEntryL is a polymorphic Dll entry point

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

//

EXPORT_C CTestModuleBase* LibEntryL()

    {

    return CSifUiTest::NewL();

    }

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

// SetRequirements handles test module parameters

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

//

EXPORT_C TInt SetRequirements( CTestModuleParam*& aTestModuleParam,

        TUint32& aParameterValid )

    {

    aParameterValid = KStifTestModuleParameterChanged;

    CTestModuleParamVer01* param = NULL;

    TRAPD( error, param = CTestModuleParamVer01::NewL() );

    if( !error )

        {

        param->iTestThreadStackSize = KTestStackSize;

        param->iTestThreadMinHeap = KTestMinHeap;

        param->iTestThreadMaxHeap = KTestMaxHeap;

        aTestModuleParam = param;

        }

    return error;

    }