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

 //

 // Description:

 //

 /**

  @file

  @test

  @internalComponent - Internal Symbian test code

 */

 #ifndef __EGLTEST_ENDPOINT_ENGINE_H__

 #define __EGLTEST_ENDPOINT_ENGINE_H__

 #include "localtestbase.h"

 #include "remotetestbase.h"

 #include "egltest_surface.h"

 #include "egltest_endpoint_engine_types.h"

 #include "egltest_endpoint_images.h"

 #define ENGINE_ASSERT(x) DoEngineAssert((x) != 0, #x, __FILE__, __LINE__)

 static inline void DoEngineAssert(TInt aX, const char *aXStr, 

         const char *aFile, TInt aLine)

     {

     if (!aX)

         {

         RDebug::Printf("EGL_ENDPOINT_TEST_ENGINE ASSERT(%s) failed (value %d) at %s:%d\n",

                 aXStr, aX, aFile, aLine);

         User::Panic(_L("ENGINE_ASSERT"), aLine);

         }

     }

 // This could be wrapped in #if/#else to allow us to generate non-unicode text content.

 #define TESTIDS(x)  _S(x)

 #define CASETITLE(x)  _S(x)

 // SurfaceType lists.

 // We use macros so that we get an automatic comment as to what the fields are,

 // rather than just listing enums in an array.

 #define SurfaceTypes1(type1) 1, { type1 }

 #define SurfaceTypes2(type1, type2) 2, { type1, type2 }

 #define SurfaceTypes3(type1, type2, type3) 3, { type1, type2, type3 }

 #define SurfaceTypes4(type1, type2, type3, type4) 4, { type1, type2, type3, type4 }

 // Macro used for building a TTestCases entry.

 #define TestCase(x) { x, sizeof(x) / sizeof(x[0]) }

 // Forward declare this class.

 class CEgltest_Local_Engine_Exec;

 // The object passed back from the exec thread to the

 // controller thread.

 class TExecResult

     {

 public:

     TExecResult();

     //Constructor for sending result info.

     TExecResult(TVerdict aVerdict, TEngineCases aCase);

     // Constructor for sending result of buffer count paramters.

     TExecResult(TVerdict aBufferCountVerdict, TVerdict aVerdict, TEngineCases aCase);

 public:

     //Result message.

     TVerdict             iVerdict;

     // Checking buffer count. 

     TVerdict             iBufferCountVerdict;

     // Get Surface parameter reply.

     TSurfaceParamsRemote iSurfaceParams;

     // To check that we are in sync - it should match the request.

     TEngineCases         iCase;

     };

 const TInt KMaxLoadThreads = 4;

 NONSHARABLE_CLASS(CEgltest_Local_Engine): public CLocalTestStepBase

     {

 private:

     enum TExecState

         {

         EExecStateNone  = 0,

         EExecStateRemote, 

         EExecStateLocal

         };

 public:

     CEgltest_Local_Engine(const TTestCases *aTestCases, TInt aNumCases);

     virtual ~CEgltest_Local_Engine();

     virtual TVerdict doTestStepL();

     virtual void DoPreambleL();

     virtual void DoPostambleL();

     void SetTestCasesL(const TTestCases * const aTestCases, TInt aNumCases);

 private:

     void RunTestCase(const TTestCases &aTestCase);

     void RunOneTestCase(const TTestCase& aTestCase, TSurfaceType aSurfType);

     void SendLocalTestCase(const TRemoteTestParams &aParams);

     void RunLocalTestCase(TEngineCases aCase);

     void DoSyncToLocal();

     void GetLocalResult(TExecResult& aResult, TEngineCases aCase);

     void DoMonitorThreadEntry();

     void ForwardPanic(RThread& aThread, RThread& aOtherThread, TRequestStatus &aStatus);

     static TInt MonitorThreadEntry(TAny *aParam);

     void RunControllerLocalAndRemoteL(const TEngineTestCase&, const TRemoteTestParams& params);

 protected:

     void RunLocalTestCase(const TRemoteTestParams& aMessageIn, TExecResult& aResult);

     TVerdict RunRemoteTestCase(TInt aTestCase, const TRemoteTestParams& aMessageIn);

     void RunSingleCaseL(const TTestCase& aTestCase, TSurfaceType aSurfType);

     void CommonPreambleL();

     CEgltest_Local_Engine();

     // The StartThread and EndThread needs to be overridden in the 

     // implementation to provide a good functionality. 

     virtual void StartThreadL(TInt aThreadNumber);

     virtual void EndThread(TInt aThreadNumber);

 protected:

     const TTestCases*                  iTestCases;

     TInt                               iNumCases;

     RThread                            iExecThread;

     RThread                            iMonitorThread;

     RThread                            iControllerThread;  // Controller thread

     RMsgQueue<TExecResult>             iExecResultOutQueue;

     RMsgQueue<TRemoteTestParamsPacket> iExecParamsInQueue;

     TExecState                         iExecState;

     TBool                              iLogging;

     };

 struct TRemoteTestArgs

     {

     EGLDisplay     iDisplay;

     EGLEndpointNOK iEndpoint;

     EGLImageKHR    iImage;

     };

 struct TAvailableMemory

     {

     TInt iHeapMemAvailable;

     TInt iGpuMemAvailable;

     };

 // Base class that allows "script" style exectution of testcases.

 NONSHARABLE_CLASS(CEgltest_Remote_Engine): public CRemoteTestStepBase

     {

 public:

     CEgltest_Remote_Engine();

     virtual ~CEgltest_Remote_Engine();

     virtual TRemoteTestVerdict DoStartRemoteTestStepL(const TRemoteTestParams& aParams);

     virtual TRemoteTestVerdict DoEndRemoteTestStepL(const TRemoteTestParams& aParams);

     virtual TRemoteTestVerdict DoRunRemoteTestCaseL(TInt aTestCase, const TRemoteTestParams& aParams);

 private:

     void LogDump(const TEngineTestCase& aCase);

     EGLDisplay GetDisplay(TInt aFlags);

     EGLEndpointNOK GetEndpoint(TInt aIndex, TInt aFlags);

     EGLImageKHR GetImage(TInt aIndex, TInt aFlags);

     EGLenum GetEndpointType(TInt aFlags);

     EGLenum GetSourceType(TInt aFlags);

     const TSurfaceId GetSurfaceId(TInt aFlags, const TSurfaceId& aSurfaceId);

     void CheckReturn(TInt aRetval, const TEngineTestCase& aStreamItem, TInt aFailValue,

                       const TText* aFailSymbol, const TText* aFunction);

     void RunCaseL(TInt aTestCase, const TRemoteTestParams &aParams, const TRemoteTestArgs& aArgs);

     void CreateEndpointCaseL(const TRemoteTestParams& aParams, const TRemoteTestArgs& aArgs);

     void ReleaseImageCaseL(const TRemoteTestParams& aParams, const TRemoteTestArgs& aArgs);

     void ActivateVgContextL();

     void RequestNotificationL(const TRemoteTestParams& aParams, const TRemoteTestArgs& aArgs);

     void GetEndpointDirtyAreaL(const TRemoteTestParams& aParams, const TRemoteTestArgs& aArgs);

     void DoCheckRectsL(EGLint *aActualRects, EGLint aRectCount, EGLint aMaxRects,

                        TInt aRectsIndex, const TRect aSurfacRect);

     void CheckForMemoryLeaks();

     void CheckForMemoryLeaksFinish();

     TInt FillGpuMemory();

     TInt CalculateAvailableGPUMemory();

     TInt CalculateAvailableHeapMemory();

     // Thread entry points for "load" threads.

     static TInt LoadHeapMemory(TAny *);

     void LoadHeapMemoryL();

     static TInt LoadGpuMemory(TAny *);

     void LoadGpuMemoryL();

     void StartThreadL(TInt aThreadNumber);

     void EndThread(TInt aThreadNumber);

     TThreadFunction GetThreadFunction(TInt aThreadNumber);

 private:

     EGLEndpointNOK iEndpoints[KMaxEndpoints];

     EGLImageKHR iEglImage[KMaxEndpoints];

     CTestVgEglImage* iVgImage[KMaxEndpoints];

     TRequestStatus iRequestStatus[KMaxEndpoints];

     TRemoteTestVerdict iTestVerdict;

     TBool iLogging;

     CEglWindowSurface *iSurface;

     // when this flag is set, errors discovered during a test-step is logged.

     // This is normally true, but for stress tests [etc], it can be turned

     // off so that when a test is set up to run 1000 times, but only succeeds

     // X times, we don't get "error, something failed", when we really didn't

     // get an error.

     TBool iLogErrors;

     // Tracking memory available. 

     RArray<TAvailableMemory> iMemoryStats;

     // Variables to keep track of load-threads.

     RThread iLoadThread[KMaxLoadThreads];

     TBool   iStopThreadFlag[KMaxLoadThreads]; 

     RHeap* iMainThreadHeap;

     PFNEGLQUERYPROFILINGDATANOKPROC ipfnEglQueryProfilingDataNOK;

     };

 #define CASE(x)   case x: caseName=_S(#x); break

 static inline const TText* EngineCaseName(TEngineCases aCase)

     {

     const TText* caseName = _S("Unknown Engine Case");

     switch (aCase)

         {

 	  CASE(ECreateEndpointCase);

 	  CASE(EBeginStreamingCase);

 	  CASE(EAcquireImageCase);

 	  CASE(EReleaseImageCase);

 	  CASE(EEndStreamingCase);

 	  CASE(EContentUpdateCase);

 	  CASE(EDestroyEndpointCase);

 	  CASE(EInitializeCase);

 	  CASE(ETerminateCase);

 	  CASE(EGetAttribCase);

 	  CASE(ESetAttribCase);

 	  CASE(ECreateSurfaceCase);

 	  CASE(EDrawContentCase);

 	  CASE(ECompareImageCase);

 	  CASE(EWaitForCase);

 	  CASE(ENotifyWhenCase);

 	  CASE(ETestVgImageValidCase);

 	  CASE(EDestroyVgImageCase);

 	  CASE(EDestroyEglImageCase);

 	  CASE(ETimeStampCase);

 	  CASE(ERequestNotificationCase);

 	  CASE(EWaitForNotificationCase);

 	  CASE(ECancelNotificationCase);

 	  CASE(EBreakPointCase);

 	  CASE(ELogEnableCase);

 	  CASE(EIllegalCase);

 	  CASE(EPanicCase);

 	  CASE(EGetEndpointDirtyAreaCase);

 	  CASE(ESyncLocalCase);

 	  CASE(EGetSurfaceParamsCase);

 	  CASE(EFinishedCase);

 	  CASE(ECreateVgImageCase);

       CASE(EDestroySurfaceCase);

       CASE(EStartLoadThreadCase);

       CASE(EEndLoadThreadCase);

       CASE(ECheckForMemoryLeaks);

       CASE(ECheckForMemoryLeaksFinish);

         }

     return caseName;

     }

 #undef CASE

 inline void LogDump(CTestExecuteLogger &aLogger, const TEngineTestCase& aCase)

 {

     const TText *caseName = EngineCaseName(aCase.iCase);

     aLogger.LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo,

                     _L("Performing subcase %d (%s), with flags=%d, err=%04x endpointidx=%d, image=%d, args=(%d, %d)"),

                     aCase.iCase,

                     caseName,

                     aCase.iFlags,

                     aCase.iErrorExpected,

                     aCase.iEndpointIndex,

                     aCase.iImageIndex,

                     aCase.iArg1, aCase.iArg2);

 }

 #endif // __EGLTEST_ENDPOINT_ENGINE_H__