modules/glshared/glsStateQueryUtil.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 State Query test utils.
  22  *//*--------------------------------------------------------------------*/
  23 #include "glsStateQueryUtil.hpp"
  24 #include "tcuTestContext.hpp"
  25 #include "tcuFormatUtil.hpp"
  26 #include "gluCallLogWrapper.hpp"
  27 #include "gluStrUtil.hpp"
  28 #include "glwEnums.hpp"
  29 #include "deStringUtil.hpp"
  30
  31 namespace deqp
  32 {
  33 namespace gls
  34 {
  35 namespace StateQueryUtil
  36 {
  37
  38 static glw::GLboolean mapBoolToGLBoolean (bool b)
  39 {
  40         return (b ? GL_TRUE : GL_FALSE);
  41 }
  42
  43 static bool checkError (tcu::ResultCollector& result, glu::CallLogWrapper& gl, const char* msg)
  44 {
  45         const glw::GLenum errorCode = gl.glGetError();
  46
  47         if (errorCode == GL_NO_ERROR)
  48                 return true;
  49
  50         result.fail(std::string(msg) + ": glGetError() returned " + glu::getErrorStr(errorCode).toString());
  51         return false;
  52 }
  53
  54 QueriedState::QueriedState (void)
  55         : m_type(DATATYPE_LAST)
  56 {
  57 }
  58
  59 QueriedState::QueriedState (glw::GLint v)
  60         : m_type(DATATYPE_INTEGER)
  61 {
  62         m_v.vInt = v;
  63 }
  64
  65 QueriedState::QueriedState (glw::GLint64 v)
  66         : m_type(DATATYPE_INTEGER64)
  67 {
  68         m_v.vInt64 = v;
  69 }
  70
  71 QueriedState::QueriedState (bool v)
  72         : m_type(DATATYPE_BOOLEAN)
  73 {
  74         m_v.vBool = v;
  75 }
  76
  77 QueriedState::QueriedState (glw::GLfloat v)
  78         : m_type(DATATYPE_FLOAT)
  79 {
  80         m_v.vFloat = v;
  81 }
  82
  83 QueriedState::QueriedState (glw::GLuint v)
  84         : m_type(DATATYPE_UNSIGNED_INTEGER)
  85 {
  86         m_v.vUint = v;
  87 }
  88
  89 QueriedState::QueriedState (const GLIntVec3& v)
  90         : m_type(DATATYPE_INTEGER_VEC3)
  91 {
  92         m_v.vIntVec3[0] = v[0];
  93         m_v.vIntVec3[1] = v[1];
  94         m_v.vIntVec3[2] = v[2];
  95 }
  96
  97 QueriedState::QueriedState (void* v)
  98         : m_type(DATATYPE_POINTER)
  99 {
 100         m_v.vPtr = v;
 101 }
 102
 103 QueriedState::QueriedState (const GLIntVec4& v)
 104         : m_type(DATATYPE_INTEGER_VEC4)
 105 {
 106         m_v.vIntVec4[0] = v[0];
 107         m_v.vIntVec4[1] = v[1];
 108         m_v.vIntVec4[2] = v[2];
 109         m_v.vIntVec4[3] = v[3];
 110 }
 111
 112 QueriedState::QueriedState (const GLUintVec4& v)
 113         : m_type(DATATYPE_UNSIGNED_INTEGER_VEC4)
 114 {
 115         m_v.vUintVec4[0] = v[0];
 116         m_v.vUintVec4[1] = v[1];
 117         m_v.vUintVec4[2] = v[2];
 118         m_v.vUintVec4[3] = v[3];
 119 }
 120
 121 QueriedState::QueriedState (const GLFloatVec4& v)
 122         : m_type(DATATYPE_FLOAT_VEC4)
 123 {
 124         m_v.vFloatVec4[0] = v[0];
 125         m_v.vFloatVec4[1] = v[1];
 126         m_v.vFloatVec4[2] = v[2];
 127         m_v.vFloatVec4[3] = v[3];
 128 }
 129
 130 QueriedState::QueriedState (const BooleanVec4& v)
 131         : m_type(DATATYPE_BOOLEAN_VEC4)
 132 {
 133         m_v.vBooleanVec4[0] = v[0];
 134         m_v.vBooleanVec4[1] = v[1];
 135         m_v.vBooleanVec4[2] = v[2];
 136         m_v.vBooleanVec4[3] = v[3];
 137 }
 138
 139 QueriedState::QueriedState (const GLInt64Vec4& v)
 140         : m_type(DATATYPE_INTEGER64_VEC4)
 141 {
 142         m_v.vInt64Vec4[0] = v[0];
 143         m_v.vInt64Vec4[1] = v[1];
 144         m_v.vInt64Vec4[2] = v[2];
 145         m_v.vInt64Vec4[3] = v[3];
 146 }
 147
 148 bool QueriedState::isUndefined (void) const
 149 {
 150         return m_type == DATATYPE_LAST;
 151 }
 152
 153 DataType QueriedState::getType (void) const
 154 {
 155         return m_type;
 156 }
 157
 158 glw::GLint& QueriedState::getIntAccess (void)
 159 {
 160         DE_ASSERT(m_type == DATATYPE_INTEGER);
 161         return m_v.vInt;
 162 }
 163
 164 glw::GLint64& QueriedState::getInt64Access (void)
 165 {
 166         DE_ASSERT(m_type == DATATYPE_INTEGER64);
 167         return m_v.vInt64;
 168 }
 169
 170 bool& QueriedState::getBoolAccess (void)
 171 {
 172         DE_ASSERT(m_type == DATATYPE_BOOLEAN);
 173         return m_v.vBool;
 174 }
 175
 176 glw::GLfloat& QueriedState::getFloatAccess (void)
 177 {
 178         DE_ASSERT(m_type == DATATYPE_FLOAT);
 179         return m_v.vFloat;
 180 }
 181
 182 glw::GLuint& QueriedState::getUintAccess (void)
 183 {
 184         DE_ASSERT(m_type == DATATYPE_UNSIGNED_INTEGER);
 185         return m_v.vUint;
 186 }
 187
 188 QueriedState::GLIntVec3& QueriedState::getIntVec3Access (void)
 189 {
 190         DE_ASSERT(m_type == DATATYPE_INTEGER_VEC3);
 191         return m_v.vIntVec3;
 192 }
 193
 194 void*& QueriedState::getPtrAccess (void)
 195 {
 196         DE_ASSERT(m_type == DATATYPE_POINTER);
 197         return m_v.vPtr;
 198 }
 199
 200 QueriedState::GLIntVec4& QueriedState::getIntVec4Access (void)
 201 {
 202         DE_ASSERT(m_type == DATATYPE_INTEGER_VEC4);
 203         return m_v.vIntVec4;
 204 }
 205
 206 QueriedState::GLUintVec4& QueriedState::getUintVec4Access (void)
 207 {
 208         DE_ASSERT(m_type == DATATYPE_UNSIGNED_INTEGER_VEC4);
 209         return m_v.vUintVec4;
 210 }
 211
 212 QueriedState::GLFloatVec4& QueriedState::getFloatVec4Access (void)
 213 {
 214         DE_ASSERT(m_type == DATATYPE_FLOAT_VEC4);
 215         return m_v.vFloatVec4;
 216 }
 217
 218 QueriedState::BooleanVec4& QueriedState::getBooleanVec4Access (void)
 219 {
 220         DE_ASSERT(m_type == DATATYPE_BOOLEAN_VEC4);
 221         return m_v.vBooleanVec4;
 222 }
 223
 224 QueriedState::GLInt64Vec4& QueriedState::getInt64Vec4Access (void)
 225 {
 226         DE_ASSERT(m_type == DATATYPE_INTEGER64_VEC4);
 227         return m_v.vInt64Vec4;
 228 }
 229
 230 // query
 231
 232 static bool verifyBooleanValidity (tcu::ResultCollector& result, glw::GLboolean v)
 233 {
 234         if (v == GL_TRUE || v == GL_FALSE)
 235                 return true;
 236         else
 237         {
 238                 std::ostringstream buf;
 239                 buf << "Boolean value was not neither GL_TRUE nor GL_FALSE, got " << de::toString(tcu::Format::Hex<2>(v));
 240                 result.fail(buf.str());
 241                 return false;
 242         }
 243 }
 244
 245 static bool verifyBooleanVec4Validity (tcu::ResultCollector& result, const glw::GLboolean v[4])
 246 {
 247         bool valid = true;
 248
 249         for (int i = 0; i < 4; i++)
 250         {
 251                 if (v[i] != GL_TRUE && v[i] != GL_FALSE)
 252                         valid = false;
 253         }
 254
 255         if (!valid)
 256         {
 257                 std::ostringstream buf;
 258                 buf << "Boolean vec4 value was not neither GL_TRUE nor GL_FALSE, got (";
 259
 260                 for (int i = 0; i < 4; i++)
 261                         buf << (i > 0 ? ", " : "") << de::toString(tcu::Format::Hex<2>(v[i]));
 262
 263                 buf << ")";
 264
 265                 result.fail(buf.str());
 266         }
 267
 268         return valid;
 269 }
 270
 271 void queryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, QueriedState& state)
 272 {
 273         switch (type)
 274         {
 275                 case QUERY_ISENABLED:
 276                 {
 277                         const glw::GLboolean value = gl.glIsEnabled(target);
 278
 279                         if (!checkError(result, gl, "glIsEnabled"))
 280                                 return;
 281
 282                         if (!verifyBooleanValidity(result, value))
 283                                 return;
 284
 285                         state = QueriedState(value == GL_TRUE);
 286                         break;
 287                 }
 288
 289                 case QUERY_BOOLEAN:
 290                 {
 291                         StateQueryMemoryWriteGuard<glw::GLboolean> value;
 292                         gl.glGetBooleanv(target, &value);
 293
 294                         if (!checkError(result, gl, "glGetBooleanv"))
 295                                 return;
 296
 297                         if (!value.verifyValidity(result))
 298                                 return;
 299                         if (!verifyBooleanValidity(result, value))
 300                                 return;
 301
 302                         state = QueriedState(value == GL_TRUE);
 303                         break;
 304                 }
 305
 306                 case QUERY_INTEGER:
 307                 {
 308                         StateQueryMemoryWriteGuard<glw::GLint> value;
 309                         gl.glGetIntegerv(target, &value);
 310
 311                         if (!checkError(result, gl, "glGetIntegerv"))
 312                                 return;
 313
 314                         if (!value.verifyValidity(result))
 315                                 return;
 316
 317                         state = QueriedState(value);
 318                         break;
 319                 }
 320
 321                 case QUERY_INTEGER64:
 322                 {
 323                         StateQueryMemoryWriteGuard<glw::GLint64> value;
 324                         gl.glGetInteger64v(target, &value);
 325
 326                         if (!checkError(result, gl, "glGetInteger64v"))
 327                                 return;
 328
 329                         if (!value.verifyValidity(result))
 330                                 return;
 331
 332                         state = QueriedState(value);
 333                         break;
 334                 }
 335
 336                 case QUERY_FLOAT:
 337                 {
 338                         StateQueryMemoryWriteGuard<glw::GLfloat> value;
 339                         gl.glGetFloatv(target, &value);
 340
 341                         if (!checkError(result, gl, "glGetFloatv"))
 342                                 return;
 343
 344                         if (!value.verifyValidity(result))
 345                                 return;
 346
 347                         state = QueriedState(value);
 348                         break;
 349                 }
 350
 351                 default:
 352                         DE_ASSERT(DE_FALSE);
 353                         break;
 354         }
 355 }
 356
 357 void queryIndexedState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state)
 358 {
 359         switch (type)
 360         {
 361                 case QUERY_INDEXED_BOOLEAN_VEC4:
 362                 {
 363                         StateQueryMemoryWriteGuard<glw::GLboolean[4]> value;
 364                         gl.glGetBooleani_v(target, index, value);
 365
 366                         if (!checkError(result, gl, "glGetBooleani_v"))
 367                                 return;
 368
 369                         if (!value.verifyValidity(result))
 370                                 return;
 371
 372                         if (!verifyBooleanVec4Validity(result, value))
 373                                 return;
 374
 375                         {
 376                                 bool res[4];
 377
 378                                 for (int i = 0; i < 4; i++)
 379                                         res[i] = value[i] == GL_TRUE;
 380
 381                                 state = QueriedState(res);
 382                         }
 383
 384                         break;
 385                 }
 386
 387                 case QUERY_INDEXED_INTEGER_VEC4:
 388                 {
 389                         StateQueryMemoryWriteGuard<glw::GLint[4]> value;
 390                         gl.glGetIntegeri_v(target, index, value);
 391
 392                         if (!checkError(result, gl, "glGetIntegeri_v"))
 393                                 return;
 394
 395                         if (!value.verifyValidity(result))
 396                                 return;
 397
 398                         state = QueriedState(value);
 399                         break;
 400                 }
 401
 402                 case QUERY_INDEXED_INTEGER64_VEC4:
 403                 {
 404                         StateQueryMemoryWriteGuard<glw::GLint64[4]> value;
 405                         gl.glGetInteger64i_v(target, index, value);
 406
 407                         if (!checkError(result, gl, "glGetInteger64i_v"))
 408                                 return;
 409
 410                         if (!value.verifyValidity(result))
 411                                 return;
 412
 413                         state = QueriedState(value);
 414                         break;
 415                 }
 416
 417                 case QUERY_INDEXED_ISENABLED:
 418                 {
 419                         const glw::GLboolean value = gl.glIsEnabledi(target, index);
 420
 421                         if (!checkError(result, gl, "glIsEnabledi"))
 422                                 return;
 423
 424                         if (!verifyBooleanValidity(result, value))
 425                                 return;
 426
 427                         state = QueriedState(value == GL_TRUE);
 428                         break;
 429                 }
 430
 431                 case QUERY_INDEXED_BOOLEAN:
 432                 {
 433                         StateQueryMemoryWriteGuard<glw::GLboolean> value;
 434                         gl.glGetBooleani_v(target, index, &value);
 435
 436                         if (!checkError(result, gl, "glGetBooleani_v"))
 437                                 return;
 438
 439                         if (!value.verifyValidity(result))
 440                                 return;
 441                         if (!verifyBooleanValidity(result, value))
 442                                 return;
 443
 444                         state = QueriedState(value == GL_TRUE);
 445                         break;
 446                 }
 447
 448                 case QUERY_INDEXED_INTEGER:
 449                 {
 450                         StateQueryMemoryWriteGuard<glw::GLint> value;
 451                         gl.glGetIntegeri_v(target, index, &value);
 452
 453                         if (!checkError(result, gl, "glGetIntegeri_v"))
 454                                 return;
 455
 456                         if (!value.verifyValidity(result))
 457                                 return;
 458
 459                         state = QueriedState(value);
 460                         break;
 461                 }
 462
 463                 case QUERY_INDEXED_INTEGER64:
 464                 {
 465                         StateQueryMemoryWriteGuard<glw::GLint64> value;
 466                         gl.glGetInteger64i_v(target, index, &value);
 467
 468                         if (!checkError(result, gl, "glGetInteger64i_v"))
 469                                 return;
 470
 471                         if (!value.verifyValidity(result))
 472                                 return;
 473
 474                         state = QueriedState(value);
 475                         break;
 476                 }
 477
 478                 default:
 479                         DE_ASSERT(DE_FALSE);
 480                         break;
 481         }
 482 }
 483
 484 void queryAttributeState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state)
 485 {
 486         switch (type)
 487         {
 488                 case QUERY_ATTRIBUTE_INTEGER:
 489                 {
 490                         StateQueryMemoryWriteGuard<glw::GLint> value;
 491                         gl.glGetVertexAttribiv(index, target, &value);
 492
 493                         if (!checkError(result, gl, "glGetVertexAttribiv"))
 494                                 return;
 495
 496                         if (!value.verifyValidity(result))
 497                                 return;
 498
 499                         state = QueriedState(value);
 500                         break;
 501                 }
 502                 case QUERY_ATTRIBUTE_FLOAT:
 503                 {
 504                         StateQueryMemoryWriteGuard<glw::GLfloat> value;
 505                         gl.glGetVertexAttribfv(index, target, &value);
 506
 507                         if (!checkError(result, gl, "glGetVertexAttribfv"))
 508                                 return;
 509
 510                         if (!value.verifyValidity(result))
 511                                 return;
 512
 513                         state = QueriedState(value);
 514                         break;
 515                 }
 516                 case QUERY_ATTRIBUTE_PURE_INTEGER:
 517                 {
 518                         StateQueryMemoryWriteGuard<glw::GLint> value;
 519                         gl.glGetVertexAttribIiv(index, target, &value);
 520
 521                         if (!checkError(result, gl, "glGetVertexAttribIiv"))
 522                                 return;
 523
 524                         if (!value.verifyValidity(result))
 525                                 return;
 526
 527                         state = QueriedState(value);
 528                         break;
 529                 }
 530                 case QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER:
 531                 {
 532                         StateQueryMemoryWriteGuard<glw::GLuint> value;
 533                         gl.glGetVertexAttribIuiv(index, target, &value);
 534
 535                         if (!checkError(result, gl, "glGetVertexAttribIuiv"))
 536                                 return;
 537
 538                         if (!value.verifyValidity(result))
 539                                 return;
 540
 541                         state = QueriedState(value);
 542                         break;
 543                 }
 544                 default:
 545                         DE_ASSERT(false);
 546         }
 547 }
 548
 549 void queryFramebufferState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state)
 550 {
 551         switch (type)
 552         {
 553                 case QUERY_FRAMEBUFFER_INTEGER:
 554                 {
 555                         StateQueryMemoryWriteGuard<glw::GLint> value;
 556                         gl.glGetFramebufferParameteriv(target, pname, &value);
 557
 558                         if (!checkError(result, gl, "glGetVertexAttribiv"))
 559                                 return;
 560
 561                         if (!value.verifyValidity(result))
 562                                 return;
 563
 564                         state = QueriedState(value);
 565                         break;
 566                 }
 567                 default:
 568                         DE_ASSERT(false);
 569         }
 570 }
 571
 572 void queryProgramState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint program, glw::GLenum pname, QueriedState& state)
 573 {
 574         switch (type)
 575         {
 576                 case QUERY_PROGRAM_INTEGER:
 577                 {
 578                         StateQueryMemoryWriteGuard<glw::GLint> value;
 579                         gl.glGetProgramiv(program, pname, &value);
 580
 581                         if (!checkError(result, gl, "glGetProgramiv"))
 582                                 return;
 583
 584                         if (!value.verifyValidity(result))
 585                                 return;
 586
 587                         state = QueriedState(value);
 588                         break;
 589                 }
 590                 case QUERY_PROGRAM_INTEGER_VEC3:
 591                 {
 592                         StateQueryMemoryWriteGuard<glw::GLint[3]> value;
 593                         gl.glGetProgramiv(program, pname, value);
 594
 595                         if (!checkError(result, gl, "glGetProgramiv"))
 596                                 return;
 597
 598                         if (!value.verifyValidity(result))
 599                                 return;
 600
 601                         state = QueriedState(value);
 602                         break;
 603                 }
 604                 default:
 605                         DE_ASSERT(false);
 606         }
 607 }
 608
 609 void queryPipelineState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint pipeline, glw::GLenum pname, QueriedState& state)
 610 {
 611         switch (type)
 612         {
 613                 case QUERY_PIPELINE_INTEGER:
 614                 {
 615                         StateQueryMemoryWriteGuard<glw::GLint> value;
 616                         gl.glGetProgramPipelineiv(pipeline, pname, &value);
 617
 618                         if (!checkError(result, gl, "glGetProgramiv"))
 619                                 return;
 620
 621                         if (!value.verifyValidity(result))
 622                                 return;
 623
 624                         state = QueriedState(value);
 625                         break;
 626                 }
 627                 default:
 628                         DE_ASSERT(false);
 629         }
 630 }
 631
 632 void queryTextureParamState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state)
 633 {
 634         switch (type)
 635         {
 636                 case QUERY_TEXTURE_PARAM_INTEGER:
 637                 {
 638                         StateQueryMemoryWriteGuard<glw::GLint> value;
 639                         gl.glGetTexParameteriv(target, pname, &value);
 640
 641                         if (!checkError(result, gl, "glGetTexParameteriv"))
 642                                 return;
 643
 644                         if (!value.verifyValidity(result))
 645                                 return;
 646
 647                         state = QueriedState(value);
 648                         break;
 649                 }
 650                 case QUERY_TEXTURE_PARAM_FLOAT:
 651                 {
 652                         StateQueryMemoryWriteGuard<glw::GLfloat> value;
 653                         gl.glGetTexParameterfv(target, pname, &value);
 654
 655                         if (!checkError(result, gl, "glGetTexParameterfv"))
 656                                 return;
 657
 658                         if (!value.verifyValidity(result))
 659                                 return;
 660
 661                         state = QueriedState(value);
 662                         break;
 663                 }
 664                 case QUERY_TEXTURE_PARAM_PURE_INTEGER:
 665                 {
 666                         StateQueryMemoryWriteGuard<glw::GLint> value;
 667                         gl.glGetTexParameterIiv(target, pname, &value);
 668
 669                         if (!checkError(result, gl, "GetTexParameterIiv"))
 670                                 return;
 671
 672                         if (!value.verifyValidity(result))
 673                                 return;
 674
 675                         state = QueriedState(value);
 676                         break;
 677                 }
 678                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER:
 679                 {
 680                         StateQueryMemoryWriteGuard<glw::GLuint> value;
 681                         gl.glGetTexParameterIuiv(target, pname, &value);
 682
 683                         if (!checkError(result, gl, "GetTexParameterIuiv"))
 684                                 return;
 685
 686                         if (!value.verifyValidity(result))
 687                                 return;
 688
 689                         state = QueriedState(value);
 690                         break;
 691                 }
 692                 case QUERY_TEXTURE_PARAM_INTEGER_VEC4:
 693                 {
 694                         StateQueryMemoryWriteGuard<glw::GLint[4]> value;
 695                         gl.glGetTexParameteriv(target, pname, value);
 696
 697                         if (!checkError(result, gl, "glGetTexParameteriv"))
 698                                 return;
 699
 700                         if (!value.verifyValidity(result))
 701                                 return;
 702
 703                         state = QueriedState(value);
 704                         break;
 705                 }
 706                 case QUERY_TEXTURE_PARAM_FLOAT_VEC4:
 707                 {
 708                         StateQueryMemoryWriteGuard<glw::GLfloat[4]> value;
 709                         gl.glGetTexParameterfv(target, pname, value);
 710
 711                         if (!checkError(result, gl, "glGetTexParameterfv"))
 712                                 return;
 713
 714                         if (!value.verifyValidity(result))
 715                                 return;
 716
 717                         state = QueriedState(value);
 718                         break;
 719                 }
 720                 case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4:
 721                 {
 722                         StateQueryMemoryWriteGuard<glw::GLint[4]> value;
 723                         gl.glGetTexParameterIiv(target, pname, value);
 724
 725                         if (!checkError(result, gl, "GetTexParameterIiv"))
 726                                 return;
 727
 728                         if (!value.verifyValidity(result))
 729                                 return;
 730
 731                         state = QueriedState(value);
 732                         break;
 733                 }
 734                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
 735                 {
 736                         StateQueryMemoryWriteGuard<glw::GLuint[4]> value;
 737                         gl.glGetTexParameterIuiv(target, pname, value);
 738
 739                         if (!checkError(result, gl, "GetTexParameterIuiv"))
 740                                 return;
 741
 742                         if (!value.verifyValidity(result))
 743                                 return;
 744
 745                         state = QueriedState(value);
 746                         break;
 747                 }
 748                 default:
 749                         DE_ASSERT(false);
 750         }
 751 }
 752
 753 void queryTextureLevelState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int level, glw::GLenum pname, QueriedState& state)
 754 {
 755         switch (type)
 756         {
 757                 case QUERY_TEXTURE_LEVEL_INTEGER:
 758                 {
 759                         StateQueryMemoryWriteGuard<glw::GLint> value;
 760                         gl.glGetTexLevelParameteriv(target, level, pname, &value);
 761
 762                         if (!checkError(result, gl, "glGetTexLevelParameteriv"))
 763                                 return;
 764
 765                         if (!value.verifyValidity(result))
 766                                 return;
 767
 768                         state = QueriedState(value);
 769                         break;
 770                 }
 771                 case QUERY_TEXTURE_LEVEL_FLOAT:
 772                 {
 773                         StateQueryMemoryWriteGuard<glw::GLfloat> value;
 774                         gl.glGetTexLevelParameterfv(target, level, pname, &value);
 775
 776                         if (!checkError(result, gl, "glGetTexLevelParameterfv"))
 777                                 return;
 778
 779                         if (!value.verifyValidity(result))
 780                                 return;
 781
 782                         state = QueriedState(value);
 783                         break;
 784                 }
 785                 default:
 786                         DE_ASSERT(false);
 787         }
 788 }
 789
 790 void queryPointerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state)
 791 {
 792         switch (type)
 793         {
 794                 case QUERY_POINTER:
 795                 {
 796                         StateQueryMemoryWriteGuard<void*> value;
 797                         gl.glGetPointerv(pname, &value);
 798
 799                         if (!checkError(result, gl, "glGetPointerv"))
 800                                 return;
 801
 802                         if (!value.verifyValidity(result))
 803                                 return;
 804
 805                         state = QueriedState(value);
 806                         break;
 807                 }
 808                 default:
 809                         DE_ASSERT(false);
 810         }
 811 }
 812
 813 void queryObjectState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint handle, QueriedState& state)
 814 {
 815         switch (type)
 816         {
 817                 case QUERY_ISTEXTURE:
 818                 {
 819                         const glw::GLboolean value = gl.glIsTexture(handle);
 820
 821                         if (!checkError(result, gl, "glIsTexture"))
 822                                 return;
 823
 824                         if (!verifyBooleanValidity(result, value))
 825                                 return;
 826
 827                         state = QueriedState(value == GL_TRUE);
 828                         break;
 829                 }
 830                 default:
 831                         DE_ASSERT(false);
 832         }
 833 }
 834
 835 void queryQueryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state)
 836 {
 837         switch (type)
 838         {
 839                 case QUERY_QUERY:
 840                 {
 841                         StateQueryMemoryWriteGuard<glw::GLint> value;
 842                         gl.glGetQueryiv(target, pname, &value);
 843
 844                         if (!checkError(result, gl, "glGetQueryiv"))
 845                                 return;
 846
 847                         if (!value.verifyValidity(result))
 848                                 return;
 849
 850                         state = QueriedState(value);
 851                         break;
 852                 }
 853                 default:
 854                         DE_ASSERT(false);
 855         }
 856 }
 857
 858 void querySamplerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint sampler, glw::GLenum pname, QueriedState& state)
 859 {
 860         switch (type)
 861         {
 862                 case QUERY_SAMPLER_PARAM_INTEGER:
 863                 {
 864                         StateQueryMemoryWriteGuard<glw::GLint> value;
 865                         gl.glGetSamplerParameteriv(sampler, pname, &value);
 866
 867                         if (!checkError(result, gl, "glGetSamplerParameteriv"))
 868                                 return;
 869
 870                         if (!value.verifyValidity(result))
 871                                 return;
 872
 873                         state = QueriedState(value);
 874                         break;
 875                 }
 876                 case QUERY_SAMPLER_PARAM_FLOAT:
 877                 {
 878                         StateQueryMemoryWriteGuard<glw::GLfloat> value;
 879                         gl.glGetSamplerParameterfv(sampler, pname, &value);
 880
 881                         if (!checkError(result, gl, "glGetSamplerParameteriv"))
 882                                 return;
 883
 884                         if (!value.verifyValidity(result))
 885                                 return;
 886
 887                         state = QueriedState(value);
 888                         break;
 889                 }
 890                 case QUERY_SAMPLER_PARAM_PURE_INTEGER:
 891                 {
 892                         StateQueryMemoryWriteGuard<glw::GLint> value;
 893                         gl.glGetSamplerParameterIiv(sampler, pname, &value);
 894
 895                         if (!checkError(result, gl, "glGetSamplerParameterIiv"))
 896                                 return;
 897
 898                         if (!value.verifyValidity(result))
 899                                 return;
 900
 901                         state = QueriedState(value);
 902                         break;
 903                 }
 904                 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER:
 905                 {
 906                         StateQueryMemoryWriteGuard<glw::GLuint> value;
 907                         gl.glGetSamplerParameterIuiv(sampler, pname, &value);
 908
 909                         if (!checkError(result, gl, "glGetSamplerParameterIuiv"))
 910                                 return;
 911
 912                         if (!value.verifyValidity(result))
 913                                 return;
 914
 915                         state = QueriedState(value);
 916                         break;
 917                 }
 918                 case QUERY_SAMPLER_PARAM_INTEGER_VEC4:
 919                 {
 920                         StateQueryMemoryWriteGuard<glw::GLint[4]> value;
 921                         gl.glGetSamplerParameteriv(sampler, pname, value);
 922
 923                         if (!checkError(result, gl, "glGetSamplerParameteriv"))
 924                                 return;
 925
 926                         if (!value.verifyValidity(result))
 927                                 return;
 928
 929                         state = QueriedState(value);
 930                         break;
 931                 }
 932                 case QUERY_SAMPLER_PARAM_FLOAT_VEC4:
 933                 {
 934                         StateQueryMemoryWriteGuard<glw::GLfloat[4]> value;
 935                         gl.glGetSamplerParameterfv(sampler, pname, value);
 936
 937                         if (!checkError(result, gl, "glGetSamplerParameteriv"))
 938                                 return;
 939
 940                         if (!value.verifyValidity(result))
 941                                 return;
 942
 943                         state = QueriedState(value);
 944                         break;
 945                 }
 946                 case QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4:
 947                 {
 948                         StateQueryMemoryWriteGuard<glw::GLint[4]> value;
 949                         gl.glGetSamplerParameterIiv(sampler, pname, value);
 950
 951                         if (!checkError(result, gl, "glGetSamplerParameterIiv"))
 952                                 return;
 953
 954                         if (!value.verifyValidity(result))
 955                                 return;
 956
 957                         state = QueriedState(value);
 958                         break;
 959                 }
 960                 case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
 961                 {
 962                         StateQueryMemoryWriteGuard<glw::GLuint[4]> value;
 963                         gl.glGetSamplerParameterIuiv(sampler, pname, value);
 964
 965                         if (!checkError(result, gl, "glGetSamplerParameterIuiv"))
 966                                 return;
 967
 968                         if (!value.verifyValidity(result))
 969                                 return;
 970
 971                         state = QueriedState(value);
 972                         break;
 973                 }
 974                 default:
 975                         DE_ASSERT(false);
 976         }
 977 }
 978
 979 // verify
 980
 981 void verifyBoolean (tcu::ResultCollector& result, QueriedState& state, bool expected)
 982 {
 983         switch (state.getType())
 984         {
 985                 case DATATYPE_BOOLEAN:
 986                 {
 987                         if (state.getBoolAccess() != expected)
 988                         {
 989                                 std::ostringstream buf;
 990                                 buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(expected)) << ", got " << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess()));
 991                                 result.fail(buf.str());
 992                         }
 993                         break;
 994                 }
 995
 996                 case DATATYPE_INTEGER:
 997                 {
 998                         const glw::GLint reference = expected ? 1 : 0;
 999                         if (state.getIntAccess() != reference)
1000                         {
1001                                 std::ostringstream buf;
1002                                 buf << "Expected " << reference << ", got " << state.getIntAccess();
1003                                 result.fail(buf.str());
1004                         }
1005                         break;
1006                 }
1007
1008                 case DATATYPE_INTEGER64:
1009                 {
1010                         const glw::GLint64 reference = expected ? 1 : 0;
1011                         if (state.getInt64Access() != reference)
1012                         {
1013                                 std::ostringstream buf;
1014                                 buf << "Expected " << reference << ", got " << state.getInt64Access();
1015                                 result.fail(buf.str());
1016                         }
1017                         break;
1018                 }
1019
1020                 case DATATYPE_FLOAT:
1021                 {
1022                         const glw::GLfloat reference = expected ? 1.0f : 0.0f;
1023                         if (state.getFloatAccess() != reference)
1024                         {
1025                                 std::ostringstream buf;
1026                                 buf << "Expected " << reference << ", got " << state.getFloatAccess();
1027                                 result.fail(buf.str());
1028                         }
1029                         break;
1030                 }
1031
1032                 default:
1033                         DE_ASSERT(DE_FALSE);
1034                         break;
1035         }
1036 }
1037
1038 void verifyInteger (tcu::ResultCollector& result, QueriedState& state, int expected)
1039 {
1040         switch (state.getType())
1041         {
1042                 case DATATYPE_BOOLEAN:
1043                 {
1044                         const bool reference = (expected != 0);
1045                         if (state.getBoolAccess() != reference)
1046                         {
1047                                 std::ostringstream buf;
1048                                 buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(reference)) << ", got " << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess()));
1049                                 result.fail(buf.str());
1050                         }
1051                         break;
1052                 }
1053
1054                 case DATATYPE_INTEGER:
1055                 {
1056                         const glw::GLint reference = expected;
1057                         if (state.getIntAccess() != reference)
1058                         {
1059                                 std::ostringstream buf;
1060                                 buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference))
1061                                         << ") , got " << state.getIntAccess() << "(" << de::toString(tcu::Format::Hex<8>(state.getIntAccess())) << ")";
1062                                 result.fail(buf.str());
1063                         }
1064                         break;
1065                 }
1066
1067                 case DATATYPE_INTEGER64:
1068                 {
1069                         const glw::GLint64 reference = (glw::GLint64)expected;
1070                         if (state.getInt64Access() != reference)
1071                         {
1072                                 std::ostringstream buf;
1073                                 buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got "
1074                                         << state.getInt64Access() << "(" << de::toString(tcu::Format::Hex<8>(state.getInt64Access())) << ")";
1075                                 result.fail(buf.str());
1076                         }
1077                         break;
1078                 }
1079
1080                 case DATATYPE_FLOAT:
1081                 {
1082                         const glw::GLfloat refValueMin = deInt32ToFloatRoundToNegInf(expected);
1083                         const glw::GLfloat refValueMax = deInt32ToFloatRoundToPosInf(expected);
1084
1085                         if (state.getFloatAccess() < refValueMin ||
1086                                 state.getFloatAccess() > refValueMax ||
1087                                 deIsNaN(state.getFloatAccess()))
1088                         {
1089                                 std::ostringstream buf;
1090
1091                                 if (refValueMin == refValueMax)
1092                                         buf << "Expected " << refValueMin << ", got " << state.getFloatAccess();
1093                                 else
1094                                         buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getFloatAccess();
1095
1096                                 result.fail(buf.str());
1097                         }
1098                         break;
1099                 }
1100
1101                 case DATATYPE_UNSIGNED_INTEGER:
1102                 {
1103                         const glw::GLuint reference = (glw::GLuint)expected;
1104                         if (state.getUintAccess() != reference)
1105                         {
1106                                 std::ostringstream buf;
1107                                 buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got "
1108                                         << state.getInt64Access() << "(" << de::toString(tcu::Format::Hex<8>(state.getInt64Access())) << ")";
1109                                 result.fail(buf.str());
1110                         }
1111                         break;
1112                 }
1113
1114                 default:
1115                         DE_ASSERT(DE_FALSE);
1116                         break;
1117         }
1118 }
1119
1120 void verifyIntegerMin (tcu::ResultCollector& result, QueriedState& state, int minValue)
1121 {
1122         switch (state.getType())
1123         {
1124                 case DATATYPE_BOOLEAN:
1125                 {
1126                         if (minValue > 0 && state.getBoolAccess() != true)
1127                         {
1128                                 std::ostringstream buf;
1129                                 buf << "Expected GL_TRUE, got GL_FALSE";
1130                                 result.fail(buf.str());
1131                         }
1132                         break;
1133                 }
1134
1135                 case DATATYPE_INTEGER:
1136                 {
1137                         if (state.getIntAccess() < minValue)
1138                         {
1139                                 std::ostringstream buf;
1140                                 buf << "Expected greater or equal to " << minValue << ", got " << state.getIntAccess();
1141                                 result.fail(buf.str());
1142                         }
1143                         break;
1144                 }
1145
1146                 case DATATYPE_INTEGER64:
1147                 {
1148                         if (state.getInt64Access() < minValue)
1149                         {
1150                                 std::ostringstream buf;
1151                                 buf << "Expected greater or equal to " << minValue << ", got " << state.getInt64Access();
1152                                 result.fail(buf.str());
1153                         }
1154                         break;
1155                 }
1156
1157                 case DATATYPE_FLOAT:
1158                 {
1159                         if (state.getFloatAccess() < deInt32ToFloatRoundToNegInf(minValue) || deIsNaN(state.getFloatAccess()))
1160                         {
1161                                 std::ostringstream buf;
1162                                 buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess();
1163                                 result.fail(buf.str());
1164                         }
1165                         break;
1166                 }
1167
1168                 default:
1169                         DE_ASSERT(DE_FALSE);
1170                         break;
1171         }
1172 }
1173
1174 void verifyIntegerMax (tcu::ResultCollector& result, QueriedState& state, int maxValue)
1175 {
1176         switch (state.getType())
1177         {
1178                 case DATATYPE_BOOLEAN:
1179                 {
1180                         if (maxValue < 0 && state.getBoolAccess() != true)
1181                         {
1182                                 std::ostringstream buf;
1183                                 buf << "Expected GL_TRUE, got GL_FALSE";
1184                                 result.fail(buf.str());
1185                         }
1186                         break;
1187                 }
1188
1189                 case DATATYPE_INTEGER:
1190                 {
1191                         if (state.getIntAccess() > maxValue)
1192                         {
1193                                 std::ostringstream buf;
1194                                 buf << "Expected less or equal to " << maxValue << ", got " << state.getIntAccess();
1195                                 result.fail(buf.str());
1196                         }
1197                         break;
1198                 }
1199
1200                 case DATATYPE_INTEGER64:
1201                 {
1202                         if (state.getInt64Access() > maxValue)
1203                         {
1204                                 std::ostringstream buf;
1205                                 buf << "Expected less or equal to " << maxValue << ", got " << state.getInt64Access();
1206                                 result.fail(buf.str());
1207                         }
1208                         break;
1209                 }
1210
1211                 case DATATYPE_FLOAT:
1212                 {
1213                         if (state.getFloatAccess() > deInt32ToFloatRoundToPosInf(maxValue) || deIsNaN(state.getFloatAccess()))
1214                         {
1215                                 std::ostringstream buf;
1216                                 buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess();
1217                                 result.fail(buf.str());
1218                         }
1219                         break;
1220                 }
1221
1222                 default:
1223                         DE_ASSERT(DE_FALSE);
1224                         break;
1225         }
1226 }
1227
1228 void verifyFloat (tcu::ResultCollector& result, QueriedState& state, float expected)
1229 {
1230         switch (state.getType())
1231         {
1232                 case DATATYPE_BOOLEAN:
1233                 {
1234                         const bool reference = (expected != 0.0f);
1235
1236                         if (state.getBoolAccess() != reference)
1237                         {
1238                                 std::ostringstream buf;
1239                                 buf << "Expected " << glu::getBooleanStr(mapBoolToGLBoolean(reference)) << ", got " << glu::getBooleanStr(mapBoolToGLBoolean(state.getBoolAccess()));
1240                                 result.fail(buf.str());
1241                         }
1242                         break;
1243                 }
1244
1245                 case DATATYPE_INTEGER:
1246                 {
1247                         const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(expected);
1248                         const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(expected);
1249
1250                         if (state.getIntAccess() < refValueMin ||
1251                                 state.getIntAccess() > refValueMax)
1252                         {
1253                                 std::ostringstream buf;
1254
1255                                 if (refValueMin == refValueMax)
1256                                         buf << "Expected " << refValueMin << ", got " << state.getIntAccess();
1257                                 else
1258                                         buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getIntAccess();
1259
1260                                 result.fail(buf.str());
1261                         }
1262                         break;
1263                 }
1264
1265                 case DATATYPE_FLOAT:
1266                 {
1267                         if (state.getFloatAccess() != expected)
1268                         {
1269                                 std::ostringstream buf;
1270                                 buf << "Expected " << expected << ", got " << state.getFloatAccess();
1271                                 result.fail(buf.str());
1272                         }
1273                         break;
1274                 }
1275
1276                 case DATATYPE_INTEGER64:
1277                 {
1278                         const glw::GLint64 refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(expected);
1279                         const glw::GLint64 refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(expected);
1280
1281                         if (state.getInt64Access() < refValueMin ||
1282                                 state.getInt64Access() > refValueMax)
1283                         {
1284                                 std::ostringstream buf;
1285
1286                                 if (refValueMin == refValueMax)
1287                                         buf << "Expected " << refValueMin << ", got " << state.getInt64Access();
1288                                 else
1289                                         buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getInt64Access();
1290
1291                                 result.fail(buf.str());
1292                         }
1293                         break;
1294                 }
1295
1296                 case DATATYPE_UNSIGNED_INTEGER:
1297                 {
1298                         const glw::GLuint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLuint>(expected);
1299                         const glw::GLuint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLuint>(expected);
1300
1301                         if (state.getUintAccess() < refValueMin ||
1302                                 state.getUintAccess() > refValueMax)
1303                         {
1304                                 std::ostringstream buf;
1305
1306                                 if (refValueMin == refValueMax)
1307                                         buf << "Expected " << refValueMin << ", got " << state.getUintAccess();
1308                                 else
1309                                         buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getUintAccess();
1310
1311                                 result.fail(buf.str());
1312                         }
1313                         break;
1314                 }
1315
1316                 default:
1317                         DE_ASSERT(DE_FALSE);
1318                         break;
1319         }
1320 }
1321
1322 void verifyFloatMin (tcu::ResultCollector& result, QueriedState& state, float minValue)
1323 {
1324         switch (state.getType())
1325         {
1326                 case DATATYPE_BOOLEAN:
1327                 {
1328                         if (minValue > 0.0f && state.getBoolAccess() != true)
1329                                 result.fail("expected GL_TRUE, got GL_FALSE");
1330                         break;
1331                 }
1332
1333                 case DATATYPE_INTEGER:
1334                 {
1335                         const glw::GLint refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(minValue);
1336
1337                         if (state.getIntAccess() < refValue)
1338                         {
1339                                 std::ostringstream buf;
1340                                 buf << "Expected greater or equal to " << refValue << ", got " << state.getIntAccess();
1341                                 result.fail(buf.str());
1342                         }
1343                         break;
1344                 }
1345
1346                 case DATATYPE_FLOAT:
1347                 {
1348                         if (state.getFloatAccess() < minValue || deIsNaN(state.getFloatAccess()))
1349                         {
1350                                 std::ostringstream buf;
1351                                 buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess();
1352                                 result.fail(buf.str());
1353                         }
1354                         break;
1355                 }
1356
1357                 case DATATYPE_INTEGER64:
1358                 {
1359                         const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(minValue);
1360
1361                         if (state.getInt64Access() < refValue)
1362                         {
1363                                 std::ostringstream buf;
1364                                 buf << "Expected greater or equal to " << refValue << ", got " << state.getInt64Access();
1365                                 result.fail(buf.str());
1366                         }
1367                         break;
1368                 }
1369
1370                 default:
1371                         DE_ASSERT(DE_FALSE);
1372                         break;
1373         }
1374 }
1375
1376 void verifyFloatMax (tcu::ResultCollector& result, QueriedState& state, float maxValue)
1377 {
1378         switch (state.getType())
1379         {
1380                 case DATATYPE_BOOLEAN:
1381                 {
1382                         if (maxValue < 0.0f && state.getBoolAccess() != true)
1383                                 result.fail("expected GL_TRUE, got GL_FALSE");
1384                         break;
1385                 }
1386
1387                 case DATATYPE_INTEGER:
1388                 {
1389                         const glw::GLint refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(maxValue);
1390
1391                         if (state.getIntAccess() > refValue)
1392                         {
1393                                 std::ostringstream buf;
1394                                 buf << "Expected less or equal to " << refValue << ", got " << state.getIntAccess();
1395                                 result.fail(buf.str());
1396                         }
1397                         break;
1398                 }
1399
1400                 case DATATYPE_FLOAT:
1401                 {
1402                         if (state.getFloatAccess() > maxValue || deIsNaN(state.getFloatAccess()))
1403                         {
1404                                 std::ostringstream buf;
1405                                 buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess();
1406                                 result.fail(buf.str());
1407                         }
1408                         break;
1409                 }
1410
1411                 case DATATYPE_INTEGER64:
1412                 {
1413                         const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(maxValue);
1414
1415                         if (state.getInt64Access() > refValue)
1416                         {
1417                                 std::ostringstream buf;
1418                                 buf << "Expected less or equal to " << refValue << ", got " << state.getInt64Access();
1419                                 result.fail(buf.str());
1420                         }
1421                         break;
1422                 }
1423
1424                 default:
1425                         DE_ASSERT(DE_FALSE);
1426                         break;
1427         }
1428 }
1429
1430 void verifyIntegerVec3 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec3& expected)
1431 {
1432         switch (state.getType())
1433         {
1434                 case DATATYPE_INTEGER_VEC3:
1435                 {
1436                         if (state.getIntVec3Access()[0] != expected[0] ||
1437                                 state.getIntVec3Access()[1] != expected[1] ||
1438                                 state.getIntVec3Access()[2] != expected[2])
1439                         {
1440                                 std::ostringstream buf;
1441                                 buf << "Expected " << expected << ", got " << tcu::formatArray(state.getIntVec3Access());
1442                                 result.fail(buf.str());
1443                         }
1444                         break;
1445                 }
1446
1447                 default:
1448                         DE_ASSERT(DE_FALSE);
1449                         break;
1450         }
1451 }
1452
1453 void verifyIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected)
1454 {
1455         switch (state.getType())
1456         {
1457                 case DATATYPE_INTEGER_VEC4:
1458                 {
1459                         if (state.getIntVec4Access()[0] != expected[0] ||
1460                                 state.getIntVec4Access()[1] != expected[1] ||
1461                                 state.getIntVec4Access()[2] != expected[2] ||
1462                                 state.getIntVec4Access()[3] != expected[3])
1463                         {
1464                                 std::ostringstream buf;
1465                                 buf << "Expected " << expected << ", got " << tcu::formatArray(state.getIntVec4Access());
1466                                 result.fail(buf.str());
1467                         }
1468                         break;
1469                 }
1470
1471                 default:
1472                         DE_ASSERT(DE_FALSE);
1473                         break;
1474         }
1475 }
1476
1477 void verifyUnsignedIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::UVec4& expected)
1478 {
1479         switch (state.getType())
1480         {
1481                 case DATATYPE_UNSIGNED_INTEGER_VEC4:
1482                 {
1483                         if (state.getUintVec4Access()[0] != expected[0] ||
1484                                 state.getUintVec4Access()[1] != expected[1] ||
1485                                 state.getUintVec4Access()[2] != expected[2] ||
1486                                 state.getUintVec4Access()[3] != expected[3])
1487                         {
1488                                 std::ostringstream buf;
1489                                 buf << "Expected " << expected << ", got " << tcu::formatArray(state.getUintVec4Access());
1490                                 result.fail(buf.str());
1491                         }
1492                         break;
1493                 }
1494
1495                 default:
1496                         DE_ASSERT(DE_FALSE);
1497                         break;
1498         }
1499 }
1500
1501 void verifyBooleanVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::BVec4& expected)
1502 {
1503         switch (state.getType())
1504         {
1505                 case DATATYPE_BOOLEAN_VEC4:
1506                 {
1507                         const glw::GLboolean referenceVec4[4] =
1508                         {
1509                                 mapBoolToGLBoolean(expected[0]),
1510                                 mapBoolToGLBoolean(expected[1]),
1511                                 mapBoolToGLBoolean(expected[2]),
1512                                 mapBoolToGLBoolean(expected[3])
1513                         };
1514
1515                         const glw::GLboolean resultVec4[4] =
1516                         {
1517                                 mapBoolToGLBoolean(state.getBooleanVec4Access()[0]),
1518                                 mapBoolToGLBoolean(state.getBooleanVec4Access()[1]),
1519                                 mapBoolToGLBoolean(state.getBooleanVec4Access()[2]),
1520                                 mapBoolToGLBoolean(state.getBooleanVec4Access()[3])
1521                         };
1522
1523                         if (resultVec4[0] != referenceVec4[0] ||
1524                                 resultVec4[1] != referenceVec4[1] ||
1525                                 resultVec4[2] != referenceVec4[2] ||
1526                                 resultVec4[3] != referenceVec4[3])
1527                         {
1528                                 std::ostringstream buf;
1529                                 buf << "Expected " << glu::getBooleanPointerStr(referenceVec4, 4) << ", got " << glu::getBooleanPointerStr(resultVec4, 4);
1530                                 result.fail(buf.str());
1531                         }
1532
1533                         break;
1534                 }
1535                 case DATATYPE_FLOAT_VEC4:
1536                 {
1537                         const glw::GLfloat reference[4] =
1538                         {
1539                                 (expected[0] ? 1.0f : 0.0f),
1540                                 (expected[1] ? 1.0f : 0.0f),
1541                                 (expected[2] ? 1.0f : 0.0f),
1542                                 (expected[3] ? 1.0f : 0.0f)
1543                         };
1544
1545                         if (state.getFloatVec4Access()[0] != reference[0] ||
1546                                 state.getFloatVec4Access()[1] != reference[1] ||
1547                                 state.getFloatVec4Access()[2] != reference[2] ||
1548                                 state.getFloatVec4Access()[3] != reference[3])
1549                         {
1550                                 std::ostringstream buf;
1551                                 buf << "Expected " << reference << ", got " << tcu::formatArray(state.getFloatVec4Access());
1552                                 result.fail(buf.str());
1553                         }
1554                         break;
1555                 }
1556                 case DATATYPE_INTEGER_VEC4:
1557                 {
1558                         const glw::GLint reference[4] =
1559                         {
1560                                 (expected[0] ? 1 : 0),
1561                                 (expected[1] ? 1 : 0),
1562                                 (expected[2] ? 1 : 0),
1563                                 (expected[3] ? 1 : 0)
1564                         };
1565
1566                         if (state.getIntVec4Access()[0] != reference[0] ||
1567                                 state.getIntVec4Access()[1] != reference[1] ||
1568                                 state.getIntVec4Access()[2] != reference[2] ||
1569                                 state.getIntVec4Access()[3] != reference[3])
1570                         {
1571                                 std::ostringstream buf;
1572                                 buf << "Expected " << reference << ", got " << tcu::formatArray(state.getIntVec4Access());
1573                                 result.fail(buf.str());
1574                         }
1575                         break;
1576                 }
1577                 case DATATYPE_INTEGER64_VEC4:
1578                 {
1579                         const glw::GLint64 reference[4] =
1580                         {
1581                                 (expected[0] ? 1 : 0),
1582                                 (expected[1] ? 1 : 0),
1583                                 (expected[2] ? 1 : 0),
1584                                 (expected[3] ? 1 : 0)
1585                         };
1586
1587                         if (state.getInt64Vec4Access()[0] != reference[0] ||
1588                                 state.getInt64Vec4Access()[1] != reference[1] ||
1589                                 state.getInt64Vec4Access()[2] != reference[2] ||
1590                                 state.getInt64Vec4Access()[3] != reference[3])
1591                         {
1592                                 std::ostringstream buf;
1593                                 buf << "Expected " << reference << ", got " << tcu::formatArray(state.getInt64Vec4Access());
1594                                 result.fail(buf.str());
1595                         }
1596                         break;
1597                 }
1598                 case DATATYPE_UNSIGNED_INTEGER_VEC4:
1599                 {
1600                         const glw::GLuint reference[4] =
1601                         {
1602                                 (expected[0] ? 1u : 0u),
1603                                 (expected[1] ? 1u : 0u),
1604                                 (expected[2] ? 1u : 0u),
1605                                 (expected[3] ? 1u : 0u)
1606                         };
1607
1608                         if (state.getUintVec4Access()[0] != reference[0] ||
1609                                 state.getUintVec4Access()[1] != reference[1] ||
1610                                 state.getUintVec4Access()[2] != reference[2] ||
1611                                 state.getUintVec4Access()[3] != reference[3])
1612                         {
1613                                 std::ostringstream buf;
1614                                 buf << "Expected " << reference << ", got " << tcu::formatArray(state.getUintVec4Access());
1615                                 result.fail(buf.str());
1616                         }
1617                         break;
1618                 }
1619
1620                 default:
1621                         DE_ASSERT(DE_FALSE);
1622                         break;
1623         }
1624 }
1625
1626 void verifyFloatVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::Vec4& expected)
1627 {
1628         switch (state.getType())
1629         {
1630                 case DATATYPE_FLOAT_VEC4:
1631                 {
1632                         if (state.getFloatVec4Access()[0] != expected[0] ||
1633                                 state.getFloatVec4Access()[1] != expected[1] ||
1634                                 state.getFloatVec4Access()[2] != expected[2] ||
1635                                 state.getFloatVec4Access()[3] != expected[3])
1636                         {
1637                                 std::ostringstream buf;
1638                                 buf << "Expected " << expected << ", got " << tcu::formatArray(state.getFloatVec4Access());
1639                                 result.fail(buf.str());
1640                         }
1641                         break;
1642                 }
1643                 case DATATYPE_INTEGER_VEC4:
1644                 {
1645                         bool                            anyError = false;
1646                         std::ostringstream      expectation;
1647
1648                         for (int ndx = 0; ndx < 4; ++ndx)
1649                         {
1650                                 const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(expected[ndx]);
1651                                 const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(expected[ndx]);
1652
1653                                 if (state.getIntVec4Access()[ndx] < refValueMin ||
1654                                         state.getIntVec4Access()[ndx] > refValueMax)
1655                                 {
1656                                         std::ostringstream buf;
1657
1658                                         if (ndx > 0)
1659                                                 expectation << " ,";
1660
1661                                         if (refValueMin == refValueMax)
1662                                                 buf << refValueMin;
1663                                         else
1664                                                 buf << "[" << refValueMin << ", " << refValueMax << "]";
1665                                 }
1666                         }
1667
1668                         if (anyError)
1669                         {
1670                                 std::ostringstream buf;
1671                                 buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getIntVec4Access());
1672                                 result.fail(buf.str());
1673                         }
1674                         break;
1675                 }
1676                 case DATATYPE_UNSIGNED_INTEGER_VEC4:
1677                 {
1678                         bool                            anyError = false;
1679                         std::ostringstream      expectation;
1680
1681                         for (int ndx = 0; ndx < 4; ++ndx)
1682                         {
1683                                 const glw::GLuint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLuint>(expected[ndx]);
1684                                 const glw::GLuint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLuint>(expected[ndx]);
1685
1686                                 if (state.getUintVec4Access()[ndx] < refValueMin ||
1687                                         state.getUintVec4Access()[ndx] > refValueMax)
1688                                 {
1689                                         std::ostringstream buf;
1690
1691                                         if (ndx > 0)
1692                                                 expectation << " ,";
1693
1694                                         if (refValueMin == refValueMax)
1695                                                 buf << refValueMin;
1696                                         else
1697                                                 buf << "[" << refValueMin << ", " << refValueMax << "]";
1698                                 }
1699                         }
1700
1701                         if (anyError)
1702                         {
1703                                 std::ostringstream buf;
1704                                 buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getUintVec4Access());
1705                                 result.fail(buf.str());
1706                         }
1707                         break;
1708                 }
1709
1710                 default:
1711                         DE_ASSERT(DE_FALSE);
1712                         break;
1713         }
1714 }
1715
1716 void verifyPointer (tcu::ResultCollector& result, QueriedState& state, const void* expected)
1717 {
1718         switch (state.getType())
1719         {
1720                 case DATATYPE_POINTER:
1721                 {
1722                         if (state.getPtrAccess() != expected)
1723                         {
1724                                 std::ostringstream buf;
1725                                 buf << "Expected " << expected << ", got " << state.getPtrAccess();
1726                                 result.fail(buf.str());
1727                         }
1728                         break;
1729                 }
1730
1731                 default:
1732                         DE_ASSERT(DE_FALSE);
1733                         break;
1734         }
1735 }
1736
1737 static float normalizeI32Float (deInt32 c)
1738 {
1739         return de::max((float)c / float((1ul << 31) - 1u), -1.0f);
1740 }
1741
1742 void verifyNormalizedI32Vec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected)
1743 {
1744         // \note: normalization precision is irrelevant for these tests, we can use very large thresholds
1745         const float                     normalizationError      = 0.1f;
1746         const tcu::Vec4         reference                       (normalizeI32Float(expected[0]),
1747                                                                                          normalizeI32Float(expected[1]),
1748                                                                                          normalizeI32Float(expected[2]),
1749                                                                                          normalizeI32Float(expected[3]));
1750         const tcu::Vec4         validHigh                       (de::min( 1.0f, reference[0] + normalizationError),
1751                                                                                          de::min( 1.0f, reference[1] + normalizationError),
1752                                                                                          de::min( 1.0f, reference[2] + normalizationError),
1753                                                                                          de::min( 1.0f, reference[3] + normalizationError));
1754         const tcu::Vec4         validLow                        (de::max(-1.0f, reference[0] - normalizationError),
1755                                                                                          de::max(-1.0f, reference[1] - normalizationError),
1756                                                                                          de::max(-1.0f, reference[2] - normalizationError),
1757                                                                                          de::max(-1.0f, reference[3] - normalizationError));
1758
1759         switch (state.getType())
1760         {
1761                 case DATATYPE_FLOAT_VEC4:
1762                 {
1763                         bool                            anyError = false;
1764                         std::ostringstream      expectation;
1765
1766                         for (int ndx = 0; ndx < 4; ++ndx)
1767                         {
1768                                 if (state.getFloatVec4Access()[ndx] < validLow[ndx] ||
1769                                         state.getFloatVec4Access()[ndx] > validHigh[ndx])
1770                                 {
1771                                         std::ostringstream buf;
1772
1773                                         if (ndx > 0)
1774                                                 expectation << " ,";
1775                                         buf << "[" << validLow[ndx] << ", " << validHigh[ndx] << "]";
1776                                 }
1777                         }
1778
1779                         if (anyError)
1780                         {
1781                                 std::ostringstream buf;
1782                                 buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getFloatVec4Access());
1783                                 result.fail(buf.str());
1784                         }
1785                         break;
1786                 }
1787                 case DATATYPE_INTEGER_VEC4:
1788                 {
1789                         bool                            anyError = false;
1790                         std::ostringstream      expectation;
1791
1792                         for (int ndx = 0; ndx < 4; ++ndx)
1793                         {
1794                                 const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(validHigh[ndx]);
1795                                 const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(validLow[ndx]);
1796
1797                                 if (state.getIntVec4Access()[ndx] < refValueMin ||
1798                                         state.getIntVec4Access()[ndx] > refValueMax)
1799                                 {
1800                                         std::ostringstream buf;
1801
1802                                         if (ndx > 0)
1803                                                 expectation << " ,";
1804
1805                                         if (refValueMin == refValueMax)
1806                                                 buf << refValueMin;
1807                                         else
1808                                                 buf << "[" << refValueMin << ", " << refValueMax << "]";
1809                                 }
1810                         }
1811
1812                         if (anyError)
1813                         {
1814                                 std::ostringstream buf;
1815                                 buf << "Expected {" << expectation.str() << "}, got " << tcu::formatArray(state.getIntVec4Access());
1816                                 result.fail(buf.str());
1817                         }
1818                         break;
1819                 }
1820
1821                 default:
1822                         DE_ASSERT(DE_FALSE);
1823                         break;
1824         }
1825 }
1826
1827 // helpers
1828
1829 void verifyStateBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, bool refValue, QueryType type)
1830 {
1831         QueriedState state;
1832
1833         queryState(result, gl, type, target, state);
1834
1835         if (!state.isUndefined())
1836                 verifyBoolean(result, state, refValue);
1837 }
1838
1839 void verifyStateInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int refValue, QueryType type)
1840 {
1841         QueriedState state;
1842
1843         queryState(result, gl, type, target, state);
1844
1845         if (!state.isUndefined())
1846                 verifyInteger(result, state, refValue);
1847 }
1848
1849 void verifyStateIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int minValue, QueryType type)
1850 {
1851         QueriedState state;
1852
1853         queryState(result, gl, type, target, state);
1854
1855         if (!state.isUndefined())
1856                 verifyIntegerMin(result, state, minValue);
1857 }
1858
1859 void verifyStateIntegerMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int maxValue, QueryType type)
1860 {
1861         QueriedState state;
1862
1863         queryState(result, gl, type, target, state);
1864
1865         if (!state.isUndefined())
1866                 verifyIntegerMax(result, state, maxValue);
1867 }
1868
1869 void verifyStateIntegerEqualToOther (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum other, QueryType type)
1870 {
1871         QueriedState stateA;
1872         QueriedState stateB;
1873
1874         queryState(result, gl, type, target, stateA);
1875         queryState(result, gl, type, other, stateB);
1876
1877         if (stateA.isUndefined() || stateB.isUndefined())
1878                 return;
1879
1880         switch (type)
1881         {
1882                 case QUERY_BOOLEAN:
1883                 {
1884                         if (stateA.getBoolAccess() != stateB.getBoolAccess())
1885                                 result.fail("expected equal results");
1886                         break;
1887                 }
1888
1889                 case QUERY_INTEGER:
1890                 {
1891                         if (stateA.getIntAccess() != stateB.getIntAccess())
1892                                 result.fail("expected equal results");
1893                         break;
1894                 }
1895
1896                 case QUERY_INTEGER64:
1897                 {
1898                         if (stateA.getInt64Access() != stateB.getInt64Access())
1899                                 result.fail("expected equal results");
1900                         break;
1901                 }
1902
1903                 case QUERY_FLOAT:
1904                 {
1905                         if (stateA.getFloatAccess() != stateB.getFloatAccess())
1906                                 result.fail("expected equal results");
1907                         break;
1908                 }
1909
1910                 default:
1911                         DE_ASSERT(DE_FALSE);
1912                         break;
1913         }
1914 }
1915
1916 void verifyStateFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float reference, QueryType type)
1917 {
1918         QueriedState state;
1919
1920         queryState(result, gl, type, target, state);
1921
1922         if (!state.isUndefined())
1923                 verifyFloat(result, state, reference);
1924 }
1925
1926 void verifyStateFloatMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float minValue, QueryType type)
1927 {
1928         QueriedState state;
1929
1930         queryState(result, gl, type, target, state);
1931
1932         if (!state.isUndefined())
1933                 verifyFloatMin(result, state, minValue);
1934 }
1935
1936 void verifyStateFloatMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float maxValue, QueryType type)
1937 {
1938         QueriedState state;
1939
1940         queryState(result, gl, type, target, state);
1941
1942         if (!state.isUndefined())
1943                 verifyFloatMax(result, state, maxValue);
1944 }
1945
1946 void verifyStatePointer (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, const void* expected, QueryType type)
1947 {
1948         QueriedState state;
1949
1950         queryPointerState(result, gl, type, target, state);
1951
1952         if (!state.isUndefined())
1953                 verifyPointer(result, state, expected);
1954 }
1955
1956 void verifyStateIndexedBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, bool expected, QueryType type)
1957 {
1958         QueriedState state;
1959
1960         queryIndexedState(result, gl, type, target, index, state);
1961
1962         if (!state.isUndefined())
1963                 verifyBoolean(result, state, expected);
1964 }
1965
1966 void verifyStateIndexedBooleanVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, const tcu::BVec4& expected, QueryType type)
1967 {
1968         QueriedState state;
1969
1970         queryIndexedState(result, gl, type, target, index, state);
1971
1972         if (!state.isUndefined())
1973                 verifyBooleanVec4(result, state, expected);
1974 }
1975
1976 void verifyStateIndexedInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type)
1977 {
1978         QueriedState state;
1979
1980         queryIndexedState(result, gl, type, target, index, state);
1981
1982         if (!state.isUndefined())
1983                 verifyInteger(result, state, expected);
1984 }
1985
1986 void verifyStateIndexedIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int minValue, QueryType type)
1987 {
1988         QueriedState state;
1989
1990         queryIndexedState(result, gl, type, target, index, state);
1991
1992         if (!state.isUndefined())
1993                 verifyIntegerMin(result, state, minValue);
1994 }
1995
1996 void verifyStateAttributeInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type)
1997 {
1998         QueriedState state;
1999
2000         queryAttributeState(result, gl, type, target, index, state);
2001
2002         if (!state.isUndefined())
2003                 verifyInteger(result, state, expected);
2004 }
2005
2006 void verifyStateFramebufferInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type)
2007 {
2008         QueriedState state;
2009
2010         queryFramebufferState(result, gl, type, target, pname, state);
2011
2012         if (!state.isUndefined())
2013                 verifyInteger(result, state, expected);
2014 }
2015
2016 void verifyStateFramebufferIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int minValue, QueryType type)
2017 {
2018         QueriedState state;
2019
2020         queryFramebufferState(result, gl, type, target, pname, state);
2021
2022         if (!state.isUndefined())
2023                 verifyIntegerMin(result, state, minValue);
2024 }
2025
2026 void verifyStateProgramInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, int expected, QueryType type)
2027 {
2028         QueriedState state;
2029
2030         queryProgramState(result, gl, type, program, pname, state);
2031
2032         if (!state.isUndefined())
2033                 verifyInteger(result, state, expected);
2034 }
2035
2036 void verifyStateProgramIntegerVec3 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, const tcu::IVec3& expected, QueryType type)
2037 {
2038         QueriedState state;
2039
2040         queryProgramState(result, gl, type, program, pname, state);
2041
2042         if (!state.isUndefined())
2043                 verifyIntegerVec3(result, state, expected);
2044 }
2045
2046 void verifyStatePipelineInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint pipeline, glw::GLenum pname, int expected, QueryType type)
2047 {
2048         QueriedState state;
2049
2050         queryPipelineState(result, gl, type, pipeline, pname, state);
2051
2052         if (!state.isUndefined())
2053                 verifyInteger(result, state, expected);
2054 }
2055
2056 void verifyStateTextureParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type)
2057 {
2058         QueriedState state;
2059
2060         queryTextureParamState(result, gl, type, target, pname, state);
2061
2062         if (!state.isUndefined())
2063                 verifyInteger(result, state, expected);
2064 }
2065
2066 void verifyStateTextureParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, float expected, QueryType type)
2067 {
2068         QueriedState state;
2069
2070         queryTextureParamState(result, gl, type, target, pname, state);
2071
2072         if (!state.isUndefined())
2073                 verifyFloat(result, state, expected);
2074 }
2075
2076 void verifyStateTextureParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::Vec4& expected, QueryType type)
2077 {
2078         QueriedState state;
2079
2080         queryTextureParamState(result, gl, type, target, pname, state);
2081
2082         if (!state.isUndefined())
2083                 verifyFloatVec4(result, state, expected);
2084 }
2085
2086 void verifyStateTextureParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type)
2087 {
2088         QueriedState state;
2089
2090         queryTextureParamState(result, gl, type, target, pname, state);
2091
2092         if (!state.isUndefined())
2093                 verifyNormalizedI32Vec4(result, state, expected);
2094 }
2095
2096 void verifyStateTextureParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type)
2097 {
2098         QueriedState state;
2099
2100         queryTextureParamState(result, gl, type, target, pname, state);
2101
2102         if (!state.isUndefined())
2103                 verifyIntegerVec4(result, state, expected);
2104 }
2105
2106 void verifyStateTextureParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::UVec4& expected, QueryType type)
2107 {
2108         QueriedState state;
2109
2110         queryTextureParamState(result, gl, type, target, pname, state);
2111
2112         if (!state.isUndefined())
2113                 verifyUnsignedIntegerVec4(result, state, expected);
2114 }
2115
2116 void verifyStateTextureLevelInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int level, glw::GLenum pname, int expected, QueryType type)
2117 {
2118         QueriedState state;
2119
2120         queryTextureLevelState(result, gl, type, target, level, pname, state);
2121
2122         if (!state.isUndefined())
2123                 verifyInteger(result, state, expected);
2124 }
2125
2126 void verifyStateObjectBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint handle, bool expected, QueryType type)
2127 {
2128         QueriedState state;
2129
2130         queryObjectState(result, gl, type, handle, state);
2131
2132         if (!state.isUndefined())
2133                 verifyBoolean(result, state, expected);
2134 }
2135
2136 void verifyStateQueryInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type)
2137 {
2138         QueriedState state;
2139
2140         queryQueryState(result, gl, type, target, pname, state);
2141
2142         if (!state.isUndefined())
2143                 verifyInteger(result, state, expected);
2144 }
2145
2146 void verifyStateSamplerParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, int expected, QueryType type)
2147 {
2148         QueriedState state;
2149
2150         querySamplerState(result, gl, type, sampler, pname, state);
2151
2152         if (!state.isUndefined())
2153                 verifyInteger(result, state, expected);
2154 }
2155
2156 void verifyStateSamplerParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, float expected, QueryType type)
2157 {
2158         QueriedState state;
2159
2160         querySamplerState(result, gl, type, sampler, pname, state);
2161
2162         if (!state.isUndefined())
2163                 verifyFloat(result, state, expected);
2164 }
2165
2166 void verifyStateSamplerParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::Vec4& expected, QueryType type)
2167 {
2168         QueriedState state;
2169
2170         querySamplerState(result, gl, type, sampler, pname, state);
2171
2172         if (!state.isUndefined())
2173                 verifyFloatVec4(result, state, expected);
2174 }
2175
2176 void verifyStateSamplerParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type)
2177 {
2178         QueriedState state;
2179
2180         querySamplerState(result, gl, type, sampler, pname, state);
2181
2182         if (!state.isUndefined())
2183                 verifyNormalizedI32Vec4(result, state, expected);
2184 }
2185
2186 void verifyStateSamplerParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type)
2187 {
2188         QueriedState state;
2189
2190         querySamplerState(result, gl, type, sampler, pname, state);
2191
2192         if (!state.isUndefined())
2193                 verifyIntegerVec4(result, state, expected);
2194 }
2195
2196 void verifyStateSamplerParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4& expected, QueryType type)
2197 {
2198         QueriedState state;
2199
2200         querySamplerState(result, gl, type, sampler, pname, state);
2201
2202         if (!state.isUndefined())
2203                 verifyUnsignedIntegerVec4(result, state, expected);
2204 }
2205
2206 } // StateQueryUtil
2207 } // gls
2208 } // deqp