external/openglcts/modules/gles31/es31cTextureStorageMultisampleGLCoverageTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2014-2016 The Khronos Group Inc.
   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
  22  */ /*-------------------------------------------------------------------*/
  23
  24 /**
  25  */ /*!
  26  * \file  es31cTextureStorageMultisampleGLCoverageTests.cpp
  27  * \brief Implements coverage tests for multisample textures. (ES3.1 only)
  28  */ /*-------------------------------------------------------------------*/
  29
  30 #include "es31cTextureStorageMultisampleGLCoverageTests.hpp"
  31 #include "gluContextInfo.hpp"
  32 #include "gluDefs.hpp"
  33 #include "glwEnums.hpp"
  34 #include "glwFunctions.hpp"
  35 #include "tcuRenderTarget.hpp"
  36 #include "tcuTestLog.hpp"
  37
  38 #include <string>
  39 #include <vector>
  40
  41 namespace glcts
  42 {
  43 /** Constructor.
  44  *
  45  *  @param context Rendering context handle.
  46  **/
  47 GLCoverageExtensionSpecificEnumsAreRecognizedTest::GLCoverageExtensionSpecificEnumsAreRecognizedTest(Context& context)
  48         : TestCase(context, "extension_specific_enums_are_recognized",
  49                            "GL_MAX_SAMPLE_MASK_WORDS, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_MAX_DEPTH_TEXTURE_SAMPLES"
  50                            ", GL_MAX_INTEGER_SAMPLES, GL_TEXTURE_BINDING_2D_MULTISAMPLE and"
  51                            " GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES enums are recognized.")
  52         , gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
  53         , to_id_2d_multisample(0)
  54         , to_id_2d_multisample_array(0)
  55 {
  56         /* Left blank on purpose */
  57 }
  58
  59 /* Deinitializes ES objects that may have been created while the test executed. */
  60 void GLCoverageExtensionSpecificEnumsAreRecognizedTest::deinit()
  61 {
  62         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
  63
  64         if (to_id_2d_multisample != 0)
  65         {
  66                 gl.deleteTextures(1, &to_id_2d_multisample);
  67
  68                 to_id_2d_multisample = 0;
  69         }
  70
  71         if (to_id_2d_multisample_array != 0)
  72         {
  73                 gl.deleteTextures(1, &to_id_2d_multisample_array);
  74
  75                 to_id_2d_multisample_array = 0;
  76         }
  77
  78         /* Call base class' deinit() */
  79         TestCase::deinit();
  80 }
  81
  82 /** Executes test iteration.
  83  *
  84  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
  85  */
  86 tcu::TestNode::IterateResult GLCoverageExtensionSpecificEnumsAreRecognizedTest::iterate()
  87 {
  88         gl_oes_texture_storage_multisample_2d_array_supported =
  89                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");
  90
  91         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
  92
  93         /* Iterate through all pnames that need to be verified */
  94         const glw::GLenum pnames[] = { GL_MAX_SAMPLE_MASK_WORDS, GL_MAX_COLOR_TEXTURE_SAMPLES, GL_MAX_DEPTH_TEXTURE_SAMPLES,
  95                                                                    GL_MAX_INTEGER_SAMPLES };
  96         const unsigned int n_pnames = sizeof(pnames) / sizeof(pnames[0]);
  97
  98         for (unsigned int n_pname = 0; n_pname < n_pnames; ++n_pname)
  99         {
 100                 const float epsilon = (float)1e-5;
 101                 glw::GLenum pname   = pnames[n_pname];
 102
 103                 /* Test glGetIntegerv() */
 104                 glw::GLint int_value = -1;
 105
 106                 gl.getIntegerv(pname, &int_value);
 107                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error for a valid pname");
 108
 109                 if (int_value < 1)
 110                 {
 111                         m_testCtx.getLog() << tcu::TestLog::Message << "An invalid integer value " << int_value
 112                                                            << " was reported for pname [" << pname << "]." << tcu::TestLog::EndMessage;
 113
 114                         TCU_FAIL("Invalid integer value reported for pname.");
 115                 }
 116
 117                 /* Test glGetBooleanv() */
 118                 glw::GLboolean bool_value = GL_TRUE;
 119
 120                 gl.getBooleanv(pname, &bool_value);
 121                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error for a valid pname");
 122
 123                 if ((int_value != 0 && bool_value == GL_FALSE) || (int_value == 0 && bool_value != GL_FALSE))
 124                 {
 125                         m_testCtx.getLog() << tcu::TestLog::Message << "An invalid boolean value [" << bool_value << "]"
 126                                                            << " was reported for pname [" << pname << "]"
 127                                                            << " (integer value reported for the same property:" << int_value << ")"
 128                                                            << tcu::TestLog::EndMessage;
 129
 130                         TCU_FAIL("Invalid boolean value reported for pname.");
 131                 }
 132
 133                 /* Test glGetFloatv() */
 134                 glw::GLfloat float_value = -1.0f;
 135
 136                 gl.getFloatv(pname, &float_value);
 137                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error for a valid pname");
 138
 139                 if (de::abs(float_value - float(int_value)) > epsilon)
 140                 {
 141                         m_testCtx.getLog() << tcu::TestLog::Message << "An invalid floating-point value [" << float_value << "]"
 142                                                            << " was reported for pname        [" << pname << "]"
 143                                                            << " (integer value reported for the same property:" << int_value << ")"
 144                                                            << tcu::TestLog::EndMessage;
 145
 146                         TCU_FAIL("Invalid floating-point value reported for pname.");
 147                 }
 148         } /* for (all pnames) */
 149
 150         /* Verify default multisample texture bindings are valid */
 151         glw::GLboolean bool_value  = GL_TRUE;
 152         const float     epsilon  = (float)1e-5;
 153         glw::GLfloat   float_value = 1.0f;
 154         glw::GLint       int_value   = 1;
 155
 156         gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &bool_value);
 157         gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &float_value);
 158         gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &int_value);
 159
 160         GLU_EXPECT_NO_ERROR(gl.getError(),
 161                                                 "GL_TEXTURE_BINDING_2D_MULTISAMPLE pname was not recognized by one of the glGet*() functions");
 162
 163         if (bool_value != GL_FALSE || de::abs(float_value) > epsilon || int_value != 0)
 164         {
 165                 TCU_FAIL("Default GL_TEXTURE_BINDING_2D_MULTISAMPLE value is invalid");
 166         }
 167
 168         if (gl_oes_texture_storage_multisample_2d_array_supported)
 169         {
 170                 bool_value  = GL_TRUE;
 171                 float_value = 1.0f;
 172                 int_value   = 1;
 173
 174                 gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &bool_value);
 175                 gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &float_value);
 176                 gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &int_value);
 177
 178                 GLU_EXPECT_NO_ERROR(
 179                         gl.getError(),
 180                         "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES pname was not recognized by one of the glGet*() functions");
 181
 182                 if (bool_value != GL_FALSE || de::abs(float_value) > epsilon || int_value != 0)
 183                 {
 184                         TCU_FAIL("Default GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES value is invalid");
 185                 }
 186         }
 187
 188         /* Generate two texture objects we will later bind to multisample texture targets to
 189          * verify the values reported for corresponding pnames have also changed.
 190          */
 191         gl.genTextures(1, &to_id_2d_multisample);
 192
 193         if (gl_oes_texture_storage_multisample_2d_array_supported)
 194         {
 195                 gl.genTextures(1, &to_id_2d_multisample_array);
 196         }
 197
 198         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() failed");
 199
 200         /* Now bind the IDs to relevant texture targets */
 201         gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d_multisample);
 202
 203         if (gl_oes_texture_storage_multisample_2d_array_supported)
 204         {
 205                 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_multisample_array);
 206         }
 207
 208         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() failed");
 209
 210         /* Verify new bindings are reported */
 211         bool_value  = GL_FALSE;
 212         float_value = 0.0f;
 213         int_value   = 0;
 214
 215         gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &bool_value);
 216         gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &float_value);
 217         gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE, &int_value);
 218
 219         GLU_EXPECT_NO_ERROR(gl.getError(),
 220                                                 "GL_TEXTURE_BINDING_2D_MULTISAMPLE pname was not recognized by one of the glGet*() functions");
 221
 222         glw::GLfloat expected_float_value = float(to_id_2d_multisample);
 223
 224         if (bool_value != GL_TRUE || de::abs(float_value - expected_float_value) > epsilon ||
 225                 (glw::GLuint)int_value != to_id_2d_multisample)
 226         {
 227                 TCU_FAIL("GL_TEXTURE_BINDING_2D_MULTISAMPLE value is invalid");
 228         }
 229
 230         if (gl_oes_texture_storage_multisample_2d_array_supported)
 231         {
 232                 bool_value  = GL_FALSE;
 233                 float_value = 0.0f;
 234                 int_value   = 0;
 235
 236                 gl.getBooleanv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &bool_value);
 237                 gl.getFloatv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &float_value);
 238                 gl.getIntegerv(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES, &int_value);
 239
 240                 GLU_EXPECT_NO_ERROR(
 241                         gl.getError(),
 242                         "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES pname was not recognized by one of the glGet*() functions");
 243
 244                 expected_float_value = float(to_id_2d_multisample_array);
 245
 246                 if (bool_value != GL_TRUE || de::abs(float_value - expected_float_value) > epsilon ||
 247                         (glw::GLuint)int_value != to_id_2d_multisample_array)
 248                 {
 249                         TCU_FAIL("GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES value is invalid");
 250                 }
 251         }
 252
 253         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 254         return STOP;
 255 }
 256
 257 /** Constructor.
 258  *
 259  *  @param context Rendering context handle.
 260  **/
 261 GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::
 262         GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets(Context& context)
 263         : TestCase(context, "get_tex_parameter_reports_correct_default_values_for_multisample_texture_targets",
 264                            "glGetTexParameter*() report correct default values for multisample texture targets.")
 265         , gl_oes_texture_storage_multisample_2d_array_supported(GL_FALSE)
 266         , to_id_2d(0)
 267         , to_id_2d_array(0)
 268 {
 269         /* Left blank on purpose */
 270 }
 271
 272 /* Deinitializes test-specific ES objects */
 273 void GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::deinit()
 274 {
 275         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 276
 277         if (to_id_2d != 0)
 278         {
 279                 gl.deleteTextures(1, &to_id_2d);
 280
 281                 to_id_2d = 0;
 282         }
 283
 284         if (to_id_2d_array != 0)
 285         {
 286                 gl.deleteTextures(1, &to_id_2d_array);
 287
 288                 to_id_2d_array = 0;
 289         }
 290
 291         /* Call base test class' deinit() */
 292         TestCase::deinit();
 293 }
 294
 295 /** Executes test iteration.
 296  *
 297  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 298  */
 299 tcu::TestNode::IterateResult GLCoverageGLGetTexParameterReportsCorrectDefaultValuesForMultisampleTextureTargets::
 300         iterate()
 301 {
 302         gl_oes_texture_storage_multisample_2d_array_supported =
 303                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");
 304
 305         const float                       epsilon = (float)1e-5;
 306         const glw::Functions& gl          = m_context.getRenderContext().getFunctions();
 307
 308         /* Generate texture objects */
 309         gl.genTextures(1, &to_id_2d);
 310
 311         if (gl_oes_texture_storage_multisample_2d_array_supported)
 312         {
 313                 gl.genTextures(1, &to_id_2d_array);
 314         }
 315
 316         GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glGenTextures() call failed");
 317
 318         /* Bind the texture objects to multisample texture targets */
 319         gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d);
 320
 321         if (gl_oes_texture_storage_multisample_2d_array_supported)
 322         {
 323                 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_array);
 324         }
 325
 326         GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glBindTexture() call failed");
 327
 328         /* Initialize texture storage */
 329         gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 2, /* samples */
 330                                                            GL_RGBA8, 4,                                  /* width */
 331                                                            4,                                                    /* height */
 332                                                            GL_TRUE);                                     /* fixedsamplelocations */
 333
 334         if (gl_oes_texture_storage_multisample_2d_array_supported)
 335         {
 336                 gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2, /* samples */
 337                                                                    GL_RGBA8, 4,                                                    /* width */
 338                                                                    4,                                                                      /* height */
 339                                                                    4,                                                                      /* depth */
 340                                                                    GL_TRUE);                                                       /* fixedsamplelocations */
 341         }
 342
 343         GLU_EXPECT_NO_ERROR(gl.getError(), "Texture storage initialization failed");
 344
 345         /* List of supported texture targets when the extension is not present. */
 346         glw::GLenum texture_targets_without_extension[] = { GL_TEXTURE_2D_MULTISAMPLE };
 347
 348         /* List of supported texture targets when the extension is present. */
 349         glw::GLenum texture_targets_with_extension[] = { GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES };
 350
 351         /* Iterate through all the texture targets supported for the specific case. */
 352         glw::GLenum* texture_targets = NULL;
 353
 354         unsigned int n_texture_targets = 0;
 355
 356         if (gl_oes_texture_storage_multisample_2d_array_supported)
 357         {
 358                 n_texture_targets = sizeof(texture_targets_with_extension) / sizeof(texture_targets_with_extension[0]);
 359                 texture_targets   = texture_targets_with_extension;
 360         }
 361         else
 362         {
 363                 n_texture_targets = sizeof(texture_targets_without_extension) / sizeof(texture_targets_without_extension[0]);
 364                 texture_targets   = texture_targets_without_extension;
 365         }
 366
 367         for (unsigned int n_texture_target = 0; n_texture_target < n_texture_targets; ++n_texture_target)
 368         {
 369                 glw::GLenum target = texture_targets[n_texture_target];
 370
 371                 /* Iterate through all texture parameters */
 372                 const glw::GLenum texture_parameters[] = {
 373                         GL_TEXTURE_BASE_LEVEL, GL_TEXTURE_IMMUTABLE_FORMAT, GL_TEXTURE_MAX_LEVEL, GL_TEXTURE_SWIZZLE_R,
 374                         GL_TEXTURE_SWIZZLE_G,  GL_TEXTURE_SWIZZLE_B,            GL_TEXTURE_SWIZZLE_A,
 375
 376                         /* The following are sampler states, hence are left out */
 377
 378                         // GL_TEXTURE_COMPARE_FUNC,
 379                         // GL_TEXTURE_COMPARE_MODE,
 380                         // GL_TEXTURE_MAG_FILTER,
 381                         // GL_TEXTURE_MAX_LOD,
 382                         // GL_TEXTURE_MIN_FILTER,
 383                         // GL_TEXTURE_MIN_LOD,
 384                         // GL_TEXTURE_WRAP_S,
 385                         // GL_TEXTURE_WRAP_T,
 386                         // GL_TEXTURE_WRAP_R
 387                 };
 388                 const unsigned int n_texture_parameters = sizeof(texture_parameters) / sizeof(texture_parameters[0]);
 389
 390                 for (unsigned int n_texture_parameter = 0; n_texture_parameter < n_texture_parameters; ++n_texture_parameter)
 391                 {
 392                         glw::GLenum texture_parameter = texture_parameters[n_texture_parameter];
 393
 394                         /* Query implementation for the parameter values for texture target considered */
 395                         glw::GLint   expected_int_value = 0;
 396                         glw::GLfloat float_value                = 0.0f;
 397                         glw::GLint   int_value                  = 0;
 398
 399                         gl.getTexParameterfv(target, texture_parameter, &float_value);
 400                         gl.getTexParameteriv(target, texture_parameter, &int_value);
 401
 402                         GLU_EXPECT_NO_ERROR(gl.getError(), "Either of the glGetTexParameter*() calls generated an error");
 403
 404                         /* Verify the value is valid */
 405                         switch (texture_parameter)
 406                         {
 407                         case GL_TEXTURE_BASE_LEVEL:
 408                                 expected_int_value = 0;
 409                                 break;
 410                         case GL_TEXTURE_COMPARE_FUNC:
 411                                 expected_int_value = GL_LEQUAL;
 412                                 break;
 413                         case GL_TEXTURE_COMPARE_MODE:
 414                                 expected_int_value = GL_NONE;
 415                                 break;
 416                         case GL_TEXTURE_IMMUTABLE_FORMAT:
 417                                 expected_int_value = GL_TRUE;
 418                                 break;
 419                         case GL_TEXTURE_MAG_FILTER:
 420                                 expected_int_value = GL_LINEAR;
 421                                 break;
 422                         case GL_TEXTURE_MAX_LEVEL:
 423                                 expected_int_value = 1000;
 424                                 break;
 425                         case GL_TEXTURE_MAX_LOD:
 426                                 expected_int_value = 1000;
 427                                 break;
 428                         case GL_TEXTURE_MIN_FILTER:
 429                                 expected_int_value = GL_NEAREST_MIPMAP_LINEAR;
 430                                 break;
 431                         case GL_TEXTURE_MIN_LOD:
 432                                 expected_int_value = -1000;
 433                                 break;
 434                         case GL_TEXTURE_SWIZZLE_R:
 435                                 expected_int_value = GL_RED;
 436                                 break;
 437                         case GL_TEXTURE_SWIZZLE_G:
 438                                 expected_int_value = GL_GREEN;
 439                                 break;
 440                         case GL_TEXTURE_SWIZZLE_B:
 441                                 expected_int_value = GL_BLUE;
 442                                 break;
 443                         case GL_TEXTURE_SWIZZLE_A:
 444                                 expected_int_value = GL_ALPHA;
 445                                 break;
 446                         case GL_TEXTURE_WRAP_S:
 447                                 expected_int_value = GL_REPEAT;
 448                                 break;
 449                         case GL_TEXTURE_WRAP_T:
 450                                 expected_int_value = GL_REPEAT;
 451                                 break;
 452                         case GL_TEXTURE_WRAP_R:
 453                                 expected_int_value = GL_REPEAT;
 454                                 break;
 455
 456                         default:
 457                         {
 458                                 TCU_FAIL("Unrecognized texture parameter name");
 459                         }
 460                         } /* switch (texture_parameter) */
 461
 462                         /* Verify integer value the implementation returned */
 463                         if (expected_int_value != int_value)
 464                         {
 465                                 m_testCtx.getLog() << tcu::TestLog::Message << "Implementation returned an invalid integer value of "
 466                                                                    << int_value << " instead of the expected value " << expected_int_value
 467                                                                    << " for property " << texture_parameter << " of texture target " << target
 468                                                                    << tcu::TestLog::EndMessage;
 469
 470                                 TCU_FAIL("Invalid integer value returned by glGetTexParameteriv()");
 471                         }
 472
 473                         /* Verify floating-point value the implementation returned */
 474                         if (de::abs(float(expected_int_value) - float_value) > epsilon)
 475                         {
 476                                 m_testCtx.getLog() << tcu::TestLog::Message
 477                                                                    << "Implementation returned an invalid floating-point value of " << float_value
 478                                                                    << " instead of the expected value " << expected_int_value << " for property "
 479                                                                    << texture_parameter << " of texture target " << target << tcu::TestLog::EndMessage;
 480
 481                                 TCU_FAIL("Invalid floating-point value returned by glGetTexParameteriv()");
 482                         }
 483                 } /* for (all texture parameters) */
 484         }        /* for (all texture targets) */
 485
 486         /* All done */
 487         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 488         return STOP;
 489 }
 490
 491 /** Constructor.
 492  *
 493  *  @param context Rendering context handle.
 494  **/
 495 GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest::GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest(
 496         Context& context)
 497         : TestCase(context, "gl_sample_mask_mode_status_is_reported_correctly",
 498                            "glGet*() calls report correct disabled/enabled status of GL_SAMPLE_MASK mode.")
 499 {
 500         /* Left blank on purpose */
 501 }
 502
 503 /** Executes test iteration.
 504  *
 505  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 506  */
 507 tcu::TestNode::IterateResult GLCoverageGLSampleMaskModeStatusIsReportedCorrectlyTest::iterate()
 508 {
 509         const float                       epsilon = (float)1e-5;
 510         const glw::Functions& gl          = m_context.getRenderContext().getFunctions();
 511
 512         /* Check GL_SAMPLE_MASK is disabled by default */
 513         glw::GLint enabled = gl.isEnabled(GL_SAMPLE_MASK);
 514         GLU_EXPECT_NO_ERROR(gl.getError(), "Unexpected error generated by glIsEnabled(GL_SAMPLE_MASK) call.");
 515
 516         if (enabled != GL_FALSE)
 517         {
 518                 TCU_FAIL("GL_SAMPLE_MASK mode is considered enabled by default which is incorrect.");
 519         }
 520
 521         /* Verify glGet*() calls also report the mode to be disabled */
 522         glw::GLboolean bool_value  = GL_TRUE;
 523         glw::GLfloat   float_value = 1.0f;
 524         glw::GLint       int_value   = 1;
 525
 526         gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
 527         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");
 528
 529         if (bool_value != GL_FALSE)
 530         {
 531                 TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
 532         }
 533
 534         gl.getFloatv(GL_SAMPLE_MASK, &float_value);
 535         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");
 536
 537         if (de::abs(float_value - float(GL_FALSE)) > epsilon)
 538         {
 539                 TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
 540         }
 541
 542         gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
 543         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");
 544
 545         if (int_value != GL_FALSE)
 546         {
 547                 TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
 548         }
 549
 550         /* Enable GL_SAMPLE_MASK mode */
 551         gl.enable(GL_SAMPLE_MASK);
 552
 553         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_SAMPLE_MASK) call generated an unexpected error");
 554
 555         /* Verify values reported by glIsEnabled(), as well as GL getters is still correct */
 556         enabled = gl.isEnabled(GL_SAMPLE_MASK);
 557         GLU_EXPECT_NO_ERROR(gl.getError(), "glIsEnabled(GL_SAMPLE_MASK) call generated an unexpected error");
 558
 559         if (enabled != GL_TRUE)
 560         {
 561                 TCU_FAIL(
 562                         "glIsEnabled(GL_SAMPLE_MASK) did not report GL_TRUE after a successful glEnable(GL_SAMPLE_MASK) call.");
 563         }
 564
 565         gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
 566         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");
 567
 568         if (bool_value != GL_TRUE)
 569         {
 570                 TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
 571         }
 572
 573         gl.getFloatv(GL_SAMPLE_MASK, &float_value);
 574         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");
 575
 576         if (de::abs(float_value - float(GL_TRUE)) > epsilon)
 577         {
 578                 TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
 579         }
 580
 581         gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
 582         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");
 583
 584         if (int_value != GL_TRUE)
 585         {
 586                 TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
 587         }
 588
 589         /* Disable the mode and see if the getters react accordingly */
 590         gl.disable(GL_SAMPLE_MASK);
 591         GLU_EXPECT_NO_ERROR(gl.getError(), "glDisable(GL_SAMPLE_MASK) call generated an unexpected error");
 592
 593         enabled = gl.isEnabled(GL_SAMPLE_MASK);
 594         GLU_EXPECT_NO_ERROR(gl.getError(), "glIsEnabled(GL_SAMPLE_MASK) call generated an unexpected error");
 595
 596         if (enabled != GL_FALSE)
 597         {
 598                 TCU_FAIL(
 599                         "glIsEnabled(GL_SAMPLE_MASK) did not report GL_FALSE after a successful glDisable(GL_SAMPLE_MASK) call.");
 600         }
 601
 602         gl.getBooleanv(GL_SAMPLE_MASK, &bool_value);
 603         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetBooleanv() reported an error when queried for GL_SAMPLE_MASK property");
 604
 605         if (bool_value != GL_FALSE)
 606         {
 607                 TCU_FAIL("Invalid boolean value reported for GL_SAMPLE_MASK property");
 608         }
 609
 610         gl.getFloatv(GL_SAMPLE_MASK, &float_value);
 611         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() reported an error when queried for GL_SAMPLE_MASK property");
 612
 613         if (de::abs(float_value - float(GL_FALSE)) > epsilon)
 614         {
 615                 TCU_FAIL("Invalid float value reported for GL_SAMPLE_MASK property");
 616         }
 617
 618         gl.getIntegerv(GL_SAMPLE_MASK, &int_value);
 619         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() reported an error when queried for GL_SAMPLE_MASK property");
 620
 621         if (int_value != GL_FALSE)
 622         {
 623                 TCU_FAIL("Invalid integer value reported for GL_SAMPLE_MASK property");
 624         }
 625
 626         /* All good! */
 627         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 628         return STOP;
 629 }
 630
 631 /** Constructor.
 632  *
 633  *  @param context Rendering context handle.
 634  **/
 635 GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::
 636         GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest(Context& context)
 637         : TestCase(context, "gl_tex_parameter_handlers_accept_zero_base_level",
 638                            "glTexParameter*() calls should not generate an error if zero base "
 639                            "level is requested for 2D multisample or 2D multisample array texture targets.")
 640         , are_2d_array_multisample_tos_supported(false)
 641         , to_id_2d(0)
 642         , to_id_2d_array(0)
 643 {
 644         /* Left blank on purpose */
 645 }
 646
 647 /* Deinitializes texture objects created specifically for this test case. */
 648 void GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::deinit()
 649 {
 650         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 651
 652         if (to_id_2d != 0)
 653         {
 654                 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
 655                 gl.deleteTextures(1, &to_id_2d);
 656         }
 657
 658         if (to_id_2d_array != 0)
 659         {
 660                 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 0);
 661                 gl.deleteTextures(1, &to_id_2d_array);
 662         }
 663
 664         /* Call base class' deinit() */
 665         TestCase::deinit();
 666 }
 667
 668 /* Initializes test instance: creates test-specific texture objects. */
 669 void GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::initInternals()
 670 {
 671         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 672
 673         /* Generate texture objects */
 674         gl.genTextures(1, &to_id_2d);
 675
 676         if (are_2d_array_multisample_tos_supported)
 677         {
 678                 gl.genTextures(1, &to_id_2d_array);
 679         }
 680
 681         GLU_EXPECT_NO_ERROR(gl.getError(), "Could not generate texture object(s)");
 682
 683         /* Bind the texture objects to extension-specific texture targets */
 684         gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, to_id_2d);
 685
 686         if (are_2d_array_multisample_tos_supported)
 687         {
 688                 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, to_id_2d_array);
 689         }
 690
 691         GLU_EXPECT_NO_ERROR(gl.getError(), "Could not bind texture object(s) to corresponding texture target(s).");
 692 }
 693
 694 /** Executes test iteration.
 695  *
 696  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 697  */
 698 tcu::TestNode::IterateResult GLCoverageGLTexParameterHandlersAcceptZeroBaseLevelForExtensionSpecificTextureTargetsTest::
 699         iterate()
 700 {
 701         are_2d_array_multisample_tos_supported =
 702                 m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array");
 703
 704         initInternals();
 705
 706         /* Initialize texture storage for 2D multisample texture object */
 707         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 708
 709         gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 2 /* samples */, GL_RGBA8, 4, /* width */
 710                                                            4,                                                                                                           /* height */
 711                                                            GL_TRUE /* fixedsamplelocations */);
 712
 713         GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up an immutable 2D multisample texture object");
 714
 715         /* Initialize texture storage for 2D multisample array texture object */
 716         if (are_2d_array_multisample_tos_supported)
 717         {
 718                 gl.texStorage3DMultisample(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, 2 /* samples */, GL_RGBA8, 4 /* width */,
 719                                                                    4 /* height */, 4 /* depth */, GL_TRUE /* fixedsamplelocations */);
 720
 721                 GLU_EXPECT_NO_ERROR(gl.getError(), "Could not set up an immutable 2D multisample array texture object");
 722         }
 723
 724         /* Force a zero base level setting for 2D multisample texture using all available glTexParameter*() entry-points */
 725         glw::GLfloat zero_float = 0.0f;
 726         glw::GLint   zero_int   = 0;
 727
 728         gl.texParameterf(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0.0f);
 729         gl.texParameterfv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &zero_float);
 730         gl.texParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0);
 731         gl.texParameteriv(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, &zero_int);
 732
 733         GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glTexParameter*() call reported an error.");
 734
 735         /* Do the same for 2D multisample array texture */
 736         if (are_2d_array_multisample_tos_supported)
 737         {
 738                 gl.texParameterf(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, 0.0f);
 739                 gl.texParameterfv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, &zero_float);
 740                 gl.texParameteri(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, 0);
 741                 gl.texParameteriv(GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES, GL_TEXTURE_BASE_LEVEL, &zero_int);
 742
 743                 GLU_EXPECT_NO_ERROR(gl.getError(), "At least one glTexParameter*() call reported an error.");
 744         }
 745
 746         /* All good! */
 747         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 748         return STOP;
 749 }
 750 } /* glcts namespace */