modules/gles2/functional/es2fImplementationLimitTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.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 Implementation-defined limit tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fImplementationLimitTests.hpp"
  25 #include "tcuTestLog.hpp"
  26 #include "gluDefs.hpp"
  27 #include "gluStrUtil.hpp"
  28 #include "gluRenderContext.hpp"
  29
  30 #include "glwEnums.hpp"
  31 #include "glwFunctions.hpp"
  32
  33 namespace deqp
  34 {
  35 namespace gles2
  36 {
  37 namespace Functional
  38 {
  39
  40 using namespace glw; // GL types
  41
  42 namespace LimitQuery
  43 {
  44
  45 // Query function template.
  46 template<typename T>
  47 T query (const glw::Functions& gl, deUint32 param);
  48
  49 // Compare template.
  50 template<typename T>
  51 inline bool compare (const T& min, const T& reported) { return min <= reported; }
  52
  53 // Types for queries
  54
  55 struct NegInt
  56 {
  57         GLint value;
  58         NegInt (GLint value_) : value(value_) {}
  59 };
  60
  61 std::ostream& operator<< (std::ostream& str, const NegInt& v) { return str << v.value; }
  62
  63 struct FloatRange
  64 {
  65         float min;
  66         float max;
  67         FloatRange (float min_, float max_) : min(min_), max(max_) {}
  68 };
  69
  70 std::ostream& operator<< (std::ostream& str, const FloatRange& range) { return str << range.min << ", " << range.max; }
  71
  72 // For custom formatting
  73 struct Boolean
  74 {
  75         GLboolean value;
  76         Boolean (GLboolean value_) : value(value_) {}
  77 };
  78
  79 std::ostream& operator<< (std::ostream& str, const Boolean& boolean) { return str << (boolean.value ? "GL_TRUE" : "GL_FALSE"); }
  80
  81 // Query function implementations.
  82 template<>
  83 GLint query<GLint> (const glw::Functions& gl, deUint32 param)
  84 {
  85         GLint val = -1;
  86         gl.getIntegerv(param, &val);
  87         return val;
  88 }
  89
  90 template<>
  91 GLfloat query<GLfloat> (const glw::Functions& gl, deUint32 param)
  92 {
  93         GLfloat val = -1000.f;
  94         gl.getFloatv(param, &val);
  95         return val;
  96 }
  97
  98 template<>
  99 NegInt query<NegInt> (const glw::Functions& gl, deUint32 param)
 100 {
 101         return NegInt(query<GLint>(gl, param));
 102 }
 103
 104 template<>
 105 Boolean query<Boolean> (const glw::Functions& gl, deUint32 param)
 106 {
 107         GLboolean val = GL_FALSE;
 108         gl.getBooleanv(param, &val);
 109         return Boolean(val);
 110 }
 111
 112 template<>
 113 FloatRange query<FloatRange> (const glw::Functions& gl, deUint32 param)
 114 {
 115         float v[2] = { -1.0f, -1.0f };
 116         gl.getFloatv(param, &v[0]);
 117         return FloatRange(v[0], v[1]);
 118 }
 119
 120 // Special comparison operators
 121 template<>
 122 bool compare<Boolean> (const Boolean& min, const Boolean& reported)
 123 {
 124         return !min.value || (min.value && reported.value);
 125 }
 126
 127 template<>
 128 bool compare<NegInt> (const NegInt& min, const NegInt& reported)
 129 {
 130         // Reverse comparison.
 131         return reported.value <= min.value;
 132 }
 133
 134 template<>
 135 bool compare<FloatRange> (const FloatRange& min, const FloatRange& reported)
 136 {
 137         return reported.min <= min.min && min.max <= reported.max;
 138 }
 139
 140 } // LimitQuery
 141
 142 using namespace LimitQuery;
 143 using tcu::TestLog;
 144
 145 template<typename T>
 146 class LimitQueryCase : public TestCase
 147 {
 148 public:
 149         LimitQueryCase (Context& context, const char* name, const char* description, deUint32 limit, const T& minRequiredValue)
 150                 : TestCase                              (context, name, description)
 151                 , m_limit                               (limit)
 152                 , m_minRequiredValue    (minRequiredValue)
 153         {
 154         }
 155
 156         IterateResult iterate (void)
 157         {
 158                 const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
 159                 const T                                 value   = query<T>(m_context.getRenderContext().getFunctions(), m_limit);
 160                 GLU_EXPECT_NO_ERROR(gl.getError(), "Query failed");
 161
 162                 const bool isOk = compare<T>(m_minRequiredValue, value);
 163
 164                 m_testCtx.getLog() << TestLog::Message << "Reported: " << value << TestLog::EndMessage;
 165                 m_testCtx.getLog() << TestLog::Message << "Minimum required: " << m_minRequiredValue << TestLog::EndMessage;
 166
 167                 if (!isOk)
 168                         m_testCtx.getLog() << TestLog::Message << "FAIL: reported value is less than minimum required value!" << TestLog::EndMessage;
 169
 170                 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS      : QP_TEST_RESULT_FAIL,
 171                                                                 isOk ? "Pass"                           : "Requirement not satisfied");
 172                 return STOP;
 173         }
 174
 175 private:
 176         deUint32        m_limit;
 177         T                       m_minRequiredValue;
 178 };
 179
 180 ImplementationLimitTests::ImplementationLimitTests (Context& context)
 181         : TestCaseGroup(context, "implementation_limits", "Implementation-defined limits")
 182 {
 183 }
 184
 185 ImplementationLimitTests::~ImplementationLimitTests (void)
 186 {
 187 }
 188
 189 void ImplementationLimitTests::init (void)
 190 {
 191 #define LIMIT_CASE(NAME, PARAM, TYPE, MIN_VAL)  \
 192         addChild(new LimitQueryCase<TYPE>(m_context, #NAME, #PARAM, PARAM, MIN_VAL))
 193
 194         LIMIT_CASE(subpixel_bits,                                               GL_SUBPIXEL_BITS,                                               GLint,          4);
 195         LIMIT_CASE(max_texture_size,                                    GL_MAX_TEXTURE_SIZE,                                    GLint,          64);
 196         LIMIT_CASE(max_cube_map_texture_size,                   GL_MAX_CUBE_MAP_TEXTURE_SIZE,                   GLint,          16);
 197         // GL_MAX_VIEWPORT_DIMS
 198         LIMIT_CASE(aliased_point_size_range,                    GL_ALIASED_POINT_SIZE_RANGE,                    FloatRange,     FloatRange(1,1));
 199         LIMIT_CASE(aliased_line_width_range,                    GL_ALIASED_LINE_WIDTH_RANGE,                    FloatRange,     FloatRange(1,1));
 200 //      LIMIT_CASE(sample_buffers,                                              GL_SAMPLE_BUFFERS,                                              GLint,          0);
 201 //      LIMIT_CASE(samples,                                                             GL_SAMPLES,                                                             GLint,          0);
 202         LIMIT_CASE(num_compressed_texture_formats,              GL_NUM_COMPRESSED_TEXTURE_FORMATS,              GLint,          0);
 203         LIMIT_CASE(num_shader_binary_formats,                   GL_NUM_SHADER_BINARY_FORMATS,                   GLint,          0);
 204         LIMIT_CASE(shader_compiler,                                             GL_SHADER_COMPILER,                                             Boolean,        GL_FALSE);
 205         // Shader precision format
 206         LIMIT_CASE(max_vertex_attribs,                                  GL_MAX_VERTEX_ATTRIBS,                                  GLint,          8);
 207         LIMIT_CASE(max_vertex_uniform_vectors,                  GL_MAX_VERTEX_UNIFORM_VECTORS,                  GLint,          128);
 208         LIMIT_CASE(max_varying_vectors,                                 GL_MAX_VARYING_VECTORS,                                 GLint,          8);
 209         LIMIT_CASE(max_combined_texture_image_units,    GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,    GLint,          8);
 210         LIMIT_CASE(max_vertex_texture_image_units,              GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS,              GLint,          0);
 211         LIMIT_CASE(max_texture_image_units,                             GL_MAX_TEXTURE_IMAGE_UNITS,                             GLint,          8);
 212         LIMIT_CASE(max_fragment_uniform_vectors,                GL_MAX_FRAGMENT_UNIFORM_VECTORS,                GLint,          16);
 213         LIMIT_CASE(max_renderbuffer_size,                               GL_MAX_RENDERBUFFER_SIZE,                               GLint,          1);
 214 }
 215
 216 } // Functional
 217 } // gles2
 218 } // deqp