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

#define __EGLTEST_ENDPOINT_ENGINE_TYPES_H__

#include "egltest_surface.h"

enum TEngineCases

    {

    // ECreateEndpointCase

    // iEndPointIndex is used to store the endpoint at that index.

    ECreateEndpointCase = 0,

    // EBeginStreamingCase

    // Call EglEndpointBeginStreaming.

    // iEndpointIndex indicates the endpoint to call BeginStreaming on.

    EBeginStreamingCase = 1,

    // EAcquireImageCase

    // iEndpointIndex indicates the endpoint used to acquire the image.

    // iImageIndex is ignored.

    EAcquireImageCase = 2,

    // EReleaseImageCase

    // iEndpointIndex indicates the endpoint used to acquire the image.

    // iImageIndex indicates the slot of the eglImage to be used.

    EReleaseImageCase = 3,

    // EEndStreamingCase

    // Call EglEndPointEndStreaming.

    // iEndpointIndex indicates which endpoint to use.

    EEndStreamingCase = 4,

    // EContentUpdateCase

    // iEndpointIndex indicates which surface to use.

    // iImageIndex index to the rectangle set to pass in as "dirty rectangles".

    //             if index = 0, then a NULL is passed - indicating full surface 

    //             (no other value currently supported).

    // iFlags: ENoWait: complete immediately, rather than wait for displayed 

    //                  notification (only valid for non-EGL surfaces).

    //         ENoSync: Do not wait for contentupdate to complete, instead, 

    //                  use a short delay (300ms) to ensure the submitupdate

    //                  has reached SUS.

    //                  This is necessary to avoid a deadlock where the local

    //                  side is doing EglSwapBuffer [or similar], and the 

    //                  remote side has not yet done EglReleaseImageNOK.

    //                  If the local side was to wait for the EglSwapBuffer 

    //                  to complete, the EglReleaseImageNOK would not happen.

    //                  There is no need to have ENoSync if the EglReleaseBuffer

    //                  for that endpoint is called before the EContentUpdateCase.

    EContentUpdateCase = 5,

    // EDestroyEndpointCase

    // iEndpointIndex indciates the endpoint to be destroyed.

    EDestroyEndpointCase = 6,

    // ETerminateCase

    // Call eglTerminate and does various other cleanup.

    // No egl calls except eglInitialize is expected to "work" after this point.

    // This is also sent to the local exec thread to terminate it when test step

    // is finished. 

    ETerminateCase = 7,

    // EInitializeCase

    // Initialize. Call eglInitialize and other setup.

    EInitializeCase = 8,

    // EGetAttributeCase

    // iEndpointIndex indicates the endpoint to use.

    // iArg1 is the attribute key to request.

    // iArg2 is the value expected.

    EGetAttribCase = 9,

    // ESetAttributeCase

    // iEndpointIndex indicates the endpoint to use.

    // iImageIndex is ignored.

    // iArg1 is the attribute key to request.

    // iArg2 is the value to set.

    ESetAttribCase = 10,

    // ECreateSurfaceCase

    // iEndpointIndex indicates which the surface object is stored at

    // iImageIndex indicates the surfaceParams to use.

    ECreateSurfaceCase = 11,

    // EDrawContentCase

    // Draws an image.

    // iEndpointIndex indicates the surface to draw to.

    // iImageIndex is the index of the image to be drawn.

    EDrawContentCase = 12,

    // ECompareImageCase

    // iEndpointIndex = the index of the eglimage stored, the iImageIndex when it was acquired

    // iImageIndex is the index of the image to compare

    ECompareImageCase = 13,

    // EBufferCountCase

    // Query the surface to find out number of buffers, and only run the remainder

    // of case if the number of buffers match. If test fails, log a warning that

    // the test is not executed, then terminate the case.

    // iEndpointIndex = number of the surface to check.

    // iImageIndex = n/a - ignored.

    // arg1 = Min buffer count (inclusive). 0 -> any number.

    // arg2 = Max buffer count (inclusive). 0 -> any number

    EBufferCountCase = 14,

    // ENotifyWhenCase

    // iEndpointIndex = surface for which the notification applies.

    // iImageIndex = which notification (See TNotification in egltest_surface.h)

    // iArg1 = XTimes when ENotifyWhenDispXTimes

    ENotifyWhenCase = 15,

    // EWaitForCase

    // iExpectedError = KErrTimedOut if the notification is expected to "not be signaled", KErrNone for other cases.

    // iEndpointIndex = surface for which to wait on notification (also used for timestamp).

    // iImageIndex = which notification (See TNotification in egltest_surface.h)

    // iArg1 = Timeout length in microseconds.

    // iArg2 = expected timestamp. (NOtifywhendisplayed), relative to timestamp of ETimeStampCase.

    EWaitForCase = 16,

    // ECreateVgImageCase

    // iEndpointIndex = the index of the eglimage to create the vgimage from.

    // iImageIndex is the index in the vgimages array that the created vgimage will be saved to.

    ECreateVgImageCase = 17,

    // EDestroyVgImageCase

    // iImageIndex is the index in the vgimages array that will be destroyed.

    EDestroyVgImageCase = 18,

    // EDestroyEglImageCase

    // Note: This is not intended for normal endpoint tests - use EReleaseImageCase for that.

    // iEndpointIndex = ignored.

    // iImageIndex = image index to destroy.

    EDestroyEglImageCase = 19,

    // ETimeStampCase

    // Store current User::FastCounter().

    // iEndpointIndex = index to store timestamp at (should match the surface index).

    ETimeStampCase = 20,

    // ETestVgImageValidCase

    // Test that the VgImage is valid and "works" by reading some of the pixels in it.

    // No checking that the content is as expected, since where we use this

    // is to test that the VgImage is valid after destroying the endpoint - at which point

    // the content is undefined, but the VgImage must be usable by the effects engine code.

    // See also ECreateVgImageCase.

    // iEndpointIndex ignored.

    // iImageIndex is the index of the vgimage to be drawn.

    ETestVgImageValidCase = 21,

    // ERequestNotificationCase

    // Request a notification of update.

    // iEndpointIndexis the index of the endpoint to use.

    ERequestNotificationCase = 22,

    // ECancelNotificationCase

    // Cancel a notification of update.

    // iEndpointIndexis the index of the endpoint to use.

    ECancelNotificationCase = 23,

    // EWaitForNotificationCase

    // Wait for the notification of the

    // iEndpointIndex is the index of the endpoint to use.

    // iImageIndex - not used

    // iArg1 - timeout value in microseconds.

    EWaitForNotificationCase = 24,

    // EGetEndpointDirtyAreaCase

    // Get dirty area

    // iEndpointIndex is the index of the endpoint to use.

    // iImageIndex index to the rectangle set to pass in as "dirty rectangles".

    //             if index = 0, then full surface is expected.

    // iarg1 start_rect

    // iArg2 max_rects

    // iFlags - EUseNullRects - pass NULL as the rects value.

    //          EUseCollapseArea - pass TRUE for collapse

    EGetEndpointDirtyAreaCase = 25,

    // EGetSurfaceParamsCase

    // Get parameters of the surface. 

    // iEndpointIndex is the index of the surface being used.

    // This is used for internal communication between the controller thread

    // and the EGL execution thread, so the parameters can be passed over to

    // the remote side. This is due to the fact that we can only use the 

    // RWindow component that is part of an EGL surface in the thread that

    // created the RWindow.

    EGetSurfaceParamsCase = 26, 

    // EDestroySurfaceCase

    // Opposite of ECreatSurfaceCase.

    // iEndpointIndex indicates which surface object

    EDestroySurfaceCase = 27,

    // EStartLoadThreadCase

    // For tests that have some sort of second thread that does "loading" 

    // (e.g. heavy drawing or using up memory), this will start that thread.

    // iEndpointIndex is the thread number. 

    // Note, relies on the thread implementing a StartLoadThread() function -

    // default implementation will panic.

    EStartLoadThreadCase = 28,

    // EEndLoadThreadCase

    // For tests that have some sort of second thread that does "loading" 

    // (e.g. heavy drawing or using up memory), this will end the thread.

    // iEndpointIndex is the thread number. 

    // Note, relies on the thread implementing a EndLoadThread() function -

    // default implementation will panic.

    EEndLoadThreadCase = 29,

    // ECheckForMemoryLeaks

    // Used by tests that perform for example out-of-memory testing. 

    // Executed on the in the remote engine code. 

    // The amount of memory available is stored in an array, and when 

    // the ECheckForMemoryLeaksFinish is called, the statistics is

    // calculated abd deternubed if there is a leak or not. 

    ECheckForMemoryLeaks = 30,

    // ECheckForMemoryLeaksFinish

    // Check the collected data from ECheckForMemoryLeaks, and determine the

    // trend of memory usage. 

    // See ECheckForMemoryLeaks

    ECheckForMemoryLeaksFinish = 31,

    // ESpecialEglHeapCase

    // Configure a heap for the EGL calls. 

    // This is used to allow egl calls to be done with a heap that is full.

    // iEndpointIndex = min size

    // iImageIndex = max size

    // IMPORTANT NOTE: This HAS TO BE the first case sent to the remote engine. 

    ESpecialEglHeapCase = 32,

    ///

    /// Debug cases

    ///

    // EBreakPointCase

    // Used for debugging.

    // iFlags = EDebugExecThread, EDebugController, EDebugRemote - break 

    // exec_thread, controller and/or remote part of engine.

    EBreakPointCase = 64,

    // ELogEnableCase

    // Logging enable - all items executed after this point are written out, including data parameters.

    // iFlags = EDebugLocal, EDebugRemote - log on local/remote side.

    ELogEnableCase = 65,

    ///////////////////////////////////////////////////////

    // Control messages - "done", "sync", etc.

    ///////////////////////////////////////////////////////

    // ESetVerdictCase

    // Used to set the relevant threads "teststepresult".

    // Flags indicate which thread is updated.

    // iEndpointIndex = verdict to set. 

    // Note: Remote value is not using the ERtvXXX values, the standard

    // values in Test Framework are translated in the remote step.

    ESetVerdictCase = 996,

    // ESyncLocalCase

    // Used for synchronizing the local execution thread. 

    // Should normally not be needed for the common cases of coding, but used internally to 

    // perform the synchronization. 

    ESyncLocalCase = 997,

    // EPanicCase

    // Cause panic on local or remote side. Used for testing purposes only.

    // iFlags = EDebugExecThread, EDebugController, EDebugRemote - break 

    // exec_thread, controller and/or remote part of engine.

    EPanicCase = 998,

    // EIllegalCase

    // A case that is by definition not legal/valid. There should be no case-

    // statement for this in the engine, it should be treated as a "unknown" case,

    // and cause any test to fail in the same way as if an unused value was put

    // in the table. Used for testing purposes, and can also be used to make a

    // particular test fail on purpose (e.g. due to production code bugs).

    // All arguments ignored.

    EIllegalCase = 999,

    // Indicate end of sequence.

    EFinishedCase = 1000

    };

