Home | History | Annotate | Download | only in functional
      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 
     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 
     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 
     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 
     93 BufferParamVerifier::~BufferParamVerifier ()
     94 {
     95 }
     96 
     97 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 
    111 GetBufferParameterIVerifier::GetBufferParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log)
    112 	: BufferParamVerifier(gl, log, "_getbufferparameteri")
    113 {
    114 }
    115 
    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 
    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 
    167 GetBufferParameterI64Verifier::GetBufferParameterI64Verifier (const glw::Functions& gl, tcu::TestLog& log)
    168 	: BufferParamVerifier(gl, log, "_getbufferparameteri64")
    169 {
    170 }
    171 
    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 
    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:
    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 
    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:
    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 
    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:
    300 	BufferUsageCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description)
    301 		: BufferCase(context, verifier, name, description)
    302 	{
    303 	}
    304 
    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:
    332 	BufferAccessFlagsCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description)
    333 		: BufferCase(context, verifier, name, description)
    334 	{
    335 	}
    336 
    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:
    385 	BufferMappedCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description)
    386 		: BufferCase(context, verifier, name, description)
    387 	{
    388 	}
    389 
    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:
    409 	BufferOffsetLengthCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description)
    410 		: BufferCase(context, verifier, name, description)
    411 	{
    412 	}
    413 
    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:
    451 	BufferPointerCase (Context& context, const char* name, const char* description)
    452 		: ApiCase(context, name, description)
    453 	{
    454 	}
    455 
    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 
    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 
    498 BufferObjectQueryTests::~BufferObjectQueryTests (void)
    499 {
    500 	deinit();
    501 }
    502 
    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 
    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