Merge "Remove tests affected by NV/OES_viewport_array extension" into nougat-cts...
[platform/upstream/VK-GL-CTS.git] / modules / glshared / glsStateQueryUtil.hpp
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 } // 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 deUint32 err = (ERR); \
49                 if (err != GL_NO_ERROR) \
50                         (RES).fail(std::string("Got Error ") + glu::getErrorStr(err).toString() + ": " + (MSG)); \
51         } \
52         while (deGetFalse())
53
54 /*--------------------------------------------------------------------*//*!
55  * \brief Rounds given float to the nearest integer (half up).
56  *
57  * Returns the nearest integer for a float argument. In the case that there
58  * are two nearest integers at the equal distance (aka. the argument is of
59  * form x.5), the integer with the higher value is chosen. (x.5 rounds to x+1)
60  *//*--------------------------------------------------------------------*/
61 template <typename T>
62 T roundGLfloatToNearestIntegerHalfUp (float val)
63 {
64         return (T)(deFloatFloor(val + 0.5f));
65 }
66
67 /*--------------------------------------------------------------------*//*!
68  * \brief Rounds given float to the nearest integer (half down).
69  *
70  * Returns the nearest integer for a float argument. In the case that there
71  * are two nearest integers at the equal distance (aka. the argument is of
72  * form x.5), the integer with the higher value is chosen. (x.5 rounds to x)
73  *//*--------------------------------------------------------------------*/
74 template <typename T>
75 T roundGLfloatToNearestIntegerHalfDown (float val)
76 {
77         return (T)(deFloatCeil(val - 0.5f));
78 }
79
80 template <typename T>
81 class StateQueryMemoryWriteGuard
82 {
83 public:
84                                         StateQueryMemoryWriteGuard      (void);
85
86                                         operator T&                                     (void);
87         T*                              operator &                                      (void);
88
89         bool                    isUndefined                                     (void) const;
90         bool                    isMemoryContaminated            (void) const;
91         bool                    isPreguardContaminated          (void) const;
92         bool                    isPostguardContaminated         (void) const;
93         bool                    verifyValidity                          (tcu::TestContext& testCtx) const;
94         bool                    verifyValidity                          (tcu::ResultCollector& result) const;
95
96         const T&                get                                                     (void) const { return m_value; }
97
98 private:
99         enum
100         {
101                 WRITE_GUARD_VALUE = 0xDE
102         };
103
104         T                               m_preguard;
105         T                               m_value;
106         T                               m_postguard; // \note guards are not const qualified since the GL implementation might modify them
107 };
108
109 template <typename T>
110 StateQueryMemoryWriteGuard<T>::StateQueryMemoryWriteGuard (void)
111 {
112         DE_STATIC_ASSERT(sizeof(T) * 3 == sizeof(StateQueryMemoryWriteGuard<T>)); // tightly packed
113
114         for (size_t i = 0; i < sizeof(T); ++i)
115         {
116                 ((deUint8*)&m_preguard)[i]      = (deUint8)WRITE_GUARD_VALUE;
117                 ((deUint8*)&m_value)[i]         = (deUint8)WRITE_GUARD_VALUE;
118                 ((deUint8*)&m_postguard)[i]     = (deUint8)WRITE_GUARD_VALUE;
119         }
120 }
121
122 template <typename T>
123 StateQueryMemoryWriteGuard<T>::operator T& (void)
124 {
125         return m_value;
126 }
127
128 template <typename T>
129 T* StateQueryMemoryWriteGuard<T>::operator & (void)
130 {
131         return &m_value;
132 }
133
134 template <typename T>
135 bool StateQueryMemoryWriteGuard<T>::isUndefined () const
136 {
137         for (size_t i = 0; i < sizeof(T); ++i)
138                 if (((deUint8*)&m_value)[i] != (deUint8)WRITE_GUARD_VALUE)
139                         return false;
140         return true;
141 }
142
143 template <typename T>
144 bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated () const
145 {
146         return isPreguardContaminated() || isPostguardContaminated();
147 }
148
149 template <typename T>
150 bool StateQueryMemoryWriteGuard<T>::isPreguardContaminated (void) const
151 {
152         for (size_t i = 0; i < sizeof(T); ++i)
153                 if (((deUint8*)&m_preguard)[i] != (deUint8)WRITE_GUARD_VALUE)
154                         return true;
155         return false;
156 }
157
158 template <typename T>
159 bool StateQueryMemoryWriteGuard<T>::isPostguardContaminated (void) const
160 {
161         for (size_t i = 0; i < sizeof(T); ++i)
162                 if (((deUint8*)&m_postguard)[i] != (deUint8)WRITE_GUARD_VALUE)
163                         return true;
164         return false;
165 }
166
167 template <typename T>
168 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::TestContext& testCtx) const
169 {
170         using tcu::TestLog;
171
172         if (isPreguardContaminated())
173         {
174                 testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage;
175                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
176                         testCtx.getTestResult() == QP_TEST_RESULT_LAST)
177                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");
178
179                 return false;
180         }
181         else if (isPostguardContaminated())
182         {
183                 testCtx.getLog() << TestLog::Message << "// ERROR: Post-guard value was modified " << TestLog::EndMessage;
184                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
185                         testCtx.getTestResult() == QP_TEST_RESULT_LAST)
186                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");
187
188                 return false;
189         }
190         else if (isUndefined())
191         {
192                 testCtx.getLog() << TestLog::Message << "// ERROR: Get* did not return a value" << TestLog::EndMessage;
193                 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
194                         testCtx.getTestResult() == QP_TEST_RESULT_LAST)
195                         testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did not return a value");
196
197                 return false;
198         }
199
200         return true;
201 }
202
203 template <typename T>
204 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::ResultCollector& result) const
205 {
206         using tcu::TestLog;
207
208         if (isPreguardContaminated())
209         {
210                 result.fail("pre-guard value was modified");
211                 return false;
212         }
213         else if (isPostguardContaminated())
214         {
215                 result.fail("post-guard value was modified");
216                 return false;
217         }
218         else if (isUndefined())
219         {
220                 result.fail("Get* did not return a value");
221                 return false;
222         }
223
224         return true;
225 }
226
227 template<typename T>
228 std::ostream& operator<< (std::ostream& str, const StateQueryMemoryWriteGuard<T>& guard)
229 {
230         return str << guard.get();
231 }
232
233 // Verifiers
234
235 enum QueryType
236 {
237         QUERY_BOOLEAN = 0,
238         QUERY_BOOLEAN_VEC4,
239         QUERY_ISENABLED,
240         QUERY_INTEGER,
241         QUERY_INTEGER64,
242         QUERY_FLOAT,
243
244         // indexed
245         QUERY_INDEXED_BOOLEAN,
246         QUERY_INDEXED_BOOLEAN_VEC4,
247         QUERY_INDEXED_ISENABLED,
248         QUERY_INDEXED_INTEGER,
249         QUERY_INDEXED_INTEGER_VEC4,
250         QUERY_INDEXED_INTEGER64,
251         QUERY_INDEXED_INTEGER64_VEC4,
252
253         // attributes
254         QUERY_ATTRIBUTE_INTEGER,
255         QUERY_ATTRIBUTE_FLOAT,
256         QUERY_ATTRIBUTE_PURE_INTEGER,
257         QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER,
258
259         // fb
260         QUERY_FRAMEBUFFER_INTEGER,
261
262         // program
263         QUERY_PROGRAM_INTEGER,
264         QUERY_PROGRAM_INTEGER_VEC3,
265
266         // program pipeline
267         QUERY_PIPELINE_INTEGER,
268
269         // texture param
270         QUERY_TEXTURE_PARAM_INTEGER,
271         QUERY_TEXTURE_PARAM_FLOAT,
272         QUERY_TEXTURE_PARAM_PURE_INTEGER,
273         QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER,
274         QUERY_TEXTURE_PARAM_INTEGER_VEC4,
275         QUERY_TEXTURE_PARAM_FLOAT_VEC4,
276         QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4,
277         QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
278
279         // texture level
280         QUERY_TEXTURE_LEVEL_INTEGER,
281         QUERY_TEXTURE_LEVEL_FLOAT,
282
283         // pointer
284         QUERY_POINTER,
285
286         // object states
287         QUERY_ISTEXTURE,
288
289         // query queries
290         QUERY_QUERY,
291
292         // sampler state
293         QUERY_SAMPLER_PARAM_INTEGER,
294         QUERY_SAMPLER_PARAM_FLOAT,
295         QUERY_SAMPLER_PARAM_PURE_INTEGER,
296         QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER,
297         QUERY_SAMPLER_PARAM_INTEGER_VEC4,
298         QUERY_SAMPLER_PARAM_FLOAT_VEC4,
299         QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4,
300         QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
301
302         QUERY_LAST
303 };
304
305 enum DataType
306 {
307         DATATYPE_BOOLEAN = 0,
308         DATATYPE_INTEGER,
309         DATATYPE_INTEGER64,
310         DATATYPE_FLOAT,
311         DATATYPE_UNSIGNED_INTEGER,
312         DATATYPE_INTEGER_VEC3,
313         DATATYPE_FLOAT_VEC4,
314         DATATYPE_INTEGER_VEC4,
315         DATATYPE_INTEGER64_VEC4,
316         DATATYPE_UNSIGNED_INTEGER_VEC4,
317         DATATYPE_BOOLEAN_VEC4,
318         DATATYPE_POINTER,
319
320         DATATYPE_LAST
321 };
322
323 class QueriedState
324 {
325 public:
326         typedef glw::GLint              GLIntVec3[3];
327         typedef glw::GLint              GLIntVec4[4];
328         typedef glw::GLuint             GLUintVec4[4];
329         typedef glw::GLfloat    GLFloatVec4[4];
330         typedef bool                    BooleanVec4[4];
331         typedef glw::GLint64    GLInt64Vec4[4];
332
333                                                         QueriedState                    (void);
334         explicit                                QueriedState                    (glw::GLint);
335         explicit                                QueriedState                    (glw::GLint64);
336         explicit                                QueriedState                    (bool);
337         explicit                                QueriedState                    (glw::GLfloat);
338         explicit                                QueriedState                    (glw::GLuint);
339         explicit                                QueriedState                    (const GLIntVec3&);
340         explicit                                QueriedState                    (void*);
341         explicit                                QueriedState                    (const GLIntVec4&);
342         explicit                                QueriedState                    (const GLUintVec4&);
343         explicit                                QueriedState                    (const GLFloatVec4&);
344         explicit                                QueriedState                    (const BooleanVec4&);
345         explicit                                QueriedState                    (const GLInt64Vec4&);
346
347         bool                                    isUndefined                             (void) const;
348         DataType                                getType                                 (void) const;
349
350         glw::GLint&                             getIntAccess                    (void);
351         glw::GLint64&                   getInt64Access                  (void);
352         bool&                                   getBoolAccess                   (void);
353         glw::GLfloat&                   getFloatAccess                  (void);
354         glw::GLuint&                    getUintAccess                   (void);
355         GLIntVec3&                              getIntVec3Access                (void);
356         void*&                                  getPtrAccess                    (void);
357         GLIntVec4&                              getIntVec4Access                (void);
358         GLUintVec4&                             getUintVec4Access               (void);
359         GLFloatVec4&                    getFloatVec4Access              (void);
360         BooleanVec4&                    getBooleanVec4Access    (void);
361         GLInt64Vec4&                    getInt64Vec4Access              (void);
362
363 private:
364         DataType                                m_type;
365         union
366         {
367                 glw::GLint                      vInt;
368                 glw::GLint64            vInt64;
369                 bool                            vBool;
370                 glw::GLfloat            vFloat;
371                 glw::GLuint                     vUint;
372                 GLIntVec3                       vIntVec3;
373                 void*                           vPtr;
374                 GLIntVec4                       vIntVec4;
375                 GLUintVec4                      vUintVec4;
376                 GLFloatVec4                     vFloatVec4;
377                 BooleanVec4                     vBooleanVec4;
378                 GLInt64Vec4                     vInt64Vec4;
379         } m_v;
380 };
381
382 // query functions
383
384 void queryState                                                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state);
385 void queryIndexedState                                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state);
386 void queryAttributeState                                                (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state);
387 void queryFramebufferState                                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
388 void queryProgramState                                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint program, glw::GLenum pname, QueriedState& state);
389 void queryPipelineState                                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint pipeline, glw::GLenum pname, QueriedState& state);
390 void queryTextureParamState                                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
391 void queryTextureLevelState                                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int level, glw::GLenum pname, QueriedState& state);
392 void queryPointerState                                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state);
393 void queryObjectState                                                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint handle, QueriedState& state);
394 void queryQueryState                                                    (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
395 void querySamplerState                                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint sampler, glw::GLenum pname, QueriedState& state);
396
397 // verification functions
398
399 void verifyBoolean                                                              (tcu::ResultCollector& result, QueriedState& state, bool expected);
400 void verifyInteger                                                              (tcu::ResultCollector& result, QueriedState& state, int expected);
401 void verifyIntegerMin                                                   (tcu::ResultCollector& result, QueriedState& state, int minValue);
402 void verifyIntegerMax                                                   (tcu::ResultCollector& result, QueriedState& state, int maxValue);
403 void verifyIntegersEqual                                                (tcu::ResultCollector& result, QueriedState& stateA, QueriedState& stateB);
404 void verifyFloat                                                                (tcu::ResultCollector& result, QueriedState& state, float expected);
405 void verifyFloatMin                                                             (tcu::ResultCollector& result, QueriedState& state, float minValue);
406 void verifyFloatMax                                                             (tcu::ResultCollector& result, QueriedState& state, float maxValue);
407 void verifyIntegerVec3                                                  (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec3& expected);
408 void verifyIntegerVec4                                                  (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected);
409 void verifyUnsignedIntegerVec4                                  (tcu::ResultCollector& result, QueriedState& state, const tcu::UVec4& expected);
410 void verifyFloatVec4                                                    (tcu::ResultCollector& result, QueriedState& state, const tcu::Vec4& expected);
411 void verifyBooleanVec4                                                  (tcu::ResultCollector& result, QueriedState& state, const tcu::BVec4& expected);
412 void verifyPointer                                                              (tcu::ResultCollector& result, QueriedState& state, const void* expected);
413 void verifyNormalizedI32Vec4                                    (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected);
414
415 // Helper functions that both query and verify
416
417 void verifyStateBoolean                                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             bool expected,                  QueryType type);
418 void verifyStateInteger                                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int expected,                   QueryType type);
419 void verifyStateIntegerMin                                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int minValue,                   QueryType type);
420 void verifyStateIntegerMax                                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int maxValue,                   QueryType type);
421 void verifyStateIntegerEqualToOther                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum other,              QueryType type);
422 void verifyStateFloat                                                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             float reference,                QueryType type);
423 void verifyStateFloatMin                                                (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             float minValue,                 QueryType type);
424 void verifyStateFloatMax                                                (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             float maxValue,                 QueryType type);
425 void verifyStatePointer                                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             const void* expected,   QueryType type);
426 void verifyStateIndexedBoolean                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int index,                              bool expected,                          QueryType type);
427 void verifyStateIndexedBooleanVec4                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int index,                              const tcu::BVec4& expected,     QueryType type);
428 void verifyStateIndexedInteger                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int index,                              int expected,                           QueryType type);
429 void verifyStateIndexedIntegerMin                               (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int index,                              int minValue,                           QueryType type);
430 void verifyStateAttributeInteger                                (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int index,                              int expected,                           QueryType type);
431 void verifyStateFramebufferInteger                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              int expected,                           QueryType type);
432 void verifyStateFramebufferIntegerMin                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              int minValue,                           QueryType type);
433 void verifyStateProgramInteger                                  (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program,    glw::GLenum pname,              int expected,                           QueryType type);
434 void verifyStateProgramIntegerVec3                              (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program,    glw::GLenum pname,              const tcu::IVec3& expected,     QueryType type);
435 void verifyStatePipelineInteger                                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint pipeline,   glw::GLenum pname,              int expected,                           QueryType type);
436 void verifyStateTextureParamInteger                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              int expected,                           QueryType type);
437 void verifyStateTextureParamFloat                               (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              float expected,                         QueryType type);
438 void verifyStateTextureParamFloatVec4                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              const tcu::Vec4& expected,      QueryType type);
439 void verifyStateTextureParamNormalizedI32Vec4   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              const tcu::IVec4& expected,     QueryType type);
440 void verifyStateTextureParamIntegerVec4                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              const tcu::IVec4& expected,     QueryType type);
441 void verifyStateTextureParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              const tcu::UVec4& expected,     QueryType type);
442 void verifyStateTextureLevelInteger                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             int level,                              glw::GLenum pname,                      int expected,           QueryType type);
443 void verifyStateObjectBoolean                                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint handle,             bool expected,                  QueryType type);
444 void verifyStateQueryInteger                                    (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target,             glw::GLenum pname,              int expected,                           QueryType type);
445 void verifyStateSamplerParamInteger                             (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              int expected,                           QueryType type);
446 void verifyStateSamplerParamFloat                               (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              float expected,                         QueryType type);
447 void verifyStateSamplerParamFloatVec4                   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              const tcu::Vec4& expected,      QueryType type);
448 void verifyStateSamplerParamNormalizedI32Vec4   (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              const tcu::IVec4& expected,     QueryType type);
449 void verifyStateSamplerParamIntegerVec4                 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              const tcu::IVec4& expected,     QueryType type);
450 void verifyStateSamplerParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler,    glw::GLenum pname,              const tcu::UVec4& expected,     QueryType type);
451
452 } // StateQueryUtil
453 } // gls
454 } // deqp
455
456 #endif // _GLSSTATEQUERYUTIL_HPP