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