// Copyright (c) 2007-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:

//

/** @file

    @internalComponent - Internal Symbian test code */

#include <e32base.h>

#include <e32debug.h>

#include <e32msgqueue.h>

#include <ecom/ecom.h>

#include <test/testexecuteserverbase.h>

#include <e32math.h>

#include "localtestbase.h"

#include "egltest_commscommon.h"

#include "egltest_endpoint_util.h"

_LIT(KEglEndpointTestServerName,"eglendpointtestserver");

CLocalTestStepBase::CLocalTestStepBase(enum TTestUid aUid) :

    iTestId(aUid),

    iIsInTestStep(EFalse)

    {

    }

void CLocalTestStepBase::DoPreambleL()

    {

    //null implmentation for base class

    }

void CLocalTestStepBase::DoPostambleL()

    {

    //null implmentation for base class

    }

//function used for creating the queues.

TVerdict CLocalTestStepBase::doTestStepPreambleL()

    {

    //Open the queues.

    User::LeaveIfError(iResultOutQueue.OpenGlobal(KResultQueueName));

    User::LeaveIfError(iParamsInQueue.OpenGlobal(KParamsQueueName));

    SetTestStepResult(EPass);

    iHasCurrentTestIds = EFalse;

    iResultLog = CTestIdResultLogger::NewL(Logger());

    DoPreambleL();

    return EPass;

    }

TVerdict CLocalTestStepBase::doTestStepPostambleL()

    {

    //Log the result of the current tests.

    if(iHasCurrentTestIds)

        {

        iResultLog->LogResult(iTestIdVerdict);

        }

    DoPostambleL();

    delete iResultLog;

    iResultLog = NULL;

    iResultOutQueue.Close();

    iParamsInQueue.Close();

    return EPass;

    }

CLocalTestStepBase::~CLocalTestStepBase()

    {

    //closing an already closed handle is harmless

    iResultOutQueue.Close();

    iParamsInQueue.Close();

    }

TVerdict CLocalTestStepBase::StartRemoteTestStep(const TRemoteTestParams& aMessageIn)

    {

    //Starting the remote test step is implemented as a special case

    //of running a test case, with TestCase = KStartTestStepCaseNumber.

    iIsInTestStep = ETrue;

    TVerdict retVal = RunRemoteTestCase(KStartTestStepCaseNumber, aMessageIn);

    if(retVal != EPass)

        {

        iIsInTestStep = EFalse;

        }

    return retVal;

    }

TVerdict CLocalTestStepBase::EndRemoteTestStep(const TRemoteTestParams& aMessageIn)

    {

    //Ending the remote test step is implemented as a special case

    //of running a test case, with TestCase = KEndTestStepCaseNumber.

    TVerdict retVal = RunRemoteTestCase(KEndTestStepCaseNumber, aMessageIn);

    iIsInTestStep = EFalse;

    return retVal;

    }

