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