enum TEngineFlags

    {

    EUseBadDisplay      = 1 << 0,

    EUseBadEndpoint     = 1 << 1,

    EUseBadEglImage     = 1 << 2,

    EUseBadEndpointType = 1 << 3,

    EUseBadSourceType   = 1 << 4,

    EExpectError        = 1 << 5,  // Used when other flags are not indicating a failure expected.

    EUseBadSurfaceId    = 1 << 6,

    EUseBadApi          = 1 << 7,

    // Flag to modify EContentUpdateCase to not wait for displayed.

    EUseBadSync         = 1 << 8,

    EUseBadRects        = 1 << 9,

    // Extra flags for EGetEndpointDirtyAreaCase

    EUseNullRects       = 1 << 10,

    EUseCollapseArea    = 1 << 11,

    // flags used by EContentUpdateCase

    ENoWait             = 1 << 14,

    ENoSync             = 1 << 15,

    // Debug flags - perform operation on "Local"

    EDebugExecThread      = 1 << 16,

    EDebugRemote        = 1 << 17,

    EDebugController    = 1 << 18,

    // ThreadingFlags - just rename the debug flags, because it's actually the

    // same thing. We _RELY_ on this being the same to simplify the code in 

    // the controller thread.

    // Note: the lack of "execthread" is intentional. Since controller and exec

    // are in the same process, there is no reason to use the ExecThread to 

    // start a new thread. ??This may need to be changed int he future.??

    EThreadRemote       = EDebugRemote,

    EThreadController   = EDebugController,

    };

