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