/*

 * 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: Symbian C++ test runner Class.

 *

 */

#include "testrunner_s60.h"

#include "symbianunittestrunner.h"

#include "widgettestrunner.h"

_LIT( KOutputFileName, "SymbianUnitTestResults" );

_LIT( KDefaultOutputFormat, "html" );

TestRunnerPrivate* TestRunnerPrivate::NewLC(WidgetTestRunner* aPublicApi)

    {

    TestRunnerPrivate* self = new (ELeave) TestRunnerPrivate(aPublicApi);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

TestRunnerPrivate* TestRunnerPrivate::NewL(WidgetTestRunner* aPublicApi)

    {

    TestRunnerPrivate* self = TestRunnerPrivate::NewLC(aPublicApi);

    CleanupStack::Pop(self);

    return self;

    }

TestRunnerPrivate::TestRunnerPrivate(WidgetTestRunner* aPublicApi) :

    CActive(EPriorityStandard), d_ptr(aPublicApi), iTimeout(

            KSymbianUnitTestDefaultTimeout)

    {

    }

void TestRunnerPrivate::ConstructL()

    {

    User::SetJustInTime(EFalse); // Do not stop on test case panics

    iTestDllNames = new (ELeave) CDesCArrayFlat(1);

    iTestCaseNames = new (ELeave) CDesCArrayFlat(1);

    iOutputFormat = KDefaultOutputFormat().AllocL();

    CActiveScheduler::Add(this);

    }

TestRunnerPrivate::~TestRunnerPrivate()

    {

    Cancel();

    delete iTestDllNames;

    delete iTestCaseNames;

    delete iOutputFormat;

    }

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

// From MSymbianUnitTestUiCallBack

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

//

void TestRunnerPrivate::InfoMsg(const TDesC& aMessage)

    {

    QString msg = QString::fromUtf16(aMessage.Ptr(), aMessage.Length());

    emit d_ptr->infoMsgReceived(msg);

    }

int TestRunnerPrivate::SetTestDllNames(const QStringList& aDllNames)

    {

    TRAPD(err, SetTestDllNamesL(aDllNames));

    return err;

    }

int TestRunnerPrivate::SetTestCaseNames(const QStringList& aCaseNames)

    {

    TRAPD(err, SetTestCaseNamesL(aCaseNames));

    return err;

    }

int TestRunnerPrivate::SetOutputFormat(const QString& aFmt)

    {

    TRAPD(err, SetOutputFormatL(aFmt));

    return err;

    }

int TestRunnerPrivate::ListTestCases(const QString& aDllName, QStringList& aCaseNames)

    {

    TRAPD(err, ListTestCasesL(aDllName, aCaseNames));

    return err;

    }

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

// From MSymbianUnitTestUiCallBack

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

//

void TestRunnerPrivate::InfoMsg(const TDesC& aFormat, const TDesC& aMessage)

    {

    //    iConsole->Printf( aFormat, &aMessage );

    }

void TestRunnerPrivate::TestsCount()

    {

    }

void TestRunnerPrivate::TestsExecuted()

    {

    emit d_ptr->testExecuted(iPassedTestsCount + iFailedTestsCount);

    }

void TestRunnerPrivate::SetTestDllNamesL(const QStringList& aDllNames)

    {

    if (!aDllNames.isEmpty())

        {

        CDesCArray* testDllNames = new (ELeave) CDesCArrayFlat(1);

        CleanupStack::PushL(testDllNames);

        foreach (QString tmp, aDllNames)

                {

                TPtrC myDescriptor(static_cast<const TUint16*> (tmp.utf16()),

                        tmp.length());

                HBufC* buffer = myDescriptor.AllocL();

                testDllNames->AppendL(buffer->Des());

                }

        delete iTestDllNames;

        iTestDllNames = testDllNames;

        CleanupStack::Pop(testDllNames);

        }

    }

void TestRunnerPrivate::SetTestCaseNamesL(const QStringList& aNames)

    {

    if (!aNames.isEmpty())

        {

        CDesCArray* testCaseNames = new (ELeave) CDesCArrayFlat(1);

        CleanupStack::PushL(testCaseNames);

        foreach (QString tmp, aNames)

                {

                TPtrC myDescriptor(static_cast<const TUint16*> (tmp.utf16()),

                        tmp.length());

                HBufC* buffer = myDescriptor.AllocL();

                testCaseNames->AppendL(buffer->Des());

                }

        delete iTestCaseNames;

        iTestCaseNames = testCaseNames;

        CleanupStack::Pop(testCaseNames);

        }

    }

void TestRunnerPrivate::SetAllocFailureSimulation(const TBool aSimulation)

    {

    iAllocFailureSimulation = aSimulation;

    }

void TestRunnerPrivate::SetTimeout(const TInt aTimeout)

    {

    iTimeout = aTimeout;

    }

void TestRunnerPrivate::SetOutputFormatL(const QString& aFormat)

    {

    TPtrC outputFormatPtr(aFormat.utf16());

    HBufC* outputFormat = outputFormatPtr.AllocL();

    delete iOutputFormat;

    iOutputFormat = outputFormat;

    }

void TestRunnerPrivate::RunL()

    {

    iTestRunner = CSymbianUnitTestRunner::NewL(*this);

    iPassedTestsCount = 0;

    iFailedTestsCount = 0;

    TRAPD(err, iTestRunner->ExecuteTestsL(*iTestDllNames,

                    iAllocFailureSimulation,

                    KOutputFileName,

                    *iOutputFormat,

                    *iTestCaseNames,

                    iTimeout));

    if (err != KErrNone)

        {

        emit d_ptr->errorOccurred(err);

        }

    delete iTestRunner;

    iTestRunner = NULL;

    }

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

// From CActive

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

//

void TestRunnerPrivate::DoCancel()

    {

    }

void TestRunnerPrivate::RunTests()

    {

    // Set ready to run immediately

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    if (!IsActive())

        {

        SetActive();

        }

    }

void TestRunnerPrivate::ListTestCasesL(const QString& aDllName,

        QStringList& aTestCases)

    {

    iTestRunner = CSymbianUnitTestRunner::NewL(*this);

    TPtrC dllName(static_cast<const TUint16*> (aDllName.utf16()),

            aDllName.length());

    CDesCArray* testCaseNames = new (ELeave) CDesCArrayFlat(1);

    CleanupStack::PushL(testCaseNames);

    iTestRunner->TestCaseNamesL(dllName, *testCaseNames);

    for (int i = 0; i < testCaseNames->Count(); ++i)

        {

        aTestCases << QString::fromUtf16((*testCaseNames)[i].Ptr(),

                (*testCaseNames)[i].Length());

        }

    CleanupStack::PopAndDestroy(testCaseNames);

    delete iTestRunner;

    iTestRunner = NULL;

    }

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

// From MSymbianUnitTestUiCallBack

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

//

void TestRunnerPrivate::TestPass(const TDesC& aTestCaseName)

    {

    QString caseName = QString::fromUtf16(aTestCaseName.Ptr(),

            aTestCaseName.Length());

    emit

    d_ptr->infoMsgReceived(caseName);

    emit

    d_ptr->testPassed(++iPassedTestsCount);

    TestsExecuted();

    }

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

// From MSymbianUnitTestUiCallBack

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

//

void TestRunnerPrivate::TestFailed(const TDesC& aTestCaseName,

        const TDesC8& aErrMsg)

    {

    QString caseName = QString::fromUtf16(aTestCaseName.Ptr(),

            aTestCaseName.Length());

    QString reason = QString::fromUtf8(

            reinterpret_cast<const char*> (aErrMsg.Ptr()), aErrMsg.Length());

    emit

    d_ptr->testFailed(caseName, reason, ++iFailedTestsCount);

    TestsExecuted();

    }