1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 Module
3 * -------------------------------------------------
5 * Copyright 2014 The Android Open Source Project
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief State Query tests.
22 *//*--------------------------------------------------------------------*/
24 #include "es2fIntegerStateQueryTests.hpp"
25 #include "es2fApiCase.hpp"
27 #include "glsStateQueryUtil.hpp"
29 #include "gluRenderContext.hpp"
30 #include "gluContextInfo.hpp"
31 #include "gluStrUtil.hpp"
33 #include "tcuRenderTarget.hpp"
35 #include "deRandom.hpp"
37 #include "glwEnums.hpp"
39 using namespace glw; // GLint and other GL types
40 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
42 #ifndef GL_SLUMINANCE_NV
43 #define GL_SLUMINANCE_NV 0x8C46
45 #ifndef GL_SLUMINANCE_ALPHA_NV
46 #define GL_SLUMINANCE_ALPHA_NV 0x8C44
49 #define GL_BGR_NV 0x80E0
58 namespace IntegerStateQueryVerifiers
63 class StateVerifier : protected glu::CallLogWrapper
66 StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
67 virtual ~StateVerifier (); // make GCC happy
69 const char* getTestNamePostfix (void) const;
71 virtual void verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference) = DE_NULL;
72 virtual void verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3) = DE_NULL;
73 virtual void verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3) = DE_NULL;
74 virtual void verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference) = DE_NULL;
75 virtual void verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference) = DE_NULL;
76 virtual void verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1) = DE_NULL;
77 virtual void verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength) = DE_NULL;
78 virtual void verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits) = DE_NULL;
81 const char* const m_testNamePostfix;
84 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
85 : glu::CallLogWrapper (gl, log)
86 , m_testNamePostfix (testNamePostfix)
91 StateVerifier::~StateVerifier ()
95 const char* StateVerifier::getTestNamePostfix (void) const
97 return m_testNamePostfix;
100 // GetBooleanVerifier
102 class GetBooleanVerifier : public StateVerifier
105 GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log);
106 void verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference);
107 void verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
108 void verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
109 void verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference);
110 void verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference);
111 void verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
112 void verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
113 void verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits);
116 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
117 : StateVerifier(gl, log, "_getboolean")
121 void GetBooleanVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
125 StateQueryMemoryWriteGuard<GLboolean> state;
126 glGetBooleanv(name, &state);
128 if (!state.verifyValidity(testCtx))
131 const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
133 if (state != expectedGLState)
135 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (expectedGLState==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << "; got " << (state == GL_TRUE ? "GL_TRUE" : (state == GL_FALSE ? "GL_FALSE" : "non-boolean")) << TestLog::EndMessage;
136 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
137 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
141 void GetBooleanVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
143 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
146 void GetBooleanVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
150 StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
151 glGetBooleanv(name, boolVector4);
153 if (!boolVector4.verifyValidity(testCtx))
156 const GLboolean referenceAsGLBoolean[] =
158 reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
159 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
160 reference2 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
161 reference3 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
164 if ((enableRef0 && (boolVector4[0] != referenceAsGLBoolean[0])) ||
165 (enableRef1 && (boolVector4[1] != referenceAsGLBoolean[1])) ||
166 (enableRef2 && (boolVector4[2] != referenceAsGLBoolean[2])) ||
167 (enableRef3 && (boolVector4[3] != referenceAsGLBoolean[3])))
169 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
170 << (enableRef0 ? (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
171 << (enableRef1 ? (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
172 << (enableRef2 ? (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
173 << (enableRef3 ? (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") : " - ") << TestLog::EndMessage;
175 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
176 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
180 void GetBooleanVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
184 StateQueryMemoryWriteGuard<GLboolean> state;
185 glGetBooleanv(name, &state);
187 if (!state.verifyValidity(testCtx))
190 if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
193 if (state == GL_FALSE) // state is zero
195 if (reference > 0) // and reference is greater than zero?
197 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
198 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
199 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
204 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
205 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
206 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
210 void GetBooleanVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
214 StateQueryMemoryWriteGuard<GLboolean> state;
215 glGetBooleanv(name, &state);
217 if (!state.verifyValidity(testCtx))
220 if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
223 if (state == GL_FALSE) // state is zero
225 if (reference > 0) // and reference is greater than zero?
227 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
228 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
229 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
234 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
235 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
236 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
240 void GetBooleanVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
244 StateQueryMemoryWriteGuard<GLboolean[2]> boolVector;
245 glGetBooleanv(name, boolVector);
247 if (!boolVector.verifyValidity(testCtx))
250 const GLboolean referenceAsGLBoolean[2] =
252 reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
253 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE
256 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(referenceAsGLBoolean); ++ndx)
258 if (boolVector[ndx] == GL_TRUE) // state is non-zero, could be greater than any integer
262 else if (boolVector[ndx] == GL_FALSE) // state is zero
264 if (referenceAsGLBoolean[ndx] > 0) // and reference is greater than zero?
266 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
267 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
268 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
273 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
274 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
275 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
280 void GetBooleanVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
284 StateQueryMemoryWriteGuard<GLboolean> state;
285 glGetBooleanv(name, &state);
287 if (!state.verifyValidity(testCtx))
290 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
292 const GLboolean expectedGLState = references[ndx] ? GL_TRUE : GL_FALSE;
294 if (state == expectedGLState)
298 testCtx.getLog() << TestLog::Message << "// ERROR: got " << (state==GL_TRUE ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
299 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
300 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
303 void GetBooleanVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
305 // if stencilBits == 0, the mask is allowed to be either GL_TRUE or GL_FALSE
306 // otherwise it must be GL_TRUE
309 StateQueryMemoryWriteGuard<GLboolean> state;
310 glGetBooleanv(name, &state);
312 if (!state.verifyValidity(testCtx))
315 if (stencilBits > 0 && state != GL_TRUE)
317 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
318 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
319 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
325 class GetIntegerVerifier : public StateVerifier
328 GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log);
329 void verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference);
330 void verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
331 void verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
332 void verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference);
333 void verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference);
334 void verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
335 void verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
336 void verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits);
339 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
340 : StateVerifier(gl, log, "_getinteger")
344 void GetIntegerVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
348 StateQueryMemoryWriteGuard<GLint> state;
349 glGetIntegerv(name, &state);
351 if (!state.verifyValidity(testCtx))
354 if (state != reference)
356 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage;
357 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
358 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
362 void GetIntegerVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
364 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
367 void GetIntegerVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
371 StateQueryMemoryWriteGuard<GLint[4]> intVector4;
372 glGetIntegerv(name, intVector4);
374 if (!intVector4.verifyValidity(testCtx))
377 if ((enableRef0 && (intVector4[0] != reference0)) ||
378 (enableRef1 && (intVector4[1] != reference1)) ||
379 (enableRef2 && (intVector4[2] != reference2)) ||
380 (enableRef3 && (intVector4[3] != reference3)))
382 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
383 << (enableRef0?"":"(") << reference0 << (enableRef0?"":")") << ", "
384 << (enableRef1?"":"(") << reference1 << (enableRef1?"":")") << ", "
385 << (enableRef2?"":"(") << reference2 << (enableRef2?"":")") << ", "
386 << (enableRef3?"":"(") << reference3 << (enableRef3?"":")") << TestLog::EndMessage;
389 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
390 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
394 void GetIntegerVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
398 StateQueryMemoryWriteGuard<GLint> state;
399 glGetIntegerv(name, &state);
401 if (!state.verifyValidity(testCtx))
404 if (state < reference)
406 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << state << TestLog::EndMessage;
407 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
408 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
412 void GetIntegerVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
416 StateQueryMemoryWriteGuard<GLint> state;
417 glGetIntegerv(name, &state);
419 if (!state.verifyValidity(testCtx))
422 if (GLuint(state) < reference)
424 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got " << GLuint(state) << TestLog::EndMessage;
425 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
426 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
430 void GetIntegerVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
434 StateQueryMemoryWriteGuard<GLint[2]> intVector2;
435 glGetIntegerv(name, intVector2);
437 if (!intVector2.verifyValidity(testCtx))
440 if (intVector2[0] < reference0 || intVector2[1] < reference1)
442 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference0 << ", " << reference1 << "; got " << intVector2[0] << ", " << intVector2[0] << TestLog::EndMessage;
443 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
444 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
448 void GetIntegerVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
452 StateQueryMemoryWriteGuard<GLint> state;
453 glGetIntegerv(name, &state);
455 if (!state.verifyValidity(testCtx))
458 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
460 const GLint expectedGLState = references[ndx];
462 if (state == expectedGLState)
466 testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
467 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
468 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
471 void GetIntegerVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
475 StateQueryMemoryWriteGuard<GLint> state;
476 glGetIntegerv(name, &state);
478 if (!state.verifyValidity(testCtx))
481 const GLint reference = (1 << stencilBits) - 1;
483 if ((state & reference) != reference) // the least significant stencilBits bits should be on
485 testCtx.getLog() << TestLog::Message << "// ERROR: expected minimum mask of " << reference << "; got " << state << TestLog::EndMessage;
486 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
487 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
493 class GetFloatVerifier : public StateVerifier
496 GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log);
497 void verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference);
498 void verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3);
499 void verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
500 void verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference);
501 void verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference);
502 void verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1);
503 void verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength);
504 void verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits);
507 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
508 : StateVerifier(gl, log, "_getfloat")
512 void GetFloatVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum name, GLint reference)
516 const GLfloat referenceAsFloat = GLfloat(reference);
517 DE_ASSERT(reference == GLint(referenceAsFloat)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
519 StateQueryMemoryWriteGuard<GLfloat> state;
520 glGetFloatv(name, &state);
522 if (!state.verifyValidity(testCtx))
525 if (state != referenceAsFloat)
527 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state << TestLog::EndMessage;
528 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
529 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
533 void GetFloatVerifier::verifyInteger4 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2, GLint reference3)
535 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
538 void GetFloatVerifier::verifyInteger4Mask (tcu::TestContext& testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1, bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3)
542 StateQueryMemoryWriteGuard<GLfloat[4]> floatVector4;
543 glGetFloatv(name, floatVector4);
545 if (!floatVector4.verifyValidity(testCtx))
548 if ((enableRef0 && (floatVector4[0] != GLfloat(reference0))) ||
549 (enableRef1 && (floatVector4[1] != GLfloat(reference1))) ||
550 (enableRef2 && (floatVector4[2] != GLfloat(reference2))) ||
551 (enableRef3 && (floatVector4[3] != GLfloat(reference3))))
553 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
554 << (enableRef0?"":"(") << GLfloat(reference0) << (enableRef0?"":")") << ", "
555 << (enableRef1?"":"(") << GLfloat(reference1) << (enableRef1?"":")") << ", "
556 << (enableRef2?"":"(") << GLfloat(reference2) << (enableRef2?"":")") << ", "
557 << (enableRef3?"":"(") << GLfloat(reference3) << (enableRef3?"":")") << TestLog::EndMessage;
559 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
560 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
564 void GetFloatVerifier::verifyIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLint reference)
568 StateQueryMemoryWriteGuard<GLfloat> state;
569 glGetFloatv(name, &state);
571 if (!state.verifyValidity(testCtx))
574 if (state < GLfloat(reference))
576 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
577 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
578 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
582 void GetFloatVerifier::verifyUnsignedIntegerGreaterOrEqual (tcu::TestContext& testCtx, GLenum name, GLuint reference)
586 StateQueryMemoryWriteGuard<GLfloat> state;
587 glGetFloatv(name, &state);
589 if (!state.verifyValidity(testCtx))
592 if (state < GLfloat(reference))
594 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference) << "; got " << state << TestLog::EndMessage;
595 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
596 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
600 void GetFloatVerifier::verifyIntegerGreaterOrEqual2 (tcu::TestContext& testCtx, GLenum name, GLint reference0, GLint reference1)
604 StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2;
605 glGetFloatv(name, floatVector2);
607 if (!floatVector2.verifyValidity(testCtx))
610 if (floatVector2[0] < GLfloat(reference0) || floatVector2[1] < GLfloat(reference1))
612 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference0) << ", " << GLfloat(reference1) << "; got " << floatVector2[0] << ", " << floatVector2[1] << TestLog::EndMessage;
613 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
614 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
618 void GetFloatVerifier::verifyIntegerAnyOf (tcu::TestContext& testCtx, GLenum name, const GLint references[], size_t referencesLength)
622 StateQueryMemoryWriteGuard<GLfloat> state;
623 glGetFloatv(name, &state);
625 if (!state.verifyValidity(testCtx))
628 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
630 const GLfloat expectedGLState = GLfloat(references[ndx]);
631 DE_ASSERT(references[ndx] == GLint(expectedGLState)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
633 if (state == expectedGLState)
637 testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
638 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
639 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
642 void GetFloatVerifier::verifyStencilMaskInitial (tcu::TestContext& testCtx, GLenum name, int stencilBits)
644 // checking the mask bits with float doesn't make much sense because of conversion errors
645 // just verify that the value is greater or equal to the minimum value
646 const GLint reference = (1 << stencilBits) - 1;
647 verifyIntegerGreaterOrEqual(testCtx, name, reference);
650 } // IntegerStateQueryVerifiers
655 using namespace IntegerStateQueryVerifiers;
656 using namespace deqp::gls::StateQueryUtil;
658 class ConstantMinimumValueTestCase : public ApiCase
661 ConstantMinimumValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, GLint minValue)
662 : ApiCase (context, name, description)
663 , m_targetName (targetName)
664 , m_minValue (minValue)
665 , m_verifier (verifier)
671 m_verifier->verifyUnsignedIntegerGreaterOrEqual(m_testCtx, m_targetName, m_minValue);
672 expectError(GL_NO_ERROR);
678 StateVerifier* m_verifier;
681 class SampleBuffersTestCase : public ApiCase
684 SampleBuffersTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
685 : ApiCase (context, name, description)
686 , m_verifier (verifier)
692 const int expectedSampleBuffers = (m_context.getRenderTarget().getNumSamples() > 1) ? 1 : 0;
694 m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << ", expecting GL_SAMPLE_BUFFERS to be " << expectedSampleBuffers << tcu::TestLog::EndMessage;
696 m_verifier->verifyInteger(m_testCtx, GL_SAMPLE_BUFFERS, expectedSampleBuffers);
697 expectError(GL_NO_ERROR);
701 StateVerifier* m_verifier;
704 class SamplesTestCase : public ApiCase
707 SamplesTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
708 : ApiCase (context, name, description)
709 , m_verifier (verifier)
716 if (m_context.getRenderTarget().getNumSamples() > 1)
718 m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples()) << tcu::TestLog::EndMessage;
720 m_verifier->verifyInteger(m_testCtx, GL_SAMPLES, m_context.getRenderTarget().getNumSamples());
721 expectError(GL_NO_ERROR);
725 const glw::GLint validSamples[] = {0, 1};
727 m_log << tcu::TestLog::Message << "Expecting GL_SAMPLES to be 0 or 1" << tcu::TestLog::EndMessage;
729 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_SAMPLES, validSamples, DE_LENGTH_OF_ARRAY(validSamples));
730 expectError(GL_NO_ERROR);
735 StateVerifier* m_verifier;
738 class HintTestCase : public ApiCase
741 HintTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName)
742 : ApiCase (context, name, description)
743 , m_targetName (targetName)
744 , m_verifier (verifier)
750 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
751 expectError(GL_NO_ERROR);
753 glHint(m_targetName, GL_NICEST);
754 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_NICEST);
755 expectError(GL_NO_ERROR);
757 glHint(m_targetName, GL_FASTEST);
758 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_FASTEST);
759 expectError(GL_NO_ERROR);
761 glHint(m_targetName, GL_DONT_CARE);
762 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
763 expectError(GL_NO_ERROR);
768 StateVerifier* m_verifier;
771 class DepthFuncTestCase : public ApiCase
774 DepthFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
775 : ApiCase (context, name, description)
776 , m_verifier (verifier)
782 m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, GL_LESS);
783 expectError(GL_NO_ERROR);
785 const GLenum depthFunctions[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GREATER, GL_GEQUAL, GL_NOTEQUAL};
786 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFunctions); ndx++)
788 glDepthFunc(depthFunctions[ndx]);
789 expectError(GL_NO_ERROR);
791 m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, depthFunctions[ndx]);
792 expectError(GL_NO_ERROR);
797 StateVerifier* m_verifier;
800 class CullFaceTestCase : public ApiCase
803 CullFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
804 : ApiCase (context, name, description)
805 , m_verifier (verifier)
811 m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, GL_BACK);
812 expectError(GL_NO_ERROR);
814 const GLenum cullFaces[] = {GL_FRONT, GL_BACK, GL_FRONT_AND_BACK};
815 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cullFaces); ndx++)
817 glCullFace(cullFaces[ndx]);
818 expectError(GL_NO_ERROR);
820 m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, cullFaces[ndx]);
821 expectError(GL_NO_ERROR);
826 StateVerifier* m_verifier;
829 class FrontFaceTestCase : public ApiCase
832 FrontFaceTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
833 : ApiCase (context, name, description)
834 , m_verifier (verifier)
840 m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, GL_CCW);
841 expectError(GL_NO_ERROR);
843 const GLenum frontFaces[] = {GL_CW, GL_CCW};
844 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(frontFaces); ndx++)
846 glFrontFace(frontFaces[ndx]);
847 expectError(GL_NO_ERROR);
849 m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, frontFaces[ndx]);
850 expectError(GL_NO_ERROR);
855 StateVerifier* m_verifier;
858 class ViewPortTestCase : public ApiCase
861 ViewPortTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
862 : ApiCase (context, name, description)
863 , m_verifier (verifier)
869 de::Random rnd(0xabcdef);
871 GLint maxViewportDimensions[2] = {0};
872 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);
874 // verify initial value of first two values
875 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
876 expectError(GL_NO_ERROR);
878 const int numIterations = 120;
879 for (int i = 0; i < numIterations; ++i)
881 GLint x = rnd.getInt(-64000, 64000);
882 GLint y = rnd.getInt(-64000, 64000);
883 GLsizei width = rnd.getInt(0, maxViewportDimensions[0]);
884 GLsizei height = rnd.getInt(0, maxViewportDimensions[1]);
886 glViewport(x, y, width, height);
887 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
888 expectError(GL_NO_ERROR);
893 StateVerifier* m_verifier;
896 class ScissorBoxTestCase : public ApiCase
899 ScissorBoxTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
900 : ApiCase (context, name, description)
901 , m_verifier (verifier)
907 de::Random rnd(0xabcdef);
909 // verify initial value
910 m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, 0, 0, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
911 expectError(GL_NO_ERROR);
913 const int numIterations = 120;
914 for (int i = 0; i < numIterations; ++i)
916 GLint left = rnd.getInt(-64000, 64000);
917 GLint bottom = rnd.getInt(-64000, 64000);
918 GLsizei width = rnd.getInt(0, 64000);
919 GLsizei height = rnd.getInt(0, 64000);
921 glScissor(left, bottom, width, height);
922 m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, left, bottom, width, height);
923 expectError(GL_NO_ERROR);
927 StateVerifier* m_verifier;
930 class MaxViewportDimsTestCase : public ApiCase
933 MaxViewportDimsTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
934 : ApiCase (context, name, description)
935 , m_verifier (verifier)
941 m_verifier->verifyIntegerGreaterOrEqual2(m_testCtx, GL_MAX_VIEWPORT_DIMS, m_context.getRenderTarget().getWidth(), m_context.getRenderTarget().getHeight());
942 expectError(GL_NO_ERROR);
945 StateVerifier* m_verifier;
948 class StencilRefTestCase : public ApiCase
951 StencilRefTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
952 : ApiCase (context, name, description)
953 , m_verifier (verifier)
954 , m_testTargetName (testTargetName)
960 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
961 expectError(GL_NO_ERROR);
963 const int stencilBits = m_context.getRenderTarget().getStencilBits();
965 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
967 const int ref = 1 << stencilBit;
969 glStencilFunc(GL_ALWAYS, ref, 0); // mask should not affect the REF
970 expectError(GL_NO_ERROR);
972 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
973 expectError(GL_NO_ERROR);
975 glStencilFunc(GL_ALWAYS, ref, ref);
976 expectError(GL_NO_ERROR);
978 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
979 expectError(GL_NO_ERROR);
984 StateVerifier* m_verifier;
985 GLenum m_testTargetName;
988 class StencilRefSeparateTestCase : public ApiCase
991 StencilRefSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
992 : ApiCase (context, name, description)
993 , m_verifier (verifier)
994 , m_testTargetName (testTargetName)
995 , m_stencilFuncTargetFace (stencilFuncTargetFace)
1001 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
1002 expectError(GL_NO_ERROR);
1004 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1006 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1008 const int ref = 1 << stencilBit;
1010 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, 0);
1011 expectError(GL_NO_ERROR);
1013 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1014 expectError(GL_NO_ERROR);
1016 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, ref);
1017 expectError(GL_NO_ERROR);
1019 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1020 expectError(GL_NO_ERROR);
1024 StateVerifier* m_verifier;
1025 GLenum m_testTargetName;
1026 GLenum m_stencilFuncTargetFace;
1029 class StencilOpTestCase : public ApiCase
1032 StencilOpTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName)
1033 : ApiCase (context, name, description)
1034 , m_verifier (verifier)
1035 , m_stencilOpName (stencilOpName)
1041 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, GL_KEEP);
1042 expectError(GL_NO_ERROR);
1044 const GLenum stencilOpValues[] = {GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP};
1046 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilOpValues); ++ndx)
1048 SetStencilOp(stencilOpValues[ndx]);
1049 expectError(GL_NO_ERROR);
1051 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, stencilOpValues[ndx]);
1052 expectError(GL_NO_ERROR);
1057 virtual void SetStencilOp (GLenum stencilOpValue)
1059 switch (m_stencilOpName)
1061 case GL_STENCIL_FAIL:
1062 case GL_STENCIL_BACK_FAIL:
1063 glStencilOp(stencilOpValue, GL_KEEP, GL_KEEP);
1066 case GL_STENCIL_PASS_DEPTH_FAIL:
1067 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1068 glStencilOp(GL_KEEP, stencilOpValue, GL_KEEP);
1071 case GL_STENCIL_PASS_DEPTH_PASS:
1072 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1073 glStencilOp(GL_KEEP, GL_KEEP, stencilOpValue);
1077 DE_ASSERT(false && "should not happen");
1082 StateVerifier* m_verifier;
1083 GLenum m_stencilOpName;
1086 class StencilOpSeparateTestCase : public StencilOpTestCase
1089 StencilOpSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilOpName, GLenum stencilOpFace)
1090 : StencilOpTestCase (context, verifier, name, description, stencilOpName)
1091 , m_stencilOpFace (stencilOpFace)
1096 void SetStencilOp (GLenum stencilOpValue)
1098 switch (m_stencilOpName)
1100 case GL_STENCIL_FAIL:
1101 case GL_STENCIL_BACK_FAIL:
1102 glStencilOpSeparate(m_stencilOpFace, stencilOpValue, GL_KEEP, GL_KEEP);
1105 case GL_STENCIL_PASS_DEPTH_FAIL:
1106 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1107 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, stencilOpValue, GL_KEEP);
1110 case GL_STENCIL_PASS_DEPTH_PASS:
1111 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1112 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, GL_KEEP, stencilOpValue);
1116 DE_ASSERT(false && "should not happen");
1121 GLenum m_stencilOpFace;
1124 class StencilFuncTestCase : public ApiCase
1127 StencilFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1128 : ApiCase (context, name, description)
1129 , m_verifier (verifier)
1135 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, GL_ALWAYS);
1136 expectError(GL_NO_ERROR);
1138 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1140 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1142 glStencilFunc(stencilfuncValues[ndx], 0, 0);
1143 expectError(GL_NO_ERROR);
1145 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, stencilfuncValues[ndx]);
1146 expectError(GL_NO_ERROR);
1148 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_BACK_FUNC, stencilfuncValues[ndx]);
1149 expectError(GL_NO_ERROR);
1153 StateVerifier* m_verifier;
1156 class StencilFuncSeparateTestCase : public ApiCase
1159 StencilFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum stencilFuncName, GLenum stencilFuncFace)
1160 : ApiCase (context, name, description)
1161 , m_verifier (verifier)
1162 , m_stencilFuncName (stencilFuncName)
1163 , m_stencilFuncFace (stencilFuncFace)
1169 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, GL_ALWAYS);
1170 expectError(GL_NO_ERROR);
1172 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL, GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1174 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1176 glStencilFuncSeparate(m_stencilFuncFace, stencilfuncValues[ndx], 0, 0);
1177 expectError(GL_NO_ERROR);
1179 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, stencilfuncValues[ndx]);
1180 expectError(GL_NO_ERROR);
1184 StateVerifier* m_verifier;
1185 GLenum m_stencilFuncName;
1186 GLenum m_stencilFuncFace;
1189 class StencilMaskTestCase : public ApiCase
1192 StencilMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1193 : ApiCase (context, name, description)
1194 , m_verifier (verifier)
1195 , m_testTargetName (testTargetName)
1201 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1203 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1204 expectError(GL_NO_ERROR);
1206 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1208 const int mask = 1 << stencilBit;
1210 glStencilFunc(GL_ALWAYS, 0, mask);
1211 expectError(GL_NO_ERROR);
1213 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1214 expectError(GL_NO_ERROR);
1218 StateVerifier* m_verifier;
1219 GLenum m_testTargetName;
1222 class StencilMaskSeparateTestCase : public ApiCase
1225 StencilMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilFuncTargetFace)
1226 : ApiCase (context, name, description)
1227 , m_verifier (verifier)
1228 , m_testTargetName (testTargetName)
1229 , m_stencilFuncTargetFace (stencilFuncTargetFace)
1235 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1237 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1238 expectError(GL_NO_ERROR);
1240 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1242 const int mask = 1 << stencilBit;
1244 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, 0, mask);
1245 expectError(GL_NO_ERROR);
1247 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1248 expectError(GL_NO_ERROR);
1252 StateVerifier* m_verifier;
1253 GLenum m_testTargetName;
1254 GLenum m_stencilFuncTargetFace;
1257 class StencilWriteMaskTestCase : public ApiCase
1260 StencilWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1261 : ApiCase (context, name, description)
1262 , m_verifier (verifier)
1263 , m_testTargetName (testTargetName)
1269 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1271 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1273 const int mask = 1 << stencilBit;
1275 glStencilMask(mask);
1276 expectError(GL_NO_ERROR);
1278 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1279 expectError(GL_NO_ERROR);
1283 StateVerifier* m_verifier;
1284 GLenum m_testTargetName;
1287 class StencilWriteMaskSeparateTestCase : public ApiCase
1290 StencilWriteMaskSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum stencilTargetFace)
1291 : ApiCase (context, name, description)
1292 , m_verifier (verifier)
1293 , m_testTargetName (testTargetName)
1294 , m_stencilTargetFace (stencilTargetFace)
1300 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1302 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1304 const int mask = 1 << stencilBit;
1306 glStencilMaskSeparate(m_stencilTargetFace, mask);
1307 expectError(GL_NO_ERROR);
1309 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1310 expectError(GL_NO_ERROR);
1314 StateVerifier* m_verifier;
1315 GLenum m_testTargetName;
1316 GLenum m_stencilTargetFace;
1319 class PixelStoreAlignTestCase : public ApiCase
1322 PixelStoreAlignTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName)
1323 : ApiCase (context, name, description)
1324 , m_verifier (verifier)
1325 , m_testTargetName (testTargetName)
1331 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 4);
1332 expectError(GL_NO_ERROR);
1334 const int alignments[] = {1, 2, 4, 8};
1336 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(alignments); ++ndx)
1338 const int referenceValue = alignments[ndx];
1340 glPixelStorei(m_testTargetName, referenceValue);
1341 expectError(GL_NO_ERROR);
1343 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1344 expectError(GL_NO_ERROR);
1349 StateVerifier* m_verifier;
1350 GLenum m_testTargetName;
1353 class BlendFuncTestCase : public ApiCase
1356 BlendFuncTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1357 : ApiCase (context, name, description)
1358 , m_verifier (verifier)
1359 , m_testTargetName (testTargetName)
1360 , m_initialValue (initialValue)
1366 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1367 expectError(GL_NO_ERROR);
1369 const GLenum blendFuncValues[] =
1371 GL_ZERO, GL_ONE, GL_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR,
1372 GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_CONSTANT_COLOR,
1373 GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA,
1374 GL_SRC_ALPHA_SATURATE
1377 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1379 const GLenum referenceValue = blendFuncValues[ndx];
1381 //GL_SRC_ALPHA_SATURATE is ony allowed for srcRGB or srcA
1382 if (referenceValue == GL_SRC_ALPHA_SATURATE &&
1383 !(m_testTargetName == GL_BLEND_SRC_RGB || m_testTargetName == GL_BLEND_SRC_ALPHA))
1386 SetBlendFunc(referenceValue);
1387 expectError(GL_NO_ERROR);
1389 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1390 expectError(GL_NO_ERROR);
1394 virtual void SetBlendFunc (GLenum func)
1396 switch (m_testTargetName)
1398 case GL_BLEND_SRC_RGB:
1399 case GL_BLEND_SRC_ALPHA:
1400 glBlendFunc(func, GL_ZERO);
1403 case GL_BLEND_DST_RGB:
1404 case GL_BLEND_DST_ALPHA:
1405 glBlendFunc(GL_ZERO, func);
1409 DE_ASSERT(false && "should not happen");
1414 StateVerifier* m_verifier;
1415 GLenum m_testTargetName;
1419 class BlendFuncSeparateTestCase : public BlendFuncTestCase
1422 BlendFuncSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1423 : BlendFuncTestCase (context, verifier, name, description, testTargetName, initialValue)
1427 void SetBlendFunc (GLenum func)
1429 switch (m_testTargetName)
1431 case GL_BLEND_SRC_RGB:
1432 glBlendFuncSeparate(func, GL_ZERO, GL_ZERO, GL_ZERO);
1435 case GL_BLEND_DST_RGB:
1436 glBlendFuncSeparate(GL_ZERO, func, GL_ZERO, GL_ZERO);
1439 case GL_BLEND_SRC_ALPHA:
1440 glBlendFuncSeparate(GL_ZERO, GL_ZERO, func, GL_ZERO);
1443 case GL_BLEND_DST_ALPHA:
1444 glBlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, func);
1448 DE_ASSERT(false && "should not happen");
1454 class BlendEquationTestCase : public ApiCase
1457 BlendEquationTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1458 : ApiCase (context, name, description)
1459 , m_verifier (verifier)
1460 , m_testTargetName (testTargetName)
1461 , m_initialValue (initialValue)
1467 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1468 expectError(GL_NO_ERROR);
1470 const GLenum blendFuncValues[] =
1472 GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT
1475 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1477 const GLenum referenceValue = blendFuncValues[ndx];
1479 SetBlendEquation(referenceValue);
1480 expectError(GL_NO_ERROR);
1482 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1483 expectError(GL_NO_ERROR);
1487 virtual void SetBlendEquation (GLenum equation)
1489 glBlendEquation(equation);
1492 StateVerifier* m_verifier;
1493 GLenum m_testTargetName;
1497 class BlendEquationSeparateTestCase : public BlendEquationTestCase
1500 BlendEquationSeparateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, int initialValue)
1501 : BlendEquationTestCase (context, verifier, name, description, testTargetName, initialValue)
1506 void SetBlendEquation (GLenum equation)
1508 switch (m_testTargetName)
1510 case GL_BLEND_EQUATION_RGB:
1511 glBlendEquationSeparate(equation, GL_FUNC_ADD);
1514 case GL_BLEND_EQUATION_ALPHA:
1515 glBlendEquationSeparate(GL_FUNC_ADD, equation);
1519 DE_ASSERT(false && "should not happen");
1525 class ImplementationArrayTestCase : public ApiCase
1528 ImplementationArrayTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum testTargetName, GLenum testTargetLengthTargetName, int minValue)
1529 : ApiCase (context, name, description)
1530 , m_verifier (verifier)
1531 , m_testTargetName (testTargetName)
1532 , m_testTargetLengthTargetName (testTargetLengthTargetName)
1533 , m_minValue (minValue)
1539 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, m_testTargetLengthTargetName, m_minValue);
1540 expectError(GL_NO_ERROR);
1542 GLint targetArrayLength = 0;
1543 glGetIntegerv(m_testTargetLengthTargetName, &targetArrayLength);
1544 expectError(GL_NO_ERROR);
1546 if (targetArrayLength)
1548 std::vector<GLint> queryResult;
1549 queryResult.resize(targetArrayLength, 0);
1551 glGetIntegerv(m_testTargetName, &queryResult[0]);
1552 expectError(GL_NO_ERROR);
1557 StateVerifier* m_verifier;
1558 GLenum m_testTargetName;
1559 GLenum m_testTargetLengthTargetName;
1563 class BindingTest : public TestCase
1566 BindingTest (Context& context,
1571 IterateResult iterate (void);
1573 virtual void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const = 0;
1576 const QueryType m_type;
1579 BindingTest::BindingTest (Context& context,
1583 : TestCase (context, name, desc)
1588 BindingTest::IterateResult BindingTest::iterate (void)
1590 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
1591 tcu::ResultCollector result (m_context.getTestContext().getLog(), " // ERROR: ");
1593 gl.enableLogging(true);
1597 result.setTestContextResult(m_testCtx);
1601 class CurrentProgramBindingTestCase : public BindingTest
1604 CurrentProgramBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
1605 : BindingTest(context, name, description, type)
1609 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1611 static const char* testVertSource =
1612 "void main (void)\n"
1614 " gl_Position = vec4(0.0);\n"
1616 static const char* testFragSource =
1617 "void main (void)\n"
1619 " gl_FragColor = vec4(0.0);\n"
1625 GLint compileStatus;
1629 const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial");
1631 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
1634 const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader");
1636 shaderVert = gl.glCreateShader(GL_VERTEX_SHADER);
1637 gl.glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
1638 gl.glCompileShader(shaderVert);
1639 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
1641 gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
1642 if (compileStatus != GL_TRUE)
1643 result.fail("expected GL_TRUE");
1646 const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader");
1648 shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER);
1649 gl.glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);
1650 gl.glCompileShader(shaderFrag);
1651 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
1653 gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
1654 if (compileStatus != GL_TRUE)
1655 result.fail("expected GL_TRUE");
1658 const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program");
1660 shaderProg = gl.glCreateProgram();
1661 gl.glAttachShader(shaderProg, shaderVert);
1662 gl.glAttachShader(shaderProg, shaderFrag);
1663 gl.glLinkProgram(shaderProg);
1664 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram");
1666 gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
1667 if (linkStatus != GL_TRUE)
1668 result.fail("expected GL_TRUE");
1670 gl.glUseProgram(shaderProg);
1671 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
1673 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
1676 const tcu::ScopedLogSection section(gl.getLog(), "Delete", "Delete program while in use");
1678 gl.glDeleteShader(shaderVert);
1679 gl.glDeleteShader(shaderFrag);
1680 gl.glDeleteProgram(shaderProg);
1681 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram");
1683 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
1686 const tcu::ScopedLogSection section(gl.getLog(), "Unbind", "Unbind program");
1688 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
1690 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
1695 class BufferBindingTestCase : public BindingTest
1698 BufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum bufferBindingName, GLenum bufferType)
1699 : BindingTest (context, name, description, type)
1700 , m_bufferBindingName (bufferBindingName)
1701 , m_bufferType (bufferType)
1705 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1707 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
1709 GLuint bufferObject = 0;
1710 gl.glGenBuffers(1, &bufferObject);
1711 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
1713 gl.glBindBuffer(m_bufferType, bufferObject);
1714 verifyStateInteger(result, gl, m_bufferBindingName, bufferObject, m_type);
1716 gl.glDeleteBuffers(1, &bufferObject);
1717 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteBuffers");
1719 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
1723 const GLenum m_bufferBindingName;
1724 const GLenum m_bufferType;
1727 class StencilClearValueTestCase : public ApiCase
1730 StencilClearValueTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1731 : ApiCase (context, name, description)
1732 , m_verifier (verifier)
1738 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, 0);
1739 expectError(GL_NO_ERROR);
1741 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1743 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1745 const int ref = 1 << stencilBit;
1747 glClearStencil(ref);
1748 expectError(GL_NO_ERROR);
1750 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, ref);
1751 expectError(GL_NO_ERROR);
1756 StateVerifier* m_verifier;
1759 class ActiveTextureTestCase : public ApiCase
1762 ActiveTextureTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1763 : ApiCase (context, name, description)
1764 , m_verifier (verifier)
1770 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0);
1771 expectError(GL_NO_ERROR);
1773 GLint textureUnits = 0;
1774 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &textureUnits);
1775 expectError(GL_NO_ERROR);
1777 for (int ndx = 0; ndx < textureUnits; ++ndx)
1779 glActiveTexture(GL_TEXTURE0 + ndx);
1780 expectError(GL_NO_ERROR);
1782 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0 + ndx);
1783 expectError(GL_NO_ERROR);
1788 StateVerifier* m_verifier;
1791 class RenderbufferBindingTestCase : public BindingTest
1794 RenderbufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
1795 : BindingTest(context, name, description, type)
1799 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1801 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
1803 GLuint renderBuffer = 0;
1804 gl.glGenRenderbuffers(1, &renderBuffer);
1805 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenRenderbuffers");
1807 gl.glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);
1808 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindRenderbuffer");
1810 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, renderBuffer, m_type);
1812 gl.glDeleteRenderbuffers(1, &renderBuffer);
1813 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteRenderbuffers");
1815 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
1819 class TextureBindingTestCase : public BindingTest
1822 TextureBindingTestCase (Context& context, QueryType type, const char* name, const char* description, GLenum testBindingName, GLenum textureType)
1823 : BindingTest (context, name, description, type)
1824 , m_testBindingName (testBindingName)
1825 , m_textureType (textureType)
1829 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1831 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
1834 gl.glGenTextures(1, &texture);
1835 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTextures");
1837 gl.glBindTexture(m_textureType, texture);
1838 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
1840 verifyStateInteger(result, gl, m_testBindingName, texture, m_type);
1842 gl.glDeleteTextures(1, &texture);
1843 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
1845 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
1848 const GLenum m_testBindingName;
1849 const GLenum m_textureType;
1852 class FrameBufferBindingTestCase : public BindingTest
1855 FrameBufferBindingTestCase (Context& context, QueryType type, const char* name, const char* description)
1856 : BindingTest(context, name, description, type)
1860 void test (glu::CallLogWrapper& gl, tcu::ResultCollector& result) const
1862 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
1864 GLuint framebufferId = 0;
1865 gl.glGenFramebuffers(1, &framebufferId);
1866 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenFramebuffers");
1868 gl.glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
1869 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindFramebuffer");
1871 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, framebufferId, m_type);
1873 gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
1874 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindFramebuffer");
1876 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
1878 gl.glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
1879 gl.glDeleteFramebuffers(1, &framebufferId);
1880 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteFramebuffers");
1882 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
1886 class ImplementationColorReadTestCase : public ApiCase
1889 ImplementationColorReadTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1890 : ApiCase (context, name, description)
1891 , m_verifier (verifier)
1897 const GLint defaultColorTypes[] =
1899 GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_5_6_5
1901 const GLint defaultColorFormats[] =
1903 GL_RGBA, GL_RGB, GL_ALPHA
1906 std::vector<GLint> validColorTypes;
1907 std::vector<GLint> validColorFormats;
1909 // Defined by the spec
1911 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorTypes); ++ndx)
1912 validColorTypes.push_back(defaultColorTypes[ndx]);
1913 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorFormats); ++ndx)
1914 validColorFormats.push_back(defaultColorFormats[ndx]);
1918 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888") ||
1919 m_context.getContextInfo().isExtensionSupported("GL_APPLE_texture_format_BGRA8888"))
1920 validColorFormats.push_back(GL_BGRA);
1922 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_read_format_bgra"))
1924 validColorFormats.push_back(GL_BGRA);
1925 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
1926 validColorTypes.push_back(GL_UNSIGNED_SHORT_1_5_5_5_REV);
1929 if (m_context.getContextInfo().isExtensionSupported("GL_IMG_read_format"))
1931 validColorFormats.push_back(GL_BGRA);
1932 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
1935 if (m_context.getContextInfo().isExtensionSupported("GL_NV_sRGB_formats"))
1937 validColorFormats.push_back(GL_SLUMINANCE_NV);
1938 validColorFormats.push_back(GL_SLUMINANCE_ALPHA_NV);
1941 if (m_context.getContextInfo().isExtensionSupported("GL_NV_bgr"))
1943 validColorFormats.push_back(GL_BGR_NV);
1946 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_rg"))
1948 validColorFormats.push_back(GL_RED);
1949 validColorFormats.push_back(GL_RG);
1952 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_TYPE, &validColorTypes[0], validColorTypes.size());
1953 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_FORMAT, &validColorFormats[0], validColorFormats.size());
1954 expectError(GL_NO_ERROR);
1958 StateVerifier* m_verifier;
1961 class BufferComponentSizeCase : public ApiCase
1964 BufferComponentSizeCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
1965 : ApiCase (context, name, description)
1966 , m_verifier (verifier)
1972 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_RED_BITS, m_context.getRenderTarget().getPixelFormat().redBits);
1973 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_BLUE_BITS, m_context.getRenderTarget().getPixelFormat().blueBits);
1974 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_GREEN_BITS, m_context.getRenderTarget().getPixelFormat().greenBits);
1975 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_ALPHA_BITS, m_context.getRenderTarget().getPixelFormat().alphaBits);
1976 expectError(GL_NO_ERROR);
1978 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_DEPTH_BITS, m_context.getRenderTarget().getDepthBits());
1979 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, GL_STENCIL_BITS, m_context.getRenderTarget().getStencilBits());
1980 expectError(GL_NO_ERROR);
1983 StateVerifier* m_verifier;
1986 static const char* getQueryTypeSuffix (QueryType type)
1990 case QUERY_BOOLEAN: return "_getboolean";
1991 case QUERY_INTEGER: return "_getinteger";
1992 case QUERY_FLOAT: return "_getfloat";
1994 DE_ASSERT(DE_FALSE);
1999 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
2000 for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
2002 StateVerifier* verifier = (VERIFIERS)[_verifierNdx]; \
2006 #define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
2007 for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
2009 const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
2015 IntegerStateQueryTests::IntegerStateQueryTests (Context& context)
2016 : TestCaseGroup (context, "integers", "Integer Values")
2017 , m_verifierBoolean (DE_NULL)
2018 , m_verifierInteger (DE_NULL)
2019 , m_verifierFloat (DE_NULL)
2023 IntegerStateQueryTests::~IntegerStateQueryTests (void)
2028 void IntegerStateQueryTests::init (void)
2030 static const QueryType queryTypes[] =
2037 DE_ASSERT(m_verifierBoolean == DE_NULL);
2038 DE_ASSERT(m_verifierInteger == DE_NULL);
2039 DE_ASSERT(m_verifierFloat == DE_NULL);
2041 m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2042 m_verifierInteger = new GetIntegerVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2043 m_verifierFloat = new GetFloatVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2045 const struct LimitedStateInteger
2048 const char* description;
2051 } implementationMinLimits[] =
2053 { "subpixel_bits", "SUBPIXEL_BITS has a minimum value of 4", GL_SUBPIXEL_BITS, 4 },
2054 { "max_texture_size", "MAX_TEXTURE_SIZE has a minimum value of 64", GL_MAX_TEXTURE_SIZE, 64 },
2055 { "max_cube_map_texture_size", "MAX_CUBE_MAP_TEXTURE_SIZE has a minimum value of 16", GL_MAX_CUBE_MAP_TEXTURE_SIZE, 16 },
2056 { "max_vertex_attribs", "MAX_VERTEX_ATTRIBS has a minimum value of 8", GL_MAX_VERTEX_ATTRIBS, 8 },
2057 { "max_vertex_uniform_vectors", "MAX_VERTEX_UNIFORM_VECTORS has a minimum value of 128", GL_MAX_VERTEX_UNIFORM_VECTORS, 128 },
2058 { "max_varying_vectors", "MAX_VARYING_VECTORS has a minimum value of 8", GL_MAX_VARYING_VECTORS, 8 },
2059 { "max_combined_texture_image_units", "MAX_COMBINED_TEXTURE_IMAGE_UNITS has a minimum value of 8", GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, 8 },
2060 { "max_vertex_texture_image_units", "MAX_VERTEX_TEXTURE_IMAGE_UNITS has a minimum value of 0", GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 0 },
2061 { "max_texture_image_units", "MAX_TEXTURE_IMAGE_UNITS has a minimum value of 8", GL_MAX_TEXTURE_IMAGE_UNITS, 8 },
2062 { "max_fragment_uniform_vectors", "MAX_FRAGMENT_UNIFORM_VECTORS has a minimum value of 16", GL_MAX_FRAGMENT_UNIFORM_VECTORS, 16 },
2063 { "max_renderbuffer_size", "MAX_RENDERBUFFER_SIZE has a minimum value of 1", GL_MAX_RENDERBUFFER_SIZE, 1 },
2066 // \note implementation defined limits have their own tests so just check the conversions to boolean and float
2067 StateVerifier* implementationLimitVerifiers[] = {m_verifierBoolean, m_verifierFloat};
2068 StateVerifier* normalVerifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierFloat};
2070 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMinLimits); testNdx++)
2071 FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new ConstantMinimumValueTestCase(m_context, verifier, (std::string(implementationMinLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(), implementationMinLimits[testNdx].description, implementationMinLimits[testNdx].targetName, implementationMinLimits[testNdx].value)));
2073 FOR_EACH_VERIFIER(implementationLimitVerifiers, addChild(new SampleBuffersTestCase (m_context, verifier, (std::string("sample_buffers") + verifier->getTestNamePostfix()).c_str(), "SAMPLE_BUFFERS")));
2075 FOR_EACH_VERIFIER(normalVerifiers, addChild(new SamplesTestCase (m_context, verifier, (std::string("samples") + verifier->getTestNamePostfix()).c_str(), "SAMPLES")));
2076 FOR_EACH_VERIFIER(normalVerifiers, addChild(new HintTestCase (m_context, verifier, (std::string("generate_mipmap_hint") + verifier->getTestNamePostfix()).c_str(), "GENERATE_MIPMAP_HINT", GL_GENERATE_MIPMAP_HINT)));
2077 FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthFuncTestCase (m_context, verifier, (std::string("depth_func") + verifier->getTestNamePostfix()).c_str(), "DEPTH_FUNC")));
2078 FOR_EACH_VERIFIER(normalVerifiers, addChild(new CullFaceTestCase (m_context, verifier, (std::string("cull_face_mode") + verifier->getTestNamePostfix()).c_str(), "CULL_FACE_MODE")));
2079 FOR_EACH_VERIFIER(normalVerifiers, addChild(new FrontFaceTestCase (m_context, verifier, (std::string("front_face_mode") + verifier->getTestNamePostfix()).c_str(), "FRONT_FACE")));
2080 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ViewPortTestCase (m_context, verifier, (std::string("viewport") + verifier->getTestNamePostfix()).c_str(), "VIEWPORT")));
2081 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ScissorBoxTestCase (m_context, verifier, (std::string("scissor_box") + verifier->getTestNamePostfix()).c_str(), "SCISSOR_BOX")));
2082 FOR_EACH_VERIFIER(normalVerifiers, addChild(new MaxViewportDimsTestCase (m_context, verifier, (std::string("max_viewport_dims") + verifier->getTestNamePostfix()).c_str(), "MAX_VIEWPORT_DIMS")));
2083 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BufferComponentSizeCase (m_context, verifier, (std::string("buffer_component_size") + verifier->getTestNamePostfix()).c_str(), "x BITS")));
2084 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase (m_context, verifier, (std::string("stencil_ref") + verifier->getTestNamePostfix()).c_str(), "STENCIL_REF", GL_STENCIL_REF)));
2085 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase (m_context, verifier, (std::string("stencil_back_ref") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_REF", GL_STENCIL_BACK_REF)));
2086 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase (m_context, verifier, (std::string("stencil_ref_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_REF (separate)", GL_STENCIL_REF, GL_FRONT)));
2087 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase (m_context, verifier, (std::string("stencil_ref_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_REF (separate)", GL_STENCIL_REF, GL_FRONT_AND_BACK)));
2088 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase (m_context, verifier, (std::string("stencil_back_ref_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_REF (separate)", GL_STENCIL_BACK_REF, GL_BACK)));
2089 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefSeparateTestCase (m_context, verifier, (std::string("stencil_back_ref_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_REF (separate)", GL_STENCIL_BACK_REF, GL_FRONT_AND_BACK)));
2091 const struct NamedStencilOp
2095 const char* frontDescription;
2097 const char* backDescription;
2101 { "fail", "STENCIL_FAIL", GL_STENCIL_FAIL, "STENCIL_BACK_FAIL", GL_STENCIL_BACK_FAIL },
2102 { "depth_fail", "STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL, "STENCIL_BACK_PASS_DEPTH_FAIL", GL_STENCIL_BACK_PASS_DEPTH_FAIL },
2103 { "depth_pass", "STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS, "STENCIL_BACK_PASS_DEPTH_PASS", GL_STENCIL_BACK_PASS_DEPTH_PASS }
2106 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(stencilOps); testNdx++)
2108 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase (m_context, verifier, (std::string("stencil_") + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget)));
2109 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpTestCase (m_context, verifier, (std::string("stencil_back_") + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget)));
2111 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase (m_context, verifier, (std::string("stencil_") + stencilOps[testNdx].name + "_separate_both" + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget, GL_FRONT_AND_BACK)));
2112 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase (m_context, verifier, (std::string("stencil_back_") + stencilOps[testNdx].name + "_separate_both" + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget, GL_FRONT_AND_BACK)));
2114 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase (m_context, verifier, (std::string("stencil_") + stencilOps[testNdx].name + "_separate" + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget, GL_FRONT)));
2115 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilOpSeparateTestCase (m_context, verifier, (std::string("stencil_back_") + stencilOps[testNdx].name + "_separate" + verifier->getTestNamePostfix()).c_str(), stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget, GL_BACK)));
2118 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncTestCase (m_context, verifier, (std::string("stencil_func") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC")));
2119 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase (m_context, verifier, (std::string("stencil_func_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC (separate)", GL_STENCIL_FUNC, GL_FRONT)));
2120 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase (m_context, verifier, (std::string("stencil_func_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC (separate)", GL_STENCIL_FUNC, GL_FRONT_AND_BACK)));
2121 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase (m_context, verifier, (std::string("stencil_back_func_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC (separate)", GL_STENCIL_BACK_FUNC, GL_BACK)));
2122 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilFuncSeparateTestCase (m_context, verifier, (std::string("stencil_back_func_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_FUNC (separate)", GL_STENCIL_BACK_FUNC, GL_FRONT_AND_BACK)));
2123 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase (m_context, verifier, (std::string("stencil_value_mask") + verifier->getTestNamePostfix()).c_str(), "STENCIL_VALUE_MASK", GL_STENCIL_VALUE_MASK)));
2124 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase (m_context, verifier, (std::string("stencil_back_value_mask") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_VALUE_MASK", GL_STENCIL_BACK_VALUE_MASK)));
2125 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase (m_context, verifier, (std::string("stencil_value_mask_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_VALUE_MASK (separate)", GL_STENCIL_VALUE_MASK, GL_FRONT)));
2126 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase (m_context, verifier, (std::string("stencil_value_mask_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_VALUE_MASK (separate)", GL_STENCIL_VALUE_MASK, GL_FRONT_AND_BACK)));
2127 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase (m_context, verifier, (std::string("stencil_back_value_mask_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_VALUE_MASK (separate)", GL_STENCIL_BACK_VALUE_MASK, GL_BACK)));
2128 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskSeparateTestCase (m_context, verifier, (std::string("stencil_back_value_mask_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_VALUE_MASK (separate)", GL_STENCIL_BACK_VALUE_MASK, GL_FRONT_AND_BACK)));
2129 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase (m_context, verifier, (std::string("stencil_writemask") + verifier->getTestNamePostfix()).c_str(), "STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK)));
2130 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase (m_context, verifier, (std::string("stencil_back_writemask") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_WRITEMASK", GL_STENCIL_BACK_WRITEMASK)));
2131 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase (m_context, verifier, (std::string("stencil_writemask_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_WRITEMASK (separate)", GL_STENCIL_WRITEMASK, GL_FRONT)));
2132 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase (m_context, verifier, (std::string("stencil_writemask_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_WRITEMASK (separate)", GL_STENCIL_WRITEMASK, GL_FRONT_AND_BACK)));
2133 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase (m_context, verifier, (std::string("stencil_back_writemask_separate") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_WRITEMASK (separate)", GL_STENCIL_BACK_WRITEMASK, GL_BACK)));
2134 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskSeparateTestCase (m_context, verifier, (std::string("stencil_back_writemask_separate_both") + verifier->getTestNamePostfix()).c_str(), "STENCIL_BACK_WRITEMASK (separate)", GL_STENCIL_BACK_WRITEMASK, GL_FRONT_AND_BACK)));
2136 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("unpack_alignment") + verifier->getTestNamePostfix()).c_str(), "UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT)));
2137 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(m_context, verifier, (std::string("pack_alignment") + verifier->getTestNamePostfix()).c_str(), "PACK_ALIGNMENT", GL_PACK_ALIGNMENT)));
2140 const struct BlendColorState
2143 const char* description;
2146 } blendColorStates[] =
2148 { "blend_src_rgb", "BLEND_SRC_RGB", GL_BLEND_SRC_RGB, GL_ONE },
2149 { "blend_src_alpha", "BLEND_SRC_ALPHA", GL_BLEND_SRC_ALPHA, GL_ONE },
2150 { "blend_dst_rgb", "BLEND_DST_RGB", GL_BLEND_DST_RGB, GL_ZERO },
2151 { "blend_dst_alpha", "BLEND_DST_ALPHA", GL_BLEND_DST_ALPHA, GL_ZERO }
2153 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendColorStates); testNdx++)
2155 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncTestCase (m_context, verifier, (std::string(blendColorStates[testNdx].name) + verifier->getTestNamePostfix()).c_str(), blendColorStates[testNdx].description, blendColorStates[testNdx].target, blendColorStates[testNdx].initialValue)));
2156 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendFuncSeparateTestCase (m_context, verifier, (std::string(blendColorStates[testNdx].name) + "_separate" + verifier->getTestNamePostfix()).c_str(), blendColorStates[testNdx].description, blendColorStates[testNdx].target, blendColorStates[testNdx].initialValue)));
2161 const struct BlendEquationState
2164 const char* description;
2167 } blendEquationStates[] =
2169 { "blend_equation_rgb", "BLEND_EQUATION_RGB", GL_BLEND_EQUATION_RGB, GL_FUNC_ADD },
2170 { "blend_equation_alpha", "BLEND_EQUATION_ALPHA", GL_BLEND_EQUATION_ALPHA, GL_FUNC_ADD }
2172 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendEquationStates); testNdx++)
2174 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationTestCase (m_context, verifier, (std::string(blendEquationStates[testNdx].name) + + verifier->getTestNamePostfix()).c_str(), blendEquationStates[testNdx].description, blendEquationStates[testNdx].target, blendEquationStates[testNdx].initialValue)));
2175 FOR_EACH_VERIFIER(normalVerifiers, addChild(new BlendEquationSeparateTestCase (m_context, verifier, (std::string(blendEquationStates[testNdx].name) + "_separate" + verifier->getTestNamePostfix()).c_str(), blendEquationStates[testNdx].description, blendEquationStates[testNdx].target, blendEquationStates[testNdx].initialValue)));
2179 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase (m_context, verifier, (std::string("compressed_texture_formats") + verifier->getTestNamePostfix()).c_str(), "COMPRESSED_TEXTURE_FORMATS", GL_COMPRESSED_TEXTURE_FORMATS, GL_NUM_COMPRESSED_TEXTURE_FORMATS, 0)));
2180 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase (m_context, verifier, (std::string("shader_binary_formats") + verifier->getTestNamePostfix()).c_str(), "SHADER_BINARY_FORMATS", GL_SHADER_BINARY_FORMATS, GL_NUM_SHADER_BINARY_FORMATS, 0)));
2182 FOR_EACH_QUERYTYPE(queryTypes, addChild(new BufferBindingTestCase (m_context, queryType, (std::string("array_buffer_binding") + getQueryTypeSuffix(queryType)).c_str(), "ARRAY_BUFFER_BINDING", GL_ARRAY_BUFFER_BINDING, GL_ARRAY_BUFFER)));
2183 FOR_EACH_QUERYTYPE(queryTypes, addChild(new BufferBindingTestCase (m_context, queryType, (std::string("element_array_buffer_binding") + getQueryTypeSuffix(queryType)).c_str(), "ELEMENT_ARRAY_BUFFER_BINDING", GL_ELEMENT_ARRAY_BUFFER_BINDING, GL_ELEMENT_ARRAY_BUFFER)));
2185 FOR_EACH_QUERYTYPE(queryTypes, addChild(new CurrentProgramBindingTestCase (m_context, queryType, (std::string("current_program_binding") + getQueryTypeSuffix(queryType)).c_str(), "CURRENT_PROGRAM")));
2186 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilClearValueTestCase (m_context, verifier, (std::string("stencil_clear_value") + verifier->getTestNamePostfix()).c_str(), "STENCIL_CLEAR_VALUE")));
2187 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ActiveTextureTestCase (m_context, verifier, (std::string("active_texture") + verifier->getTestNamePostfix()).c_str(), "ACTIVE_TEXTURE")));
2188 FOR_EACH_QUERYTYPE(queryTypes, addChild(new RenderbufferBindingTestCase (m_context, queryType, (std::string("renderbuffer_binding") + getQueryTypeSuffix(queryType)).c_str(), "RENDERBUFFER_BINDING")));
2190 FOR_EACH_QUERYTYPE(queryTypes, addChild(new TextureBindingTestCase (m_context, queryType, (std::string("texture_binding_2d") + getQueryTypeSuffix(queryType)).c_str(), "TEXTURE_BINDING_2D", GL_TEXTURE_BINDING_2D, GL_TEXTURE_2D)));
2191 FOR_EACH_QUERYTYPE(queryTypes, addChild(new TextureBindingTestCase (m_context, queryType, (std::string("texture_binding_cube_map") + getQueryTypeSuffix(queryType)).c_str(), "TEXTURE_BINDING_CUBE_MAP", GL_TEXTURE_BINDING_CUBE_MAP, GL_TEXTURE_CUBE_MAP)));
2193 FOR_EACH_QUERYTYPE(queryTypes, addChild(new FrameBufferBindingTestCase (m_context, queryType, (std::string("framebuffer_binding") + getQueryTypeSuffix(queryType)).c_str(), "DRAW_FRAMEBUFFER_BINDING and READ_FRAMEBUFFER_BINDING")));
2194 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationColorReadTestCase (m_context, verifier, (std::string("implementation_color_read") + verifier->getTestNamePostfix()).c_str(), "IMPLEMENTATION_COLOR_READ_TYPE and IMPLEMENTATION_COLOR_READ_FORMAT")));
2197 void IntegerStateQueryTests::deinit (void)
2199 if (m_verifierBoolean)
2201 delete m_verifierBoolean;
2202 m_verifierBoolean = DE_NULL;
2204 if (m_verifierInteger)
2206 delete m_verifierInteger;
2207 m_verifierInteger = DE_NULL;
2209 if (m_verifierFloat)
2211 delete m_verifierFloat;
2212 m_verifierFloat = DE_NULL;
2215 this->TestCaseGroup::deinit();