/*

* 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: This module contains implementation of CTestReport 

* class member functions.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <f32file.h>

#include <hal.h>

#include "TestReport.h"

#include "TestEngineCommon.h"

#include "Logging.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

// None

// MACROS

const TInt KMaxLenEol = 6;

const TInt KMaxReportData = 256;

typedef TBuf<KMaxReportData> TPrintInfo;

const TInt KSummaryLineEndLen = 12;

_LIT( KSummaryLineEnd,  "            ");

// XML Tags (alphabetically)

_LIT(KXMLCaseNumberTag,          "<CaseNumber>");

_LIT(KXMLCaseNumberTagEnd,       "</CaseNumber>");

_LIT(KXMLCaseTitleTag,           "<Title>");

_LIT(KXMLCaseTitleTagEnd,        "</Title>");

_LIT(KXMLConfigFileTag,          "<Config>");

_LIT(KXMLConfigFileTagEnd,       "</Config>");

_LIT(KXMLCpuSpeedTag,            "<CPUSpeed>");

_LIT(KXMLCpuSpeedTagEnd,         "</CPUSpeed>");

_LIT(KXMLCpuTag,                 "<CPU>");

_LIT(KXMLCpuTagEnd,              "</CPU>");

_LIT(KXMLCrashedTag,             "<Crashed>");

_LIT(KXMLCrashedTagEnd,          "</Crashed>");

_LIT(KXMLDateTag,                "<Date>");

_LIT(KXMLDateTagEnd,             "</Date>");

_LIT(KXMLDllSummaryTag,          "<Dlls>");

_LIT(KXMLDllSummaryTagEnd,       "</Dlls>");

_LIT(KXMLDllTag,                 "<Dll>");

_LIT(KXMLDllTagEnd,              "</Dll>");

_LIT(KXMLEndTimeTag,             "<EndTime>");

_LIT(KXMLEndTimeTagEnd,          "</EndTime>");

_LIT(KXMLEnvironmentInfoTag,     "<EnvironmentInfo>");

_LIT(KXMLEnvironmentInfoTagEnd,  "</EnvironmentInfo>");

_LIT(KXMLExecutionResultTag,     "<ExecutionResultCode>");

_LIT(KXMLExecutionResultTagEnd,  "</ExecutionResultCode>");

_LIT(KXMLFailedTag,              "<Failed>");

_LIT(KXMLFailedTagEnd,           "</Failed>");

_LIT(KXMLFileNameTag,            "<FileName>");

_LIT(KXMLFileNameTagEnd,         "</FileName>");

_LIT(KXMLHardwareInfoTag,        "<HardwareInfo>");

_LIT(KXMLHardwareInfoTagEnd,     "</HardwareInfo>");

_LIT(KXMLHwRevisionTag,          "<HwRevision>");

_LIT(KXMLHwRevisionTagEnd,       "</HwRevision>");

_LIT(KXMLLanguageTag,            "<Language>");

_LIT(KXMLLanguageTagEnd,         "</Language>");

_LIT(KXMLMachineUidTag,          "<MachineUID>");

_LIT(KXMLMachineUidTagEnd,       "</MachineUID>");

_LIT(KXMLManufacturerTag,        "<Manufacturer>");

_LIT(KXMLManufacturerTagEnd,     "</Manufacturer>");

_LIT(KXMLMemoryInfoTag,          "<MemoryInfo>");

_LIT(KXMLMemoryInfoTagEnd,       "</MemoryInfo>");

_LIT(KXMLModelTag,               "<Model>");

_LIT(KXMLModelTagEnd,            "</Model>");

_LIT(KXMLModuleNameTag,          "<ModuleName>");

_LIT(KXMLModuleNameTagEnd,       "</ModuleName>");

_LIT(KXMLModuleSummaryTag,       "<Modules>");

_LIT(KXMLModuleSummaryTagEnd,    "</Modules>");

_LIT(KXMLModuleTag,              "<Module>");

_LIT(KXMLModuleTagEnd,           "</Module>");

_LIT(KXMLPassedTag,              "<Passed>");

_LIT(KXMLPassedTagEnd,           "</Passed>");

_LIT(KXMLRamFreeTag,             "<RAMFree>");

_LIT(KXMLRamFreeTagEnd,          "</RAMFree>");

_LIT(KXMLRamTag,                 "<RAM>");

_LIT(KXMLRamTagEnd,              "</RAM>");

_LIT(KXMLResultDescrTag,         "<ResultDescription>");

_LIT(KXMLResultDescrTagEnd,      "</ResultDescription>");

_LIT(KXMLResultTag,              "<Result>");

_LIT(KXMLResultTagEnd,           "</Result>");

_LIT(KXMLSoftwareInfoTag,        "<SoftwareInfo>");

_LIT(KXMLSoftwareInfoTagEnd,     "</SoftwareInfo>");

_LIT(KXMLStartTimeTag,           "<StartTime>");

_LIT(KXMLStartTimeTagEnd,        "</StartTime>");

_LIT(KXMLSwBuildTag,             "<SwBuild>");

_LIT(KXMLSwBuildTagEnd,          "</SwBuild>");

_LIT(KXMLSwRevisionTag,          "<SwRevision>");

_LIT(KXMLSwRevisionTagEnd,       "</SwRevision>");

_LIT(KXMLTestCasesSummaryTag,    "<TestCasesSummary>");

_LIT(KXMLTestCasesSummaryTagEnd, "</TestCasesSummary>");

_LIT(KXMLTestCasesTag,           "<TestCases>");

_LIT(KXMLTestCasesTagEnd,        "</TestCases>");

_LIT(KXMLTestCaseTag,            "<TestCase>");

_LIT(KXMLTestCaseTagEnd,         "</TestCase>");

_LIT(KXMLTestReportTag,          "<TestReport>");

_LIT(KXMLTestReportTagEnd,       "</TestReport>");

_LIT(KXMLTestResultTag,          "<ResultCode>");

_LIT(KXMLTestResultTagEnd,       "</ResultCode>");

_LIT(KXMLTimeoutedTag,           "<Timeout>");

_LIT(KXMLTimeoutedTagEnd,        "</Timeout>");

_LIT(KXMLTimeTag,                "<Time>");

_LIT(KXMLTimeTagEnd,             "</Time>");

_LIT(KXMLTotalTag,               "<Total>");

_LIT(KXMLTotalTagEnd,            "</Total>");

_LIT(KXMLVersionTag,             "<Version>");

_LIT(KXMLVersionTagEnd,          "</Version>");

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

// ==================== LOCAL FUNCTIONS =======================================

// None

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

/*

-------------------------------------------------------------------------------

    Class: CTestReport

    Method: CTestReport

    Description: Default constructor

    C++ default constructor can NOT contain any code, that

    might leave.

    Parameters: const TTestReportMode aReportMode: in: Report mode

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

CTestReport::CTestReport( const TTestReportMode aReportMode ):

    iReportMode( aReportMode ) 

    {

    iXML = EFalse;

    iReportHWInfo = TTestHWInfo();

    }

/*

-------------------------------------------------------------------------------

    Class: CTestReport

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Parameters: CTestReportSettings& aTestReportSettings: in: Report settings

    Return Values: None

    Errors/Exceptions: Leaves if memory allocation for iTotalSummary fails

    Status: Approved

-------------------------------------------------------------------------------

*/

