modules/gles31/functional/es31fShaderStateQueryTests.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 Shader state query tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fShaderStateQueryTests.hpp"
  25 #include "es31fInfoLogQueryShared.hpp"
  26 #include "glsStateQueryUtil.hpp"
  27 #include "tcuTestLog.hpp"
  28 #include "tcuStringTemplate.hpp"
  29 #include "gluShaderProgram.hpp"
  30 #include "gluRenderContext.hpp"
  31 #include "gluCallLogWrapper.hpp"
  32 #include "gluContextInfo.hpp"
  33 #include "gluStrUtil.hpp"
  34 #include "glwFunctions.hpp"
  35 #include "glwEnums.hpp"
  36
  37 namespace deqp
  38 {
  39 namespace gles31
  40 {
  41 namespace Functional
  42 {
  43 namespace
  44 {
  45
  46 static inline std::string brokenShaderSource (const glu::ContextType &contextType)
  47 {
  48         const std::string glslVersionDecl = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(contextType));
  49
  50         return  glslVersionDecl + "\n"
  51                         "broken, this should not compile,\n"
  52                         "{";
  53 }
  54
  55 class BaseTypeCase : public TestCase
  56 {
  57 public:
  58         struct TestTypeInfo
  59         {
  60                 glw::GLenum     glType;
  61                 const char*     declarationStr;
  62                 const char*     accessStr;
  63         };
  64
  65                                                                                 BaseTypeCase            (Context& ctx, const char* name, const char* desc, const char* extension);
  66
  67 private:
  68         IterateResult                                           iterate                         (void);
  69         virtual std::vector<TestTypeInfo>       getInfos                        (void) const = 0;
  70         virtual void                                            checkRequirements       (void) const;
  71
  72         const char* const                                       m_extension;
  73 };
  74
  75 BaseTypeCase::BaseTypeCase (Context& ctx, const char* name, const char* desc, const char* extension)
  76         : TestCase              (ctx, name, desc)
  77         , m_extension   (extension)
  78 {
  79 }
  80
  81 BaseTypeCase::IterateResult BaseTypeCase::iterate (void)
  82 {
  83         static const char* const        vertexSourceTemplate    =       "${VERSIONDECL}\n"
  84                                                                                                                         "in highp vec4 a_position;\n"
  85                                                                                                                         "void main(void)\n"
  86                                                                                                                         "{\n"
  87                                                                                                                         "       gl_Position = a_position;\n"
  88                                                                                                                         "}\n";
  89         static const char* const        fragmentSourceTemplate  =       "${VERSIONDECL}\n"
  90                                                                                                                         "${EXTENSIONSTATEMENT}"
  91                                                                                                                         "${DECLARATIONSTR};\n"
  92                                                                                                                         "layout(location = 0) out highp vec4 dEQP_FragColor;\n"
  93                                                                                                                         "void main(void)\n"
  94                                                                                                                         "{\n"
  95                                                                                                                         "       dEQP_FragColor = vec4(${ACCESSSTR});\n"
  96                                                                                                                         "}\n";
  97
  98         tcu::ResultCollector            result                  (m_testCtx.getLog());
  99         std::vector<TestTypeInfo>       samplerTypes    = getInfos();
 100         const bool                                      supportsES32    = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
 101
 102         if (m_extension && !m_context.getContextInfo().isExtensionSupported(m_extension) && !supportsES32)
 103                 throw tcu::NotSupportedError("Test requires " + std::string(m_extension));
 104         checkRequirements();
 105
 106         for (int typeNdx = 0; typeNdx < (int)samplerTypes.size(); ++typeNdx)
 107         {
 108                 const tcu::ScopedLogSection                     section (m_testCtx.getLog(),
 109                                                                                                          std::string(glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType).toString()),
 110                                                                                                          "Uniform type " + glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType).toString());
 111
 112                 std::map<std::string, std::string>      shaderArgs;
 113                 shaderArgs["DECLARATIONSTR"]            = samplerTypes[typeNdx].declarationStr;
 114                 shaderArgs["ACCESSSTR"]                         = samplerTypes[typeNdx].accessStr;
 115                 shaderArgs["EXTENSIONSTATEMENT"]        = (m_extension && !supportsES32) ? (std::string() + "#extension " + m_extension + " : require\n") : ("");
 116                 shaderArgs["VERSIONDECL"]                       = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType()));
 117
 118                 const std::string                                       fragmentSource  = tcu::StringTemplate(fragmentSourceTemplate).specialize(shaderArgs);
 119                 const std::string                                       vertexSource    = tcu::StringTemplate(vertexSourceTemplate).specialize(shaderArgs);
 120                 const glw::Functions&                           gl                              = m_context.getRenderContext().getFunctions();
 121                 glu::ShaderProgram                                      program                 (m_context.getRenderContext(), glu::ProgramSources() << glu::VertexSource(vertexSource) << glu::FragmentSource(fragmentSource));
 122
 123                 m_testCtx.getLog() << tcu::TestLog::Message << "Building program with uniform sampler of type " << glu::getShaderVarTypeStr(samplerTypes[typeNdx].glType) << tcu::TestLog::EndMessage;
 124
 125                 if (!program.isOk())
 126                 {
 127                         m_testCtx.getLog() << program;
 128                         result.fail("could not build shader");
 129                 }
 130                 else
 131                 {
 132                         // only one uniform -- uniform at index 0
 133                         int uniforms = 0;
 134                         gl.getProgramiv(program.getProgram(), GL_ACTIVE_UNIFORMS, &uniforms);
 135
 136                         if (uniforms != 1)
 137                                 result.fail("Unexpected GL_ACTIVE_UNIFORMS, expected 1");
 138                         else
 139                         {
 140                                 // check type
 141                                 const glw::GLuint       uniformIndex    = 0;
 142                                 glw::GLint                      type                    = 0;
 143
 144                                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying uniform type." << tcu::TestLog::EndMessage;
 145                                 gl.getActiveUniformsiv(program.getProgram(), 1, &uniformIndex, GL_UNIFORM_TYPE, &type);
 146
 147                                 if (type != (glw::GLint)samplerTypes[typeNdx].glType)
 148                                 {
 149                                         std::ostringstream buf;
 150                                         buf << "Invalid type, expected " << samplerTypes[typeNdx].glType << ", got " << type;
 151                                         result.fail(buf.str());
 152                                 }
 153                         }
 154                 }
 155
 156                 GLU_EXPECT_NO_ERROR(gl.getError(), "");
 157         }
 158
 159         result.setTestContextResult(m_testCtx);
 160         return STOP;
 161 }
 162
 163 void BaseTypeCase::checkRequirements (void) const
 164 {
 165 }
 166
 167 class CoreSamplerTypeCase : public BaseTypeCase
 168 {
 169 public:
 170                                                                 CoreSamplerTypeCase     (Context& ctx, const char* name, const char* desc);
 171
 172 private:
 173         std::vector<TestTypeInfo>       getInfos                        (void) const;
 174 };
 175
 176 CoreSamplerTypeCase::CoreSamplerTypeCase (Context& ctx, const char* name, const char* desc)
 177         : BaseTypeCase(ctx, name, desc, DE_NULL)
 178 {
 179 }
 180
 181 std::vector<BaseTypeCase::TestTypeInfo> CoreSamplerTypeCase::getInfos (void) const
 182 {
 183         static const TestTypeInfo samplerTypes[] =
 184         {
 185                 { GL_SAMPLER_2D_MULTISAMPLE,                            "uniform highp sampler2DMS u_sampler",  "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
 186                 { GL_INT_SAMPLER_2D_MULTISAMPLE,                        "uniform highp isampler2DMS u_sampler", "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
 187                 { GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE,       "uniform highp usampler2DMS u_sampler", "texelFetch(u_sampler, ivec2(gl_FragCoord.xy), 0)" },
 188         };
 189
 190         std::vector<TestTypeInfo> infos;
 191         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 192                 infos.push_back(samplerTypes[ndx]);
 193
 194         return infos;
 195 }
 196
 197 class MSArraySamplerTypeCase : public BaseTypeCase
 198 {
 199 public:
 200                                                                 MSArraySamplerTypeCase  (Context& ctx, const char* name, const char* desc);
 201
 202 private:
 203         std::vector<TestTypeInfo>       getInfos                                (void) const;
 204 };
 205
 206 MSArraySamplerTypeCase::MSArraySamplerTypeCase (Context& ctx, const char* name, const char* desc)
 207         : BaseTypeCase(ctx, name, desc, "GL_OES_texture_storage_multisample_2d_array")
 208 {
 209 }
 210
 211 std::vector<BaseTypeCase::TestTypeInfo> MSArraySamplerTypeCase::getInfos (void) const
 212 {
 213         static const TestTypeInfo samplerTypes[] =
 214         {
 215                 { GL_SAMPLER_2D_MULTISAMPLE_ARRAY,                              "uniform highp sampler2DMSArray u_sampler",             "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
 216                 { GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,                  "uniform highp isampler2DMSArray u_sampler",    "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
 217                 { GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, "uniform highp usampler2DMSArray u_sampler",    "texelFetch(u_sampler, ivec3(gl_FragCoord.xyz), 0)" },
 218         };
 219
 220         std::vector<TestTypeInfo> infos;
 221         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 222                 infos.push_back(samplerTypes[ndx]);
 223
 224         return infos;
 225 }
 226
 227 class TextureBufferSamplerTypeCase : public BaseTypeCase
 228 {
 229 public:
 230                                                                 TextureBufferSamplerTypeCase    (Context& ctx, const char* name, const char* desc);
 231
 232 private:
 233         std::vector<TestTypeInfo>       getInfos                                                (void) const;
 234 };
 235
 236 TextureBufferSamplerTypeCase::TextureBufferSamplerTypeCase (Context& ctx, const char* name, const char* desc)
 237         : BaseTypeCase(ctx, name, desc, "GL_EXT_texture_buffer")
 238 {
 239 }
 240
 241 std::vector<BaseTypeCase::TestTypeInfo> TextureBufferSamplerTypeCase::getInfos (void) const
 242 {
 243         static const TestTypeInfo samplerTypes[] =
 244         {
 245                 { GL_SAMPLER_BUFFER,                            "uniform highp samplerBuffer u_sampler",        "texelFetch(u_sampler, int(gl_FragCoord.x))" },
 246                 { GL_INT_SAMPLER_BUFFER,                        "uniform highp isamplerBuffer u_sampler",       "texelFetch(u_sampler, int(gl_FragCoord.x))" },
 247                 { GL_UNSIGNED_INT_SAMPLER_BUFFER,       "uniform highp usamplerBuffer u_sampler",       "texelFetch(u_sampler, int(gl_FragCoord.x))" },
 248         };
 249
 250         std::vector<TestTypeInfo> infos;
 251         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 252                 infos.push_back(samplerTypes[ndx]);
 253
 254         return infos;
 255 }
 256
 257 class TextureBufferImageTypeCase : public BaseTypeCase
 258 {
 259 public:
 260                                                                 TextureBufferImageTypeCase      (Context& ctx, const char* name, const char* desc);
 261
 262 private:
 263         std::vector<TestTypeInfo>       getInfos                                        (void) const;
 264         void                                            checkRequirements                       (void) const;
 265 };
 266
 267 TextureBufferImageTypeCase::TextureBufferImageTypeCase (Context& ctx, const char* name, const char* desc)
 268         : BaseTypeCase(ctx, name, desc, "GL_EXT_texture_buffer")
 269 {
 270 }
 271
 272 std::vector<BaseTypeCase::TestTypeInfo> TextureBufferImageTypeCase::getInfos (void) const
 273 {
 274         static const TestTypeInfo samplerTypes[] =
 275         {
 276                 { GL_IMAGE_BUFFER,                              "layout(binding=0, rgba8) readonly uniform highp imageBuffer u_image",  "imageLoad(u_image, int(gl_FragCoord.x))" },
 277                 { GL_INT_IMAGE_BUFFER,                  "layout(binding=0, r32i) readonly uniform highp iimageBuffer u_image",  "imageLoad(u_image, int(gl_FragCoord.x))" },
 278                 { GL_UNSIGNED_INT_IMAGE_BUFFER, "layout(binding=0, r32ui) readonly uniform highp uimageBuffer u_image", "imageLoad(u_image, int(gl_FragCoord.x))" },
 279         };
 280
 281         std::vector<TestTypeInfo> infos;
 282         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 283                 infos.push_back(samplerTypes[ndx]);
 284
 285         return infos;
 286 }
 287
 288 void TextureBufferImageTypeCase::checkRequirements (void) const
 289 {
 290         if (m_context.getContextInfo().getInt(GL_MAX_FRAGMENT_IMAGE_UNIFORMS) < 1)
 291                 throw tcu::NotSupportedError("Test requires fragment images");
 292 }
 293
 294 class CubeArraySamplerTypeCase : public BaseTypeCase
 295 {
 296 public:
 297                                                                 CubeArraySamplerTypeCase        (Context& ctx, const char* name, const char* desc);
 298
 299 private:
 300         std::vector<TestTypeInfo>       getInfos                                                (void) const;
 301 };
 302
 303 CubeArraySamplerTypeCase::CubeArraySamplerTypeCase (Context& ctx, const char* name, const char* desc)
 304         : BaseTypeCase(ctx, name, desc, "GL_EXT_texture_cube_map_array")
 305 {
 306 }
 307
 308 std::vector<BaseTypeCase::TestTypeInfo> CubeArraySamplerTypeCase::getInfos (void) const
 309 {
 310         static const TestTypeInfo samplerTypes[] =
 311         {
 312                 { GL_SAMPLER_CUBE_MAP_ARRAY,                            "uniform highp samplerCubeArray u_sampler",                     "texture(u_sampler, gl_FragCoord.xxyz)"                 },
 313                 { GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW,                     "uniform highp samplerCubeArrayShadow u_sampler",       "texture(u_sampler, gl_FragCoord.xxyz, 0.5)"    },
 314                 { GL_INT_SAMPLER_CUBE_MAP_ARRAY,                        "uniform highp isamplerCubeArray u_sampler",            "texture(u_sampler, gl_FragCoord.xxyz)"                 },
 315                 { GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY,       "uniform highp usamplerCubeArray u_sampler",            "texture(u_sampler, gl_FragCoord.xxyz)"                 },
 316         };
 317
 318         std::vector<TestTypeInfo> infos;
 319         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 320                 infos.push_back(samplerTypes[ndx]);
 321
 322         return infos;
 323 }
 324
 325 class CubeArrayImageTypeCase : public BaseTypeCase
 326 {
 327 public:
 328                                                                 CubeArrayImageTypeCase  (Context& ctx, const char* name, const char* desc);
 329
 330 private:
 331         std::vector<TestTypeInfo>       getInfos                                (void) const;
 332         void                                            checkRequirements               (void) const;
 333 };
 334
 335 CubeArrayImageTypeCase::CubeArrayImageTypeCase (Context& ctx, const char* name, const char* desc)
 336         : BaseTypeCase(ctx, name, desc, "GL_EXT_texture_cube_map_array")
 337 {
 338 }
 339
 340 std::vector<BaseTypeCase::TestTypeInfo> CubeArrayImageTypeCase::getInfos (void) const
 341 {
 342         static const TestTypeInfo samplerTypes[] =
 343         {
 344                 { GL_IMAGE_CUBE_MAP_ARRAY,                              "layout(binding=0, rgba8) readonly uniform highp imageCubeArray u_image",       "imageLoad(u_image, ivec3(gl_FragCoord.xyx))"   },
 345                 { GL_INT_IMAGE_CUBE_MAP_ARRAY,                  "layout(binding=0, r32i) readonly uniform highp iimageCubeArray u_image",       "imageLoad(u_image, ivec3(gl_FragCoord.xyx))"   },
 346                 { GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY, "layout(binding=0, r32ui) readonly uniform highp uimageCubeArray u_image",      "imageLoad(u_image, ivec3(gl_FragCoord.xyx))"   },
 347         };
 348
 349         std::vector<TestTypeInfo> infos;
 350         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(samplerTypes); ++ndx)
 351                 infos.push_back(samplerTypes[ndx]);
 352
 353         return infos;
 354 }
 355
 356 void CubeArrayImageTypeCase::checkRequirements (void) const
 357 {
 358         if (m_context.getContextInfo().getInt(GL_MAX_FRAGMENT_IMAGE_UNIFORMS) < 1)
 359                 throw tcu::NotSupportedError("Test requires fragment images");
 360 }
 361
 362 class ShaderLogCase : public TestCase
 363 {
 364 public:
 365                                                         ShaderLogCase   (Context& ctx, const char* name, const char* desc, glu::ShaderType shaderType);
 366
 367 private:
 368         void                                    init                    (void);
 369         IterateResult                   iterate                 (void);
 370
 371         const glu::ShaderType   m_shaderType;
 372 };
 373
 374 ShaderLogCase::ShaderLogCase (Context& ctx, const char* name, const char* desc, glu::ShaderType shaderType)
 375         : TestCase              (ctx, name, desc)
 376         , m_shaderType  (shaderType)
 377 {
 378 }
 379
 380 void ShaderLogCase::init (void)
 381 {
 382         const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
 383
 384         switch (m_shaderType)
 385         {
 386                 case glu::SHADERTYPE_VERTEX:
 387                 case glu::SHADERTYPE_FRAGMENT:
 388                 case glu::SHADERTYPE_COMPUTE:
 389                         break;
 390
 391                 case glu::SHADERTYPE_GEOMETRY:
 392                         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader") && !supportsES32)
 393                                 throw tcu::NotSupportedError("Test requires GL_EXT_geometry_shader extension or an OpenGL ES 3.2 or higher context.");
 394                         break;
 395
 396                 case glu::SHADERTYPE_TESSELLATION_CONTROL:
 397                 case glu::SHADERTYPE_TESSELLATION_EVALUATION:
 398                         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") && !supportsES32)
 399                                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader extension or an OpenGL ES 3.2 or higher context.");
 400                         break;
 401
 402                 default:
 403                         DE_ASSERT(false);
 404                         break;
 405         }
 406 }
 407
 408 ShaderLogCase::IterateResult ShaderLogCase::iterate (void)
 409 {
 410         using gls::StateQueryUtil::StateQueryMemoryWriteGuard;
 411
 412         tcu::ResultCollector                                    result                  (m_testCtx.getLog());
 413         glu::CallLogWrapper                                             gl                              (m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
 414         deUint32                                                                shader                  = 0;
 415         const std::string                                               source                  = brokenShaderSource(m_context.getRenderContext().getType());
 416         const char* const                                               brokenSource    = source.c_str();
 417         StateQueryMemoryWriteGuard<glw::GLint>  logLen;
 418
 419         gl.enableLogging(true);
 420
 421         m_testCtx.getLog() << tcu::TestLog::Message << "Trying to compile broken shader source." << tcu::TestLog::EndMessage;
 422
 423         shader = gl.glCreateShader(glu::getGLShaderType(m_shaderType));
 424         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "create shader");
 425
 426         gl.glShaderSource(shader, 1, &brokenSource, DE_NULL);
 427         gl.glCompileShader(shader);
 428         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "compile");
 429
 430         gl.glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &logLen);
 431         logLen.verifyValidity(result);
 432
 433         if (!logLen.isUndefined())
 434                 verifyInfoLogQuery(result, gl, logLen, shader, &glu::CallLogWrapper::glGetShaderInfoLog, "glGetShaderInfoLog");
 435
 436         gl.glDeleteShader(shader);
 437         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "delete");
 438
 439         result.setTestContextResult(m_testCtx);
 440         return STOP;
 441 }
 442
 443 } // anonymous
 444
 445 ShaderStateQueryTests::ShaderStateQueryTests (Context& context)
 446         : TestCaseGroup(context, "shader", "Shader state query tests")
 447 {
 448 }
 449
 450 ShaderStateQueryTests::~ShaderStateQueryTests (void)
 451 {
 452 }
 453
 454 void ShaderStateQueryTests::init (void)
 455 {
 456         addChild(new CoreSamplerTypeCase                        (m_context, "sampler_type",                                             "Sampler type cases"));
 457         addChild(new MSArraySamplerTypeCase                     (m_context, "sampler_type_multisample_array",   "MSAA array sampler type cases"));
 458         addChild(new TextureBufferSamplerTypeCase       (m_context, "sampler_type_texture_buffer",              "Texture buffer sampler type cases"));
 459         addChild(new TextureBufferImageTypeCase         (m_context, "image_type_texture_buffer",                "Texture buffer image type cases"));
 460         addChild(new CubeArraySamplerTypeCase           (m_context, "sampler_type_cube_array",                  "Cube array sampler type cases"));
 461         addChild(new CubeArrayImageTypeCase                     (m_context, "image_type_cube_array",                    "Cube array image type cases"));
 462
 463         // shader info log tests
 464         // \note, there exists similar tests in gles3 module. However, the gles31 could use a different
 465         //        shader compiler with different INFO_LOG bugs.
 466         {
 467                 static const struct
 468                 {
 469                         const char*             caseName;
 470                         glu::ShaderType caseType;
 471                 } shaderTypes[] =
 472                 {
 473                         { "info_log_vertex",            glu::SHADERTYPE_VERTEX                                  },
 474                         { "info_log_fragment",          glu::SHADERTYPE_FRAGMENT                                },
 475                         { "info_log_geometry",          glu::SHADERTYPE_GEOMETRY                                },
 476                         { "info_log_tess_ctrl",         glu::SHADERTYPE_TESSELLATION_CONTROL    },
 477                         { "info_log_tess_eval",         glu::SHADERTYPE_TESSELLATION_EVALUATION },
 478                         { "info_log_compute",           glu::SHADERTYPE_COMPUTE                                 },
 479                 };
 480
 481                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(shaderTypes); ++ndx)
 482                         addChild(new ShaderLogCase(m_context, shaderTypes[ndx].caseName, "", shaderTypes[ndx].caseType));
 483         }
 484 }
 485
 486 } // Functional
 487 } // gles31
 488 } // deqp