modules/glshared/glsTextureStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL (ES) Module
   3  * -----------------------------------------------
   4  *
   5  * Copyright 2015 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 Texture State Query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "glsTextureStateQueryTests.hpp"
  25 #include "gluStrUtil.hpp"
  26 #include "gluObjectWrapper.hpp"
  27 #include "gluCallLogWrapper.hpp"
  28 #include "gluContextInfo.hpp"
  29 #include "gluTextureUtil.hpp"
  30 #include "glwEnums.hpp"
  31 #include "deUniquePtr.hpp"
  32 #include "deRandom.hpp"
  33 #include "deStringUtil.hpp"
  34
  35 namespace deqp
  36 {
  37 namespace gls
  38 {
  39 namespace TextureStateQueryTests
  40 {
  41 namespace
  42 {
  43
  44 using namespace glw;
  45 using namespace gls::StateQueryUtil;
  46
  47 static glw::GLenum mapTesterToPname (TesterType tester)
  48 {
  49
  50 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
  51
  52         switch (tester)
  53         {
  54                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R):                             return GL_TEXTURE_SWIZZLE_R;
  55                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G):                             return GL_TEXTURE_SWIZZLE_G;
  56                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B):                             return GL_TEXTURE_SWIZZLE_B;
  57                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A):                             return GL_TEXTURE_SWIZZLE_A;
  58
  59                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
  60                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:                             return GL_TEXTURE_WRAP_S;
  61
  62                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
  63                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:                             return GL_TEXTURE_WRAP_T;
  64
  65                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
  66                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:                             return GL_TEXTURE_WRAP_R;
  67
  68                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):                    return GL_TEXTURE_MAG_FILTER;
  69                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):                    return GL_TEXTURE_MIN_FILTER;
  70                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):                               return GL_TEXTURE_MIN_LOD;
  71                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):                               return GL_TEXTURE_MAX_LOD;
  72                 CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL):                    return GL_TEXTURE_BASE_LEVEL;
  73                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL):                             return GL_TEXTURE_MAX_LEVEL;
  74                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):                  return GL_TEXTURE_COMPARE_MODE;
  75                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):                  return GL_TEXTURE_COMPARE_FUNC;
  76                 case TESTER_TEXTURE_IMMUTABLE_LEVELS:                                   return GL_TEXTURE_IMMUTABLE_LEVELS;
  77                 case TESTER_TEXTURE_IMMUTABLE_FORMAT:                                   return GL_TEXTURE_IMMUTABLE_FORMAT;
  78                 CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):    return GL_DEPTH_STENCIL_TEXTURE_MODE;
  79                 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):               return GL_TEXTURE_SRGB_DECODE_EXT;
  80                 case TESTER_TEXTURE_BORDER_COLOR:                                               return GL_TEXTURE_BORDER_COLOR;
  81
  82                 default:
  83                         DE_ASSERT(false);
  84                         return -1;
  85         }
  86
  87 #undef CASE_PURE_SETTERS
  88 }
  89
  90 static bool querySupportsSigned (QueryType type)
  91 {
  92         return  type != QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER &&
  93                         type != QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER;
  94 }
  95
  96 static bool isPureIntTester (TesterType tester)
  97 {
  98 #define HANDLE_ALL_SETTERS(X) \
  99                 case X: \
 100                 case X ## _SET_PURE_UINT: return false; \
 101                 case X ## _SET_PURE_INT: return true;
 102
 103         switch (tester)
 104         {
 105                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
 106                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
 107                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
 108                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
 109                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
 110                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
 111                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
 112                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
 113                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
 114                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
 115                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
 116                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
 117                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
 118                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
 119                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
 120                 HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
 121                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
 122
 123                 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
 124                 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
 125                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
 126                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
 127                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
 128                 case TESTER_TEXTURE_BORDER_COLOR:
 129                         return false;
 130
 131                 default:
 132                         DE_ASSERT(false);
 133                         return false;
 134         }
 135
 136 #undef HANDLE_ALL_SETTERS
 137 }
 138
 139 static bool isPureUintTester (TesterType tester)
 140 {
 141 #define HANDLE_ALL_SETTERS(X) \
 142                 case X: \
 143                 case X ## _SET_PURE_INT: return false; \
 144                 case X ## _SET_PURE_UINT: return true;
 145
 146         switch (tester)
 147         {
 148                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
 149                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
 150                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
 151                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
 152                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
 153                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
 154                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
 155                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
 156                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
 157                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
 158                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
 159                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
 160                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
 161                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
 162                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
 163                 HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
 164                 HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
 165
 166                 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
 167                 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
 168                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
 169                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
 170                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
 171                 case TESTER_TEXTURE_BORDER_COLOR:
 172                         return false;
 173
 174                 default:
 175                         DE_ASSERT(false);
 176                         return false;
 177         }
 178
 179 #undef HANDLE_ALL_SETTERS
 180 }
 181
 182 class RequiredExtensions
 183 {
 184 public:
 185                                                                 RequiredExtensions      (void)                                                                  { }
 186         explicit                                        RequiredExtensions      (const char* ext)                                               { add(ext);                             }
 187                                                                 RequiredExtensions      (const char* extA, const char* extB)    { add(extA); add(extB); }
 188
 189         void                                            add                                     (const char* ext);
 190         void                                            add                                     (const RequiredExtensions& other);
 191         void                                            check                           (const glu::ContextInfo&) const;
 192
 193 private:
 194         std::vector<const char*>        m_extensions;
 195 };
 196
 197 void RequiredExtensions::add (const char* ext)
 198 {
 199         for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
 200                 if (deStringEqual(m_extensions[ndx], ext) == DE_TRUE)
 201                         return;
 202         m_extensions.push_back(ext);
 203 }
 204
 205 void RequiredExtensions::add (const RequiredExtensions& other)
 206 {
 207         for (int ndx = 0; ndx < (int)other.m_extensions.size(); ++ndx)
 208                 add(other.m_extensions[ndx]);
 209 }
 210
 211 void RequiredExtensions::check (const glu::ContextInfo& ctxInfo) const
 212 {
 213         std::vector<const char*> failedExtensions;
 214
 215         for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
 216                 if (!ctxInfo.isExtensionSupported(m_extensions[ndx]))
 217                         failedExtensions.push_back(m_extensions[ndx]);
 218
 219         if (!failedExtensions.empty())
 220         {
 221                 std::ostringstream buf;
 222                 buf << "Test requires extension: ";
 223
 224                 for (int ndx = 0; ndx < (int)failedExtensions.size(); ++ndx)
 225                 {
 226                         if (ndx)
 227                                 buf << ", ";
 228                         buf << failedExtensions[ndx];
 229                 }
 230
 231                 throw tcu::NotSupportedError(buf.str());
 232         }
 233 }
 234
 235 namespace es30
 236 {
 237
 238 static bool isCoreTextureTarget (glw::GLenum target)
 239 {
 240         return  target == GL_TEXTURE_2D                 ||
 241                         target == GL_TEXTURE_3D                 ||
 242                         target == GL_TEXTURE_2D_ARRAY   ||
 243                         target == GL_TEXTURE_CUBE_MAP;
 244 }
 245
 246 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
 247 {
 248         DE_UNREF(target);
 249         DE_ASSERT(false);
 250         return RequiredExtensions();
 251 }
 252
 253 static bool isCoreTextureParam (glw::GLenum pname)
 254 {
 255         return  pname == GL_TEXTURE_BASE_LEVEL                  ||
 256                         pname == GL_TEXTURE_COMPARE_MODE                ||
 257                         pname == GL_TEXTURE_COMPARE_FUNC                ||
 258                         pname == GL_TEXTURE_MAG_FILTER                  ||
 259                         pname == GL_TEXTURE_MAX_LEVEL                   ||
 260                         pname == GL_TEXTURE_MAX_LOD                             ||
 261                         pname == GL_TEXTURE_MIN_FILTER                  ||
 262                         pname == GL_TEXTURE_MIN_LOD                             ||
 263                         pname == GL_TEXTURE_SWIZZLE_R                   ||
 264                         pname == GL_TEXTURE_SWIZZLE_G                   ||
 265                         pname == GL_TEXTURE_SWIZZLE_B                   ||
 266                         pname == GL_TEXTURE_SWIZZLE_A                   ||
 267                         pname == GL_TEXTURE_WRAP_S                              ||
 268                         pname == GL_TEXTURE_WRAP_T                              ||
 269                         pname == GL_TEXTURE_WRAP_R                              ||
 270                         pname == GL_TEXTURE_IMMUTABLE_FORMAT    ||
 271                         pname == GL_TEXTURE_IMMUTABLE_LEVELS;
 272 }
 273
 274 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
 275 {
 276         DE_UNREF(pname);
 277         DE_ASSERT(false);
 278         return RequiredExtensions();
 279 }
 280
 281 static bool isCoreQuery (QueryType query)
 282 {
 283         return  query == QUERY_TEXTURE_PARAM_INTEGER            ||
 284                         query == QUERY_TEXTURE_PARAM_FLOAT                      ||
 285                         query == QUERY_TEXTURE_PARAM_INTEGER_VEC4       ||
 286                         query == QUERY_TEXTURE_PARAM_FLOAT_VEC4         ||
 287                         query == QUERY_SAMPLER_PARAM_INTEGER            ||
 288                         query == QUERY_SAMPLER_PARAM_FLOAT                      ||
 289                         query == QUERY_SAMPLER_PARAM_INTEGER_VEC4       ||
 290                         query == QUERY_SAMPLER_PARAM_FLOAT_VEC4;
 291 }
 292
 293 static RequiredExtensions getQueryExtension (QueryType query)
 294 {
 295         DE_UNREF(query);
 296         DE_ASSERT(false);
 297         return RequiredExtensions();
 298 }
 299
 300 static bool isCoreTester (TesterType tester)
 301 {
 302         return  tester == TESTER_TEXTURE_SWIZZLE_R                      ||
 303                         tester == TESTER_TEXTURE_SWIZZLE_G                      ||
 304                         tester == TESTER_TEXTURE_SWIZZLE_B                      ||
 305                         tester == TESTER_TEXTURE_SWIZZLE_A                      ||
 306                         tester == TESTER_TEXTURE_WRAP_S                         ||
 307                         tester == TESTER_TEXTURE_WRAP_T                         ||
 308                         tester == TESTER_TEXTURE_WRAP_R                         ||
 309                         tester == TESTER_TEXTURE_MAG_FILTER                     ||
 310                         tester == TESTER_TEXTURE_MIN_FILTER                     ||
 311                         tester == TESTER_TEXTURE_MIN_LOD                        ||
 312                         tester == TESTER_TEXTURE_MAX_LOD                        ||
 313                         tester == TESTER_TEXTURE_BASE_LEVEL                     ||
 314                         tester == TESTER_TEXTURE_MAX_LEVEL                      ||
 315                         tester == TESTER_TEXTURE_COMPARE_MODE           ||
 316                         tester == TESTER_TEXTURE_COMPARE_FUNC           ||
 317                         tester == TESTER_TEXTURE_IMMUTABLE_LEVELS       ||
 318                         tester == TESTER_TEXTURE_IMMUTABLE_FORMAT;
 319 }
 320
 321 static RequiredExtensions getTesterExtension (TesterType tester)
 322 {
 323         DE_UNREF(tester);
 324         DE_ASSERT(false);
 325         return RequiredExtensions();
 326 }
 327
 328 } // es30
 329
 330 namespace es31
 331 {
 332
 333 static bool isCoreTextureTarget (glw::GLenum target)
 334 {
 335         return  es30::isCoreTextureTarget(target) ||
 336                         target == GL_TEXTURE_2D_MULTISAMPLE;
 337 }
 338
 339 static RequiredExtensions getTextureTargetExtension (glw::GLenum target)
 340 {
 341         switch (target)
 342         {
 343                 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:   return RequiredExtensions("GL_OES_texture_storage_multisample_2d_array");
 344                 case GL_TEXTURE_BUFFER:                                 return RequiredExtensions("GL_EXT_texture_buffer");
 345                 case GL_TEXTURE_CUBE_MAP_ARRAY:                 return RequiredExtensions("GL_EXT_texture_cube_map_array");
 346                 default:
 347                         DE_ASSERT(false);
 348                         return RequiredExtensions();
 349         }
 350 }
 351
 352 static bool isCoreTextureParam (glw::GLenum pname)
 353 {
 354         return  es30::isCoreTextureParam(pname) ||
 355                         pname == GL_DEPTH_STENCIL_TEXTURE_MODE;
 356 }
 357
 358 static RequiredExtensions getTextureParamExtension (glw::GLenum pname)
 359 {
 360         switch (pname)
 361         {
 362                 case GL_TEXTURE_SRGB_DECODE_EXT:        return RequiredExtensions("GL_EXT_texture_sRGB_decode");
 363                 case GL_TEXTURE_BORDER_COLOR:           return RequiredExtensions("GL_EXT_texture_border_clamp");
 364                 default:
 365                         DE_ASSERT(false);
 366                         return RequiredExtensions();
 367         }
 368 }
 369
 370 static bool isCoreQuery (QueryType query)
 371 {
 372         return es30::isCoreQuery(query);
 373 }
 374
 375 static RequiredExtensions getQueryExtension (QueryType query)
 376 {
 377         switch (query)
 378         {
 379                 case QUERY_TEXTURE_PARAM_PURE_INTEGER:
 380                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER:
 381                 case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4:
 382                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
 383                 case QUERY_SAMPLER_PARAM_PURE_INTEGER:
 384                 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER:
 385                 case QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4:
 386                 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
 387                         return RequiredExtensions("GL_EXT_texture_border_clamp");
 388
 389                 default:
 390                         DE_ASSERT(false);
 391                         return RequiredExtensions();
 392         }
 393 }
 394
 395 static bool isCoreTester (TesterType tester)
 396 {
 397         return  es30::isCoreTester(tester)                                                      ||
 398                         tester == TESTER_DEPTH_STENCIL_TEXTURE_MODE;
 399 }
 400
 401 static RequiredExtensions getTesterExtension (TesterType tester)
 402 {
 403 #define CASE_PURE_SETTERS(X) case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
 404
 405         switch (tester)
 406         {
 407                 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_R):
 408                 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_G):
 409                 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_B):
 410                 CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_A):
 411                 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_S):
 412                 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_T):
 413                 CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_R):
 414                 CASE_PURE_SETTERS(TESTER_TEXTURE_MAG_FILTER):
 415                 CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_FILTER):
 416                 CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_LOD):
 417                 CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LOD):
 418                 CASE_PURE_SETTERS(TESTER_TEXTURE_BASE_LEVEL):
 419                 CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LEVEL):
 420                 CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
 421                 CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
 422                 CASE_PURE_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):
 423                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
 424                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
 425                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
 426                 case TESTER_TEXTURE_BORDER_COLOR:
 427                         return RequiredExtensions("GL_EXT_texture_border_clamp");
 428
 429                 case TESTER_TEXTURE_SRGB_DECODE_EXT:
 430                         return RequiredExtensions("GL_EXT_texture_sRGB_decode");
 431
 432                 CASE_PURE_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
 433                         return RequiredExtensions("GL_EXT_texture_sRGB_decode", "GL_EXT_texture_border_clamp");
 434
 435                 default:
 436                         DE_ASSERT(false);
 437                         return RequiredExtensions();
 438         }
 439
 440 #undef CASE_PURE_SETTERS
 441 }
 442
 443 } // es31
 444
 445 static bool isCoreTextureTarget (const glu::ContextType& contextType, glw::GLenum target)
 446 {
 447         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 448                 return es31::isCoreTextureTarget(target);
 449         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 450                 return es30::isCoreTextureTarget(target);
 451         else
 452         {
 453                 DE_ASSERT(false);
 454                 return DE_NULL;
 455         }
 456 }
 457
 458 static bool isCoreTextureParam (const glu::ContextType& contextType, glw::GLenum pname)
 459 {
 460         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 461                 return es31::isCoreTextureParam(pname);
 462         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 463                 return es30::isCoreTextureParam(pname);
 464         else
 465         {
 466                 DE_ASSERT(false);
 467                 return DE_NULL;
 468         }
 469 }
 470
 471 static bool isCoreQuery (const glu::ContextType& contextType, QueryType query)
 472 {
 473         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 474                 return es31::isCoreQuery(query);
 475         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 476                 return es30::isCoreQuery(query);
 477         else
 478         {
 479                 DE_ASSERT(false);
 480                 return DE_NULL;
 481         }
 482 }
 483
 484 static bool isCoreTester (const glu::ContextType& contextType, TesterType tester)
 485 {
 486         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 487                 return es31::isCoreTester(tester);
 488         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 489                 return es30::isCoreTester(tester);
 490         else
 491         {
 492                 DE_ASSERT(false);
 493                 return DE_NULL;
 494         }
 495 }
 496
 497 static RequiredExtensions getTextureTargetExtension (const glu::ContextType& contextType, glw::GLenum target)
 498 {
 499         DE_ASSERT(!isCoreTextureTarget(contextType, target));
 500
 501         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 502                 return es31::getTextureTargetExtension(target);
 503         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 504                 return es30::getTextureTargetExtension(target);
 505         else
 506         {
 507                 DE_ASSERT(false);
 508                 return RequiredExtensions();
 509         }
 510 }
 511
 512 static RequiredExtensions getTextureParamExtension (const glu::ContextType& contextType, glw::GLenum pname)
 513 {
 514         DE_ASSERT(!isCoreTextureParam(contextType, pname));
 515
 516         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 517                 return es31::getTextureParamExtension(pname);
 518         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 519                 return es30::getTextureParamExtension(pname);
 520         else
 521         {
 522                 DE_ASSERT(false);
 523                 return RequiredExtensions();
 524         }
 525 }
 526
 527 static RequiredExtensions getQueryExtension (const glu::ContextType& contextType, QueryType query)
 528 {
 529         DE_ASSERT(!isCoreQuery(contextType, query));
 530
 531         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 532                 return es31::getQueryExtension(query);
 533         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 534                 return es30::getQueryExtension(query);
 535         else
 536         {
 537                 DE_ASSERT(false);
 538                 return RequiredExtensions();
 539         }
 540 }
 541
 542 static RequiredExtensions getTesterExtension (const glu::ContextType& contextType, TesterType tester)
 543 {
 544         DE_ASSERT(!isCoreTester(contextType, tester));
 545
 546         if (contextSupports(contextType, glu::ApiType::es(3,1)))
 547                 return es31::getTesterExtension(tester);
 548         else if (contextSupports(contextType, glu::ApiType::es(3,0)))
 549                 return es30::getTesterExtension(tester);
 550         else
 551         {
 552                 DE_ASSERT(false);
 553                 return RequiredExtensions();
 554         }
 555 }
 556
 557 class TextureTest : public tcu::TestCase
 558 {
 559 public:
 560                                                 TextureTest     (tcu::TestContext&                      testCtx,
 561                                                                          const glu::RenderContext&      renderCtx,
 562                                                                          const char*                            name,
 563                                                                          const char*                            desc,
 564                                                                          glw::GLenum                            target,
 565                                                                          TesterType                                     tester,
 566                                                                          QueryType                                      type);
 567
 568         void                            init            (void);
 569         IterateResult           iterate         (void);
 570
 571         virtual void            test            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
 572
 573 protected:
 574         const glu::RenderContext&       m_renderCtx;
 575         const glw::GLenum                       m_target;
 576         const glw::GLenum                       m_pname;
 577         const TesterType                        m_tester;
 578         const QueryType                         m_type;
 579 };
 580
 581 TextureTest::TextureTest (tcu::TestContext&                     testCtx,
 582                                                   const glu::RenderContext&     renderCtx,
 583                                                   const char*                           name,
 584                                                   const char*                           desc,
 585                                                   glw::GLenum                           target,
 586                                                   TesterType                            tester,
 587                                                   QueryType                                     type)
 588         : TestCase              (testCtx, name, desc)
 589         , m_renderCtx   (renderCtx)
 590         , m_target              (target)
 591         , m_pname               (mapTesterToPname(tester))
 592         , m_tester              (tester)
 593         , m_type                (type)
 594 {
 595 }
 596
 597 void TextureTest::init (void)
 598 {
 599         const de::UniquePtr<glu::ContextInfo>   ctxInfo         (glu::ContextInfo::create(m_renderCtx));
 600         RequiredExtensions                                              extensions;
 601
 602         // target
 603         if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
 604                 extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));
 605
 606         // param
 607         if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
 608                 extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));
 609
 610         // query
 611         if (!isCoreQuery(m_renderCtx.getType(), m_type))
 612                 extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));
 613
 614         // test type
 615         if (!isCoreTester(m_renderCtx.getType(), m_tester))
 616                 extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));
 617
 618         extensions.check(*ctxInfo);
 619 }
 620
 621 TextureTest::IterateResult TextureTest::iterate (void)
 622 {
 623         glu::CallLogWrapper             gl              (m_renderCtx.getFunctions(), m_testCtx.getLog());
 624         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
 625
 626         gl.enableLogging(true);
 627         test(gl, result);
 628
 629         result.setTestContextResult(m_testCtx);
 630         return STOP;
 631 }
 632
 633 class IsTextureCase : public tcu::TestCase
 634 {
 635 public:
 636                                                                 IsTextureCase   (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target);
 637
 638         void                                            init                    (void);
 639         IterateResult                           iterate                 (void);
 640
 641 protected:
 642         const glu::RenderContext&       m_renderCtx;
 643         const glw::GLenum                       m_target;
 644 };
 645
 646 IsTextureCase::IsTextureCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target)
 647         : tcu::TestCase (testCtx, name, desc)
 648         , m_renderCtx   (renderCtx)
 649         , m_target              (target)
 650 {
 651 }
 652
 653 void IsTextureCase::init (void)
 654 {
 655         const de::UniquePtr<glu::ContextInfo>   ctxInfo         (glu::ContextInfo::create(m_renderCtx));
 656         RequiredExtensions                                              extensions;
 657
 658         // target
 659         if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
 660                 extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));
 661
 662         extensions.check(*ctxInfo);
 663 }
 664
 665 IsTextureCase::IterateResult IsTextureCase::iterate (void)
 666 {
 667         glu::CallLogWrapper             gl                      (m_renderCtx.getFunctions(), m_testCtx.getLog());
 668         tcu::ResultCollector    result          (m_testCtx.getLog(), " // ERROR: ");
 669         glw::GLuint                             textureId       = 0;
 670
 671         gl.enableLogging(true);
 672
 673         gl.glGenTextures(1, &textureId);
 674         gl.glBindTexture(m_target, textureId);
 675         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
 676
 677         verifyStateObjectBoolean(result, gl, textureId, true, QUERY_ISTEXTURE);
 678
 679         gl.glDeleteTextures(1, &textureId);
 680         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
 681
 682         verifyStateObjectBoolean(result, gl, textureId, false, QUERY_ISTEXTURE);
 683
 684         result.setTestContextResult(m_testCtx);
 685         return STOP;
 686 }
 687
 688 class DepthStencilModeCase : public TextureTest
 689 {
 690 public:
 691                         DepthStencilModeCase    (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
 692         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
 693 };
 694
 695 DepthStencilModeCase::DepthStencilModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
 696         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
 697 {
 698 }
 699
 700 void DepthStencilModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
 701 {
 702         const bool              isPureCase      = isPureIntTester(m_tester) || isPureUintTester(m_tester);
 703         glu::Texture    texture         (m_renderCtx);
 704
 705         gl.glBindTexture(m_target, *texture);
 706         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");
 707
 708         if (!isPureCase)
 709         {
 710                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
 711                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
 712         }
 713
 714         if (!isPureCase)
 715         {
 716                 const tcu::ScopedLogSection     section                         (m_testCtx.getLog(), "Toggle", "Toggle");
 717                 const glw::GLint                        depthComponentInt       = GL_DEPTH_COMPONENT;
 718                 const glw::GLfloat                      depthComponentFloat     = (glw::GLfloat)GL_DEPTH_COMPONENT;
 719
 720                 gl.glTexParameteri(m_target, m_pname, GL_STENCIL_INDEX);
 721                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 722                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
 723
 724                 gl.glTexParameteriv(m_target, m_pname, &depthComponentInt);
 725                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 726                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
 727
 728                 gl.glTexParameterf(m_target, m_pname, GL_STENCIL_INDEX);
 729                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 730                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
 731
 732                 gl.glTexParameterfv(m_target, m_pname, &depthComponentFloat);
 733                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 734                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
 735         }
 736
 737         if (isPureIntTester(m_tester))
 738         {
 739                 const glw::GLint depthComponent = GL_DEPTH_COMPONENT;
 740                 const glw::GLint stencilIndex   = GL_STENCIL_INDEX;
 741
 742                 gl.glTexParameterIiv(m_target, m_pname, &stencilIndex);
 743                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 744                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
 745
 746                 gl.glTexParameterIiv(m_target, m_pname, &depthComponent);
 747                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 748                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
 749         }
 750
 751         if (isPureUintTester(m_tester))
 752         {
 753                 const glw::GLuint depthComponent        = GL_DEPTH_COMPONENT;
 754                 const glw::GLuint stencilIndex  = GL_STENCIL_INDEX;
 755
 756                 gl.glTexParameterIuiv(m_target, m_pname, &stencilIndex);
 757                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 758                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);
 759
 760                 gl.glTexParameterIuiv(m_target, m_pname, &depthComponent);
 761                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 762                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
 763         }
 764 }
 765
 766 class TextureSRGBDecodeCase : public TextureTest
 767 {
 768 public:
 769                         TextureSRGBDecodeCase   (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
 770         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
 771 };
 772
 773 TextureSRGBDecodeCase::TextureSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
 774         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
 775 {
 776 }
 777
 778 void TextureSRGBDecodeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
 779 {
 780         const bool              isPureCase      = isPureIntTester(m_tester) || isPureUintTester(m_tester);
 781         glu::Texture    texture         (m_renderCtx);
 782
 783         gl.glBindTexture(m_target, *texture);
 784         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");
 785
 786         if (!isPureCase)
 787         {
 788                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
 789                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
 790         }
 791
 792         if (!isPureCase)
 793         {
 794                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Toggle", "Toggle");
 795                 const glw::GLint                        decodeInt               = GL_DECODE_EXT;
 796                 const glw::GLfloat                      decodeFloat             = (glw::GLfloat)GL_DECODE_EXT;
 797
 798                 gl.glTexParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
 799                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 800                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
 801
 802                 gl.glTexParameteriv(m_target, m_pname, &decodeInt);
 803                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 804                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
 805
 806                 gl.glTexParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
 807                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 808                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
 809
 810                 gl.glTexParameterfv(m_target, m_pname, &decodeFloat);
 811                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
 812                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
 813         }
 814
 815         if (isPureIntTester(m_tester))
 816         {
 817                 const glw::GLint skipDecode     = GL_SKIP_DECODE_EXT;
 818                 const glw::GLint decode         = GL_DECODE_EXT;
 819
 820                 gl.glTexParameterIiv(m_target, m_pname, &skipDecode);
 821                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 822                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
 823
 824                 gl.glTexParameterIiv(m_target, m_pname, &decode);
 825                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 826                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
 827         }
 828
 829         if (isPureUintTester(m_tester))
 830         {
 831                 const glw::GLuint skipDecode    = GL_SKIP_DECODE_EXT;
 832                 const glw::GLuint decode                = GL_DECODE_EXT;
 833
 834                 gl.glTexParameterIuiv(m_target, m_pname, &skipDecode);
 835                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 836                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
 837
 838                 gl.glTexParameterIuiv(m_target, m_pname, &decode);
 839                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 840                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
 841         }
 842 }
 843
 844 class TextureSwizzleCase : public TextureTest
 845 {
 846 public:
 847                         TextureSwizzleCase      (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
 848         void    test                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
 849 };
 850
 851 TextureSwizzleCase::TextureSwizzleCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
 852         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
 853 {
 854 }
 855
 856 void TextureSwizzleCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
 857 {
 858         const bool      isPureCase              = isPureIntTester(m_tester) || isPureUintTester(m_tester);
 859         const int       initialValue    = (m_pname == GL_TEXTURE_SWIZZLE_R) ? (GL_RED) :
 860                                                                   (m_pname == GL_TEXTURE_SWIZZLE_G) ? (GL_GREEN) :
 861                                                                   (m_pname == GL_TEXTURE_SWIZZLE_B) ? (GL_BLUE) :
 862                                                                   (m_pname == GL_TEXTURE_SWIZZLE_A) ? (GL_ALPHA) :
 863                                                                   (-1);
 864
 865         if (!isPureCase)
 866         {
 867                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
 868                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
 869         }
 870
 871         {
 872                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
 873                 const GLenum                            swizzleValues[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE};
 874
 875                 if (isPureCase)
 876                 {
 877                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
 878                         {
 879                                 if (isPureIntTester(m_tester))
 880                                 {
 881                                         const glw::GLint value = (glw::GLint)swizzleValues[ndx];
 882                                         gl.glTexParameterIiv(m_target, m_pname, &value);
 883                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 884                                 }
 885                                 else
 886                                 {
 887                                         DE_ASSERT(isPureUintTester(m_tester));
 888
 889                                         const glw::GLuint value = swizzleValues[ndx];
 890                                         gl.glTexParameterIuiv(m_target, m_pname, &value);
 891                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 892                                 }
 893
 894                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
 895                         }
 896                 }
 897                 else
 898                 {
 899                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
 900                         {
 901                                 gl.glTexParameteri(m_target, m_pname, swizzleValues[ndx]);
 902                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
 903
 904                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
 905                         }
 906
 907                         //check unit conversions with float
 908
 909                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
 910                         {
 911                                 gl.glTexParameterf(m_target, m_pname, (GLfloat)swizzleValues[ndx]);
 912                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
 913
 914                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
 915                         }
 916                 }
 917         }
 918 }
 919
 920 class TextureWrapCase : public TextureTest
 921 {
 922 public:
 923                         TextureWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
 924         void    test                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
 925 };
 926
 927 TextureWrapCase::TextureWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
 928         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
 929 {
 930 }
 931
 932 void TextureWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
 933 {
 934         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
 935
 936         if (!isPureCase)
 937         {
 938                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
 939                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
 940         }
 941
 942         {
 943                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
 944                 const GLenum                            wrapValues[]    = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
 945
 946                 if (isPureCase)
 947                 {
 948                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
 949                         {
 950                                 if (isPureIntTester(m_tester))
 951                                 {
 952                                         const glw::GLint value = (glw::GLint)wrapValues[ndx];
 953                                         gl.glTexParameterIiv(m_target, m_pname, &value);
 954                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
 955                                 }
 956                                 else
 957                                 {
 958                                         DE_ASSERT(isPureUintTester(m_tester));
 959
 960                                         const glw::GLuint value = wrapValues[ndx];
 961                                         gl.glTexParameterIuiv(m_target, m_pname, &value);
 962                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
 963                                 }
 964
 965                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
 966                         }
 967                 }
 968                 else
 969                 {
 970                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
 971                         {
 972                                 gl.glTexParameteri(m_target, m_pname, wrapValues[ndx]);
 973                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
 974
 975                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
 976                         }
 977
 978                         //check unit conversions with float
 979
 980                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
 981                         {
 982                                 gl.glTexParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
 983                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
 984
 985                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
 986                         }
 987                 }
 988         }
 989 }
 990
 991 class TextureFilterCase : public TextureTest
 992 {
 993 public:
 994                         TextureFilterCase       (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
 995         void    test                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
 996 };
 997
 998 TextureFilterCase::TextureFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
 999         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1000 {
1001 }
1002
1003 void TextureFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1004 {
1005         const bool                      isPureCase      = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1006         const glw::GLenum       initial         = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
1007                                                                         : (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR)
1008                                                                         : (0);
1009
1010         if (!isPureCase)
1011         {
1012                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1013                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initial, m_type);
1014         }
1015
1016         {
1017                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Set", "Set");
1018                 std::vector<GLenum>                     values;
1019
1020                 values.push_back(GL_NEAREST);
1021                 values.push_back(GL_LINEAR);
1022                 if (m_pname == GL_TEXTURE_MIN_FILTER)
1023                 {
1024                         values.push_back(GL_NEAREST_MIPMAP_NEAREST);
1025                         values.push_back(GL_NEAREST_MIPMAP_LINEAR);
1026                         values.push_back(GL_LINEAR_MIPMAP_NEAREST);
1027                         values.push_back(GL_LINEAR_MIPMAP_LINEAR);
1028                 }
1029
1030                 if (isPureCase)
1031                 {
1032                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1033                         {
1034                                 if (isPureIntTester(m_tester))
1035                                 {
1036                                         const glw::GLint value = (glw::GLint)values[ndx];
1037                                         gl.glTexParameterIiv(m_target, m_pname, &value);
1038                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1039                                 }
1040                                 else
1041                                 {
1042                                         DE_ASSERT(isPureUintTester(m_tester));
1043
1044                                         const glw::GLuint value = values[ndx];
1045                                         gl.glTexParameterIuiv(m_target, m_pname, &value);
1046                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1047                                 }
1048
1049                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1050                         }
1051                 }
1052                 else
1053                 {
1054                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1055                         {
1056                                 gl.glTexParameteri(m_target, m_pname, values[ndx]);
1057                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1058
1059                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1060                         }
1061
1062                         //check unit conversions with float
1063
1064                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1065                         {
1066                                 gl.glTexParameterf(m_target, m_pname, (GLfloat)values[ndx]);
1067                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1068
1069                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1070                         }
1071                 }
1072         }
1073 }
1074
1075 class TextureLODCase : public TextureTest
1076 {
1077 public:
1078                         TextureLODCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1079         void    test                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1080 };
1081
1082 TextureLODCase::TextureLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1083         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1084 {
1085 }
1086
1087 void TextureLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1088 {
1089         const bool      isPureCase              = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1090         const int       initialValue    = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
1091                                                                 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
1092                                                                 : (-1);
1093
1094         if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
1095         {
1096                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1097                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1098         }
1099
1100         {
1101                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1102                 const int                                       numIterations   = 20;
1103                 de::Random                                      rnd                             (0xabcdef);
1104
1105                 if (isPureCase)
1106                 {
1107                         if (isPureIntTester(m_tester))
1108                         {
1109                                 for (int ndx = 0; ndx < numIterations; ++ndx)
1110                                 {
1111                                         const GLint ref = rnd.getInt(-1000, 1000);
1112
1113                                         gl.glTexParameterIiv(m_target, m_pname, &ref);
1114                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1115
1116                                         verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1117                                 }
1118                         }
1119                         else
1120                         {
1121                                 DE_ASSERT(isPureUintTester(m_tester));
1122
1123                                 for (int ndx = 0; ndx < numIterations; ++ndx)
1124                                 {
1125                                         const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
1126
1127                                         gl.glTexParameterIuiv(m_target, m_pname, &ref);
1128                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1129
1130                                         verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1131                                 }
1132                         }
1133                 }
1134                 else
1135                 {
1136                         const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
1137
1138                         for (int ndx = 0; ndx < numIterations; ++ndx)
1139                         {
1140                                 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
1141
1142                                 gl.glTexParameterf(m_target, m_pname, ref);
1143                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1144
1145                                 verifyStateTextureParamFloat(result, gl, m_target, m_pname, ref, m_type);
1146                         }
1147
1148                         // check unit conversions with int
1149
1150                         for (int ndx = 0; ndx < numIterations; ++ndx)
1151                         {
1152                                 const GLint ref = rnd.getInt(minLimit, 1000);
1153
1154                                 gl.glTexParameteri(m_target, m_pname, ref);
1155                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1156
1157                                 verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1158                         }
1159                 }
1160         }
1161 }
1162
1163 class TextureLevelCase : public TextureTest
1164 {
1165 public:
1166                         TextureLevelCase        (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1167         void    test                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1168 };
1169
1170 TextureLevelCase::TextureLevelCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1171         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1172 {
1173 }
1174
1175 void TextureLevelCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1176 {
1177         const bool      isPureCase              = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1178         const int       initialValue    = (m_pname == GL_TEXTURE_BASE_LEVEL) ? (0)
1179                                                                 : (m_pname == GL_TEXTURE_MAX_LEVEL)     ? (1000)
1180                                                                 : (-1);
1181
1182         if (!isPureCase)
1183         {
1184                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1185                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1186         }
1187
1188         if (m_target == GL_TEXTURE_2D_MULTISAMPLE               ||
1189                 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1190         {
1191                 // only 0 allowed
1192                 {
1193                         const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
1194
1195                         gl.glTexParameteri(m_target, m_pname, 0);
1196                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1197                         verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1198
1199                         gl.glTexParameterf(m_target, m_pname, 0.0f);
1200                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1201                         verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1202                 }
1203         }
1204         else
1205         {
1206                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1207                 const int                                       numIterations   = 20;
1208                 de::Random                                      rnd                             (0xabcdef);
1209
1210                 if (isPureCase)
1211                 {
1212                         for (int ndx = 0; ndx < numIterations; ++ndx)
1213                         {
1214                                 const GLint             ref             = rnd.getInt(0, 64000);
1215                                 const GLuint    uRef    = (glw::GLuint)ref;
1216
1217                                 if (isPureIntTester(m_tester))
1218                                 {
1219                                         gl.glTexParameterIiv(m_target, m_pname, &ref);
1220                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1221                                 }
1222                                 else
1223                                 {
1224                                         DE_ASSERT(isPureUintTester(m_tester));
1225                                         gl.glTexParameterIuiv(m_target, m_pname, &uRef);
1226                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1227                                 }
1228
1229                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1230                         }
1231                 }
1232                 else
1233                 {
1234                         for (int ndx = 0; ndx < numIterations; ++ndx)
1235                         {
1236                                 const GLint ref = rnd.getInt(0, 64000);
1237
1238                                 gl.glTexParameteri(m_target, m_pname, ref);
1239                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1240
1241                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1242                         }
1243
1244                         // check unit conversions with float
1245
1246                         const float nonSignificantOffsets[] = {-0.45f, -0.25f, 0, 0.45f}; // offsets O so that for any integers z in Z, o in O roundToClosestInt(z+o)==z
1247
1248                         const int numConversionIterations = 30;
1249                         for (int ndx = 0; ndx < numConversionIterations; ++ndx)
1250                         {
1251                                 const GLint ref = rnd.getInt(1, 64000);
1252
1253                                 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(nonSignificantOffsets); ++offsetNdx)
1254                                 {
1255                                         gl.glTexParameterf(m_target, m_pname, ((GLfloat)ref) + nonSignificantOffsets[offsetNdx]);
1256                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1257
1258                                         verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
1259                                 }
1260                         }
1261                 }
1262         }
1263 }
1264
1265 class TextureCompareModeCase : public TextureTest
1266 {
1267 public:
1268                         TextureCompareModeCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1269         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1270 };
1271
1272 TextureCompareModeCase::TextureCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1273         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1274 {
1275 }
1276
1277 void TextureCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1278 {
1279         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1280
1281         if (!isPureCase)
1282         {
1283                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1284                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
1285         }
1286
1287         {
1288                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Set", "Set");
1289                 const GLenum                            modes[]         = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
1290
1291                 if (isPureCase)
1292                 {
1293                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1294                         {
1295                                 if (isPureIntTester(m_tester))
1296                                 {
1297                                         const glw::GLint value = (glw::GLint)modes[ndx];
1298                                         gl.glTexParameterIiv(m_target, m_pname, &value);
1299                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1300                                 }
1301                                 else
1302                                 {
1303                                         DE_ASSERT(isPureUintTester(m_tester));
1304
1305                                         const glw::GLuint value = modes[ndx];
1306                                         gl.glTexParameterIuiv(m_target, m_pname, &value);
1307                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1308                                 }
1309
1310                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1311                         }
1312                 }
1313                 else
1314                 {
1315                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1316                         {
1317                                 gl.glTexParameteri(m_target, m_pname, modes[ndx]);
1318                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1319
1320                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1321                         }
1322
1323                         //check unit conversions with float
1324
1325                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
1326                         {
1327                                 gl.glTexParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
1328                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1329
1330                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
1331                         }
1332                 }
1333         }
1334 }
1335
1336 class TextureCompareFuncCase : public TextureTest
1337 {
1338 public:
1339                         TextureCompareFuncCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1340         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1341 };
1342
1343 TextureCompareFuncCase::TextureCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1344         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1345 {
1346 }
1347
1348 void TextureCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1349 {
1350         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1351
1352         if (!isPureCase)
1353         {
1354                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1355                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
1356         }
1357
1358         {
1359                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1360                 const GLenum                            compareFuncs[]  = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
1361
1362                 if (isPureCase)
1363                 {
1364                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1365                         {
1366                                 if (isPureIntTester(m_tester))
1367                                 {
1368                                         const glw::GLint value = (glw::GLint)compareFuncs[ndx];
1369                                         gl.glTexParameterIiv(m_target, m_pname, &value);
1370                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1371                                 }
1372                                 else
1373                                 {
1374                                         DE_ASSERT(isPureUintTester(m_tester));
1375
1376                                         const glw::GLuint value = compareFuncs[ndx];
1377                                         gl.glTexParameterIuiv(m_target, m_pname, &value);
1378                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1379                                 }
1380
1381                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1382                         }
1383                 }
1384                 else
1385                 {
1386                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1387                         {
1388                                 gl.glTexParameteri(m_target, m_pname, compareFuncs[ndx]);
1389                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1390
1391                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1392                         }
1393
1394                         //check unit conversions with float
1395
1396                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
1397                         {
1398                                 gl.glTexParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
1399                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1400
1401                                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
1402                         }
1403                 }
1404         }
1405 }
1406
1407 class TextureImmutableLevelsCase : public TextureTest
1408 {
1409 public:
1410                         TextureImmutableLevelsCase      (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1411         void    test                                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1412 };
1413
1414 TextureImmutableLevelsCase::TextureImmutableLevelsCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1415         : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_LEVELS, type)
1416 {
1417 }
1418
1419 void TextureImmutableLevelsCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1420 {
1421         {
1422                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1423                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1424         }
1425
1426         if (m_target == GL_TEXTURE_2D_MULTISAMPLE               ||
1427                 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1428         {
1429                 // no levels
1430                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Level", "Level");
1431                 GLuint                                          textureID       = 0;
1432
1433                 gl.glGenTextures(1, &textureID);
1434                 gl.glBindTexture(m_target, textureID);
1435                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1436
1437                 if (m_target == GL_TEXTURE_2D_MULTISAMPLE)
1438                         gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1439                 else if (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1440                         gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1441                 else
1442                         DE_ASSERT(false);
1443                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1444
1445                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1446
1447                 gl.glDeleteTextures(1, &textureID);
1448                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1449         }
1450         else
1451         {
1452                 for (int level = 1; level <= 7; ++level)
1453                 {
1454                         const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Levels", "Levels = " + de::toString(level));
1455                         GLuint                                          textureID       = 0;
1456
1457                         gl.glGenTextures(1, &textureID);
1458                         gl.glBindTexture(m_target, textureID);
1459                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1460
1461                         if (m_target == GL_TEXTURE_2D || m_target == GL_TEXTURE_CUBE_MAP)
1462                                 gl.glTexStorage2D(m_target, level, GL_RGB8, 64, 64);
1463                         else if (m_target == GL_TEXTURE_2D_ARRAY || m_target == GL_TEXTURE_3D)
1464                                 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 64);
1465                         else if (m_target == GL_TEXTURE_CUBE_MAP_ARRAY)
1466                                 gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 6 * 2);
1467                         else
1468                                 DE_ASSERT(false);
1469                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");
1470
1471                         verifyStateTextureParamInteger(result, gl, m_target, m_pname, level, m_type);
1472
1473                         gl.glDeleteTextures(1, &textureID);
1474                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1475                 }
1476         }
1477 }
1478
1479 class TextureImmutableFormatCase : public TextureTest
1480 {
1481 public:
1482                         TextureImmutableFormatCase      (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1483         void    test                                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1484 };
1485
1486 TextureImmutableFormatCase::TextureImmutableFormatCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1487         : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_FORMAT, type)
1488 {
1489 }
1490
1491 void TextureImmutableFormatCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1492 {
1493         {
1494                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1495                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1496         }
1497
1498         {
1499                 const tcu::ScopedLogSection     subsection      (m_testCtx.getLog(), "Immutable", "Immutable");
1500                 GLuint                                          textureID       = 0;
1501
1502                 gl.glGenTextures(1, &textureID);
1503                 gl.glBindTexture(m_target, textureID);
1504                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1505
1506                 switch (m_target)
1507                 {
1508                         case GL_TEXTURE_2D:
1509                         case GL_TEXTURE_CUBE_MAP:
1510                         {
1511                                 gl.glTexStorage2D(m_target, 1, GL_RGBA8, 32, 32);
1512                                 break;
1513                         }
1514                         case GL_TEXTURE_2D_ARRAY:
1515                         case GL_TEXTURE_3D:
1516                         {
1517                                 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 8);
1518                                 break;
1519                         }
1520                         case GL_TEXTURE_2D_MULTISAMPLE:
1521                         {
1522                                 gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
1523                                 break;
1524                         }
1525                         case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
1526                         {
1527                                 gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
1528                                 break;
1529                         }
1530                         case GL_TEXTURE_CUBE_MAP_ARRAY:
1531                         {
1532                                 gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 6 * 2);
1533                                 break;
1534                         }
1535                         default:
1536                                 DE_ASSERT(false);
1537                 }
1538                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1539
1540                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);
1541
1542                 gl.glDeleteTextures(1, &textureID);
1543                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1544         }
1545
1546         // no mutable
1547         if (m_target == GL_TEXTURE_2D_MULTISAMPLE ||
1548                 m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
1549                 return;
1550
1551         // test mutable
1552         {
1553                 const tcu::ScopedLogSection     subsection              (m_testCtx.getLog(), "Mutable", "Mutable");
1554                 GLuint                                          textureID               = 0;
1555
1556                 gl.glGenTextures(1, &textureID);
1557                 gl.glBindTexture(m_target, textureID);
1558                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1559
1560                 switch (m_target)
1561                 {
1562                         case GL_TEXTURE_2D:
1563                         {
1564                                 gl.glTexImage2D(m_target, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1565                                 break;
1566                         }
1567                         case GL_TEXTURE_CUBE_MAP:
1568                         {
1569                                 gl.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1570                                 break;
1571                         }
1572                         case GL_TEXTURE_2D_ARRAY:
1573                         case GL_TEXTURE_3D:
1574                         {
1575                                 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1576                                 break;
1577                         }
1578                         case GL_TEXTURE_CUBE_MAP_ARRAY:
1579                         {
1580                                 gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 6 * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
1581                                 break;
1582                         }
1583                         default:
1584                                 DE_ASSERT(false);
1585                 }
1586                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");
1587
1588                 verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
1589
1590                 gl.glDeleteTextures(1, &textureID);
1591                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1592         }
1593 }
1594
1595 class TextureWrapClampToBorderCase : public TextureTest
1596 {
1597 public:
1598                         TextureWrapClampToBorderCase    (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type);
1599         void    test                                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1600 };
1601
1602 TextureWrapClampToBorderCase::TextureWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, TesterType tester, QueryType type)
1603         : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
1604 {
1605 }
1606
1607 void TextureWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1608 {
1609         gl.glTexParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
1610         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1611         verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1612
1613         gl.glTexParameteri(m_target, m_pname, GL_REPEAT);
1614         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
1615
1616         gl.glTexParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
1617         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
1618
1619         verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
1620 }
1621
1622 class TextureBorderColorCase : public TextureTest
1623 {
1624 public:
1625                         TextureBorderColorCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, glw::GLenum target, QueryType type);
1626         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1627 };
1628
1629 TextureBorderColorCase::TextureBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, glw::GLenum target, QueryType type)
1630         : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_BORDER_COLOR, type)
1631 {
1632 }
1633
1634 void TextureBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1635 {
1636         // border color is undefined if queried with pure type and was not set to pure value
1637         if (m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4)
1638         {
1639                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1640                 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
1641         }
1642
1643         if (m_type == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4)
1644         {
1645                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1646                 const tcu::IVec4                        color                   (0x7FFFFFFF, -2, 3, -128);
1647
1648                 gl.glTexParameterIiv(m_target, m_pname, color.getPtr());
1649                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
1650
1651                 verifyStateTextureParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1652         }
1653         else if (m_type == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
1654         {
1655                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1656                 const tcu::UVec4                        color                   (0x8000000ul, 2, 3, 128);
1657
1658                 gl.glTexParameterIuiv(m_target, m_pname, color.getPtr());
1659                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
1660
1661                 verifyStateTextureParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
1662         }
1663         else
1664         {
1665                 DE_ASSERT(m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4);
1666
1667                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1668                 const tcu::Vec4                         color                   (0.25f, 1.0f, 0.0f, 0.77f);
1669                 const tcu::IVec4                        icolor                  (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
1670
1671                 gl.glTexParameterfv(m_target, m_pname, color.getPtr());
1672                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterfv");
1673
1674                 verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
1675
1676                 gl.glTexParameteriv(m_target, m_pname, icolor.getPtr());
1677                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteriv");
1678
1679                 verifyStateTextureParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
1680         }
1681 }
1682
1683 class SamplerTest : public tcu::TestCase
1684 {
1685 public:
1686                                                 SamplerTest     (tcu::TestContext&                      testCtx,
1687                                                                          const glu::RenderContext&      renderCtx,
1688                                                                          const char*                            name,
1689                                                                          const char*                            desc,
1690                                                                          TesterType                                     tester,
1691                                                                          QueryType                                      type);
1692
1693         void                            init            (void);
1694         IterateResult           iterate         (void);
1695
1696         virtual void            test            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
1697
1698 protected:
1699         const glu::RenderContext&       m_renderCtx;
1700         const glw::GLenum                       m_pname;
1701         const TesterType                        m_tester;
1702         const QueryType                         m_type;
1703         glw::GLuint                                     m_target;
1704 };
1705
1706 SamplerTest::SamplerTest (tcu::TestContext&                     testCtx,
1707                                                   const glu::RenderContext&     renderCtx,
1708                                                   const char*                           name,
1709                                                   const char*                           desc,
1710                                                   TesterType                            tester,
1711                                                   QueryType                                     type)
1712         : TestCase              (testCtx, name, desc)
1713         , m_renderCtx   (renderCtx)
1714         , m_pname               (mapTesterToPname(tester))
1715         , m_tester              (tester)
1716         , m_type                (type)
1717         , m_target              (0)
1718 {
1719 }
1720
1721 void SamplerTest::init (void)
1722 {
1723         const de::UniquePtr<glu::ContextInfo>   ctxInfo         (glu::ContextInfo::create(m_renderCtx));
1724         RequiredExtensions                                              extensions;
1725
1726         // param
1727         if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
1728                 extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));
1729
1730         // query
1731         if (!isCoreQuery(m_renderCtx.getType(), m_type))
1732                 extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));
1733
1734         // test type
1735         if (!isCoreTester(m_renderCtx.getType(), m_tester))
1736                 extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));
1737
1738         extensions.check(*ctxInfo);
1739 }
1740
1741 SamplerTest::IterateResult SamplerTest::iterate (void)
1742 {
1743         glu::CallLogWrapper             gl              (m_renderCtx.getFunctions(), m_testCtx.getLog());
1744         tcu::ResultCollector    result  (m_testCtx.getLog(), " // ERROR: ");
1745         glu::Sampler                    sampler (m_renderCtx);
1746
1747         gl.enableLogging(true);
1748
1749         m_target = *sampler;
1750         test(gl, result);
1751         m_target = 0;
1752
1753         result.setTestContextResult(m_testCtx);
1754         return STOP;
1755 }
1756
1757 class SamplerWrapCase : public SamplerTest
1758 {
1759 public:
1760                         SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
1761         void    test                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1762 };
1763
1764 SamplerWrapCase::SamplerWrapCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
1765         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
1766 {
1767 }
1768
1769 void SamplerWrapCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1770 {
1771         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1772
1773         if (!isPureCase)
1774         {
1775                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1776                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
1777         }
1778
1779         {
1780                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1781                 const GLenum                            wrapValues[]    = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};
1782
1783                 if (isPureCase)
1784                 {
1785                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1786                         {
1787                                 if (isPureIntTester(m_tester))
1788                                 {
1789                                         const glw::GLint value = (glw::GLint)wrapValues[ndx];
1790                                         gl.glSamplerParameterIiv(m_target, m_pname, &value);
1791                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
1792                                 }
1793                                 else
1794                                 {
1795                                         DE_ASSERT(isPureUintTester(m_tester));
1796
1797                                         const glw::GLuint value = wrapValues[ndx];
1798                                         gl.glSamplerParameterIuiv(m_target, m_pname, &value);
1799                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
1800                                 }
1801
1802                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1803                         }
1804                 }
1805                 else
1806                 {
1807                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1808                         {
1809                                 gl.glSamplerParameteri(m_target, m_pname, wrapValues[ndx]);
1810                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
1811
1812                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1813                         }
1814
1815                         //check unit conversions with float
1816
1817                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
1818                         {
1819                                 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
1820                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
1821
1822                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
1823                         }
1824                 }
1825         }
1826 }
1827
1828 class SamplerFilterCase : public SamplerTest
1829 {
1830 public:
1831                         SamplerFilterCase       (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
1832         void    test                            (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1833 };
1834
1835 SamplerFilterCase::SamplerFilterCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
1836         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
1837 {
1838 }
1839
1840 void SamplerFilterCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1841 {
1842         const bool                      isPureCase      = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1843         const glw::GLenum       initial         = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR)
1844                                                                         : (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR)
1845                                                                         : (0);
1846
1847         if (!isPureCase)
1848         {
1849                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1850                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initial, m_type);
1851         }
1852
1853         {
1854                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Set", "Set");
1855                 std::vector<GLenum>                     values;
1856
1857                 values.push_back(GL_NEAREST);
1858                 values.push_back(GL_LINEAR);
1859                 if (m_pname == GL_TEXTURE_MIN_FILTER)
1860                 {
1861                         values.push_back(GL_NEAREST_MIPMAP_NEAREST);
1862                         values.push_back(GL_NEAREST_MIPMAP_LINEAR);
1863                         values.push_back(GL_LINEAR_MIPMAP_NEAREST);
1864                         values.push_back(GL_LINEAR_MIPMAP_LINEAR);
1865                 }
1866
1867                 if (isPureCase)
1868                 {
1869                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1870                         {
1871                                 if (isPureIntTester(m_tester))
1872                                 {
1873                                         const glw::GLint value = (glw::GLint)values[ndx];
1874                                         gl.glSamplerParameterIiv(m_target, m_pname, &value);
1875                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
1876                                 }
1877                                 else
1878                                 {
1879                                         DE_ASSERT(isPureUintTester(m_tester));
1880
1881                                         const glw::GLuint value = values[ndx];
1882                                         gl.glSamplerParameterIuiv(m_target, m_pname, &value);
1883                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
1884                                 }
1885
1886                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1887                         }
1888                 }
1889                 else
1890                 {
1891                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1892                         {
1893                                 gl.glSamplerParameteri(m_target, m_pname, values[ndx]);
1894                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
1895
1896                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1897                         }
1898
1899                         //check unit conversions with float
1900
1901                         for (int ndx = 0; ndx < (int)values.size(); ++ndx)
1902                         {
1903                                 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)values[ndx]);
1904                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
1905
1906                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
1907                         }
1908                 }
1909         }
1910 }
1911
1912 class SamplerLODCase : public SamplerTest
1913 {
1914 public:
1915                         SamplerLODCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
1916         void    test                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
1917 };
1918
1919 SamplerLODCase::SamplerLODCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
1920         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
1921 {
1922 }
1923
1924 void SamplerLODCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1925 {
1926         const bool      isPureCase              = isPureIntTester(m_tester) || isPureUintTester(m_tester);
1927         const int       initialValue    = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000)
1928                                                                 : (m_pname == GL_TEXTURE_MAX_LOD) ? (1000)
1929                                                                 : (-1);
1930
1931         if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
1932         {
1933                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
1934                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
1935         }
1936
1937         {
1938                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
1939                 const int                                       numIterations   = 20;
1940                 de::Random                                      rnd                             (0xabcdef);
1941
1942                 if (isPureCase)
1943                 {
1944                         if (isPureIntTester(m_tester))
1945                         {
1946                                 for (int ndx = 0; ndx < numIterations; ++ndx)
1947                                 {
1948                                         const GLint ref = rnd.getInt(-1000, 1000);
1949
1950                                         gl.glSamplerParameterIiv(m_target, m_pname, &ref);
1951                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
1952
1953                                         verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1954                                 }
1955                         }
1956                         else
1957                         {
1958                                 DE_ASSERT(isPureUintTester(m_tester));
1959
1960                                 for (int ndx = 0; ndx < numIterations; ++ndx)
1961                                 {
1962                                         const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);
1963
1964                                         gl.glSamplerParameterIuiv(m_target, m_pname, &ref);
1965                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
1966
1967                                         verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1968                                 }
1969                         }
1970                 }
1971                 else
1972                 {
1973                         const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);
1974
1975                         for (int ndx = 0; ndx < numIterations; ++ndx)
1976                         {
1977                                 const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);
1978
1979                                 gl.glSamplerParameterf(m_target, m_pname, ref);
1980                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
1981
1982                                 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, ref, m_type);
1983                         }
1984
1985                         // check unit conversions with int
1986
1987                         for (int ndx = 0; ndx < numIterations; ++ndx)
1988                         {
1989                                 const GLint ref = rnd.getInt(minLimit, 1000);
1990
1991                                 gl.glSamplerParameteri(m_target, m_pname, ref);
1992                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
1993
1994                                 verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
1995                         }
1996                 }
1997         }
1998 }
1999
2000 class SamplerCompareModeCase : public SamplerTest
2001 {
2002 public:
2003                         SamplerCompareModeCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2004         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2005 };
2006
2007 SamplerCompareModeCase::SamplerCompareModeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2008         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2009 {
2010 }
2011
2012 void SamplerCompareModeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2013 {
2014         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2015
2016         if (!isPureCase)
2017         {
2018                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2019                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
2020         }
2021
2022         {
2023                 const tcu::ScopedLogSection     section         (m_testCtx.getLog(), "Set", "Set");
2024                 const GLenum                            modes[]         = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};
2025
2026                 if (isPureCase)
2027                 {
2028                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2029                         {
2030                                 if (isPureIntTester(m_tester))
2031                                 {
2032                                         const glw::GLint value = (glw::GLint)modes[ndx];
2033                                         gl.glSamplerParameterIiv(m_target, m_pname, &value);
2034                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2035                                 }
2036                                 else
2037                                 {
2038                                         DE_ASSERT(isPureUintTester(m_tester));
2039
2040                                         const glw::GLuint value = modes[ndx];
2041                                         gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2042                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2043                                 }
2044
2045                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2046                         }
2047                 }
2048                 else
2049                 {
2050                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2051                         {
2052                                 gl.glSamplerParameteri(m_target, m_pname, modes[ndx]);
2053                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2054
2055                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2056                         }
2057
2058                         //check unit conversions with float
2059
2060                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
2061                         {
2062                                 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
2063                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2064
2065                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
2066                         }
2067                 }
2068         }
2069 }
2070
2071 class SamplerCompareFuncCase : public SamplerTest
2072 {
2073 public:
2074                         SamplerCompareFuncCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2075         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2076 };
2077
2078 SamplerCompareFuncCase::SamplerCompareFuncCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2079         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2080 {
2081 }
2082
2083 void SamplerCompareFuncCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2084 {
2085         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2086
2087         if (!isPureCase)
2088         {
2089                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2090                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
2091         }
2092
2093         {
2094                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
2095                 const GLenum                            compareFuncs[]  = {GL_LEQUAL, GL_GEQUAL, GL_LESS, GL_GREATER, GL_EQUAL, GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};
2096
2097                 if (isPureCase)
2098                 {
2099                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2100                         {
2101                                 if (isPureIntTester(m_tester))
2102                                 {
2103                                         const glw::GLint value = (glw::GLint)compareFuncs[ndx];
2104                                         gl.glSamplerParameterIiv(m_target, m_pname, &value);
2105                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2106                                 }
2107                                 else
2108                                 {
2109                                         DE_ASSERT(isPureUintTester(m_tester));
2110
2111                                         const glw::GLuint value = compareFuncs[ndx];
2112                                         gl.glSamplerParameterIuiv(m_target, m_pname, &value);
2113                                         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2114                                 }
2115
2116                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2117                         }
2118                 }
2119                 else
2120                 {
2121                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2122                         {
2123                                 gl.glSamplerParameteri(m_target, m_pname, compareFuncs[ndx]);
2124                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2125
2126                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2127                         }
2128
2129                         //check unit conversions with float
2130
2131                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
2132                         {
2133                                 gl.glSamplerParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
2134                                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2135
2136                                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
2137                         }
2138                 }
2139         }
2140 }
2141
2142 class SamplerWrapClampToBorderCase : public SamplerTest
2143 {
2144 public:
2145                         SamplerWrapClampToBorderCase    (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2146         void    test                                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2147 };
2148
2149 SamplerWrapClampToBorderCase::SamplerWrapClampToBorderCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2150         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2151 {
2152 }
2153
2154 void SamplerWrapClampToBorderCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2155 {
2156         gl.glSamplerParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
2157         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2158         verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2159
2160         gl.glSamplerParameteri(m_target, m_pname, GL_REPEAT);
2161         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
2162
2163         gl.glSamplerParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
2164         GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");
2165
2166         verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
2167 }
2168
2169 class SamplerSRGBDecodeCase : public SamplerTest
2170 {
2171 public:
2172                         SamplerSRGBDecodeCase   (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, TesterType tester, QueryType type);
2173         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2174 };
2175
2176 SamplerSRGBDecodeCase::SamplerSRGBDecodeCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, TesterType tester, QueryType type)
2177         : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
2178 {
2179 }
2180
2181 void SamplerSRGBDecodeCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2182 {
2183         const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
2184
2185         if (!isPureCase)
2186         {
2187                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2188                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2189         }
2190
2191         {
2192                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Toggle", "Toggle");
2193                 const glw::GLint                        decodeInt               = GL_DECODE_EXT;
2194                 const glw::GLfloat                      decodeFloat             = (glw::GLfloat)GL_DECODE_EXT;
2195
2196                 gl.glSamplerParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
2197                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2198                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2199
2200                 gl.glSamplerParameteriv(m_target, m_pname, &decodeInt);
2201                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2202                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2203
2204                 gl.glSamplerParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
2205                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2206                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2207
2208                 gl.glSamplerParameterfv(m_target, m_pname, &decodeFloat);
2209                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
2210                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2211         }
2212
2213         if (isPureIntTester(m_tester))
2214         {
2215                 const glw::GLint skipDecode     = GL_SKIP_DECODE_EXT;
2216                 const glw::GLint decode         = GL_DECODE_EXT;
2217
2218                 gl.glSamplerParameterIiv(m_target, m_pname, &skipDecode);
2219                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2220                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2221
2222                 gl.glSamplerParameterIiv(m_target, m_pname, &decode);
2223                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2224                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2225         }
2226
2227         if (isPureUintTester(m_tester))
2228         {
2229                 const glw::GLuint skipDecode    = GL_SKIP_DECODE_EXT;
2230                 const glw::GLuint decode                = GL_DECODE_EXT;
2231
2232                 gl.glSamplerParameterIuiv(m_target, m_pname, &skipDecode);
2233                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2234                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);
2235
2236                 gl.glSamplerParameterIuiv(m_target, m_pname, &decode);
2237                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2238                 verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
2239         }
2240 }
2241
2242 class SamplerBorderColorCase : public SamplerTest
2243 {
2244 public:
2245                         SamplerBorderColorCase  (tcu::TestContext& testCtx, const glu::RenderContext& renderContext, const char* name, const char* desc, QueryType type);
2246         void    test                                    (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const;
2247 };
2248
2249 SamplerBorderColorCase::SamplerBorderColorCase (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const char* name, const char* desc, QueryType type)
2250         : SamplerTest(testCtx, renderCtx, name, desc, TESTER_TEXTURE_BORDER_COLOR, type)
2251 {
2252         DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4                                    ||
2253                           m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4                                              ||
2254                           m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4                               ||
2255                           m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4);
2256 }
2257
2258 void SamplerBorderColorCase::test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
2259 {
2260         // border color is undefined if queried with pure type and was not set to pure value
2261         if (m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4)
2262         {
2263                 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
2264                 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
2265         }
2266
2267         if (m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4)
2268         {
2269                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
2270                 const tcu::IVec4                        color                   (0x7FFFFFFF, -2, 3, -128);
2271
2272                 gl.glSamplerParameterIiv(m_target, m_pname, color.getPtr());
2273                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
2274
2275                 verifyStateSamplerParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2276         }
2277         else if (m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
2278         {
2279                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
2280                 const tcu::UVec4                        color                   (0x8000000ul, 2, 3, 128);
2281
2282                 gl.glSamplerParameterIuiv(m_target, m_pname, color.getPtr());
2283                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
2284
2285                 verifyStateSamplerParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
2286         }
2287         else
2288         {
2289                 DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4);
2290
2291                 const tcu::ScopedLogSection     section                 (m_testCtx.getLog(), "Set", "Set");
2292                 const tcu::Vec4                         color                   (0.25f, 1.0f, 0.0f, 0.77f);
2293                 const tcu::IVec4                        icolor                  (0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);
2294
2295                 gl.glSamplerParameterfv(m_target, m_pname, color.getPtr());
2296                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterfv");
2297
2298                 verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, color, m_type);
2299
2300                 gl.glSamplerParameteriv(m_target, m_pname, icolor.getPtr());
2301                 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteriv");
2302
2303                 verifyStateSamplerParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
2304         }
2305 }
2306
2307 } // anonymous
2308
2309 bool isLegalTesterForTarget (glw::GLenum target, TesterType tester)
2310 {
2311         // no 3d filtering on 2d targets
2312         if ((tester == TESTER_TEXTURE_WRAP_R || tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER) &&  target != GL_TEXTURE_3D)
2313                 return false;
2314
2315         // no sampling on multisample
2316         if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2317                 return false;
2318
2319         // no states in buffer
2320         if (target == GL_TEXTURE_BUFFER)
2321                 return false;
2322
2323         return true;
2324 }
2325
2326 bool isMultisampleTarget (glw::GLenum target)
2327 {
2328         return  target == GL_TEXTURE_2D_MULTISAMPLE                     ||
2329                         target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
2330 }
2331
2332 bool isSamplerStateTester (TesterType tester)
2333 {
2334         return  tester == TESTER_TEXTURE_WRAP_S                                 ||
2335                         tester == TESTER_TEXTURE_WRAP_T                                 ||
2336                         tester == TESTER_TEXTURE_WRAP_R                                 ||
2337                         tester == TESTER_TEXTURE_MAG_FILTER                             ||
2338                         tester == TESTER_TEXTURE_MIN_FILTER                             ||
2339                         tester == TESTER_TEXTURE_MIN_LOD                                ||
2340                         tester == TESTER_TEXTURE_MAX_LOD                                ||
2341                         tester == TESTER_TEXTURE_COMPARE_MODE                   ||
2342                         tester == TESTER_TEXTURE_COMPARE_FUNC                   ||
2343                         tester == TESTER_TEXTURE_SRGB_DECODE_EXT                ||
2344                         tester == TESTER_TEXTURE_BORDER_COLOR                   ||
2345                         tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER ||
2346                         tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
2347                         tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER;
2348 }
2349
2350 tcu::TestCase* createIsTextureTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, glw::GLenum target)
2351 {
2352         return new IsTextureCase(testCtx, renderCtx, name.c_str(), description.c_str(), target);
2353 }
2354
2355 tcu::TestCase* createTexParamTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, QueryType queryType, glw::GLenum target, TesterType tester)
2356 {
2357         if (isMultisampleTarget(target) && isSamplerStateTester(tester))
2358         {
2359                 DE_ASSERT(!"Multisample textures have no sampler state");
2360                 return DE_NULL;
2361         }
2362         if (target == GL_TEXTURE_BUFFER)
2363         {
2364                 DE_ASSERT(!"Buffer textures have no texture state");
2365                 return DE_NULL;
2366         }
2367         if (target != GL_TEXTURE_3D && mapTesterToPname(tester) == GL_TEXTURE_WRAP_R)
2368         {
2369                 DE_ASSERT(!"Only 3D textures have wrap r filter");
2370                 return DE_NULL;
2371         }
2372
2373 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2374
2375         switch (tester)
2376         {
2377                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R):
2378                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G):
2379                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B):
2380                 CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A):
2381                         return new TextureSwizzleCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2382
2383                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2384                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2385                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2386                         return new TextureWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2387
2388                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2389                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2390                         return new TextureFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2391
2392                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2393                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2394                         return new TextureLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2395
2396                 CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL):
2397                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL):
2398                         return new TextureLevelCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2399
2400                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2401                         return new TextureCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2402
2403                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2404                         return new TextureCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2405
2406                 case TESTER_TEXTURE_IMMUTABLE_LEVELS:
2407                         return new TextureImmutableLevelsCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2408
2409                 case TESTER_TEXTURE_IMMUTABLE_FORMAT:
2410                         return new TextureImmutableFormatCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2411
2412                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2413                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2414                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2415                         return new TextureWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2416
2417                 CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE):
2418                         return new DepthStencilModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2419
2420                 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2421                         return new TextureSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester, queryType);
2422
2423                 case TESTER_TEXTURE_BORDER_COLOR:
2424                         return new TextureBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);
2425
2426                 default:
2427                         break;
2428         }
2429
2430 #undef CASE_ALL_SETTERS
2431
2432         DE_ASSERT(false);
2433         return DE_NULL;
2434 }
2435
2436 tcu::TestCase* createSamplerParamTest (tcu::TestContext& testCtx, const glu::RenderContext& renderCtx, const std::string& name, const std::string& description, StateQueryUtil::QueryType queryType, TesterType tester)
2437 {
2438 #define CASE_ALL_SETTERS(X) case X: case X ## _SET_PURE_INT: case X ## _SET_PURE_UINT
2439
2440         switch (tester)
2441         {
2442                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S):
2443                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T):
2444                 CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R):
2445                         return new SamplerWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2446
2447                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER):
2448                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER):
2449                         return new SamplerFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2450
2451                 CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD):
2452                 CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD):
2453                         return new SamplerLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2454
2455                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE):
2456                         return new SamplerCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2457
2458                 CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC):
2459                         return new SamplerCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2460
2461                 case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
2462                 case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
2463                 case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
2464                         return new SamplerWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2465
2466                 CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT):
2467                         return new SamplerSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);
2468
2469                 case TESTER_TEXTURE_BORDER_COLOR:
2470                         return new SamplerBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), queryType);
2471
2472                 default:
2473                         break;
2474         }
2475
2476 #undef CASE_ALL_SETTERS
2477
2478         DE_ASSERT(false);
2479         return DE_NULL;
2480 }
2481
2482 } // TextureStateQueryTests
2483 } // gls
2484 } // deqp