| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.1 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 Integer state query tests |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es31fIntegerStateQueryTests.hpp" |
| #include "tcuTestLog.hpp" |
| #include "gluRenderContext.hpp" |
| #include "gluCallLogWrapper.hpp" |
| #include "gluContextInfo.hpp" |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| #include "deRandom.hpp" |
| #include "glsStateQueryUtil.hpp" |
| |
| namespace deqp |
| { |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| namespace |
| { |
| |
| using gls::StateQueryUtil::StateQueryMemoryWriteGuard; |
| |
| enum VerifierType |
| { |
| VERIFIER_GETBOOLEAN = 0, |
| VERIFIER_GETINTEGER, |
| VERIFIER_GETINTEGER64, |
| VERIFIER_GETFLOAT |
| }; |
| |
| static const char* getVerifierSuffix (VerifierType type) |
| { |
| switch (type) |
| { |
| case VERIFIER_GETBOOLEAN: return "getboolean"; |
| case VERIFIER_GETINTEGER: return "getinteger"; |
| case VERIFIER_GETINTEGER64: return "getinteger64"; |
| case VERIFIER_GETFLOAT: return "getfloat"; |
| default: |
| DE_ASSERT(DE_FALSE); |
| return DE_NULL; |
| } |
| } |
| |
| static bool verifyValue (glu::CallLogWrapper& gl, glw::GLenum target, int refValue, VerifierType type) |
| { |
| switch (type) |
| { |
| case VERIFIER_GETBOOLEAN: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean> value; |
| gl.glGetBooleanv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetBooleanv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value != ((refValue == 0) ? (GL_FALSE) : (GL_TRUE))) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected " << ((refValue == 0) ? (GL_FALSE) : (GL_TRUE)) << ", got " << ((value == 0) ? (GL_FALSE) : (GL_TRUE)) << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetIntegerv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value != refValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected " << refValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER64: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64> value; |
| gl.glGetInteger64v(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetInteger64v"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value != (glw::GLint64)refValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected " << refValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETFLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetFloatv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetFloatv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value != (glw::GLfloat)refValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected " << refValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return DE_NULL; |
| } |
| } |
| |
| static bool verifyMinValue (glu::CallLogWrapper& gl, glw::GLenum target, int minValue, VerifierType type) |
| { |
| switch (type) |
| { |
| case VERIFIER_GETBOOLEAN: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean> value; |
| gl.glGetBooleanv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetBooleanv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (minValue > 0 && value == GL_FALSE) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetIntegerv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value < minValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected greater or equal to " << minValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER64: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64> value; |
| gl.glGetInteger64v(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetInteger64v"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value < minValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected greater or equal to " << minValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETFLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetFloatv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetFloatv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value < minValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected greater or equal to " << minValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return DE_NULL; |
| } |
| } |
| |
| static bool verifyMaxValue (glu::CallLogWrapper& gl, glw::GLenum target, int maxValue, VerifierType type) |
| { |
| switch (type) |
| { |
| case VERIFIER_GETBOOLEAN: |
| { |
| StateQueryMemoryWriteGuard<glw::GLboolean> value; |
| gl.glGetBooleanv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetBooleanv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (maxValue < 0 && value == GL_FALSE) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected GL_TRUE, got GL_FALSE" << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint> value; |
| gl.glGetIntegerv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value > maxValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected less or equal to " << maxValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETINTEGER64: |
| { |
| StateQueryMemoryWriteGuard<glw::GLint64> value; |
| gl.glGetInteger64v(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetInteger64v"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value > maxValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected less or equal to " << maxValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| case VERIFIER_GETFLOAT: |
| { |
| StateQueryMemoryWriteGuard<glw::GLfloat> value; |
| gl.glGetFloatv(target, &value); |
| |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetFloatv"); |
| |
| if (value.isUndefined()) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Get* did not return a value." << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else if (value > maxValue) |
| { |
| gl.getLog() << tcu::TestLog::Message << "Expected less or equal to " << maxValue << ", got " << value << tcu::TestLog::EndMessage; |
| return false; |
| } |
| else |
| return true; |
| } |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return DE_NULL; |
| } |
| } |
| |
| class SampleMaskCase : public TestCase |
| { |
| public: |
| SampleMaskCase (Context& context, const char* name, const char* desc); |
| |
| private: |
| void init (void); |
| IterateResult iterate (void); |
| |
| int m_maxSampleMaskWords; |
| }; |
| |
| SampleMaskCase::SampleMaskCase (Context& context, const char* name, const char* desc) |
| : TestCase (context, name, desc) |
| , m_maxSampleMaskWords (-1) |
| { |
| } |
| |
| void SampleMaskCase::init (void) |
| { |
| const glw::Functions& gl = m_context.getRenderContext().getFunctions(); |
| |
| gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords); |
| m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords << tcu::TestLog::EndMessage; |
| } |
| |
| SampleMaskCase::IterateResult SampleMaskCase::iterate (void) |
| { |
| glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| bool error = false; |
| |
| gl.enableLogging(true); |
| |
| // mask word count ok? |
| if (m_maxSampleMaskWords <= 0) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " << m_maxSampleMaskWords << tcu::TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid limit value"); |
| return STOP; |
| } |
| |
| // initial values |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values"); |
| |
| for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx) |
| { |
| glw::GLint word = 0; |
| gl.glGetIntegeri_v(GL_SAMPLE_MASK_VALUE, ndx, &word); |
| |
| if (word != -1) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Expected all bits set (-1), got " << word << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| } |
| } |
| |
| // random masks |
| { |
| const int numRandomTest = 20; |
| const tcu::ScopedLogSection section (m_testCtx.getLog(), "random", "Random values"); |
| de::Random rnd (0x4312); |
| |
| for (int testNdx = 0; testNdx < numRandomTest; ++testNdx) |
| { |
| const glw::GLint maskIndex = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords); |
| glw::GLint mask = (glw::GLint)(rnd.getUint32()); |
| glw::GLint queriedMask = 0; |
| |
| gl.glSampleMaski(maskIndex, mask); |
| gl.glGetIntegeri_v(GL_SAMPLE_MASK_VALUE, maskIndex, &queriedMask); |
| |
| if (mask != queriedMask) |
| { |
| m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Expected " << mask << ", got " << queriedMask << tcu::TestLog::EndMessage; |
| error = true; |
| } |
| } |
| } |
| |
| if (!error) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid mask value"); |
| |
| return STOP; |
| } |
| |
| class MaxSamplesCase : public TestCase |
| { |
| public: |
| MaxSamplesCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType); |
| private: |
| IterateResult iterate (void); |
| |
| const glw::GLenum m_target; |
| const int m_minValue; |
| const VerifierType m_verifierType; |
| }; |
| |
| MaxSamplesCase::MaxSamplesCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType) |
| : TestCase (context, name, desc) |
| , m_target (target) |
| , m_minValue (minValue) |
| , m_verifierType (verifierType) |
| { |
| } |
| |
| MaxSamplesCase::IterateResult MaxSamplesCase::iterate (void) |
| { |
| glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| |
| gl.enableLogging(true); |
| |
| if (verifyMinValue(gl, m_target, m_minValue, m_verifierType)) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Value not in legal range"); |
| return STOP; |
| } |
| |
| class TexBindingCase : public TestCase |
| { |
| public: |
| TexBindingCase (Context& context, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum bindTarget, VerifierType verifierType); |
| private: |
| void init (void); |
| IterateResult iterate (void); |
| |
| const glw::GLenum m_texTarget; |
| const glw::GLenum m_bindTarget; |
| const VerifierType m_verifierType; |
| }; |
| |
| TexBindingCase::TexBindingCase (Context& context, const char* name, const char* desc, glw::GLenum texTarget, glw::GLenum bindTarget, VerifierType verifierType) |
| : TestCase (context, name, desc) |
| , m_texTarget (texTarget) |
| , m_bindTarget (bindTarget) |
| , m_verifierType (verifierType) |
| { |
| } |
| |
| void TexBindingCase::init (void) |
| { |
| if (m_texTarget == GL_TEXTURE_2D_MULTISAMPLE_ARRAY && !m_context.getContextInfo().isExtensionSupported("GL_OES_texture_storage_multisample_2d_array")) |
| throw tcu::NotSupportedError("Test requires OES_texture_storage_multisample_2d_array extension"); |
| } |
| |
| TexBindingCase::IterateResult TexBindingCase::iterate (void) |
| { |
| glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| bool allOk = true; |
| |
| gl.enableLogging(true); |
| |
| // initial |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial value"); |
| |
| allOk &= verifyValue(gl, m_bindTarget, 0, m_verifierType); |
| } |
| |
| // bind |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After bind"); |
| |
| glw::GLuint texture; |
| |
| gl.glGenTextures(1, &texture); |
| gl.glBindTexture(m_texTarget, texture); |
| GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind texture"); |
| |
| allOk &= verifyValue(gl, m_bindTarget, texture, m_verifierType); |
| |
| gl.glDeleteTextures(1, &texture); |
| } |
| |
| // after delete |
| { |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), "bind", "After delete"); |
| |
| allOk &= verifyValue(gl, m_bindTarget, 0, m_verifierType); |
| } |
| |
| if (allOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| return STOP; |
| } |
| |
| class MinimumValueCase : public TestCase |
| { |
| public: |
| MinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType); |
| private: |
| IterateResult iterate (void); |
| |
| const glw::GLenum m_target; |
| const int m_minValue; |
| const VerifierType m_verifierType; |
| }; |
| |
| MinimumValueCase::MinimumValueCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType) |
| : TestCase (context, name, desc) |
| , m_target (target) |
| , m_minValue (minValue) |
| , m_verifierType (verifierType) |
| { |
| } |
| |
| MinimumValueCase::IterateResult MinimumValueCase::iterate (void) |
| { |
| glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| |
| gl.enableLogging(true); |
| |
| if (verifyMinValue(gl, m_target, m_minValue, m_verifierType)) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| return STOP; |
| } |
| |
| class AlignmentCase : public TestCase |
| { |
| public: |
| AlignmentCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType); |
| private: |
| IterateResult iterate (void); |
| |
| const glw::GLenum m_target; |
| const int m_minValue; |
| const VerifierType m_verifierType; |
| }; |
| |
| AlignmentCase::AlignmentCase (Context& context, const char* name, const char* desc, glw::GLenum target, int minValue, VerifierType verifierType) |
| : TestCase (context, name, desc) |
| , m_target (target) |
| , m_minValue (minValue) |
| , m_verifierType (verifierType) |
| { |
| } |
| |
| AlignmentCase::IterateResult AlignmentCase::iterate (void) |
| { |
| glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); |
| |
| gl.enableLogging(true); |
| |
| if (verifyMaxValue(gl, m_target, m_minValue, m_verifierType)) |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| else |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid value"); |
| return STOP; |
| } |
| |
| } // anonymous |
| |
| IntegerStateQueryTests::IntegerStateQueryTests (Context& context) |
| : TestCaseGroup(context, "integer", "Integer state query tests") |
| { |
| } |
| |
| IntegerStateQueryTests::~IntegerStateQueryTests (void) |
| { |
| } |
| |
| void IntegerStateQueryTests::init (void) |
| { |
| // Verifiers |
| const VerifierType verifiers[] = { VERIFIER_GETBOOLEAN, VERIFIER_GETINTEGER, VERIFIER_GETINTEGER64, VERIFIER_GETFLOAT }; |
| |
| #define FOR_EACH_VERIFIER(X) \ |
| for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \ |
| { \ |
| const char* verifierSuffix = getVerifierSuffix(verifiers[verifierNdx]); \ |
| const VerifierType verifier = verifiers[verifierNdx]; \ |
| this->addChild(X); \ |
| } |
| |
| // No additional verifiers for sample_mask_value |
| this->addChild(new SampleMaskCase(m_context, "sample_mask_value", "Test sample mask value")); |
| |
| FOR_EACH_VERIFIER(new MaxSamplesCase(m_context, (std::string() + "max_color_texture_samples_" + verifierSuffix).c_str(), "Test GL_MAX_COLOR_TEXTURE_SAMPLES", GL_MAX_COLOR_TEXTURE_SAMPLES, 1, verifier)) |
| FOR_EACH_VERIFIER(new MaxSamplesCase(m_context, (std::string() + "max_depth_texture_samples_" + verifierSuffix).c_str(), "Test GL_MAX_DEPTH_TEXTURE_SAMPLES", GL_MAX_DEPTH_TEXTURE_SAMPLES, 1, verifier)) |
| FOR_EACH_VERIFIER(new MaxSamplesCase(m_context, (std::string() + "max_integer_samples_" + verifierSuffix).c_str(), "Test GL_MAX_INTEGER_SAMPLES", GL_MAX_INTEGER_SAMPLES, 1, verifier)) |
| |
| FOR_EACH_VERIFIER(new TexBindingCase(m_context, (std::string() + "texture_binding_2d_multisample_" + verifierSuffix).c_str(), "Test TEXTURE_BINDING_2D_MULTISAMPLE", GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BINDING_2D_MULTISAMPLE, verifier)) |
| FOR_EACH_VERIFIER(new TexBindingCase(m_context, (std::string() + "texture_binding_2d_multisample_array_" + verifierSuffix).c_str(), "Test TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY", GL_TEXTURE_2D_MULTISAMPLE_ARRAY, GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY, verifier)) |
| |
| FOR_EACH_VERIFIER(new MinimumValueCase(m_context, (std::string() + "max_vertex_attrib_relative_offset_" + verifierSuffix).c_str(), "Test MAX_VERTEX_ATTRIB_RELATIVE_OFFSET", GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET, 2047, verifier)) |
| FOR_EACH_VERIFIER(new MinimumValueCase(m_context, (std::string() + "max_vertex_attrib_bindings_" + verifierSuffix).c_str(), "Test MAX_VERTEX_ATTRIB_BINDINGS", GL_MAX_VERTEX_ATTRIB_BINDINGS, 16, verifier)) |
| FOR_EACH_VERIFIER(new MinimumValueCase(m_context, (std::string() + "max_vertex_attrib_stride_" + verifierSuffix).c_str(), "Test MAX_VERTEX_ATTRIB_STRIDE", GL_MAX_VERTEX_ATTRIB_STRIDE, 2048, verifier)) |
| |
| FOR_EACH_VERIFIER(new AlignmentCase(m_context, (std::string() + "shader_storage_buffer_offset_alignment_" + verifierSuffix).c_str(), "Test SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT", GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, 256, verifier)) |
| |
| #undef FOR_EACH_VERIFIER |
| } |
| |
| } // Functional |
| } // gles31 |
| } // deqp |