TVerdict CLocalTestStepBase::RunRemoteTestCase(TInt aTestCase, const TRemoteTestParams& aMessageIn)

    {

    //Don't attempt to run any test cases if we are not in a test step.

    if(!iIsInTestStep)

        {

        SetTestStepResult(EFail);

        return TestStepResult();

        }

    //send the message

    TRemoteTestParamsPacket message(iTestId, aTestCase, aMessageIn);

    iParamsInQueue.SendBlocking(message);

    TRemoteTestResult result;

    do

        {

        //relying on TEF timeout if there are problems such as the render stage not loaded.

        iResultOutQueue.ReceiveBlocking(result);

        //if uid and test case doesn't match something has gone badly wrong

        if (result.iUid != iTestId || result.iTestCase != aTestCase)

            {

            //test is out of Sync

            User::Panic(_L("Test out of sync with render stage"), KErrGeneral);

            }

        //log the message if there is one

        if (!result.iFinished)

            {

            //Convert the filename to a C string. The remote test env guarantees

            //that there is a free space at the end of the descriptor to add NULL.

            const TText8* file = result.iFile.PtrZ();

            //Convert the message to unicode and log the message.

            TBuf<KRSLogMessageLength> message;

            message.Copy(result.iMessage);

            Logger().LogExtra(file, result.iLine, result.iSeverity, _L("%S"), &message);

            }

        }while (!result.iFinished);

    //Translate the RemoteTestStep verdict to a TVerdict.

    TVerdict retVal = EPass;

    switch (result.iVerdict)

        {

        case ERtvPass:

            retVal = EPass;

            break;

        case ERtvFail:

            retVal = EFail;

            break;

        case ERtvInconclusive:

            retVal = EInconclusive;

            break;

        case ERtvAbort:

            retVal = EAbort;

            break;

        case ERtvPanic:

            //The remote test paniced, so we panic too.

            //This means the output log relects what actually happened.

            User::Panic(_L("Remote Test Step Paniced!"), KErrGeneral);

            break;

        case ERtvTimeout:

            //The remote test timedout, so we sleep so that tef times us out too.

            //This means the output log relects what actually happened.

            User::After(KMaxTInt);

            break;

        case ERtvUnknownTestUid:

            retVal = EIgnore;

            break;

        default:

            User::Panic(_L("Invalid verdict returned from the remote test step!"), KErrGeneral);

            break;

        }

    if(retVal != EPass)

        {

        SetTestStepResult(retVal);

        }

    return retVal;

    }

void CLocalTestStepBase::RegisterTestIdsL(const TDesC& aTestString)

    {

    iResultLog->RegisterTestIdsL(aTestString);

    }

void CLocalTestStepBase::SetCurrentTestIds(const TDesC& aTestString)

    {

    if(iHasCurrentTestIds)

        {

        iResultLog->LogResult(iTestIdVerdict);

        }

    iResultLog->SetCurrentTestIds(aTestString);

    iHasCurrentTestIds = ETrue;

    iTestIdVerdict = EPass;

    }

void CLocalTestStepBase::SetTestStepResult(TVerdict aVerdict)

    {

    iTestIdVerdict = aVerdict;

    CTestStep::SetTestStepResult(aVerdict);

    }

//Used by the result logger to delimit the csv test id strings.

class TCommaDelimiter

    {

private:

    mutable TPtrC iRemaining;

public:

    TCommaDelimiter(const TDesC& aString)

        {

        //Set our remaining string to the whole string, or NULL if empty.

        if(aString.Length() == 0)

            {

            iRemaining.Set(NULL, 0);

            }

        else

            {

            iRemaining.Set(aString);

            }

        }

    TInt GetNext(TPtrC& aSegment) const

        {

        //Trim off any leading commas.

        while(iRemaining.Length() >= 2 && iRemaining[0] == ',')

            {

            iRemaining.Set(&iRemaining[1], iRemaining.Length() - 1);

            }

        //If remaining string is empty or has one remaining comma, return.

        if(iRemaining.Length() == 0 || iRemaining[0] == ',')

            {

            iRemaining.Set(NULL, 0);

            return KErrNotFound;

            }

        //Find the first comma.

        TInt pos = iRemaining.Locate(',');

        //If comma not found, return all remaining string.

        if(pos == KErrNotFound)

            {

            aSegment.Set(iRemaining);

            iRemaining.Set(NULL, 0);

            return KErrNone;

            }

        //Comma found. There must be non-comma chars between 0 

        //and pos since we trimmed leading commas previously.

        aSegment.Set(&iRemaining[0], pos);

        iRemaining.Set(&iRemaining[pos], iRemaining.Length() - pos);

        return KErrNone;

        }

    TInt GetNextTrimmed(TPtrC& aSegment) const

        {

        //Keep calling GetNext() until we get a segment that has 

        //chars other than spaces or there are no more segments.

        while(1)

            {

            TPtrC segment;

            TInt err = GetNext(segment);

            if(err != KErrNone)

                {

                return err;

                }

            TInt front;

            TInt back;

            for(front = 0; front < segment.Length() && segment[front] == ' '; front++) {}

            for(back = segment.Length() - 1; back >= 0 && segment[back] == ' '; back--) {}

            TInt length = (back + 1) - front;

            if(length > 0 && segment[front] != ' ' && segment[back] != ' ')

                {

                aSegment.Set(&segment[front], length);

                return KErrNone;

                }

            }

        }

    };