enum TEngineFlagsMask

    {

    // Mask to match all "bad".

    EExpectFailureMask  = EUseBadDisplay       |

                          EUseBadEndpoint      |

                          EUseBadEglImage      |

                          EUseBadEndpointType  |

                          EUseBadSourceType    |

                          EExpectError         |

                          EUseBadSurfaceId     |

                          EUseBadApi           |

                          EUseBadSync          |

                          EUseBadRects         |

                          0   // So that it's easier to merge.

    };

enum TRemoteThreadEngineThread

    {

    EUnknownThread = 0,

    EThreadLoadHeapMemory = 1,

    EThreadLoadGpuMemory = 2,

    EThreadLoadGpuProcessor = 3,

    };

struct TEngineTestCase

    {

    TEngineCases iCase;             // Command to execute. See TEngineCases for details.

    TInt         iFlags;            // Flags to indicate for example bad parameters (TEngineFlags).

    TInt         iErrorExpected;    // The value that eglGetError() is expected to return.

    TInt         iEndpointIndex;    // Index to the endpoint to use.

    TInt         iImageIndex;       // Index to image to draw/compare(egltest_endpoint_images)

    TInt         iArg1;             // E.g. GetAttrib or SetAttrib attrib.

    TInt         iArg2;             // E.g  GetAttrib expected value or SetAttrib value to set.

    };

