1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 2.0 Module
3 * -------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
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
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
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.
18 *
19 *//*!
20 * \file
21 * \brief Boolean State Query tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es2fBooleanStateQueryTests.hpp"
25 #include "es2fApiCase.hpp"
26 #include "glsStateQueryUtil.hpp"
27 #include "gluRenderContext.hpp"
28 #include "tcuRenderTarget.hpp"
29 #include "glwEnums.hpp"
30
31 using namespace glw; // GLint and other GL types
32 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
33
34 namespace deqp
35 {
36 namespace gles2
37 {
38 namespace Functional
39 {
40 namespace BooleanStateQueryVerifiers
41 {
42
43 // StateVerifier
44
45 class StateVerifier : protected glu::CallLogWrapper
46 {
47 public:
48 StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix);
49 virtual ~StateVerifier (); // make GCC happy
50
51 const char* getTestNamePostfix (void) const;
52
53 virtual void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference) = DE_NULL;
54 virtual void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3) = DE_NULL;
55 virtual void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name) = DE_NULL;
56 private:
57 const char* const m_testNamePostfix;
58 };
59
StateVerifier(const glw::Functions & gl,tcu::TestLog & log,const char * testNamePostfix)60 StateVerifier::StateVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix)
61 : glu::CallLogWrapper (gl, log)
62 , m_testNamePostfix (testNamePostfix)
63 {
64 enableLogging(true);
65 }
66
~StateVerifier()67 StateVerifier::~StateVerifier ()
68 {
69 }
70
getTestNamePostfix(void) const71 const char* StateVerifier::getTestNamePostfix (void) const
72 {
73 return m_testNamePostfix;
74 }
75
76 // IsEnabledVerifier
77
78 class IsEnabledVerifier : public StateVerifier
79 {
80 public:
81 IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log);
82 void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
83 void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
84 void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
85 };
86
IsEnabledVerifier(const glw::Functions & gl,tcu::TestLog & log)87 IsEnabledVerifier::IsEnabledVerifier (const glw::Functions& gl, tcu::TestLog& log)
88 : StateVerifier(gl, log, "_isenabled")
89 {
90 }
91
verifyBoolean(tcu::TestContext & testCtx,GLenum name,bool reference)92 void IsEnabledVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
93 {
94 using tcu::TestLog;
95
96 const GLboolean state = glIsEnabled(name);
97 const GLboolean expectedGLState = reference ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE;
98
99 if (state != expectedGLState)
100 {
101 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
102 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
103 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
104 }
105 }
106
verifyBoolean4(tcu::TestContext & testCtx,GLenum name,bool reference0,bool reference1,bool reference2,bool reference3)107 void IsEnabledVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
108 {
109 DE_UNREF(testCtx);
110 DE_UNREF(name);
111 DE_UNREF(reference0);
112 DE_UNREF(reference1);
113 DE_UNREF(reference2);
114 DE_UNREF(reference3);
115 DE_ASSERT(false && "not supported");
116 }
117
verifyBooleanAnything(tcu::TestContext & testCtx,GLenum name)118 void IsEnabledVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
119 {
120 DE_UNREF(testCtx);
121 DE_UNREF(name);
122 DE_ASSERT(false && "not supported");
123 }
124 // GetBooleanVerifier
125
126 class GetBooleanVerifier : public StateVerifier
127 {
128 public:
129 GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log);
130 void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
131 void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
132 void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
133 };
134
GetBooleanVerifier(const glw::Functions & gl,tcu::TestLog & log)135 GetBooleanVerifier::GetBooleanVerifier (const glw::Functions& gl, tcu::TestLog& log)
136 : StateVerifier(gl, log, "_getboolean")
137 {
138 }
139
verifyBoolean(tcu::TestContext & testCtx,GLenum name,bool reference)140 void GetBooleanVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
141 {
142 using tcu::TestLog;
143
144 StateQueryMemoryWriteGuard<GLboolean> state;
145 glGetBooleanv(name, &state);
146
147 if (!state.verifyValidity(testCtx))
148 return;
149
150 const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
151
152 if (state != expectedGLState)
153 {
154 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (reference ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
155 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
156 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
157 }
158 }
159
verifyBoolean4(tcu::TestContext & testCtx,GLenum name,bool reference0,bool reference1,bool reference2,bool reference3)160 void GetBooleanVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
161 {
162 using tcu::TestLog;
163
164 StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
165 glGetBooleanv(name, boolVector4);
166
167 if (!boolVector4.verifyValidity(testCtx))
168 return;
169
170 const GLboolean referenceAsGLBoolean[] =
171 {
172 reference0 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
173 reference1 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
174 reference2 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
175 reference3 ? GLboolean(GL_TRUE) : GLboolean(GL_FALSE),
176 };
177
178 if (boolVector4[0] != referenceAsGLBoolean[0] ||
179 boolVector4[1] != referenceAsGLBoolean[1] ||
180 boolVector4[2] != referenceAsGLBoolean[2] ||
181 boolVector4[3] != referenceAsGLBoolean[3])
182 {
183 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
184 << (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") << " "
185 << (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") << " "
186 << (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") << " "
187 << (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") << TestLog::EndMessage;
188
189 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
190 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
191 }
192 }
193
verifyBooleanAnything(tcu::TestContext & testCtx,GLenum name)194 void GetBooleanVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
195 {
196 using tcu::TestLog;
197
198 StateQueryMemoryWriteGuard<GLboolean> state;
199 glGetBooleanv(name, &state);
200
201 state.verifyValidity(testCtx);
202 }
203
204 //GetIntegerVerifier
205
206 class GetIntegerVerifier : public StateVerifier
207 {
208 public:
209 GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log);
210 void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
211 void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
212 void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
213
214 };
215
GetIntegerVerifier(const glw::Functions & gl,tcu::TestLog & log)216 GetIntegerVerifier::GetIntegerVerifier (const glw::Functions& gl, tcu::TestLog& log)
217 : StateVerifier(gl, log, "_getinteger")
218 {
219 }
220
verifyBoolean(tcu::TestContext & testCtx,GLenum name,bool reference)221 void GetIntegerVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
222 {
223 using tcu::TestLog;
224
225 StateQueryMemoryWriteGuard<GLint> state;
226 glGetIntegerv(name, &state);
227
228 if (!state.verifyValidity(testCtx))
229 return;
230
231 const GLint expectedGLState = reference ? 1 : 0;
232
233 if (state != expectedGLState)
234 {
235 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << TestLog::EndMessage;
236 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
237 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
238 }
239 }
240
verifyBoolean4(tcu::TestContext & testCtx,GLenum name,bool reference0,bool reference1,bool reference2,bool reference3)241 void GetIntegerVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
242 {
243 using tcu::TestLog;
244
245 StateQueryMemoryWriteGuard<GLint[4]> boolVector4;
246 glGetIntegerv(name, boolVector4);
247
248 if (!boolVector4.verifyValidity(testCtx))
249 return;
250
251 const GLint referenceAsGLint[] =
252 {
253 reference0 ? 1 : 0,
254 reference1 ? 1 : 0,
255 reference2 ? 1 : 0,
256 reference3 ? 1 : 0,
257 };
258
259 if (boolVector4[0] != referenceAsGLint[0] ||
260 boolVector4[1] != referenceAsGLint[1] ||
261 boolVector4[2] != referenceAsGLint[2] ||
262 boolVector4[3] != referenceAsGLint[3])
263 {
264 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
265 << referenceAsGLint[0] << " "
266 << referenceAsGLint[1] << " "
267 << referenceAsGLint[2] << " "
268 << referenceAsGLint[3] << " " << TestLog::EndMessage;
269
270 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
271 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
272 }
273 }
274
verifyBooleanAnything(tcu::TestContext & testCtx,GLenum name)275 void GetIntegerVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
276 {
277 using tcu::TestLog;
278
279 StateQueryMemoryWriteGuard<GLint> state;
280 glGetIntegerv(name, &state);
281
282 state.verifyValidity(testCtx);
283 }
284
285 //GetFloatVerifier
286
287 class GetFloatVerifier : public StateVerifier
288 {
289 public:
290 GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log);
291 void verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference);
292 void verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3);
293 void verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name);
294 };
295
GetFloatVerifier(const glw::Functions & gl,tcu::TestLog & log)296 GetFloatVerifier::GetFloatVerifier (const glw::Functions& gl, tcu::TestLog& log)
297 : StateVerifier(gl, log, "_getfloat")
298 {
299 }
300
verifyBoolean(tcu::TestContext & testCtx,GLenum name,bool reference)301 void GetFloatVerifier::verifyBoolean (tcu::TestContext& testCtx, GLenum name, bool reference)
302 {
303 using tcu::TestLog;
304
305 StateQueryMemoryWriteGuard<GLfloat> state;
306 glGetFloatv(name, &state);
307
308 if (!state.verifyValidity(testCtx))
309 return;
310
311 const GLfloat expectedGLState = reference ? 1.0f : 0.0f;
312
313 if (state != expectedGLState)
314 {
315 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << expectedGLState << "; got " << state << TestLog::EndMessage;
316 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
317 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
318 }
319 }
320
verifyBoolean4(tcu::TestContext & testCtx,GLenum name,bool reference0,bool reference1,bool reference2,bool reference3)321 void GetFloatVerifier::verifyBoolean4 (tcu::TestContext& testCtx, GLenum name, bool reference0, bool reference1, bool reference2, bool reference3)
322 {
323 using tcu::TestLog;
324
325 StateQueryMemoryWriteGuard<GLfloat[4]> boolVector4;
326 glGetFloatv(name, boolVector4);
327
328 if (!boolVector4.verifyValidity(testCtx))
329 return;
330
331 const GLfloat referenceAsGLfloat[] =
332 {
333 reference0 ? 1.0f : 0.0f,
334 reference1 ? 1.0f : 0.0f,
335 reference2 ? 1.0f : 0.0f,
336 reference3 ? 1.0f : 0.0f,
337 };
338
339 if (boolVector4[0] != referenceAsGLfloat[0] ||
340 boolVector4[1] != referenceAsGLfloat[1] ||
341 boolVector4[2] != referenceAsGLfloat[2] ||
342 boolVector4[3] != referenceAsGLfloat[3])
343 {
344 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
345 << referenceAsGLfloat[0] << " "
346 << referenceAsGLfloat[1] << " "
347 << referenceAsGLfloat[2] << " "
348 << referenceAsGLfloat[3] << " " << TestLog::EndMessage;
349
350 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
351 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
352 }
353 }
354
verifyBooleanAnything(tcu::TestContext & testCtx,GLenum name)355 void GetFloatVerifier::verifyBooleanAnything (tcu::TestContext& testCtx, GLenum name)
356 {
357 using tcu::TestLog;
358
359 StateQueryMemoryWriteGuard<GLfloat> state;
360 glGetFloatv(name, &state);
361
362 state.verifyValidity(testCtx);
363 }
364
365 } // BooleanStateQueryVerifiers
366
367 namespace
368 {
369
370 using namespace BooleanStateQueryVerifiers;
371
372 class IsEnabledStateTestCase : public ApiCase
373 {
374 public:
IsEnabledStateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum targetName,bool initial)375 IsEnabledStateTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description, GLenum targetName, bool initial)
376 : ApiCase (context, name, description)
377 , m_targetName (targetName)
378 , m_initial (initial)
379 , m_verifier (verifier)
380 {
381 }
382
test(void)383 void test (void)
384 {
385 // check inital value
386 m_verifier->verifyBoolean(m_testCtx, m_targetName, m_initial);
387 expectError(GL_NO_ERROR);
388
389 // check toggle
390
391 glEnable(m_targetName);
392 expectError(GL_NO_ERROR);
393
394 m_verifier->verifyBoolean(m_testCtx, m_targetName, true);
395 expectError(GL_NO_ERROR);
396
397 glDisable(m_targetName);
398 expectError(GL_NO_ERROR);
399
400 m_verifier->verifyBoolean(m_testCtx, m_targetName, false);
401 expectError(GL_NO_ERROR);
402 }
403
404 private:
405 GLenum m_targetName;
406 bool m_initial;
407 StateVerifier* m_verifier;
408 };
409
410 class DepthWriteMaskTestCase : public ApiCase
411 {
412 public:
DepthWriteMaskTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)413 DepthWriteMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
414 : ApiCase (context, name, description)
415 , m_verifier (verifier)
416 {
417 }
418
test(void)419 void test (void)
420 {
421 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
422 expectError(GL_NO_ERROR);
423
424 glDepthMask(GL_FALSE);
425 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, false);
426 expectError(GL_NO_ERROR);
427
428 glDepthMask(GL_TRUE);
429 m_verifier->verifyBoolean(m_testCtx, GL_DEPTH_WRITEMASK, true);
430 expectError(GL_NO_ERROR);
431 }
432 private:
433 StateVerifier* m_verifier;
434 };
435
436 class SampleCoverageInvertTestCase : public ApiCase
437 {
438 public:
SampleCoverageInvertTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)439 SampleCoverageInvertTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
440 : ApiCase (context, name, description)
441 , m_verifier (verifier)
442 {
443 }
444
test(void)445 void test (void)
446 {
447 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
448 expectError(GL_NO_ERROR);
449
450 glSampleCoverage(1.0f, GL_TRUE);
451 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, true);
452 expectError(GL_NO_ERROR);
453
454 glSampleCoverage(1.0f, GL_FALSE);
455 m_verifier->verifyBoolean(m_testCtx, GL_SAMPLE_COVERAGE_INVERT, false);
456 expectError(GL_NO_ERROR);
457 }
458 private:
459 StateVerifier* m_verifier;
460 };
461
462 class ShaderCompilerTestCase : public ApiCase
463 {
464 public:
ShaderCompilerTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)465 ShaderCompilerTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
466 : ApiCase (context, name, description)
467 , m_verifier (verifier)
468 {
469 }
470
test(void)471 void test (void)
472 {
473 m_verifier->verifyBooleanAnything(m_testCtx, GL_SHADER_COMPILER);
474 expectError(GL_NO_ERROR);
475 }
476
477 private:
478 StateVerifier* m_verifier;
479 };
480
481 class ColorMaskTestCase : public ApiCase
482 {
483 public:
ColorMaskTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)484 ColorMaskTestCase (Context& context, StateVerifier* verifier, const char* name, const char* description)
485 : ApiCase(context, name, description)
486 , m_verifier (verifier)
487 {
488 }
test(void)489 void test (void)
490 {
491 m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, true, true, true, true);
492 expectError(GL_NO_ERROR);
493
494 const struct ColorMask
495 {
496 GLboolean r, g, b, a;
497 } testMasks[] =
498 {
499 { GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE },
500 { GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE },
501 { GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE },
502 { GL_TRUE, GL_TRUE, GL_FALSE, GL_FALSE },
503 { GL_TRUE, GL_FALSE, GL_TRUE, GL_TRUE },
504 { GL_TRUE, GL_FALSE, GL_TRUE, GL_FALSE },
505 { GL_TRUE, GL_FALSE, GL_FALSE, GL_TRUE },
506 { GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE },
507 { GL_FALSE, GL_TRUE, GL_TRUE, GL_TRUE },
508 { GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE },
509 { GL_FALSE, GL_TRUE, GL_FALSE, GL_TRUE },
510 { GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE },
511 { GL_FALSE, GL_FALSE, GL_TRUE, GL_TRUE },
512 { GL_FALSE, GL_FALSE, GL_TRUE, GL_FALSE },
513 { GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE },
514 { GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE },
515 };
516
517 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(testMasks); ndx++)
518 {
519 glColorMask(testMasks[ndx].r, testMasks[ndx].g, testMasks[ndx].b, testMasks[ndx].a);
520 m_verifier->verifyBoolean4(m_testCtx, GL_COLOR_WRITEMASK, testMasks[ndx].r==GL_TRUE, testMasks[ndx].g==GL_TRUE, testMasks[ndx].b==GL_TRUE, testMasks[ndx].a==GL_TRUE);
521 expectError(GL_NO_ERROR);
522 }
523 }
524 private:
525 StateVerifier* m_verifier;
526 };
527
528 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
529 for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
530 { \
531 StateVerifier* verifier = VERIFIERS[_verifierNdx]; \
532 CODE_BLOCK; \
533 }
534
535 } // anonymous
536
BooleanStateQueryTests(Context & context)537 BooleanStateQueryTests::BooleanStateQueryTests (Context& context)
538 : TestCaseGroup (context, "boolean", "Boolean State Query tests")
539 , m_verifierIsEnabled (DE_NULL)
540 , m_verifierBoolean (DE_NULL)
541 , m_verifierInteger (DE_NULL)
542 , m_verifierFloat (DE_NULL)
543 {
544 }
545
~BooleanStateQueryTests(void)546 BooleanStateQueryTests::~BooleanStateQueryTests (void)
547 {
548 deinit();
549 }
550
init(void)551 void BooleanStateQueryTests::init (void)
552 {
553 DE_ASSERT(m_verifierIsEnabled == DE_NULL);
554 DE_ASSERT(m_verifierBoolean == DE_NULL);
555 DE_ASSERT(m_verifierInteger == DE_NULL);
556 DE_ASSERT(m_verifierFloat == DE_NULL);
557
558 m_verifierIsEnabled = new IsEnabledVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
559 m_verifierBoolean = new GetBooleanVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
560 m_verifierInteger = new GetIntegerVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
561 m_verifierFloat = new GetFloatVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
562
563 StateVerifier* isEnabledVerifiers[] = {m_verifierIsEnabled, m_verifierBoolean, m_verifierInteger, m_verifierFloat};
564 StateVerifier* normalVerifiers[] = { m_verifierBoolean, m_verifierInteger, m_verifierFloat};
565
566 struct StateBoolean
567 {
568 const char* name;
569 const char* description;
570 GLenum targetName;
571 bool value;
572 };
573 const StateBoolean isEnableds[] =
574 {
575 { "cull_face", "CULL_FACE", GL_CULL_FACE, false},
576 { "polygon_offset_fill", "POLYGON_OFFSET_FILL", GL_POLYGON_OFFSET_FILL, false},
577 { "sample_alpha_to_coverage", "SAMPLE_ALPHA_TO_COVERAGE", GL_SAMPLE_ALPHA_TO_COVERAGE, false},
578 { "sample_coverage", "SAMPLE_COVERAGE", GL_SAMPLE_COVERAGE, false},
579 { "scissor_test", "SCISSOR_TEST", GL_SCISSOR_TEST, false},
580 { "stencil_test", "STENCIL_TEST", GL_STENCIL_TEST, false},
581 { "depth_test", "DEPTH_TEST", GL_DEPTH_TEST, false},
582 { "blend", "BLEND", GL_BLEND, false},
583 { "dither", "DITHER", GL_DITHER, true },
584 };
585 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(isEnableds); testNdx++)
586 FOR_EACH_VERIFIER(isEnabledVerifiers, addChild(new IsEnabledStateTestCase(m_context, verifier, (std::string(isEnableds[testNdx].name) + verifier->getTestNamePostfix()).c_str(), isEnableds[testNdx].description, isEnableds[testNdx].targetName, isEnableds[testNdx].value)));
587
588 FOR_EACH_VERIFIER(normalVerifiers, addChild(new SampleCoverageInvertTestCase (m_context, verifier, (std::string("sample_coverage_invert") + verifier->getTestNamePostfix()).c_str(), "SAMPLE_COVERAGE_INVERT")));
589 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ColorMaskTestCase (m_context, verifier, (std::string("color_writemask") + verifier->getTestNamePostfix()).c_str(), "COLOR_WRITEMASK")));
590 FOR_EACH_VERIFIER(normalVerifiers, addChild(new DepthWriteMaskTestCase (m_context, verifier, (std::string("depth_writemask") + verifier->getTestNamePostfix()).c_str(), "DEPTH_WRITEMASK")));
591 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ShaderCompilerTestCase (m_context, verifier, (std::string("shader_compiler") + verifier->getTestNamePostfix()).c_str(), "SHADER_COMPILER")));
592 }
593
deinit(void)594 void BooleanStateQueryTests::deinit (void)
595 {
596 if (m_verifierIsEnabled)
597 {
598 delete m_verifierIsEnabled;
599 m_verifierIsEnabled = DE_NULL;
600 }
601 if (m_verifierBoolean)
602 {
603 delete m_verifierBoolean;
604 m_verifierBoolean = DE_NULL;
605 }
606 if (m_verifierInteger)
607 {
608 delete m_verifierInteger;
609 m_verifierInteger = DE_NULL;
610 }
611 if (m_verifierFloat)
612 {
613 delete m_verifierFloat;
614 m_verifierFloat = DE_NULL;
615 }
616
617 this->TestCaseGroup::deinit();
618 }
619
620 } // Functional
621 } // gles2
622 } // deqp
623