1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <chrono>
16 #include <thread>
17 #include <unistd.h>
18 #include <gtest/gtest.h>
19
20 #include <EGL/egl.h>
21 #include <EGL/eglext.h>
22 #include <GLES3/gl3.h>
23 #include <GLES3/gl31.h>
24 #include <GLES3/gl32.h>
25
26 #include <surface.h>
27 #include <window.h>
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS::Rosen {
33 constexpr int32_t EGL_CONTEXT_CLIENT_VERSION_NUM = 2;
34
35 class BufferProcTest : public IBufferConsumerListenerClazz {
36 virtual void OnBufferAvailable() override;
37 };
38
OnBufferAvailable()39 void BufferProcTest::OnBufferAvailable()
40 {
41 }
42
43 class OpenglWrapperApiTest : public testing::Test {
44 public:
45 static void SetUpTestCase();
46 static void TearDownTestCase();
47
48 static inline EGLDisplay eglDisplay_ = EGL_NO_DISPLAY;
49 static inline EGLConfig eglConfig_ = EGL_NO_CONFIG_KHR;
50 static inline EGLContext eglContext_ = EGL_NO_CONTEXT;
51 static inline EGLSurface eglSurface_ = EGL_NO_SURFACE;
52 static inline sptr<OHOS::Surface> cSurface_ = nullptr;
53 static inline sptr<OHOS::Surface> pSurface_ = nullptr;
54 static inline struct NativeWindow *gWindow_ = nullptr;
55 };
56
SetUpTestCase()57 void OpenglWrapperApiTest::SetUpTestCase()
58 {
59 eglDisplay_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
60 }
61
TearDownTestCase()62 void OpenglWrapperApiTest::TearDownTestCase()
63 {
64 eglDisplay_ = EGL_NO_DISPLAY;
65 }
66
67 /*
68 * Function: eglGetDisplay
69 * Type: Function
70 * Rank: Important(2)
71 * EnvConditions: N/A
72 * CaseDescription: 1. call eglGetDisplay
73 * 2. check ret
74 */
75 HWTEST_F(OpenglWrapperApiTest, eglGetDisplay, TestSize.Level0)
76 {
77 // normal
78 EGLDisplay disp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
79 EXPECT_NE(disp, EGL_NO_DISPLAY);
80
81 EGLint error = eglGetError();
82 EXPECT_EQ(error, EGL_SUCCESS);
83
84 // abnormal
85 disp = eglGetDisplay((EGLNativeDisplayType)1);
86 EXPECT_EQ(disp, EGL_NO_DISPLAY);
87
88 error = eglGetError();
89 EXPECT_EQ(error, EGL_BAD_PARAMETER);
90 }
91
92 /*
93 * Function: eglInitialize
94 * Type: Function
95 * Rank: Important(2)
96 * EnvConditions: N/A
97 * CaseDescription: 1. call eglInitialize
98 * 2. check ret
99 */
100 HWTEST_F(OpenglWrapperApiTest, eglInitialize, TestSize.Level0)
101 {
102 EGLint major, minor;
103 // abnormal
104 EGLBoolean ret = eglInitialize(nullptr, &major, &minor);
105 EXPECT_EQ(ret, EGL_FALSE);
106
107 EGLint error = eglGetError();
108 EXPECT_EQ(error, EGL_BAD_DISPLAY);
109
110 // normal
111 ret = eglInitialize(eglDisplay_, &major, &minor);
112 EXPECT_EQ(ret, EGL_TRUE);
113 EXPECT_GE(major, 0);
114 EXPECT_GE(minor, 0);
115
116 error = eglGetError();
117 EXPECT_EQ(error, EGL_SUCCESS);
118 }
119
120 /*
121 * Function: eglBindAPI
122 * Type: Function
123 * Rank: Important(2)
124 * EnvConditions: N/A
125 * CaseDescription: 1. call eglBindAPI
126 * 2. check ret
127 */
128 HWTEST_F(OpenglWrapperApiTest, eglBindAPI, TestSize.Level0)
129 {
130 // abnormal
131 EGLBoolean ret = eglBindAPI(1);
132 EXPECT_EQ(ret, EGL_FALSE);
133
134 EGLint error = eglGetError();
135 EXPECT_EQ(error, EGL_BAD_PARAMETER);
136
137 // normal
138 ret = eglBindAPI(EGL_OPENGL_ES_API);
139 EXPECT_EQ(ret, EGL_TRUE);
140
141 error = eglGetError();
142 EXPECT_EQ(error, EGL_SUCCESS);
143 }
144
145 /*
146 * Function: eglChooseConfig
147 * Type: Function
148 * Rank: Important(2)
149 * EnvConditions: N/A
150 * CaseDescription: 1. call eglChooseConfig
151 * 2. check ret
152 */
153 HWTEST_F(OpenglWrapperApiTest, eglChooseConfig, TestSize.Level0)
154 {
155 EGLint count;
156 EGLint configAttribs[] = { EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 8,
157 EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8,
158 EGL_ALPHA_SIZE, 8, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_NONE };
159 // abnormal
160 EGLBoolean ret = eglChooseConfig(nullptr, configAttribs, &eglConfig_, 1, &count);
161 EXPECT_EQ(ret, EGL_FALSE);
162
163 EGLint error = eglGetError();
164 EXPECT_EQ(error, EGL_BAD_DISPLAY);
165
166 // normal
167 ret = eglChooseConfig(eglDisplay_, configAttribs, &eglConfig_, 1, &count);
168 EXPECT_EQ(ret, EGL_TRUE);
169 EXPECT_GE(count, 1);
170
171 error = eglGetError();
172 EXPECT_EQ(error, EGL_SUCCESS);
173 }
174
175 /*
176 * Function: eglCreateContext
177 * Type: Function
178 * Rank: Important(2)
179 * EnvConditions: N/A
180 * CaseDescription: 1. call eglCreateContext
181 * 2. check ret
182 */
183 HWTEST_F(OpenglWrapperApiTest, eglCreateContext, TestSize.Level0)
184 {
185 const EGLint contextAttribs[] = { EGL_CONTEXT_CLIENT_VERSION,
186 EGL_CONTEXT_CLIENT_VERSION_NUM, EGL_NONE };
187
188 // abnormal
189 eglContext_ = eglCreateContext(nullptr, eglConfig_, EGL_NO_CONTEXT, contextAttribs);
190 EXPECT_EQ(eglContext_, EGL_NO_CONTEXT);
191
192 EGLint error = eglGetError();
193 EXPECT_EQ(error, EGL_BAD_DISPLAY);
194
195 // normal
196 eglContext_ = eglCreateContext(eglDisplay_, eglConfig_, EGL_NO_CONTEXT, contextAttribs);
197 EXPECT_NE(eglContext_, EGL_NO_CONTEXT);
198
199 error = eglGetError();
200 EXPECT_EQ(error, EGL_SUCCESS);
201 }
202
203 /*
204 * Function: eglCreateWindowSurface
205 * Type: Function
206 * Rank: Important(2)
207 * EnvConditions: N/A
208 * CaseDescription: 1. call eglCreateWindowSurface
209 * 2. check ret
210 */
211 HWTEST_F(OpenglWrapperApiTest, eglCreateWindowSurface, TestSize.Level0)
212 {
213 static BufferProcTest test;
214 cSurface_ = Surface::CreateSurfaceAsConsumer("test");
215 EXPECT_NE(cSurface_, nullptr);
216 cSurface_->RegisterConsumerListener(&test);
217
218 auto producer = cSurface_->GetProducer();
219 EXPECT_NE(producer, nullptr);
220
221 pSurface_ = Surface::CreateSurfaceAsProducer(producer);
222 EXPECT_NE(pSurface_, nullptr);
223
224 gWindow_ = CreateNativeWindowFromSurface(&pSurface_);
225 EXPECT_NE(gWindow_, nullptr);
226
227 int32_t height = 0x100;
228 int32_t width = 0x100;
229 cSurface_->SetDefaultWidthAndHeight(height, width);
230 cSurface_->SetDefaultUsage(BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA);
231
232 NativeWindowHandleOpt(gWindow_, SET_USAGE, BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA);
233 NativeWindowHandleOpt(gWindow_, SET_BUFFER_GEOMETRY, height, width);
234 NativeWindowHandleOpt(gWindow_, SET_COLOR_GAMUT, GraphicColorGamut::GRAPHIC_COLOR_GAMUT_SRGB);
235
236 EGLint winAttribs[] = { EGL_GL_COLORSPACE_KHR, EGL_GL_COLORSPACE_SRGB_KHR, EGL_NONE };
237 eglSurface_ = eglCreateWindowSurface(nullptr, eglConfig_, gWindow_, winAttribs);
238 EXPECT_EQ(eglSurface_, EGL_NO_SURFACE);
239
240 EGLint error = eglGetError();
241 EXPECT_EQ(error, EGL_BAD_DISPLAY);
242
243 eglSurface_ = eglCreateWindowSurface(eglDisplay_, eglConfig_, gWindow_, winAttribs);
244 EXPECT_NE(eglSurface_, EGL_NO_SURFACE);
245
246 error = eglGetError();
247 EXPECT_EQ(error, EGL_SUCCESS);
248 }
249
250 /*
251 * Function: eglMakeCurrent
252 * Type: Function
253 * Rank: Important(2)
254 * EnvConditions: N/A
255 * CaseDescription: 1. call eglMakeCurrent
256 * 2. check ret
257 */
258 HWTEST_F(OpenglWrapperApiTest, eglMakeCurrent, TestSize.Level0)
259 {
260 // abnormal
261 EGLBoolean ret = eglMakeCurrent(nullptr, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
262 EXPECT_EQ(ret, EGL_FALSE);
263
264 EGLint error = eglGetError();
265 EXPECT_EQ(error, EGL_BAD_DISPLAY);
266
267 ret = eglMakeCurrent(eglDisplay_, eglSurface_, eglSurface_, EGL_NO_CONTEXT);
268 EXPECT_EQ(ret, EGL_FALSE);
269
270 error = eglGetError();
271 EXPECT_EQ(error, EGL_BAD_MATCH);
272
273 ret = eglMakeCurrent(eglDisplay_, EGL_NO_SURFACE, EGL_NO_SURFACE, eglContext_);
274 EXPECT_EQ(ret, EGL_TRUE);
275
276 error = eglGetError();
277 EXPECT_EQ(error, EGL_SUCCESS);
278
279 ret = eglMakeCurrent(eglDisplay_, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
280 EXPECT_EQ(ret, EGL_TRUE);
281
282 error = eglGetError();
283 EXPECT_EQ(error, EGL_SUCCESS);
284
285 ret = eglMakeCurrent(eglDisplay_, eglSurface_, eglSurface_, eglContext_);
286 EXPECT_EQ(ret, EGL_TRUE);
287
288 error = eglGetError();
289 EXPECT_EQ(error, EGL_SUCCESS);
290 }
291
292 /*
293 * Function: eglQuerySurface
294 * Type: Function
295 * Rank: Important(2)
296 * EnvConditions: N/A
297 * CaseDescription: 1. call eglQuerySurface
298 * 2. check ret
299 */
300 HWTEST_F(OpenglWrapperApiTest, eglQuerySurface, TestSize.Level0)
301 {
302 EGLint value;
303 // abnormal
304 EGLBoolean ret = eglQuerySurface(nullptr, eglSurface_, EGL_WIDTH, &value);
305 EXPECT_EQ(ret, EGL_FALSE);
306
307 EGLint error = eglGetError();
308 EXPECT_EQ(error, EGL_BAD_DISPLAY);
309
310 ret = eglQuerySurface(eglDisplay_, nullptr, EGL_WIDTH, &value);
311 EXPECT_EQ(ret, EGL_FALSE);
312
313 error = eglGetError();
314 EXPECT_EQ(error, EGL_BAD_SURFACE);
315
316 ret = eglQuerySurface(eglDisplay_, eglSurface_, EGL_WIDTH, &value);
317 EXPECT_EQ(ret, EGL_TRUE);
318 EXPECT_GE(value, 0);
319
320 error = eglGetError();
321 EXPECT_EQ(error, EGL_SUCCESS);
322 }
323
324 /*
325 * Function: glClearColor
326 * Type: Function
327 * Rank: Important(2)
328 * EnvConditions: N/A
329 * CaseDescription: 1. call glClearColor
330 */
331 HWTEST_F(OpenglWrapperApiTest, glClearColor, TestSize.Level0)
332 {
333 glClearColor(0, 0, 0, 1.0);
334 }
335
336 /*
337 * Function: glClear
338 * Type: Function
339 * Rank: Important(2)
340 * EnvConditions: N/A
341 * CaseDescription: 1. call glClear
342 */
343 HWTEST_F(OpenglWrapperApiTest, glClear, TestSize.Level0)
344 {
345 glClear(GL_COLOR_BUFFER_BIT);
346 }
347
348 /*
349 * Function: eglSwapBuffers
350 * Type: Function
351 * Rank: Important(2)
352 * EnvConditions: N/A
353 * CaseDescription: 1. call eglSwapBuffers
354 * 2. check ret
355 */
356 HWTEST_F(OpenglWrapperApiTest, eglSwapBuffers, TestSize.Level0)
357 {
358 // abnormal
359 EGLBoolean ret = eglSwapBuffers(nullptr, eglSurface_);
360 EXPECT_EQ(ret, EGL_FALSE);
361
362 EGLint error = eglGetError();
363 EXPECT_EQ(error, EGL_BAD_DISPLAY);
364
365 ret = eglSwapBuffers(eglDisplay_, nullptr);
366 EXPECT_EQ(ret, EGL_FALSE);
367
368 error = eglGetError();
369 EXPECT_EQ(error, EGL_BAD_SURFACE);
370
371 ret = eglSwapBuffers(eglDisplay_, eglSurface_);
372 EXPECT_EQ(ret, EGL_TRUE);
373
374 error = eglGetError();
375 EXPECT_EQ(error, EGL_SUCCESS);
376 }
377
378 /*
379 * Function: eglDestroySurface
380 * Type: Function
381 * Rank: Important(2)
382 * EnvConditions: N/A
383 * CaseDescription: 1. call eglDestroySurface
384 * 2. check ret
385 */
386 HWTEST_F(OpenglWrapperApiTest, eglDestroySurface, TestSize.Level0)
387 {
388 // abnormal
389 EGLBoolean ret = eglDestroySurface(nullptr, eglSurface_);
390 EXPECT_EQ(ret, EGL_FALSE);
391
392 EGLint error = eglGetError();
393 EXPECT_EQ(error, EGL_BAD_DISPLAY);
394
395 ret = eglDestroySurface(eglDisplay_, nullptr);
396 EXPECT_EQ(ret, EGL_FALSE);
397
398 error = eglGetError();
399 EXPECT_EQ(error, EGL_BAD_SURFACE);
400
401 ret = eglDestroySurface(eglDisplay_, eglSurface_);
402 EXPECT_EQ(ret, EGL_TRUE);
403
404 error = eglGetError();
405 EXPECT_EQ(error, EGL_SUCCESS);
406 eglSurface_ = EGL_NO_SURFACE;
407 }
408
409 /*
410 * Function: eglDestroyContext
411 * Type: Function
412 * Rank: Important(2)
413 * EnvConditions: N/A
414 * CaseDescription: 1. call eglDestroyContext
415 * 2. check ret
416 */
417 HWTEST_F(OpenglWrapperApiTest, eglDestroyContext, TestSize.Level0)
418 {
419 // abnormal
420 EGLBoolean ret = eglDestroyContext(nullptr, eglContext_);
421 EXPECT_EQ(ret, EGL_FALSE);
422
423 EGLint error = eglGetError();
424 EXPECT_EQ(error, EGL_BAD_DISPLAY);
425
426 ret = eglDestroyContext(eglDisplay_, nullptr);
427 EXPECT_EQ(ret, EGL_FALSE);
428
429 error = eglGetError();
430 EXPECT_EQ(error, EGL_BAD_CONTEXT);
431
432 ret = eglDestroyContext(eglDisplay_, eglContext_);
433 EXPECT_EQ(ret, EGL_TRUE);
434
435 error = eglGetError();
436 EXPECT_EQ(error, EGL_SUCCESS);
437 eglContext_ = EGL_NO_CONTEXT;
438 }
439
440 /*
441 * Function: eglTerminate
442 * Type: Function
443 * Rank: Important(2)
444 * EnvConditions: N/A
445 * CaseDescription: 1. call eglTerminate
446 * 2. check ret
447 */
448 HWTEST_F(OpenglWrapperApiTest, eglTerminate, TestSize.Level0)
449 {
450 // abnormal
451 EGLBoolean ret = eglTerminate(nullptr);
452 EXPECT_EQ(ret, EGL_FALSE);
453
454 EGLint error = eglGetError();
455 EXPECT_EQ(error, EGL_BAD_DISPLAY);
456
457 ret = eglTerminate(eglDisplay_);
458 EXPECT_EQ(ret, EGL_TRUE);
459
460 error = eglGetError();
461 EXPECT_EQ(error, EGL_SUCCESS);
462 eglDisplay_ = EGL_NO_DISPLAY;
463 }
464
465 /*
466 * Function: eglReleaseThread
467 * Type: Function
468 * Rank: Important(2)
469 * EnvConditions: N/A
470 * CaseDescription: 1. call eglReleaseThread
471 * 2. check ret
472 */
473 HWTEST_F(OpenglWrapperApiTest, eglReleaseThread, TestSize.Level0)
474 {
475 // abnormal
476 EGLBoolean ret = eglReleaseThread();
477 EXPECT_EQ(ret, EGL_TRUE);
478
479 EGLint error = eglGetError();
480 EXPECT_EQ(error, EGL_SUCCESS);
481 }
482 }
483