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>
roundGLfloatToNearestIntegerHalfUp(float val)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>
roundGLfloatToNearestIntegerHalfDown(float val)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
get(void) const96 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>
StateQueryMemoryWriteGuard(void)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>
operator T&(void)123 StateQueryMemoryWriteGuard<T>::operator T& (void)
124 {
125 return m_value;
126 }
127
128 template <typename T>
operator &(void)129 T* StateQueryMemoryWriteGuard<T>::operator & (void)
130 {
131 return &m_value;
132 }
133
134 template <typename T>
isUndefined() const135 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>
isMemoryContaminated() const144 bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated () const
145 {
146 return isPreguardContaminated() || isPostguardContaminated();
147 }
148
149 template <typename T>
isPreguardContaminated(void) const150 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>
isPostguardContaminated(void) const159 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>
verifyValidity(tcu::TestContext & testCtx) const168 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>
verifyValidity(tcu::ResultCollector & result) const204 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>
operator <<(std::ostream & str,const StateQueryMemoryWriteGuard<T> & guard)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
457