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

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

/*

 * This file contains the parts of CRemoteTestEnv and CRemoteTestStepBase

 * that do not need editting when adding new tests.

 *

 * CRemoteTestEnv acts as the controller. It provides the means of communicating

 * with the local side and it instantiates remote test steps and executes them in

 * their own thread. It monitors this thread for panic / timeout. If this

 * happens, it informs the local side.

 */

#include "remotetestbase.h"

#include <e32debug.h>

#include <e32math.h>

// Default timout for remote test steps. This MUST be smaller

// than any timeout passed to TEF for the local test step

// in the script file. Remote test steps can override this 

// value by implementing the Timeout() function in their 

// derrived class.

const TInt KRemoteTestStepTimeout = 10 * 1000000;

//Active object used to generate a timeout if worker thread takes too long. ------

CTimeoutTimer* CTimeoutTimer::NewL(CRemoteTestEnv& aEnv, TInt aPriority)

    {

    CTimeoutTimer* obj = new (ELeave) CTimeoutTimer(aEnv, aPriority);

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

CTimeoutTimer::CTimeoutTimer(CRemoteTestEnv& aEnv, TInt aPriority) :

    CTimer(aPriority),

    iEnv(aEnv)

    {

    }

void CTimeoutTimer::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add(this);

    }

CTimeoutTimer::~CTimeoutTimer()

    {

    Cancel();

    }

void CTimeoutTimer::RunL()

    {

    ENDPOINT_ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Invariant());

    iEnv.TestCaseTimedOut();

    }

//--------------------------------------------------------------------------------

//Active object used to listen to the worker thread to see if it panics. ---------

