1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 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 ANDROID_extension_pack_es31a tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fAndroidExtensionPackES31ATests.hpp" 25 #include "glsStateQueryUtil.hpp" 26 #include "glsShaderLibrary.hpp" 27 #include "tcuTestLog.hpp" 28 #include "gluCallLogWrapper.hpp" 29 #include "gluContextInfo.hpp" 30 #include "gluStrUtil.hpp" 31 #include "glwFunctions.hpp" 32 #include "glwEnums.hpp" 33 #include "deStringUtil.hpp" 34 35 namespace deqp 36 { 37 namespace gles31 38 { 39 namespace Functional 40 { 41 namespace 42 { 43 44 static std::string genExtensionTestName (const char* extensionName) 45 { 46 DE_ASSERT(deStringBeginsWith(extensionName, "GL_")); 47 return de::toLower(std::string(extensionName + 3)); 48 } 49 50 class ExtensionPackTestCase : public TestCase 51 { 52 public: 53 ExtensionPackTestCase (Context& context, const char* name, const char* description); 54 55 protected: 56 void init (void); 57 }; 58 59 ExtensionPackTestCase::ExtensionPackTestCase (Context& context, const char* name, const char* description) 60 : TestCase (context, name, description) 61 { 62 } 63 64 void ExtensionPackTestCase::init (void) 65 { 66 if (!m_context.getContextInfo().isExtensionSupported("GL_ANDROID_extension_pack_es31a")) 67 throw tcu::NotSupportedError("Test requires GL_ANDROID_extension_pack_es31a extension"); 68 } 69 70 class ImplementationLimitCase : public ExtensionPackTestCase 71 { 72 public: 73 ImplementationLimitCase (Context& context, const char* name, const char* description, glw::GLenum target, int limit); 74 75 private: 76 IterateResult iterate (void); 77 78 const glw::GLenum m_target; 79 const int m_limit; 80 }; 81 82 ImplementationLimitCase::ImplementationLimitCase (Context& context, const char* name, const char* description, glw::GLenum target, int limit) 83 : ExtensionPackTestCase (context, name, description) 84 , m_target (target) 85 , m_limit (limit) 86 { 87 } 88 89 ImplementationLimitCase::IterateResult ImplementationLimitCase::iterate (void) 90 { 91 using namespace gls::StateQueryUtil; 92 93 glu::CallLogWrapper gl (m_context.getRenderContext().getFunctions(), m_testCtx.getLog()); 94 StateQueryMemoryWriteGuard<glw::GLint> result; 95 96 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 97 m_testCtx.getLog() 98 << tcu::TestLog::Message 99 << "Querying " << glu::getGettableStateName(m_target) << ", expecting at least " << m_limit 100 << tcu::TestLog::EndMessage; 101 102 gl.enableLogging(true); 103 gl.glGetIntegerv(m_target, &result); 104 GLU_EXPECT_NO_ERROR(gl.glGetError(), "implementation limit query failed"); 105 106 if (result.verifyValidity(m_testCtx) && result < m_limit) 107 { 108 m_testCtx.getLog() 109 << tcu::TestLog::Message 110 << "// ERROR: Got " << result << ", expected at least " << m_limit 111 << tcu::TestLog::EndMessage; 112 113 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Too low implementation limit"); 114 } 115 116 return STOP; 117 } 118 119 class SubExtensionCase : public ExtensionPackTestCase 120 { 121 public: 122 SubExtensionCase (Context& context, const char* name, const char* description, const char* extension); 123 124 private: 125 IterateResult iterate (void); 126 127 const std::string m_extension; 128 }; 129 130 SubExtensionCase::SubExtensionCase (Context& context, const char* name, const char* description, const char* extension) 131 : ExtensionPackTestCase (context, name, description) 132 , m_extension (extension) 133 { 134 } 135 136 SubExtensionCase::IterateResult SubExtensionCase::iterate (void) 137 { 138 m_testCtx.getLog() 139 << tcu::TestLog::Message 140 << "Verifying that extension \"" << m_extension << "\" is supported." 141 << tcu::TestLog::EndMessage; 142 143 if (m_context.getContextInfo().isExtensionSupported(m_extension.c_str())) 144 { 145 m_testCtx.getLog() 146 << tcu::TestLog::Message 147 << "Extension is supported." 148 << tcu::TestLog::EndMessage; 149 150 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 151 } 152 else 153 { 154 m_testCtx.getLog() 155 << tcu::TestLog::Message 156 << "Error, extension is not supported." 157 << tcu::TestLog::EndMessage; 158 159 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Required extension not supported"); 160 } 161 162 return STOP; 163 } 164 165 } //anonymous 166 167 AndroidExtensionPackES31ATests::AndroidExtensionPackES31ATests (Context& context) 168 : TestCaseGroup(context, "android_extension_pack", "ANDROID_extension_pack_es31a extension tests") 169 { 170 } 171 172 AndroidExtensionPackES31ATests::~AndroidExtensionPackES31ATests (void) 173 { 174 } 175 176 void AndroidExtensionPackES31ATests::init (void) 177 { 178 // .limits 179 { 180 static const struct 181 { 182 const char* name; 183 glw::GLenum target; 184 int limit; 185 } limits[] = 186 { 187 { 188 "max_fragment_atomic_counter_buffers", 189 GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, 190 1 191 }, 192 { 193 "max_fragment_atomic_counters", 194 GL_MAX_FRAGMENT_ATOMIC_COUNTERS, 195 8 196 }, 197 { 198 "max_fragment_image_uniforms", 199 GL_MAX_FRAGMENT_IMAGE_UNIFORMS, 200 4 201 }, 202 { 203 "max_fragment_shader_storage_blocks", 204 GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS, 205 4 206 }, 207 }; 208 209 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "limits", "Implementation limits"); 210 addChild(group); 211 212 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(limits); ++ndx) 213 group->addChild(new ImplementationLimitCase(m_context, 214 limits[ndx].name, 215 (std::string() + "Check " + limits[ndx].name + " is at least " + de::toString(limits[ndx].limit)).c_str(), 216 limits[ndx].target, 217 limits[ndx].limit)); 218 } 219 220 // .extensions 221 { 222 static const char* const subExtensions[] = 223 { 224 "GL_KHR_debug", 225 "GL_KHR_texture_compression_astc_ldr", 226 "GL_KHR_blend_equation_advanced", 227 "GL_OES_sample_shading", 228 "GL_OES_sample_variables", 229 "GL_OES_shader_image_atomic", 230 "GL_OES_shader_multisample_interpolation", 231 "GL_OES_texture_stencil8", 232 "GL_OES_texture_storage_multisample_2d_array", 233 "GL_EXT_copy_image", 234 "GL_EXT_draw_buffers_indexed", 235 "GL_EXT_geometry_shader", 236 "GL_EXT_gpu_shader5", 237 "GL_EXT_primitive_bounding_box", 238 "GL_EXT_shader_io_blocks", 239 "GL_EXT_tessellation_shader", 240 "GL_EXT_texture_border_clamp", 241 "GL_EXT_texture_buffer", 242 "GL_EXT_texture_cube_map_array", 243 "GL_EXT_texture_sRGB_decode", 244 }; 245 246 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "extensions", "Required extensions"); 247 addChild(group); 248 249 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(subExtensions); ++ndx) 250 { 251 const std::string name = genExtensionTestName(subExtensions[ndx]); 252 const std::string description = "Check that extension " + name + " is supported if extension pack is supported"; 253 group->addChild(new SubExtensionCase(m_context, name.c_str(), description.c_str(), subExtensions[ndx])); 254 } 255 } 256 257 // .shaders 258 { 259 gls::ShaderLibrary shaderLibrary (m_testCtx, m_context.getRenderContext(), m_context.getContextInfo()); 260 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "shaders", "Shader tests"); 261 262 { 263 const std::vector<tcu::TestNode*>& children = shaderLibrary.loadShaderFile("shaders/es31/android_extension_pack.test"); 264 tcu::TestCaseGroup* const groupES31 = new tcu::TestCaseGroup(m_testCtx, "es31", "GLSL ES 3.1 Shader tests", children); 265 266 group->addChild(groupES31); 267 } 268 269 { 270 const std::vector<tcu::TestNode*>& children = shaderLibrary.loadShaderFile("shaders/es32/android_extension_pack.test"); 271 tcu::TestCaseGroup* const groupES32 = new tcu::TestCaseGroup(m_testCtx, "es32", "GLSL ES 3.2 Shader tests", children); 272 273 group->addChild(groupES32); 274 } 275 276 addChild(group); 277 } 278 } 279 280 } // Functional 281 } // gles31 282 } // deqp 283
