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