Symaptic: os/graphics/egl/egltest/endpointtestsuite/automated/tsrc/egltest_endpoint

     1 // Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 /**

    17  @file

    18  @test

    19  @internalComponent - Internal Symbian test code

    20 */

    22 #include "egltest_endpoint_stresstests.h"

    23 #include "egltest_endpoint_engine.h"

    26 // an example of table with "random order numbers 0..3".

    27 static const TInt KImageTable[] = { 1, 3, 0, 2, 3, 1, 2, 0 };

    29 static TStressTestSection test588A[] =

    30 {

    31     1, EOnErrorPolicyFail,

    32     { NO_PARAMS },

    33     {

    34         { EInitializeCase,           0,                EGL_SUCCESS },

    35         { EFinishedCase }

    36     },

    37     100, EOnErrorPolicyBreak,

    38     { PARAM_DECL_ITER(0, 100, 1) },

    39     {

    40         { ECreateSurfaceCase,        0,              EGL_SUCCESS, PARAM0(0), EStandardSurface },

    41         { EFinishedCase }

    42     },

    43     100, EOnErrorPolicyBreak,

    44     { PARAM_DECL_ITER(0, 100, 1), PARAM_DECL_TABLE(KImageTable) },

    45     {

    46         { ECreateEndpointCase,       0,              EGL_SUCCESS, PARAM0(0) },

    47         { EDrawContentCase,          0,              EGL_SUCCESS, PARAM0(0), PARAM1(0) },

    48         { EContentUpdateCase,        0,              EGL_SUCCESS, PARAM0(0) },

    49         { EBeginStreamingCase,       0,              EGL_SUCCESS, PARAM0(0) },

    50         { EAcquireImageCase,         0,              EGL_SUCCESS, PARAM0(0) },

    51         { ECompareImageCase,         0,              EGL_SUCCESS, PARAM0(0), PARAM1(0) },

    52         { EReleaseImageCase,         0,              EGL_SUCCESS, PARAM0(0), PARAM0(0) },

    53         { EDestroyEndpointCase,      0,              EGL_SUCCESS, PARAM0(0) },

    54         { EFinishedCase }

    55     },

    56     1, EOnErrorPolicyFail,

    57     { NO_PARAMS },

    58     {

    59         { ETerminateCase,            0,              EGL_SUCCESS },

    60         { EFinishedCase }

    61     },

    62 };

    64 static TStressTestSection test588B[] =

    65 {

    66     1, EOnErrorPolicyFail,

    67     { NO_PARAMS },

    68     {

    69         { EInitializeCase,           0,                EGL_SUCCESS },

    70         { EFinishedCase }

    71     },

    72     1000, EOnErrorPolicyBreak,

    73     { PARAM_DECL_ITER(0, 1000, 1) },

    74     {

    75         { ECreateSurfaceCase,        0,              EGL_SUCCESS, PARAM0(0), EStandardSurface },

    76         { ECreateEndpointCase,       0,              EGL_SUCCESS, PARAM0(0) },

    77         { EDrawContentCase,          0,              EGL_SUCCESS, PARAM0(0), PARAM0(0) },

    78         { EContentUpdateCase,        0,              EGL_SUCCESS, PARAM0(0) },

    79         { EBeginStreamingCase,       0,              EGL_SUCCESS, PARAM0(0) },

    80         { EAcquireImageCase,         0,              EGL_SUCCESS, PARAM0(0) },

    81         { EFinishedCase }

    82     },

    83     1000, EOnErrorPolicyBreak,

    84     { PARAM_DECL_ITER(0, 1000, 1) },

    85     {

    86         { EReleaseImageCase,         0,              EGL_SUCCESS, PARAM0(0), PARAM0(0) },

    87         { EDestroyEndpointCase,      0,              EGL_SUCCESS, PARAM0(0) },

    88         { EFinishedCase }

    89     },

    90     1, EOnErrorPolicyFail,

    91     { NO_PARAMS },

    92     {

    93         { ETerminateCase,            0,              EGL_SUCCESS },

    94         { EFinishedCase }

    95     },

    96 };

    98 static TStressTestSection test589[] =

    99 {

   100     1, EOnErrorPolicyFail,

   101     { NO_PARAMS },

   102     {

   103         { EInitializeCase,           0,              EGL_SUCCESS },

   104         { ECreateSurfaceCase,        0,              EGL_SUCCESS, 0, ELargestPossibleSurface },

   105         { ECreateEndpointCase,       0,              EGL_SUCCESS, 0 },

   106         { EFinishedCase }

   107     },

   108     5, EOnErrorPolicyBreak,

   109     { PARAM_DECL_ITER(0, 4, 1) },

   110     {

   111         { EDrawContentCase,          0,              EGL_SUCCESS, 0, PARAM0(0) },

   112         { EContentUpdateCase,        0,              EGL_SUCCESS, 0 },

   113         { EBeginStreamingCase,       0,              EGL_SUCCESS, 0 },

   114         { EAcquireImageCase,         0,              EGL_SUCCESS, 0 },

   115         { ECompareImageCase,         0,              EGL_SUCCESS, 0, PARAM0(0) },

   116         { EReleaseImageCase,         0,              EGL_SUCCESS, 0 },

   117         { EFinishedCase }

   118     },

   119     1, EOnErrorPolicyFail,

   120     { NO_PARAMS },

   121     {

   122         { EDestroyEndpointCase,      0,              EGL_SUCCESS, 0 },

   123         { EDestroySurfaceCase,       0,              EGL_SUCCESS, 0 },

   124         { ETerminateCase,            0,              EGL_SUCCESS },

   125         { EFinishedCase }

   126     },

   127 };

   129 static TStressTestSection test590A[] =

   130 {

   131     1, EOnErrorPolicyFail,

   132     { NO_PARAMS },

   133     {

   134         { EInitializeCase,          0,          EGL_SUCCESS },

   135         { ECreateSurfaceCase,       0,          EGL_SUCCESS, 0, EStandardSurface },

   136         { ECreateEndpointCase,      0,          EGL_SUCCESS, 0 },

   137         { EFinishedCase }

   138     },

   139     1000, EOnErrorPolicyBreak,

   140     { PARAM_DECL_TABLE(KImageTable) },

   141     {

   142         { EDrawContentCase,         0,         EGL_SUCCESS, 0, PARAM0(0)},

   143         { EContentUpdateCase,       0,         EGL_SUCCESS, 0 },

   144         { EBeginStreamingCase,      0,         EGL_SUCCESS, 0 },

   145         { EAcquireImageCase,        0,         EGL_SUCCESS, 0 },

   146         { ECompareImageCase,        0,         EGL_SUCCESS, 0, PARAM0(0) },

   147         { EReleaseImageCase,        0,         EGL_SUCCESS, 0 },

   148         { EFinishedCase }

   149     },

   150     1, EOnErrorPolicyFail,

   151     { NO_PARAMS },

   152     {

   153         { EDestroyEndpointCase,     0,          EGL_SUCCESS, 0 },

   154         { ETerminateCase,           0,          EGL_SUCCESS },

   155         { EFinishedCase }

   156     },

   157 };

   159 static TStressTestSection test590B[] =

   160 {

   161     1, EOnErrorPolicyFail,

   162     { NO_PARAMS },

   163     {

   164         { EInitializeCase,          0,          EGL_SUCCESS },

   165         { EFinishedCase }

   166     },

   167     260, EOnErrorPolicyBreak,

   168     {PARAM_DECL_ITER(0, 260, 1), PARAM_DECL_TABLE(KImageTable)},

   169     {

   170         { ECreateSurfaceCase,       0,          EGL_SUCCESS, PARAM0(0), EStandardSurface },

   171         { ECreateEndpointCase,      0,          EGL_SUCCESS, PARAM0(0) },

   172         { EDrawContentCase,         0,          EGL_SUCCESS, PARAM0(0), PARAM1(0)},

   173         { EContentUpdateCase,       0,          EGL_SUCCESS, PARAM0(0) },

   174         { EBeginStreamingCase,      0,          EGL_SUCCESS, PARAM0(0) },

   175         { EAcquireImageCase,        0,          EGL_SUCCESS, PARAM0(0) },

   176         { ECompareImageCase,        0,          EGL_SUCCESS, PARAM0(0), PARAM1(0)},

   177         { EFinishedCase }

   178     },

   179     260, EOnErrorPolicyBreak,

   180     {PARAM_DECL_ITER(0, 260, 1)},

   181     {

   182         { EReleaseImageCase,        0,          EGL_SUCCESS, PARAM0(0), PARAM0(0) },

   183         { EDestroyEndpointCase,     0,          EGL_SUCCESS, PARAM0(0) },

   184         { EFinishedCase }

   185     },

   186     1, EOnErrorPolicyFail,

   187     { NO_PARAMS },

   188     {

   189         { ETerminateCase,           0,          EGL_SUCCESS },

   190         { EFinishedCase }

   191     },

   192 };

   194 static TStressTestSection test592A[] =

   195 {

   196     1, EOnErrorPolicyFail,

   197     { NO_PARAMS },

   198     {

   199         { EInitializeCase,          0,          EGL_SUCCESS },

   200         { ECreateSurfaceCase,       0,          EGL_SUCCESS, 0, EStandardSurface },

   201         { EFinishedCase }

   202     },

   203     1000, EOnErrorPolicyBreak,

   204     { PARAM_DECL_TABLE(KImageTable) },

   205     {

   206         { ECreateEndpointCase,      0,          EGL_SUCCESS, 0 },

   207         { EDrawContentCase,         0,          EGL_SUCCESS, 0, PARAM0(0)},

   208         { EContentUpdateCase,       0,          EGL_SUCCESS, 0 },

   209         { EBeginStreamingCase,      0,          EGL_SUCCESS, 0 },

   210         { EAcquireImageCase,        0,          EGL_SUCCESS, 0 },

   211         { ECompareImageCase,        0,          EGL_SUCCESS, 0, PARAM0(0)},

   212         { EReleaseImageCase,        0,          EGL_SUCCESS, 0 },

   213         { EDestroyEndpointCase,     0,          EGL_SUCCESS, 0 },

   214         { EFinishedCase }

   215     },

   216     1, EOnErrorPolicyFail,

   217     { NO_PARAMS },

   218     {

   219         { ETerminateCase,           0,          EGL_SUCCESS },

   220         { EFinishedCase }

   221     },

   222 };

   224 static TStressTestSection test592B[] =

   225 {

   226     1, EOnErrorPolicyFail,

   227     { NO_PARAMS },

   228     {

   229         { EInitializeCase,          0,          EGL_SUCCESS },

   230         { EFinishedCase }

   231     },

   232     1000, EOnErrorPolicyBreak,

   233     { PARAM_DECL_TABLE(KImageTable) },

   234     {

   235         { ECreateSurfaceCase,       0,          EGL_SUCCESS, 0, EStandardSurface },

   236         { ECreateEndpointCase,      0,          EGL_SUCCESS, 0 },

   237         { EDrawContentCase,         0,          EGL_SUCCESS, 0, PARAM0(0)},

   238         { EContentUpdateCase,       0,          EGL_SUCCESS, 0 },

   239         { EBeginStreamingCase,      0,          EGL_SUCCESS, 0 },

   240         { EAcquireImageCase,        0,          EGL_SUCCESS, 0 },

   241         { ECompareImageCase,        0,          EGL_SUCCESS, 0, PARAM0(0) },

   242         { EReleaseImageCase,        0,          EGL_SUCCESS, 0 },

   243         { EDestroyEndpointCase,     0,          EGL_SUCCESS, 0 },

   244         { EDestroySurfaceCase,      0,          EGL_SUCCESS, 0 },

   245         { EFinishedCase }

   246     },

   247     1,  EOnErrorPolicyFail,

   248     { NO_PARAMS },

   249     {

   250         { ETerminateCase,           0,          EGL_SUCCESS },

   251         { EFinishedCase }

   252     },

   253 };

   254 static const TStressTestTable testTable[] =

   255 {

   256 #if 0

   257     {

   258         {

   259         TESTIDS("588A"),

   260         CASETITLE("Functional: Stress: Test 100 surfaces."),

   261         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   262         },

   263         TESTTABLE(test588A)

   264     },

   265     {

   266         {

   267         TESTIDS("588B"),

   268         CASETITLE("Functional: Stress: Test 1000 surfaces, destroy after."),

   269         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   270         },

   271         TESTTABLE(test588B)

   272     },

   273     {

   274         {

   275         TESTIDS("589"),

   276         CASETITLE("Functional: Stress: Test with largest possible surface"),

   277         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   278         },

   279         TESTTABLE(test589)

   280     },

   281 #endif

   282     {

   283         {

   284         TESTIDS("590A"),

   285         CASETITLE("Functional: Stress: Test with 1000 surface updates"),

   286         SurfaceTypes3(ESurfTypeEglWindow, ESurfTypeRaw, ESurfTypeRawSingleBuffered),

   287         },

   288         TESTTABLE(test590A)

   289     },

   290 #if 0

   291     {

   292         {

   293         TESTIDS("590B"),

   294         CASETITLE("Functional: Stress: Test with 260 surfaces"),

   295         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   296         },

   297         TESTTABLE(test590B)

   298     },

   299     {

   300         {

   301         TESTIDS("592A"),

   302         CASETITLE("Functional: Stress: Large number of endpoint creation/destruction"),

   303         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   304         },

   305         TESTTABLE(test592A)

   306     },

   307     {

   308         {

   309         TESTIDS("592B"),

   310         CASETITLE("Functional: Stress: Large number of endpoint creation/destruction"),

   311         SurfaceTypes3(ESurfTypeRaw, ESurfTypeEglWindow, ESurfTypeRawSingleBuffered),

   312         },

   313         TESTTABLE(test592B)

   314     },

   315 #endif

   316 };

   319 CEglTest_TestStep_StressTests::CEglTest_TestStep_StressTests()

   320     {

   321     }

   323 CEglTest_TestStep_StressTests* CEglTest_TestStep_StressTests::New()

   324     {

   325     CEglTest_TestStep_StressTests *self = new CEglTest_TestStep_StressTests;

   327     if (self)

   328         {

   329         self->ConstructL(testTable, sizeof(testTable)/sizeof(testTable[0]));

   330         }

   331     return self;

   332     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--