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