1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program EGL 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 EGL_EXT_client_extensions tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "teglClientExtensionTests.hpp"
25
26 #include "tcuTestLog.hpp"
27
28 #include "egluUtil.hpp"
29
30 #include "eglwLibrary.hpp"
31 #include "eglwEnums.hpp"
32
33 #include "deStringUtil.hpp"
34 #include "deSTLUtil.hpp"
35
36 #include <vector>
37 #include <set>
38 #include <string>
39 #include <sstream>
40
41 using std::set;
42 using std::string;
43 using std::vector;
44
45 using tcu::TestLog;
46
47 using namespace eglw;
48
49 namespace deqp
50 {
51 namespace egl
52 {
53 namespace
54 {
55
56 static const char *const s_displayExtensionList[] = {
57 "EGL_KHR_config_attribs", "EGL_KHR_lock_surface", "EGL_KHR_image", "EGL_KHR_vg_parent_image",
58 "EGL_KHR_gl_texture_2D_image", "EGL_KHR_gl_texture_cubemap_image", "EGL_KHR_gl_texture_3D_image",
59 "EGL_KHR_gl_renderbuffer_image", "EGL_KHR_reusable_sync", "EGL_KHR_image_base", "EGL_KHR_image_pixmap",
60 "EGL_IMG_context_priority", "EGL_KHR_lock_surface2", "EGL_NV_coverage_sample", "EGL_NV_depth_nonlinear",
61 "EGL_NV_sync", "EGL_KHR_fence_sync", "EGL_HI_clientpixmap", "EGL_HI_colorformats", "EGL_MESA_drm_image",
62 "EGL_NV_post_sub_buffer", "EGL_ANGLE_query_surface_pointer", "EGL_ANGLE_surface_d3d_texture_2d_share_handle",
63 "EGL_NV_coverage_sample_resolve",
64 // "EGL_NV_system_time", \todo [mika] Unclear which one this is
65 "EGL_KHR_stream", "EGL_KHR_stream_consumer_gltexture", "EGL_KHR_stream_producer_eglsurface",
66 "EGL_KHR_stream_producer_aldatalocator", "EGL_KHR_stream_fifo", "EGL_EXT_create_context_robustness",
67 "EGL_ANGLE_d3d_share_handle_client_buffer", "EGL_KHR_create_context", "EGL_KHR_surfaceless_context",
68 "EGL_KHR_stream_cross_process_fd", "EGL_EXT_multiview_window", "EGL_KHR_wait_sync", "EGL_NV_post_convert_rounding",
69 "EGL_NV_native_query", "EGL_NV_3dvision_surface", "EGL_ANDROID_framebuffer_target", "EGL_ANDROID_blob_cache",
70 "EGL_ANDROID_image_native_buffer", "EGL_ANDROID_native_fence_sync", "EGL_ANDROID_recordable", "EGL_EXT_buffer_age",
71 "EGL_EXT_image_dma_buf_import", "EGL_ARM_pixmap_multisample_discard", "EGL_EXT_swap_buffers_with_damage",
72 "EGL_NV_stream_sync", "EGL_KHR_cl_event", "EGL_KHR_get_all_proc_addresses"};
73
74 static const char *const s_clientExtensionList[] = {"EGL_EXT_platform_base", "EGL_EXT_client_extensions",
75 "EGL_EXT_platform_x11", "EGL_KHR_client_get_all_proc_addresses",
76 "EGL_MESA_platform_gbm", "EGL_EXT_platform_wayland"};
77
78 class BaseTest : public TestCase
79 {
80 public:
81 BaseTest(EglTestContext &eglTestCtx);
82 IterateResult iterate(void);
83 };
84
BaseTest(EglTestContext & eglTestCtx)85 BaseTest::BaseTest(EglTestContext &eglTestCtx)
86 : TestCase(eglTestCtx, "base", "Basic tests for EGL_EXT_client_extensions")
87 {
88 }
89
iterate(void)90 TestCase::IterateResult BaseTest::iterate(void)
91 {
92 const Library &egl = m_eglTestCtx.getLibrary();
93 const char *const clientExtesionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
94 const EGLint eglError = egl.getError();
95
96 if (eglError == EGL_BAD_DISPLAY)
97 TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
98 else if (eglError != EGL_SUCCESS)
99 throw eglu::Error(eglError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);
100
101 TCU_CHECK(clientExtesionsStr);
102
103 {
104 bool found = false;
105 std::istringstream stream(clientExtesionsStr);
106 string extension;
107
108 while (std::getline(stream, extension, ' '))
109 {
110 if (extension == "EGL_EXT_client_extensions")
111 {
112 found = true;
113 break;
114 }
115 }
116
117 if (found)
118 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
119 else
120 {
121 m_testCtx.getLog() << TestLog::Message
122 << "eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS) didn't fail, but extension string "
123 "doesn't contain EGL_EXT_client_extensions"
124 << TestLog::EndMessage;
125 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
126 }
127 }
128
129 return STOP;
130 }
131
132 class CheckExtensionsTest : public TestCase
133 {
134 public:
135 CheckExtensionsTest(EglTestContext &eglTestCtx);
136 IterateResult iterate(void);
137 };
138
CheckExtensionsTest(EglTestContext & eglTestCtx)139 CheckExtensionsTest::CheckExtensionsTest(EglTestContext &eglTestCtx)
140 : TestCase(eglTestCtx, "extensions", "Check that returned extensions are client or display extensions")
141 {
142 }
143
iterate(void)144 TestCase::IterateResult CheckExtensionsTest::iterate(void)
145 {
146 const Library &egl = m_eglTestCtx.getLibrary();
147 bool isOk = true;
148 const char *const clientExtensionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
149 const EGLint eglQueryError = egl.getError();
150
151 set<string> knownClientExtensions(s_clientExtensionList,
152 s_clientExtensionList + DE_LENGTH_OF_ARRAY(s_clientExtensionList));
153 set<string> knownDisplayExtensions(s_displayExtensionList,
154 s_displayExtensionList + DE_LENGTH_OF_ARRAY(s_displayExtensionList));
155
156 vector<string> displayExtensions;
157 vector<string> clientExtensions;
158
159 if (eglQueryError == EGL_BAD_DISPLAY)
160 TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
161 else if (eglQueryError != EGL_SUCCESS)
162 throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);
163
164 TCU_CHECK(clientExtensionsStr);
165
166 clientExtensions = de::splitString(clientExtensionsStr, ' ');
167
168 {
169 EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
170
171 displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');
172
173 egl.terminate(display);
174 }
175
176 for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
177 {
178 if (knownDisplayExtensions.find(clientExtensions[extNdx]) != knownDisplayExtensions.end())
179 {
180 m_testCtx.getLog() << TestLog::Message << "'" << clientExtensions[extNdx] << "' is not client extension"
181 << TestLog::EndMessage;
182 isOk = false;
183 }
184 }
185
186 for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
187 {
188 if (knownClientExtensions.find(displayExtensions[extNdx]) != knownClientExtensions.end())
189 {
190 m_testCtx.getLog() << TestLog::Message << "'" << displayExtensions[extNdx] << "' is not display extension"
191 << TestLog::EndMessage;
192 isOk = false;
193 }
194 }
195
196 if (isOk)
197 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
198 else
199 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
200 return STOP;
201 }
202
203 class DisjointTest : public TestCase
204 {
205 public:
206 DisjointTest(EglTestContext &eglTestCtx);
207 IterateResult iterate(void);
208 };
209
DisjointTest(EglTestContext & eglTestCtx)210 DisjointTest::DisjointTest(EglTestContext &eglTestCtx)
211 : TestCase(eglTestCtx, "disjoint", "Check that client and display extensions are disjoint")
212 {
213 }
214
iterate(void)215 TestCase::IterateResult DisjointTest::iterate(void)
216 {
217 const Library &egl = m_eglTestCtx.getLibrary();
218 const char *const clientExtensionsStr = egl.queryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
219 const EGLint eglQueryError = egl.getError();
220
221 if (eglQueryError == EGL_BAD_DISPLAY)
222 TCU_THROW(NotSupportedError, "EGL_EXT_client_extensions not supported");
223 else if (eglQueryError != EGL_SUCCESS)
224 throw eglu::Error(eglQueryError, "eglQueryString()", DE_NULL, __FILE__, __LINE__);
225
226 vector<string> displayExtensions;
227 vector<string> clientExtensions;
228
229 clientExtensions = de::splitString(clientExtensionsStr, ' ');
230
231 {
232 EGLDisplay display = eglu::getAndInitDisplay(m_eglTestCtx.getNativeDisplay());
233
234 displayExtensions = de::splitString(egl.queryString(display, EGL_EXTENSIONS), ' ');
235
236 egl.terminate(display);
237 }
238
239 // Log client extensions
240 {
241 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Client extensions", "Client extensions");
242
243 for (int extNdx = 0; extNdx < (int)clientExtensions.size(); extNdx++)
244 m_testCtx.getLog() << TestLog::Message << clientExtensions[extNdx] << TestLog::EndMessage;
245 }
246
247 // Log display extensions
248 {
249 const tcu::ScopedLogSection section(m_testCtx.getLog(), "Display extensions", "Display extensions");
250
251 for (int extNdx = 0; extNdx < (int)displayExtensions.size(); extNdx++)
252 m_testCtx.getLog() << TestLog::Message << displayExtensions[extNdx] << TestLog::EndMessage;
253 }
254
255 // Check that sets are disjoint
256 {
257 set<string> commonExtensionSet;
258 const set<string> clientExtensionSet(clientExtensions.begin(), clientExtensions.end());
259 const set<string> displayExtensionSet(displayExtensions.begin(), displayExtensions.end());
260
261 for (set<string>::const_iterator iter = clientExtensionSet.begin(); iter != clientExtensionSet.end(); ++iter)
262 {
263 if (displayExtensionSet.find(*iter) != displayExtensionSet.end())
264 commonExtensionSet.insert(*iter);
265 }
266
267 for (set<string>::const_iterator iter = commonExtensionSet.begin(); iter != commonExtensionSet.end(); ++iter)
268 m_testCtx.getLog() << TestLog::Message << "Extension '" << *iter
269 << "' exists in client and display extension sets." << TestLog::EndMessage;
270
271 if (commonExtensionSet.empty())
272 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
273 else
274 {
275 m_testCtx.getLog() << TestLog::Message << "Extension sets are not disjoint" << TestLog::EndMessage;
276 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
277 }
278 }
279
280 return STOP;
281 }
282
283 } // namespace
284
ClientExtensionTests(EglTestContext & eglTestCtx)285 ClientExtensionTests::ClientExtensionTests(EglTestContext &eglTestCtx)
286 : TestCaseGroup(eglTestCtx, "client_extensions", "Test for EGL_EXT_client_extensions")
287 {
288 }
289
init(void)290 void ClientExtensionTests::init(void)
291 {
292 addChild(new BaseTest(m_eglTestCtx));
293 addChild(new DisjointTest(m_eglTestCtx));
294 addChild(new CheckExtensionsTest(m_eglTestCtx));
295 }
296
297 } // namespace egl
298 } // namespace deqp
299