1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.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 State Query tests.
22 *//*--------------------------------------------------------------------*/
23
24 #include "es3fIntegerStateQueryTests.hpp"
25 #include "es3fApiCase.hpp"
26
27 #include "glsStateQueryUtil.hpp"
28
29 #include "gluRenderContext.hpp"
30 #include "gluContextInfo.hpp"
31 #include "gluStrUtil.hpp"
32
33 #include "tcuRenderTarget.hpp"
34
35 #include "deRandom.hpp"
36
37 #include "glwEnums.hpp"
38
39 using namespace glw; // GLint and other GL types
40 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
41
42 #ifndef GL_SLUMINANCE_NV
43 #define GL_SLUMINANCE_NV 0x8C46
44 #endif
45 #ifndef GL_SLUMINANCE_ALPHA_NV
46 #define GL_SLUMINANCE_ALPHA_NV 0x8C44
47 #endif
48 #ifndef GL_BGR_NV
49 #define GL_BGR_NV 0x80E0
50 #endif
51
52 namespace deqp
53 {
54 namespace gles3
55 {
56 namespace Functional
57 {
58 namespace IntegerStateQueryVerifiers
59 {
60
61 // StateVerifier
62
63 class StateVerifier : protected glu::CallLogWrapper
64 {
65 public:
66 StateVerifier(const glw::Functions &gl, tcu::TestLog &log, const char *testNamePostfix);
67 virtual ~StateVerifier(); // make GCC happy
68
69 const char *getTestNamePostfix(void) const;
70
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,
73 GLint reference2, GLint reference3) = DE_NULL;
74 virtual void verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0,
75 GLint reference1, bool enableRef1, GLint reference2, bool enableRef2,
76 GLint reference3, bool enableRef3) = DE_NULL;
77 virtual void verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference) = DE_NULL;
78 virtual void verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name,
79 GLuint reference) = DE_NULL;
80 virtual void verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference) = DE_NULL;
81 virtual void verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0,
82 GLint reference1) = DE_NULL;
83 virtual void verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[],
84 size_t referencesLength) = DE_NULL;
85 virtual void verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits) = DE_NULL;
86
87 private:
88 const char *const m_testNamePostfix;
89 };
90
StateVerifier(const glw::Functions & gl,tcu::TestLog & log,const char * testNamePostfix)91 StateVerifier::StateVerifier(const glw::Functions &gl, tcu::TestLog &log, const char *testNamePostfix)
92 : glu::CallLogWrapper(gl, log)
93 , m_testNamePostfix(testNamePostfix)
94 {
95 enableLogging(true);
96 }
97
~StateVerifier()98 StateVerifier::~StateVerifier()
99 {
100 }
101
getTestNamePostfix(void) const102 const char *StateVerifier::getTestNamePostfix(void) const
103 {
104 return m_testNamePostfix;
105 }
106
107 // GetBooleanVerifier
108
109 class GetBooleanVerifier : public StateVerifier
110 {
111 public:
112 GetBooleanVerifier(const glw::Functions &gl, tcu::TestLog &log);
113 void verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference);
114 void verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2,
115 GLint reference3);
116 void verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1,
117 bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
118 void verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
119 void verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference);
120 void verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
121 void verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1);
122 void verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[], size_t referencesLength);
123 void verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits);
124 };
125
GetBooleanVerifier(const glw::Functions & gl,tcu::TestLog & log)126 GetBooleanVerifier::GetBooleanVerifier(const glw::Functions &gl, tcu::TestLog &log)
127 : StateVerifier(gl, log, "_getboolean")
128 {
129 }
130
verifyInteger(tcu::TestContext & testCtx,GLenum name,GLint reference)131 void GetBooleanVerifier::verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference)
132 {
133 using tcu::TestLog;
134
135 StateQueryMemoryWriteGuard<GLboolean> state;
136 glGetBooleanv(name, &state);
137
138 if (!state.verifyValidity(testCtx))
139 return;
140
141 const GLboolean expectedGLState = reference ? GL_TRUE : GL_FALSE;
142
143 if (state != expectedGLState)
144 {
145 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
146 << (expectedGLState == GL_TRUE ? "GL_TRUE" : "GL_FALSE") << "; got "
147 << (state == GL_TRUE ? "GL_TRUE" : (state == GL_FALSE ? "GL_FALSE" : "non-boolean"))
148 << TestLog::EndMessage;
149 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
150 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
151 }
152 }
153
verifyInteger4(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1,GLint reference2,GLint reference3)154 void GetBooleanVerifier::verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1,
155 GLint reference2, GLint reference3)
156 {
157 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
158 }
159
verifyInteger4Mask(tcu::TestContext & testCtx,GLenum name,GLint reference0,bool enableRef0,GLint reference1,bool enableRef1,GLint reference2,bool enableRef2,GLint reference3,bool enableRef3)160 void GetBooleanVerifier::verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0,
161 GLint reference1, bool enableRef1, GLint reference2, bool enableRef2,
162 GLint reference3, bool enableRef3)
163 {
164 using tcu::TestLog;
165
166 StateQueryMemoryWriteGuard<GLboolean[4]> boolVector4;
167 glGetBooleanv(name, boolVector4);
168
169 if (!boolVector4.verifyValidity(testCtx))
170 return;
171
172 const GLboolean referenceAsGLBoolean[] = {
173 reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
174 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
175 reference2 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
176 reference3 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
177 };
178
179 if ((enableRef0 && (boolVector4[0] != referenceAsGLBoolean[0])) ||
180 (enableRef1 && (boolVector4[1] != referenceAsGLBoolean[1])) ||
181 (enableRef2 && (boolVector4[2] != referenceAsGLBoolean[2])) ||
182 (enableRef3 && (boolVector4[3] != referenceAsGLBoolean[3])))
183 {
184 testCtx.getLog() << TestLog::Message << "// ERROR: expected "
185 << (enableRef0 ? (referenceAsGLBoolean[0] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
186 << (enableRef1 ? (referenceAsGLBoolean[1] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
187 << (enableRef2 ? (referenceAsGLBoolean[2] ? "GL_TRUE" : "GL_FALSE") : " - ") << ", "
188 << (enableRef3 ? (referenceAsGLBoolean[3] ? "GL_TRUE" : "GL_FALSE") : " - ")
189 << TestLog::EndMessage;
190
191 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
192 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
193 }
194 }
195
verifyIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)196 void GetBooleanVerifier::verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
197 {
198 using tcu::TestLog;
199
200 StateQueryMemoryWriteGuard<GLboolean> state;
201 glGetBooleanv(name, &state);
202
203 if (!state.verifyValidity(testCtx))
204 return;
205
206 if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
207 return;
208
209 if (state == GL_FALSE) // state is zero
210 {
211 if (reference > 0) // and reference is greater than zero?
212 {
213 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
214 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
215 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
216 }
217 }
218 else
219 {
220 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
221 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
222 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
223 }
224 }
225
verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLuint reference)226 void GetBooleanVerifier::verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference)
227 {
228 using tcu::TestLog;
229
230 StateQueryMemoryWriteGuard<GLboolean> state;
231 glGetBooleanv(name, &state);
232
233 if (!state.verifyValidity(testCtx))
234 return;
235
236 if (state == GL_TRUE) // state is non-zero, could be greater than reference (correct)
237 return;
238
239 if (state == GL_FALSE) // state is zero
240 {
241 if (reference > 0) // and reference is greater than zero?
242 {
243 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
244 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
245 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
246 }
247 }
248 else
249 {
250 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
251 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
252 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
253 }
254 }
255
verifyIntegerLessOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)256 void GetBooleanVerifier::verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
257 {
258 using tcu::TestLog;
259
260 StateQueryMemoryWriteGuard<GLboolean> state;
261 glGetBooleanv(name, &state);
262
263 if (!state.verifyValidity(testCtx))
264 return;
265
266 if (state == GL_TRUE) // state is non-zero, could be less than reference (correct)
267 return;
268
269 if (state == GL_FALSE) // state is zero
270 {
271 if (reference < 0) // and reference is less than zero?
272 {
273 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
274 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
275 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
276 }
277 }
278 else
279 {
280 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
281 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
282 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
283 }
284 }
285
verifyIntegerGreaterOrEqual2(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1)286 void GetBooleanVerifier::verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0,
287 GLint reference1)
288 {
289 using tcu::TestLog;
290
291 StateQueryMemoryWriteGuard<GLboolean[2]> boolVector;
292 glGetBooleanv(name, boolVector);
293
294 if (!boolVector.verifyValidity(testCtx))
295 return;
296
297 const GLboolean referenceAsGLBoolean[2] = {reference0 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE,
298 reference1 ? (GLboolean)GL_TRUE : (GLboolean)GL_FALSE};
299
300 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(referenceAsGLBoolean); ++ndx)
301 {
302 if (boolVector[ndx] == GL_TRUE) // state is non-zero, could be greater than any integer
303 {
304 continue;
305 }
306 else if (boolVector[ndx] == GL_FALSE) // state is zero
307 {
308 if (referenceAsGLBoolean[ndx] > 0) // and reference is greater than zero?
309 {
310 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
311 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
312 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
313 }
314 }
315 else
316 {
317 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE or GL_FALSE" << TestLog::EndMessage;
318 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
319 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
320 }
321 }
322 }
323
verifyIntegerAnyOf(tcu::TestContext & testCtx,GLenum name,const GLint references[],size_t referencesLength)324 void GetBooleanVerifier::verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[],
325 size_t referencesLength)
326 {
327 using tcu::TestLog;
328
329 StateQueryMemoryWriteGuard<GLboolean> state;
330 glGetBooleanv(name, &state);
331
332 if (!state.verifyValidity(testCtx))
333 return;
334
335 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
336 {
337 const GLboolean expectedGLState = references[ndx] ? GL_TRUE : GL_FALSE;
338
339 if (state == expectedGLState)
340 return;
341 }
342
343 testCtx.getLog() << TestLog::Message << "// ERROR: got " << (state == GL_TRUE ? "GL_TRUE" : "GL_FALSE")
344 << TestLog::EndMessage;
345 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
346 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
347 }
348
verifyStencilMaskInitial(tcu::TestContext & testCtx,GLenum name,int stencilBits)349 void GetBooleanVerifier::verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits)
350 {
351 // if stencilBits == 0, the mask is allowed to be either GL_TRUE or GL_FALSE
352 // otherwise it must be GL_TRUE
353 using tcu::TestLog;
354
355 StateQueryMemoryWriteGuard<GLboolean> state;
356 glGetBooleanv(name, &state);
357
358 if (!state.verifyValidity(testCtx))
359 return;
360
361 if (stencilBits > 0 && state != GL_TRUE)
362 {
363 testCtx.getLog() << TestLog::Message << "// ERROR: expected GL_TRUE" << TestLog::EndMessage;
364 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
365 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid boolean value");
366 }
367 }
368
369 //GetIntegerVerifier
370
371 class GetIntegerVerifier : public StateVerifier
372 {
373 public:
374 GetIntegerVerifier(const glw::Functions &gl, tcu::TestLog &log);
375 void verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference);
376 void verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2,
377 GLint reference3);
378 void verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1,
379 bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
380 void verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
381 void verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference);
382 void verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
383 void verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1);
384 void verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[], size_t referencesLength);
385 void verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits);
386 };
387
GetIntegerVerifier(const glw::Functions & gl,tcu::TestLog & log)388 GetIntegerVerifier::GetIntegerVerifier(const glw::Functions &gl, tcu::TestLog &log)
389 : StateVerifier(gl, log, "_getinteger")
390 {
391 }
392
verifyInteger(tcu::TestContext & testCtx,GLenum name,GLint reference)393 void GetIntegerVerifier::verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference)
394 {
395 using tcu::TestLog;
396
397 StateQueryMemoryWriteGuard<GLint> state;
398 glGetIntegerv(name, &state);
399
400 if (!state.verifyValidity(testCtx))
401 return;
402
403 if (state != reference)
404 {
405 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
406 << TestLog::EndMessage;
407 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
408 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
409 }
410 }
411
verifyInteger4(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1,GLint reference2,GLint reference3)412 void GetIntegerVerifier::verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1,
413 GLint reference2, GLint reference3)
414 {
415 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
416 }
417
verifyInteger4Mask(tcu::TestContext & testCtx,GLenum name,GLint reference0,bool enableRef0,GLint reference1,bool enableRef1,GLint reference2,bool enableRef2,GLint reference3,bool enableRef3)418 void GetIntegerVerifier::verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0,
419 GLint reference1, bool enableRef1, GLint reference2, bool enableRef2,
420 GLint reference3, bool enableRef3)
421 {
422 using tcu::TestLog;
423
424 StateQueryMemoryWriteGuard<GLint[4]> intVector4;
425 glGetIntegerv(name, intVector4);
426
427 if (!intVector4.verifyValidity(testCtx))
428 return;
429
430 if ((enableRef0 && (intVector4[0] != reference0)) || (enableRef1 && (intVector4[1] != reference1)) ||
431 (enableRef2 && (intVector4[2] != reference2)) || (enableRef3 && (intVector4[3] != reference3)))
432 {
433 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (enableRef0 ? "" : "(") << reference0
434 << (enableRef0 ? "" : ")") << ", " << (enableRef1 ? "" : "(") << reference1
435 << (enableRef1 ? "" : ")") << ", " << (enableRef2 ? "" : "(") << reference2
436 << (enableRef2 ? "" : ")") << ", " << (enableRef3 ? "" : "(") << reference3
437 << (enableRef3 ? "" : ")") << TestLog::EndMessage;
438
439 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
440 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
441 }
442 }
443
verifyIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)444 void GetIntegerVerifier::verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
445 {
446 using tcu::TestLog;
447
448 StateQueryMemoryWriteGuard<GLint> state;
449 glGetIntegerv(name, &state);
450
451 if (!state.verifyValidity(testCtx))
452 return;
453
454 if (state < reference)
455 {
456 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got "
457 << state << TestLog::EndMessage;
458 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
459 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
460 }
461 }
462
verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLuint reference)463 void GetIntegerVerifier::verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference)
464 {
465 using tcu::TestLog;
466
467 StateQueryMemoryWriteGuard<GLint> state;
468 glGetIntegerv(name, &state);
469
470 if (!state.verifyValidity(testCtx))
471 return;
472
473 if (GLuint(state) < reference)
474 {
475 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference << "; got "
476 << GLuint(state) << TestLog::EndMessage;
477 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
478 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
479 }
480 }
481
verifyIntegerLessOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)482 void GetIntegerVerifier::verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
483 {
484 using tcu::TestLog;
485
486 StateQueryMemoryWriteGuard<GLint> state;
487 glGetIntegerv(name, &state);
488
489 if (!state.verifyValidity(testCtx))
490 return;
491
492 if (state > reference)
493 {
494 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << reference << "; got " << state
495 << TestLog::EndMessage;
496 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
497 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
498 }
499 }
500
verifyIntegerGreaterOrEqual2(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1)501 void GetIntegerVerifier::verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0,
502 GLint reference1)
503 {
504 using tcu::TestLog;
505
506 StateQueryMemoryWriteGuard<GLint[2]> intVector2;
507 glGetIntegerv(name, intVector2);
508
509 if (!intVector2.verifyValidity(testCtx))
510 return;
511
512 if (intVector2[0] < reference0 || intVector2[1] < reference1)
513 {
514 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << reference0 << ", "
515 << reference1 << "; got " << intVector2[0] << ", " << intVector2[0] << TestLog::EndMessage;
516 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
517 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
518 }
519 }
520
verifyIntegerAnyOf(tcu::TestContext & testCtx,GLenum name,const GLint references[],size_t referencesLength)521 void GetIntegerVerifier::verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[],
522 size_t referencesLength)
523 {
524 using tcu::TestLog;
525
526 StateQueryMemoryWriteGuard<GLint> state;
527 glGetIntegerv(name, &state);
528
529 if (!state.verifyValidity(testCtx))
530 return;
531
532 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
533 {
534 const GLint expectedGLState = references[ndx];
535
536 if (state == expectedGLState)
537 return;
538 }
539
540 testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
541 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
542 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
543 }
544
verifyStencilMaskInitial(tcu::TestContext & testCtx,GLenum name,int stencilBits)545 void GetIntegerVerifier::verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits)
546 {
547 using tcu::TestLog;
548
549 StateQueryMemoryWriteGuard<GLint> state;
550 glGetIntegerv(name, &state);
551
552 if (!state.verifyValidity(testCtx))
553 return;
554
555 const GLint reference = (1 << stencilBits) - 1;
556
557 if ((state & reference) != reference) // the least significant stencilBits bits should be on
558 {
559 testCtx.getLog() << TestLog::Message << "// ERROR: expected minimum mask of " << reference << "; got " << state
560 << TestLog::EndMessage;
561 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
562 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
563 }
564 }
565
566 //GetInteger64Verifier
567
568 class GetInteger64Verifier : public StateVerifier
569 {
570 public:
571 GetInteger64Verifier(const glw::Functions &gl, tcu::TestLog &log);
572 void verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference);
573 void verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2,
574 GLint reference3);
575 void verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1,
576 bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
577 void verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
578 void verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference);
579 void verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
580 void verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1);
581 void verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[], size_t referencesLength);
582 void verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits);
583 };
584
GetInteger64Verifier(const glw::Functions & gl,tcu::TestLog & log)585 GetInteger64Verifier::GetInteger64Verifier(const glw::Functions &gl, tcu::TestLog &log)
586 : StateVerifier(gl, log, "_getinteger64")
587 {
588 }
589
verifyInteger(tcu::TestContext & testCtx,GLenum name,GLint reference)590 void GetInteger64Verifier::verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference)
591 {
592 using tcu::TestLog;
593
594 StateQueryMemoryWriteGuard<GLint64> state;
595 glGetInteger64v(name, &state);
596
597 if (!state.verifyValidity(testCtx))
598 return;
599
600 if (state != GLint64(reference))
601 {
602 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
603 << TestLog::EndMessage;
604 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
605 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
606 }
607 }
608
verifyInteger4(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1,GLint reference2,GLint reference3)609 void GetInteger64Verifier::verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1,
610 GLint reference2, GLint reference3)
611 {
612 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
613 }
614
verifyInteger4Mask(tcu::TestContext & testCtx,GLenum name,GLint reference0,bool enableRef0,GLint reference1,bool enableRef1,GLint reference2,bool enableRef2,GLint reference3,bool enableRef3)615 void GetInteger64Verifier::verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0,
616 GLint reference1, bool enableRef1, GLint reference2, bool enableRef2,
617 GLint reference3, bool enableRef3)
618 {
619 using tcu::TestLog;
620
621 StateQueryMemoryWriteGuard<GLint64[4]> intVector4;
622 glGetInteger64v(name, intVector4);
623
624 if (!intVector4.verifyValidity(testCtx))
625 return;
626
627 if ((enableRef0 && (intVector4[0] != GLint64(reference0))) ||
628 (enableRef1 && (intVector4[1] != GLint64(reference1))) ||
629 (enableRef2 && (intVector4[2] != GLint64(reference2))) ||
630 (enableRef3 && (intVector4[3] != GLint64(reference3))))
631 {
632 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (enableRef0 ? "" : "(") << reference0
633 << (enableRef0 ? "" : ")") << ", " << (enableRef1 ? "" : "(") << reference1
634 << (enableRef1 ? "" : ")") << ", " << (enableRef2 ? "" : "(") << reference2
635 << (enableRef2 ? "" : ")") << ", " << (enableRef3 ? "" : "(") << reference3
636 << (enableRef3 ? "" : ")") << TestLog::EndMessage;
637
638 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
639 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
640 }
641 }
642
verifyIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)643 void GetInteger64Verifier::verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
644 {
645 using tcu::TestLog;
646
647 StateQueryMemoryWriteGuard<GLint64> state;
648 glGetInteger64v(name, &state);
649
650 if (!state.verifyValidity(testCtx))
651 return;
652
653 if (state < GLint64(reference))
654 {
655 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference)
656 << "; got " << state << TestLog::EndMessage;
657 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
658 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
659 }
660 }
661
verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLuint reference)662 void GetInteger64Verifier::verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference)
663 {
664 using tcu::TestLog;
665
666 StateQueryMemoryWriteGuard<GLint64> state;
667 glGetInteger64v(name, &state);
668
669 if (!state.verifyValidity(testCtx))
670 return;
671
672 if (GLuint(state) < GLint64(reference))
673 {
674 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference)
675 << "; got " << GLuint(state) << TestLog::EndMessage;
676 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
677 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
678 }
679 }
680
verifyIntegerLessOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)681 void GetInteger64Verifier::verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
682 {
683 using tcu::TestLog;
684
685 StateQueryMemoryWriteGuard<GLint64> state;
686 glGetInteger64v(name, &state);
687
688 if (!state.verifyValidity(testCtx))
689 return;
690
691 if (state > GLint64(reference))
692 {
693 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << GLint64(reference) << "; got "
694 << state << TestLog::EndMessage;
695 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
696 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
697 }
698 }
699
verifyIntegerGreaterOrEqual2(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1)700 void GetInteger64Verifier::verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0,
701 GLint reference1)
702 {
703 using tcu::TestLog;
704
705 StateQueryMemoryWriteGuard<GLint64[2]> intVector2;
706 glGetInteger64v(name, intVector2);
707
708 if (!intVector2.verifyValidity(testCtx))
709 return;
710
711 if (intVector2[0] < GLint64(reference0) || intVector2[1] < GLint64(reference1))
712 {
713 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLint64(reference0) << ", "
714 << GLint64(reference1) << "; got " << intVector2[0] << ", " << intVector2[1]
715 << TestLog::EndMessage;
716 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
717 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
718 }
719 }
720
verifyIntegerAnyOf(tcu::TestContext & testCtx,GLenum name,const GLint references[],size_t referencesLength)721 void GetInteger64Verifier::verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[],
722 size_t referencesLength)
723 {
724 using tcu::TestLog;
725
726 StateQueryMemoryWriteGuard<GLint64> state;
727 glGetInteger64v(name, &state);
728
729 if (!state.verifyValidity(testCtx))
730 return;
731
732 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
733 {
734 const GLint64 expectedGLState = GLint64(references[ndx]);
735
736 if (state == expectedGLState)
737 return;
738 }
739
740 testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
741 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
742 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid integer value");
743 }
744
verifyStencilMaskInitial(tcu::TestContext & testCtx,GLenum name,int stencilBits)745 void GetInteger64Verifier::verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits)
746 {
747 using tcu::TestLog;
748
749 StateQueryMemoryWriteGuard<GLint64> state;
750 glGetInteger64v(name, &state);
751
752 if (!state.verifyValidity(testCtx))
753 return;
754
755 const GLint64 reference = (1ULL << stencilBits) - 1;
756
757 if ((state & reference) != reference) // the least significant stencilBits bits should be on
758 {
759 testCtx.getLog() << TestLog::Message << "// ERROR: expected mimimum mask of " << reference << "; got " << state
760 << TestLog::EndMessage;
761 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
762 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid mask value");
763 }
764 }
765
766 //GetFloatVerifier
767
768 class GetFloatVerifier : public StateVerifier
769 {
770 public:
771 GetFloatVerifier(const glw::Functions &gl, tcu::TestLog &log);
772 void verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference);
773 void verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1, GLint reference2,
774 GLint reference3);
775 void verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0, GLint reference1,
776 bool enableRef1, GLint reference2, bool enableRef2, GLint reference3, bool enableRef3);
777 void verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
778 void verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference);
779 void verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference);
780 void verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1);
781 void verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[], size_t referencesLength);
782 void verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits);
783 };
784
GetFloatVerifier(const glw::Functions & gl,tcu::TestLog & log)785 GetFloatVerifier::GetFloatVerifier(const glw::Functions &gl, tcu::TestLog &log) : StateVerifier(gl, log, "_getfloat")
786 {
787 }
788
verifyInteger(tcu::TestContext & testCtx,GLenum name,GLint reference)789 void GetFloatVerifier::verifyInteger(tcu::TestContext &testCtx, GLenum name, GLint reference)
790 {
791 using tcu::TestLog;
792
793 const GLfloat referenceAsFloat = GLfloat(reference);
794 DE_ASSERT(
795 reference ==
796 GLint(
797 referenceAsFloat)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
798
799 StateQueryMemoryWriteGuard<GLfloat> state;
800 glGetFloatv(name, &state);
801
802 if (!state.verifyValidity(testCtx))
803 return;
804
805 if (state != referenceAsFloat)
806 {
807 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << referenceAsFloat << "; got " << state
808 << TestLog::EndMessage;
809 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
810 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
811 }
812 }
813
verifyInteger4(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1,GLint reference2,GLint reference3)814 void GetFloatVerifier::verifyInteger4(tcu::TestContext &testCtx, GLenum name, GLint reference0, GLint reference1,
815 GLint reference2, GLint reference3)
816 {
817 verifyInteger4Mask(testCtx, name, reference0, true, reference1, true, reference2, true, reference3, true);
818 }
819
verifyInteger4Mask(tcu::TestContext & testCtx,GLenum name,GLint reference0,bool enableRef0,GLint reference1,bool enableRef1,GLint reference2,bool enableRef2,GLint reference3,bool enableRef3)820 void GetFloatVerifier::verifyInteger4Mask(tcu::TestContext &testCtx, GLenum name, GLint reference0, bool enableRef0,
821 GLint reference1, bool enableRef1, GLint reference2, bool enableRef2,
822 GLint reference3, bool enableRef3)
823 {
824 using tcu::TestLog;
825
826 StateQueryMemoryWriteGuard<GLfloat[4]> floatVector4;
827 glGetFloatv(name, floatVector4);
828
829 if (!floatVector4.verifyValidity(testCtx))
830 return;
831
832 if ((enableRef0 && (floatVector4[0] != GLfloat(reference0))) ||
833 (enableRef1 && (floatVector4[1] != GLfloat(reference1))) ||
834 (enableRef2 && (floatVector4[2] != GLfloat(reference2))) ||
835 (enableRef3 && (floatVector4[3] != GLfloat(reference3))))
836 {
837 testCtx.getLog() << TestLog::Message << "// ERROR: expected " << (enableRef0 ? "" : "(") << GLfloat(reference0)
838 << (enableRef0 ? "" : ")") << ", " << (enableRef1 ? "" : "(") << GLfloat(reference1)
839 << (enableRef1 ? "" : ")") << ", " << (enableRef2 ? "" : "(") << GLfloat(reference2)
840 << (enableRef2 ? "" : ")") << ", " << (enableRef3 ? "" : "(") << GLfloat(reference3)
841 << (enableRef3 ? "" : ")") << TestLog::EndMessage;
842
843 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
844 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
845 }
846 }
847
verifyIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)848 void GetFloatVerifier::verifyIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
849 {
850 using tcu::TestLog;
851
852 StateQueryMemoryWriteGuard<GLfloat> state;
853 glGetFloatv(name, &state);
854
855 if (!state.verifyValidity(testCtx))
856 return;
857
858 if (state < GLfloat(reference))
859 {
860 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference)
861 << "; got " << state << TestLog::EndMessage;
862 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
863 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
864 }
865 }
866
verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext & testCtx,GLenum name,GLuint reference)867 void GetFloatVerifier::verifyUnsignedIntegerGreaterOrEqual(tcu::TestContext &testCtx, GLenum name, GLuint reference)
868 {
869 using tcu::TestLog;
870
871 StateQueryMemoryWriteGuard<GLfloat> state;
872 glGetFloatv(name, &state);
873
874 if (!state.verifyValidity(testCtx))
875 return;
876
877 if (state < GLfloat(reference))
878 {
879 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference)
880 << "; got " << state << TestLog::EndMessage;
881 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
882 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
883 }
884 }
885
verifyIntegerLessOrEqual(tcu::TestContext & testCtx,GLenum name,GLint reference)886 void GetFloatVerifier::verifyIntegerLessOrEqual(tcu::TestContext &testCtx, GLenum name, GLint reference)
887 {
888 using tcu::TestLog;
889
890 StateQueryMemoryWriteGuard<GLfloat> state;
891 glGetFloatv(name, &state);
892
893 if (!state.verifyValidity(testCtx))
894 return;
895
896 if (state > GLfloat(reference))
897 {
898 testCtx.getLog() << TestLog::Message << "// ERROR: expected less or equal to " << GLfloat(reference) << "; got "
899 << state << TestLog::EndMessage;
900 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
901 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
902 }
903 }
904
verifyIntegerGreaterOrEqual2(tcu::TestContext & testCtx,GLenum name,GLint reference0,GLint reference1)905 void GetFloatVerifier::verifyIntegerGreaterOrEqual2(tcu::TestContext &testCtx, GLenum name, GLint reference0,
906 GLint reference1)
907 {
908 using tcu::TestLog;
909
910 StateQueryMemoryWriteGuard<GLfloat[2]> floatVector2;
911 glGetFloatv(name, floatVector2);
912
913 if (!floatVector2.verifyValidity(testCtx))
914 return;
915
916 if (floatVector2[0] < GLfloat(reference0) || floatVector2[1] < GLfloat(reference1))
917 {
918 testCtx.getLog() << TestLog::Message << "// ERROR: expected greater or equal to " << GLfloat(reference0) << ", "
919 << GLfloat(reference1) << "; got " << floatVector2[0] << ", " << floatVector2[1]
920 << TestLog::EndMessage;
921 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
922 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
923 }
924 }
925
verifyIntegerAnyOf(tcu::TestContext & testCtx,GLenum name,const GLint references[],size_t referencesLength)926 void GetFloatVerifier::verifyIntegerAnyOf(tcu::TestContext &testCtx, GLenum name, const GLint references[],
927 size_t referencesLength)
928 {
929 using tcu::TestLog;
930
931 StateQueryMemoryWriteGuard<GLfloat> state;
932 glGetFloatv(name, &state);
933
934 if (!state.verifyValidity(testCtx))
935 return;
936
937 for (size_t ndx = 0; ndx < referencesLength; ++ndx)
938 {
939 const GLfloat expectedGLState = GLfloat(references[ndx]);
940 DE_ASSERT(
941 references[ndx] ==
942 GLint(
943 expectedGLState)); // reference integer must have 1:1 mapping to float for this to work. Reference value is always such value in these tests
944
945 if (state == expectedGLState)
946 return;
947 }
948
949 testCtx.getLog() << TestLog::Message << "// ERROR: got " << state << TestLog::EndMessage;
950 if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
951 testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid float value");
952 }
953
verifyStencilMaskInitial(tcu::TestContext & testCtx,GLenum name,int stencilBits)954 void GetFloatVerifier::verifyStencilMaskInitial(tcu::TestContext &testCtx, GLenum name, int stencilBits)
955 {
956 // checking the mask bits with float doesn't make much sense because of conversion errors
957 // just verify that the value is greater or equal to the minimum value
958 const GLint reference = (1 << stencilBits) - 1;
959 verifyIntegerGreaterOrEqual(testCtx, name, reference);
960 }
961
962 } // namespace IntegerStateQueryVerifiers
963
964 namespace
965 {
966
967 using namespace IntegerStateQueryVerifiers;
968 using namespace deqp::gls::StateQueryUtil;
969
970 class ConstantMinimumValueTestCase : public ApiCase
971 {
972 public:
ConstantMinimumValueTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum targetName,GLint minValue)973 ConstantMinimumValueTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
974 GLenum targetName, GLint minValue)
975 : ApiCase(context, name, description)
976 , m_targetName(targetName)
977 , m_minValue(minValue)
978 , m_verifier(verifier)
979 {
980 }
981
test(void)982 void test(void)
983 {
984 m_verifier->verifyUnsignedIntegerGreaterOrEqual(m_testCtx, m_targetName, m_minValue);
985 expectError(GL_NO_ERROR);
986 }
987
988 private:
989 GLenum m_targetName;
990 GLint m_minValue;
991 StateVerifier *m_verifier;
992 };
993
994 class ConstantMaximumValueTestCase : public ApiCase
995 {
996 public:
ConstantMaximumValueTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum targetName,GLint minValue)997 ConstantMaximumValueTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
998 GLenum targetName, GLint minValue)
999 : ApiCase(context, name, description)
1000 , m_targetName(targetName)
1001 , m_minValue(minValue)
1002 , m_verifier(verifier)
1003 {
1004 }
1005
test(void)1006 void test(void)
1007 {
1008 m_verifier->verifyIntegerLessOrEqual(m_testCtx, m_targetName, m_minValue);
1009 expectError(GL_NO_ERROR);
1010 }
1011
1012 private:
1013 GLenum m_targetName;
1014 GLint m_minValue;
1015 StateVerifier *m_verifier;
1016 };
1017
1018 class SampleBuffersTestCase : public ApiCase
1019 {
1020 public:
SampleBuffersTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1021 SampleBuffersTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1022 : ApiCase(context, name, description)
1023 , m_verifier(verifier)
1024 {
1025 }
1026
test(void)1027 void test(void)
1028 {
1029 const int expectedSampleBuffers = (m_context.getRenderTarget().getNumSamples() > 1) ? 1 : 0;
1030
1031 m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples())
1032 << ", expecting GL_SAMPLE_BUFFERS to be " << expectedSampleBuffers << tcu::TestLog::EndMessage;
1033
1034 m_verifier->verifyInteger(m_testCtx, GL_SAMPLE_BUFFERS, expectedSampleBuffers);
1035 expectError(GL_NO_ERROR);
1036 }
1037
1038 private:
1039 StateVerifier *m_verifier;
1040 };
1041
1042 class SamplesTestCase : public ApiCase
1043 {
1044 public:
SamplesTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1045 SamplesTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1046 : ApiCase(context, name, description)
1047 , m_verifier(verifier)
1048 {
1049 }
1050
test(void)1051 void test(void)
1052 {
1053 // MSAA?
1054 if (m_context.getRenderTarget().getNumSamples() > 1)
1055 {
1056 m_log << tcu::TestLog::Message << "Sample count is " << (m_context.getRenderTarget().getNumSamples())
1057 << tcu::TestLog::EndMessage;
1058
1059 m_verifier->verifyInteger(m_testCtx, GL_SAMPLES, m_context.getRenderTarget().getNumSamples());
1060 expectError(GL_NO_ERROR);
1061 }
1062 else
1063 {
1064 const glw::GLint validSamples[] = {0, 1};
1065
1066 m_log << tcu::TestLog::Message << "Expecting GL_SAMPLES to be 0 or 1" << tcu::TestLog::EndMessage;
1067
1068 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_SAMPLES, validSamples, DE_LENGTH_OF_ARRAY(validSamples));
1069 expectError(GL_NO_ERROR);
1070 }
1071 }
1072
1073 private:
1074 StateVerifier *m_verifier;
1075 };
1076
1077 class HintTestCase : public ApiCase
1078 {
1079 public:
HintTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum targetName)1080 HintTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1081 GLenum targetName)
1082 : ApiCase(context, name, description)
1083 , m_targetName(targetName)
1084 , m_verifier(verifier)
1085 {
1086 }
1087
test(void)1088 void test(void)
1089 {
1090 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
1091 expectError(GL_NO_ERROR);
1092
1093 glHint(m_targetName, GL_NICEST);
1094 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_NICEST);
1095 expectError(GL_NO_ERROR);
1096
1097 glHint(m_targetName, GL_FASTEST);
1098 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_FASTEST);
1099 expectError(GL_NO_ERROR);
1100
1101 glHint(m_targetName, GL_DONT_CARE);
1102 m_verifier->verifyInteger(m_testCtx, m_targetName, GL_DONT_CARE);
1103 expectError(GL_NO_ERROR);
1104 }
1105
1106 private:
1107 GLenum m_targetName;
1108 StateVerifier *m_verifier;
1109 };
1110
1111 class DepthFuncTestCase : public ApiCase
1112 {
1113 public:
DepthFuncTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1114 DepthFuncTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1115 : ApiCase(context, name, description)
1116 , m_verifier(verifier)
1117 {
1118 }
1119
test(void)1120 void test(void)
1121 {
1122 m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, GL_LESS);
1123 expectError(GL_NO_ERROR);
1124
1125 const GLenum depthFunctions[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL,
1126 GL_EQUAL, GL_GREATER, GL_GEQUAL, GL_NOTEQUAL};
1127 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFunctions); ndx++)
1128 {
1129 glDepthFunc(depthFunctions[ndx]);
1130 expectError(GL_NO_ERROR);
1131
1132 m_verifier->verifyInteger(m_testCtx, GL_DEPTH_FUNC, depthFunctions[ndx]);
1133 expectError(GL_NO_ERROR);
1134 }
1135 }
1136
1137 private:
1138 StateVerifier *m_verifier;
1139 };
1140
1141 class CullFaceTestCase : public ApiCase
1142 {
1143 public:
CullFaceTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1144 CullFaceTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1145 : ApiCase(context, name, description)
1146 , m_verifier(verifier)
1147 {
1148 }
1149
test(void)1150 void test(void)
1151 {
1152 m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, GL_BACK);
1153 expectError(GL_NO_ERROR);
1154
1155 const GLenum cullFaces[] = {GL_FRONT, GL_BACK, GL_FRONT_AND_BACK};
1156 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cullFaces); ndx++)
1157 {
1158 glCullFace(cullFaces[ndx]);
1159 expectError(GL_NO_ERROR);
1160
1161 m_verifier->verifyInteger(m_testCtx, GL_CULL_FACE_MODE, cullFaces[ndx]);
1162 expectError(GL_NO_ERROR);
1163 }
1164 }
1165
1166 private:
1167 StateVerifier *m_verifier;
1168 };
1169
1170 class FrontFaceTestCase : public ApiCase
1171 {
1172 public:
FrontFaceTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1173 FrontFaceTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1174 : ApiCase(context, name, description)
1175 , m_verifier(verifier)
1176 {
1177 }
1178
test(void)1179 void test(void)
1180 {
1181 m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, GL_CCW);
1182 expectError(GL_NO_ERROR);
1183
1184 const GLenum frontFaces[] = {GL_CW, GL_CCW};
1185 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(frontFaces); ndx++)
1186 {
1187 glFrontFace(frontFaces[ndx]);
1188 expectError(GL_NO_ERROR);
1189
1190 m_verifier->verifyInteger(m_testCtx, GL_FRONT_FACE, frontFaces[ndx]);
1191 expectError(GL_NO_ERROR);
1192 }
1193 }
1194
1195 private:
1196 StateVerifier *m_verifier;
1197 };
1198
1199 class ViewPortTestCase : public ApiCase
1200 {
1201 public:
ViewPortTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1202 ViewPortTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1203 : ApiCase(context, name, description)
1204 , m_verifier(verifier)
1205 {
1206 }
1207
test(void)1208 void test(void)
1209 {
1210 de::Random rnd(0xabcdef);
1211
1212 GLint maxViewportDimensions[2] = {0};
1213 GLfloat viewportBoundsRange[2] = {0.0f};
1214 GLboolean hasViewportArray = false;
1215 glGetIntegerv(GL_MAX_VIEWPORT_DIMS, maxViewportDimensions);
1216 hasViewportArray = m_context.getContextInfo().isExtensionSupported("GL_OES_viewport_array") ||
1217 m_context.getContextInfo().isExtensionSupported("GL_NV_viewport_array") ||
1218 m_context.getContextInfo().isExtensionSupported("GL_ARB_viewport_array");
1219 if (hasViewportArray)
1220 {
1221 glGetFloatv(GL_VIEWPORT_BOUNDS_RANGE, viewportBoundsRange);
1222 }
1223
1224 // verify initial value of first two values
1225 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, 0, 0, m_context.getRenderTarget().getWidth(),
1226 m_context.getRenderTarget().getHeight());
1227 expectError(GL_NO_ERROR);
1228
1229 const int numIterations = 120;
1230 for (int i = 0; i < numIterations; ++i)
1231 {
1232 GLint x = rnd.getInt(-64000, 64000);
1233 GLint y = rnd.getInt(-64000, 64000);
1234 GLsizei width = rnd.getInt(0, maxViewportDimensions[0]);
1235 GLsizei height = rnd.getInt(0, maxViewportDimensions[1]);
1236
1237 glViewport(x, y, width, height);
1238
1239 if (hasViewportArray)
1240 {
1241 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT,
1242 de::clamp(x, deFloorFloatToInt32(viewportBoundsRange[0]),
1243 deFloorFloatToInt32(viewportBoundsRange[1])),
1244 de::clamp(y, deFloorFloatToInt32(viewportBoundsRange[0]),
1245 deFloorFloatToInt32(viewportBoundsRange[1])),
1246 width, height);
1247 }
1248 else
1249 {
1250 m_verifier->verifyInteger4(m_testCtx, GL_VIEWPORT, x, y, width, height);
1251 }
1252
1253 expectError(GL_NO_ERROR);
1254 }
1255 }
1256
1257 private:
1258 StateVerifier *m_verifier;
1259 };
1260
1261 class ScissorBoxTestCase : public ApiCase
1262 {
1263 public:
ScissorBoxTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1264 ScissorBoxTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1265 : ApiCase(context, name, description)
1266 , m_verifier(verifier)
1267 {
1268 }
1269
test(void)1270 void test(void)
1271 {
1272 de::Random rnd(0xabcdef);
1273
1274 // verify initial value of first two values
1275 m_verifier->verifyInteger4Mask(m_testCtx, GL_SCISSOR_BOX, 0, true, 0, true, 0, false, 0, false);
1276 expectError(GL_NO_ERROR);
1277
1278 const int numIterations = 120;
1279 for (int i = 0; i < numIterations; ++i)
1280 {
1281 GLint left = rnd.getInt(-64000, 64000);
1282 GLint bottom = rnd.getInt(-64000, 64000);
1283 GLsizei width = rnd.getInt(0, 64000);
1284 GLsizei height = rnd.getInt(0, 64000);
1285
1286 glScissor(left, bottom, width, height);
1287 m_verifier->verifyInteger4(m_testCtx, GL_SCISSOR_BOX, left, bottom, width, height);
1288 expectError(GL_NO_ERROR);
1289 }
1290 }
1291
1292 private:
1293 StateVerifier *m_verifier;
1294 };
1295
1296 class MaxViewportDimsTestCase : public ApiCase
1297 {
1298 public:
MaxViewportDimsTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1299 MaxViewportDimsTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1300 : ApiCase(context, name, description)
1301 , m_verifier(verifier)
1302 {
1303 }
1304
test(void)1305 void test(void)
1306 {
1307 m_verifier->verifyIntegerGreaterOrEqual2(m_testCtx, GL_MAX_VIEWPORT_DIMS,
1308 m_context.getRenderTarget().getWidth(),
1309 m_context.getRenderTarget().getHeight());
1310 expectError(GL_NO_ERROR);
1311 }
1312
1313 private:
1314 StateVerifier *m_verifier;
1315 };
1316
1317 class StencilRefTestCase : public ApiCase
1318 {
1319 public:
StencilRefTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName)1320 StencilRefTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1321 GLenum testTargetName)
1322 : ApiCase(context, name, description)
1323 , m_verifier(verifier)
1324 , m_testTargetName(testTargetName)
1325 {
1326 }
1327
test(void)1328 void test(void)
1329 {
1330 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
1331 expectError(GL_NO_ERROR);
1332
1333 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1334
1335 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1336 {
1337 const int ref = 1 << stencilBit;
1338
1339 glStencilFunc(GL_ALWAYS, ref, 0); // mask should not affect the REF
1340 expectError(GL_NO_ERROR);
1341
1342 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1343 expectError(GL_NO_ERROR);
1344
1345 glStencilFunc(GL_ALWAYS, ref, ref);
1346 expectError(GL_NO_ERROR);
1347
1348 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1349 expectError(GL_NO_ERROR);
1350 }
1351 }
1352
1353 private:
1354 StateVerifier *m_verifier;
1355 GLenum m_testTargetName;
1356 };
1357
1358 class StencilRefSeparateTestCase : public ApiCase
1359 {
1360 public:
StencilRefSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,GLenum stencilFuncTargetFace)1361 StencilRefSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1362 GLenum testTargetName, GLenum stencilFuncTargetFace)
1363 : ApiCase(context, name, description)
1364 , m_verifier(verifier)
1365 , m_testTargetName(testTargetName)
1366 , m_stencilFuncTargetFace(stencilFuncTargetFace)
1367 {
1368 }
1369
test(void)1370 void test(void)
1371 {
1372 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 0);
1373 expectError(GL_NO_ERROR);
1374
1375 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1376
1377 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1378 {
1379 const int ref = 1 << stencilBit;
1380
1381 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, 0);
1382 expectError(GL_NO_ERROR);
1383
1384 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1385 expectError(GL_NO_ERROR);
1386
1387 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, ref, ref);
1388 expectError(GL_NO_ERROR);
1389
1390 m_verifier->verifyInteger(m_testCtx, m_testTargetName, ref);
1391 expectError(GL_NO_ERROR);
1392 }
1393 }
1394
1395 private:
1396 StateVerifier *m_verifier;
1397 GLenum m_testTargetName;
1398 GLenum m_stencilFuncTargetFace;
1399 };
1400
1401 class StencilOpTestCase : public ApiCase
1402 {
1403 public:
StencilOpTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum stencilOpName)1404 StencilOpTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1405 GLenum stencilOpName)
1406 : ApiCase(context, name, description)
1407 , m_verifier(verifier)
1408 , m_stencilOpName(stencilOpName)
1409 {
1410 }
1411
test(void)1412 void test(void)
1413 {
1414 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, GL_KEEP);
1415 expectError(GL_NO_ERROR);
1416
1417 const GLenum stencilOpValues[] = {GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR,
1418 GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP};
1419
1420 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilOpValues); ++ndx)
1421 {
1422 SetStencilOp(stencilOpValues[ndx]);
1423 expectError(GL_NO_ERROR);
1424
1425 m_verifier->verifyInteger(m_testCtx, m_stencilOpName, stencilOpValues[ndx]);
1426 expectError(GL_NO_ERROR);
1427 }
1428 }
1429
1430 protected:
SetStencilOp(GLenum stencilOpValue)1431 virtual void SetStencilOp(GLenum stencilOpValue)
1432 {
1433 switch (m_stencilOpName)
1434 {
1435 case GL_STENCIL_FAIL:
1436 case GL_STENCIL_BACK_FAIL:
1437 glStencilOp(stencilOpValue, GL_KEEP, GL_KEEP);
1438 break;
1439
1440 case GL_STENCIL_PASS_DEPTH_FAIL:
1441 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1442 glStencilOp(GL_KEEP, stencilOpValue, GL_KEEP);
1443 break;
1444
1445 case GL_STENCIL_PASS_DEPTH_PASS:
1446 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1447 glStencilOp(GL_KEEP, GL_KEEP, stencilOpValue);
1448 break;
1449
1450 default:
1451 DE_ASSERT(false && "should not happen");
1452 break;
1453 }
1454 }
1455
1456 StateVerifier *m_verifier;
1457 GLenum m_stencilOpName;
1458 };
1459
1460 class StencilOpSeparateTestCase : public StencilOpTestCase
1461 {
1462 public:
StencilOpSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum stencilOpName,GLenum stencilOpFace)1463 StencilOpSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1464 GLenum stencilOpName, GLenum stencilOpFace)
1465 : StencilOpTestCase(context, verifier, name, description, stencilOpName)
1466 , m_stencilOpFace(stencilOpFace)
1467 {
1468 }
1469
1470 private:
SetStencilOp(GLenum stencilOpValue)1471 void SetStencilOp(GLenum stencilOpValue)
1472 {
1473 switch (m_stencilOpName)
1474 {
1475 case GL_STENCIL_FAIL:
1476 case GL_STENCIL_BACK_FAIL:
1477 glStencilOpSeparate(m_stencilOpFace, stencilOpValue, GL_KEEP, GL_KEEP);
1478 break;
1479
1480 case GL_STENCIL_PASS_DEPTH_FAIL:
1481 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
1482 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, stencilOpValue, GL_KEEP);
1483 break;
1484
1485 case GL_STENCIL_PASS_DEPTH_PASS:
1486 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
1487 glStencilOpSeparate(m_stencilOpFace, GL_KEEP, GL_KEEP, stencilOpValue);
1488 break;
1489
1490 default:
1491 DE_ASSERT(false && "should not happen");
1492 break;
1493 }
1494 }
1495
1496 GLenum m_stencilOpFace;
1497 };
1498
1499 class StencilFuncTestCase : public ApiCase
1500 {
1501 public:
StencilFuncTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)1502 StencilFuncTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
1503 : ApiCase(context, name, description)
1504 , m_verifier(verifier)
1505 {
1506 }
1507
test(void)1508 void test(void)
1509 {
1510 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, GL_ALWAYS);
1511 expectError(GL_NO_ERROR);
1512
1513 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL,
1514 GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1515
1516 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1517 {
1518 glStencilFunc(stencilfuncValues[ndx], 0, 0);
1519 expectError(GL_NO_ERROR);
1520
1521 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_FUNC, stencilfuncValues[ndx]);
1522 expectError(GL_NO_ERROR);
1523
1524 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_BACK_FUNC, stencilfuncValues[ndx]);
1525 expectError(GL_NO_ERROR);
1526 }
1527 }
1528
1529 private:
1530 StateVerifier *m_verifier;
1531 };
1532
1533 class StencilFuncSeparateTestCase : public ApiCase
1534 {
1535 public:
StencilFuncSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum stencilFuncName,GLenum stencilFuncFace)1536 StencilFuncSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1537 GLenum stencilFuncName, GLenum stencilFuncFace)
1538 : ApiCase(context, name, description)
1539 , m_verifier(verifier)
1540 , m_stencilFuncName(stencilFuncName)
1541 , m_stencilFuncFace(stencilFuncFace)
1542 {
1543 }
1544
test(void)1545 void test(void)
1546 {
1547 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, GL_ALWAYS);
1548 expectError(GL_NO_ERROR);
1549
1550 const GLenum stencilfuncValues[] = {GL_NEVER, GL_ALWAYS, GL_LESS, GL_LEQUAL,
1551 GL_EQUAL, GL_GEQUAL, GL_GREATER, GL_NOTEQUAL};
1552
1553 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(stencilfuncValues); ++ndx)
1554 {
1555 glStencilFuncSeparate(m_stencilFuncFace, stencilfuncValues[ndx], 0, 0);
1556 expectError(GL_NO_ERROR);
1557
1558 m_verifier->verifyInteger(m_testCtx, m_stencilFuncName, stencilfuncValues[ndx]);
1559 expectError(GL_NO_ERROR);
1560 }
1561 }
1562
1563 private:
1564 StateVerifier *m_verifier;
1565 GLenum m_stencilFuncName;
1566 GLenum m_stencilFuncFace;
1567 };
1568
1569 class StencilMaskTestCase : public ApiCase
1570 {
1571 public:
StencilMaskTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName)1572 StencilMaskTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1573 GLenum testTargetName)
1574 : ApiCase(context, name, description)
1575 , m_verifier(verifier)
1576 , m_testTargetName(testTargetName)
1577 {
1578 }
1579
test(void)1580 void test(void)
1581 {
1582 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1583
1584 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1585 expectError(GL_NO_ERROR);
1586
1587 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1588 {
1589 const int mask = 1 << stencilBit;
1590
1591 glStencilFunc(GL_ALWAYS, 0, mask);
1592 expectError(GL_NO_ERROR);
1593
1594 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1595 expectError(GL_NO_ERROR);
1596 }
1597 }
1598
1599 private:
1600 StateVerifier *m_verifier;
1601 GLenum m_testTargetName;
1602 };
1603
1604 class StencilMaskSeparateTestCase : public ApiCase
1605 {
1606 public:
StencilMaskSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,GLenum stencilFuncTargetFace)1607 StencilMaskSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1608 GLenum testTargetName, GLenum stencilFuncTargetFace)
1609 : ApiCase(context, name, description)
1610 , m_verifier(verifier)
1611 , m_testTargetName(testTargetName)
1612 , m_stencilFuncTargetFace(stencilFuncTargetFace)
1613 {
1614 }
1615
test(void)1616 void test(void)
1617 {
1618 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1619
1620 m_verifier->verifyStencilMaskInitial(m_testCtx, m_testTargetName, stencilBits);
1621 expectError(GL_NO_ERROR);
1622
1623 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1624 {
1625 const int mask = 1 << stencilBit;
1626
1627 glStencilFuncSeparate(m_stencilFuncTargetFace, GL_ALWAYS, 0, mask);
1628 expectError(GL_NO_ERROR);
1629
1630 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1631 expectError(GL_NO_ERROR);
1632 }
1633 }
1634
1635 private:
1636 StateVerifier *m_verifier;
1637 GLenum m_testTargetName;
1638 GLenum m_stencilFuncTargetFace;
1639 };
1640
1641 class StencilWriteMaskTestCase : public ApiCase
1642 {
1643 public:
StencilWriteMaskTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName)1644 StencilWriteMaskTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1645 GLenum testTargetName)
1646 : ApiCase(context, name, description)
1647 , m_verifier(verifier)
1648 , m_testTargetName(testTargetName)
1649 {
1650 }
1651
test(void)1652 void test(void)
1653 {
1654 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1655
1656 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1657 {
1658 const int mask = 1 << stencilBit;
1659
1660 glStencilMask(mask);
1661 expectError(GL_NO_ERROR);
1662
1663 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1664 expectError(GL_NO_ERROR);
1665 }
1666 }
1667
1668 private:
1669 StateVerifier *m_verifier;
1670 GLenum m_testTargetName;
1671 };
1672
1673 class StencilWriteMaskSeparateTestCase : public ApiCase
1674 {
1675 public:
StencilWriteMaskSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,GLenum stencilTargetFace)1676 StencilWriteMaskSeparateTestCase(Context &context, StateVerifier *verifier, const char *name,
1677 const char *description, GLenum testTargetName, GLenum stencilTargetFace)
1678 : ApiCase(context, name, description)
1679 , m_verifier(verifier)
1680 , m_testTargetName(testTargetName)
1681 , m_stencilTargetFace(stencilTargetFace)
1682 {
1683 }
1684
test(void)1685 void test(void)
1686 {
1687 const int stencilBits = m_context.getRenderTarget().getStencilBits();
1688
1689 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
1690 {
1691 const int mask = 1 << stencilBit;
1692
1693 glStencilMaskSeparate(m_stencilTargetFace, mask);
1694 expectError(GL_NO_ERROR);
1695
1696 m_verifier->verifyInteger(m_testCtx, m_testTargetName, mask);
1697 expectError(GL_NO_ERROR);
1698 }
1699 }
1700
1701 private:
1702 StateVerifier *m_verifier;
1703 GLenum m_testTargetName;
1704 GLenum m_stencilTargetFace;
1705 };
1706
1707 class PixelStoreTestCase : public ApiCase
1708 {
1709 public:
PixelStoreTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,int initialValue)1710 PixelStoreTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1711 GLenum testTargetName, int initialValue)
1712 : ApiCase(context, name, description)
1713 , m_verifier(verifier)
1714 , m_testTargetName(testTargetName)
1715 , m_initialValue(initialValue)
1716 {
1717 }
1718
test(void)1719 void test(void)
1720 {
1721 de::Random rnd(0xabcdef);
1722
1723 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1724 expectError(GL_NO_ERROR);
1725
1726 const int numIterations = 120;
1727 for (int i = 0; i < numIterations; ++i)
1728 {
1729 const int referenceValue = rnd.getInt(0, 64000);
1730
1731 glPixelStorei(m_testTargetName, referenceValue);
1732 expectError(GL_NO_ERROR);
1733
1734 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1735 expectError(GL_NO_ERROR);
1736 }
1737 }
1738
1739 private:
1740 StateVerifier *m_verifier;
1741 GLenum m_testTargetName;
1742 int m_initialValue;
1743 };
1744
1745 class PixelStoreAlignTestCase : public ApiCase
1746 {
1747 public:
PixelStoreAlignTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName)1748 PixelStoreAlignTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1749 GLenum testTargetName)
1750 : ApiCase(context, name, description)
1751 , m_verifier(verifier)
1752 , m_testTargetName(testTargetName)
1753 {
1754 }
1755
test(void)1756 void test(void)
1757 {
1758 m_verifier->verifyInteger(m_testCtx, m_testTargetName, 4);
1759 expectError(GL_NO_ERROR);
1760
1761 const int alignments[] = {1, 2, 4, 8};
1762
1763 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(alignments); ++ndx)
1764 {
1765 const int referenceValue = alignments[ndx];
1766
1767 glPixelStorei(m_testTargetName, referenceValue);
1768 expectError(GL_NO_ERROR);
1769
1770 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1771 expectError(GL_NO_ERROR);
1772 }
1773 }
1774
1775 private:
1776 StateVerifier *m_verifier;
1777 GLenum m_testTargetName;
1778 };
1779
1780 class BlendFuncTestCase : public ApiCase
1781 {
1782 public:
BlendFuncTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,int initialValue)1783 BlendFuncTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1784 GLenum testTargetName, int initialValue)
1785 : ApiCase(context, name, description)
1786 , m_verifier(verifier)
1787 , m_testTargetName(testTargetName)
1788 , m_initialValue(initialValue)
1789 {
1790 }
1791
test(void)1792 void test(void)
1793 {
1794 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1795 expectError(GL_NO_ERROR);
1796
1797 const GLenum blendFuncValues[] = {GL_ZERO,
1798 GL_ONE,
1799 GL_SRC_COLOR,
1800 GL_ONE_MINUS_SRC_COLOR,
1801 GL_DST_COLOR,
1802 GL_ONE_MINUS_DST_COLOR,
1803 GL_SRC_ALPHA,
1804 GL_ONE_MINUS_SRC_ALPHA,
1805 GL_DST_ALPHA,
1806 GL_ONE_MINUS_DST_ALPHA,
1807 GL_CONSTANT_COLOR,
1808 GL_ONE_MINUS_CONSTANT_COLOR,
1809 GL_CONSTANT_ALPHA,
1810 GL_ONE_MINUS_CONSTANT_ALPHA,
1811 GL_SRC_ALPHA_SATURATE};
1812
1813 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1814 {
1815 const GLenum referenceValue = blendFuncValues[ndx];
1816
1817 SetBlendFunc(referenceValue);
1818 expectError(GL_NO_ERROR);
1819
1820 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1821 expectError(GL_NO_ERROR);
1822 }
1823 }
1824
1825 protected:
SetBlendFunc(GLenum func)1826 virtual void SetBlendFunc(GLenum func)
1827 {
1828 switch (m_testTargetName)
1829 {
1830 case GL_BLEND_SRC_RGB:
1831 case GL_BLEND_SRC_ALPHA:
1832 glBlendFunc(func, GL_ZERO);
1833 break;
1834
1835 case GL_BLEND_DST_RGB:
1836 case GL_BLEND_DST_ALPHA:
1837 glBlendFunc(GL_ZERO, func);
1838 break;
1839
1840 default:
1841 DE_ASSERT(false && "should not happen");
1842 break;
1843 }
1844 }
1845
1846 StateVerifier *m_verifier;
1847 GLenum m_testTargetName;
1848 int m_initialValue;
1849 };
1850
1851 class BlendFuncSeparateTestCase : public BlendFuncTestCase
1852 {
1853 public:
BlendFuncSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,int initialValue)1854 BlendFuncSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1855 GLenum testTargetName, int initialValue)
1856 : BlendFuncTestCase(context, verifier, name, description, testTargetName, initialValue)
1857 {
1858 }
1859
SetBlendFunc(GLenum func)1860 void SetBlendFunc(GLenum func)
1861 {
1862 switch (m_testTargetName)
1863 {
1864 case GL_BLEND_SRC_RGB:
1865 glBlendFuncSeparate(func, GL_ZERO, GL_ZERO, GL_ZERO);
1866 break;
1867
1868 case GL_BLEND_DST_RGB:
1869 glBlendFuncSeparate(GL_ZERO, func, GL_ZERO, GL_ZERO);
1870 break;
1871
1872 case GL_BLEND_SRC_ALPHA:
1873 glBlendFuncSeparate(GL_ZERO, GL_ZERO, func, GL_ZERO);
1874 break;
1875
1876 case GL_BLEND_DST_ALPHA:
1877 glBlendFuncSeparate(GL_ZERO, GL_ZERO, GL_ZERO, func);
1878 break;
1879
1880 default:
1881 DE_ASSERT(false && "should not happen");
1882 break;
1883 }
1884 }
1885 };
1886
1887 class BlendEquationTestCase : public ApiCase
1888 {
1889 public:
BlendEquationTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,int initialValue)1890 BlendEquationTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1891 GLenum testTargetName, int initialValue)
1892 : ApiCase(context, name, description)
1893 , m_verifier(verifier)
1894 , m_testTargetName(testTargetName)
1895 , m_initialValue(initialValue)
1896 {
1897 }
1898
test(void)1899 void test(void)
1900 {
1901 m_verifier->verifyInteger(m_testCtx, m_testTargetName, m_initialValue);
1902 expectError(GL_NO_ERROR);
1903
1904 const GLenum blendFuncValues[] = {GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX};
1905
1906 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(blendFuncValues); ++ndx)
1907 {
1908 const GLenum referenceValue = blendFuncValues[ndx];
1909
1910 SetBlendEquation(referenceValue);
1911 expectError(GL_NO_ERROR);
1912
1913 m_verifier->verifyInteger(m_testCtx, m_testTargetName, referenceValue);
1914 expectError(GL_NO_ERROR);
1915 }
1916 }
1917
1918 protected:
SetBlendEquation(GLenum equation)1919 virtual void SetBlendEquation(GLenum equation)
1920 {
1921 glBlendEquation(equation);
1922 }
1923
1924 StateVerifier *m_verifier;
1925 GLenum m_testTargetName;
1926 int m_initialValue;
1927 };
1928 class BlendEquationSeparateTestCase : public BlendEquationTestCase
1929 {
1930 public:
BlendEquationSeparateTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,int initialValue)1931 BlendEquationSeparateTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1932 GLenum testTargetName, int initialValue)
1933 : BlendEquationTestCase(context, verifier, name, description, testTargetName, initialValue)
1934 {
1935 }
1936
1937 protected:
SetBlendEquation(GLenum equation)1938 void SetBlendEquation(GLenum equation)
1939 {
1940 switch (m_testTargetName)
1941 {
1942 case GL_BLEND_EQUATION_RGB:
1943 glBlendEquationSeparate(equation, GL_FUNC_ADD);
1944 break;
1945
1946 case GL_BLEND_EQUATION_ALPHA:
1947 glBlendEquationSeparate(GL_FUNC_ADD, equation);
1948 break;
1949
1950 default:
1951 DE_ASSERT(false && "should not happen");
1952 break;
1953 }
1954 }
1955 };
1956
1957 class ImplementationArrayTestCase : public ApiCase
1958 {
1959 public:
ImplementationArrayTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description,GLenum testTargetName,GLenum testTargetLengthTargetName,int minValue)1960 ImplementationArrayTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description,
1961 GLenum testTargetName, GLenum testTargetLengthTargetName, int minValue)
1962 : ApiCase(context, name, description)
1963 , m_verifier(verifier)
1964 , m_testTargetName(testTargetName)
1965 , m_testTargetLengthTargetName(testTargetLengthTargetName)
1966 , m_minValue(minValue)
1967 {
1968 }
1969
test(void)1970 void test(void)
1971 {
1972 m_verifier->verifyIntegerGreaterOrEqual(m_testCtx, m_testTargetLengthTargetName, m_minValue);
1973 expectError(GL_NO_ERROR);
1974
1975 GLint targetArrayLength = 0;
1976 glGetIntegerv(m_testTargetLengthTargetName, &targetArrayLength);
1977 expectError(GL_NO_ERROR);
1978
1979 if (targetArrayLength)
1980 {
1981 std::vector<GLint> queryResult;
1982 queryResult.resize(targetArrayLength, 0);
1983
1984 glGetIntegerv(m_testTargetName, &queryResult[0]);
1985 expectError(GL_NO_ERROR);
1986 }
1987 }
1988
1989 private:
1990 StateVerifier *m_verifier;
1991 GLenum m_testTargetName;
1992 GLenum m_testTargetLengthTargetName;
1993 int m_minValue;
1994 };
1995
1996 class BindingTest : public TestCase
1997 {
1998 public:
1999 BindingTest(Context &context, const char *name, const char *desc, QueryType type);
2000
2001 IterateResult iterate(void);
2002
2003 virtual void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const = 0;
2004
2005 protected:
2006 const QueryType m_type;
2007 };
2008
BindingTest(Context & context,const char * name,const char * desc,QueryType type)2009 BindingTest::BindingTest(Context &context, const char *name, const char *desc, QueryType type)
2010 : TestCase(context, name, desc)
2011 , m_type(type)
2012 {
2013 }
2014
iterate(void)2015 BindingTest::IterateResult BindingTest::iterate(void)
2016 {
2017 glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2018 tcu::ResultCollector result(m_context.getTestContext().getLog(), " // ERROR: ");
2019
2020 gl.enableLogging(true);
2021
2022 test(gl, result);
2023
2024 result.setTestContextResult(m_testCtx);
2025 return STOP;
2026 }
2027
2028 class TransformFeedbackBindingTestCase : public BindingTest
2029 {
2030 public:
TransformFeedbackBindingTestCase(Context & context,QueryType type,const char * name)2031 TransformFeedbackBindingTestCase(Context &context, QueryType type, const char *name)
2032 : BindingTest(context, name, "GL_TRANSFORM_FEEDBACK_BINDING", type)
2033 {
2034 }
2035
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2036 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2037 {
2038 static const char *transformFeedbackTestVertSource = "#version 300 es\n"
2039 "void main (void)\n"
2040 "{\n"
2041 " gl_Position = vec4(0.0);\n"
2042 "}\n\0";
2043 static const char *transformFeedbackTestFragSource = "#version 300 es\n"
2044 "layout(location = 0) out mediump vec4 fragColor;"
2045 "void main (void)\n"
2046 "{\n"
2047 " fragColor = vec4(0.0);\n"
2048 "}\n\0";
2049
2050 GLuint shaderVert;
2051 GLuint shaderFrag;
2052 GLuint shaderProg;
2053 GLuint transformfeedback = 0;
2054 GLuint feedbackBufferId = 0;
2055
2056 {
2057 const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial");
2058 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type);
2059 }
2060
2061 gl.glGenTransformFeedbacks(1, &transformfeedback);
2062 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTransformFeedbacks");
2063
2064 {
2065 const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader");
2066
2067 GLint compileStatus = -1;
2068
2069 shaderVert = gl.glCreateShader(GL_VERTEX_SHADER);
2070 gl.glShaderSource(shaderVert, 1, &transformFeedbackTestVertSource, DE_NULL);
2071 gl.glCompileShader(shaderVert);
2072 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2073
2074 gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
2075 if (compileStatus != GL_TRUE)
2076 result.fail("expected GL_TRUE");
2077 }
2078 {
2079 const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader");
2080
2081 GLint compileStatus = -1;
2082
2083 shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER);
2084 gl.glShaderSource(shaderFrag, 1, &transformFeedbackTestFragSource, DE_NULL);
2085 gl.glCompileShader(shaderFrag);
2086 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2087
2088 gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
2089 if (compileStatus != GL_TRUE)
2090 result.fail("expected GL_TRUE");
2091 }
2092 {
2093 const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program");
2094
2095 const char *transform_feedback_outputs = "gl_Position";
2096 GLint linkStatus = -1;
2097
2098 shaderProg = gl.glCreateProgram();
2099 gl.glAttachShader(shaderProg, shaderVert);
2100 gl.glAttachShader(shaderProg, shaderFrag);
2101 gl.glTransformFeedbackVaryings(shaderProg, 1, &transform_feedback_outputs, GL_INTERLEAVED_ATTRIBS);
2102 gl.glLinkProgram(shaderProg);
2103 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram");
2104
2105 gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
2106 if (linkStatus != GL_TRUE)
2107 result.fail("expected GL_TRUE");
2108 }
2109
2110 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformfeedback);
2111 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTransformFeedback");
2112
2113 gl.glGenBuffers(1, &feedbackBufferId);
2114 gl.glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, feedbackBufferId);
2115 gl.glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 16, NULL, GL_DYNAMIC_READ);
2116 gl.glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, feedbackBufferId);
2117 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind buffers");
2118
2119 gl.glUseProgram(shaderProg);
2120
2121 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, transformfeedback, m_type);
2122
2123 gl.glUseProgram(0);
2124 gl.glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
2125 gl.glDeleteTransformFeedbacks(1, &transformfeedback);
2126
2127 verifyStateInteger(result, gl, GL_TRANSFORM_FEEDBACK_BINDING, 0, m_type);
2128
2129 gl.glDeleteBuffers(1, &feedbackBufferId);
2130 gl.glDeleteShader(shaderVert);
2131 gl.glDeleteShader(shaderFrag);
2132 gl.glDeleteProgram(shaderProg);
2133 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram");
2134 }
2135 };
2136
2137 class CurrentProgramBindingTestCase : public BindingTest
2138 {
2139 public:
CurrentProgramBindingTestCase(Context & context,QueryType type,const char * name,const char * description)2140 CurrentProgramBindingTestCase(Context &context, QueryType type, const char *name, const char *description)
2141 : BindingTest(context, name, description, type)
2142 {
2143 }
2144
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2145 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2146 {
2147 static const char *testVertSource = "#version 300 es\n"
2148 "void main (void)\n"
2149 "{\n"
2150 " gl_Position = vec4(0.0);\n"
2151 "}\n\0";
2152 static const char *testFragSource = "#version 300 es\n"
2153 "layout(location = 0) out mediump vec4 fragColor;"
2154 "void main (void)\n"
2155 "{\n"
2156 " fragColor = vec4(0.0);\n"
2157 "}\n\0";
2158
2159 GLuint shaderVert;
2160 GLuint shaderFrag;
2161 GLuint shaderProg;
2162
2163 {
2164 const tcu::ScopedLogSection section(gl.getLog(), "Initial", "Initial");
2165
2166 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
2167 }
2168 {
2169 const tcu::ScopedLogSection section(gl.getLog(), "VertexShader", "Vertex Shader");
2170
2171 GLint compileStatus = -1;
2172
2173 shaderVert = gl.glCreateShader(GL_VERTEX_SHADER);
2174 gl.glShaderSource(shaderVert, 1, &testVertSource, DE_NULL);
2175 gl.glCompileShader(shaderVert);
2176 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2177
2178 gl.glGetShaderiv(shaderVert, GL_COMPILE_STATUS, &compileStatus);
2179 if (compileStatus != GL_TRUE)
2180 result.fail("expected GL_TRUE");
2181 }
2182 {
2183 const tcu::ScopedLogSection section(gl.getLog(), "FragmentShader", "Fragment Shader");
2184
2185 GLint compileStatus = -1;
2186
2187 shaderFrag = gl.glCreateShader(GL_FRAGMENT_SHADER);
2188 gl.glShaderSource(shaderFrag, 1, &testFragSource, DE_NULL);
2189 gl.glCompileShader(shaderFrag);
2190 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glCompileShader");
2191
2192 gl.glGetShaderiv(shaderFrag, GL_COMPILE_STATUS, &compileStatus);
2193 if (compileStatus != GL_TRUE)
2194 result.fail("expected GL_TRUE");
2195 }
2196 {
2197 const tcu::ScopedLogSection section(gl.getLog(), "Program", "Create and bind program");
2198
2199 GLint linkStatus = -1;
2200
2201 shaderProg = gl.glCreateProgram();
2202 gl.glAttachShader(shaderProg, shaderVert);
2203 gl.glAttachShader(shaderProg, shaderFrag);
2204 gl.glLinkProgram(shaderProg);
2205 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glLinkProgram");
2206
2207 gl.glGetProgramiv(shaderProg, GL_LINK_STATUS, &linkStatus);
2208 if (linkStatus != GL_TRUE)
2209 result.fail("expected GL_TRUE");
2210
2211 gl.glUseProgram(shaderProg);
2212 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
2213
2214 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
2215 }
2216 {
2217 const tcu::ScopedLogSection section(gl.getLog(), "Delete", "Delete program while in use");
2218
2219 gl.glDeleteShader(shaderVert);
2220 gl.glDeleteShader(shaderFrag);
2221 gl.glDeleteProgram(shaderProg);
2222 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteProgram");
2223
2224 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, shaderProg, m_type);
2225 }
2226 {
2227 const tcu::ScopedLogSection section(gl.getLog(), "Unbind", "Unbind program");
2228 gl.glUseProgram(0);
2229 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glUseProgram");
2230
2231 verifyStateInteger(result, gl, GL_CURRENT_PROGRAM, 0, m_type);
2232 }
2233 }
2234 };
2235
2236 class VertexArrayBindingTestCase : public BindingTest
2237 {
2238 public:
VertexArrayBindingTestCase(Context & context,QueryType type,const char * name,const char * description)2239 VertexArrayBindingTestCase(Context &context, QueryType type, const char *name, const char *description)
2240 : BindingTest(context, name, description, type)
2241 {
2242 }
2243
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2244 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2245 {
2246 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type);
2247
2248 GLuint vertexArrayObject = 0;
2249 gl.glGenVertexArrays(1, &vertexArrayObject);
2250 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays");
2251
2252 gl.glBindVertexArray(vertexArrayObject);
2253 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, vertexArrayObject, m_type);
2254
2255 gl.glDeleteVertexArrays(1, &vertexArrayObject);
2256 verifyStateInteger(result, gl, GL_VERTEX_ARRAY_BINDING, 0, m_type);
2257 }
2258 };
2259
2260 class BufferBindingTestCase : public BindingTest
2261 {
2262 public:
BufferBindingTestCase(Context & context,QueryType type,const char * name,const char * description,GLenum bufferBindingName,GLenum bufferType)2263 BufferBindingTestCase(Context &context, QueryType type, const char *name, const char *description,
2264 GLenum bufferBindingName, GLenum bufferType)
2265 : BindingTest(context, name, description, type)
2266 , m_bufferBindingName(bufferBindingName)
2267 , m_bufferType(bufferType)
2268 {
2269 }
2270
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2271 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2272 {
2273 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
2274
2275 GLuint bufferObject = 0;
2276 gl.glGenBuffers(1, &bufferObject);
2277 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2278
2279 gl.glBindBuffer(m_bufferType, bufferObject);
2280 verifyStateInteger(result, gl, m_bufferBindingName, bufferObject, m_type);
2281
2282 gl.glDeleteBuffers(1, &bufferObject);
2283 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteBuffers");
2284
2285 verifyStateInteger(result, gl, m_bufferBindingName, 0, m_type);
2286 }
2287
2288 private:
2289 const GLenum m_bufferBindingName;
2290 const GLenum m_bufferType;
2291 };
2292
2293 class ElementArrayBufferBindingTestCase : public BindingTest
2294 {
2295 public:
ElementArrayBufferBindingTestCase(Context & context,QueryType type,const char * name)2296 ElementArrayBufferBindingTestCase(Context &context, QueryType type, const char *name)
2297 : BindingTest(context, name, "GL_ELEMENT_ARRAY_BUFFER_BINDING", type)
2298 {
2299 }
2300
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2301 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2302 {
2303 // Test with default VAO
2304 {
2305 const tcu::ScopedLogSection section(gl.getLog(), "DefaultVAO", "Test with default VAO");
2306
2307 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2308
2309 GLuint bufferObject = 0;
2310 gl.glGenBuffers(1, &bufferObject);
2311 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2312
2313 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferObject);
2314 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, bufferObject, m_type);
2315
2316 gl.glDeleteBuffers(1, &bufferObject);
2317 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2318 }
2319
2320 // Test with multiple VAOs
2321 {
2322 const tcu::ScopedLogSection section(gl.getLog(), "WithVAO", "Test with VAO");
2323
2324 GLuint vaos[2] = {0};
2325 GLuint buffers[2] = {0};
2326
2327 gl.glGenVertexArrays(2, vaos);
2328 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenVertexArrays");
2329
2330 gl.glGenBuffers(2, buffers);
2331 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenBuffers");
2332
2333 // initial
2334 gl.glBindVertexArray(vaos[0]);
2335 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2336
2337 // after setting
2338 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[0]);
2339 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type);
2340
2341 // initial of vao 2
2342 gl.glBindVertexArray(vaos[1]);
2343 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2344
2345 // after setting to 2
2346 gl.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[1]);
2347 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type);
2348
2349 // vao 1 still has buffer 1 bound?
2350 gl.glBindVertexArray(vaos[0]);
2351 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[0], m_type);
2352
2353 // deleting clears from bound vaos ...
2354 gl.glDeleteBuffers(2, buffers);
2355 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, 0, m_type);
2356
2357 // ... but does not from non-bound vaos?
2358 gl.glBindVertexArray(vaos[1]);
2359 verifyStateInteger(result, gl, GL_ELEMENT_ARRAY_BUFFER_BINDING, buffers[1], m_type);
2360
2361 gl.glDeleteVertexArrays(2, vaos);
2362 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteVertexArrays");
2363 }
2364 }
2365 };
2366
2367 class StencilClearValueTestCase : public ApiCase
2368 {
2369 public:
StencilClearValueTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)2370 StencilClearValueTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
2371 : ApiCase(context, name, description)
2372 , m_verifier(verifier)
2373 {
2374 }
2375
test(void)2376 void test(void)
2377 {
2378 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, 0);
2379 expectError(GL_NO_ERROR);
2380
2381 const int stencilBits = m_context.getRenderTarget().getStencilBits();
2382
2383 for (int stencilBit = 0; stencilBit < stencilBits; ++stencilBit)
2384 {
2385 const int ref = 1 << stencilBit;
2386
2387 glClearStencil(ref); // mask should not affect the REF
2388 expectError(GL_NO_ERROR);
2389
2390 m_verifier->verifyInteger(m_testCtx, GL_STENCIL_CLEAR_VALUE, ref);
2391 expectError(GL_NO_ERROR);
2392 }
2393 }
2394
2395 private:
2396 StateVerifier *m_verifier;
2397 };
2398
2399 class ActiveTextureTestCase : public ApiCase
2400 {
2401 public:
ActiveTextureTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)2402 ActiveTextureTestCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
2403 : ApiCase(context, name, description)
2404 , m_verifier(verifier)
2405 {
2406 }
2407
test(void)2408 void test(void)
2409 {
2410 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0);
2411 expectError(GL_NO_ERROR);
2412
2413 GLint textureUnits = 0;
2414 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &textureUnits);
2415 expectError(GL_NO_ERROR);
2416
2417 for (int ndx = 0; ndx < textureUnits; ++ndx)
2418 {
2419 glActiveTexture(GL_TEXTURE0 + ndx);
2420 expectError(GL_NO_ERROR);
2421
2422 m_verifier->verifyInteger(m_testCtx, GL_ACTIVE_TEXTURE, GL_TEXTURE0 + ndx);
2423 expectError(GL_NO_ERROR);
2424 }
2425 }
2426
2427 private:
2428 StateVerifier *m_verifier;
2429 };
2430
2431 class RenderbufferBindingTestCase : public BindingTest
2432 {
2433 public:
RenderbufferBindingTestCase(Context & context,QueryType type,const char * name,const char * description)2434 RenderbufferBindingTestCase(Context &context, QueryType type, const char *name, const char *description)
2435 : BindingTest(context, name, description, type)
2436 {
2437 }
2438
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2439 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2440 {
2441 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
2442
2443 GLuint renderBuffer = 0;
2444 gl.glGenRenderbuffers(1, &renderBuffer);
2445 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenRenderbuffers");
2446
2447 gl.glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);
2448 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindRenderbuffer");
2449
2450 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, renderBuffer, m_type);
2451
2452 gl.glDeleteRenderbuffers(1, &renderBuffer);
2453 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteRenderbuffers");
2454
2455 verifyStateInteger(result, gl, GL_RENDERBUFFER_BINDING, 0, m_type);
2456 }
2457 };
2458
2459 class SamplerObjectBindingTestCase : public BindingTest
2460 {
2461 public:
SamplerObjectBindingTestCase(Context & context,QueryType type,const char * name,const char * description)2462 SamplerObjectBindingTestCase(Context &context, QueryType type, const char *name, const char *description)
2463 : BindingTest(context, name, description, type)
2464 {
2465 }
2466
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2467 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2468 {
2469 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2470
2471 {
2472 const tcu::ScopedLogSection section(gl.getLog(), "SingleUnit", "Single unit");
2473
2474 GLuint sampler = 0;
2475 gl.glGenSamplers(1, &sampler);
2476 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers");
2477
2478 gl.glBindSampler(0, sampler);
2479 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler");
2480
2481 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, sampler, m_type);
2482
2483 gl.glDeleteSamplers(1, &sampler);
2484 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2485 }
2486
2487 {
2488 const tcu::ScopedLogSection section(gl.getLog(), "MultipleUnits", "Multiple units");
2489
2490 GLuint samplerA = 0;
2491 GLuint samplerB = 0;
2492 gl.glGenSamplers(1, &samplerA);
2493 gl.glGenSamplers(1, &samplerB);
2494 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenSamplers");
2495
2496 gl.glBindSampler(1, samplerA);
2497 gl.glBindSampler(2, samplerB);
2498 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindSampler");
2499
2500 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, 0, m_type);
2501
2502 gl.glActiveTexture(GL_TEXTURE1);
2503 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerA, m_type);
2504
2505 gl.glActiveTexture(GL_TEXTURE2);
2506 verifyStateInteger(result, gl, GL_SAMPLER_BINDING, samplerB, m_type);
2507
2508 gl.glDeleteSamplers(1, &samplerB);
2509 gl.glDeleteSamplers(1, &samplerA);
2510 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteSamplers");
2511 }
2512 }
2513 };
2514
2515 class TextureBindingTestCase : public BindingTest
2516 {
2517 public:
TextureBindingTestCase(Context & context,QueryType type,const char * name,const char * description,GLenum testBindingName,GLenum textureType)2518 TextureBindingTestCase(Context &context, QueryType type, const char *name, const char *description,
2519 GLenum testBindingName, GLenum textureType)
2520 : BindingTest(context, name, description, type)
2521 , m_testBindingName(testBindingName)
2522 , m_textureType(textureType)
2523 {
2524 }
2525
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2526 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2527 {
2528 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
2529
2530 GLuint texture = 0;
2531 gl.glGenTextures(1, &texture);
2532 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenTextures");
2533
2534 gl.glBindTexture(m_textureType, texture);
2535 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");
2536
2537 verifyStateInteger(result, gl, m_testBindingName, texture, m_type);
2538
2539 gl.glDeleteTextures(1, &texture);
2540 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
2541
2542 verifyStateInteger(result, gl, m_testBindingName, 0, m_type);
2543 }
2544
2545 private:
2546 const GLenum m_testBindingName;
2547 const GLenum m_textureType;
2548 };
2549
2550 class FrameBufferBindingTestCase : public BindingTest
2551 {
2552 public:
FrameBufferBindingTestCase(Context & context,QueryType type,const char * name,const char * description)2553 FrameBufferBindingTestCase(Context &context, QueryType type, const char *name, const char *description)
2554 : BindingTest(context, name, description, type)
2555 {
2556 }
2557
test(glu::CallLogWrapper & gl,tcu::ResultCollector & result) const2558 void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
2559 {
2560 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type);
2561 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
2562 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, 0, m_type);
2563
2564 GLuint framebufferId = 0;
2565 gl.glGenFramebuffers(1, &framebufferId);
2566 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glGenFramebuffers");
2567
2568 gl.glBindFramebuffer(GL_FRAMEBUFFER, framebufferId);
2569 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_FRAMEBUFFER");
2570
2571 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, framebufferId, m_type);
2572 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, framebufferId, m_type);
2573 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, framebufferId, m_type);
2574
2575 gl.glBindFramebuffer(GL_FRAMEBUFFER, 0);
2576 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "unbind GL_FRAMEBUFFER");
2577
2578 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type);
2579 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
2580 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, 0, m_type);
2581
2582 gl.glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId);
2583 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_READ_FRAMEBUFFER");
2584
2585 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type);
2586 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
2587 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, framebufferId, m_type);
2588
2589 gl.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId);
2590 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind GL_DRAW_FRAMEBUFFER");
2591
2592 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, framebufferId, m_type);
2593 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, framebufferId, m_type);
2594 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, framebufferId, m_type);
2595
2596 gl.glDeleteFramebuffers(1, &framebufferId);
2597 GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteFramebuffers");
2598
2599 verifyStateInteger(result, gl, GL_DRAW_FRAMEBUFFER_BINDING, 0, m_type);
2600 verifyStateInteger(result, gl, GL_FRAMEBUFFER_BINDING, 0, m_type);
2601 verifyStateInteger(result, gl, GL_READ_FRAMEBUFFER_BINDING, 0, m_type);
2602 }
2603 };
2604
2605 class ImplementationColorReadTestCase : public ApiCase
2606 {
2607 public:
ImplementationColorReadTestCase(Context & context,StateVerifier * verifier,const char * name,const char * description)2608 ImplementationColorReadTestCase(Context &context, StateVerifier *verifier, const char *name,
2609 const char *description)
2610 : ApiCase(context, name, description)
2611 , m_verifier(verifier)
2612 {
2613 }
2614
test(void)2615 void test(void)
2616 {
2617 const GLint defaultColorTypes[] = {GL_UNSIGNED_BYTE,
2618 GL_BYTE,
2619 GL_UNSIGNED_SHORT,
2620 GL_SHORT,
2621 GL_UNSIGNED_INT,
2622 GL_INT,
2623 GL_HALF_FLOAT,
2624 GL_FLOAT,
2625 GL_UNSIGNED_SHORT_5_6_5,
2626 GL_UNSIGNED_SHORT_4_4_4_4,
2627 GL_UNSIGNED_SHORT_5_5_5_1,
2628 GL_UNSIGNED_INT_2_10_10_10_REV,
2629 GL_UNSIGNED_INT_10F_11F_11F_REV};
2630 const GLint defaultColorFormats[] = {GL_RGBA, GL_RGBA_INTEGER, GL_RGB, GL_RGB_INTEGER,
2631 GL_RG, GL_RG_INTEGER, GL_RED, GL_RED_INTEGER};
2632
2633 std::vector<GLint> validColorTypes;
2634 std::vector<GLint> validColorFormats;
2635
2636 // Defined by the spec
2637
2638 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorTypes); ++ndx)
2639 validColorTypes.push_back(defaultColorTypes[ndx]);
2640 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(defaultColorFormats); ++ndx)
2641 validColorFormats.push_back(defaultColorFormats[ndx]);
2642
2643 // Extensions
2644
2645 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_format_BGRA8888") ||
2646 m_context.getContextInfo().isExtensionSupported("GL_APPLE_texture_format_BGRA8888"))
2647 validColorFormats.push_back(GL_BGRA);
2648
2649 if (m_context.getContextInfo().isExtensionSupported("GL_EXT_read_format_bgra"))
2650 {
2651 validColorFormats.push_back(GL_BGRA);
2652 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
2653 validColorTypes.push_back(GL_UNSIGNED_SHORT_1_5_5_5_REV);
2654 }
2655
2656 if (m_context.getContextInfo().isExtensionSupported("GL_IMG_read_format"))
2657 {
2658 validColorFormats.push_back(GL_BGRA);
2659 validColorTypes.push_back(GL_UNSIGNED_SHORT_4_4_4_4_REV);
2660 }
2661
2662 if (m_context.getContextInfo().isExtensionSupported("GL_NV_sRGB_formats"))
2663 {
2664 validColorFormats.push_back(GL_SLUMINANCE_NV);
2665 validColorFormats.push_back(GL_SLUMINANCE_ALPHA_NV);
2666 }
2667
2668 if (m_context.getContextInfo().isExtensionSupported("GL_NV_bgr"))
2669 {
2670 validColorFormats.push_back(GL_BGR_NV);
2671 }
2672
2673 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_TYPE, &validColorTypes[0],
2674 validColorTypes.size());
2675 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_IMPLEMENTATION_COLOR_READ_FORMAT, &validColorFormats[0],
2676 validColorFormats.size());
2677 expectError(GL_NO_ERROR);
2678 }
2679
2680 private:
2681 StateVerifier *m_verifier;
2682 };
2683
2684 class ReadBufferCase : public ApiCase
2685 {
2686 public:
ReadBufferCase(Context & context,StateVerifier * verifier,const char * name,const char * description)2687 ReadBufferCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
2688 : ApiCase(context, name, description)
2689 , m_verifier(verifier)
2690 {
2691 }
2692
test(void)2693 void test(void)
2694 {
2695 const bool isGlCore45 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
2696 const GLenum colorAttachment = isGlCore45 ? GL_FRONT : GL_BACK;
2697 const GLint validInitialValues[] = {(GLint)colorAttachment, GL_BACK, GL_NONE};
2698 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_READ_BUFFER, validInitialValues,
2699 DE_LENGTH_OF_ARRAY(validInitialValues));
2700 expectError(GL_NO_ERROR);
2701
2702 glReadBuffer(GL_NONE);
2703 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_NONE);
2704 expectError(GL_NO_ERROR);
2705
2706 glReadBuffer(colorAttachment);
2707 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, colorAttachment);
2708 expectError(GL_NO_ERROR);
2709
2710 // test GL_READ_BUFFER with framebuffers
2711
2712 GLuint framebufferId = 0;
2713 glGenFramebuffers(1, &framebufferId);
2714 expectError(GL_NO_ERROR);
2715
2716 GLuint renderbuffer_id = 0;
2717 glGenRenderbuffers(1, &renderbuffer_id);
2718 expectError(GL_NO_ERROR);
2719
2720 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_id);
2721 expectError(GL_NO_ERROR);
2722
2723 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2724 expectError(GL_NO_ERROR);
2725
2726 glBindFramebuffer(GL_READ_FRAMEBUFFER, framebufferId);
2727 expectError(GL_NO_ERROR);
2728
2729 glFramebufferRenderbuffer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_id);
2730 expectError(GL_NO_ERROR);
2731
2732 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, GL_COLOR_ATTACHMENT0);
2733
2734 glDeleteFramebuffers(1, &framebufferId);
2735 glDeleteRenderbuffers(1, &renderbuffer_id);
2736 expectError(GL_NO_ERROR);
2737
2738 m_verifier->verifyInteger(m_testCtx, GL_READ_BUFFER, colorAttachment);
2739 expectError(GL_NO_ERROR);
2740 }
2741
2742 private:
2743 StateVerifier *m_verifier;
2744 };
2745
2746 class DrawBufferCase : public ApiCase
2747 {
2748 public:
DrawBufferCase(Context & context,StateVerifier * verifier,const char * name,const char * description)2749 DrawBufferCase(Context &context, StateVerifier *verifier, const char *name, const char *description)
2750 : ApiCase(context, name, description)
2751 , m_verifier(verifier)
2752 {
2753 }
2754
test(void)2755 void test(void)
2756 {
2757 const GLint validInitialValues[] = {GL_FRONT, GL_BACK, GL_NONE};
2758 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validInitialValues,
2759 DE_LENGTH_OF_ARRAY(validInitialValues));
2760 expectError(GL_NO_ERROR);
2761
2762 GLenum bufs = GL_NONE;
2763 glDrawBuffers(1, &bufs);
2764 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE);
2765 expectError(GL_NO_ERROR);
2766
2767 bufs = GL_BACK;
2768 glDrawBuffers(1, &bufs);
2769 const GLint validDraw0Values[] = {GL_FRONT_LEFT, GL_BACK};
2770 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validDraw0Values,
2771 DE_LENGTH_OF_ARRAY(validDraw0Values));
2772 expectError(GL_NO_ERROR);
2773
2774 // test GL_DRAW_BUFFER with framebuffers
2775
2776 GLuint framebufferId = 0;
2777 glGenFramebuffers(1, &framebufferId);
2778 expectError(GL_NO_ERROR);
2779
2780 GLuint renderbuffer_ids[2] = {0};
2781 glGenRenderbuffers(2, renderbuffer_ids);
2782 expectError(GL_NO_ERROR);
2783
2784 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[0]);
2785 expectError(GL_NO_ERROR);
2786 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2787 expectError(GL_NO_ERROR);
2788
2789 glBindRenderbuffer(GL_RENDERBUFFER, renderbuffer_ids[1]);
2790 expectError(GL_NO_ERROR);
2791 glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, 128, 128);
2792 expectError(GL_NO_ERROR);
2793
2794 glBindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferId);
2795 expectError(GL_NO_ERROR);
2796
2797 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffer_ids[0]);
2798 expectError(GL_NO_ERROR);
2799 glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, renderbuffer_ids[1]);
2800 expectError(GL_NO_ERROR);
2801
2802 // only the initial state the draw buffer for fragment color zero is defined
2803 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_COLOR_ATTACHMENT0);
2804
2805 GLenum bufTargets[2] = {GL_NONE, GL_COLOR_ATTACHMENT1};
2806 glDrawBuffers(2, bufTargets);
2807 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER0, GL_NONE);
2808 m_verifier->verifyInteger(m_testCtx, GL_DRAW_BUFFER1, GL_COLOR_ATTACHMENT1);
2809
2810 glDeleteFramebuffers(1, &framebufferId);
2811 glDeleteRenderbuffers(2, renderbuffer_ids);
2812 expectError(GL_NO_ERROR);
2813
2814 m_verifier->verifyIntegerAnyOf(m_testCtx, GL_DRAW_BUFFER0, validDraw0Values,
2815 DE_LENGTH_OF_ARRAY(validDraw0Values));
2816 expectError(GL_NO_ERROR);
2817 }
2818
2819 private:
2820 StateVerifier *m_verifier;
2821 };
2822
getQueryTypeSuffix(QueryType type)2823 static const char *getQueryTypeSuffix(QueryType type)
2824 {
2825 switch (type)
2826 {
2827 case QUERY_BOOLEAN:
2828 return "_getboolean";
2829 case QUERY_INTEGER:
2830 return "_getinteger";
2831 case QUERY_INTEGER64:
2832 return "_getinteger64";
2833 case QUERY_FLOAT:
2834 return "_getfloat";
2835 default:
2836 DE_ASSERT(false);
2837 return DE_NULL;
2838 }
2839 }
2840
2841 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \
2842 do \
2843 { \
2844 for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
2845 { \
2846 StateVerifier *verifier = (VERIFIERS)[_verifierNdx]; \
2847 CODE_BLOCK; \
2848 } \
2849 } while (0)
2850
2851 #define FOR_EACH_QUERYTYPE(QUERYTYPES, CODE_BLOCK) \
2852 do \
2853 { \
2854 for (int _queryTypeNdx = 0; _queryTypeNdx < DE_LENGTH_OF_ARRAY(QUERYTYPES); _queryTypeNdx++) \
2855 { \
2856 const QueryType queryType = (QUERYTYPES)[_queryTypeNdx]; \
2857 CODE_BLOCK; \
2858 } \
2859 } while (0)
2860
2861 } // namespace
2862
IntegerStateQueryTests(Context & context)2863 IntegerStateQueryTests::IntegerStateQueryTests(Context &context)
2864 : TestCaseGroup(context, "integers", "Integer Values")
2865 , m_verifierBoolean(DE_NULL)
2866 , m_verifierInteger(DE_NULL)
2867 , m_verifierInteger64(DE_NULL)
2868 , m_verifierFloat(DE_NULL)
2869 {
2870 }
2871
~IntegerStateQueryTests(void)2872 IntegerStateQueryTests::~IntegerStateQueryTests(void)
2873 {
2874 deinit();
2875 }
2876
init(void)2877 void IntegerStateQueryTests::init(void)
2878 {
2879 static const QueryType queryTypes[] = {
2880 QUERY_BOOLEAN,
2881 QUERY_INTEGER,
2882 QUERY_INTEGER64,
2883 QUERY_FLOAT,
2884 };
2885
2886 DE_ASSERT(m_verifierBoolean == DE_NULL);
2887 DE_ASSERT(m_verifierInteger == DE_NULL);
2888 DE_ASSERT(m_verifierInteger64 == DE_NULL);
2889 DE_ASSERT(m_verifierFloat == DE_NULL);
2890
2891 m_verifierBoolean =
2892 new GetBooleanVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2893 m_verifierInteger =
2894 new GetIntegerVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2895 m_verifierInteger64 =
2896 new GetInteger64Verifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2897 m_verifierFloat =
2898 new GetFloatVerifier(m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog());
2899
2900 const struct LimitedStateInteger
2901 {
2902 const char *name;
2903 const char *description;
2904 GLenum targetName;
2905 GLint value;
2906 bool skipForGl;
2907 } implementationMinLimits[] = {
2908 {"subpixel_bits", "SUBPIXEL_BITS has minimum value of 4", GL_SUBPIXEL_BITS, 4, false},
2909 {"max_3d_texture_size", "MAX_3D_TEXTURE_SIZE has minimum value of 256", GL_MAX_3D_TEXTURE_SIZE, 256, false},
2910 {"max_texture_size", "MAX_TEXTURE_SIZE has minimum value of 2048", GL_MAX_TEXTURE_SIZE, 2048, false},
2911 {"max_array_texture_layers", "MAX_ARRAY_TEXTURE_LAYERS has minimum value of 256", GL_MAX_ARRAY_TEXTURE_LAYERS,
2912 256, false},
2913 {"max_cube_map_texture_size", "MAX_CUBE_MAP_TEXTURE_SIZE has minimum value of 2048",
2914 GL_MAX_CUBE_MAP_TEXTURE_SIZE, 2048, false},
2915 {"max_renderbuffer_size", "MAX_RENDERBUFFER_SIZE has minimum value of 2048", GL_MAX_RENDERBUFFER_SIZE, 2048,
2916 false},
2917 {"max_draw_buffers", "MAX_DRAW_BUFFERS has minimum value of 4", GL_MAX_DRAW_BUFFERS, 4, false},
2918 {"max_color_attachments", "MAX_COLOR_ATTACHMENTS has minimum value of 4", GL_MAX_COLOR_ATTACHMENTS, 4, false},
2919 {"max_elements_indices", "MAX_ELEMENTS_INDICES has minimum value of 0", GL_MAX_ELEMENTS_INDICES, 0, false},
2920 {"max_elements_vertices", "MAX_ELEMENTS_VERTICES has minimum value of 0", GL_MAX_ELEMENTS_VERTICES, 0, false},
2921 {"num_extensions", "NUM_EXTENSIONS has minimum value of 0", GL_NUM_EXTENSIONS, 0, false},
2922 {"major_version", "MAJOR_VERSION has minimum value of 3", GL_MAJOR_VERSION, 3, false},
2923 {"minor_version", "MINOR_VERSION has minimum value of 0", GL_MINOR_VERSION, 0, false},
2924 {"max_vertex_attribs", "MAX_VERTEX_ATTRIBS has minimum value of 16", GL_MAX_VERTEX_ATTRIBS, 16, false},
2925 {"max_vertex_uniform_components", "MAX_VERTEX_UNIFORM_COMPONENTS has minimum value of 1024",
2926 GL_MAX_VERTEX_UNIFORM_COMPONENTS, 1024, false},
2927 {"max_vertex_uniform_vectors", "MAX_VERTEX_UNIFORM_VECTORS has minimum value of 256",
2928 GL_MAX_VERTEX_UNIFORM_VECTORS, 256, false},
2929 {"max_vertex_uniform_blocks", "MAX_VERTEX_UNIFORM_BLOCKS has minimum value of 12", GL_MAX_VERTEX_UNIFORM_BLOCKS,
2930 12, false},
2931 {"max_vertex_output_components", "MAX_VERTEX_OUTPUT_COMPONENTS has minimum value of 64",
2932 GL_MAX_VERTEX_OUTPUT_COMPONENTS, 64, false},
2933 {"max_vertex_texture_image_units", "MAX_VERTEX_TEXTURE_IMAGE_UNITS has minimum value of 16",
2934 GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, 16, false},
2935 {"max_fragment_uniform_components", "MAX_FRAGMENT_UNIFORM_COMPONENTS has minimum value of 896",
2936 GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, 896, false},
2937 {"max_fragment_uniform_vectors", "MAX_FRAGMENT_UNIFORM_VECTORS has minimum value of 224",
2938 GL_MAX_FRAGMENT_UNIFORM_VECTORS, 224, false},
2939 {"max_fragment_uniform_blocks", "MAX_FRAGMENT_UNIFORM_BLOCKS has minimum value of 12",
2940 GL_MAX_FRAGMENT_UNIFORM_BLOCKS, 12, false},
2941 {"max_fragment_input_components", "MAX_FRAGMENT_INPUT_COMPONENTS has minimum value of 60",
2942 GL_MAX_FRAGMENT_INPUT_COMPONENTS, 60, false},
2943 {"max_texture_image_units", "MAX_TEXTURE_IMAGE_UNITS has minimum value of 16", GL_MAX_TEXTURE_IMAGE_UNITS, 16,
2944 false},
2945 {"max_program_texel_offset", "MAX_PROGRAM_TEXEL_OFFSET has minimum value of 7", GL_MAX_PROGRAM_TEXEL_OFFSET, 7,
2946 false},
2947 {"max_uniform_buffer_bindings", "MAX_UNIFORM_BUFFER_BINDINGS has minimum value of 24",
2948 GL_MAX_UNIFORM_BUFFER_BINDINGS, 24, false},
2949 {"max_combined_uniform_blocks", "MAX_COMBINED_UNIFORM_BLOCKS has minimum value of 24",
2950 GL_MAX_COMBINED_UNIFORM_BLOCKS, 24, false},
2951 {"max_varying_components", "MAX_VARYING_COMPONENTS has minimum value of 60", GL_MAX_VARYING_COMPONENTS, 60,
2952 false},
2953 {"max_varying_vectors", "MAX_VARYING_VECTORS has minimum value of 15", GL_MAX_VARYING_VECTORS, 15, false},
2954 {"max_combined_texture_image_units", "MAX_COMBINED_TEXTURE_IMAGE_UNITS has minimum value of 32",
2955 GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, 32, false},
2956 {"max_transform_feedback_interleaved_components",
2957 "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS has minimum value of 64",
2958 GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS, 64, false},
2959 {"max_transform_feedback_separate_attribs", "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS has minimum value of 4",
2960 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS, 4, false},
2961 {"max_transform_feedback_separate_components",
2962 "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS has minimum value of 4",
2963 GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS, 4, false},
2964 {"max_samples", "MAX_SAMPLES has minimum value of 4", GL_MAX_SAMPLES, 4, false},
2965 {"red_bits", "RED_BITS has minimum value of 0", GL_RED_BITS, 0, true},
2966 {"green_bits", "GREEN_BITS has minimum value of 0", GL_GREEN_BITS, 0, true},
2967 {"blue_bits", "BLUE_BITS has minimum value of 0", GL_BLUE_BITS, 0, true},
2968 {"alpha_bits", "ALPHA_BITS has minimum value of 0", GL_ALPHA_BITS, 0, true},
2969 {"depth_bits", "DEPTH_BITS has minimum value of 0", GL_DEPTH_BITS, 0, true},
2970 {"stencil_bits", "STENCIL_BITS has minimum value of 0", GL_STENCIL_BITS, 0, true},
2971 };
2972 const LimitedStateInteger implementationMaxLimits[] = {
2973 {"min_program_texel_offset", "MIN_PROGRAM_TEXEL_OFFSET has maximum value of -8", GL_MIN_PROGRAM_TEXEL_OFFSET,
2974 -8, false},
2975 {"uniform_buffer_offset_alignment", "UNIFORM_BUFFER_OFFSET_ALIGNMENT has minimum value of 1",
2976 GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, 256, false},
2977 };
2978
2979 // \note implementation defined limits have their own tests so just check the conversions to boolean, int64 and float
2980 StateVerifier *implementationLimitVerifiers[] = {m_verifierBoolean, m_verifierInteger64, m_verifierFloat};
2981
2982 const bool isGlCore45 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
2983 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMinLimits); testNdx++)
2984 {
2985 if (implementationMinLimits[testNdx].skipForGl && isGlCore45)
2986 continue;
2987 FOR_EACH_VERIFIER(
2988 implementationLimitVerifiers,
2989 addChild(new ConstantMinimumValueTestCase(
2990 m_context, verifier,
2991 (std::string(implementationMinLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(),
2992 implementationMinLimits[testNdx].description, implementationMinLimits[testNdx].targetName,
2993 implementationMinLimits[testNdx].value)));
2994 }
2995 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationMaxLimits); testNdx++)
2996 FOR_EACH_VERIFIER(
2997 implementationLimitVerifiers,
2998 addChild(new ConstantMaximumValueTestCase(
2999 m_context, verifier,
3000 (std::string(implementationMaxLimits[testNdx].name) + verifier->getTestNamePostfix()).c_str(),
3001 implementationMaxLimits[testNdx].description, implementationMaxLimits[testNdx].targetName,
3002 implementationMaxLimits[testNdx].value)));
3003
3004 StateVerifier *normalVerifiers[] = {m_verifierBoolean, m_verifierInteger, m_verifierInteger64, m_verifierFloat};
3005
3006 FOR_EACH_VERIFIER(implementationLimitVerifiers,
3007 addChild(new SampleBuffersTestCase(
3008 m_context, verifier, (std::string("sample_buffers") + verifier->getTestNamePostfix()).c_str(),
3009 "SAMPLE_BUFFERS")));
3010
3011 FOR_EACH_VERIFIER(
3012 normalVerifiers,
3013 addChild(new SamplesTestCase(m_context, verifier,
3014 (std::string("samples") + verifier->getTestNamePostfix()).c_str(), "SAMPLES")));
3015 if (!isGlCore45)
3016 FOR_EACH_VERIFIER(
3017 normalVerifiers,
3018 addChild(new HintTestCase(m_context, verifier,
3019 (std::string("generate_mipmap_hint") + verifier->getTestNamePostfix()).c_str(),
3020 "GENERATE_MIPMAP_HINT", GL_GENERATE_MIPMAP_HINT)));
3021 FOR_EACH_VERIFIER(normalVerifiers,
3022 addChild(new HintTestCase(
3023 m_context, verifier,
3024 (std::string("fragment_shader_derivative_hint") + verifier->getTestNamePostfix()).c_str(),
3025 "FRAGMENT_SHADER_DERIVATIVE_HINT", GL_FRAGMENT_SHADER_DERIVATIVE_HINT)));
3026 FOR_EACH_VERIFIER(
3027 normalVerifiers,
3028 addChild(new DepthFuncTestCase(
3029 m_context, verifier, (std::string("depth_func") + verifier->getTestNamePostfix()).c_str(), "DEPTH_FUNC")));
3030 FOR_EACH_VERIFIER(normalVerifiers,
3031 addChild(new CullFaceTestCase(
3032 m_context, verifier, (std::string("cull_face_mode") + verifier->getTestNamePostfix()).c_str(),
3033 "CULL_FACE_MODE")));
3034 FOR_EACH_VERIFIER(normalVerifiers,
3035 addChild(new FrontFaceTestCase(
3036 m_context, verifier,
3037 (std::string("front_face_mode") + verifier->getTestNamePostfix()).c_str(), "FRONT_FACE")));
3038 FOR_EACH_VERIFIER(
3039 normalVerifiers,
3040 addChild(new ViewPortTestCase(m_context, verifier,
3041 (std::string("viewport") + verifier->getTestNamePostfix()).c_str(), "VIEWPORT")));
3042 FOR_EACH_VERIFIER(normalVerifiers,
3043 addChild(new ScissorBoxTestCase(
3044 m_context, verifier, (std::string("scissor_box") + verifier->getTestNamePostfix()).c_str(),
3045 "SCISSOR_BOX")));
3046 FOR_EACH_VERIFIER(normalVerifiers, addChild(new MaxViewportDimsTestCase(
3047 m_context, verifier,
3048 (std::string("max_viewport_dims") + verifier->getTestNamePostfix()).c_str(),
3049 "MAX_VIEWPORT_DIMS")));
3050 FOR_EACH_VERIFIER(normalVerifiers,
3051 addChild(new StencilRefTestCase(
3052 m_context, verifier, (std::string("stencil_ref") + verifier->getTestNamePostfix()).c_str(),
3053 "STENCIL_REF", GL_STENCIL_REF)));
3054 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilRefTestCase(
3055 m_context, verifier,
3056 (std::string("stencil_back_ref") + verifier->getTestNamePostfix()).c_str(),
3057 "STENCIL_BACK_REF", GL_STENCIL_BACK_REF)));
3058 FOR_EACH_VERIFIER(
3059 normalVerifiers,
3060 addChild(new StencilRefSeparateTestCase(
3061 m_context, verifier, (std::string("stencil_ref_separate") + verifier->getTestNamePostfix()).c_str(),
3062 "STENCIL_REF (separate)", GL_STENCIL_REF, GL_FRONT)));
3063 FOR_EACH_VERIFIER(
3064 normalVerifiers,
3065 addChild(new StencilRefSeparateTestCase(
3066 m_context, verifier, (std::string("stencil_ref_separate_both") + verifier->getTestNamePostfix()).c_str(),
3067 "STENCIL_REF (separate)", GL_STENCIL_REF, GL_FRONT_AND_BACK)));
3068 FOR_EACH_VERIFIER(
3069 normalVerifiers,
3070 addChild(new StencilRefSeparateTestCase(
3071 m_context, verifier, (std::string("stencil_back_ref_separate") + verifier->getTestNamePostfix()).c_str(),
3072 "STENCIL_BACK_REF (separate)", GL_STENCIL_BACK_REF, GL_BACK)));
3073 FOR_EACH_VERIFIER(normalVerifiers,
3074 addChild(new StencilRefSeparateTestCase(
3075 m_context, verifier,
3076 (std::string("stencil_back_ref_separate_both") + verifier->getTestNamePostfix()).c_str(),
3077 "STENCIL_BACK_REF (separate)", GL_STENCIL_BACK_REF, GL_FRONT_AND_BACK)));
3078
3079 const struct NamedStencilOp
3080 {
3081 const char *name;
3082
3083 const char *frontDescription;
3084 GLenum frontTarget;
3085 const char *backDescription;
3086 GLenum backTarget;
3087 } stencilOps[] = {{"fail", "STENCIL_FAIL", GL_STENCIL_FAIL, "STENCIL_BACK_FAIL", GL_STENCIL_BACK_FAIL},
3088 {"depth_fail", "STENCIL_PASS_DEPTH_FAIL", GL_STENCIL_PASS_DEPTH_FAIL,
3089 "STENCIL_BACK_PASS_DEPTH_FAIL", GL_STENCIL_BACK_PASS_DEPTH_FAIL},
3090 {"depth_pass", "STENCIL_PASS_DEPTH_PASS", GL_STENCIL_PASS_DEPTH_PASS,
3091 "STENCIL_BACK_PASS_DEPTH_PASS", GL_STENCIL_BACK_PASS_DEPTH_PASS}};
3092
3093 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(stencilOps); testNdx++)
3094 {
3095 FOR_EACH_VERIFIER(
3096 normalVerifiers,
3097 addChild(new StencilOpTestCase(
3098 m_context, verifier,
3099 (std::string("stencil_") + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(),
3100 stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget)));
3101 FOR_EACH_VERIFIER(
3102 normalVerifiers,
3103 addChild(new StencilOpTestCase(
3104 m_context, verifier,
3105 (std::string("stencil_back_") + stencilOps[testNdx].name + verifier->getTestNamePostfix()).c_str(),
3106 stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget)));
3107
3108 FOR_EACH_VERIFIER(
3109 normalVerifiers,
3110 addChild(new StencilOpSeparateTestCase(
3111 m_context, verifier,
3112 (std::string("stencil_") + stencilOps[testNdx].name + "_separate_both" + verifier->getTestNamePostfix())
3113 .c_str(),
3114 stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget, GL_FRONT_AND_BACK)));
3115 FOR_EACH_VERIFIER(normalVerifiers,
3116 addChild(new StencilOpSeparateTestCase(
3117 m_context, verifier,
3118 (std::string("stencil_back_") + stencilOps[testNdx].name + "_separate_both" +
3119 verifier->getTestNamePostfix())
3120 .c_str(),
3121 stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget, GL_FRONT_AND_BACK)));
3122
3123 FOR_EACH_VERIFIER(
3124 normalVerifiers,
3125 addChild(new StencilOpSeparateTestCase(
3126 m_context, verifier,
3127 (std::string("stencil_") + stencilOps[testNdx].name + "_separate" + verifier->getTestNamePostfix())
3128 .c_str(),
3129 stencilOps[testNdx].frontDescription, stencilOps[testNdx].frontTarget, GL_FRONT)));
3130 FOR_EACH_VERIFIER(
3131 normalVerifiers,
3132 addChild(new StencilOpSeparateTestCase(
3133 m_context, verifier,
3134 (std::string("stencil_back_") + stencilOps[testNdx].name + "_separate" + verifier->getTestNamePostfix())
3135 .c_str(),
3136 stencilOps[testNdx].backDescription, stencilOps[testNdx].backTarget, GL_BACK)));
3137 }
3138
3139 FOR_EACH_VERIFIER(normalVerifiers,
3140 addChild(new StencilFuncTestCase(
3141 m_context, verifier, (std::string("stencil_func") + verifier->getTestNamePostfix()).c_str(),
3142 "STENCIL_FUNC")));
3143 FOR_EACH_VERIFIER(
3144 normalVerifiers,
3145 addChild(new StencilFuncSeparateTestCase(
3146 m_context, verifier, (std::string("stencil_func_separate") + verifier->getTestNamePostfix()).c_str(),
3147 "STENCIL_FUNC (separate)", GL_STENCIL_FUNC, GL_FRONT)));
3148 FOR_EACH_VERIFIER(
3149 normalVerifiers,
3150 addChild(new StencilFuncSeparateTestCase(
3151 m_context, verifier, (std::string("stencil_func_separate_both") + verifier->getTestNamePostfix()).c_str(),
3152 "STENCIL_FUNC (separate)", GL_STENCIL_FUNC, GL_FRONT_AND_BACK)));
3153 FOR_EACH_VERIFIER(
3154 normalVerifiers,
3155 addChild(new StencilFuncSeparateTestCase(
3156 m_context, verifier, (std::string("stencil_back_func_separate") + verifier->getTestNamePostfix()).c_str(),
3157 "STENCIL_FUNC (separate)", GL_STENCIL_BACK_FUNC, GL_BACK)));
3158 FOR_EACH_VERIFIER(normalVerifiers,
3159 addChild(new StencilFuncSeparateTestCase(
3160 m_context, verifier,
3161 (std::string("stencil_back_func_separate_both") + verifier->getTestNamePostfix()).c_str(),
3162 "STENCIL_FUNC (separate)", GL_STENCIL_BACK_FUNC, GL_FRONT_AND_BACK)));
3163 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilMaskTestCase(
3164 m_context, verifier,
3165 (std::string("stencil_value_mask") + verifier->getTestNamePostfix()).c_str(),
3166 "STENCIL_VALUE_MASK", GL_STENCIL_VALUE_MASK)));
3167 FOR_EACH_VERIFIER(
3168 normalVerifiers,
3169 addChild(new StencilMaskTestCase(
3170 m_context, verifier, (std::string("stencil_back_value_mask") + verifier->getTestNamePostfix()).c_str(),
3171 "STENCIL_BACK_VALUE_MASK", GL_STENCIL_BACK_VALUE_MASK)));
3172 FOR_EACH_VERIFIER(
3173 normalVerifiers,
3174 addChild(new StencilMaskSeparateTestCase(
3175 m_context, verifier, (std::string("stencil_value_mask_separate") + verifier->getTestNamePostfix()).c_str(),
3176 "STENCIL_VALUE_MASK (separate)", GL_STENCIL_VALUE_MASK, GL_FRONT)));
3177 FOR_EACH_VERIFIER(normalVerifiers,
3178 addChild(new StencilMaskSeparateTestCase(
3179 m_context, verifier,
3180 (std::string("stencil_value_mask_separate_both") + verifier->getTestNamePostfix()).c_str(),
3181 "STENCIL_VALUE_MASK (separate)", GL_STENCIL_VALUE_MASK, GL_FRONT_AND_BACK)));
3182 FOR_EACH_VERIFIER(normalVerifiers,
3183 addChild(new StencilMaskSeparateTestCase(
3184 m_context, verifier,
3185 (std::string("stencil_back_value_mask_separate") + verifier->getTestNamePostfix()).c_str(),
3186 "STENCIL_BACK_VALUE_MASK (separate)", GL_STENCIL_BACK_VALUE_MASK, GL_BACK)));
3187 FOR_EACH_VERIFIER(
3188 normalVerifiers,
3189 addChild(new StencilMaskSeparateTestCase(
3190 m_context, verifier,
3191 (std::string("stencil_back_value_mask_separate_both") + verifier->getTestNamePostfix()).c_str(),
3192 "STENCIL_BACK_VALUE_MASK (separate)", GL_STENCIL_BACK_VALUE_MASK, GL_FRONT_AND_BACK)));
3193 FOR_EACH_VERIFIER(normalVerifiers, addChild(new StencilWriteMaskTestCase(
3194 m_context, verifier,
3195 (std::string("stencil_writemask") + verifier->getTestNamePostfix()).c_str(),
3196 "STENCIL_WRITEMASK", GL_STENCIL_WRITEMASK)));
3197 FOR_EACH_VERIFIER(
3198 normalVerifiers,
3199 addChild(new StencilWriteMaskTestCase(
3200 m_context, verifier, (std::string("stencil_back_writemask") + verifier->getTestNamePostfix()).c_str(),
3201 "STENCIL_BACK_WRITEMASK", GL_STENCIL_BACK_WRITEMASK)));
3202 FOR_EACH_VERIFIER(
3203 normalVerifiers,
3204 addChild(new StencilWriteMaskSeparateTestCase(
3205 m_context, verifier, (std::string("stencil_writemask_separate") + verifier->getTestNamePostfix()).c_str(),
3206 "STENCIL_WRITEMASK (separate)", GL_STENCIL_WRITEMASK, GL_FRONT)));
3207 FOR_EACH_VERIFIER(normalVerifiers,
3208 addChild(new StencilWriteMaskSeparateTestCase(
3209 m_context, verifier,
3210 (std::string("stencil_writemask_separate_both") + verifier->getTestNamePostfix()).c_str(),
3211 "STENCIL_WRITEMASK (separate)", GL_STENCIL_WRITEMASK, GL_FRONT_AND_BACK)));
3212 FOR_EACH_VERIFIER(normalVerifiers,
3213 addChild(new StencilWriteMaskSeparateTestCase(
3214 m_context, verifier,
3215 (std::string("stencil_back_writemask_separate") + verifier->getTestNamePostfix()).c_str(),
3216 "STENCIL_BACK_WRITEMASK (separate)", GL_STENCIL_BACK_WRITEMASK, GL_BACK)));
3217 FOR_EACH_VERIFIER(
3218 normalVerifiers,
3219 addChild(new StencilWriteMaskSeparateTestCase(
3220 m_context, verifier,
3221 (std::string("stencil_back_writemask_separate_both") + verifier->getTestNamePostfix()).c_str(),
3222 "STENCIL_BACK_WRITEMASK (separate)", GL_STENCIL_BACK_WRITEMASK, GL_FRONT_AND_BACK)));
3223
3224 const struct PixelStoreState
3225 {
3226 const char *name;
3227 const char *description;
3228 GLenum target;
3229 int initialValue;
3230 } pixelStoreStates[] = {{"unpack_image_height", "UNPACK_IMAGE_HEIGHT", GL_UNPACK_IMAGE_HEIGHT, 0},
3231 {"unpack_skip_images", "UNPACK_SKIP_IMAGES", GL_UNPACK_SKIP_IMAGES, 0},
3232 {"unpack_row_length", "UNPACK_ROW_LENGTH", GL_UNPACK_ROW_LENGTH, 0},
3233 {"unpack_skip_rows", "UNPACK_SKIP_ROWS", GL_UNPACK_SKIP_ROWS, 0},
3234 {"unpack_skip_pixels", "UNPACK_SKIP_PIXELS", GL_UNPACK_SKIP_PIXELS, 0},
3235 {"pack_row_length", "PACK_ROW_LENGTH", GL_PACK_ROW_LENGTH, 0},
3236 {"pack_skip_rows", "PACK_SKIP_ROWS", GL_PACK_SKIP_ROWS, 0},
3237 {"pack_skip_pixels", "PACK_SKIP_PIXELS", GL_PACK_SKIP_PIXELS, 0}};
3238 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(pixelStoreStates); testNdx++)
3239 {
3240 FOR_EACH_VERIFIER(normalVerifiers,
3241 addChild(new PixelStoreTestCase(
3242 m_context, verifier,
3243 (std::string(pixelStoreStates[testNdx].name) + verifier->getTestNamePostfix()).c_str(),
3244 pixelStoreStates[testNdx].description, pixelStoreStates[testNdx].target,
3245 pixelStoreStates[testNdx].initialValue)));
3246 }
3247
3248 FOR_EACH_VERIFIER(normalVerifiers, addChild(new PixelStoreAlignTestCase(
3249 m_context, verifier,
3250 (std::string("unpack_alignment") + verifier->getTestNamePostfix()).c_str(),
3251 "UNPACK_ALIGNMENT", GL_UNPACK_ALIGNMENT)));
3252 FOR_EACH_VERIFIER(normalVerifiers,
3253 addChild(new PixelStoreAlignTestCase(
3254 m_context, verifier, (std::string("pack_alignment") + verifier->getTestNamePostfix()).c_str(),
3255 "PACK_ALIGNMENT", GL_PACK_ALIGNMENT)));
3256
3257 const struct BlendColorState
3258 {
3259 const char *name;
3260 const char *description;
3261 GLenum target;
3262 int initialValue;
3263 } blendColorStates[] = {{"blend_src_rgb", "BLEND_SRC_RGB", GL_BLEND_SRC_RGB, GL_ONE},
3264 {"blend_src_alpha", "BLEND_SRC_ALPHA", GL_BLEND_SRC_ALPHA, GL_ONE},
3265 {"blend_dst_rgb", "BLEND_DST_RGB", GL_BLEND_DST_RGB, GL_ZERO},
3266 {"blend_dst_alpha", "BLEND_DST_ALPHA", GL_BLEND_DST_ALPHA, GL_ZERO}};
3267 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendColorStates); testNdx++)
3268 {
3269 FOR_EACH_VERIFIER(normalVerifiers,
3270 addChild(new BlendFuncTestCase(
3271 m_context, verifier,
3272 (std::string(blendColorStates[testNdx].name) + verifier->getTestNamePostfix()).c_str(),
3273 blendColorStates[testNdx].description, blendColorStates[testNdx].target,
3274 blendColorStates[testNdx].initialValue)));
3275 FOR_EACH_VERIFIER(
3276 normalVerifiers,
3277 addChild(new BlendFuncSeparateTestCase(
3278 m_context, verifier,
3279 (std::string(blendColorStates[testNdx].name) + "_separate" + verifier->getTestNamePostfix()).c_str(),
3280 blendColorStates[testNdx].description, blendColorStates[testNdx].target,
3281 blendColorStates[testNdx].initialValue)));
3282 }
3283
3284 const struct BlendEquationState
3285 {
3286 const char *name;
3287 const char *description;
3288 GLenum target;
3289 int initialValue;
3290 } blendEquationStates[] = {{"blend_equation_rgb", "BLEND_EQUATION_RGB", GL_BLEND_EQUATION_RGB, GL_FUNC_ADD},
3291 {"blend_equation_alpha", "BLEND_EQUATION_ALPHA", GL_BLEND_EQUATION_ALPHA, GL_FUNC_ADD}};
3292 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(blendEquationStates); testNdx++)
3293 {
3294 FOR_EACH_VERIFIER(
3295 normalVerifiers,
3296 addChild(new BlendEquationTestCase(
3297 m_context, verifier,
3298 (std::string(blendEquationStates[testNdx].name) + +verifier->getTestNamePostfix()).c_str(),
3299 blendEquationStates[testNdx].description, blendEquationStates[testNdx].target,
3300 blendEquationStates[testNdx].initialValue)));
3301 FOR_EACH_VERIFIER(
3302 normalVerifiers,
3303 addChild(new BlendEquationSeparateTestCase(
3304 m_context, verifier,
3305 (std::string(blendEquationStates[testNdx].name) + "_separate" + verifier->getTestNamePostfix()).c_str(),
3306 blendEquationStates[testNdx].description, blendEquationStates[testNdx].target,
3307 blendEquationStates[testNdx].initialValue)));
3308 }
3309
3310 const struct ImplementationArrayReturningState
3311 {
3312 const char *name;
3313 const char *description;
3314 GLenum target;
3315 GLenum targetLengthTarget;
3316 int minLength;
3317 } implementationArrayReturningStates[] = {
3318 {"compressed_texture_formats", "COMPRESSED_TEXTURE_FORMATS", GL_COMPRESSED_TEXTURE_FORMATS,
3319 GL_NUM_COMPRESSED_TEXTURE_FORMATS, 10},
3320 {"program_binary_formats", "PROGRAM_BINARY_FORMATS", GL_PROGRAM_BINARY_FORMATS, GL_NUM_PROGRAM_BINARY_FORMATS,
3321 0},
3322 {"shader_binary_formats", "SHADER_BINARY_FORMATS", GL_SHADER_BINARY_FORMATS, GL_NUM_SHADER_BINARY_FORMATS, 0}};
3323 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(implementationArrayReturningStates); testNdx++)
3324 {
3325 FOR_EACH_VERIFIER(normalVerifiers, addChild(new ImplementationArrayTestCase(
3326 m_context, verifier,
3327 (std::string(implementationArrayReturningStates[testNdx].name) +
3328 verifier->getTestNamePostfix())
3329 .c_str(),
3330 implementationArrayReturningStates[testNdx].description,
3331 implementationArrayReturningStates[testNdx].target,
3332 implementationArrayReturningStates[testNdx].targetLengthTarget,
3333 implementationArrayReturningStates[testNdx].minLength)));
3334 }
3335
3336 const struct BufferBindingState
3337 {
3338 const char *name;
3339 const char *description;
3340 GLenum target;
3341 GLenum type;
3342 } bufferBindingStates[] = {
3343 {"array_buffer_binding", "ARRAY_BUFFER_BINDING", GL_ARRAY_BUFFER_BINDING, GL_ARRAY_BUFFER},
3344 {"uniform_buffer_binding", "UNIFORM_BUFFER_BINDING", GL_UNIFORM_BUFFER_BINDING, GL_UNIFORM_BUFFER},
3345 {"pixel_pack_buffer_binding", "PIXEL_PACK_BUFFER_BINDING", GL_PIXEL_PACK_BUFFER_BINDING, GL_PIXEL_PACK_BUFFER},
3346 {"pixel_unpack_buffer_binding", "PIXEL_UNPACK_BUFFER_BINDING", GL_PIXEL_UNPACK_BUFFER_BINDING,
3347 GL_PIXEL_UNPACK_BUFFER},
3348 {"transform_feedback_buffer_binding", "TRANSFORM_FEEDBACK_BUFFER_BINDING", GL_TRANSFORM_FEEDBACK_BUFFER_BINDING,
3349 GL_TRANSFORM_FEEDBACK_BUFFER},
3350 {"copy_read_buffer_binding", "COPY_READ_BUFFER_BINDING", GL_COPY_READ_BUFFER_BINDING, GL_COPY_READ_BUFFER},
3351 {"copy_write_buffer_binding", "COPY_WRITE_BUFFER_BINDING", GL_COPY_WRITE_BUFFER_BINDING, GL_COPY_WRITE_BUFFER}};
3352 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(bufferBindingStates); testNdx++)
3353 {
3354 FOR_EACH_QUERYTYPE(queryTypes,
3355 addChild(new BufferBindingTestCase(
3356 m_context, queryType,
3357 (std::string(bufferBindingStates[testNdx].name) + getQueryTypeSuffix(queryType)).c_str(),
3358 bufferBindingStates[testNdx].description, bufferBindingStates[testNdx].target,
3359 bufferBindingStates[testNdx].type)));
3360 }
3361
3362 FOR_EACH_QUERYTYPE(queryTypes,
3363 addChild(new ElementArrayBufferBindingTestCase(
3364 m_context, queryType,
3365 (std::string("element_array_buffer_binding") + getQueryTypeSuffix(queryType)).c_str())));
3366 FOR_EACH_QUERYTYPE(queryTypes,
3367 addChild(new TransformFeedbackBindingTestCase(
3368 m_context, queryType,
3369 (std::string("transform_feedback_binding") + getQueryTypeSuffix(queryType)).c_str())));
3370 FOR_EACH_QUERYTYPE(queryTypes, addChild(new CurrentProgramBindingTestCase(
3371 m_context, queryType,
3372 (std::string("current_program_binding") + getQueryTypeSuffix(queryType)).c_str(),
3373 "CURRENT_PROGRAM")));
3374 FOR_EACH_QUERYTYPE(queryTypes, addChild(new VertexArrayBindingTestCase(
3375 m_context, queryType,
3376 (std::string("vertex_array_binding") + getQueryTypeSuffix(queryType)).c_str(),
3377 "VERTEX_ARRAY_BINDING")));
3378 FOR_EACH_VERIFIER(
3379 normalVerifiers,
3380 addChild(new StencilClearValueTestCase(
3381 m_context, verifier, (std::string("stencil_clear_value") + verifier->getTestNamePostfix()).c_str(),
3382 "STENCIL_CLEAR_VALUE")));
3383 FOR_EACH_VERIFIER(normalVerifiers,
3384 addChild(new ActiveTextureTestCase(
3385 m_context, verifier, (std::string("active_texture") + verifier->getTestNamePostfix()).c_str(),
3386 "ACTIVE_TEXTURE")));
3387 FOR_EACH_QUERYTYPE(queryTypes, addChild(new RenderbufferBindingTestCase(
3388 m_context, queryType,
3389 (std::string("renderbuffer_binding") + getQueryTypeSuffix(queryType)).c_str(),
3390 "RENDERBUFFER_BINDING")));
3391 FOR_EACH_QUERYTYPE(
3392 queryTypes, addChild(new SamplerObjectBindingTestCase(
3393 m_context, queryType, (std::string("sampler_binding") + getQueryTypeSuffix(queryType)).c_str(),
3394 "SAMPLER_BINDING")));
3395
3396 const struct TextureBinding
3397 {
3398 const char *name;
3399 const char *description;
3400 GLenum target;
3401 GLenum type;
3402 } textureBindings[] = {
3403 {"texture_binding_2d", "TEXTURE_BINDING_2D", GL_TEXTURE_BINDING_2D, GL_TEXTURE_2D},
3404 {"texture_binding_3d", "TEXTURE_BINDING_3D", GL_TEXTURE_BINDING_3D, GL_TEXTURE_3D},
3405 {"texture_binding_2d_array", "TEXTURE_BINDING_2D_ARRAY", GL_TEXTURE_BINDING_2D_ARRAY, GL_TEXTURE_2D_ARRAY},
3406 {"texture_binding_cube_map", "TEXTURE_BINDING_CUBE_MAP", GL_TEXTURE_BINDING_CUBE_MAP, GL_TEXTURE_CUBE_MAP}};
3407
3408 for (int testNdx = 0; testNdx < DE_LENGTH_OF_ARRAY(textureBindings); testNdx++)
3409 {
3410 FOR_EACH_QUERYTYPE(
3411 queryTypes,
3412 addChild(new TextureBindingTestCase(
3413 m_context, queryType,
3414 (std::string(textureBindings[testNdx].name) + getQueryTypeSuffix(queryType)).c_str(),
3415 textureBindings[testNdx].description, textureBindings[testNdx].target, textureBindings[testNdx].type)));
3416 }
3417
3418 FOR_EACH_QUERYTYPE(queryTypes, addChild(new FrameBufferBindingTestCase(
3419 m_context, queryType,
3420 (std::string("framebuffer_binding") + getQueryTypeSuffix(queryType)).c_str(),
3421 "DRAW_FRAMEBUFFER_BINDING and READ_FRAMEBUFFER_BINDING")));
3422 FOR_EACH_VERIFIER(
3423 normalVerifiers,
3424 addChild(new ImplementationColorReadTestCase(
3425 m_context, verifier, (std::string("implementation_color_read") + verifier->getTestNamePostfix()).c_str(),
3426 "IMPLEMENTATION_COLOR_READ_TYPE and IMPLEMENTATION_COLOR_READ_FORMAT")));
3427 FOR_EACH_VERIFIER(normalVerifiers,
3428 addChild(new ReadBufferCase(m_context, verifier,
3429 (std::string("read_buffer") + verifier->getTestNamePostfix()).c_str(),
3430 "READ_BUFFER")));
3431 FOR_EACH_VERIFIER(normalVerifiers,
3432 addChild(new DrawBufferCase(m_context, verifier,
3433 (std::string("draw_buffer") + verifier->getTestNamePostfix()).c_str(),
3434 "DRAW_BUFFER")));
3435 }
3436
deinit(void)3437 void IntegerStateQueryTests::deinit(void)
3438 {
3439 if (m_verifierBoolean)
3440 {
3441 delete m_verifierBoolean;
3442 m_verifierBoolean = DE_NULL;
3443 }
3444 if (m_verifierInteger)
3445 {
3446 delete m_verifierInteger;
3447 m_verifierInteger = DE_NULL;
3448 }
3449 if (m_verifierInteger64)
3450 {
3451 delete m_verifierInteger64;
3452 m_verifierInteger64 = DE_NULL;
3453 }
3454 if (m_verifierFloat)
3455 {
3456 delete m_verifierFloat;
3457 m_verifierFloat = DE_NULL;
3458 }
3459
3460 this->TestCaseGroup::deinit();
3461 }
3462
3463 } // namespace Functional
3464 } // namespace gles3
3465 } // namespace deqp
3466