xref: /aosp_15_r20/external/deqp/modules/gles3/functional/es3fBufferObjectQueryTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)
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 Buffer Object Query tests.
22  *//*--------------------------------------------------------------------*/
23 
24 #include "es3fBufferObjectQueryTests.hpp"
25 #include "glsStateQueryUtil.hpp"
26 #include "es3fApiCase.hpp"
27 #include "gluRenderContext.hpp"
28 #include "glwEnums.hpp"
29 #include "glwFunctions.hpp"
30 #include "deRandom.hpp"
31 #include "deMath.h"
32 
33 #include <limits>
34 
35 using namespace glw; // GLint and other GL types
36 using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard;
37 
38 namespace deqp
39 {
40 namespace gles3
41 {
42 namespace Functional
43 {
44 namespace BufferParamVerifiers
45 {
46 
checkIntEquals(tcu::TestContext & testCtx,GLint got,GLint expected)47 void checkIntEquals(tcu::TestContext &testCtx, GLint got, GLint expected)
48 {
49     using tcu::TestLog;
50 
51     if (got != expected)
52     {
53         testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got
54                          << TestLog::EndMessage;
55         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
56             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
57     }
58 }
59 
checkPointerEquals(tcu::TestContext & testCtx,const void * got,const void * expected)60 void checkPointerEquals(tcu::TestContext &testCtx, const void *got, const void *expected)
61 {
62     using tcu::TestLog;
63 
64     if (got != expected)
65     {
66         testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got
67                          << TestLog::EndMessage;
68         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
69             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value");
70     }
71 }
72 
73 class BufferParamVerifier : protected glu::CallLogWrapper
74 {
75 public:
76     BufferParamVerifier(const glw::Functions &gl, tcu::TestLog &log, const char *testNamePostfix);
77     virtual ~BufferParamVerifier(); // make GCC happy
78 
79     const char *getTestNamePostfix(void) const;
80 
81     virtual void verifyInteger(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint reference)     = DE_NULL;
82     virtual void verifyInteger64(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint64 reference) = DE_NULL;
83 
84 private:
85     const char *const m_testNamePostfix;
86 };
87 
BufferParamVerifier(const glw::Functions & gl,tcu::TestLog & log,const char * testNamePostfix)88 BufferParamVerifier::BufferParamVerifier(const glw::Functions &gl, tcu::TestLog &log, const char *testNamePostfix)
89     : glu::CallLogWrapper(gl, log)
90     , m_testNamePostfix(testNamePostfix)
91 {
92     enableLogging(true);
93 }
94 
~BufferParamVerifier()95 BufferParamVerifier::~BufferParamVerifier()
96 {
97 }
98 
getTestNamePostfix(void) const99 const char *BufferParamVerifier::getTestNamePostfix(void) const
100 {
101     return m_testNamePostfix;
102 }
103 
104 class GetBufferParameterIVerifier : public BufferParamVerifier
105 {
106 public:
107     GetBufferParameterIVerifier(const glw::Functions &gl, tcu::TestLog &log);
108 
109     void verifyInteger(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint reference);
110     void verifyInteger64(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint64 reference);
111 };
112 
GetBufferParameterIVerifier(const glw::Functions & gl,tcu::TestLog & log)113 GetBufferParameterIVerifier::GetBufferParameterIVerifier(const glw::Functions &gl, tcu::TestLog &log)
114     : BufferParamVerifier(gl, log, "_getbufferparameteri")
115 {
116 }
117 
verifyInteger(tcu::TestContext & testCtx,GLenum target,GLenum name,GLint reference)118 void GetBufferParameterIVerifier::verifyInteger(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint reference)
119 {
120     using tcu::TestLog;
121 
122     StateQueryMemoryWriteGuard<GLint> state;
123     glGetBufferParameteriv(target, name, &state);
124 
125     if (!state.verifyValidity(testCtx))
126         return;
127 
128     if (state != reference)
129     {
130         testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
131                          << TestLog::EndMessage;
132 
133         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
134             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
135     }
136 }
137 
verifyInteger64(tcu::TestContext & testCtx,GLenum target,GLenum name,GLint64 reference)138 void GetBufferParameterIVerifier::verifyInteger64(tcu::TestContext &testCtx, GLenum target, GLenum name,
139                                                   GLint64 reference)
140 {
141     using tcu::TestLog;
142 
143     StateQueryMemoryWriteGuard<GLint> state;
144     glGetBufferParameteriv(target, name, &state);
145 
146     if (!state.verifyValidity(testCtx))
147         return;
148 
149     // check that the converted value would be in the correct range, otherwise checking wont tell us anything
150     if (!de::inRange(reference, (GLint64)std::numeric_limits<GLint>::min(), (GLint64)std::numeric_limits<GLint>::max()))
151         return;
152 
153     if (state != reference)
154     {
155         testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
156                          << TestLog::EndMessage;
157 
158         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
159             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
160     }
161 }
162 
163 class GetBufferParameterI64Verifier : public BufferParamVerifier
164 {
165 public:
166     GetBufferParameterI64Verifier(const glw::Functions &gl, tcu::TestLog &log);
167 
168     void verifyInteger(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint reference);
169     void verifyInteger64(tcu::TestContext &testCtx, GLenum target, GLenum name, GLint64 reference);
170 };
171 
GetBufferParameterI64Verifier(const glw::Functions & gl,tcu::TestLog & log)172 GetBufferParameterI64Verifier::GetBufferParameterI64Verifier(const glw::Functions &gl, tcu::TestLog &log)
173     : BufferParamVerifier(gl, log, "_getbufferparameteri64")
174 {
175 }
176 
verifyInteger(tcu::TestContext & testCtx,GLenum target,GLenum name,GLint reference)177 void GetBufferParameterI64Verifier::verifyInteger(tcu::TestContext &testCtx, GLenum target, GLenum name,
178                                                   GLint reference)
179 {
180     using tcu::TestLog;
181 
182     StateQueryMemoryWriteGuard<GLint64> state;
183     glGetBufferParameteri64v(target, name, &state);
184 
185     if (!state.verifyValidity(testCtx))
186         return;
187 
188     if (state != reference)
189     {
190         testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
191                          << TestLog::EndMessage;
192 
193         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
194             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
195     }
196 }
197 
verifyInteger64(tcu::TestContext & testCtx,GLenum target,GLenum name,GLint64 reference)198 void GetBufferParameterI64Verifier::verifyInteger64(tcu::TestContext &testCtx, GLenum target, GLenum name,
199                                                     GLint64 reference)
200 {
201     using tcu::TestLog;
202 
203     StateQueryMemoryWriteGuard<GLint64> state;
204     glGetBufferParameteri64v(target, name, &state);
205 
206     if (!state.verifyValidity(testCtx))
207         return;
208 
209     if (state != reference)
210     {
211         testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state
212                          << TestLog::EndMessage;
213 
214         if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
215             testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value");
216     }
217 }
218 
219 } // namespace BufferParamVerifiers
220 
221 namespace
222 {
223 
224 using namespace BufferParamVerifiers;
225 
226 // Tests
227 
228 class BufferCase : public ApiCase
229 {
230 public:
BufferCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)231     BufferCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
232         : ApiCase(context, name, description)
233         , m_bufferTarget(0)
234         , m_verifier(verifier)
235         , m_testAllTargets(false)
236     {
237     }
238 
239     virtual void testBuffer(void) = DE_NULL;
240 
test(void)241     void test(void)
242     {
243         const GLenum bufferTargets[] = {
244             GL_ARRAY_BUFFER,      GL_COPY_READ_BUFFER,     GL_TRANSFORM_FEEDBACK_BUFFER, GL_UNIFORM_BUFFER,
245 
246             GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER,         GL_PIXEL_UNPACK_BUFFER};
247 
248         // most test need only to be run with a subset of targets
249         const int targets = m_testAllTargets ? DE_LENGTH_OF_ARRAY(bufferTargets) : 4;
250 
251         for (int ndx = 0; ndx < targets; ++ndx)
252         {
253             m_bufferTarget = bufferTargets[ndx];
254 
255             GLuint bufferId = 0;
256             glGenBuffers(1, &bufferId);
257             glBindBuffer(m_bufferTarget, bufferId);
258             expectError(GL_NO_ERROR);
259 
260             testBuffer();
261 
262             glDeleteBuffers(1, &bufferId);
263             expectError(GL_NO_ERROR);
264         }
265     }
266 
267 protected:
268     GLenum m_bufferTarget;
269     BufferParamVerifier *m_verifier;
270     bool m_testAllTargets;
271 };
272 
273 class BufferSizeCase : public BufferCase
274 {
275 public:
BufferSizeCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)276     BufferSizeCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
277         : BufferCase(context, verifier, name, description)
278     {
279         m_testAllTargets = true;
280     }
281 
testBuffer(void)282     void testBuffer(void)
283     {
284         de::Random rnd(0xabcdef);
285 
286         m_verifier->verifyInteger64(m_testCtx, m_bufferTarget, GL_BUFFER_SIZE, 0);
287 
288         const int numIterations = 16;
289         for (int i = 0; i < numIterations; ++i)
290         {
291             const GLint len = rnd.getInt(0, 1024);
292             glBufferData(m_bufferTarget, len, DE_NULL, GL_STREAM_DRAW);
293             expectError(GL_NO_ERROR);
294 
295             m_verifier->verifyInteger64(m_testCtx, m_bufferTarget, GL_BUFFER_SIZE, len);
296             expectError(GL_NO_ERROR);
297         }
298     }
299 };
300 
301 class BufferUsageCase : public BufferCase
302 {
303 public:
BufferUsageCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)304     BufferUsageCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
305         : BufferCase(context, verifier, name, description)
306     {
307     }
308 
testBuffer(void)309     void testBuffer(void)
310     {
311         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_USAGE, GL_STATIC_DRAW);
312 
313         const GLenum usages[] = {GL_STREAM_DRAW, GL_STREAM_READ,  GL_STREAM_COPY,  GL_STATIC_DRAW, GL_STATIC_READ,
314                                  GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, GL_DYNAMIC_COPY};
315 
316         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(usages); ++ndx)
317         {
318             glBufferData(m_bufferTarget, 16, DE_NULL, usages[ndx]);
319             expectError(GL_NO_ERROR);
320 
321             m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_USAGE, usages[ndx]);
322             expectError(GL_NO_ERROR);
323         }
324     }
325 };
326 
327 class BufferAccessFlagsCase : public BufferCase
328 {
329 public:
BufferAccessFlagsCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)330     BufferAccessFlagsCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
331         : BufferCase(context, verifier, name, description)
332     {
333     }
334 
testBuffer(void)335     void testBuffer(void)
336     {
337         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_ACCESS_FLAGS, 0);
338 
339         const GLenum accessFlags[] = {
340             GL_MAP_READ_BIT,
341 
342             GL_MAP_WRITE_BIT,
343             GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
344             GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
345             GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
346 
347             GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT,
348             GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
349             GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
350             GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
351 
352             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT,
353             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
354             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
355             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
356 
357             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT,
358             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT,
359             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT,
360             GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT |
361                 GL_MAP_INVALIDATE_BUFFER_BIT,
362 
363         };
364 
365         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(accessFlags); ++ndx)
366         {
367             glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY);
368             glMapBufferRange(m_bufferTarget, 0, 16, accessFlags[ndx]);
369             expectError(GL_NO_ERROR);
370 
371             m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_ACCESS_FLAGS, accessFlags[ndx]);
372             expectError(GL_NO_ERROR);
373 
374             glUnmapBuffer(m_bufferTarget);
375             expectError(GL_NO_ERROR);
376         }
377     }
378 };
379 
380 class BufferMappedCase : public BufferCase
381 {
382 public:
BufferMappedCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)383     BufferMappedCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
384         : BufferCase(context, verifier, name, description)
385     {
386     }
387 
testBuffer(void)388     void testBuffer(void)
389     {
390         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAPPED, GL_FALSE);
391 
392         glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY);
393         glMapBufferRange(m_bufferTarget, 0, 16, GL_MAP_WRITE_BIT);
394         expectError(GL_NO_ERROR);
395 
396         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAPPED, GL_TRUE);
397         expectError(GL_NO_ERROR);
398 
399         glUnmapBuffer(m_bufferTarget);
400         expectError(GL_NO_ERROR);
401     }
402 };
403 
404 class BufferOffsetLengthCase : public BufferCase
405 {
406 public:
BufferOffsetLengthCase(Context & context,BufferParamVerifier * verifier,const char * name,const char * description)407     BufferOffsetLengthCase(Context &context, BufferParamVerifier *verifier, const char *name, const char *description)
408         : BufferCase(context, verifier, name, description)
409     {
410     }
411 
testBuffer(void)412     void testBuffer(void)
413     {
414         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_OFFSET, 0);
415         m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_LENGTH, 0);
416 
417         glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY);
418 
419         const struct BufferRange
420         {
421             int offset;
422             int length;
423         } ranges[] = {
424             {0, 16},
425             {4, 12},
426             {0, 12},
427             {8, 8},
428         };
429 
430         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(ranges); ++ndx)
431         {
432             glMapBufferRange(m_bufferTarget, ranges[ndx].offset, ranges[ndx].length, GL_MAP_WRITE_BIT);
433             expectError(GL_NO_ERROR);
434 
435             m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_OFFSET, ranges[ndx].offset);
436             m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_LENGTH, ranges[ndx].length);
437             expectError(GL_NO_ERROR);
438 
439             glUnmapBuffer(m_bufferTarget);
440             expectError(GL_NO_ERROR);
441         }
442     }
443 };
444 
445 class BufferPointerCase : public ApiCase
446 {
447 public:
BufferPointerCase(Context & context,const char * name,const char * description)448     BufferPointerCase(Context &context, const char *name, const char *description) : ApiCase(context, name, description)
449     {
450     }
451 
test(void)452     void test(void)
453     {
454         GLuint bufferId = 0;
455         glGenBuffers(1, &bufferId);
456         glBindBuffer(GL_ARRAY_BUFFER, bufferId);
457         expectError(GL_NO_ERROR);
458 
459         StateQueryMemoryWriteGuard<GLvoid *> initialState;
460         glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &initialState);
461         initialState.verifyValidity(m_testCtx);
462         checkPointerEquals(m_testCtx, initialState, 0);
463 
464         glBufferData(GL_ARRAY_BUFFER, 8, DE_NULL, GL_DYNAMIC_COPY);
465         GLvoid *mapPointer = glMapBufferRange(GL_ARRAY_BUFFER, 0, 8, GL_MAP_READ_BIT);
466         expectError(GL_NO_ERROR);
467 
468         StateQueryMemoryWriteGuard<GLvoid *> mapPointerState;
469         glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &mapPointerState);
470         mapPointerState.verifyValidity(m_testCtx);
471         checkPointerEquals(m_testCtx, mapPointerState, mapPointer);
472 
473         glDeleteBuffers(1, &bufferId);
474         expectError(GL_NO_ERROR);
475     }
476 };
477 
478 } // namespace
479 
480 #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK)                                                 \
481     do                                                                                           \
482     {                                                                                            \
483         for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \
484         {                                                                                        \
485             BufferParamVerifier *verifier = (VERIFIERS)[_verifierNdx];                           \
486             CODE_BLOCK;                                                                          \
487         }                                                                                        \
488     } while (0)
489 
BufferObjectQueryTests(Context & context)490 BufferObjectQueryTests::BufferObjectQueryTests(Context &context)
491     : TestCaseGroup(context, "buffer_object", "Buffer Object Query tests")
492     , m_verifierInt(DE_NULL)
493     , m_verifierInt64(DE_NULL)
494 {
495 }
496 
~BufferObjectQueryTests(void)497 BufferObjectQueryTests::~BufferObjectQueryTests(void)
498 {
499     deinit();
500 }
501 
init(void)502 void BufferObjectQueryTests::init(void)
503 {
504     using namespace BufferParamVerifiers;
505 
506     DE_ASSERT(m_verifierInt == DE_NULL);
507     DE_ASSERT(m_verifierInt64 == DE_NULL);
508 
509     m_verifierInt                    = new GetBufferParameterIVerifier(m_context.getRenderContext().getFunctions(),
510                                                                        m_context.getTestContext().getLog());
511     m_verifierInt64                  = new GetBufferParameterI64Verifier(m_context.getRenderContext().getFunctions(),
512                                                                          m_context.getTestContext().getLog());
513     BufferParamVerifier *verifiers[] = {m_verifierInt, m_verifierInt64};
514 
515     FOR_EACH_VERIFIER(verifiers,
516                       addChild(new BufferSizeCase(m_context, verifier,
517                                                   (std::string("buffer_size") + verifier->getTestNamePostfix()).c_str(),
518                                                   "BUFFER_SIZE")));
519     FOR_EACH_VERIFIER(
520         verifiers, addChild(new BufferUsageCase(m_context, verifier,
521                                                 (std::string("buffer_usage") + verifier->getTestNamePostfix()).c_str(),
522                                                 "BUFFER_USAGE")));
523     FOR_EACH_VERIFIER(verifiers, addChild(new BufferAccessFlagsCase(
524                                      m_context, verifier,
525                                      (std::string("buffer_access_flags") + verifier->getTestNamePostfix()).c_str(),
526                                      "BUFFER_ACCESS_FLAGS")));
527     FOR_EACH_VERIFIER(verifiers,
528                       addChild(new BufferMappedCase(
529                           m_context, verifier, (std::string("buffer_mapped") + verifier->getTestNamePostfix()).c_str(),
530                           "BUFFER_MAPPED")));
531     FOR_EACH_VERIFIER(verifiers, addChild(new BufferOffsetLengthCase(
532                                      m_context, verifier,
533                                      (std::string("buffer_map_offset_length") + verifier->getTestNamePostfix()).c_str(),
534                                      "BUFFER_MAP_OFFSET and BUFFER_MAP_LENGTH")));
535 
536     addChild(new BufferPointerCase(m_context, "buffer_pointer", "GetBufferPointerv"));
537 }
538 
deinit(void)539 void BufferObjectQueryTests::deinit(void)
540 {
541     if (m_verifierInt)
542     {
543         delete m_verifierInt;
544         m_verifierInt = NULL;
545     }
546     if (m_verifierInt64)
547     {
548         delete m_verifierInt64;
549         m_verifierInt64 = NULL;
550     }
551 }
552 
553 } // namespace Functional
554 } // namespace gles3
555 } // namespace deqp
556