/*

* Copyright (c) 2002 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: TestCase.cpp

*

*/

#include <utf.h>

#include "TestFrameWork/testCase.h"

#include "TestFrameWork/AssertFailure.h"

#include <StifTestModule.h>

#if 0

#include "TestCase.h"

#include "TestResult.h"

#include "AssertFailure.h"

#include "CppUnitLog.h"

#endif

// Assertion failure message formats:

_LIT8(KIntsNotEqualFormat,"expected: %d but was: %d");

_LIT8(KRealsNotEqualFormat,"expected: %g but was: %g");                                                    

_LIT8(KDesCsNotEqualFormat,"expected: '%S' but was: '%S'");

// A unique error code:

const TInt KErrCppUnitAssertionFailed=(-99999999);

void CTestCase::ConstructL (const TDesC8& aName)

    {

    iName = aName.AllocL();

    User::LeaveIfError(Dll::SetTls(0));

    }

CTestCase::CTestCase ()

: iAllocFailureType(RHeap::ENone),

iAllocFailureRate(0)

    {

    }

CTestCase::~CTestCase () 

    { 

    delete iName;

    }

// From MTest:

void CTestCase::ExecuteL (TTestResult& aResult)

    {

    TInt error = ExecuteImplL();

    aResult.iResult = error;

    // add the possible failure or error to the result

    if (error == KErrCppUnitAssertionFailed)

        {

        CAssertFailure* assertFailure = AssertFailureFromTlsL ();

        CleanupStack::PushL(assertFailure);

        TBuf16 <0x80> convertBuf;

        TBuf16 <256> temporaryBuf;

        convertBuf.Copy(assertFailure->What());

        temporaryBuf.Append(convertBuf);

        temporaryBuf.AppendFormat(_L(" at Line %i of "), assertFailure->LineNumber()); 

        convertBuf.Copy(assertFailure->FileName());

        if (convertBuf.Length() + temporaryBuf.Length() >= 0x80)

            {

            TBuf <0x80> printBuf;

            printBuf = convertBuf.Right(0x80 - temporaryBuf.Length() - 1 -3 );

            convertBuf = _L("...");

            convertBuf.Append(printBuf);

            }

        temporaryBuf.Append(convertBuf);

        aResult.iResultDes = temporaryBuf;

        CleanupStack::PopAndDestroy(assertFailure); 

        }

    }

// From MTest:

TInt CTestCase::CountTestCases ()

    {

    return 1;

    }

// From MTest:

const TDesC8& CTestCase::Name ()

    {

    return *iName;

    }

#if 1

// From MTest:

void CTestCase::ExecuteTestL(TTestResult& aResult,

                             TInt /*aIndex */)

    { 

    ExecuteL(aResult);

    }

const TDesC8& CTestCase::TestCaseName (TInt /*aIndex*/) 

    {

    return Name();

    }

#endif

// Check for a failed general assertion 

void CTestCase::AssertL (TBool aCondition,

                         const TDesC8& aConditionExpression,

                         TInt aLineNumber,

                         const TDesC8& aFileName)

    {

    if (!aCondition)

        {

        AllocFailureSimulation(EFalse);

        AssertFailureToTlsL (aConditionExpression,aLineNumber,aFileName);

        User::Leave (KErrCppUnitAssertionFailed);

        }

    }

// Check for a failed equality assertion

void CTestCase::AssertEqualsL (TInt anExpected, 

                               TInt anActual, 

                               TInt aLineNumber,

                               const TDesC8& aFileName)

    {

    if (anExpected != anActual)

        {

        AllocFailureSimulation(EFalse);

        HBufC8* msg = HBufC8::NewLC (KIntsNotEqualFormat().Size()+100);

        msg->Des().Format(KIntsNotEqualFormat, anExpected, anActual);

        AssertFailureToTlsL(*msg,aLineNumber,aFileName);

        CleanupStack::PopAndDestroy(); // msg

        User::Leave (KErrCppUnitAssertionFailed);

        }

    }

// Check for a failed equality assertion

void CTestCase::AssertEqualsL (TReal anExpected, 

                               TReal anActual, 

                               TReal aDelta,

                               TInt aLineNumber,

                               const TDesC8& aFileName)

    {

    if (Abs(anExpected-anActual) > aDelta)

        {

        AllocFailureSimulation(EFalse);

        HBufC8* msg = HBufC8::NewLC (KRealsNotEqualFormat().Size()+100);

        msg->Des().Format(KRealsNotEqualFormat, anExpected, anActual);

        AssertFailureToTlsL(*msg,aLineNumber,aFileName);

        CleanupStack::PopAndDestroy(); // msg

        User::Leave (KErrCppUnitAssertionFailed);

        }

    }