void CTestReport::ConstructL( TTestReportSettings& aTestReportSettings )

    {

    // Create summary for all test cases

    _LIT( KName, "All test cases" );

    iTotalSummary = new ( ELeave ) TTestSummary( KName() );

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

    TPtrC path;

    path.Set( aTestReportSettings.iPath->Des() );

    TPtrC name;

    name.Set( aTestReportSettings.iName->Des() );

    iFormat = aTestReportSettings.iFormat;

    iOutput = aTestReportSettings.iOutput;

    iXML = aTestReportSettings.iXML;

    // XML format can be used only when report is of txt file type.

    if(iFormat != CStifLogger::ETxt && iOutput != CStifLogger::EFile && iXML)

        {

        RDebug::Print(_L("Stif: XML report is available only when TestReportFormat is TXT and TestReportOutput is FILE"));

        iXML = EFalse;

        }

    if( iOutput == CStifLogger::EFile )

        {

        iFs.MkDirAll( path );

        HBufC* pathAndFileBuf = HBufC::NewLC( path.Length() + name.Length() + 5 );

        TPtr pathAndFile(pathAndFileBuf->Des() );

        pathAndFile.Append( path );

        pathAndFile.Append( name );

        if(iXML)

            {

            pathAndFile.Append( _L(".xml") );

            }

        else

            {

            if( ( iFormat == CStifLogger::EHtml ) && 

                ( iOutput == CStifLogger::EFile ) )

                {

                pathAndFile.Append( _L(".html") );

                }

            else 

                {

                pathAndFile.Append( _L(".txt") );

                }

            }

        if( aTestReportSettings.iOverwrite )

            {

            User::LeaveIfError( iFile.Replace( iFs, 

                           pathAndFile,

                           EFileWrite | EFileStreamText | EFileShareAny ) );

            }

        else

            {

            TBool isOpen( EFalse );

            TInt fileOpen = iFs.IsFileOpen( pathAndFile, isOpen );

            if( fileOpen == KErrNotFound )

                {

                User::LeaveIfError( 

                    iFile.Create( iFs, 

                                  pathAndFile, 

                                  EFileWrite | EFileStreamText | EFileShareAny ) );

                }

            else if( fileOpen == KErrNone )

                {

                User::LeaveIfError( 

                    iFile.Open( iFs, 

                                pathAndFile, 

                                EFileWrite | EFileStreamText | EFileShareAny ) );

                TInt endPosOfFile = 0;

                User::LeaveIfError( iFile.Seek( ESeekEnd, endPosOfFile ) );

                }

            else

                {

                User::Leave( fileOpen );

                }

            }

        CleanupStack::PopAndDestroy( pathAndFileBuf );

        }

    WriteHeaderL();

    // Add temporarily closing tags to keep valid xml structure

    CloseXMLTagsInUnfinishedFileL();

    }

