modules/gles31/functional/es31fFunctionalTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Functional Tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fFunctionalTests.hpp"
  25
  26 #include "glsShaderLibrary.hpp"
  27 #include "es31fBasicComputeShaderTests.hpp"
  28 #include "es31fComputeShaderBuiltinVarTests.hpp"
  29 #include "es31fDrawTests.hpp"
  30 #include "es31fShaderSharedVarTests.hpp"
  31 #include "es31fAtomicCounterTests.hpp"
  32 #include "es31fShaderAtomicOpTests.hpp"
  33 #include "es31fShaderImageLoadStoreTests.hpp"
  34 #include "es31fTessellationTests.hpp"
  35 #include "es31fSSBOLayoutTests.hpp"
  36 #include "es31fSSBOArrayLengthTests.hpp"
  37 #include "es31fShaderCommonFunctionTests.hpp"
  38 #include "es31fShaderPackingFunctionTests.hpp"
  39 #include "es31fShaderIntegerFunctionTests.hpp"
  40 #include "es31fStencilTexturingTests.hpp"
  41 #include "es31fShaderTextureSizeTests.hpp"
  42 #include "es31fShaderStateQueryTests.hpp"
  43 #include "es31fLayoutBindingTests.hpp"
  44 #include "es31fTextureLevelStateQueryTests.hpp"
  45 #include "es31fIntegerStateQueryTests.hpp"
  46 #include "es31fInternalFormatQueryTests.hpp"
  47 #include "es31fBooleanStateQueryTests.hpp"
  48 #include "es31fIndexedStateQueryTests.hpp"
  49 #include "es31fTextureStateQueryTests.hpp"
  50 #include "es31fFramebufferDefaultStateQueryTests.hpp"
  51 #include "es31fProgramPipelineStateQueryTests.hpp"
  52 #include "es31fProgramStateQueryTests.hpp"
  53 #include "es31fSamplerStateQueryTests.hpp"
  54 #include "es31fTextureFilteringTests.hpp"
  55 #include "es31fTextureFormatTests.hpp"
  56 #include "es31fTextureSpecificationTests.hpp"
  57 #include "es31fTextureMultisampleTests.hpp"
  58 #include "es31fMultisampleTests.hpp"
  59 #include "es31fSynchronizationTests.hpp"
  60 #include "es31fGeometryShaderTests.hpp"
  61 #include "es31fSampleShadingTests.hpp"
  62 #include "es31fSampleVariableTests.hpp"
  63 #include "es31fIndirectComputeDispatchTests.hpp"
  64 #include "es31fVertexAttributeBindingTests.hpp"
  65 #include "es31fVertexAttributeBindingStateQueryTests.hpp"
  66 #include "es31fShaderMultisampleInterpolationTests.hpp"
  67 #include "es31fShaderMultisampleInterpolationStateQueryTests.hpp"
  68 #include "es31fProgramUniformTests.hpp"
  69 #include "es31fOpaqueTypeIndexingTests.hpp"
  70 #include "es31fAdvancedBlendTests.hpp"
  71 #include "es31fSeparateShaderTests.hpp"
  72 #include "es31fUniformLocationTests.hpp"
  73 #include "es31fBuiltinPrecisionTests.hpp"
  74 #include "es31fTessellationGeometryInteractionTests.hpp"
  75 #include "es31fUniformBlockTests.hpp"
  76 #include "es31fDebugTests.hpp"
  77 #include "es31fFboColorbufferTests.hpp"
  78 #include "es31fFboNoAttachmentTests.hpp"
  79 #include "es31fFboSRGBWriteControlTests.hpp"
  80 #include "es31fProgramInterfaceQueryTests.hpp"
  81 #include "es31fTextureGatherTests.hpp"
  82 #include "es31fTextureFormatTests.hpp"
  83 #include "es31fTextureBufferTests.hpp"
  84 #include "es31fTextureBorderClampTests.hpp"
  85 #include "es31fShaderBuiltinConstantTests.hpp"
  86 #include "es31fShaderHelperInvocationTests.hpp"
  87 #include "es31fPrimitiveBoundingBoxTests.hpp"
  88 #include "es31fAndroidExtensionPackES31ATests.hpp"
  89 #include "es31fCopyImageTests.hpp"
  90 #include "es31fDefaultVertexArrayObjectTests.hpp"
  91 #include "es31fSRGBDecodeTests.hpp"
  92 #include "es31fDrawElementsBaseVertexTests.hpp"
  93 #include "es31fShaderFramebufferFetchTests.hpp"
  94 #include "es31fShaderUniformIntegerFunctionTests.hpp"
  95
  96 namespace deqp
  97 {
  98 namespace gles31
  99 {
 100 namespace Functional
 101 {
 102
 103 class ShaderLibraryTest : public TestCaseGroup
 104 {
 105 public:
 106         ShaderLibraryTest (Context& context, const char* filename, const char* name, const char* description)
 107                 : TestCaseGroup (context, name, description)
 108                 , m_filename    (filename)
 109         {
 110         }
 111
 112         void init (void)
 113         {
 114                 gls::ShaderLibrary                      shaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
 115                 std::string                                     fileName        = m_filename;
 116                 std::vector<tcu::TestNode*>     children        = shaderLibrary.loadShaderFile(fileName.c_str());
 117
 118                 for (int i = 0; i < (int)children.size(); i++)
 119                         addChild(children[i]);
 120         }
 121
 122 private:
 123         const std::string m_filename;
 124 };
 125
 126 class ShaderLibraryGroup : public TestCaseGroup
 127 {
 128 public:
 129         struct File
 130         {
 131                 const char*             fileName;
 132                 const char*             testName;
 133                 const char*             description;
 134         };
 135
 136         ShaderLibraryGroup (Context& context, const char* name, const char* description, int numFiles, const File* files)
 137                 : TestCaseGroup (context, name, description)
 138                 , m_numFiles    (numFiles)
 139                 , m_files               (files)
 140         {}
 141
 142         void init (void)
 143         {
 144                 for (int ndx = 0; ndx < m_numFiles; ++ndx)
 145                         addChild(new ShaderLibraryTest(m_context, m_files[ndx].fileName, m_files[ndx].testName, m_files[ndx].description));
 146         }
 147
 148 private:
 149         const int                       m_numFiles;
 150         const File* const       m_files;
 151 };
 152
 153 class ShaderBuiltinVarTests : public TestCaseGroup
 154 {
 155 public:
 156         ShaderBuiltinVarTests (Context& context)
 157                 : TestCaseGroup(context, "builtin_var", "Shader Built-in Variable Tests")
 158         {
 159         }
 160
 161         void init (void)
 162         {
 163                 addChild(new ComputeShaderBuiltinVarTests(m_context));
 164         }
 165 };
 166
 167 class ShaderBuiltinFunctionTests : public TestCaseGroup
 168 {
 169 public:
 170         ShaderBuiltinFunctionTests (Context& context)
 171                 : TestCaseGroup(context, "builtin_functions", "Built-in Function Tests")
 172         {
 173         }
 174
 175         void init (void)
 176         {
 177                 addChild(new ShaderCommonFunctionTests                  (m_context));
 178                 addChild(new ShaderPackingFunctionTests                 (m_context));
 179                 addChild(new ShaderIntegerFunctionTests                 (m_context));
 180                 addChild(new ShaderUniformIntegerFunctionTests  (m_context));
 181                 addChild(new ShaderTextureSizeTests                             (m_context));
 182                 addChild(createBuiltinPrecisionTests                    (m_context));
 183         }
 184 };
 185
 186 class ShaderLinkageTests : public TestCaseGroup
 187 {
 188 public:
 189         ShaderLinkageTests (Context& context, bool isGL45)
 190                 : TestCaseGroup(context,  "linkage", "Linkage Tests")
 191                 , m_isGL45(isGL45)
 192         {
 193         }
 194
 195 private:
 196         bool m_isGL45;
 197
 198         void init (void)
 199         {
 200                 static const ShaderLibraryGroup::File   s_filesES31[]   =
 201                 {
 202                         { "shaders/es31/declarations.test",                                             "declarations",                         "Declarations"                                          },
 203                         { "shaders/es31/linkage_geometry.test",                                 "geometry",                                     "Geometry shader"                                       },
 204                         { "shaders/es31/linkage_tessellation.test",                             "tessellation",                         "Tessellation shader"                           },
 205                         { "shaders/es31/linkage_tessellation_geometry.test",    "tessellation_geometry",        "Tessellation and geometry shader"      },
 206                         { "shaders/es31/linkage_shader_storage_block.test",             "shader_storage_block",         "Shader storage blocks"                         },
 207                         { "shaders/es31/linkage_io_block.test",                                 "io_block",                                     "Shader io blocks"                                      },
 208                         { "shaders/es31/linkage_uniform.test",                                  "uniform",                                      "Uniform linkage"                                       },
 209                 };
 210                 static const ShaderLibraryGroup::File   s_filesES32[]   =
 211                 {
 212                         { "shaders/es32/linkage_geometry.test",                                 "geometry",                                     "Geometry shader"                                       },
 213                         { "shaders/es32/linkage_tessellation.test",                             "tessellation",                         "Tessellation shader"                           },
 214                         { "shaders/es32/linkage_tessellation_geometry.test",    "tessellation_geometry",        "Tessellation and geometry shader"      },
 215                         { "shaders/es32/linkage_shader_storage_block.test",             "shader_storage_block",         "Shader storage blocks"                         },
 216                         { "shaders/es32/linkage_io_block.test",                                 "io_block",                                     "Shader io blocks"                                      },
 217                         { "shaders/es32/linkage_uniform.test",                                  "uniform",                                      "Uniform linkage"                                       },
 218                 };
 219                 static const ShaderLibraryGroup::File   s_filesGL45[]   =
 220                 {
 221                         { "shaders/gl45/linkage_geometry.test",                                 "geometry",                                     "Geometry shader"                                       },
 222                         { "shaders/gl45/linkage_tessellation.test",                             "tessellation",                         "Tessellation shader"                           },
 223                         { "shaders/gl45/linkage_tessellation_geometry.test",    "tessellation_geometry",        "Tessellation and geometry shader"      },
 224                         { "shaders/gl45/linkage_shader_storage_block.test",             "shader_storage_block",         "Shader storage blocks"                         },
 225                         { "shaders/gl45/linkage_io_block.test",                                 "io_block",                                     "Shader io blocks"                                      },
 226                         { "shaders/gl45/linkage_uniform.test",                                  "uniform",                                      "Uniform linkage"                                       },
 227                 };
 228
 229                 if (m_isGL45)
 230                         addChild(new ShaderLibraryGroup(m_context,      "gl45",         "GL 4.5 Linkage",               DE_LENGTH_OF_ARRAY(s_filesGL45), s_filesGL45));
 231                 else
 232                 {
 233                         addChild(new ShaderLibraryGroup(m_context,      "es31",         "GLSL ES 3.1 Linkage",  DE_LENGTH_OF_ARRAY(s_filesES31), s_filesES31));
 234                         addChild(new ShaderLibraryGroup(m_context,      "es32",         "GLSL ES 3.2 Linkage",  DE_LENGTH_OF_ARRAY(s_filesES32), s_filesES32));
 235                 }
 236         }
 237 };
 238
 239 class ShaderTests : public TestCaseGroup
 240 {
 241 public:
 242         ShaderTests (Context& context, bool isGL45)
 243                 : TestCaseGroup(context, "shaders", "Shading Language Tests")
 244                 , m_isGL45(isGL45)
 245         {
 246         }
 247
 248 private:
 249         bool m_isGL45;
 250
 251         void init (void)
 252         {
 253                 addChild(new ShaderBuiltinVarTests                              (m_context));
 254                 addChild(new ShaderBuiltinFunctionTests                 (m_context));
 255                 addChild(new SampleVariableTests                                (m_context));
 256                 addChild(new ShaderMultisampleInterpolationTests(m_context));
 257                 addChild(new OpaqueTypeIndexingTests                    (m_context));
 258
 259                 {
 260                         static const ShaderLibraryGroup::File s_functionFiles[] =
 261                         {
 262                                 { "shaders/es31/functions.test",        "es31",         "GLSL ES 3.1 Function Tests"    },
 263                                 { "shaders/es32/functions.test",        "es32",         "GLSL ES 3.2 Function Tests"    },
 264                         };
 265                         addChild(new ShaderLibraryGroup(m_context, "functions", "Function Tests", DE_LENGTH_OF_ARRAY(s_functionFiles), s_functionFiles));
 266                 }
 267
 268                 {
 269                         static const ShaderLibraryGroup::File s_arraysFiles[] =
 270                         {
 271                                 { "shaders/es31/arrays.test",   "es31",         "GLSL ES 3.1 Array Tests"       },
 272                                 { "shaders/es32/arrays.test",   "es32",         "GLSL ES 3.2 Array Tests"       },
 273                         };
 274                         addChild(new ShaderLibraryGroup(m_context, "arrays", "Array Tests", DE_LENGTH_OF_ARRAY(s_arraysFiles), s_arraysFiles));
 275                 }
 276
 277                 {
 278                         static const ShaderLibraryGroup::File s_arraysOfArraysFilesES[] =
 279                         {
 280                                 { "shaders/es31/arrays_of_arrays.test",         "es31",         "GLSL ES 3.1 Arrays of Arrays Tests"    },
 281                                 { "shaders/es32/arrays_of_arrays.test",         "es32",         "GLSL ES 3.2 Arrays of Arrays Tests"    },
 282                         };
 283
 284                         static const ShaderLibraryGroup::File s_arraysOfArraysFilesGL[] =
 285                         {
 286                                 { "shaders/gl45/arrays_of_arrays.test",         "gl45",         "GLSL 4.5 Arrays of Arrays Tests"               },
 287                         };
 288                         if (m_isGL45)
 289                                 addChild(new ShaderLibraryGroup(m_context, "arrays_of_arrays", "Arrays of Arras Tests", DE_LENGTH_OF_ARRAY(s_arraysOfArraysFilesGL), s_arraysOfArraysFilesGL));
 290                         else
 291                                 addChild(new ShaderLibraryGroup(m_context, "arrays_of_arrays", "Arrays of Arras Tests", DE_LENGTH_OF_ARRAY(s_arraysOfArraysFilesES), s_arraysOfArraysFilesES));
 292                 }
 293
 294                 addChild(new ShaderLinkageTests                                 (m_context, m_isGL45));
 295                 addChild(new ShaderBuiltinConstantTests                 (m_context));
 296                 addChild(new ShaderHelperInvocationTests                (m_context));
 297
 298                 {
 299                         static const ShaderLibraryGroup::File s_implicitConversionsFilesES[] =
 300                         {
 301                                 { "shaders/es31/implicit_conversions.test",             "es31",         "GLSL ES 3.1 GL_EXT_shader_implicit_conversions Tests"  },
 302                                 { "shaders/es32/implicit_conversions.test",             "es32",         "GLSL ES 3.2 GL_EXT_shader_implicit_conversions Tests"  },
 303                         };
 304                         static const ShaderLibraryGroup::File s_implicitConversionsFilesGL[] =
 305                         {
 306                                 { "shaders/gl45/implicit_conversions.test",             "gl45",         "GL45 implicit conversions Tests" },
 307                         };
 308                         if (m_isGL45)
 309                                 addChild(new ShaderLibraryGroup(m_context, "implicit_conversions", "GL45 implicit conversions Tests", DE_LENGTH_OF_ARRAY(s_implicitConversionsFilesGL), s_implicitConversionsFilesGL));
 310                         else
 311                                 addChild(new ShaderLibraryGroup(m_context, "implicit_conversions", "GL_EXT_shader_implicit_conversions Tests", DE_LENGTH_OF_ARRAY(s_implicitConversionsFilesES), s_implicitConversionsFilesES));
 312                 }
 313
 314                 {
 315                         static const ShaderLibraryGroup::File s_uniformBlockFiles[] =
 316                         {
 317                                 { "shaders/es31/uniform_block.test",    "es31",         "GLSL ES 3.1 Uniform block tests"       },
 318                                 { "shaders/es32/uniform_block.test",    "es32",         "GLSL ES 3.2 Uniform block tests"       },
 319                         };
 320                         addChild(new ShaderLibraryGroup(m_context, "uniform_block", "Uniform block tests", DE_LENGTH_OF_ARRAY(s_uniformBlockFiles), s_uniformBlockFiles));
 321                 }
 322
 323                 addChild(new ShaderFramebufferFetchTests                (m_context));
 324         }
 325 };
 326
 327 class ComputeTests : public TestCaseGroup
 328 {
 329 public:
 330         ComputeTests (Context& context)
 331                 : TestCaseGroup(context, "compute", "Compute Shader Tests")
 332         {
 333         }
 334
 335         void init (void)
 336         {
 337                 addChild(new BasicComputeShaderTests            (m_context));
 338                 addChild(new ShaderSharedVarTests                       (m_context));
 339                 addChild(new IndirectComputeDispatchTests       (m_context));
 340         }
 341 };
 342
 343 class SSBOTests : public TestCaseGroup
 344 {
 345 public:
 346         SSBOTests (Context& context)
 347                 : TestCaseGroup(context, "ssbo", "Shader Storage Buffer Object Tests")
 348         {
 349         }
 350
 351         void init (void)
 352         {
 353                 addChild(new SSBOLayoutTests                    (m_context));
 354                 addChild(new ShaderAtomicOpTests                (m_context, "atomic", ATOMIC_OPERAND_BUFFER_VARIABLE));
 355                 addChild(new SSBOArrayLengthTests               (m_context));
 356         }
 357 };
 358
 359 class TextureTests : public TestCaseGroup
 360 {
 361 public:
 362         TextureTests (Context& context, bool isGL45)
 363                 : TestCaseGroup(context, "texture", "Texture tests")
 364                 , m_isGL45(isGL45)
 365         {
 366         }
 367
 368         void init (void)
 369         {
 370                 addChild(new TextureFilteringTests              (m_context));
 371                 addChild(new TextureFormatTests                 (m_context));
 372                 addChild(new TextureSpecificationTests  (m_context));
 373                 addChild(new TextureMultisampleTests    (m_context));
 374                 addChild(new TextureGatherTests                 (m_context));
 375                 addChild(createTextureBufferTests               (m_context));
 376                 addChild(new TextureBorderClampTests    (m_context, m_isGL45));
 377         }
 378
 379 private:
 380         bool m_isGL45;
 381 };
 382
 383 class StateQueryTests : public TestCaseGroup
 384 {
 385 public:
 386         StateQueryTests (Context& context)
 387                 : TestCaseGroup(context, "state_query", "State query tests")
 388         {
 389         }
 390
 391         void init (void)
 392         {
 393                 addChild(new BooleanStateQueryTests                                                     (m_context));
 394                 addChild(new IntegerStateQueryTests                                                     (m_context));
 395                 addChild(new IndexedStateQueryTests                                                     (m_context));
 396                 addChild(new TextureStateQueryTests                                                     (m_context));
 397                 addChild(new TextureLevelStateQueryTests                                        (m_context));
 398                 addChild(new SamplerStateQueryTests                                                     (m_context));
 399                 addChild(new ShaderStateQueryTests                                                      (m_context));
 400                 addChild(new InternalFormatQueryTests                                           (m_context));
 401                 addChild(new VertexAttributeBindingStateQueryTests                      (m_context));
 402                 addChild(new ShaderMultisampleInterpolationStateQueryTests      (m_context));
 403                 addChild(new FramebufferDefaultStateQueryTests                          (m_context));
 404                 addChild(new ProgramStateQueryTests                                                     (m_context));
 405                 addChild(new ProgramPipelineStateQueryTests                                     (m_context));
 406         }
 407 };
 408
 409 class FboTests : public TestCaseGroup
 410 {
 411 public:
 412         FboTests (Context& context)
 413                 : TestCaseGroup(context, "fbo", "Framebuffer Object Tests")
 414         {
 415         }
 416
 417         void init (void)
 418         {
 419                 addChild(new FboColorTests                                              (m_context));
 420                 addChild(createFboNoAttachmentTests                             (m_context));
 421                 addChild(createFboNoAttachmentCompletenessTests (m_context));
 422                 addChild(new FboSRGBWriteControlTests                   (m_context));
 423         }
 424 };
 425
 426 class SRGBTextureDecodeTests : public TestCaseGroup
 427 {
 428 public:
 429         SRGBTextureDecodeTests (Context& context)
 430                 : TestCaseGroup (context, "srgb_texture_decode", "GL_EXT_texture_sRGB_decode tests")
 431         {
 432         }
 433
 434         void init (void)
 435         {
 436                 addChild(new SRGBDecodeTests    (m_context));
 437         }
 438 };
 439
 440 GLES31FunctionalTests::GLES31FunctionalTests (Context& context)
 441         : TestCaseGroup(context, "functional", "Functionality Tests")
 442 {
 443 }
 444
 445 GLES31FunctionalTests::~GLES31FunctionalTests (void)
 446 {
 447 }
 448
 449 void GLES31FunctionalTests::init (void)
 450 {
 451         addChild(new ShaderTests                                                        (m_context, false));
 452         addChild(new ComputeTests                                                       (m_context));
 453         addChild(new DrawTests                                                          (m_context));
 454         addChild(new TessellationTests                                          (m_context, false));
 455         addChild(new SSBOTests                                                          (m_context));
 456         addChild(new UniformBlockTests                                          (m_context));
 457         addChild(new ShaderImageLoadStoreTests                          (m_context));
 458         addChild(new AtomicCounterTests                                         (m_context));
 459         addChild(new StencilTexturingTests                                      (m_context));
 460         addChild(new TextureTests                                                       (m_context, false));
 461         addChild(new StateQueryTests                                            (m_context));
 462         addChild(new MultisampleTests                                           (m_context));
 463         addChild(new SynchronizationTests                                       (m_context));
 464         addChild(new GeometryShaderTests                                        (m_context, false));
 465         addChild(new SampleShadingTests                                         (m_context));
 466         addChild(new VertexAttributeBindingTests                        (m_context));
 467         addChild(new ProgramUniformTests                                        (m_context));
 468         addChild(new AdvancedBlendTests                                         (m_context));
 469         addChild(createGLESSeparateShaderTests                          (m_context));
 470         addChild(new UniformLocationTests                                       (m_context, false));
 471         addChild(new TessellationGeometryInteractionTests       (m_context, false));
 472         addChild(new DebugTests                                                         (m_context));
 473         addChild(new FboTests                                                           (m_context));
 474         addChild(new ProgramInterfaceQueryTests                         (m_context, false));
 475         addChild(new LayoutBindingTests                                         (m_context));
 476         addChild(new PrimitiveBoundingBoxTests                          (m_context));
 477         addChild(new AndroidExtensionPackES31ATests                     (m_context));
 478         addChild(createCopyImageTests                                           (m_context, false));
 479         addChild(new DefaultVertexArrayObjectTests                      (m_context));
 480         addChild(new SRGBTextureDecodeTests                                     (m_context));
 481         addChild(new DrawElementsBaseVertexTests                        (m_context));
 482 }
 483
 484 GL45ES31FunctionalTests::GL45ES31FunctionalTests (Context& context)
 485         : TestCaseGroup(context, "functional", "Functionality Tests")
 486 {
 487 }
 488
 489 GL45ES31FunctionalTests::~GL45ES31FunctionalTests (void)
 490 {
 491 }
 492
 493 void GL45ES31FunctionalTests::init (void)
 494 {
 495         addChild(new ShaderTests                                                        (m_context, true));
 496         addChild(new ComputeTests                                                       (m_context));
 497         addChild(new DrawTests                                                          (m_context));
 498         addChild(new TessellationTests                                          (m_context, true));
 499         addChild(new SSBOTests                                                          (m_context));
 500         addChild(new UniformBlockTests                                          (m_context));
 501         addChild(new ShaderImageLoadStoreTests                          (m_context));
 502         addChild(new AtomicCounterTests                                         (m_context));
 503         addChild(new StencilTexturingTests                                      (m_context));
 504         addChild(new TextureTests                                                       (m_context, true));
 505         addChild(new StateQueryTests                                            (m_context));
 506         addChild(new MultisampleTests                                           (m_context));
 507         addChild(new SynchronizationTests                                       (m_context));
 508         addChild(new GeometryShaderTests                                        (m_context, true));
 509         addChild(new SampleShadingTests                                         (m_context));
 510         addChild(new VertexAttributeBindingTests                        (m_context));
 511         addChild(new ProgramUniformTests                                        (m_context));
 512         addChild(new AdvancedBlendTests                                         (m_context));
 513         addChild(createCommonSeparateShaderTests                        (m_context));
 514         addChild(new UniformLocationTests                                       (m_context, true));
 515         addChild(new TessellationGeometryInteractionTests       (m_context, true));
 516         addChild(new DebugTests                                                         (m_context));
 517         addChild(new FboTests                                                           (m_context));
 518         addChild(new ProgramInterfaceQueryTests                         (m_context, true));
 519         addChild(new LayoutBindingTests                                         (m_context));
 520         addChild(new PrimitiveBoundingBoxTests                          (m_context));
 521         addChild(createCopyImageTests                                           (m_context, true));
 522         addChild(new SRGBTextureDecodeTests                                     (m_context));
 523         addChild(new DrawElementsBaseVertexTests                        (m_context));
 524 }
 525
 526 } // Functional
 527 } // gles31
 528 } // deqp