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