/*

-------------------------------------------------------------------------------

    Class: CTestReport

    Method: NewL

    Description: Two-phased constructor.

    Parameters: CTestReportSettings& aTestReportSettings: in: Report settings

                const TTestReportMode aReportMode: in: Report mode

    Return Values: CTestReport* : pointer to created object

    Errors/Exceptions: Leaves if memory allocation for object fails

                       Leaves if ConstructL leaves

    Status: Approved

-------------------------------------------------------------------------------

*/

CTestReport* CTestReport::NewL( TTestReportSettings& aTestReportSettings,

                                const TTestReportMode aReportMode )

    {

    CTestReport* self = new ( ELeave ) CTestReport( aReportMode );

    CleanupStack::PushL( self );

    self->ConstructL( aTestReportSettings );

    CleanupStack::Pop( self );

    return self;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestReport

    Method: ~CTestReport

    Description: Destructor

    Parameters: None

    Return Values: None

    Errors/Exceptions: None

    Status: Approved

-------------------------------------------------------------------------------

*/

CTestReport::~CTestReport()

    {

    // Reset and destroy arrays

    iTestSummaries.ResetAndDestroy();

    delete iTotalSummary;

    if( iOutput != CStifLogger::ERDebug )

        {

        // Delete file

        iFile.Close();

        iFs.Close();

        }

    }

/*

-------------------------------------------------------------------------------

    Class: CTestReport

    Method: AddTestCaseResultL

    Description: Add new test case result.

    Parameters: const TTestInfo& aTestInfo: in: TTestInfo: Test info

                const TFullTestResult& aTestResult: in: TTestResult: Testresult

                const TInt aError: in: Symbian OS error: Additional error code

    Return Values: None

    Errors/Exceptions: Leave is iReportGenerated is generated

                       Leave if summary creation fails

                       Leave if summary adding fails

    Status: Approved

-------------------------------------------------------------------------------

*/

void CTestReport::AddTestCaseResultL( const TTestInfo& aTestInfo,

                                        const TFullTestResult& aTestResult,

                                        const TInt aError )

    {

    // Create summary for this test case

    TTestCaseSummary summary;

    summary.iTestInfo = aTestInfo;

    summary.iFullTestResult = aTestResult;

    TBool passed( EFalse );

    TBool crashed( EFalse );

    TBool timeout( EFalse );

    if( ( aError == KErrNone ) && 

         ( summary.iFullTestResult.iCaseExecutionResultType == TFullTestResult::ECaseExecuted ) &&

         ( KErrNone == summary.iFullTestResult.iTestResult.iResult ) )

        {

        passed = ETrue;

        }

    else if( summary.iFullTestResult.iCaseExecutionResultType == TFullTestResult::ECaseTimeout )

        {

        timeout = ETrue;

        }

    else if( ( summary.iFullTestResult.iCaseExecutionResultCode != KErrNone )

    		|| ( summary.iFullTestResult.iCaseExecutionResultType == TFullTestResult::ECasePanic )

    		|| ( summary.iFullTestResult.iCaseExecutionResultType == TFullTestResult::ECaseException ) )

        {

        crashed = ETrue;

        }

    if ( iReportMode & ETestReportCases )

        {

        // Print summary to file

        if(iXML)

            {

            WriteLineL(_L("%S"), &KXMLTestCaseTag);

            WriteLineL(_L("%S%S%S"), &KXMLModuleNameTag, &summary.iTestInfo.iModuleName, &KXMLModuleNameTagEnd);

            if(summary.iTestInfo.iConfig != KNullDesC)

                {

                WriteLineL(_L("%S%S%S"), &KXMLConfigFileTag, &summary.iTestInfo.iConfig, &KXMLConfigFileTagEnd);

                }

            WriteLineL(_L("%S%d%S"), &KXMLCaseNumberTag, summary.iTestInfo.iTestCaseInfo.iCaseNumber, &KXMLCaseNumberTagEnd);

            WriteLineL(_L("%S%S%S"), &KXMLCaseTitleTag, &summary.iTestInfo.iTestCaseInfo.iTitle, &KXMLCaseTitleTagEnd);

            }

        else

            {

            WriteLineL( _L("[%S][%S][%d] Title:[%S]"),

                &summary.iTestInfo.iModuleName,

                &summary.iTestInfo.iConfig,

                summary.iTestInfo.iTestCaseInfo.iCaseNumber,

                &summary.iTestInfo.iTestCaseInfo.iTitle );

            }

        const TInt KTimeFieldLength = 30;

        TBuf<KTimeFieldLength> startTime;

        TBuf<KTimeFieldLength> endTime;

        _LIT(KDateString4,"%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B");

        summary.iFullTestResult.iStartTime.FormatL(

            startTime,KDateString4 );

        summary.iFullTestResult.iEndTime.FormatL(

            endTime,KDateString4 );

        // Result description needs max length 0x80(Must be same as

        // TResultDes length) + specific characters see below.

        TBuf<KMaxReportData> printBuf2;

        TInt code = CStifLogger::ENoStyle;

        if( ( summary.iFullTestResult.iCaseExecutionResultType 

        	!= TFullTestResult::ECasePanic ) &&

        	( summary.iFullTestResult.iCaseExecutionResultCode 

            == KErrNone ) )

            {

            printBuf2.AppendFormat( _L("\tResult: %d [%S]"),

                summary.iFullTestResult.iTestResult.iResult,

                &summary.iFullTestResult.iTestResult.iResultDes );

            if ( KErrNone == 

                 summary.iFullTestResult.iTestResult.iResult )

                {

                printBuf2.AppendFormat( _L(" ==> PASSED"));

                }

            else

                {

                code = CStifLogger::ERed;

                printBuf2.AppendFormat( _L(" ==> FAILED"));

                }

            }

        else

            {

            code = CStifLogger::ERed;

            printBuf2.AppendFormat( _L("\tCaseExecutionResult: %S with %d"),

                &summary.iFullTestResult.iTestResult.iResultDes,

                summary.iFullTestResult.iCaseExecutionResultCode );

            }

        if(iXML)

            {

            WriteLineL(_L("%S%S%S"), &KXMLStartTimeTag, &startTime, &KXMLStartTimeTagEnd);

            WriteLineL(_L("%S%S%S"), &KXMLEndTimeTag, &endTime, &KXMLEndTimeTagEnd);

            WriteLineL(_L("%S%d%S"), &KXMLTestResultTag, summary.iFullTestResult.iTestResult.iResult, &KXMLTestResultTagEnd);

            WriteLineL(_L("%S%S%S"), &KXMLResultDescrTag, &summary.iFullTestResult.iTestResult.iResultDes, &KXMLResultDescrTagEnd);

            WriteLineL(_L("%S%d%S"), &KXMLExecutionResultTag, summary.iFullTestResult.iCaseExecutionResultCode, &KXMLExecutionResultTagEnd);

            }

        else

            {

            WriteLineL( _L("\tStartTime: %S, EndTime: %S"),

                &startTime,

                &endTime );

            WriteLineL( printBuf2, code );

            WriteDelimiterL( _L( "- " ), 10 );

            WriteLineL( _L( "" ) );

            }

        }

    // Add test summary

    // Check if the module already exists for this test case

    TTestSummary* moduleSummary = NULL;

    TInt count = iTestSummaries.Count();

    for( TInt i = 0; i < count; i++ )

        {

        if ( iTestSummaries[i]->iName == aTestInfo.iModuleName )

            {

            moduleSummary = iTestSummaries[i];

            break;

            }

        }

    if( moduleSummary == NULL )

        {

        // Create new module array

        moduleSummary = new ( ELeave ) TTestSummary( aTestInfo.iModuleName );

        User::LeaveIfError( iTestSummaries.Append( moduleSummary ) );

        }

    if( passed )

        {

        moduleSummary->iPassedCases++;

        iTotalSummary->iPassedCases++;

        if(iXML && (iReportMode & ETestReportCases))

            {

            WriteLineL(_L("%SPASSED%S"), &KXMLResultTag, &KXMLResultTagEnd);

            }

        }

    else if( timeout )

        {

        moduleSummary->iTimeoutCases++;

        iTotalSummary->iTimeoutCases++;

        if(iXML && (iReportMode & ETestReportCases))

            {

            WriteLineL(_L("%STIMEOUT%S"), &KXMLResultTag, &KXMLResultTagEnd);

            }

        }

    else if( crashed ||

           ( aError != KErrNone ) )