/*
* Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 "t_testhandler.h"
#include "ttesthandlersettings.h"
#include "t_output.h"
#include "t_testaction.h"
#include "t_testsetup.h"
#include "tTestSpec.h"
#include "t_testrunner.h"


TTestSummary::TTestSummary() :
	iTestsRun(0), iTestsFailed(0)
	{
	}

void TTestSummary::PrintL(Output& aOut)
	{
	aOut.write(_L("%d tests failed out of %d\n"), iTestsFailed, iTestsRun);
	}

TBool TTestSummary::AllTestsPassed()
	{
	return iTestsRun > 0 && iTestsFailed == 0;
	}

EXPORT_C CTestHandler* CTestHandler::NewLC(RFs& aFs,
										   MTestSpec& aTestSpec,
										   CTestHandlerSettings& aSettings,
										   CConsoleBase* aConsole,
										   Output* aOut)
	{
	CTestHandler* self = new(ELeave) CTestHandler(aFs, aTestSpec, aConsole, aOut);
	CleanupStack::PushL(self);
	self->ConstructL(aSettings);
	return self;
	}

CTestHandler::~CTestHandler()
	{
	delete iSettings;
	delete iScheduler;
	delete iSharedData;
    delete iTestRunner;
    delete iNextTestRunner;

	iFailedTests.Reset();
	iFailedTestNames.ResetAndDestroy();
	iKnownDefects.ResetAndDestroy();
	}

CTestHandler::CTestHandler(RFs& aFs,
						   MTestSpec& aTestSpec,
						   CConsoleBase* aConsole,
						   Output* aOut) :
	iFs(aFs), iConsole(aConsole), iOut(aOut), iTestSpec(aTestSpec)
	{
	}

void CTestHandler::ConstructL(CTestHandlerSettings& aSettings) 
	{
	iSettings = CTestHandlerSettings::NewL(aSettings);
	iScheduler = new(ELeave) CActiveScheduler;
	CActiveScheduler::Install(iScheduler);

	// Set up test handler based on command line argument
	if (aSettings.iOOM)
		{
		SetTestRunnerL(new (ELeave) COOMTestRunner(*iOut));
		}
	else if (aSettings.iCancel)
		{
		SetTestRunnerL(new (ELeave) CCancelTestRunner(*iOut));
		}
	else
		{		
		SetTestRunnerL(NULL);
		}
	}

TTestSummary CTestHandler::Summary()
	{
	TTestSummary result;
	result.iTestsRun = iActionCount;
	result.iTestsFailed = iFailedTests.Count();
	return result;
	}

EXPORT_C void CTestHandler::RunTestsL()
	{
	iActionNumber = 0;
    CTestAction* action;
    while(iTestSpec.GetNextTest(action))
        {
        iActionCount++;
        iActionNumber++;
        
        TRAPD(err, RunTestL(action));
        if (err != KErrNone)
            {
            FailTestL(action, EFailInTestHandler, err);
            }
        }
	DisplaySummary();
	}

void CTestHandler::RunTestL(CTestAction* aAction)
    {
    // If the last test set a new test runner, install it here
    if (iNextTestRunner)
        {
        delete iTestRunner;
        iTestRunner = iNextTestRunner;
		iNextTestRunner = NULL;
        }

    iOut->writeString(_L("Test "));
    iOut->writeNum(iActionNumber);
    iOut->writeNewLine();

	if (iActionNumber > 1)
		{
		iConsole->Printf(_L(", "));
		}
	iConsole->Printf(_L("%d: "), iActionNumber);

    aAction->ReportAction();
    aAction->SetTestHandler(*this); 

    TInt preErr = iTestRunner->PerformPrerequisiteL(aAction);
    if ((preErr != KErrNone) && !aAction->iResult)
        {
        FailTestL(aAction, EFailInPrerequisite, preErr);
        return;
        }
	TInt actionErr = 0;
	if (preErr == KErrNone)
		{
		actionErr = iTestRunner->PerformActionL(aAction);
		}
    TInt postErr = iTestRunner->PerformPostrequisiteL(aAction, actionErr);
	// investiage if passing actionErr would make more sense here
    aAction->CheckResult(postErr);    
    if (!aAction->iResult)
        {
        FailTestL(aAction, EFailInAction, actionErr);
        return;
        }

	iConsole->Printf(_L("passed"));
    }

const TDesC& CTestHandler::GetFailLocationName(TTestFailLocation aLoc)
    {
    _LIT(KTestHandler, "test handler");
    _LIT(KPrerequisite, "prerequisite");
    _LIT(KTestAction, "test action");

    const TDesC* result = NULL;

    switch (aLoc)
        {
        case EFailInTestHandler:
            result = &KTestHandler;
            break;
        case EFailInPrerequisite:
            result = &KPrerequisite;
            break;
        case EFailInAction:
            result = &KTestAction;
            break;
        }
    
    ASSERT(result);
    return *result;
    }

void CTestHandler::FailTestL(CTestAction* aAction, TTestFailLocation aLoc, TInt aErr)
    {
    iOut->writeString(_L("Test failed in "));
    iOut->writeString(GetFailLocationName(aLoc));
    iOut->writeString(_L(": "));
    iOut->writeNum(aErr);
    iOut->writeNewLine();
    
	iConsole->Printf(_L("failed"));

	AppendFailedTestL(iActionNumber, *aAction->iNameInfo);
    if(aAction->ScriptError() == CTestAction::EFileNotFound)
        {
        TBuf<KMaxErrorSize> scriptError;
        aAction->ScriptError(scriptError);
        iOut->writeString(_L("File Not Found \""));
        iOut->writeString(scriptError);
        iOut->writeString(_L("\" in test "));
        iOut->writeNum(iActionNumber);
        iOut->writeNewLine();
        }

    if (aAction->iKnownFailure)
        {//	Expecting a failure because of known defect - record details
        HBufC* name=HBufC::NewLC(aAction->iNameInfo->Length());
        name->Des().Copy(*(aAction->iNameInfo));
        User::LeaveIfError(iKnownDefects.Append(name));
        CleanupStack::Pop(name);
        }
    }

void CTestHandler::AppendFailedTestL(TInt aIndex, const TDesC8& aName)
	{
	iFailedTests.Append(aIndex);
    HBufC* name=HBufC::NewLC(aName.Length());
    name->Des().Copy(aName);
	User::LeaveIfError(iFailedTestNames.Append(name));
    CleanupStack::Pop(name);
	}
	
void CTestHandler::DisplaySummary()
	{
	//Display the RTest information
	iConsole->Printf(_L("\n"));

//	Log the details of tests that failed because of known (deferred) defects
	TInt theFailCount = iKnownDefects.Count();
	if (theFailCount > 0)
	{
		iOut->writeNewLine();
		iOut->writeString(_L("----------------------------------------------------------------------------------"));
		iOut->writeNewLine();
		iOut->writeString(_L("These tests may not pass because of known defects details of which are given below:"));
		iOut->writeNewLine();
		iOut->writeNewLine();
		
		TInt index = 0;
		for (; index<theFailCount; index++)
		{
			iOut->writeString(*iKnownDefects[index]);
			iOut->writeNewLine();
		}
		iOut->writeString(_L("----------------------------------------------------------------------------------"));
		iOut->writeNewLine();
		iOut->writeNewLine();
	}

	// Display the failed tests
	TInt iEnd = iFailedTests.Count();
	if (iEnd!=0)
		{
		iOut->writeString(_L(" Failed tests:-"));
		iOut->writeNewLine();
		for (TInt i = 0; i < iEnd; i++)
			{
			iOut->writeNum(iFailedTests[i]);
			iOut->writeSpaces(2);
			iOut->writeString(*iFailedTestNames[i]);
			iOut->writeNewLine();
			}
		iOut->writeNewLine();
		}
	 
	// Summary line is now printed in CTestSetup
	}

CBase* CTestHandler::SharedData() const
	{
	return iSharedData;
	}

void CTestHandler::SetSharedData(CBase* aData)
	{
	iSharedData = aData;
	}

EXPORT_C void CTestHandler::SetTestRunnerL(CTestRunner *aTestRunner)
    {
    /* We can't set iTestRunner directly, as we may be called while we're inside
     * one of its methods. */

	// This method can be called twice in a row, eg if the -o option is used
	if (iNextTestRunner)
		{
		delete iNextTestRunner;
		iNextTestRunner = NULL;
		}
	
    iNextTestRunner = aTestRunner ? aTestRunner : new (ELeave) CTestRunner(*iOut);
    }

void CTestHandler::SetHeapMark(TInt aAllocCount)
    {
    iHeapMark = aAllocCount;
    }

TInt CTestHandler::HeapMark()
    {
    return iHeapMark;
    }