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