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 deMemset(&m_preguard, WRITE_GUARD_VALUE, sizeof(m_preguard));
115 deMemset(&m_value, WRITE_GUARD_VALUE, sizeof(m_value));
116 deMemset(&m_postguard, WRITE_GUARD_VALUE, sizeof(m_postguard));
117 }
118
119 template <typename T>
operator T&(void)120 StateQueryMemoryWriteGuard<T>::operator T& (void)
121 {
122 return m_value;
123 }
124
125 template <typename T>
operator &(void)126 T* StateQueryMemoryWriteGuard<T>::operator & (void)
127 {
128 return &m_value;
129 }
130
131 template <typename T>
isUndefined() const132 bool StateQueryMemoryWriteGuard<T>::isUndefined () const
133 {
134 for (size_t i = 0; i < sizeof(T); ++i)
135 if (((deUint8*)&m_value)[i] != (deUint8)WRITE_GUARD_VALUE)
136 return false;
137 return true;
138 }
139
140 template <typename T>
isMemoryContaminated() const141 bool StateQueryMemoryWriteGuard<T>::isMemoryContaminated () const
142 {
143 return isPreguardContaminated() || isPostguardContaminated();
144 }
145
146 template <typename T>
isPreguardContaminated(void) const147 bool StateQueryMemoryWriteGuard<T>::isPreguardContaminated (void) const
148 {
149 for (size_t i = 0; i < sizeof(T); ++i)
150 if (((deUint8*)&m_preguard)[i] != (deUint8)WRITE_GUARD_VALUE)
151 return true;
152 return false;
153 }
154
155 template <typename T>
isPostguardContaminated(void) const156 bool StateQueryMemoryWriteGuard<T>::isPostguardContaminated (void) const
157 {
158 for (size_t i = 0; i < sizeof(T); ++i)
159 if (((deUint8*)&m_postguard)[i] != (deUint8)WRITE_GUARD_VALUE)
160 return true;
161 return false;
162 }
163
164 template <typename T>
verifyValidity(tcu::TestContext & testCtx) const165 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::TestContext& testCtx) const
166 {
167 using tcu::TestLog;
168
169 if (isPreguardContaminated())
170 {
171 testCtx.getLog() << TestLog::Message << "// ERROR: Pre-guard value was modified " << TestLog::EndMessage;
172 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
173 testCtx.getTestResult() == QP_TEST_RESULT_LAST)
174 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did an illegal memory write");
175
176 return false;
177 }
178 else if (isPostguardContaminated())
179 {
180 testCtx.getLog() << TestLog::Message << "// ERROR: Post-guard value was modified " << TestLog::EndMessage;
181 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS ||
182 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 ||
191 testCtx.getTestResult() == QP_TEST_RESULT_LAST)
192 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Get* did not return a value");
193
194 return false;
195 }
196
197 return true;
198 }
199
200 template <typename T>
verifyValidity(tcu::ResultCollector & result) const201 bool StateQueryMemoryWriteGuard<T>::verifyValidity (tcu::ResultCollector& result) const
202 {
203 using tcu::TestLog;
204
205 if (isPreguardContaminated())
206 {
207 result.fail("pre-guard value was modified");
208 return false;
209 }
210 else if (isPostguardContaminated())
211 {
212 result.fail("post-guard value was modified");
213 return false;
214 }
215 else if (isUndefined())
216 {
217 result.fail("Get* did not return a value");
218 return false;
219 }
220
221 return true;
222 }
223
224 template<typename T>
operator <<(std::ostream & str,const StateQueryMemoryWriteGuard<T> & guard)225 std::ostream& operator<< (std::ostream& str, const StateQueryMemoryWriteGuard<T>& guard)
226 {
227 return str << guard.get();
228 }
229
230 // Verifiers
231
232 enum QueryType
233 {
234 QUERY_BOOLEAN = 0,
235 QUERY_BOOLEAN_VEC4,
236 QUERY_ISENABLED,
237 QUERY_INTEGER,
238 QUERY_INTEGER64,
239 QUERY_FLOAT,
240
241 // indexed
242 QUERY_INDEXED_BOOLEAN,
243 QUERY_INDEXED_BOOLEAN_VEC4,
244 QUERY_INDEXED_ISENABLED,
245 QUERY_INDEXED_INTEGER,
246 QUERY_INDEXED_INTEGER_VEC4,
247 QUERY_INDEXED_INTEGER64,
248 QUERY_INDEXED_INTEGER64_VEC4,
249
250 // attributes
251 QUERY_ATTRIBUTE_INTEGER,
252 QUERY_ATTRIBUTE_FLOAT,
253 QUERY_ATTRIBUTE_PURE_INTEGER,
254 QUERY_ATTRIBUTE_PURE_UNSIGNED_INTEGER,
255
256 // fb
257 QUERY_FRAMEBUFFER_INTEGER,
258
259 // program
260 QUERY_PROGRAM_INTEGER,
261 QUERY_PROGRAM_INTEGER_VEC3,
262
263 // program pipeline
264 QUERY_PIPELINE_INTEGER,
265
266 // texture param
267 QUERY_TEXTURE_PARAM_INTEGER,
268 QUERY_TEXTURE_PARAM_FLOAT,
269 QUERY_TEXTURE_PARAM_PURE_INTEGER,
270 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER,
271 QUERY_TEXTURE_PARAM_INTEGER_VEC4,
272 QUERY_TEXTURE_PARAM_FLOAT_VEC4,
273 QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4,
274 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
275
276 // texture level
277 QUERY_TEXTURE_LEVEL_INTEGER,
278 QUERY_TEXTURE_LEVEL_FLOAT,
279
280 // pointer
281 QUERY_POINTER,
282
283 // object states
284 QUERY_ISTEXTURE,
285
286 // query queries
287 QUERY_QUERY,
288
289 // sampler state
290 QUERY_SAMPLER_PARAM_INTEGER,
291 QUERY_SAMPLER_PARAM_FLOAT,
292 QUERY_SAMPLER_PARAM_PURE_INTEGER,
293 QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER,
294 QUERY_SAMPLER_PARAM_INTEGER_VEC4,
295 QUERY_SAMPLER_PARAM_FLOAT_VEC4,
296 QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4,
297 QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
298
299 QUERY_LAST
300 };
301
302 enum DataType
303 {
304 DATATYPE_BOOLEAN = 0,
305 DATATYPE_INTEGER,
306 DATATYPE_INTEGER64,
307 DATATYPE_FLOAT16,
308 DATATYPE_FLOAT,
309 DATATYPE_UNSIGNED_INTEGER,
310 DATATYPE_INTEGER_VEC3,
311 DATATYPE_FLOAT_VEC4,
312 DATATYPE_INTEGER_VEC4,
313 DATATYPE_INTEGER64_VEC4,
314 DATATYPE_UNSIGNED_INTEGER_VEC4,
315 DATATYPE_BOOLEAN_VEC4,
316 DATATYPE_POINTER,
317
318 DATATYPE_LAST
319 };
320
321 class QueriedState
322 {
323 public:
324 typedef glw::GLint GLIntVec3[3];
325 typedef glw::GLint GLIntVec4[4];
326 typedef glw::GLuint GLUintVec4[4];
327 typedef glw::GLfloat GLFloatVec4[4];
328 typedef bool BooleanVec4[4];
329 typedef glw::GLint64 GLInt64Vec4[4];
330
331 QueriedState (void);
332 explicit QueriedState (glw::GLint);
333 explicit QueriedState (glw::GLint64);
334 explicit QueriedState (bool);
335 explicit QueriedState (glw::GLfloat);
336 explicit QueriedState (glw::GLuint);
337 explicit QueriedState (const GLIntVec3&);
338 explicit QueriedState (void*);
339 explicit QueriedState (const GLIntVec4&);
340 explicit QueriedState (const GLUintVec4&);
341 explicit QueriedState (const GLFloatVec4&);
342 explicit QueriedState (const BooleanVec4&);
343 explicit QueriedState (const GLInt64Vec4&);
344
345 bool isUndefined (void) const;
346 DataType getType (void) const;
347
348 glw::GLint& getIntAccess (void);
349 glw::GLint64& getInt64Access (void);
350 bool& getBoolAccess (void);
351 glw::GLfloat& getFloatAccess (void);
352 glw::GLuint& getUintAccess (void);
353 GLIntVec3& getIntVec3Access (void);
354 void*& getPtrAccess (void);
355 GLIntVec4& getIntVec4Access (void);
356 GLUintVec4& getUintVec4Access (void);
357 GLFloatVec4& getFloatVec4Access (void);
358 BooleanVec4& getBooleanVec4Access (void);
359 GLInt64Vec4& getInt64Vec4Access (void);
360
361 private:
362 DataType m_type;
363 union
364 {
365 glw::GLint vInt;
366 glw::GLint64 vInt64;
367 bool vBool;
368 glw::GLfloat vFloat;
369 glw::GLuint vUint;
370 GLIntVec3 vIntVec3;
371 void* vPtr;
372 GLIntVec4 vIntVec4;
373 GLUintVec4 vUintVec4;
374 GLFloatVec4 vFloatVec4;
375 BooleanVec4 vBooleanVec4;
376 GLInt64Vec4 vInt64Vec4;
377 } m_v;
378 };
379
380 // query functions
381
382 void queryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state);
383 void queryIndexedState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state);
384 void queryAttributeState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int index, QueriedState& state);
385 void queryFramebufferState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
386 void queryProgramState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint program, glw::GLenum pname, QueriedState& state);
387 void queryPipelineState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint pipeline, glw::GLenum pname, QueriedState& state);
388 void queryTextureParamState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
389 void queryTextureLevelState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, int level, glw::GLenum pname, QueriedState& state);
390 void queryPointerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum pname, QueriedState& state);
391 void queryObjectState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint handle, QueriedState& state);
392 void queryQueryState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLenum target, glw::GLenum pname, QueriedState& state);
393 void querySamplerState (tcu::ResultCollector& result, glu::CallLogWrapper& gl, QueryType type, glw::GLuint sampler, glw::GLenum pname, QueriedState& state);
394
395 // verification functions
396
397 void verifyBoolean (tcu::ResultCollector& result, QueriedState& state, bool expected);
398 void verifyInteger (tcu::ResultCollector& result, QueriedState& state, int expected);
399 void verifyIntegerMin (tcu::ResultCollector& result, QueriedState& state, int minValue);
400 void verifyIntegerMax (tcu::ResultCollector& result, QueriedState& state, int maxValue);
401 void verifyIntegersEqual (tcu::ResultCollector& result, QueriedState& stateA, QueriedState& stateB);
402 void verifyFloat (tcu::ResultCollector& result, QueriedState& state, float expected);
403 void verifyFloatMin (tcu::ResultCollector& result, QueriedState& state, float minValue);
404 void verifyFloatMax (tcu::ResultCollector& result, QueriedState& state, float maxValue);
405 void verifyIntegerVec3 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec3& expected);
406 void verifyIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected);
407 void verifyUnsignedIntegerVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::UVec4& expected);
408 void verifyFloatVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::Vec4& expected);
409 void verifyBooleanVec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::BVec4& expected);
410 void verifyPointer (tcu::ResultCollector& result, QueriedState& state, const void* expected);
411 void verifyNormalizedI32Vec4 (tcu::ResultCollector& result, QueriedState& state, const tcu::IVec4& expected);
412
413 // Helper functions that both query and verify
414
415 void verifyStateBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, bool expected, QueryType type);
416 void verifyStateInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int expected, QueryType type);
417 void verifyStateIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int minValue, QueryType type);
418 void verifyStateIntegerMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int maxValue, QueryType type);
419 void verifyStateIntegerEqualToOther (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum other, QueryType type);
420 void verifyStateFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float reference, QueryType type);
421 void verifyStateFloatMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float minValue, QueryType type);
422 void verifyStateFloatMax (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, float maxValue, QueryType type);
423 void verifyStatePointer (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, const void* expected, QueryType type);
424 void verifyStateIndexedBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, bool expected, QueryType type);
425 void verifyStateIndexedBooleanVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, const tcu::BVec4& expected, QueryType type);
426 void verifyStateIndexedInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type);
427 void verifyStateIndexedIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int minValue, QueryType type);
428 void verifyStateAttributeInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int index, int expected, QueryType type);
429 void verifyStateFramebufferInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type);
430 void verifyStateFramebufferIntegerMin (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int minValue, QueryType type);
431 void verifyStateProgramInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, int expected, QueryType type);
432 void verifyStateProgramIntegerVec3 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint program, glw::GLenum pname, const tcu::IVec3& expected, QueryType type);
433 void verifyStatePipelineInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint pipeline, glw::GLenum pname, int expected, QueryType type);
434 void verifyStateTextureParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type);
435 void verifyStateTextureParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, float expected, QueryType type);
436 void verifyStateTextureParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::Vec4& expected, QueryType type);
437 void verifyStateTextureParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type);
438 void verifyStateTextureParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::IVec4& expected, QueryType type);
439 void verifyStateTextureParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, const tcu::UVec4& expected, QueryType type);
440 void verifyStateTextureLevelInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, int level, glw::GLenum pname, int expected, QueryType type);
441 void verifyStateObjectBoolean (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint handle, bool expected, QueryType type);
442 void verifyStateQueryInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLenum target, glw::GLenum pname, int expected, QueryType type);
443 void verifyStateSamplerParamInteger (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, int expected, QueryType type);
444 void verifyStateSamplerParamFloat (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, float expected, QueryType type);
445 void verifyStateSamplerParamFloatVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::Vec4& expected, QueryType type);
446 void verifyStateSamplerParamNormalizedI32Vec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type);
447 void verifyStateSamplerParamIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::IVec4& expected, QueryType type);
448 void verifyStateSamplerParamUnsignedIntegerVec4 (tcu::ResultCollector& result, glu::CallLogWrapper& gl, glw::GLuint sampler, glw::GLenum pname, const tcu::UVec4& expected, QueryType type);
449
450 } // StateQueryUtil
451 } // gls
452 } // deqp
453
454 #endif // _GLSSTATEQUERYUTIL_HPP
455