| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.0 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Buffer Object Query tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fBufferObjectQueryTests.hpp" |
| #include "glsStateQueryUtil.hpp" |
| #include "es3fApiCase.hpp" |
| #include "gluRenderContext.hpp" |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| #include "deRandom.hpp" |
| #include "deMath.h" |
| |
| #include <limits> |
| |
| using namespace glw; // GLint and other GL types |
| using deqp::gls::StateQueryUtil::StateQueryMemoryWriteGuard; |
| |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| namespace BufferParamVerifiers |
| { |
| |
| void checkIntEquals (tcu::TestContext& testCtx, GLint got, GLint expected) |
| { |
| using tcu::TestLog; |
| |
| if (got != expected) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value"); |
| } |
| } |
| |
| void checkPointerEquals (tcu::TestContext& testCtx, const void* got, const void* expected) |
| { |
| using tcu::TestLog; |
| |
| if (got != expected) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: Expected " << expected << "; got " << got << TestLog::EndMessage; |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got invalid value"); |
| } |
| } |
| |
| class BufferParamVerifier : protected glu::CallLogWrapper |
| { |
| public: |
| BufferParamVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix); |
| virtual ~BufferParamVerifier (); // make GCC happy |
| |
| const char* getTestNamePostfix (void) const; |
| |
| virtual void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) = DE_NULL; |
| virtual void verifyInteger64 (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint64 reference) = DE_NULL; |
| private: |
| const char* const m_testNamePostfix; |
| }; |
| |
| BufferParamVerifier::BufferParamVerifier (const glw::Functions& gl, tcu::TestLog& log, const char* testNamePostfix) |
| : glu::CallLogWrapper (gl, log) |
| , m_testNamePostfix (testNamePostfix) |
| { |
| enableLogging(true); |
| } |
| |
| BufferParamVerifier::~BufferParamVerifier () |
| { |
| } |
| |
| const char* BufferParamVerifier::getTestNamePostfix (void) const |
| { |
| return m_testNamePostfix; |
| } |
| |
| class GetBufferParameterIVerifier : public BufferParamVerifier |
| { |
| public: |
| GetBufferParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log); |
| |
| void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference); |
| void verifyInteger64 (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint64 reference); |
| }; |
| |
| GetBufferParameterIVerifier::GetBufferParameterIVerifier (const glw::Functions& gl, tcu::TestLog& log) |
| : BufferParamVerifier(gl, log, "_getbufferparameteri") |
| { |
| } |
| |
| void GetBufferParameterIVerifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint> state; |
| glGetBufferParameteriv(target, name, &state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state != reference) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| } |
| } |
| |
| void GetBufferParameterIVerifier::verifyInteger64 (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint64 reference) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint> state; |
| glGetBufferParameteriv(target, name, &state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| // check that the converted value would be in the correct range, otherwise checking wont tell us anything |
| if (!de::inRange(reference, (GLint64)std::numeric_limits<GLint>::min(), (GLint64)std::numeric_limits<GLint>::max())) |
| return; |
| |
| if (state != reference) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| } |
| } |
| |
| class GetBufferParameterI64Verifier : public BufferParamVerifier |
| { |
| public: |
| GetBufferParameterI64Verifier (const glw::Functions& gl, tcu::TestLog& log); |
| |
| void verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference); |
| void verifyInteger64 (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint64 reference); |
| }; |
| |
| GetBufferParameterI64Verifier::GetBufferParameterI64Verifier (const glw::Functions& gl, tcu::TestLog& log) |
| : BufferParamVerifier(gl, log, "_getbufferparameteri64") |
| { |
| } |
| |
| void GetBufferParameterI64Verifier::verifyInteger (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint reference) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint64> state; |
| glGetBufferParameteri64v(target, name, &state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state != reference) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| } |
| } |
| |
| void GetBufferParameterI64Verifier::verifyInteger64 (tcu::TestContext& testCtx, GLenum target, GLenum name, GLint64 reference) |
| { |
| using tcu::TestLog; |
| |
| StateQueryMemoryWriteGuard<GLint64> state; |
| glGetBufferParameteri64v(target, name, &state); |
| |
| if (!state.verifyValidity(testCtx)) |
| return; |
| |
| if (state != reference) |
| { |
| testCtx.getLog() << TestLog::Message << "// ERROR: expected " << reference << "; got " << state << TestLog::EndMessage; |
| |
| if (testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| } |
| } |
| |
| |
| } // BufferParamVerifiers |
| |
| namespace |
| { |
| |
| using namespace BufferParamVerifiers; |
| |
| // Tests |
| |
| class BufferCase : public ApiCase |
| { |
| public: |
| BufferCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : ApiCase (context, name, description) |
| , m_bufferTarget (0) |
| , m_verifier (verifier) |
| , m_testAllTargets (false) |
| { |
| } |
| |
| virtual void testBuffer (void) = DE_NULL; |
| |
| void test (void) |
| { |
| const GLenum bufferTargets[] = |
| { |
| GL_ARRAY_BUFFER, GL_COPY_READ_BUFFER, |
| GL_TRANSFORM_FEEDBACK_BUFFER, GL_UNIFORM_BUFFER, |
| |
| GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER, |
| GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER |
| }; |
| |
| // most test need only to be run with a subset of targets |
| const int targets = m_testAllTargets ? DE_LENGTH_OF_ARRAY(bufferTargets) : 4; |
| |
| for (int ndx = 0; ndx < targets; ++ndx) |
| { |
| m_bufferTarget = bufferTargets[ndx]; |
| |
| GLuint bufferId = 0; |
| glGenBuffers(1, &bufferId); |
| glBindBuffer(m_bufferTarget, bufferId); |
| expectError(GL_NO_ERROR); |
| |
| testBuffer(); |
| |
| glDeleteBuffers(1, &bufferId); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| |
| protected: |
| GLenum m_bufferTarget; |
| BufferParamVerifier* m_verifier; |
| bool m_testAllTargets; |
| }; |
| |
| class BufferSizeCase : public BufferCase |
| { |
| public: |
| BufferSizeCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : BufferCase(context, verifier, name, description) |
| { |
| m_testAllTargets = true; |
| } |
| |
| void testBuffer (void) |
| { |
| de::Random rnd(0xabcdef); |
| |
| m_verifier->verifyInteger64(m_testCtx, m_bufferTarget, GL_BUFFER_SIZE, 0); |
| |
| const int numIterations = 16; |
| for (int i = 0; i < numIterations; ++i) |
| { |
| const GLint len = rnd.getInt(0, 1024); |
| glBufferData(m_bufferTarget, len, DE_NULL, GL_STREAM_DRAW); |
| expectError(GL_NO_ERROR); |
| |
| m_verifier->verifyInteger64(m_testCtx, m_bufferTarget, GL_BUFFER_SIZE, len); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class BufferUsageCase : public BufferCase |
| { |
| public: |
| BufferUsageCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : BufferCase(context, verifier, name, description) |
| { |
| } |
| |
| void testBuffer (void) |
| { |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_USAGE, GL_STATIC_DRAW); |
| |
| const GLenum usages[] = |
| { |
| GL_STREAM_DRAW, GL_STREAM_READ, |
| GL_STREAM_COPY, GL_STATIC_DRAW, |
| GL_STATIC_READ, GL_STATIC_COPY, |
| GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, |
| GL_DYNAMIC_COPY |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(usages); ++ndx) |
| { |
| glBufferData(m_bufferTarget, 16, DE_NULL, usages[ndx]); |
| expectError(GL_NO_ERROR); |
| |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_USAGE, usages[ndx]); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class BufferAccessFlagsCase : public BufferCase |
| { |
| public: |
| BufferAccessFlagsCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : BufferCase(context, verifier, name, description) |
| { |
| } |
| |
| void testBuffer (void) |
| { |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_ACCESS_FLAGS, 0); |
| |
| const GLenum accessFlags[] = |
| { |
| GL_MAP_READ_BIT, |
| |
| GL_MAP_WRITE_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| |
| GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT, |
| |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(accessFlags); ++ndx) |
| { |
| glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY); |
| glMapBufferRange(m_bufferTarget, 0, 16, accessFlags[ndx]); |
| expectError(GL_NO_ERROR); |
| |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_ACCESS_FLAGS, accessFlags[ndx]); |
| expectError(GL_NO_ERROR); |
| |
| glUnmapBuffer(m_bufferTarget); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class BufferMappedCase : public BufferCase |
| { |
| public: |
| BufferMappedCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : BufferCase(context, verifier, name, description) |
| { |
| } |
| |
| void testBuffer (void) |
| { |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAPPED, GL_FALSE); |
| |
| glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY); |
| glMapBufferRange(m_bufferTarget, 0, 16, GL_MAP_WRITE_BIT); |
| expectError(GL_NO_ERROR); |
| |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAPPED, GL_TRUE); |
| expectError(GL_NO_ERROR); |
| |
| glUnmapBuffer(m_bufferTarget); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| class BufferOffsetLengthCase : public BufferCase |
| { |
| public: |
| BufferOffsetLengthCase (Context& context, BufferParamVerifier* verifier, const char* name, const char* description) |
| : BufferCase(context, verifier, name, description) |
| { |
| } |
| |
| void testBuffer (void) |
| { |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_OFFSET, 0); |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_LENGTH, 0); |
| |
| glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_COPY); |
| |
| const struct BufferRange |
| { |
| int offset; |
| int length; |
| } ranges[] = |
| { |
| { 0, 16 }, |
| { 4, 12 }, |
| { 0, 12 }, |
| { 8, 8 }, |
| }; |
| |
| for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(ranges); ++ndx) |
| { |
| glMapBufferRange(m_bufferTarget, ranges[ndx].offset, ranges[ndx].length, GL_MAP_WRITE_BIT); |
| expectError(GL_NO_ERROR); |
| |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_OFFSET, ranges[ndx].offset); |
| m_verifier->verifyInteger(m_testCtx, m_bufferTarget, GL_BUFFER_MAP_LENGTH, ranges[ndx].length); |
| expectError(GL_NO_ERROR); |
| |
| glUnmapBuffer(m_bufferTarget); |
| expectError(GL_NO_ERROR); |
| } |
| } |
| }; |
| |
| class BufferPointerCase : public ApiCase |
| { |
| public: |
| BufferPointerCase (Context& context, const char* name, const char* description) |
| : ApiCase(context, name, description) |
| { |
| } |
| |
| void test (void) |
| { |
| GLuint bufferId = 0; |
| glGenBuffers(1, &bufferId); |
| glBindBuffer(GL_ARRAY_BUFFER, bufferId); |
| expectError(GL_NO_ERROR); |
| |
| StateQueryMemoryWriteGuard<GLvoid*> initialState; |
| glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &initialState); |
| initialState.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, initialState, 0); |
| |
| glBufferData(GL_ARRAY_BUFFER, 8, DE_NULL, GL_DYNAMIC_COPY); |
| GLvoid* mapPointer = glMapBufferRange(GL_ARRAY_BUFFER, 0, 8, GL_MAP_READ_BIT); |
| expectError(GL_NO_ERROR); |
| |
| StateQueryMemoryWriteGuard<GLvoid*> mapPointerState; |
| glGetBufferPointerv(GL_ARRAY_BUFFER, GL_BUFFER_MAP_POINTER, &mapPointerState); |
| mapPointerState.verifyValidity(m_testCtx); |
| checkPointerEquals(m_testCtx, mapPointerState, mapPointer); |
| |
| glDeleteBuffers(1, &bufferId); |
| expectError(GL_NO_ERROR); |
| } |
| }; |
| |
| } // anonymous |
| |
| #define FOR_EACH_VERIFIER(VERIFIERS, CODE_BLOCK) \ |
| for (int _verifierNdx = 0; _verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); _verifierNdx++) \ |
| { \ |
| BufferParamVerifier* verifier = (VERIFIERS)[_verifierNdx]; \ |
| CODE_BLOCK; \ |
| } |
| |
| BufferObjectQueryTests::BufferObjectQueryTests (Context& context) |
| : TestCaseGroup (context, "buffer_object", "Buffer Object Query tests") |
| , m_verifierInt (DE_NULL) |
| , m_verifierInt64 (DE_NULL) |
| { |
| } |
| |
| BufferObjectQueryTests::~BufferObjectQueryTests (void) |
| { |
| deinit(); |
| } |
| |
| void BufferObjectQueryTests::init (void) |
| { |
| using namespace BufferParamVerifiers; |
| |
| DE_ASSERT(m_verifierInt == DE_NULL); |
| DE_ASSERT(m_verifierInt64 == DE_NULL); |
| |
| m_verifierInt = new GetBufferParameterIVerifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); |
| m_verifierInt64 = new GetBufferParameterI64Verifier (m_context.getRenderContext().getFunctions(), m_context.getTestContext().getLog()); |
| BufferParamVerifier* verifiers[] = {m_verifierInt, m_verifierInt64}; |
| |
| FOR_EACH_VERIFIER(verifiers, addChild(new BufferSizeCase (m_context, verifier, (std::string("buffer_size") + verifier->getTestNamePostfix()).c_str(), "BUFFER_SIZE"))); |
| FOR_EACH_VERIFIER(verifiers, addChild(new BufferUsageCase (m_context, verifier, (std::string("buffer_usage") + verifier->getTestNamePostfix()).c_str(), "BUFFER_USAGE"))); |
| FOR_EACH_VERIFIER(verifiers, addChild(new BufferAccessFlagsCase (m_context, verifier, (std::string("buffer_access_flags") + verifier->getTestNamePostfix()).c_str(), "BUFFER_ACCESS_FLAGS"))); |
| FOR_EACH_VERIFIER(verifiers, addChild(new BufferMappedCase (m_context, verifier, (std::string("buffer_mapped") + verifier->getTestNamePostfix()).c_str(), "BUFFER_MAPPED"))); |
| 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"))); |
| |
| addChild(new BufferPointerCase(m_context, "buffer_pointer", "GetBufferPointerv")); |
| } |
| |
| void BufferObjectQueryTests::deinit (void) |
| { |
| if (m_verifierInt) |
| { |
| delete m_verifierInt; |
| m_verifierInt = NULL; |
| } |
| if (m_verifierInt64) |
| { |
| delete m_verifierInt64; |
| m_verifierInt64 = NULL; |
| } |
| } |
| |
| } // Functional |
| } // gles3 |
| } // deqp |