Home | History | Annotate | Download | only in glshared
      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(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
   2209