es31fAndroidExtensionPackES31ATests.cpp revision 9e574351a4724975bf91b1e74ccae8786d711386 
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
35namespace deqp
36{
37namespace gles31
38{
39namespace Functional
40{
41namespace
42{
43
44static std::string genExtensionTestName (const char* extensionName)
45{
46	DE_ASSERT(deStringBeginsWith(extensionName, "GL_"));
47	return de::toLower(std::string(extensionName + 3));
48}
49
50class ExtensionPackTestCase : public TestCase
51{
52public:
53			ExtensionPackTestCase	(Context& context, const char* name, const char* description);
54
55protected:
56	void	init					(void);
57};
58
59ExtensionPackTestCase::ExtensionPackTestCase (Context& context, const char* name, const char* description)
60	: TestCase	(context, name, description)
61{
62}
63
64void 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
70class ImplementationLimitCase : public ExtensionPackTestCase
71{
72public:
73							ImplementationLimitCase	(Context& context, const char* name, const char* description, glw::GLenum target, int limit);
74
75private:
76	IterateResult			iterate					(void);
77
78	const glw::GLenum		m_target;
79	const int				m_limit;
80};
81
82ImplementationLimitCase::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
89ImplementationLimitCase::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
119class SubExtensionCase : public ExtensionPackTestCase
120{
121public:
122						SubExtensionCase	(Context& context, const char* name, const char* description, const char* extension);
123
124private:
125	IterateResult		iterate				(void);
126
127	const std::string	m_extension;
128};
129
130SubExtensionCase::SubExtensionCase (Context& context, const char* name, const char* description, const char* extension)
131	: ExtensionPackTestCase	(context, name, description)
132	, m_extension			(extension)
133{
134}
135
136SubExtensionCase::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
167AndroidExtensionPackES31ATests::AndroidExtensionPackES31ATests (Context& context)
168	: TestCaseGroup(context, "android_extension_pack", "ANDROID_extension_pack_es31a extension tests")
169{
170}
171
172AndroidExtensionPackES31ATests::~AndroidExtensionPackES31ATests (void)
173{
174}
175
176void 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		const std::vector<tcu::TestNode*>&	children		= shaderLibrary.loadShaderFile("shaders/android_extension_pack.test");
261		tcu::TestCaseGroup* const			group			= new tcu::TestCaseGroup(m_testCtx, "shaders", "Shader tests", children);
262
263		addChild(group);
264	}
265}
266
267} // Functional
268} // gles31
269} // deqp
270