glsStateQueryUtil.cpp revision 654d8c53a77c4fac3c57c6e7abf1fa940e715899 
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 (glw::GLboolean 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
92bool QueriedState::isUndefined (void) const
93{
94	return m_type == DATATYPE_LAST;
95}
96
97DataType QueriedState::getType (void) const
98{
99	return m_type;
100}
101
102glw::GLint& QueriedState::getIntAccess (void)
103{
104	DE_ASSERT(m_type == DATATYPE_INTEGER);
105	return m_v.vInt;
106}
107
108glw::GLint64& QueriedState::getInt64Access (void)
109{
110	DE_ASSERT(m_type == DATATYPE_INTEGER64);
111	return m_v.vInt64;
112}
113
114glw::GLboolean& QueriedState::getBoolAccess (void)
115{
116	DE_ASSERT(m_type == DATATYPE_BOOLEAN);
117	return m_v.vBool;
118}
119
120glw::GLfloat& QueriedState::getFloatAccess (void)
121{
122	DE_ASSERT(m_type == DATATYPE_FLOAT);
123	return m_v.vFloat;
124}
125
126glw::GLuint& QueriedState::getUintAccess (void)
127{
128	DE_ASSERT(m_type == DATATYPE_UNSIGNED_INTEGER);
129	return m_v.vUint;
130}
131
132QueriedState::GLIntVec3& QueriedState::getIntVec3Access (void)
133{
134	DE_ASSERT(m_type == DATATYPE_INTEGER_VEC3);
135	return m_v.vIntVec3;
136}
137
138// query
139
140void queryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, QueriedState& state)
141{
142	switch (type)
143	{
144		case QUERY_ISENABLED:
145		{
146			const glw::GLboolean value = gl.glIsEnabled(target);
147
148			if (!checkError(result, gl, "glIsEnabled"))
149				return;
150
151			state = QueriedState(value);
152			break;
153		}
154
155		case QUERY_BOOLEAN:
156		{
157			StateQueryMemoryWriteGuard<glw::GLboolean> value;
158			gl.glGetBooleanv(target, &value);
159
160			if (!checkError(result, gl, "glGetBooleanv"))
161				return;
162
163			if (!value.verifyValidity(result))
164				return;
165
166			state = QueriedState(value);
167			break;
168		}
169
170		case QUERY_INTEGER:
171		{
172			StateQueryMemoryWriteGuard<glw::GLint> value;
173			gl.glGetIntegerv(target, &value);
174
175			if (!checkError(result, gl, "glGetIntegerv"))
176				return;
177
178			if (!value.verifyValidity(result))
179				return;
180
181			state = QueriedState(value);
182			break;
183		}
184
185		case QUERY_INTEGER64:
186		{
187			StateQueryMemoryWriteGuard<glw::GLint64> value;
188			gl.glGetInteger64v(target, &value);
189
190			if (!checkError(result, gl, "glGetInteger64v"))
191				return;
192
193			if (!value.verifyValidity(result))
194				return;
195
196			state = QueriedState(value);
197			break;
198		}
199
200		case QUERY_FLOAT:
201		{
202			StateQueryMemoryWriteGuard<glw::GLfloat> value;
203			gl.glGetFloatv(target, &value);
204
205			if (!checkError(result, gl, "glGetFloatv"))
206				return;
207
208			if (!value.verifyValidity(result))
209				return;
210
211			state = QueriedState(value);
212			break;
213		}
214
215		default:
216			DE_ASSERT(DE_FALSE);
217			break;
218	}
219}
220
221void queryIndexedState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state)
222{
223	switch (type)
224	{
225		case QUERY_INDEXED_BOOLEAN:
226		{
227			StateQueryMemoryWriteGuard<glw::GLboolean> value;
228			gl.glGetBooleani_v(target, index, &value);
229
230			if (!checkError(result, gl, "glGetBooleani_v"))
231				return;
232
233			if (!value.verifyValidity(result))
234				return;
235
236			state = QueriedState(value);
237			break;
238		}
239
240		case QUERY_INDEXED_INTEGER:
241		{
242			StateQueryMemoryWriteGuard<glw::GLint> value;
243			gl.glGetIntegeri_v(target, index, &value);
244
245			if (!checkError(result, gl, "glGetIntegeri_v"))
246				return;
247
248			if (!value.verifyValidity(result))
249				return;
250
251			state = QueriedState(value);
252			break;
253		}
254
255		case QUERY_INDEXED_INTEGER64:
256		{
257			StateQueryMemoryWriteGuard<glw::GLint64> value;
258			gl.glGetInteger64i_v(target, index, &value);
259
260			if (!checkError(result, gl, "glGetInteger64i_v"))
261				return;
262
263			if (!value.verifyValidity(result))
264				return;
265
266			state = QueriedState(value);
267			break;
268		}
269
270		default:
271			DE_ASSERT(DE_FALSE);
272			break;
273	}
274}
275
276void queryAttributeState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state)
277{
278	switch (type)
279	{
280		case QUERY_ATTRIBUTE_INTEGER:
281		{
282			StateQueryMemoryWriteGuard<glw::GLint> value;
283			gl.glGetVertexAttribiv(index, target, &value);
284
285			if (!checkError(result, gl, "glGetVertexAttribiv"))
286				return;
287
288			if (!value.verifyValidity(result))
289				return;
290
291			state = QueriedState(value);
292			break;
293		}
294		case QUERY_ATTRIBUTE_FLOAT:
295		{
296			StateQueryMemoryWriteGuard<glw::GLfloat> value;
297			gl.glGetVertexAttribfv(index, target, &value);
298
299			if (!checkError(result, gl, "glGetVertexAttribfv"))
300				return;
301
302			if (!value.verifyValidity(result))
303				return;
304
305			state = QueriedState(value);
306			break;
307		}
308		case QUERY_ATTRIBUTE_PURE_INTEGER:
309		{
310			StateQueryMemoryWriteGuard<glw::GLint> value;
311			gl.glGetVertexAttribIiv(index, target, &value);
312
313			if (!checkError(result, gl, "glGetVertexAttribIiv"))
314				return;
315
316			if (!value.verifyValidity(result))
317				return;
318
319			state = QueriedState(value);
320			break;
321		}
322		case QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER:
323		{
324			StateQueryMemoryWriteGuard<glw::GLuint> value;
325			gl.glGetVertexAttribIuiv(index, target, &value);
326
327			if (!checkError(result, gl, "glGetVertexAttribIuiv"))
328				return;
329
330			if (!value.verifyValidity(result))
331				return;
332
333			state = QueriedState(value);
334			break;
335		}
336		default:
337			DE_ASSERT(false);
338	}
339}
340
341void queryFramebufferState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state)
342{
343	switch (type)
344	{
345		case QUERY_FRAMEBUFFER_INTEGER:
346		{
347			StateQueryMemoryWriteGuard<glw::GLint> value;
348			gl.glGetFramebufferParameteriv(target, pname, &value);
349
350			if (!checkError(result, gl, "glGetVertexAttribiv"))
351				return;
352
353			if (!value.verifyValidity(result))
354				return;
355
356			state = QueriedState(value);
357			break;
358		}
359		default:
360			DE_ASSERT(false);
361	}
362}
363
364void queryProgramState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint program, glw::GLenum pname, QueriedState& state)
365{
366	switch (type)
367	{
368		case QUERY_PROGRAM_INTEGER:
369		{
370			StateQueryMemoryWriteGuard<glw::GLint> value;
371			gl.glGetProgramiv(program, pname, &value);
372
373			if (!checkError(result, gl, "glGetProgramiv"))
374				return;
375
376			if (!value.verifyValidity(result))
377				return;
378
379			state = QueriedState(value);
380			break;
381		}
382		case QUERY_PROGRAM_INTEGER_VEC3:
383		{
384			StateQueryMemoryWriteGuard<glw::GLint[3]> value;
385			gl.glGetProgramiv(program, pname, value);
386
387			if (!checkError(result, gl, "glGetProgramiv"))
388				return;
389
390			if (!value.verifyValidity(result))
391				return;
392
393			state = QueriedState(value);
394			break;
395		}
396		default:
397			DE_ASSERT(false);
398	}
399}
400
401void queryPipelineState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint pipeline, glw::GLenum pname, QueriedState& state)
402{
403	switch (type)
404	{
405		case QUERY_PIPELINE_INTEGER:
406		{
407			StateQueryMemoryWriteGuard<glw::GLint> value;
408			gl.glGetProgramPipelineiv(pipeline, pname, &value);
409
410			if (!checkError(result, gl, "glGetProgramiv"))
411				return;
412
413			if (!value.verifyValidity(result))
414				return;
415
416			state = QueriedState(value);
417			break;
418		}
419		default:
420			DE_ASSERT(false);
421	}
422}
423
424void queryTextureParamState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state)
425{
426	switch (type)
427	{
428		case QUERY_TEXTURE_PARAM_INTEGER:
429		{
430			StateQueryMemoryWriteGuard<glw::GLint> value;
431			gl.glGetTexParameteriv(target, pname, &value);
432
433			if (!checkError(result, gl, "glGetTexParameteriv"))
434				return;
435
436			if (!value.verifyValidity(result))
437				return;
438
439			state = QueriedState(value);
440			break;
441		}
442		case QUERY_TEXTURE_PARAM_FLOAT:
443		{
444			StateQueryMemoryWriteGuard<glw::GLfloat> value;
445			gl.glGetTexParameterfv(target, pname, &value);
446
447			if (!checkError(result, gl, "glGetTexParameterfv"))
448				return;
449
450			if (!value.verifyValidity(result))
451				return;
452
453			state = QueriedState(value);
454			break;
455		}
456		default:
457			DE_ASSERT(false);
458	}
459}
460
461void queryTextureLevelState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int level, glw::GLenum pname, QueriedState& state)
462{
463	switch (type)
464	{
465		case QUERY_TEXTURE_LEVEL_INTEGER:
466		{
467			StateQueryMemoryWriteGuard<glw::GLint> value;
468			gl.glGetTexLevelParameteriv(target, level, pname, &value);
469
470			if (!checkError(result, gl, "glGetTexLevelParameteriv"))
471				return;
472
473			if (!value.verifyValidity(result))
474				return;
475
476			state = QueriedState(value);
477			break;
478		}
479		case QUERY_TEXTURE_LEVEL_FLOAT:
480		{
481			StateQueryMemoryWriteGuard<glw::GLfloat> value;
482			gl.glGetTexLevelParameterfv(target, level, pname, &value);
483
484			if (!checkError(result, gl, "glGetTexLevelParameterfv"))
485				return;
486
487			if (!value.verifyValidity(result))
488				return;
489
490			state = QueriedState(value);
491			break;
492		}
493		default:
494			DE_ASSERT(false);
495	}
496}
497
498// verify
499
500void verifyBoolean (tcu::ResultCollector& result, QueriedState& state, bool expected)
501{
502	switch (state.getType())
503	{
504		case DATATYPE_BOOLEAN:
505		{
506			const glw::GLboolean reference = expected ? GL_TRUE : GL_FALSE;
507			if (state.getBoolAccess() != reference)
508			{
509				std::ostringstream buf;
510				buf << "Expected " << glu::getBooleanStr(reference) << ", got " << glu::getBooleanStr(state.getBoolAccess());
511				result.fail(buf.str());
512			}
513			break;
514		}
515
516		case DATATYPE_INTEGER:
517		{
518			const glw::GLint reference = expected ? 1 : 0;
519			if (state.getIntAccess() != reference)
520			{
521				std::ostringstream buf;
522				buf << "Expected " << reference << ", got " << state.getIntAccess();
523				result.fail(buf.str());
524			}
525			break;
526		}
527
528		case DATATYPE_INTEGER64:
529		{
530			const glw::GLint64 reference = expected ? 1 : 0;
531			if (state.getInt64Access() != reference)
532			{
533				std::ostringstream buf;
534				buf << "Expected " << reference << ", got " << state.getInt64Access();
535				result.fail(buf.str());
536			}
537			break;
538		}
539
540		case DATATYPE_FLOAT:
541		{
542			const glw::GLfloat reference = expected ? 1.0f : 0.0f;
543			if (state.getFloatAccess() != reference)
544			{
545				std::ostringstream buf;
546				buf << "Expected " << reference << ", got " << state.getFloatAccess();
547				result.fail(buf.str());
548			}
549			break;
550		}
551
552		default:
553			DE_ASSERT(DE_FALSE);
554			break;
555	}
556}
557
558void verifyInteger (tcu::ResultCollector& result, QueriedState& state, int expected)
559{
560	switch (state.getType())
561	{
562		case DATATYPE_BOOLEAN:
563		{
564			const glw::GLboolean reference = (expected == 0) ? (GL_FALSE) : (GL_TRUE);
565			if (state.getBoolAccess() != reference)
566			{
567				std::ostringstream buf;
568				buf << "Expected " << glu::getBooleanStr(reference) << ", got " << glu::getBooleanStr(state.getBoolAccess());
569				result.fail(buf.str());
570			}
571			break;
572		}
573
574		case DATATYPE_INTEGER:
575		{
576			const glw::GLint reference = expected;
577			if (state.getIntAccess() != reference)
578			{
579				std::ostringstream buf;
580				buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference))
581					<< ") , got " << state.getIntAccess() << "(" << de::toString(tcu::Format::Hex<8>(state.getIntAccess())) << ")";
582				result.fail(buf.str());
583			}
584			break;
585		}
586
587		case DATATYPE_INTEGER64:
588		{
589			const glw::GLint64 reference = (glw::GLint64)expected;
590			if (state.getInt64Access() != reference)
591			{
592				std::ostringstream buf;
593				buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got "
594					<< state.getInt64Access() << "(" << de::toString(tcu::Format::Hex<8>(state.getInt64Access())) << ")";
595				result.fail(buf.str());
596			}
597			break;
598		}
599
600		case DATATYPE_FLOAT:
601		{
602			const glw::GLfloat reference = (glw::GLfloat)expected;
603			if (state.getFloatAccess() != reference)
604			{
605				std::ostringstream buf;
606				buf << "Expected " << reference << ", got " << state.getFloatAccess();
607				result.fail(buf.str());
608			}
609			break;
610		}
611
612		case DATATYPE_UNSIGNED_INTEGER:
613		{
614			const glw::GLuint reference = (glw::GLuint)expected;
615			if (state.getUintAccess() != reference)
616			{
617				std::ostringstream buf;
618				buf << "Expected " << reference << "(" << de::toString(tcu::Format::Hex<8>(reference)) << "), got "
619					<< state.getInt64Access() << "(" << de::toString(tcu::Format::Hex<8>(state.getInt64Access())) << ")";
620				result.fail(buf.str());
621			}
622			break;
623		}
624
625		default:
626			DE_ASSERT(DE_FALSE);
627			break;
628	}
629}
630
631void verifyIntegerMin (tcu::ResultCollector& result, QueriedState& state, int minValue)
632{
633	switch (state.getType())
634	{
635		case DATATYPE_BOOLEAN:
636		{
637			if (minValue > 0 && state.getBoolAccess() != GL_TRUE)
638			{
639				std::ostringstream buf;
640				buf << "Expected GL_TRUE, got GL_FALSE";
641				result.fail(buf.str());
642			}
643			break;
644		}
645
646		case DATATYPE_INTEGER:
647		{
648			if (state.getIntAccess() < minValue)
649			{
650				std::ostringstream buf;
651				buf << "Expected greater or equal to " << minValue << ", got " << state.getIntAccess();
652				result.fail(buf.str());
653			}
654			break;
655		}
656
657		case DATATYPE_INTEGER64:
658		{
659			if (state.getInt64Access() < minValue)
660			{
661				std::ostringstream buf;
662				buf << "Expected greater or equal to " << minValue << ", got " << state.getInt64Access();
663				result.fail(buf.str());
664			}
665			break;
666		}
667
668		case DATATYPE_FLOAT:
669		{
670			if (state.getFloatAccess() < minValue)
671			{
672				std::ostringstream buf;
673				buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess();
674				result.fail(buf.str());
675			}
676			break;
677		}
678
679		default:
680			DE_ASSERT(DE_FALSE);
681			break;
682	}
683}
684
685void verifyIntegerMax (tcu::ResultCollector& result, QueriedState& state, int maxValue)
686{
687	switch (state.getType())
688	{
689		case DATATYPE_BOOLEAN:
690		{
691			if (maxValue < 0 && state.getBoolAccess() != GL_TRUE)
692			{
693				std::ostringstream buf;
694				buf << "Expected GL_TRUE, got GL_FALSE";
695				result.fail(buf.str());
696			}
697			break;
698		}
699
700		case DATATYPE_INTEGER:
701		{
702			if (state.getIntAccess() > maxValue)
703			{
704				std::ostringstream buf;
705				buf << "Expected less or equal to " << maxValue << ", got " << state.getIntAccess();
706				result.fail(buf.str());
707			}
708			break;
709		}
710
711		case DATATYPE_INTEGER64:
712		{
713			if (state.getInt64Access() > maxValue)
714			{
715				std::ostringstream buf;
716				buf << "Expected less or equal to " << maxValue << ", got " << state.getInt64Access();
717				result.fail(buf.str());
718			}
719			break;
720		}
721
722		case DATATYPE_FLOAT:
723		{
724			if (state.getFloatAccess() > maxValue)
725			{
726				std::ostringstream buf;
727				buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess();
728				result.fail(buf.str());
729			}
730			break;
731		}
732
733		default:
734			DE_ASSERT(DE_FALSE);
735			break;
736	}
737}
738
739void verifyFloat (tcu::ResultCollector& result, QueriedState& state, float expected)
740{
741	switch (state.getType())
742	{
743		case DATATYPE_BOOLEAN:
744		{
745			const glw::GLboolean reference = (expected == 0.0f) ? (GL_FALSE) : (GL_TRUE);
746			if (state.getBoolAccess() != reference)
747			{
748				std::ostringstream buf;
749				buf << "Expected " << glu::getBooleanStr(reference) << ", got " << glu::getBooleanStr(state.getBoolAccess());
750				result.fail(buf.str());
751			}
752			break;
753		}
754
755		case DATATYPE_INTEGER:
756		{
757			const glw::GLint refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(expected);
758			const glw::GLint refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(expected);
759
760			if (state.getIntAccess() < refValueMin ||
761				state.getIntAccess() > refValueMax)
762			{
763				std::ostringstream buf;
764
765				if (refValueMin == refValueMax)
766					buf << "Expected " << refValueMin << ", got " << state.getIntAccess();
767				else
768					buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getIntAccess();
769
770				result.fail(buf.str());
771			}
772			break;
773		}
774
775		case DATATYPE_FLOAT:
776		{
777			if (state.getFloatAccess() != expected)
778			{
779				std::ostringstream buf;
780				buf << "Expected " << expected << ", got " << state.getFloatAccess();
781				result.fail(buf.str());
782			}
783			break;
784		}
785
786		case DATATYPE_INTEGER64:
787		{
788			const glw::GLint64 refValueMin = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(expected);
789			const glw::GLint64 refValueMax = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(expected);
790
791			if (state.getInt64Access() < refValueMin ||
792				state.getInt64Access() > refValueMax)
793			{
794				std::ostringstream buf;
795
796				if (refValueMin == refValueMax)
797					buf << "Expected " << refValueMin << ", got " << state.getInt64Access();
798				else
799					buf << "Expected in range [" << refValueMin << ", " << refValueMax << "], got " << state.getInt64Access();
800
801				result.fail(buf.str());
802			}
803			break;
804		}
805
806		default:
807			DE_ASSERT(DE_FALSE);
808			break;
809	}
810}
811
812void verifyFloatMin (tcu::ResultCollector& result, QueriedState& state, float minValue)
813{
814	switch (state.getType())
815	{
816		case DATATYPE_BOOLEAN:
817		{
818			if (minValue > 0.0f && state.getBoolAccess() != GL_TRUE)
819				result.fail("expected GL_TRUE, got GL_FALSE");
820			break;
821		}
822
823		case DATATYPE_INTEGER:
824		{
825			const glw::GLint refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint>(minValue);
826
827			if (state.getIntAccess() < refValue)
828			{
829				std::ostringstream buf;
830				buf << "Expected greater or equal to " << refValue << ", got " << state.getIntAccess();
831				result.fail(buf.str());
832			}
833			break;
834		}
835
836		case DATATYPE_FLOAT:
837		{
838			if (state.getFloatAccess() < minValue)
839			{
840				std::ostringstream buf;
841				buf << "Expected greater or equal to " << minValue << ", got " << state.getFloatAccess();
842				result.fail(buf.str());
843			}
844			break;
845		}
846
847		case DATATYPE_INTEGER64:
848		{
849			const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfDown<glw::GLint64>(minValue);
850
851			if (state.getInt64Access() < refValue)
852			{
853				std::ostringstream buf;
854				buf << "Expected greater or equal to " << refValue << ", got " << state.getInt64Access();
855				result.fail(buf.str());
856			}
857			break;
858		}
859
860		default:
861			DE_ASSERT(DE_FALSE);
862			break;
863	}
864}
865
866void verifyFloatMax (tcu::ResultCollector& result, QueriedState& state, float maxValue)
867{
868	switch (state.getType())
869	{
870		case DATATYPE_BOOLEAN:
871		{
872			if (maxValue < 0.0f && state.getBoolAccess() != GL_TRUE)
873				result.fail("expected GL_TRUE, got GL_FALSE");
874			break;
875		}
876
877		case DATATYPE_INTEGER:
878		{
879			const glw::GLint refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint>(maxValue);
880
881			if (state.getIntAccess() > refValue)
882			{
883				std::ostringstream buf;
884				buf << "Expected less or equal to " << refValue << ", got " << state.getIntAccess();
885				result.fail(buf.str());
886			}
887			break;
888		}
889
890		case DATATYPE_FLOAT:
891		{
892			if (state.getFloatAccess() > maxValue)
893			{
894				std::ostringstream buf;
895				buf << "Expected less or equal to " << maxValue << ", got " << state.getFloatAccess();
896				result.fail(buf.str());
897			}
898			break;
899		}
900
901		case DATATYPE_INTEGER64:
902		{
903			const glw::GLint64 refValue = roundGLfloatToNearestIntegerHalfUp<glw::GLint64>(maxValue);
904
905			if (state.getInt64Access() > refValue)
906			{
907				std::ostringstream buf;
908				buf << "Expected less or equal to " << refValue << ", got " << state.getInt64Access();
909				result.fail(buf.str());
910			}
911			break;
912		}
913
914		default:
915			DE_ASSERT(DE_FALSE);
916			break;
917	}
918}
919
920void verifyIntegerVec3 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec3& expected)
921{
922	switch (state.getType())
923	{
924		case DATATYPE_INTEGER_VEC3:
925		{
926			if (state.getIntVec3Access()[0] != expected[0] ||
927				state.getIntVec3Access()[1] != expected[1] ||
928				state.getIntVec3Access()[2] != expected[2])
929			{
930				std::ostringstream buf;
931				buf << "Expected " << expected << ", got " << state.getIntVec3Access();
932				result.fail(buf.str());
933			}
934			break;
935		}
936
937		default:
938			DE_ASSERT(DE_FALSE);
939			break;
940	}
941}
942
943// helpers
944
945void verifyStateBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, bool refValue, QueryType type)
946{
947	QueriedState state;
948
949	queryState(result, gl, type, target, state);
950
951	if (!state.isUndefined())
952		verifyBoolean(result, state, refValue);
953}
954
955void verifyStateInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int refValue, QueryType type)
956{
957	QueriedState state;
958
959	queryState(result, gl, type, target, state);
960
961	if (!state.isUndefined())
962		verifyInteger(result, state, refValue);
963}
964
965void verifyStateIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int minValue, QueryType type)
966{
967	QueriedState state;
968
969	queryState(result, gl, type, target, state);
970
971	if (!state.isUndefined())
972		verifyIntegerMin(result, state, minValue);
973}
974
975void verifyStateIntegerMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int maxValue, QueryType type)
976{
977	QueriedState state;
978
979	queryState(result, gl, type, target, state);
980
981	if (!state.isUndefined())
982		verifyIntegerMax(result, state, maxValue);
983}
984
985void verifyStateIntegerEqualToOther (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum other, QueryType type)
986{
987	QueriedState stateA;
988	QueriedState stateB;
989
990	queryState(result, gl, type, target, stateA);
991	queryState(result, gl, type, other, stateB);
992
993	if (stateA.isUndefined() || stateB.isUndefined())
994		return;
995
996	switch (type)
997	{
998		case QUERY_BOOLEAN:
999		{
1000			if (stateA.getBoolAccess() != stateB.getBoolAccess())
1001				result.fail("expected equal results");
1002			break;
1003		}
1004
1005		case QUERY_INTEGER:
1006		{
1007			if (stateA.getIntAccess() != stateB.getIntAccess())
1008				result.fail("expected equal results");
1009			break;
1010		}
1011
1012		case QUERY_INTEGER64:
1013		{
1014			if (stateA.getInt64Access() != stateB.getInt64Access())
1015				result.fail("expected equal results");
1016			break;
1017		}
1018
1019		case QUERY_FLOAT:
1020		{
1021			if (stateA.getFloatAccess() != stateB.getFloatAccess())
1022				result.fail("expected equal results");
1023			break;
1024		}
1025
1026		default:
1027			DE_ASSERT(DE_FALSE);
1028			break;
1029	}
1030}
1031
1032void verifyStateFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float reference, QueryType type)
1033{
1034	QueriedState state;
1035
1036	queryState(result, gl, type, target, state);
1037
1038	if (!state.isUndefined())
1039		verifyFloat(result, state, reference);
1040}
1041
1042void verifyStateFloatMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float minValue, QueryType type)
1043{
1044	QueriedState state;
1045
1046	queryState(result, gl, type, target, state);
1047
1048	if (!state.isUndefined())
1049		verifyFloatMin(result, state, minValue);
1050}
1051
1052void verifyStateFloatMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float maxValue, QueryType type)
1053{
1054	QueriedState state;
1055
1056	queryState(result, gl, type, target, state);
1057
1058	if (!state.isUndefined())
1059		verifyFloatMax(result, state, maxValue);
1060}
1061
1062void verifyStateIndexedBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, bool expected, QueryType type)
1063{
1064	QueriedState state;
1065
1066	queryIndexedState(result, gl, type, target, index, state);
1067
1068	if (!state.isUndefined())
1069		verifyBoolean(result, state, expected);
1070}
1071
1072void verifyStateIndexedInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type)
1073{
1074	QueriedState state;
1075
1076	queryIndexedState(result, gl, type, target, index, state);
1077
1078	if (!state.isUndefined())
1079		verifyInteger(result, state, expected);
1080}
1081
1082void verifyStateIndexedIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int minValue, QueryType type)
1083{
1084	QueriedState state;
1085
1086	queryIndexedState(result, gl, type, target, index, state);
1087
1088	if (!state.isUndefined())
1089		verifyIntegerMin(result, state, minValue);
1090}
1091
1092void verifyStateAttributeInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type)
1093{
1094	QueriedState state;
1095
1096	queryAttributeState(result, gl, type, target, index, state);
1097
1098	if (!state.isUndefined())
1099		verifyInteger(result, state, expected);
1100}
1101
1102void verifyStateFramebufferInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type)
1103{
1104	QueriedState state;
1105
1106	queryFramebufferState(result, gl, type, target, pname, state);
1107
1108	if (!state.isUndefined())
1109		verifyInteger(result, state, expected);
1110}
1111
1112void verifyStateFramebufferIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int minValue, QueryType type)
1113{
1114	QueriedState state;
1115
1116	queryFramebufferState(result, gl, type, target, pname, state);
1117
1118	if (!state.isUndefined())
1119		verifyIntegerMin(result, state, minValue);
1120}
1121
1122void verifyStateProgramInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, int expected, QueryType type)
1123{
1124	QueriedState state;
1125
1126	queryProgramState(result, gl, type, program, pname, state);
1127
1128	if (!state.isUndefined())
1129		verifyInteger(result, state, expected);
1130}
1131
1132void verifyStateProgramIntegerVec3 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, const tcu::IVec3& expected, QueryType type)
1133{
1134	QueriedState state;
1135
1136	queryProgramState(result, gl, type, program, pname, state);
1137
1138	if (!state.isUndefined())
1139		verifyIntegerVec3(result, state, expected);
1140}
1141
1142void verifyStatePipelineInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint pipeline, glw::GLenum pname, int expected, QueryType type)
1143{
1144	QueriedState state;
1145
1146	queryPipelineState(result, gl, type, pipeline, pname, state);
1147
1148	if (!state.isUndefined())
1149		verifyInteger(result, state, expected);
1150}
1151
1152void verifyStateTextureParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type)
1153{
1154	QueriedState state;
1155
1156	queryTextureParamState(result, gl, type, target, pname, state);
1157
1158	if (!state.isUndefined())
1159		verifyInteger(result, state, expected);
1160}
1161
1162} // StateQueryUtil
1163} // gls
1164} // deqp
1165