struct TTestEndpointEngine

    {

    TSurfaceParamsRemote iSurfaceParams;

    TEngineTestCase      iEngineTestCase;

    };

// Passed to StartRemoteTestStep() during test startup.

struct TTestEndpointEngineConfig

    {

    TBool iLogErrors; 

    };

// Number of small steps that each test is allowed to contain. Since each test

// that uses the engine has at least one table like this, increasing this 

// hugely will increase the overall  memory usage of the application (each 

// entry is about 28 bytes). So, don't go multiplying by 10 or some such

// unless there is a REAL need for that.

// THe current tables take up approximately 28 * 80 = 2240 bytes.

// As of right now, there are about 100 tests -> 220KB of tables.

const TInt KMaxCases    = 80;

// Should be PLENTY of endpoints [also used for surfaces, images and other

// objects that have roughly 1:1 mapping with endpoints. This is dynamically

// allocated in the constructor of the engine class.

const TInt KMaxEndpoints = 1000;

// Max number of surfacetypes we expect to be listed. 

// This can be increased as and when needed. 

const TInt KMaxSurfaceList = 4;   

struct TTestCaseBase

    {

    const TText*       iRelatedTestIds;

    const TText*       iName;

    TInt               iSurfaceTypeCount;

    TSurfaceType       iSurfaceTypeList[KMaxSurfaceList];

    };

// Structure for lists of cases to execute

struct TTestCase

    {

    // Use anonymous struct to avoid changing code all over the place.

    TTestCaseBase      iBase;

    TEngineTestCase    iEngineTestCase[KMaxCases];

    };

struct TTestCases

    {

    const TTestCase *iCase;

    TInt             iCount;

    };

#endif