/*

* Copyright (c) 2009 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:  

*

*/

#include "symbianunittestresult.h"

#include "symbianunittestobserver.h"

#include "symbianunittestfailure.h"

#include "sutlogger.h"

#include <symbianunittest.h>

#include <e32math.h>

#include <utf.h>

#include <e32debug.h>

// Assertion failure message formats:

_LIT8( KIntsNotEqualFormat, "Asserted: expected=%d, actual=%d" );

_LIT8( KDesCsNotEqualFormat, "Asserted: expected='%S', actual='%S'" );

_LIT8( KAssertLeaveFormat1, "'%S' expected to leave: expected=%d, actual=%d" );

_LIT8( KAssertLeaveFormat2, "'%S' expected to leave but did not leave" );

const TInt KMaxSizeOfTwoIntsAsText = 80;

const TInt KErrSymbianUnitTestAssertionFailed = -99999999;

_LIT( KTestThreadName, "SymbianUnitTestThread" );

const TInt KTestThreadMaxHeapSize = 0x400000; // 4 MB

_LIT8( KDoubleColon8, "::" );

_LIT( KDoubleColon16, "::" );

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

//

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

//

EXPORT_C void CSymbianUnitTest::ConstructL( const TDesC8& aName )

    {    

    TInt doubleColonPos( aName.FindF( KDoubleColon8 ) );

    TPtrC8 classNamePtr( aName );

    if ( doubleColonPos > 0 )

        {

        classNamePtr.Set( aName.Left( doubleColonPos ) );

        }

    iName = CnvUtfConverter::ConvertToUnicodeFromUtf8L( classNamePtr ); 

    SUT_LOG_FORMAT(_L("enter CSymbianUnitTest::ConstructL -- aName : [%S]"), iName );

    // unify the same name for armv5 & winscw. 

    // on winscw, the function name is abc, 

    // on armv5,  the function name is void abc. 

    // unify to abc. 

    TChar chSpace( ' ' );

    TChar chTab( '\t' );

    TChar chAsterisk( '*' );

    TChar chAnd( '&' );

    TBuf<100> strTmp( *iName ); 

    strTmp.Trim();

    TInt pos;

    // "char * & abc" => abc

    pos = strTmp.LocateReverse( chAnd );

    if( KErrNotFound != pos ) 

    	{

    	TPtrC ptr = strTmp.Right( strTmp.Length() - pos - 1 );

    	strTmp = ptr;

    	strTmp.Trim();

    	}

    // "void * abc" => abc

    pos = strTmp.LocateReverse( chAsterisk );

    if( KErrNotFound != pos ) 

    	{

    	TPtrC ptr = strTmp.Right( strTmp.Length() - pos - 1 );

    	strTmp = ptr;

    	strTmp.Trim();

    	}

    // "void abc"

    pos = strTmp.LocateReverse( chSpace );

    if( KErrNotFound != pos ) 

    	{

    	TPtrC ptr = strTmp.Right( strTmp.Length() - pos - 1 );

    	strTmp = ptr;

    	strTmp.Trim();

    	}

    // "void 	abc"

    pos = strTmp.LocateReverse( chTab );

    if( KErrNotFound != pos ) 

    	{

    	TPtrC ptr = strTmp.Right( strTmp.Length() - pos - 1 );

    	strTmp = ptr;

    	strTmp.Trim();

    	}

    *iName = strTmp;

    SUT_LOG_FORMAT(_L("exit CSymbianUnitTest::ConstructL -- aName : [%S]"), iName );

    }

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

//

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

//

EXPORT_C CSymbianUnitTest::CSymbianUnitTest()

 : iAllocFailureType( RHeap::ENone ),

   iAllocFailureRate( 0 )

    {

    }

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

//

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

//

EXPORT_C CSymbianUnitTest::~CSymbianUnitTest() 

    { 

    delete iName;

    iTestCases.ResetAndDestroy();

    }

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

// From MSymbianUnitTestInterface

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

//