CTestIdResultLogger* CTestIdResultLogger::NewL(CTestExecuteLogger& aLogger)

    {

    CTestIdResultLogger* self = new (ELeave) CTestIdResultLogger(aLogger);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CTestIdResultLogger::CTestIdResultLogger(CTestExecuteLogger& aLogger) :

    iOriginalThread(RThread().Id()),

    iLogger(aLogger)

    {

    }

void CTestIdResultLogger::ConstructL()

    {

    //Create panic monitor thread. Note that we share the heap with this 

    //thread so that the arrays remain in scope if this thread panics.

    //Note also no need for explicit locking of arrays since the panic 

    //monitor will only access them if a panic occurs here.

    static const TInt KStackSize =   0x2000;      //  8KB

    TUint32 random = Math::Random();

    TName threadName;

    _LIT(KThreadNameFormat, "%S-%u");

    _LIT(KEnvName, "EpTestIdLogger");

    threadName.Format(KThreadNameFormat, &KEnvName, random);

    User::LeaveIfError(iPanicMonitor.Create(threadName, PanicMonitorMain, KStackSize, &User::Heap(), this, EOwnerThread));

    //Rendezvous with panic thread.

    TRequestStatus rendStat;

    iPanicMonitor.Rendezvous(rendStat);

    iPanicMonitor.Resume();

    User::WaitForRequest(rendStat);

    }

CTestIdResultLogger::~CTestIdResultLogger()

    {

    TRequestStatus logonStat;

    iPanicMonitor.Logon(logonStat);

    iPanicMonitor.RequestComplete(iCloseMonitor, KErrNone);

    User::WaitForRequest(logonStat);

    iPanicMonitor.Close();

    iRegisteredTestIds.Close();

    iCurrentTestIds.Close();

    }

void CTestIdResultLogger::RegisterTestIdsL(const TDesC& aTestString)

    {

    //Set up delimitter.

    TCommaDelimiter delimit(aTestString);

    //Get every test id from the string and add it to the registered test ids array.

    TPtrC testIdPtr;

    while(delimit.GetNextTrimmed(testIdPtr) == KErrNone)

        {

        TTestId testId(testIdPtr);

        iRegisteredTestIds.AppendL(testId);

        }

    //Reserve enough space in the current test ids array so that SCurrentTestIds() can not fail.

    iCurrentTestIds.ReserveL(iRegisteredTestIds.Count());

    }

void CTestIdResultLogger::SetCurrentTestIds(const TDesC& aTestString)

    {

    ASSERT(iCurrentTestIds.Count() == 0);

    //Set up delimitter.

    TCommaDelimiter delimit(aTestString);

    //Get every test id from the string and add it to the registered test ids array.

    TPtrC testIdPtr;

    while(delimit.GetNextTrimmed(testIdPtr) == KErrNone)

        {

        TTestId testId(testIdPtr);

		//This cannot fail under legitimate circumstances, since enough 

		//space is reserved in this array when registering TestIds.

        TInt err = iCurrentTestIds.Append(testId);

		ASSERT(err == KErrNone);

        }

    //Make sure these tests were registered and remove from the registered array.

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

        {

        TInt idx = iRegisteredTestIds.Find(iCurrentTestIds[i]);

        ASSERT(idx != KErrNotFound);

        iRegisteredTestIds.Remove(idx);

        }

    }

void CTestIdResultLogger::LogResult(TVerdict aVerdict)

    {

    const TInt KMaxVerdictLength = 20;

    TBuf<KMaxVerdictLength> verdict;

    switch(aVerdict)

        {

        case EPass:           verdict.Append(_L("PASS"));            break;

        case EFail:           verdict.Append(_L("FAIL"));            break;

        case EInconclusive:   verdict.Append(_L("INCONCLUSIVE"));    break;

        case ETestSuiteError: verdict.Append(_L("TEST SUTE ERROR")); break;

        case EAbort:          verdict.Append(_L("ABORT"));           break;

        case EIgnore:         verdict.Append(_L("IGNORE"));          break;

        }

    while(iCurrentTestIds.Count())

        {

        LogResult(iLogger, iCurrentTestIds[0], verdict);

        iCurrentTestIds.Remove(0);

        }

    }

void CTestIdResultLogger::LogResult(CTestExecuteLogger& aLogger, const TTestId& aTestId, const TDesC& aVerdict)

    {

    aLogger.LogExtra(((TText8*)"EGL ENDPOINT TEST RESULT >>>"), 0, ESevrInfo, _L("GRAPHICS-EGL-%S: %S"), &aTestId, &aVerdict);

    }

TInt CTestIdResultLogger::PanicMonitorMain(TAny* aSelf)

    {

    CTestIdResultLogger* self = static_cast<CTestIdResultLogger*>(aSelf);

    //Create cleanup stack.

    CTrapCleanup* cleanup = CTrapCleanup::New();

    ASSERT(cleanup);

    //Create active scheduler.

    CActiveScheduler* scheduler = new CActiveScheduler();

    ASSERT(scheduler);

    CActiveScheduler::Install(scheduler);

    TRAPD(err,  self->PanicMonitorMainL());

    __ASSERT_ALWAYS(err == KErrNone, User::Invariant());

    delete scheduler;

    delete cleanup;

    return KErrNone;

    }

void CTestIdResultLogger::PanicMonitorMainL()

    {

    //Setup logging.

    CTestExecuteLogger logger;

    TEndpointUtil::SetLoggerForProcessWrapperL(logger);

    //Tell parent how to close us.

    TRequestStatus closeStatus = KRequestPending;

    iCloseMonitor = &closeStatus;

    //Open parent thread and logon.

    RThread origThread;

    User::LeaveIfError(origThread.Open(iOriginalThread, EOwnerThread));

    TRequestStatus origStatus;

    origThread.Logon(origStatus);

    //Rendevous with our parent then wait for thread to exit or close command.

    RThread().Rendezvous(KErrNone);

    User::WaitForRequest(closeStatus, origStatus);

    if (closeStatus != KRequestPending)

        {

        //Parent is shutting us down. Just cancel our outstanding request and exit.

        origThread.LogonCancel(origStatus);

        User::WaitForRequest(origStatus);

        }

    else if (origStatus != KRequestPending)

        {

        //We can only get here if parent panicked.

        //Log that all current tests were panicked and all registered tests were not run.

        _LIT(KPanicked, "PANIC");

        _LIT(KNotRun, "NOT RUN DUE TO PREVIOUS PANIC");

        while(iCurrentTestIds.Count())

            {

            LogResult(logger, iCurrentTestIds[0], KPanicked);

            iCurrentTestIds.Remove(0);

            }

        while(iRegisteredTestIds.Count())

            {

            LogResult(logger, iRegisteredTestIds[0], KNotRun);

            iRegisteredTestIds.Remove(0);

            }

        }

    origThread.Close();

    }

CEglEndpointTestServer* CEglEndpointTestServer::NewL()

	{

	CEglEndpointTestServer* server = new(ELeave) CEglEndpointTestServer();

	CleanupStack::PushL(server);

	// CServer base class call

	TParsePtrC serverName(RProcess().FileName());

	server->StartL(serverName.Name());

	CleanupStack::Pop(server);

	return server;

	}

static void MainL()

	{

	CActiveScheduler* sched=NULL;

	sched=new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(sched);

	CEglEndpointTestServer* server = NULL;

	// Create the CTestServer derived server

	TRAPD(err, server = CEglEndpointTestServer::NewL());

	if(!err)

		{

		// Sync with the client and enter the active scheduler

		RProcess::Rendezvous(KErrNone);

		sched->Start();