xref: /aosp_15_r20/external/deqp/modules/glshared/glsStateQueryUtil.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930) 
1 #ifndef _GLSSTATEQUERYUTIL_HPP
2 #define _GLSSTATEQUERYUTIL_HPP
3 /*-------------------------------------------------------------------------
4  * drawElements Quality Program OpenGL (ES) Module
5  * -----------------------------------------------
6  *
7  * Copyright 2014 The Android Open Source Project
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  *      http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  *//*!
22  * \file
23  * \brief State Query test utils.
24  *//*--------------------------------------------------------------------*/
25 
26 #include "tcuDefs.hpp"
27 #include "tcuTestLog.hpp"
28 #include "tcuTestContext.hpp"
29 #include "tcuResultCollector.hpp"
30 #include "glwDefs.hpp"
31 #include "deMath.h"
32 
33 namespace glu
34 {
35 class CallLogWrapper;
36 } // namespace glu
37 
38 namespace deqp
39 {
40 namespace gls
41 {
42 namespace StateQueryUtil
43 {
44 
45 #define GLS_COLLECT_GL_ERROR(RES, ERR, MSG)                                                          \
46     do                                                                                               \
47     {                                                                                                \
48         const uint32_t err = (ERR);                                                                  \
49         if (err != GL_NO_ERROR)                                                                      \
50             (RES).fail(std::string("Got Error ") + glu::getErrorStr(err).toString() + ": " + (MSG)); \
51     } while (false)
52 
53 /*--------------------------------------------------------------------*//*!
54  * \brief Rounds given float to the nearest integer (half up).
55  *
56  * Returns the nearest integer for a float argument. In the case that there
57  * are two nearest integers at the equal distance (aka. the argument is of
58  * form x.5), the integer with the higher value is chosen. (x.5 rounds to x+1)
59  *//*--------------------------------------------------------------------*/
60 template <typename T>
roundGLfloatToNearestIntegerHalfUp(float val)61 T roundGLfloatToNearestIntegerHalfUp(float val)
62 {
63     return (T)(deFloatFloor(val + 0.5f));
64 }
65 
66 /*--------------------------------------------------------------------*//*!
67  * \brief Rounds given float to the nearest integer (half down).
68  *
69  * Returns the nearest integer for a float argument. In the case that there
70  * are two nearest integers at the equal distance (aka. the argument is of
71  * form x.5), the integer with the higher value is chosen. (x.5 rounds to x)
72  *//*--------------------------------------------------------------------*/
73 template <typename T>
roundGLfloatToNearestIntegerHalfDown(float val)74 T roundGLfloatToNearestIntegerHalfDown(float val)
75 {
76     return (T)(deFloatCeil(val - 0.5f));
77 }
78 
79 template <typename T>
80 class StateQueryMemoryWriteGuard
81 {
82 public:
83     StateQueryMemoryWriteGuard(void);
84 
85     operator T &(void);
86     T *operator&(void);
87 
88     bool isUndefined(void) const;
89     bool isMemoryContaminated(void) const;
90     bool isPreguardContaminated(void) const;
91     bool isPostguardContaminated(void) const;
92     bool verifyValidity(tcu::TestContext &testCtx) const;
93     bool verifyValidity(tcu::ResultCollector &result) const;
94 
get(void) const95     const T &get(void) const
96     {
97         return m_value;
98     }
99 
100 private:
101     enum
102     {
103         WRITE_GUARD_VALUE = 0xDE
104     };
105 
106     T m_preguard;
107     T m_value;
108     T m_postguard; // \note guards are not const qualified since the GL implementation might modify them
109 };
110 
111 template <typename T>
StateQueryMemoryWriteGuard(void)112 StateQueryMemoryWriteGuard<T>::StateQueryMemoryWriteGuard(void)
113 {
114     DE_STATIC_ASSERT(sizeof(T) * 3 == sizeof(StateQueryMemoryWriteGuard<T>)); // tightly packed
115 
116     deMemset(&m_preguard, WRITE_GUARD_VALUE, sizeof(m_preguard));
117     deMemset(&m_value, WRITE_GUARD_VALUE, sizeof(m_value));
118     deMemset(&m_postguard, WRITE_GUARD_VALUE, sizeof(m_postguard));
119 }
120 
121 template <typename T>
operator T&(void)122 StateQueryMemoryWriteGuard<T>::operator T &(void)
123 {
124     return m_value;
125 }
126 
127 template <typename T>
operator &(void)128 T *StateQueryMemoryWriteGuard<T>::operator&(void)
129 {
130     return &m_value;
131 }
132 
133 template <typename T>
isUndefined() const134 bool StateQueryMemoryWriteGuard<T>::isUndefined() const
135 {
136     for (size_t i = 0; i < sizeof(T); ++i)
137         if (((uint8_t *)&m_value)[i] != (uint8_t)WRITE_GUARD_VALUE)
138             return false;
139     return true;
140 }
141 
142 template <typename T>
isMemoryContaminated() const143 bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated() const
144 {
145     return isPreguardContaminated() || isPostguardContaminated();
146 }
147 
148 template <typename T>
isPreguardContaminated(void) const149 bool StateQueryMemoryWriteGuard<T>::isPreguardContaminated(void) const
150 {
151     for (size_t i = 0; i < sizeof(T); ++i)
152         if (((uint8_t *)&m_preguard)[i] != (uint8_t)WRITE_GUARD_VALUE)
153             return true;
154     return false;
155 }
156 
157 template <typename T>
isPostguardContaminated(void) const158 bool StateQueryMemoryWriteGuard<T>::isPostguardContaminated(void) const
159 {
160     for (size_t i = 0; i < sizeof(T); ++i)
161         if (((uint8_t *)&m_postguard)[i] != (uint8_t)WRITE_GUARD_VALUE)
162             return true;
163     return false;
164 }
165 
166 template <typename T>
verifyValidity(tcu::TestContext & testCtx) const167 bool StateQueryMemoryWriteGuard<T>::verifyValidity(tcu::TestContext &testCtx) const
168 {
169     using tcu::TestLog;
170 
171     if (isPreguardContaminated())
172     {
173         testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage;
174         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
175             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");
176 
177         return false;
178     }
179     else if (isPostguardContaminated())
180     {
181         testCtx.getLog() << TestLog::Message << "// ERROR: Post-guard value was modified " << TestLog::EndMessage;
182         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
183             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");
184 
185         return false;
186     }
187     else if (isUndefined())
188     {
189         testCtx.getLog() << TestLog::Message << "// ERROR: Get* did not return a value" << TestLog::EndMessage;
190         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS || testCtx.getTestResult() == QP_TEST_RESULT_LAST)
191             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did not return a value");
192 
193         return false;
194     }
195 
196     return true;
197 }
198 
199 template <typename T>
verifyValidity(tcu::ResultCollector & result) const200 bool StateQueryMemoryWriteGuard<T>::verifyValidity(tcu::ResultCollector &result) const
201 {
202     using tcu::TestLog;
203 
204     if (isPreguardContaminated())
205     {
206         result.fail("pre-guard value was modified");
207         return false;
208     }
209     else if (isPostguardContaminated())
210     {
211         result.fail("post-guard value was modified");
212         return false;
213     }
214     else if (isUndefined())
215     {
216         result.fail("Get* did not return a value");
217         return false;
218     }
219 
220     return true;
221 }
222 
223 template <typename T>
operator <<(std::ostream & str,const StateQueryMemoryWriteGuard<T> & guard)224 std::ostream &operator<<(std::ostream &str, const StateQueryMemoryWriteGuard<T> &guard)
225 {
226     return str << guard.get();
227 }
228 
229 // Verifiers
230 
231 enum QueryType
232 {
233     QUERY_BOOLEAN = 0,
234     QUERY_BOOLEAN_VEC4,
235     QUERY_ISENABLED,
236     QUERY_INTEGER,
237     QUERY_INTEGER64,
238     QUERY_FLOAT,
239 
240     // indexed
241     QUERY_INDEXED_BOOLEAN,
242     QUERY_INDEXED_BOOLEAN_VEC4,
243     QUERY_INDEXED_ISENABLED,
244     QUERY_INDEXED_INTEGER,
245     QUERY_INDEXED_INTEGER_VEC4,
246     QUERY_INDEXED_INTEGER64,
247     QUERY_INDEXED_INTEGER64_VEC4,
248 
249     // attributes
250     QUERY_ATTRIBUTE_INTEGER,
251     QUERY_ATTRIBUTE_FLOAT,
252     QUERY_ATTRIBUTE_PURE_INTEGER,
253     QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER,
254 
255     // fb
256     QUERY_FRAMEBUFFER_INTEGER,
257 
258     // program
259     QUERY_PROGRAM_INTEGER,
260     QUERY_PROGRAM_INTEGER_VEC3,
261 
262     // program pipeline
263     QUERY_PIPELINE_INTEGER,
264 
265     // texture param
266     QUERY_TEXTURE_PARAM_INTEGER,
267     QUERY_TEXTURE_PARAM_FLOAT,
268     QUERY_TEXTURE_PARAM_PURE_INTEGER,
269     QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER,
270     QUERY_TEXTURE_PARAM_INTEGER_VEC4,
271     QUERY_TEXTURE_PARAM_FLOAT_VEC4,
272     QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4,
273     QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
274 
275     // texture level
276     QUERY_TEXTURE_LEVEL_INTEGER,
277     QUERY_TEXTURE_LEVEL_FLOAT,
278 
279     // pointer
280     QUERY_POINTER,
281 
282     // object states
283     QUERY_ISTEXTURE,
284 
285     // query queries
286     QUERY_QUERY,
287 
288     // sampler state
289     QUERY_SAMPLER_PARAM_INTEGER,
290     QUERY_SAMPLER_PARAM_FLOAT,
291     QUERY_SAMPLER_PARAM_PURE_INTEGER,
292     QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER,
293     QUERY_SAMPLER_PARAM_INTEGER_VEC4,
294     QUERY_SAMPLER_PARAM_FLOAT_VEC4,
295     QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4,
296     QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
297 
298     QUERY_LAST
299 };
300 
301 enum DataType
302 {
303     DATATYPE_BOOLEAN = 0,
304     DATATYPE_INTEGER,
305     DATATYPE_INTEGER64,
306     DATATYPE_FLOAT16,
307     DATATYPE_FLOAT,
308     DATATYPE_UNSIGNED_INTEGER,
309     DATATYPE_INTEGER_VEC3,
310     DATATYPE_FLOAT_VEC4,
311     DATATYPE_INTEGER_VEC4,
312     DATATYPE_INTEGER64_VEC4,
313     DATATYPE_UNSIGNED_INTEGER_VEC4,
314     DATATYPE_BOOLEAN_VEC4,
315     DATATYPE_POINTER,
316 
317     DATATYPE_LAST
318 };
319 
320 class QueriedState
321 {
322 public:
323     typedef glw::GLint GLIntVec3[3];
324     typedef glw::GLint GLIntVec4[4];
325     typedef glw::GLuint GLUintVec4[4];
326     typedef glw::GLfloat GLFloatVec4[4];
327     typedef bool BooleanVec4[4];
328     typedef glw::GLint64 GLInt64Vec4[4];
329 
330     QueriedState(void);
331     explicit QueriedState(glw::GLint);
332     explicit QueriedState(glw::GLint64);
333     explicit QueriedState(bool);
334     explicit QueriedState(glw::GLfloat);
335     explicit QueriedState(glw::GLuint);
336     explicit QueriedState(const GLIntVec3 &);
337     explicit QueriedState(void *);
338     explicit QueriedState(const GLIntVec4 &);
339     explicit QueriedState(const GLUintVec4 &);
340     explicit QueriedState(const GLFloatVec4 &);
341     explicit QueriedState(const BooleanVec4 &);
342     explicit QueriedState(const GLInt64Vec4 &);
343 
344     bool isUndefined(void) const;
345     DataType getType(void) const;
346 
347     glw::GLint &getIntAccess(void);
348     glw::GLint64 &getInt64Access(void);
349     bool &getBoolAccess(void);
350     glw::GLfloat &getFloatAccess(void);
351     glw::GLuint &getUintAccess(void);
352     GLIntVec3 &getIntVec3Access(void);
353     void *&getPtrAccess(void);
354     GLIntVec4 &getIntVec4Access(void);
355     GLUintVec4 &getUintVec4Access(void);
356     GLFloatVec4 &getFloatVec4Access(void);
357     BooleanVec4 &getBooleanVec4Access(void);
358     GLInt64Vec4 &getInt64Vec4Access(void);
359 
360 private:
361     DataType m_type;
362     union
363     {
364         glw::GLint vInt;
365         glw::GLint64 vInt64;
366         bool vBool;
367         glw::GLfloat vFloat;
368         glw::GLuint vUint;
369         GLIntVec3 vIntVec3;
370         void *vPtr;
371         GLIntVec4 vIntVec4;
372         GLUintVec4 vUintVec4;
373         GLFloatVec4 vFloatVec4;
374         BooleanVec4 vBooleanVec4;
375         GLInt64Vec4 vInt64Vec4;
376     } m_v;
377 };
378 
379 // query functions
380 
381 void queryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum pname,
382                 QueriedState &state);
383 void queryIndexedState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
384                        int index, QueriedState &state);
385 void queryAttributeState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
386                          int index, QueriedState &state);
387 void queryFramebufferState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
388                            glw::GLenum pname, QueriedState &state);
389 void queryProgramState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint program,
390                        glw::GLenum pname, QueriedState &state);
391 void queryPipelineState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint pipeline,
392                         glw::GLenum pname, QueriedState &state);
393 void queryTextureParamState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
394                             glw::GLenum pname, QueriedState &state);
395 void queryTextureLevelState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
396                             int level, glw::GLenum pname, QueriedState &state);
397 void queryPointerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum pname,
398                        QueriedState &state);
399 void queryObjectState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint handle,
400                       QueriedState &state);
401 void queryQueryState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLenum target,
402                      glw::GLenum pname, QueriedState &state);
403 void querySamplerState(tcu::ResultCollector &result, glu::CallLogWrapper &gl, QueryType type, glw::GLuint sampler,
404                        glw::GLenum pname, QueriedState &state);
405 
406 // verification functions
407 
408 void verifyBoolean(tcu::ResultCollector &result, QueriedState &state, bool expected);
409 void verifyInteger(tcu::ResultCollector &result, QueriedState &state, int expected);
410 void verifyIntegerMin(tcu::ResultCollector &result, QueriedState &state, int minValue);
411 void verifyIntegerMax(tcu::ResultCollector &result, QueriedState &state, int maxValue);
412 void verifyIntegersEqual(tcu::ResultCollector &result, QueriedState &stateA, QueriedState &stateB);
413 void verifyFloat(tcu::ResultCollector &result, QueriedState &state, float expected);
414 void verifyFloatMin(tcu::ResultCollector &result, QueriedState &state, float minValue);
415 void verifyFloatMax(tcu::ResultCollector &result, QueriedState &state, float maxValue);
416 void verifyIntegerVec3(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec3 &expected);
417 void verifyIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected);
418 void verifyUnsignedIntegerVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::UVec4 &expected);
419 void verifyFloatVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::Vec4 &expected);
420 void verifyBooleanVec4(tcu::ResultCollector &result, QueriedState &state, const tcu::BVec4 &expected);
421 void verifyPointer(tcu::ResultCollector &result, QueriedState &state, const void *expected);
422 void verifyNormalizedI32Vec4(tcu::ResultCollector &result, QueriedState &state, const tcu::IVec4 &expected);
423 
424 // Helper functions that both query and verify
425 
426 void verifyStateBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, bool expected,
427                         QueryType type);
428 void verifyStateInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int expected,
429                         QueryType type);
430 void verifyStateIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int minValue,
431                            QueryType type);
432 void verifyStateIntegerMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int maxValue,
433                            QueryType type);
434 void verifyStateIntegerEqualToOther(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
435                                     glw::GLenum other, QueryType type);
436 void verifyStateFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float reference,
437                       QueryType type);
438 void verifyStateFloatMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float minValue,
439                          QueryType type);
440 void verifyStateFloatMax(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, float maxValue,
441                          QueryType type);
442 void verifyStatePointer(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, const void *expected,
443                         QueryType type);
444 void verifyStateIndexedBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
445                                bool expected, QueryType type);
446 void verifyStateIndexedBooleanVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
447                                    const tcu::BVec4 &expected, QueryType type);
448 void verifyStateIndexedInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
449                                int expected, QueryType type);
450 void verifyStateIndexedIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
451                                   int minValue, QueryType type);
452 void verifyStateAttributeInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target, int index,
453                                  int expected, QueryType type);
454 void verifyStateFramebufferInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
455                                    glw::GLenum pname, int expected, QueryType type);
456 void verifyStateFramebufferIntegerMin(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
457                                       glw::GLenum pname, int minValue, QueryType type);
458 void verifyStateProgramInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program,
459                                glw::GLenum pname, int expected, QueryType type);
460 void verifyStateProgramIntegerVec3(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint program,
461                                    glw::GLenum pname, const tcu::IVec3 &expected, QueryType type);
462 void verifyStatePipelineInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint pipeline,
463                                 glw::GLenum pname, int expected, QueryType type);
464 void verifyStateTextureParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
465                                     glw::GLenum pname, int expected, QueryType type);
466 void verifyStateTextureParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
467                                   glw::GLenum pname, float expected, QueryType type);
468 void verifyStateTextureParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
469                                       glw::GLenum pname, const tcu::Vec4 &expected, QueryType type);
470 void verifyStateTextureParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
471                                               glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
472 void verifyStateTextureParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
473                                         glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
474 void verifyStateTextureParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
475                                                 glw::GLenum target, glw::GLenum pname, const tcu::UVec4 &expected,
476                                                 QueryType type);
477 void verifyStateTextureLevelInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
478                                     int level, glw::GLenum pname, int expected, QueryType type);
479 void verifyStateObjectBoolean(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint handle, bool expected,
480                               QueryType type);
481 void verifyStateQueryInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLenum target,
482                              glw::GLenum pname, int expected, QueryType type);
483 void verifyStateSamplerParamInteger(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
484                                     glw::GLenum pname, int expected, QueryType type);
485 void verifyStateSamplerParamFloat(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
486                                   glw::GLenum pname, float expected, QueryType type);
487 void verifyStateSamplerParamFloatVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
488                                       glw::GLenum pname, const tcu::Vec4 &expected, QueryType type);
489 void verifyStateSamplerParamNormalizedI32Vec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
490                                               glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4 &expected,
491                                               QueryType type);
492 void verifyStateSamplerParamIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl, glw::GLuint sampler,
493                                         glw::GLenum pname, const tcu::IVec4 &expected, QueryType type);
494 void verifyStateSamplerParamUnsignedIntegerVec4(tcu::ResultCollector &result, glu::CallLogWrapper &gl,
495                                                 glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4 &expected,
496                                                 QueryType type);
497 
498 } // namespace StateQueryUtil
499 } // namespace gls
500 } // namespace deqp
501 
502 #endif // _GLSSTATEQUERYUTIL_HPP
503