/*
* 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 "symbianunittestrunner.h"
#include "symbianunittestuicallback.h"
#include "symbianunittestoutputformatter.h"
#include "symbianunittestoutputfactory.h"
#include "symbianunittestresult.h"
#include "symbianunittestversion.h"
#include "sutlogger.h"
#include "symbianunittestlddctl.h"
#include <symbianunittestinterface.h>
#include <e32uid.h>


// Failures while loading dll:
_LIT( KFailedToFindDll, "Failed to find DLL:\n\"%S\"\n" );
_LIT( KFailedToLoadLDD, "Failed to load LDD:\n\"%S\"\n" );
_LIT( KFailedToRunLDD, "Failed to run LDD tests:\n\"%S\"\n" );
_LIT( KNonCompatibleUIDs, "Cannot use DLL with non-compatible UIDs!\n" );
_LIT( KExportFuncNotFound, "Cannot find EXPORT function from test DLL!\n" );
_LIT( KLogVersion, "SymbianUnitTest v%d.%d.%d" );
_LIT( KLogFinish, "SymbianUnitTest finished" );

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CSymbianUnitTestRunner* CSymbianUnitTestRunner::NewLC( 
    MSymbianUnitTestUiCallBack& aUiCallBack )
    {
    CSymbianUnitTestRunner* self = 
        new( ELeave )CSymbianUnitTestRunner( aUiCallBack );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CSymbianUnitTestRunner* CSymbianUnitTestRunner::NewL( 
    MSymbianUnitTestUiCallBack& aUiCallBack )
    {
    CSymbianUnitTestRunner* self = CSymbianUnitTestRunner::NewLC( aUiCallBack );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CSymbianUnitTestRunner::CSymbianUnitTestRunner( 
    MSymbianUnitTestUiCallBack& aUiCallBack )
    : iUiCallBack( aUiCallBack )
    {
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::ConstructL()
    {
    iResult = CSymbianUnitTestResult::NewL();
    //init logger
    TBuf<50> version;
    version.Format(KLogVersion, SUT_MAJOR_VERSION, SUT_MINOR_VERSION, SUT_BUILD_VERSION);
    SUT_LOG_START(version);
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CSymbianUnitTestRunner::~CSymbianUnitTestRunner()
    {
    delete iResult;
    }

// -----------------------------------------------------------------------------
// From MSymbianUnitTestObserver
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::TestPass(const TDesC& aTestCaseName)
    {
    iUiCallBack.TestPass(aTestCaseName);
    }

// -----------------------------------------------------------------------------
// From MSymbianUnitTestObserver
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::TestFailed(const TDesC& aTestCaseName, const TDesC8& aErrMsg)
    {
    iUiCallBack.TestFailed(aTestCaseName, aErrMsg);
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSymbianUnitTestRunner::TestCount()
    {
    return iTestCount;
    }

EXPORT_C TInt CSymbianUnitTestRunner::TestCountL(const MDesCArray& aTestDllNames, const MDesCArray& aTestCaseNames)
    {
    TInt dllCnt = aTestDllNames.MdcaCount(); 
    if (dllCnt == 0)
        {
        return 0;
        }
    TInt caseCnt = aTestCaseNames.MdcaCount();
    if (caseCnt != 0)
        {
        return caseCnt;
        }
    else
        {
        for ( TInt i = 0; i < dllCnt; i++)
            {
            CDesCArray* testCaseNames = new (ELeave) CDesCArrayFlat(1);
            CleanupStack::PushL(testCaseNames);
            this->TestCaseNamesL(aTestDllNames.MdcaPoint(i), *testCaseNames);
            caseCnt += testCaseNames->Count();
            CleanupStack::PopAndDestroy(testCaseNames);
            }
        return caseCnt;
        }
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CSymbianUnitTestRunner::ExecuteTestsL(
    const MDesCArray& aTestDllNames,
    TBool aMemoryAllocationFailureSimulation,
    const TDesC& aOutputFileName,
    const TDesC& aOutputFormat,
    const CDesCArray& aTestCaseNames,
    TInt  aTimeout )
    {
    iTestCount = 0;
    
    MSymbianUnitTestInterface::TFailureSimulation failureSimulation = 
        MSymbianUnitTestInterface::ENoFailureSimulation;
    if ( aMemoryAllocationFailureSimulation )
        {
        failureSimulation = 
            MSymbianUnitTestInterface::EMemAllocFailureSimulation;
        }
    
    for ( TInt i = 0; i < aTestDllNames.MdcaCount(); i++ )
        {
        TPtrC16 testDllName( aTestDllNames.MdcaPoint( i ) );
        if (testDllName.Find(_L(".ldd"))>0)
            {
            ExecuteLddTestsL(testDllName, aTestCaseNames, aTimeout);
            }
        else
            {
            //it is dll test
            ExecuteDllTestsL(testDllName, failureSimulation, aTestCaseNames, aTimeout);
            }
        }
    
    CSymbianUnitTestOutputFormatter* outputFormatter = 
        SymbianUnitTestOutputFactory::CreateOutputLC( 
            aOutputFileName, aOutputFormat );
    outputFormatter->PrintL( *iResult );
    CleanupStack::PopAndDestroy( outputFormatter );    
    SUT_LOG_INFO(KLogFinish);
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CSymbianUnitTestRunner::FailedTestCount()
    {
    return iResult->Failures().Count();
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CSymbianUnitTestRunner::TestCaseNamesL(
    const TDesC& aTestDllName, CDesCArray& aTestCaseNames)
    {
    
    if (aTestDllName.Find(_L(".ldd"))>0)
        {
        //it is kernel ldd test
        return GetLddTestCaseNamesL(aTestDllName, aTestCaseNames);
        }
    else
        {
        //it is dll test
        return GetDllTestCaseNamesL(aTestDllName, aTestCaseNames);
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::GetDllTestCaseNamesL(
        const TDesC& aTestDllName, CDesCArray& aTestCaseNames)
    {
    RLibrary library;
    TInt ret;
    ret = library.Load(aTestDllName);
    if (ret != KErrNone)
        {
        iUiCallBack.InfoMsg(KFailedToFindDll, aTestDllName);
        SUT_LOG_FORMAT(KFailedToFindDll, &aTestDllName);
        User::Leave(ret);
        }
    CleanupClosePushL(library);
    // The second UID of the dll to be used must be compatible
    if (library.Type()[1] != KSymbianUnitTestDllUid)
        {
        iUiCallBack.InfoMsg(KNonCompatibleUIDs);
        User::Leave(KErrNotFound);
        }
    TLibraryFunction entryFunction = library.Lookup(1);
    if (!entryFunction)
        {
        iUiCallBack.InfoMsg(KExportFuncNotFound);
        User::Leave(KErrNotFound);
        }

    MSymbianUnitTestInterface* test =
            reinterpret_cast<MSymbianUnitTestInterface*> (entryFunction());
    
    TCleanupItem cleanupItem(DeleteTest, test);
    CleanupStack::PushL(cleanupItem);
    
    test->TestCaseNamesL(aTestCaseNames);
    CleanupStack::Pop(); // cleanupItem
    CleanupStack::PopAndDestroy(&library);
  
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::GetLddTestCaseNamesL(
        const TDesC& aTestLddName, CDesCArray& aTestCaseNames)
    {
    CSymbianUnitTestLddCtl* lddCtl = CSymbianUnitTestLddCtl::NewLC(
            aTestLddName);
    TInt ret = lddCtl->LoadDriver();
    if (ret != KErrNone)
        {
        iUiCallBack.InfoMsg(KFailedToLoadLDD, aTestLddName);
        SUT_LOG_FORMAT(KFailedToLoadLDD, &aTestLddName);
        User::Leave(ret);
        }

    ret = lddCtl->GetTestCaseNames(aTestCaseNames); 
    if (ret != KErrNone)
        {
        iUiCallBack.InfoMsg(KFailedToRunLDD, aTestLddName);
        SUT_LOG_FORMAT(KFailedToRunLDD, &aTestLddName);
        User::Leave(ret);
        }
    lddCtl->FreeDriver();
    CleanupStack::PopAndDestroy(lddCtl);
    SUT_LOG_FORMAT(_L(" case name count:%d\n"), aTestCaseNames.Length());
    for (TInt i = 0; i < aTestCaseNames.Length(); i++)
        {
            SUT_LOG_FORMAT(_L(" case:%S\n"), &aTestCaseNames[i]);
        }
    }

// -----------------------------------------------------------------------------
// 
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::DeleteTest( TAny* aTest )
    {
    MSymbianUnitTestInterface* test = 
        reinterpret_cast< MSymbianUnitTestInterface* >( aTest );
    delete test;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::ExecuteDllTestsL(const TDesC& aTestDllName, MSymbianUnitTestInterface::TFailureSimulation aFailureSimulation,
        const CDesCArray& aTestCaseNames, TInt  aTimeout)
    {
    RLibrary library;
    TInt ret;
    ret = library.Load(aTestDllName);
    if (ret != KErrNone)
        {
        iUiCallBack.InfoMsg(KFailedToFindDll, aTestDllName);
        SUT_LOG_FORMAT(KFailedToFindDll, &aTestDllName);
        User::Leave(ret);
        }
    CleanupClosePushL(library);
    // The second UID of the dll to be used must be compatible
    if (library.Type()[1] != KSymbianUnitTestDllUid)
        {
        iUiCallBack.InfoMsg(KNonCompatibleUIDs);
        User::Leave(KErrNotFound);
        }
    TLibraryFunction entryFunction = library.Lookup(1);
    if (!entryFunction)
        {
        iUiCallBack.InfoMsg(KExportFuncNotFound);
        User::Leave(KErrNotFound);
        }

    MSymbianUnitTestInterface* test =
            reinterpret_cast<MSymbianUnitTestInterface*> (entryFunction());
    TCleanupItem cleanupItem(DeleteTest, test);
    CleanupStack::PushL(cleanupItem);
    iTestCount += test->TestCaseCount();
    test->ExecuteL(*this, *iResult, aFailureSimulation, aTestCaseNames,
            aTimeout);
    CleanupStack::Pop(); // cleanupItem
    CleanupStack::PopAndDestroy(&library);
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CSymbianUnitTestRunner::ExecuteLddTestsL(const TDesC& aTestLddName, const CDesCArray& /*aTestCaseNames*/,
        TInt  /*aTimeout*/)
    {
    CSymbianUnitTestLddCtl* lddCtl = CSymbianUnitTestLddCtl::NewLC( aTestLddName );
    TInt ret = lddCtl->LoadDriver();
    if (ret != KErrNone)
        {
        iUiCallBack.InfoMsg(KFailedToLoadLDD, aTestLddName);
        SUT_LOG_FORMAT(KFailedToLoadLDD, &aTestLddName);
        User::Leave(ret);
        }
    
    ret = lddCtl->ExecuteLddTests(*this, *iResult);
    if (ret != KErrNone)
            {
            iUiCallBack.InfoMsg(KFailedToRunLDD, aTestLddName);
            SUT_LOG_FORMAT(KFailedToRunLDD, &aTestLddName);
            User::Leave(ret);
            }
    lddCtl->FreeDriver();
    CleanupStack::PopAndDestroy( lddCtl );
    }