// Check equality of the contents of two 8-bit descriptors 

void CTestCase::AssertEqualsL (const TDesC8& anExpected,

                               const TDesC8& anActual,

                               TInt aLineNumber,

                               const TDesC8& aFileName)

    {

    if (anExpected.Compare(anActual) != 0)

        {

        AllocFailureSimulation(EFalse);

        HBufC8* msg = NotEqualsMessageLC (anExpected, anActual);

        AssertFailureToTlsL(*msg,aLineNumber,aFileName);

        CleanupStack::PopAndDestroy(); // msg

        User::Leave (KErrCppUnitAssertionFailed);

        }

    }

// Check equality of the contents of two 16-bit descriptors 

void CTestCase::AssertEqualsL (const TDesC16& aExpected,

                               const TDesC16& aActual,

                               TInt aLineNumber,

                               const TDesC8& aFileName)

    {

    if (aExpected.Compare(aActual) != 0)

        {

        AllocFailureSimulation(EFalse);

        HBufC8* msg = NotEqualsMessageLC (aExpected, aActual);

        AssertFailureToTlsL(*msg,aLineNumber,aFileName);

        CleanupStack::PopAndDestroy(); // msg

        User::Leave (KErrCppUnitAssertionFailed);

        }

    }

void CTestCase::AllocFailureSimulation (TBool aSwitchedOn)

    {

    if (aSwitchedOn)

        {

        __UHEAP_SETFAIL (iAllocFailureType, iAllocFailureRate);

        }

    else

        {

        __UHEAP_RESET;

        }

    }

TInt CTestCase::ExecuteImplL ()

    {

    __UHEAP_MARK;

    TRAPD (setupError, setUpL());

    if (setupError != KErrNone)

        {

        tearDown();

        __UHEAP_MARKEND;

        User::Leave(setupError);

        }

    TRAPD (executionError, executeTestL());

    tearDown();

    __UHEAP_MARKENDC(HeapCellsReservedByAssertFailure());

    return executionError;

    }

// Construct the message and put it in the cleanup stack

HBufC8* CTestCase::NotEqualsMessageLC (const TDesC8& aExpected,

                                       const TDesC8& aActual)

    {

    TInt size = KDesCsNotEqualFormat().Size()+aExpected.Size()+aActual.Size();

    HBufC8 *msg = HBufC8::NewLC(size);

    msg->Des().Format(KDesCsNotEqualFormat, &aExpected, &aActual);

    return msg;

    }

// Construct the message and put it in the cleanup stack

HBufC8* CTestCase::NotEqualsMessageLC (const TDesC16& aExpected,

                                       const TDesC16& aActual)

    {

    TInt length = KDesCsNotEqualFormat().Length() + 

        aExpected.Length() + aActual.Length();

    HBufC8* msg = HBufC8::NewLC(length);

    // Convert 16-bit to 8-bit to ensure readability

    // of the output possibly directed to a file.

    HBufC8* expected = HBufC8::NewLC(aExpected.Length());

    expected->Des().Copy(aExpected);

    HBufC8* actual = HBufC8::NewLC(aActual.Length());

    actual->Des().Copy(aActual);

    msg->Des().Format(KDesCsNotEqualFormat,expected,actual);

    // pop and destroy actual and expected

    CleanupStack::PopAndDestroy(2);

    return msg;

    }

void CTestCase::AssertFailureToTlsL (const TDesC8& aMessage,

                                     TInt  aLineNumber,

                                     const TDesC8& aFileName)

    {

    TInt cellsBefore = User::CountAllocCells();

    CAssertFailure* assertFailure = 

        CAssertFailure::NewLC(aMessage,aLineNumber,aFileName);

    User::LeaveIfError(Dll::SetTls(assertFailure));

    CleanupStack::Pop(); // assertFailure

    TInt cellsAfter = User::CountAllocCells();

    assertFailure->SetMyHeapCellCount(cellsAfter-cellsBefore);

    }

CAssertFailure* CTestCase::AssertFailureFromTlsL ()

    {

    CAssertFailure* assertFailure = static_cast<CAssertFailure*>(Dll::Tls());

    CAssertFailure* copy = CAssertFailure::NewL(*assertFailure);

    delete assertFailure;

    Dll::SetTls(0);

    return copy;

    }

TInt CTestCase::HeapCellsReservedByAssertFailure ()

    {

    if (Dll::Tls() == 0) return 0;

    CAssertFailure* assertFailure = static_cast<CAssertFailure*>(Dll::Tls());

    return assertFailure->MyHeapCellCount();

    }