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