// 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;

     }

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