// 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();
		}
	delete server;
	delete sched;
	}

/**
  @return Standard Epoc error code on process exit
  Process entry point. Called by client using RProcess API
  */
TInt E32Main()
	{
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if(!cleanup)
		{
		return KErrNoMemory;
		}
	TRAPD(err,MainL());

	if (err)
		{
		RDebug::Print(_L("CEglEndpointTestServer::MainL - Error: %d"), err);
	   	User::Panic(KEglEndpointTestServerName, err);
		}

	delete cleanup;
	REComSession::FinalClose();
	__UHEAP_MARKEND;
	return KErrNone;
    }