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