modules/gles31/functional/es31fInternalFormatQueryTests.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 Internal format query tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fInternalFormatQueryTests.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "gluRenderContext.hpp"
  27 #include "gluStrUtil.hpp"
  28 #include "gluContextInfo.hpp"
  29 #include "glwFunctions.hpp"
  30 #include "glwEnums.hpp"
  31
  32 namespace deqp
  33 {
  34 namespace gles31
  35 {
  36 namespace Functional
  37 {
  38 namespace
  39 {
  40
  41 class FormatSamplesCase : public TestCase
  42 {
  43 public:
  44         enum FormatType
  45         {
  46                 FORMAT_COLOR,
  47                 FORMAT_INT,
  48                 FORMAT_DEPTH_STENCIL
  49         };
  50
  51                                                 FormatSamplesCase       (Context& ctx, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum internalFormat, FormatType type);
  52 private:
  53         void                            init                            (void);
  54         IterateResult           iterate                         (void);
  55
  56         const glw::GLenum       m_target;
  57         const glw::GLenum       m_internalFormat;
  58         const FormatType        m_type;
  59 };
  60
  61 FormatSamplesCase::FormatSamplesCase (Context& ctx, const char* name, const char* desc, glw::GLenum target, glw::GLenum internalFormat, FormatType type)
  62         : TestCase                      (ctx, name, desc)
  63         , m_target                      (target)
  64         , m_internalFormat      (internalFormat)
  65         , m_type                        (type)
  66 {
  67         DE_ASSERT(m_target == GL_TEXTURE_2D_MULTISAMPLE                 ||
  68                           m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY   ||
  69                           m_target == GL_RENDERBUFFER);
  70 }
  71
  72 void FormatSamplesCase::init (void)
  73 {
  74         const bool isTextureTarget      =       (m_target == GL_TEXTURE_2D_MULTISAMPLE) ||
  75                                                                         (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY);
  76         const bool supportsES32         =       contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
  77
  78         if (!supportsES32 && m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array"))
  79                 TCU_THROW(NotSupportedError, "Test requires OES_texture_storage_multisample_2d_array extension or a context version equal or higher than 3.2");
  80
  81         // stencil8 textures are not supported without GL_OES_texture_stencil8 extension
  82         if (!supportsES32 && isTextureTarget && m_internalFormat == GL_STENCIL_INDEX8 && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_stencil8"))
  83                 TCU_THROW(NotSupportedError, "Test requires GL_OES_texture_stencil8 extension or a context version equal or higher than 3.2");
  84 }
  85
  86 FormatSamplesCase::IterateResult FormatSamplesCase::iterate (void)
  87 {
  88         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
  89         bool                                    isFloatFormat   = false;
  90         bool                                    error                   = false;
  91         glw::GLint                              maxSamples              = 0;
  92         glw::GLint                              numSampleCounts = 0;
  93         const bool                              supportsES32                    = contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
  94
  95         if (!supportsES32)
  96         {
  97                 if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F || m_internalFormat == GL_R16F || m_internalFormat == GL_RG16F || m_internalFormat == GL_R11F_G11F_B10F)
  98                 {
  99                         TCU_THROW(NotSupportedError, "The internal format is not supported in a context lower than 3.2");
 100                 }
 101         }
 102         else if (m_internalFormat == GL_RGBA16F || m_internalFormat == GL_R32F || m_internalFormat == GL_RG32F || m_internalFormat == GL_RGBA32F)
 103         {
 104                 isFloatFormat = true;
 105         }
 106
 107         // Lowest limit
 108         {
 109                 const glw::GLenum samplesEnum = (m_type == FORMAT_COLOR) ? (GL_MAX_COLOR_TEXTURE_SAMPLES) : (m_type == FORMAT_INT) ? (GL_MAX_INTEGER_SAMPLES) : (GL_MAX_DEPTH_TEXTURE_SAMPLES);
 110                 m_testCtx.getLog() << tcu::TestLog::Message << "Format must support sample count of " << glu::getGettableStateStr(samplesEnum) << tcu::TestLog::EndMessage;
 111
 112                 gl.getIntegerv(samplesEnum, &maxSamples);
 113                 GLU_EXPECT_NO_ERROR(gl.getError(), "get MAX_*_SAMPLES");
 114
 115                 m_testCtx.getLog() << tcu::TestLog::Message << glu::getGettableStateStr(samplesEnum) << " = " << maxSamples << tcu::TestLog::EndMessage;
 116
 117                 if (maxSamples < 1)
 118                 {
 119                         m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: minimum value of "  << glu::getGettableStateStr(samplesEnum) << " is 1" << tcu::TestLog::EndMessage;
 120                         error = true;
 121                 }
 122         }
 123
 124         // Number of sample counts
 125         {
 126                 gl.getInternalformativ(m_target, m_internalFormat, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
 127                 GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");
 128
 129                 m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 130
 131                 if (!isFloatFormat)
 132                 {
 133                         if (numSampleCounts < 1)
 134                         {
 135                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 136                                 error = true;
 137                         }
 138                 }
 139         }
 140
 141         // Sample counts
 142         {
 143                 tcu::MessageBuilder             samplesMsg      (&m_testCtx.getLog());
 144                 std::vector<glw::GLint> samples         (numSampleCounts > 0 ? numSampleCounts : 1);
 145
 146                 if (numSampleCounts > 0 || isFloatFormat)
 147                 {
 148                         gl.getInternalformativ(m_target, m_internalFormat, GL_SAMPLES, numSampleCounts, &samples[0]);
 149                         GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
 150                 }
 151                 else
 152                         TCU_FAIL("glGetInternalFormativ() reported 0 supported sample counts");
 153
 154                 // make a pretty log
 155
 156                 samplesMsg << "GL_SAMPLES = [";
 157                 for (size_t ndx = 0; ndx < samples.size(); ++ndx)
 158                 {
 159                         if (ndx)
 160                                 samplesMsg << ", ";
 161                         samplesMsg << samples[ndx];
 162                 }
 163                 samplesMsg << "]" << tcu::TestLog::EndMessage;
 164
 165                 // Samples are in order
 166                 for (size_t ndx = 1; ndx < samples.size(); ++ndx)
 167                 {
 168                         if (samples[ndx-1] <= samples[ndx])
 169                         {
 170                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Samples must be ordered descending." << tcu::TestLog::EndMessage;
 171                                 error = true;
 172                                 break;
 173                         }
 174                 }
 175
 176                 // samples are positive
 177                 for (size_t ndx = 1; ndx < samples.size(); ++ndx)
 178                 {
 179                         if (samples[ndx-1] <= 0)
 180                         {
 181                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Only positive SAMPLES allowed." << tcu::TestLog::EndMessage;
 182                                 error = true;
 183                                 break;
 184                         }
 185                 }
 186
 187                 // maxSamples must be supported
 188                 if (!isFloatFormat)
 189                 {
 190                         if (samples[0] < maxSamples)
 191                         {
 192                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: MAX_*_SAMPLES must be supported." << tcu::TestLog::EndMessage;
 193                                 error = true;
 194                         }
 195                 }
 196         }
 197
 198         // Result
 199         if (!error)
 200                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 201         else
 202                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid value");
 203
 204         return STOP;
 205 }
 206
 207 class NumSampleCountsBufferCase : public TestCase
 208 {
 209 public:
 210                                         NumSampleCountsBufferCase       (Context& ctx, const char* name, const char* desc);
 211
 212 private:
 213         IterateResult   iterate                                         (void);
 214 };
 215
 216 NumSampleCountsBufferCase::NumSampleCountsBufferCase (Context& ctx, const char* name, const char* desc)
 217         : TestCase(ctx, name, desc)
 218 {
 219 }
 220
 221 NumSampleCountsBufferCase::IterateResult NumSampleCountsBufferCase::iterate (void)
 222 {
 223         const glw::GLint                defaultValue    = -123; // queries always return positive values
 224         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
 225         bool                                    error                   = false;
 226
 227         // Query to larger buffer
 228         {
 229                 glw::GLint buffer[2] = { defaultValue, defaultValue };
 230
 231                 m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to larger-than-needed buffer." << tcu::TestLog::EndMessage;
 232                 gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 2, buffer);
 233                 GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");
 234
 235                 if (buffer[1] != defaultValue)
 236                 {
 237                         m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing values were modified." << tcu::TestLog::EndMessage;
 238                         error = true;
 239                 }
 240         }
 241
 242         // Query to empty buffer
 243         {
 244                 glw::GLint buffer[1] = { defaultValue };
 245
 246                 m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_NUM_SAMPLE_COUNTS to zero-sized buffer." << tcu::TestLog::EndMessage;
 247                 gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 0, buffer);
 248                 GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");
 249
 250                 if (buffer[0] != defaultValue)
 251                 {
 252                         m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 253                         error = true;
 254                 }
 255         }
 256
 257         // Result
 258         if (!error)
 259                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 260         else
 261                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");
 262
 263         return STOP;
 264 }
 265
 266 class SamplesBufferCase : public TestCase
 267 {
 268 public:
 269                                         SamplesBufferCase       (Context& ctx, const char* name, const char* desc);
 270
 271 private:
 272         IterateResult   iterate                         (void);
 273 };
 274
 275 SamplesBufferCase::SamplesBufferCase (Context& ctx, const char* name, const char* desc)
 276         : TestCase(ctx, name, desc)
 277 {
 278 }
 279
 280 SamplesBufferCase::IterateResult SamplesBufferCase::iterate (void)
 281 {
 282         const glw::GLint                defaultValue    = -123; // queries always return positive values
 283         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
 284         bool                                    error                   = false;
 285
 286         glw::GLint                              numSampleCounts = 0;
 287
 288         // Number of sample counts
 289         {
 290                 gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts);
 291                 GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_NUM_SAMPLE_COUNTS");
 292
 293                 m_testCtx.getLog() << tcu::TestLog::Message << "GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 294         }
 295
 296         if (numSampleCounts < 1)
 297         {
 298                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Format MUST support some multisample configuration, got GL_NUM_SAMPLE_COUNTS = " << numSampleCounts << tcu::TestLog::EndMessage;
 299                 error = true;
 300         }
 301         else
 302         {
 303                 // Query to larger buffer
 304                 {
 305                         std::vector<glw::GLint> buffer(numSampleCounts + 1, defaultValue);
 306
 307                         m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to larger-than-needed buffer." << tcu::TestLog::EndMessage;
 308                         gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, (glw::GLsizei)buffer.size(), &buffer[0]);
 309                         GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
 310
 311                         if (buffer.back() != defaultValue)
 312                         {
 313                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: trailing value was modified." << tcu::TestLog::EndMessage;
 314                                 error = true;
 315                         }
 316                 }
 317
 318                 // Query to smaller buffer
 319                 if (numSampleCounts > 2)
 320                 {
 321                         glw::GLint buffer[3] = { defaultValue, defaultValue, defaultValue };
 322
 323                         m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to buffer with bufSize=2." << tcu::TestLog::EndMessage;
 324                         gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 2, buffer);
 325                         GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
 326
 327                         if (buffer[2] != defaultValue)
 328                         {
 329                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 330                                 error = true;
 331                         }
 332                 }
 333
 334                 // Query to empty buffer
 335                 {
 336                         glw::GLint buffer[1] = { defaultValue };
 337
 338                         m_testCtx.getLog() << tcu::TestLog::Message << "Querying GL_SAMPLES to zero-sized buffer." << tcu::TestLog::EndMessage;
 339                         gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, GL_RGBA8, GL_SAMPLES, 0, buffer);
 340                         GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_SAMPLES");
 341
 342                         if (buffer[0] != defaultValue)
 343                         {
 344                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Query wrote over buffer bounds." << tcu::TestLog::EndMessage;
 345                                 error = true;
 346                         }
 347                 }
 348         }
 349
 350         // Result
 351         if (!error)
 352                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 353         else
 354                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected buffer modification");
 355
 356         return STOP;
 357 }
 358
 359 } // anonymous
 360
 361 InternalFormatQueryTests::InternalFormatQueryTests (Context& context)
 362         : TestCaseGroup(context, "internal_format", "Internal format queries")
 363 {
 364 }
 365
 366 InternalFormatQueryTests::~InternalFormatQueryTests (void)
 367 {
 368 }
 369
 370 void InternalFormatQueryTests::init (void)
 371 {
 372         static const struct InternalFormat
 373         {
 374                 const char*                                             name;
 375                 glw::GLenum                                             format;
 376                 FormatSamplesCase::FormatType   type;
 377         } internalFormats[] =
 378         {
 379                 // color renderable
 380                 { "r8",                                         GL_R8,                                  FormatSamplesCase::FORMAT_COLOR                 },
 381                 { "rg8",                                        GL_RG8,                                 FormatSamplesCase::FORMAT_COLOR                 },
 382                 { "rgb8",                                       GL_RGB8,                                FormatSamplesCase::FORMAT_COLOR                 },
 383                 { "rgb565",                                     GL_RGB565,                              FormatSamplesCase::FORMAT_COLOR                 },
 384                 { "rgba4",                                      GL_RGBA4,                               FormatSamplesCase::FORMAT_COLOR                 },
 385                 { "rgb5_a1",                            GL_RGB5_A1,                             FormatSamplesCase::FORMAT_COLOR                 },
 386                 { "rgba8",                                      GL_RGBA8,                               FormatSamplesCase::FORMAT_COLOR                 },
 387                 { "rgb10_a2",                           GL_RGB10_A2,                    FormatSamplesCase::FORMAT_COLOR                 },
 388                 { "rgb10_a2ui",                         GL_RGB10_A2UI,                  FormatSamplesCase::FORMAT_INT                   },
 389                 { "srgb8_alpha8",                       GL_SRGB8_ALPHA8,                FormatSamplesCase::FORMAT_COLOR                 },
 390                 { "r8i",                                        GL_R8I,                                 FormatSamplesCase::FORMAT_INT                   },
 391                 { "r8ui",                                       GL_R8UI,                                FormatSamplesCase::FORMAT_INT                   },
 392                 { "r16i",                                       GL_R16I,                                FormatSamplesCase::FORMAT_INT                   },
 393                 { "r16ui",                                      GL_R16UI,                               FormatSamplesCase::FORMAT_INT                   },
 394                 { "r32i",                                       GL_R32I,                                FormatSamplesCase::FORMAT_INT                   },
 395                 { "r32ui",                                      GL_R32UI,                               FormatSamplesCase::FORMAT_INT                   },
 396                 { "rg8i",                                       GL_RG8I,                                FormatSamplesCase::FORMAT_INT                   },
 397                 { "rg8ui",                                      GL_RG8UI,                               FormatSamplesCase::FORMAT_INT                   },
 398                 { "rg16i",                                      GL_RG16I,                               FormatSamplesCase::FORMAT_INT                   },
 399                 { "rg16ui",                                     GL_RG16UI,                              FormatSamplesCase::FORMAT_INT                   },
 400                 { "rg32i",                                      GL_RG32I,                               FormatSamplesCase::FORMAT_INT                   },
 401                 { "rg32ui",                                     GL_RG32UI,                              FormatSamplesCase::FORMAT_INT                   },
 402                 { "rgba8i",                                     GL_RGBA8I,                              FormatSamplesCase::FORMAT_INT                   },
 403                 { "rgba8ui",                            GL_RGBA8UI,                             FormatSamplesCase::FORMAT_INT                   },
 404                 { "rgba16i",                            GL_RGBA16I,                             FormatSamplesCase::FORMAT_INT                   },
 405                 { "rgba16ui",                           GL_RGBA16UI,                    FormatSamplesCase::FORMAT_INT                   },
 406                 { "rgba32i",                            GL_RGBA32I,                             FormatSamplesCase::FORMAT_INT                   },
 407                 { "rgba32ui",                           GL_RGBA32UI,                    FormatSamplesCase::FORMAT_INT                   },
 408
 409                 // float formats
 410                 { "r16f",                                       GL_R16F,                                FormatSamplesCase::FORMAT_COLOR                 },
 411                 { "rg16f",                                      GL_RG16F,                               FormatSamplesCase::FORMAT_COLOR                 },
 412                 { "rgba16f",                            GL_RGBA16F,                             FormatSamplesCase::FORMAT_COLOR                 },
 413                 { "r32f",                                       GL_R32F,                                FormatSamplesCase::FORMAT_INT                   },
 414                 { "rg32f",                                      GL_RG32F,                               FormatSamplesCase::FORMAT_INT                   },
 415                 { "rgba32f",                            GL_RGBA32F,                             FormatSamplesCase::FORMAT_INT                   },
 416                 { "r11f_g11f_b10f",                     GL_R11F_G11F_B10F,              FormatSamplesCase::FORMAT_COLOR                 },
 417
 418                 // depth renderable
 419                 { "depth_component16",          GL_DEPTH_COMPONENT16,   FormatSamplesCase::FORMAT_DEPTH_STENCIL },
 420                 { "depth_component24",          GL_DEPTH_COMPONENT24,   FormatSamplesCase::FORMAT_DEPTH_STENCIL },
 421                 { "depth_component32f",         GL_DEPTH_COMPONENT32F,  FormatSamplesCase::FORMAT_DEPTH_STENCIL },
 422                 { "depth24_stencil8",           GL_DEPTH24_STENCIL8,    FormatSamplesCase::FORMAT_DEPTH_STENCIL },
 423                 { "depth32f_stencil8",          GL_DEPTH32F_STENCIL8,   FormatSamplesCase::FORMAT_DEPTH_STENCIL },
 424
 425                 // stencil renderable
 426                 { "stencil_index8",                     GL_STENCIL_INDEX8,              FormatSamplesCase::FORMAT_DEPTH_STENCIL }
 427                 // DEPTH24_STENCIL8,  duplicate
 428                 // DEPTH32F_STENCIL8  duplicate
 429         };
 430
 431         static const struct
 432         {
 433                 const char*     name;
 434                 deUint32        target;
 435         } textureTargets[] =
 436         {
 437                 { "renderbuffer",                                       GL_RENDERBUFFER                                 },
 438                 { "texture_2d_multisample",                     GL_TEXTURE_2D_MULTISAMPLE               },
 439                 { "texture_2d_multisample_array",       GL_TEXTURE_2D_MULTISAMPLE_ARRAY },
 440         };
 441
 442         for (int groupNdx = 0; groupNdx < DE_LENGTH_OF_ARRAY(textureTargets); ++groupNdx)
 443         {
 444                 tcu::TestCaseGroup* const       group           = new tcu::TestCaseGroup(m_testCtx, textureTargets[groupNdx].name, glu::getInternalFormatTargetName(textureTargets[groupNdx].target));
 445                 const glw::GLenum                       texTarget       = textureTargets[groupNdx].target;
 446
 447                 addChild(group);
 448
 449                 for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(internalFormats); ++caseNdx)
 450                 {
 451                         const std::string name = std::string(internalFormats[caseNdx].name) + "_samples";
 452                         const std::string desc = std::string("Verify GL_SAMPLES of ") + internalFormats[caseNdx].name;
 453
 454                         group->addChild(new FormatSamplesCase(m_context, name.c_str(), desc.c_str(), texTarget, internalFormats[caseNdx].format, internalFormats[caseNdx].type));
 455                 }
 456         }
 457
 458         // Check buffer sizes are honored
 459         {
 460                 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "partial_query", "Query data to too short a buffer");
 461
 462                 addChild(group);
 463
 464                 group->addChild(new NumSampleCountsBufferCase   (m_context, "num_sample_counts",        "Query GL_NUM_SAMPLE_COUNTS to too short a buffer"));
 465                 group->addChild(new SamplesBufferCase                   (m_context, "samples",                          "Query GL_SAMPLES to too short a buffer"));
 466         }
 467 }
 468
 469 } // Functional
 470 } // gles31
 471 } // deqp