EXPORT_C void CSymbianUnitTest::ExecuteL(

    MSymbianUnitTestObserver& aObserver,

    CSymbianUnitTestResult& aResult,

    MSymbianUnitTestInterface::TFailureSimulation aFailureSimulation,

    const CDesCArray& aTestCaseNames,

    TInt aTimeout )

    {

    if ( aFailureSimulation == EMemAllocFailureSimulation )

        {

        iAllocFailureType = RHeap::EDeterministic;

        }

    else

        {

        iAllocFailureType = RHeap::ENone;

        }      

    SUT_LOG_FORMAT(_L("start testing, total test cases[%d]"), iTestCases.Count());

    //print the test cases name in the log

    for ( TInt i = iTestCases.Count() -1; i >=0 ; i-- )

        {

        CSymbianUnitTestCase& testCase = *( iTestCases[ i ] );

	//check the specified test case list if any

	if ( aTestCaseNames.Count() > 0 )

	    {

	    TInt index=0;

	    TInt ret = aTestCaseNames.Find(testCase.Name(), index );

	    if (ret != 0)

	        {

		    //the case isn't in the specified test case names, skip it

            SUT_LOG_FORMAT(_L("skip test case[%S]"), &testCase.Name());

		    delete iTestCases[i];

            iTestCases.Remove(i);

            continue;

	        }

	    }

	SUT_LOG_FORMAT(_L("TestCase[%S]"), &testCase.Name());

        }

    for ( TInt i = 0; i < iTestCases.Count(); i++ )

        {

        CSymbianUnitTestCase& testCase = *( iTestCases[ i ] );

        aResult.StartTestL( testCase.Name() );

        ExecuteTestCaseInThreadL( testCase, aResult, aTimeout );

        aResult.EndTestL();

        if (aResult.CurrentResult())

            {

            aObserver.TestPass(iCurrentTestCase->Name());

            }

        else

            {

            CSymbianUnitTestFailure* failure = aResult.Failures()[

                aResult.Failures().Count()-1];

            aObserver.TestFailed(iCurrentTestCase->Name(), failure->FailureMessage());

            }

        }

    SUT_LOG_FORMAT(_L("testing finished, total passed test cases[%d]"), aResult.PassedTestCount());

    }

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

// From MSymbianUnitTestInterface

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

//

EXPORT_C TInt CSymbianUnitTest::TestCaseCount()

    {

    return iTestCases.Count();

    }

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

// From MSymbianUnitTestInterface

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

//

EXPORT_C const TDesC& CSymbianUnitTest::Name() const

    {

    if ( iName )

        {

        return *iName;

        }

    return KNullDesC;

    }

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

// From MSymbianUnitTestInterface

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

//