CWorkerListener* CWorkerListener::NewL(CRemoteTestEnv& aEnv, TInt aPriority)

    {

    CWorkerListener* obj = new (ELeave) CWorkerListener(aEnv, aPriority);

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

CWorkerListener::CWorkerListener(CRemoteTestEnv& aEnv, TInt aPriority) :

    CActive(aPriority),

    iEnv(aEnv)

    {

    }

CWorkerListener::~CWorkerListener()

    {

    Cancel();

    }

void CWorkerListener::ConstructL()

    {

    CActiveScheduler::Add(this);

    }

void CWorkerListener::Listen(RThread& aThread)

    {

    ENDPOINT_ASSERT_DEBUG(!IsActive(), User::Invariant());

    iThread = &aThread;

    iThread->Logon(iStatus);

    SetActive();

    }

void CWorkerListener::RunL()

    {

    iEnv.WorkerExitted();

    }

void CWorkerListener::DoCancel()

    {

    iThread->LogonCancel(iStatus);

    }

//--------------------------------------------------------------------------------

//Active object used to listen for test case completion from the worker thread. --

CTestCaseListener* CTestCaseListener::NewL(CRemoteTestEnv& aEnv, TInt aPriority)

    {

    CTestCaseListener* obj = new (ELeave) CTestCaseListener(aEnv, aPriority);

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

CTestCaseListener::CTestCaseListener(CRemoteTestEnv& aEnv, TInt aPriority) :

    CActive(aPriority),

    iEnv(aEnv)

    {

    }

CTestCaseListener::~CTestCaseListener()

    {

    Cancel();

    }

void CTestCaseListener::ConstructL()

    {

    CActiveScheduler::Add(this);

    }

void CTestCaseListener::Listen()

    {

    ENDPOINT_ASSERT_DEBUG(!IsActive(), User::Invariant());

    iStatus = KRequestPending;

    SetActive();

    }

void CTestCaseListener::RunL()

    {

    ENDPOINT_ASSERT_DEBUG(iStatus.Int() == KErrNone, User::Invariant());

    iEnv.TestCaseCompleted();

    }

void CTestCaseListener::DoCancel()

    {

    //There is no way to actually cancel a test case,

    //But this AO will only be cancelled when the thread

    //has panicked or timed out - which is as good as a

    //cancel. We still need to call canel on the AO though

    //to set it as inactive.

    //Also need to do a request complete if the worker has not already

    //done it. There is no danger of the worker completing between our

    //check (the if) and actually completing because the worker is dead.

    if(iStatus.Int() == KRequestPending)

        {

        TRequestStatus* myStatus = &iStatus;

        User::RequestComplete(myStatus, KErrCancel);

        }

    }

//--------------------------------------------------------------------------------

//CRemoteTestEnv -----------------------------------------------------------------

CRemoteTestEnv* CRemoteTestEnv::NewL()

    {

    CRemoteTestEnv* obj = new (ELeave) CRemoteTestEnv();

    CleanupStack::PushL(obj);

    obj->ConstructL();

    CleanupStack::Pop(obj);

    return obj;

    }

CRemoteTestEnv::CRemoteTestEnv() :

    CActive(CActive::EPriorityStandard)

    {

    }

void CRemoteTestEnv::ConstructL()

    {

    //Create the message queues.

    User::LeaveIfError(iResultOutQueue.CreateGlobal(KResultQueueName, 5));

    User::LeaveIfError(iParamsInQueue.CreateGlobal(KParamsQueueName, 1));

    iSupervisorId = RThread().Id();

    //Create AOs that monitor for events.

    //These priorities are important, since if, for example, the worker

    //thread exits by returning from the thread entrypoint after

    //successfully completing the EndTestStep() case, but before the

    //supervisor runs, the supervisor's AS will find that both iWorkerListener

    //and iTestCaseListener have completed. We use the priorities to determine

    //which signal to run first. (The one we run will cancel the others).

    iTimeoutTimer = CTimeoutTimer::NewL(*this, CActive::EPriorityLow);

    iWorkerListener = CWorkerListener::NewL(*this, CActive::EPriorityStandard);

    iTestCaseListener = CTestCaseListener::NewL(*this, CActive::EPriorityHigh);

    //Add self to active scheduler.

    CActiveScheduler::Add(this);

    }

CRemoteTestEnv::~CRemoteTestEnv()

    {

    Cancel();

    delete iTimeoutTimer;

    delete iWorkerListener;

    delete iTestCaseListener;

    iParamsInQueue.Close();

    iResultOutQueue.Close();

    }

void CRemoteTestEnv::StartReceivingCmds()

    {

    ReceiveCmd();

    CActiveScheduler::Start();

    }

void CRemoteTestEnv::ReceiveCmd()

    {

    ENDPOINT_ASSERT_DEBUG(!IsActive(), User::Invariant());

    iParamsInQueue.NotifyDataAvailable(iStatus);

    SetActive();

    }

//This is run when an packet arrives in the queue from the local side.

//It is not rearmed until the test step has run to completion.

void CRemoteTestEnv::RunL()

    {

    //Retrieve the packet from the queue.

    TInt err = iParamsInQueue.Receive(iCurTestCaseParamsPacket);

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

    //Create the appropriate TestStep and launch thread if this is a "StartTestStep".

    if(iCurTestCaseParamsPacket.iTestCase == KStartTestStepCaseNumber)

        {

        //At this point in a well behaved system, iCurTestStep must be NULL.

        //If it is not, comms has gone wrong (most likely the local side has 

        //panicked midway through the test step). If iCurTestStep is not NULL

        //we can also guarantee that the thread is still running. Recover 

        //from this by getting the thread to do some special teardown, 

        //followed by tidying up in this thread.

        if(iCurTestStep)

            {

            //Logon to worker then signal to abort the test case

            //and wait for completion.

            TRequestStatus threadStat;

            iCurWorker.Logon(threadStat);

            TRequestStatus* notifyRunTestCase = &iNotifyRunTestCase;

            iCurWorker.RequestComplete(notifyRunTestCase, KErrAbort);

            User::WaitForRequest(threadStat);

            //Tidy up.

            iCurWorker.Close();

            delete iCurTestStep;

            iCurTestStep = NULL;

            }

        TBool result = SetupTestStep();

        //If we failed to setup the test step (invalid uid),

        //just register for another command and return.

        if(!result)

            {

            //Register to receive another packet from the message queue.

            ReceiveCmd();

            return;

            }

        }

    //Activate the TimoutTimer, TestCaseListener and WorkerListener.

    iTimeoutTimer->After(iCurTestStep->Timeout());

    iTestCaseListener->Listen();

    iWorkerListener->Listen(iCurWorker);

    //Signal the worker thread to start a test case.

    TRequestStatus* notifyRunTestCase = &iNotifyRunTestCase;

    iCurWorker.RequestComplete(notifyRunTestCase, KErrNone);

    }

void CRemoteTestEnv::DoCancel()

    {

    iParamsInQueue.CancelDataAvailable();

    }

//The test case can end in three ways:

//    1. Test Case compeletes normally (this includes failing).

//    2. The Test Case times out (in which case the thread is panicked).

//    3. The Test Case panics the worker thread.

//Three AOs listen for each of these possibilities and one of the functions below.

//This is called for case 1.

void CRemoteTestEnv::TestCaseCompleted()

    {

    //Cancel the TimeoutTimer and WorkerListener.

    iTimeoutTimer->Cancel();

    iWorkerListener->Cancel();

    //Test case completed correctly, so send test result.

    SendResult(iCurTestCaseVerdict);

    //Tidy up if this is the end of the test step.

    if(iCurTestCaseParamsPacket.iTestCase == KEndTestStepCaseNumber)

        {

        iCurWorker.Close();

        delete iCurTestStep;

        iCurTestStep = NULL;

        }

    //Register to receive another packet from the message queue.

    ReceiveCmd();

    }

//This is called for case 2.

void CRemoteTestEnv::TestCaseTimedOut()

    {

    //Cancel the TestCaseListener and WorkerListener.

    iTestCaseListener->Cancel();

    iWorkerListener->Cancel();

    //Thread timed out so log that it timed out and send the ERtvTimeout result.

    iCurTestStep->REMOTE_ERR_PRINTF1(_L("Remote test step timed out."));

    SendResult(ERtvTimeout);

    //Tidy up. Because we timed out, we abandon the test step, so

    //kill the thread and release even if this was not an EndTestStep

    iCurWorker.Kill(KErrTimedOut);

    iCurWorker.Close();

    delete iCurTestStep;

    iCurTestStep = NULL;

    //Register to receive another packet from the message queue.

    ReceiveCmd();

    }

//This is called for case 3.

void CRemoteTestEnv::WorkerExitted()

    {

    //Cancel the TimeoutTimer and TestCaseListener.

    iTimeoutTimer->Cancel();

    iTestCaseListener->Cancel();

    //Even if we were running a EndTestStep (ie the thread will exit normally), TestCaseListener should still

    //fire first, and it will cancel the WorkerListener - so we know that if we get here, it is because the

    //thread exitted abnormally.

    //Thread was panicked, so log the panic category before sending the ERtvPanic result.

    TExitCategoryName exitCategory = iCurWorker.ExitCategory();

    iCurTestStep->REMOTE_ERR_PRINTF3(_L("Remote test step panicked with: %S, code = %d."), &exitCategory, iCurWorker.ExitReason());

    SendResult(ERtvPanic);

    //Tidy up. Because we panicked, we abandon the test step, so

    //release resources even if this was not an EndTestStep

    iCurWorker.Close();

    delete iCurTestStep;

    iCurTestStep = NULL;

    //Register to receive another packet from the message queue.

    ReceiveCmd();

    }

TBool CRemoteTestEnv::SetupTestStep()

    {

    //Set the TRequestStatus that the worker thread triggers off for the first time.

    //After this, the worker thread will set it back to KRequestPending itself.

    iNotifyRunTestCase = KRequestPending;

    //Create TestStep

    TRAPD(err, iCurTestStep = CreateRemoteTestStepL(iCurTestCaseParamsPacket.iUid));

    if(err == KErrUnknown)

        {

        //Unknown test step. Tell the driver app.

        SendResult(ERtvUnknownTestUid);

        return EFalse;

        }

    else if(err != KErrNone || !iCurTestStep)

        {

        User::Invariant();

        }

    //Construct the test step base class.

    TRAP(err, iCurTestStep->ConstructL(*this));

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

    //Create Test Thread.

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

    static const TInt KHeapMinSize = 0x1000;      //  4KB

    static const TInt KHeapMaxSize = 0x1000000;   // 16MB

    TUint32 random = Math::Random();

    TName threadName;

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

    _LIT(KExecName, "EpTestRemoteExec");

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

    err = iCurWorker.Create(threadName, TestThreadEntryPoint, KStackSize, KHeapMinSize, KHeapMaxSize, this);

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

    //Start the test thread.

    iCurWorker.Resume();

    return ETrue;

    }

// The DoEglHeapMark and DoEglHeapCheck are intended to make sure memory

// allocations are freed when the testing is complete. The current

// implementation only supports the Symbian/Nokia reference implementation.

// An implementor of another EGL implementation is free to add their own

// variant of heapchecking here, with suitable #if around it.

// The function in egl should call __DbgMarkStart() and __DbgMarkEnd()

// on the heap for the egl implementation - or the equivalent if the

// heap is not a typical Symbian heap.

void CRemoteTestEnv::DoEglHeapMark()

    {

#if USE_EGLHEAP_CHECKING

    typedef void (*TEglDebugHeapMarkStartPtr)();

    TEglDebugHeapMarkStartPtr  heapMarkStart = reinterpret_cast<TEglDebugHeapMarkStartPtr>(eglGetProcAddress("egliDebugHeapMarkStart"));

    if (heapMarkStart)

        {

        heapMarkStart();

        }

#endif

    }

void CRemoteTestEnv::DoEglHeapCheck()

    {

#if USE_EGLHEAP_CHECKING

    typedef EGLint (*TEglDebugHeapMarkEndPtr)(EGLint count);

    TEglDebugHeapMarkEndPtr heapMarkEnd = reinterpret_cast<TEglDebugHeapMarkEndPtr>(eglGetProcAddress("egliDebugHeapMarkEnd"));

    if (heapMarkEnd)

        {

        (void)heapMarkEnd(0);

        }

#endif

    }

#define __EGLHEAP_MARK   DoEglHeapMark()

#define __EGLHEAP_MARKEND  DoEglHeapCheck()

void CRemoteTestEnv::RunCurrentTestStepL()

    {

    TInt processHandleMarkDummy;

    TInt threadHandleMarkStart;

    TInt threadHandleMarkEnd;

    TBool finished = EFalse;

    while(!finished)

        {

        //Wait to be signalled to run a test case.

        User::WaitForRequest(iNotifyRunTestCase);

        //We are aborting the test step. Tidy up EGL and exit.

        if(iNotifyRunTestCase.Int() == KErrAbort)

            {

            iCurTestStep->EglEndL();

            iNotifyRunTestCase = KRequestPending;

            return;

            }

        //Rearm the TRequestStatus (The first arming is done in the supervisor thread).

        iNotifyRunTestCase = KRequestPending;

        //Run the test case and panic if it leaves. Start/End are just special test cases.

        if(iCurTestCaseParamsPacket.iTestCase == KStartTestStepCaseNumber)

            {

            //Mark the user heap & thread handle count (we don't care about the process handle count).

            RThread().HandleCount(processHandleMarkDummy, threadHandleMarkStart);

            __UHEAP_MARK;

            __EGLHEAP_MARK;

            //StartRemoteTest.

            TRAPD(err, iCurTestCaseVerdict = iCurTestStep->DoStartRemoteTestStepL(iCurTestCaseParamsPacket.iParams));

            __ASSERT_ALWAYS(err == KErrNone, User::Panic(_L("tried to leave."), __LINE__));

            }

        else if(iCurTestCaseParamsPacket.iTestCase == KEndTestStepCaseNumber)

            {

            //EndRemoteTest.

            TRAPD(err, iCurTestCaseVerdict = iCurTestStep->DoEndRemoteTestStepL(iCurTestCaseParamsPacket.iParams));

            __ASSERT_ALWAYS(err == KErrNone, User::Panic(_L("tried to leave."), __LINE__));

            //This will cause a panic if the test step leaked memory or thread handles.

            __UHEAP_MARKEND;

            __EGLHEAP_MARKEND;

            RThread().HandleCount(processHandleMarkDummy, threadHandleMarkEnd);

            __ASSERT_ALWAYS(threadHandleMarkStart == threadHandleMarkEnd, User::Panic(_L("leaked handles."), KErrBadHandle));

            //Exit the loop (and eventually the thread).

            finished = ETrue;

            }

        else

            {

            //Run a regular Test Case.

            TRAPD(err, iCurTestCaseVerdict = iCurTestStep->DoRunRemoteTestCaseL(iCurTestCaseParamsPacket.iTestCase, iCurTestCaseParamsPacket.iParams));

            __ASSERT_ALWAYS(err == KErrNone, User::Panic(_L("tried to leave."), __LINE__));

            }

        //Notify the supervisor that we have completed the test case.

        RThread supervisor;

        TInt err = supervisor.Open(iSupervisorId);

        __ASSERT_ALWAYS(err == KErrNone, User::Panic(_L("framework error."), __LINE__));

        TRequestStatus* notifyFinishTestCase = &iTestCaseListener->iStatus;

        supervisor.RequestComplete(notifyFinishTestCase, KErrNone);

        supervisor.Close();

        }

    }

TInt CRemoteTestEnv::TestThreadEntryPoint(TAny* aSelf)

    {

    CRemoteTestEnv* self = static_cast<CRemoteTestEnv*>(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->RunCurrentTestStepL());

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

    //Clean up.

    delete scheduler;

    delete cleanup;

    return KErrNone;

    }

void CRemoteTestEnv::SendResult(TRemoteTestVerdict aVerdict)

    {

    iResultOutQueue.SendBlocking(TRemoteTestResult(iCurTestCaseParamsPacket.iUid, iCurTestCaseParamsPacket.iTestCase, aVerdict));

    }

void CRemoteTestEnv::SendLog(const TDesC8& aFile, TInt aLine, TInt aSeverity, const TDesC& aMessage)

    {

    iResultOutQueue.SendBlocking(TRemoteTestResult(iCurTestCaseParamsPacket.iUid, iCurTestCaseParamsPacket.iTestCase, aFile, aLine, aSeverity, aMessage));

    }

//--------------------------------------------------------------------------------

//CRemoteTestStepBase ------------------------------------------------------------

CRemoteTestStepBase::CRemoteTestStepBase(TTestUid aUid) :

    iUid(aUid)

    {

    }

void CRemoteTestStepBase::ConstructL(CRemoteTestEnv& aTestEnv)

    {

    iTestEnv = &aTestEnv;

    if (iEndpoint.Error() != KErrNone)

        {

        RDebug::Printf("Could not construct CRemoteTestStepBase"

                " - is EglEndpointNOK enabled?? -- Error: %d", iEndpoint.Error());

        User::Leave(iEndpoint.Error());

        }

    }

CRemoteTestStepBase::~CRemoteTestStepBase()

    {

    }

TRemoteTestVerdict CRemoteTestStepBase::DoStartRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    //Default implementation does nothing.

    return ERtvPass;

    }

TRemoteTestVerdict CRemoteTestStepBase::DoEndRemoteTestStepL(const TRemoteTestParams& /*aMessageIn*/)

    {

    //Default implementation does nothing.

    return ERtvPass;

    }

TInt CRemoteTestStepBase::Timeout() const

    {

    return KRemoteTestStepTimeout;

    }

class TOverflowTruncate : public TDesOverflow

    {

public:

    virtual void Overflow(TDes& /*aDes*/)

        {

        //Do nothing - just let it truncate.

        }

    };

void CRemoteTestStepBase::Log(const TText8* aFile, TInt aLine, TInt aSeverity, TRefByValue<const TDesC> aFmt, ...)

    {

    if(iTestEnv)

        {

        TOverflowTruncate overflow;

        VA_LIST list;

        VA_START(list, aFmt);

        TBuf<0x100> buf;

        buf.AppendFormatList(aFmt, list, &overflow);

        TPtrC8 file(aFile);

        iTestEnv->SendLog(file, aLine, aSeverity, buf);

        }

    }

void CRemoteTestStepBase::EglStartL()

    {

    eglInitialize(eglGetDisplay(EGL_DEFAULT_DISPLAY), NULL, NULL);

    if (eglGetError()!=EGL_SUCCESS)

        {

        REMOTE_INFO_PRINTF1(_L("could not initialise egl"));

        User::Leave(KErrGeneral);

        }

    }

void CRemoteTestStepBase::EglEndL()

    {

    eglTerminate(eglGetDisplay(EGL_DEFAULT_DISPLAY));

    if (eglGetError()!=EGL_SUCCESS)

        {

        REMOTE_INFO_PRINTF1(_L("could not terminate egl"));

        User::Leave(KErrGeneral);

        }

    eglReleaseThread();

    }

const TEglEndpointWrap& CRemoteTestStepBase::EglEndpoint() const

    {

    return iEndpoint;

    }

//--------------------------------------------------------------------------------