EXPORT_C void CSymbianUnitTest::TestCaseNamesL(CDesCArray& aTestCaseNames)

    {

    for ( TInt i = iTestCases.Count() -1; i >=0 ; i-- )

        {

        CSymbianUnitTestCase& testCase = *( iTestCases[ i ] );

        aTestCaseNames.AppendL(testCase.Name());

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::SetupL()

    {

    // The default implementation is no operation

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::Teardown()

    {

    // The default implementation is no operation

    }

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

//

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

//

EXPORT_C TBool CSymbianUnitTest::IsMemoryAllocationFailureSimulationUsed() const

    {

    return ( iAllocFailureType == RHeap::EDeterministic );

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AddTestCaseL( 

    const TDesC& aName,

    FunctionPtr aSetupFunction,

    FunctionPtr aTestFunction,

    FunctionPtr aTeardownFunction )

    {

    const TInt KTestCaseNameLength = 

        Name().Length() + KDoubleColon16().Length() + aName.Length(); 

    HBufC* name = HBufC::NewLC( KTestCaseNameLength );

    name->Des().Append( Name() );

    name->Des().Append( KDoubleColon16 );

    name->Des().Append( aName ); 

    CSymbianUnitTestCase* testCase = 

        CSymbianUnitTestCase::NewL( 

            *name, aSetupFunction, aTestFunction, aTeardownFunction );

    CleanupStack::PopAndDestroy( name );

    CleanupStack::PushL( testCase );

    iTestCases.AppendL( testCase );

    CleanupStack::Pop( testCase );

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    TInt aExpectedValue, 

    TInt aActualValue, 

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    if ( aExpectedValue != aActualValue )

        {

        StopAllocFailureSimulation();

        HBufC8* msg = HBufC8::NewLC( 

            KIntsNotEqualFormat().Size() + KMaxSizeOfTwoIntsAsText );

        msg->Des().Format( KIntsNotEqualFormat, aExpectedValue, aActualValue );

        AssertionFailedL( *msg, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    const TDesC8& aExpectedValue,

    const TDesC8& aActualValue,

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    if ( aExpectedValue.Compare( aActualValue ) != 0 )

        {

        StopAllocFailureSimulation();

        TInt size = 

            KDesCsNotEqualFormat().Size() + 

            aExpectedValue.Size() + 

            aActualValue.Size();

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

        msg->Des().Format( KDesCsNotEqualFormat, 

                           &aExpectedValue, 

                           &aActualValue );

        AssertionFailedL( *msg, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    const TDesC16& aExpectedValue,

    const TDesC16& aActualValue,

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    if ( aExpectedValue.Compare( aActualValue ) != 0 )

        {

        StopAllocFailureSimulation();

        HBufC8* msg = NotEqualsMessageLC( aExpectedValue, aActualValue );

        AssertionFailedL( *msg, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertLeaveL(

    const TDesC8& aStatement,

    TInt aActualLeaveCode,

    TInt aExpectedLeaveCode,

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    if ( aActualLeaveCode == KErrNoMemory &&

         aExpectedLeaveCode != KErrNoMemory &&

         iAllocFailureType == RHeap::EDeterministic )

        {

        User::Leave( KErrNoMemory );

        }   

    if ( aActualLeaveCode != aExpectedLeaveCode )

        {

        StopAllocFailureSimulation();

        HBufC8* msg = HBufC8::NewLC( 

            KAssertLeaveFormat1().Size() + 

            aStatement.Size() + 

            KMaxSizeOfTwoIntsAsText );

        msg->Des().Format( KAssertLeaveFormat2, &aStatement, 

                           aExpectedLeaveCode, aActualLeaveCode );        

        AssertionFailedL( *msg, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::RecordNoLeaveFromStatementL(

    const TDesC8& aStatement,

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    StopAllocFailureSimulation();

    HBufC8* msg = 

        HBufC8::NewLC( KAssertLeaveFormat1().Size() + aStatement.Size() );

    msg->Des().Format( KAssertLeaveFormat1, &aStatement );        

    AssertionFailedL( *msg, aLineNumber, aFileName );

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertionFailedL(

    const TDesC8& aFailureMessage,

    TInt aLineNumber,

    const TDesC8& aFileName )

    {

    TInt dummy( 0 );

    TInt heapCellsBeforeAddingTheFailure( User::Heap().AllocSize( dummy ) );

    if ( iTestResult )

        {

        User::LeaveIfError( iTestResult->AddAssertFailure( 

            aFailureMessage, aLineNumber, aFileName ) );

        }

    TInt heapCellsAfterAddingTheFailure( User::Heap().AllocSize( dummy ) );

    iHeapCellsReservedByAssertFailure = 

        heapCellsAfterAddingTheFailure - heapCellsBeforeAddingTheFailure;

    User::Leave( KErrSymbianUnitTestAssertionFailed );

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    TInt aExpectedValue, 

    TInt aActualValue, 

    TInt aLineNumber,

    const TDesC8& aFileName,

    const TDesC8& aFailureMessage )

    {

    if ( aExpectedValue != aActualValue )

        {

        StopAllocFailureSimulation();

        AssertionFailedL( aFailureMessage, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    const TDesC8& aExpectedValue,

    const TDesC8& aActualValue,

    TInt aLineNumber,

    const TDesC8& aFileName,

    const TDesC8& aFailureMessage )

    {

    if ( aExpectedValue.Compare( aActualValue ) != 0 )

        {

        StopAllocFailureSimulation();

        AssertionFailedL( aFailureMessage, aLineNumber, aFileName );

        }

    }

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

//

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

//

EXPORT_C void CSymbianUnitTest::AssertEqualsL(

    const TDesC16& aExpectedValue,

    const TDesC16& aActualValue,

    TInt aLineNumber,

    const TDesC8& aFileName,

    const TDesC8& aFailureMessage )

    {

    if ( aExpectedValue.Compare( aActualValue ) != 0 )

        {

        StopAllocFailureSimulation();

        AssertionFailedL( aFailureMessage, aLineNumber, aFileName );

        }

    }

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

//

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

//

CSymbianUnitTest::CSymbianUnitTestCase* 

CSymbianUnitTest::CSymbianUnitTestCase::NewL( 

    const TDesC& aName,

    FunctionPtr aSetupFunction,

    FunctionPtr aTestFunction,

    FunctionPtr aTeardownFunction )

    {

    CSymbianUnitTestCase* self = 

        new( ELeave )CSymbianUnitTestCase( 

            aSetupFunction, aTestFunction, aTeardownFunction );

    CleanupStack::PushL( self );

    self->ConstructL( aName );

    CleanupStack::Pop( self );

    return self;    

    }

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

//

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

//

CSymbianUnitTest::CSymbianUnitTestCase::CSymbianUnitTestCase( 

    FunctionPtr aSetupFunction,

    FunctionPtr aTestFunction,

    FunctionPtr aTeardownFunction ) :

    iSetupFunction( aSetupFunction ),

    iTestFunction( aTestFunction ),

    iTeardownFunction( aTeardownFunction )

    {

    }

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

//

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

//

void CSymbianUnitTest::CSymbianUnitTestCase::ConstructL( const TDesC& aName )

    {

    iName = aName.AllocL();

    }

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

//

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

//

CSymbianUnitTest::CSymbianUnitTestCase::~CSymbianUnitTestCase()

    {

    delete iName;

    }

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

//

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

//

const TDesC& CSymbianUnitTest::CSymbianUnitTestCase::Name() const

    {

    return *iName;

    }

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

//

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

//