1 /*
2 * Copyright (c) 2022 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, Hardware
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
16 #include <gtest/gtest.h>
17 #include <string>
18
19 #include "EGL/egl_wrapper_entry.h"
20
21 #include "EGL/egl_wrapper_display.h"
22 #include "egl_defs.h"
23 #include "hook.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS::Rosen {
29 class EglWrapperEntryTest : public testing::Test {
30 public:
SetUpTestCase()31 static void SetUpTestCase() {}
TearDownTestCase()32 static void TearDownTestCase() {}
SetUp()33 void SetUp() {}
TearDown()34 void TearDown() {}
35 };
36
37 /**
38 * @tc.name: FindEglWrapperApi001
39 * @tc.desc:
40 * @tc.type: FUNC
41 */
HWTEST_F(EglWrapperEntryTest,FindEglWrapperApi001,Level1)42 HWTEST_F(EglWrapperEntryTest, FindEglWrapperApi001, Level1)
43 {
44 auto result = FindEglWrapperApi("eglChooseConfig");
45 ASSERT_NE(nullptr, result);
46 }
47
48 /**
49 * @tc.name: FindEglWrapperApi002
50 * @tc.desc:
51 * @tc.type: FUNC
52 */
HWTEST_F(EglWrapperEntryTest,FindEglWrapperApi002,Level2)53 HWTEST_F(EglWrapperEntryTest, FindEglWrapperApi002, Level2)
54 {
55 auto result = FindEglWrapperApi("");
56 ASSERT_EQ(nullptr, result);
57 }
58
59 /**
60 * @tc.name: CheckEglWrapperApi001
61 * @tc.desc:
62 * @tc.type: FUNC
63 */
HWTEST_F(EglWrapperEntryTest,CheckEglWrapperApi001,Level1)64 HWTEST_F(EglWrapperEntryTest, CheckEglWrapperApi001, Level1)
65 {
66 auto result = CheckEglWrapperApi("eglChooseConfig");
67 ASSERT_TRUE(result);
68 }
69
70 /**
71 * @tc.name: CheckEglWrapperApi002
72 * @tc.desc:
73 * @tc.type: FUNC
74 */
HWTEST_F(EglWrapperEntryTest,CheckEglWrapperApi002,Level2)75 HWTEST_F(EglWrapperEntryTest, CheckEglWrapperApi002, Level2)
76 {
77 auto result = CheckEglWrapperApi("");
78 ASSERT_TRUE(!result);
79 }
80
81 /**
82 * @tc.name: ValidateDisplay001
83 * @tc.desc:
84 * @tc.type: FUNC
85 */
HWTEST_F(EglWrapperEntryTest,ValidateDisplay001,Level1)86 HWTEST_F(EglWrapperEntryTest, ValidateDisplay001, Level1)
87 {
88 // EglTerminateImpl calls ValidateDisplay
89 auto result = eglTerminate(nullptr);
90 ASSERT_EQ(EGL_FALSE, result);
91 }
92
93 /**
94 * @tc.name: ValidateDisplay002
95 * @tc.desc:
96 * @tc.type: FUNC
97 */
HWTEST_F(EglWrapperEntryTest,ValidateDisplay002,Level2)98 HWTEST_F(EglWrapperEntryTest, ValidateDisplay002, Level2)
99 {
100 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
101
102 // EglTerminateImpl calls ValidateDisplay
103 auto result = eglTerminate(dpy);
104 ASSERT_EQ(EGL_FALSE, result);
105 }
106
107 /**
108 * @tc.name: EglChooseConfigImpl001
109 * @tc.desc:
110 * @tc.type: FUNC
111 */
HWTEST_F(EglWrapperEntryTest,EglChooseConfigImpl001,Level1)112 HWTEST_F(EglWrapperEntryTest, EglChooseConfigImpl001, Level1)
113 {
114 EGLDisplay dpy = nullptr;
115 auto result = gWrapperHook.wrapper.eglChooseConfig(dpy, nullptr, nullptr, 0, nullptr);
116 ASSERT_EQ(EGL_FALSE, result);
117 }
118
119 /**
120 * @tc.name: EglChooseConfigImpl002
121 * @tc.desc:
122 * @tc.type: FUNC
123 */
HWTEST_F(EglWrapperEntryTest,EglChooseConfigImpl002,Level2)124 HWTEST_F(EglWrapperEntryTest, EglChooseConfigImpl002, Level2)
125 {
126 EGLint majorVersion;
127 EGLint minorVersion;
128 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
129 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
130 ASSERT_EQ(ret, EGL_TRUE);
131
132 auto result = gWrapperHook.wrapper.eglChooseConfig(dpy, nullptr, nullptr, 0, nullptr);
133 ASSERT_EQ(EGL_FALSE, result);
134 }
135
136 /**
137 * @tc.name: EglChooseConfigImpl003
138 * @tc.desc:
139 * @tc.type: FUNC
140 */
HWTEST_F(EglWrapperEntryTest,EglChooseConfigImpl003,Level2)141 HWTEST_F(EglWrapperEntryTest, EglChooseConfigImpl003, Level2)
142 {
143 EGLint majorVersion;
144 EGLint minorVersion;
145 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
146 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
147 ASSERT_EQ(ret, EGL_TRUE);
148 EGLint numConfig = 1;
149
150 auto result = gWrapperHook.wrapper.eglChooseConfig(dpy, nullptr, nullptr, 0, &numConfig);
151 ASSERT_NE(EGL_FALSE, result);
152 }
153
154 /**
155 * @tc.name: EglCopyBuffersImpl001
156 * @tc.desc:
157 * @tc.type: FUNC
158 */
HWTEST_F(EglWrapperEntryTest,EglCopyBuffersImpl001,Level1)159 HWTEST_F(EglWrapperEntryTest, EglCopyBuffersImpl001, Level1)
160 {
161 EGLDisplay dpy = nullptr;
162 auto result = gWrapperHook.wrapper.eglCopyBuffers(dpy, nullptr, 0);
163 ASSERT_EQ(EGL_FALSE, result);
164 }
165
166 /**
167 * @tc.name: EglCopyBuffersImpl002
168 * @tc.desc:
169 * @tc.type: FUNC
170 */
HWTEST_F(EglWrapperEntryTest,EglCopyBuffersImpl002,Level2)171 HWTEST_F(EglWrapperEntryTest, EglCopyBuffersImpl002, Level2)
172 {
173 EGLint majorVersion;
174 EGLint minorVersion;
175 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
176 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
177 ASSERT_EQ(ret, EGL_TRUE);
178
179 auto result = gWrapperHook.wrapper.eglCopyBuffers(dpy, nullptr, 0);
180 ASSERT_EQ(EGL_FALSE, result);
181 }
182
183 /**
184 * @tc.name: EglCreateContextImpl001
185 * @tc.desc:
186 * @tc.type: FUNC
187 */
HWTEST_F(EglWrapperEntryTest,EglCreateContextImpl001,Level1)188 HWTEST_F(EglWrapperEntryTest, EglCreateContextImpl001, Level1)
189 {
190 EGLDisplay dpy = nullptr;
191 auto result = gWrapperHook.wrapper.eglCreateContext(dpy, nullptr, nullptr, nullptr);
192 ASSERT_EQ(EGL_NO_CONTEXT, result);
193 }
194
195 /**
196 * @tc.name: EglCreateContextImpl002
197 * @tc.desc:
198 * @tc.type: FUNC
199 */
HWTEST_F(EglWrapperEntryTest,EglCreateContextImpl002,Level2)200 HWTEST_F(EglWrapperEntryTest, EglCreateContextImpl002, Level2)
201 {
202 EGLint majorVersion;
203 EGLint minorVersion;
204 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
205 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
206 ASSERT_EQ(ret, EGL_TRUE);
207
208 auto result = gWrapperHook.wrapper.eglCreateContext(dpy, nullptr, nullptr, nullptr);
209 ASSERT_NE(EGL_NO_CONTEXT, result);
210 }
211
212 /**
213 * @tc.name: EglCreatePbufferSurfaceImpl001
214 * @tc.desc:
215 * @tc.type: FUNC
216 */
HWTEST_F(EglWrapperEntryTest,EglCreatePbufferSurfaceImpl001,Level1)217 HWTEST_F(EglWrapperEntryTest, EglCreatePbufferSurfaceImpl001, Level1)
218 {
219 EGLDisplay dpy = nullptr;
220 auto result = gWrapperHook.wrapper.eglCreatePbufferSurface(dpy, nullptr, nullptr);
221 ASSERT_EQ(EGL_NO_CONTEXT, result);
222 }
223
224 /**
225 * @tc.name: EglCreatePbufferSurfaceImpl002
226 * @tc.desc:
227 * @tc.type: FUNC
228 */
HWTEST_F(EglWrapperEntryTest,EglCreatePbufferSurfaceImpl002,Level2)229 HWTEST_F(EglWrapperEntryTest, EglCreatePbufferSurfaceImpl002, Level2)
230 {
231 EGLint majorVersion;
232 EGLint minorVersion;
233 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
234 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
235 ASSERT_EQ(ret, EGL_TRUE);
236
237 auto result = gWrapperHook.wrapper.eglCreatePbufferSurface(dpy, nullptr, nullptr);
238 ASSERT_EQ(EGL_NO_CONTEXT, result);
239 }
240
241 /**
242 * @tc.name: EglCreatePixmapSurfaceImpl001
243 * @tc.desc:
244 * @tc.type: FUNC
245 */
HWTEST_F(EglWrapperEntryTest,EglCreatePixmapSurfaceImpl001,Level1)246 HWTEST_F(EglWrapperEntryTest, EglCreatePixmapSurfaceImpl001, Level1)
247 {
248 EGLDisplay dpy = nullptr;
249 auto result = gWrapperHook.wrapper.eglCreatePixmapSurface(dpy, nullptr, 0, nullptr);
250 ASSERT_EQ(EGL_NO_CONTEXT, result);
251 }
252
253 /**
254 * @tc.name: EglCreatePixmapSurfaceImpl002
255 * @tc.desc:
256 * @tc.type: FUNC
257 */
HWTEST_F(EglWrapperEntryTest,EglCreatePixmapSurfaceImpl002,Level2)258 HWTEST_F(EglWrapperEntryTest, EglCreatePixmapSurfaceImpl002, Level2)
259 {
260 EGLint majorVersion;
261 EGLint minorVersion;
262 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
263 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
264 ASSERT_EQ(ret, EGL_TRUE);
265
266 auto result = gWrapperHook.wrapper.eglCreatePixmapSurface(dpy, nullptr, 0, nullptr);
267 ASSERT_EQ(EGL_NO_CONTEXT, result);
268 }
269
270 /**
271 * @tc.name: EglCreateWindowSurfaceImpl001
272 * @tc.desc:
273 * @tc.type: FUNC
274 */
HWTEST_F(EglWrapperEntryTest,EglCreateWindowSurfaceImpl001,Level1)275 HWTEST_F(EglWrapperEntryTest, EglCreateWindowSurfaceImpl001, Level1)
276 {
277 EGLDisplay dpy = nullptr;
278 auto result = gWrapperHook.wrapper.eglCreateWindowSurface(dpy, nullptr, 0, nullptr);
279 ASSERT_EQ(EGL_NO_SURFACE, result);
280 }
281
282 /**
283 * @tc.name: EglCreateWindowSurfaceImpl002
284 * @tc.desc:
285 * @tc.type: FUNC
286 */
HWTEST_F(EglWrapperEntryTest,EglCreateWindowSurfaceImpl002,Level2)287 HWTEST_F(EglWrapperEntryTest, EglCreateWindowSurfaceImpl002, Level2)
288 {
289 EGLint majorVersion;
290 EGLint minorVersion;
291 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
292 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
293 ASSERT_EQ(ret, EGL_TRUE);
294
295 auto result = gWrapperHook.wrapper.eglCreateWindowSurface(dpy, nullptr, 0, nullptr);
296 ASSERT_EQ(EGL_NO_SURFACE, result);
297 }
298
299 /**
300 * @tc.name: EglDestroyContextImpl001
301 * @tc.desc:
302 * @tc.type: FUNC
303 */
HWTEST_F(EglWrapperEntryTest,EglDestroyContextImpl001,Level1)304 HWTEST_F(EglWrapperEntryTest, EglDestroyContextImpl001, Level1)
305 {
306 EGLDisplay dpy = nullptr;
307 auto result = gWrapperHook.wrapper.eglDestroyContext(dpy, nullptr);
308 ASSERT_EQ(EGL_FALSE, result);
309 }
310
311 /**
312 * @tc.name: EglDestroyContextImpl002
313 * @tc.desc:
314 * @tc.type: FUNC
315 */
HWTEST_F(EglWrapperEntryTest,EglDestroyContextImpl002,Level2)316 HWTEST_F(EglWrapperEntryTest, EglDestroyContextImpl002, Level2)
317 {
318 EGLint majorVersion;
319 EGLint minorVersion;
320 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
321 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
322 ASSERT_EQ(ret, EGL_TRUE);
323
324 auto result = gWrapperHook.wrapper.eglDestroyContext(dpy, nullptr);
325 ASSERT_EQ(EGL_FALSE, result);
326 }
327
328 /**
329 * @tc.name: EglDestroySurfaceImpl001
330 * @tc.desc:
331 * @tc.type: FUNC
332 */
HWTEST_F(EglWrapperEntryTest,EglDestroySurfaceImpl001,Level1)333 HWTEST_F(EglWrapperEntryTest, EglDestroySurfaceImpl001, Level1)
334 {
335 EGLDisplay dpy = nullptr;
336 auto result = gWrapperHook.wrapper.eglDestroySurface(dpy, nullptr);
337 ASSERT_EQ(EGL_FALSE, result);
338 }
339
340 /**
341 * @tc.name: EglDestroySurfaceImpl002
342 * @tc.desc:
343 * @tc.type: FUNC
344 */
HWTEST_F(EglWrapperEntryTest,EglDestroySurfaceImpl002,Level2)345 HWTEST_F(EglWrapperEntryTest, EglDestroySurfaceImpl002, Level2)
346 {
347 EGLint majorVersion;
348 EGLint minorVersion;
349 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
350 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
351 ASSERT_EQ(ret, EGL_TRUE);
352
353 auto result = gWrapperHook.wrapper.eglDestroySurface(dpy, nullptr);
354 ASSERT_EQ(EGL_FALSE, result);
355 }
356
357 /**
358 * @tc.name: EglGetConfigAttribImpl001
359 * @tc.desc:
360 * @tc.type: FUNC
361 */
HWTEST_F(EglWrapperEntryTest,EglGetConfigAttribImpl001,Level1)362 HWTEST_F(EglWrapperEntryTest, EglGetConfigAttribImpl001, Level1)
363 {
364 EGLDisplay dpy = nullptr;
365 auto result = gWrapperHook.wrapper.eglGetConfigAttrib(dpy, nullptr, 0, nullptr);
366 ASSERT_EQ(EGL_FALSE, result);
367 }
368
369 /**
370 * @tc.name: EglGetConfigAttribImpl002
371 * @tc.desc:
372 * @tc.type: FUNC
373 */
HWTEST_F(EglWrapperEntryTest,EglGetConfigAttribImpl002,Level2)374 HWTEST_F(EglWrapperEntryTest, EglGetConfigAttribImpl002, Level2)
375 {
376 EGLint majorVersion;
377 EGLint minorVersion;
378 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
379 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
380 ASSERT_EQ(ret, EGL_TRUE);
381
382 auto result = gWrapperHook.wrapper.eglGetConfigAttrib(dpy, nullptr, 0, nullptr);
383 ASSERT_EQ(EGL_FALSE, result);
384 }
385
386 /**
387 * @tc.name: EglGetConfigsImpl001
388 * @tc.desc:
389 * @tc.type: FUNC
390 */
HWTEST_F(EglWrapperEntryTest,EglGetConfigsImpl001,Level1)391 HWTEST_F(EglWrapperEntryTest, EglGetConfigsImpl001, Level1)
392 {
393 EGLDisplay dpy = nullptr;
394 auto result = gWrapperHook.wrapper.eglGetConfigs(dpy, nullptr, 0, nullptr);
395 ASSERT_EQ(EGL_FALSE, result);
396 }
397
398 /**
399 * @tc.name: EglGetConfigsImpl002
400 * @tc.desc:
401 * @tc.type: FUNC
402 */
HWTEST_F(EglWrapperEntryTest,EglGetConfigsImpl002,Level2)403 HWTEST_F(EglWrapperEntryTest, EglGetConfigsImpl002, Level2)
404 {
405 EGLint majorVersion;
406 EGLint minorVersion;
407 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
408 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
409 ASSERT_EQ(ret, EGL_TRUE);
410
411 auto result = gWrapperHook.wrapper.eglGetConfigs(dpy, nullptr, 0, nullptr);
412 ASSERT_EQ(EGL_FALSE, result);
413 }
414
415 /**
416 * @tc.name: EglGetConfigsImpl003
417 * @tc.desc:
418 * @tc.type: FUNC
419 */
HWTEST_F(EglWrapperEntryTest,EglGetConfigsImpl003,Level2)420 HWTEST_F(EglWrapperEntryTest, EglGetConfigsImpl003, Level2)
421 {
422 EGLint majorVersion;
423 EGLint minorVersion;
424 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
425 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
426 ASSERT_EQ(ret, EGL_TRUE);
427 EGLint numConfig = 1;
428
429 auto result = gWrapperHook.wrapper.eglGetConfigs(dpy, nullptr, 0, &numConfig);
430 ASSERT_NE(EGL_FALSE, result);
431 }
432
433 /**
434 * @tc.name: EglGetPlatformDisplayInternal001
435 * @tc.desc:
436 * @tc.type: FUNC
437 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayInternal001,Level1)438 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayInternal001, Level1)
439 {
440 auto type = 10;
441 auto result = gWrapperHook.wrapper.eglGetDisplay(&type);
442 ASSERT_EQ(EGL_NO_DISPLAY, result);
443 }
444
445 /**
446 * @tc.name: EglGetPlatformDisplayInternal002
447 * @tc.desc:
448 * @tc.type: FUNC
449 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayInternal002,Level2)450 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayInternal002, Level2)
451 {
452 auto result = gWrapperHook.wrapper.eglGetDisplay(EGL_DEFAULT_DISPLAY);
453 ASSERT_NE(EGL_NO_DISPLAY, result);
454 }
455
456 /**
457 * @tc.name: EglGetPlatformDisplayInternal003
458 * @tc.desc:
459 * @tc.type: FUNC
460 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayInternal003,Level2)461 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayInternal003, Level2)
462 {
463 auto result = gWrapperHook.wrapper.eglGetPlatformDisplay(0, nullptr, nullptr);
464 ASSERT_EQ(EGL_FALSE, result);
465 }
466
467 /**
468 * @tc.name: EglGetErrorImpl001
469 * @tc.desc:
470 * @tc.type: FUNC
471 */
HWTEST_F(EglWrapperEntryTest,EglGetErrorImpl001,Level1)472 HWTEST_F(EglWrapperEntryTest, EglGetErrorImpl001, Level1)
473 {
474 auto temp = gWrapperHook.isLoad;
475 gWrapperHook.isLoad = false;
476
477 auto result = gWrapperHook.wrapper.eglGetError();
478 ASSERT_NE(EGL_SUCCESS, result);
479 gWrapperHook.isLoad = temp;
480 }
481
482 /**
483 * @tc.name: EglGetErrorImpl002
484 * @tc.desc:
485 * @tc.type: FUNC
486 */
HWTEST_F(EglWrapperEntryTest,EglGetErrorImpl002,Level2)487 HWTEST_F(EglWrapperEntryTest, EglGetErrorImpl002, Level2)
488 {
489 auto temp = gWrapperHook.isLoad;
490 gWrapperHook.isLoad = true;
491
492 auto result = gWrapperHook.wrapper.eglGetError();
493 ASSERT_EQ(EGL_SUCCESS, result);
494 gWrapperHook.isLoad = temp;
495 }
496
497 /**
498 * @tc.name: EglGetProcAddressImpL001
499 * @tc.desc:
500 * @tc.type: FUNC
501 */
HWTEST_F(EglWrapperEntryTest,EglGetProcAddressImpL001,Level1)502 HWTEST_F(EglWrapperEntryTest, EglGetProcAddressImpL001, Level1)
503 {
504 std::string procname = "eglCreateImageKHR";
505 auto result = gWrapperHook.wrapper.eglGetProcAddress(procname.c_str());
506 ASSERT_NE(nullptr, result);
507 }
508
509 /**
510 * @tc.name: EglGetProcAddressImpL002
511 * @tc.desc:
512 * @tc.type: FUNC
513 */
HWTEST_F(EglWrapperEntryTest,EglGetProcAddressImpL002,Level2)514 HWTEST_F(EglWrapperEntryTest, EglGetProcAddressImpL002, Level2)
515 {
516 std::string procname = "nullptr";
517 auto result = gWrapperHook.wrapper.eglGetProcAddress(procname.c_str());
518 ASSERT_EQ(nullptr, result);
519 }
520
521 /**
522 * @tc.name: EglInitializeImpl001
523 * @tc.desc:
524 * @tc.type: FUNC
525 */
HWTEST_F(EglWrapperEntryTest,EglInitializeImpl001,Level1)526 HWTEST_F(EglWrapperEntryTest, EglInitializeImpl001, Level1)
527 {
528 EGLDisplay dpy = nullptr;
529 auto result = gWrapperHook.wrapper.eglInitialize(dpy, nullptr, nullptr);
530 ASSERT_EQ(EGL_FALSE, result);
531 }
532
533 /**
534 * @tc.name: EglInitializeImpl002
535 * @tc.desc:
536 * @tc.type: FUNC
537 */
HWTEST_F(EglWrapperEntryTest,EglInitializeImpl002,Level2)538 HWTEST_F(EglWrapperEntryTest, EglInitializeImpl002, Level2)
539 {
540 EGLint majorVersion;
541 EGLint minorVersion;
542 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
543
544 auto result = gWrapperHook.wrapper.eglInitialize(dpy, &majorVersion, &minorVersion);
545 ASSERT_NE(EGL_FALSE, result);
546 }
547
548 /**
549 * @tc.name: EglMakeCurrentImpl001
550 * @tc.desc:
551 * @tc.type: FUNC
552 */
HWTEST_F(EglWrapperEntryTest,EglMakeCurrentImpl001,Level1)553 HWTEST_F(EglWrapperEntryTest, EglMakeCurrentImpl001, Level1)
554 {
555 EGLDisplay dpy = nullptr;
556 auto result = gWrapperHook.wrapper.eglMakeCurrent(dpy, nullptr, 0, nullptr);
557 ASSERT_EQ(EGL_FALSE, result);
558 }
559
560 /**
561 * @tc.name: EglMakeCurrentImpl002
562 * @tc.desc:
563 * @tc.type: FUNC
564 */
HWTEST_F(EglWrapperEntryTest,EglMakeCurrentImpl002,Level2)565 HWTEST_F(EglWrapperEntryTest, EglMakeCurrentImpl002, Level2)
566 {
567 EGLint majorVersion;
568 EGLint minorVersion;
569 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
570 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
571 ASSERT_EQ(ret, EGL_TRUE);
572
573 auto result = gWrapperHook.wrapper.eglMakeCurrent(dpy, nullptr, 0, nullptr);
574 ASSERT_NE(EGL_FALSE, result);
575 }
576
577 /**
578 * @tc.name: EglQueryContextImpl001
579 * @tc.desc:
580 * @tc.type: FUNC
581 */
HWTEST_F(EglWrapperEntryTest,EglQueryContextImpl001,Level1)582 HWTEST_F(EglWrapperEntryTest, EglQueryContextImpl001, Level1)
583 {
584 EGLDisplay dpy = nullptr;
585 auto result = gWrapperHook.wrapper.eglQueryContext(dpy, nullptr, 0, nullptr);
586 ASSERT_EQ(EGL_FALSE, result);
587 }
588
589 /**
590 * @tc.name: EglQueryContextImpl002
591 * @tc.desc:
592 * @tc.type: FUNC
593 */
HWTEST_F(EglWrapperEntryTest,EglQueryContextImpl002,Level2)594 HWTEST_F(EglWrapperEntryTest, EglQueryContextImpl002, Level2)
595 {
596 EGLint majorVersion;
597 EGLint minorVersion;
598 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
599 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
600 ASSERT_EQ(ret, EGL_TRUE);
601
602 auto result = gWrapperHook.wrapper.eglQueryContext(dpy, nullptr, 0, nullptr);
603 ASSERT_EQ(EGL_FALSE, result);
604 }
605
606 /**
607 * @tc.name: EglQueryContextImpl003
608 * @tc.desc:
609 * @tc.type: FUNC
610 */
HWTEST_F(EglWrapperEntryTest,EglQueryContextImpl003,Level2)611 HWTEST_F(EglWrapperEntryTest, EglQueryContextImpl003, Level2)
612 {
613 EGLint majorVersion;
614 EGLint minorVersion;
615 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
616 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
617 ASSERT_EQ(ret, EGL_TRUE);
618 EGLint value = 1;
619
620 auto result = gWrapperHook.wrapper.eglQueryContext(dpy, nullptr, 0, &value);
621 ASSERT_EQ(EGL_FALSE, result);
622 }
623
624 /**
625 * @tc.name: EglQueryStringImpl001
626 * @tc.desc:
627 * @tc.type: FUNC
628 */
HWTEST_F(EglWrapperEntryTest,EglQueryStringImpl001,Level1)629 HWTEST_F(EglWrapperEntryTest, EglQueryStringImpl001, Level1)
630 {
631 EGLDisplay dpy = nullptr;
632 auto result = gWrapperHook.wrapper.eglQueryString(dpy, 0);
633 ASSERT_EQ(nullptr, result);
634 }
635
636 /**
637 * @tc.name: EglQueryStringImpl002
638 * @tc.desc:
639 * @tc.type: FUNC
640 */
HWTEST_F(EglWrapperEntryTest,EglQueryStringImpl002,Level2)641 HWTEST_F(EglWrapperEntryTest, EglQueryStringImpl002, Level2)
642 {
643 EGLint majorVersion;
644 EGLint minorVersion;
645 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
646 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
647 ASSERT_EQ(ret, EGL_TRUE);
648
649 auto result = gWrapperHook.wrapper.eglQueryString(dpy, 0);
650 ASSERT_EQ(nullptr, result);
651 }
652
653 /**
654 * @tc.name: EglQuerySurfaceImpl001
655 * @tc.desc:
656 * @tc.type: FUNC
657 */
HWTEST_F(EglWrapperEntryTest,EglQuerySurfaceImpl001,Level1)658 HWTEST_F(EglWrapperEntryTest, EglQuerySurfaceImpl001, Level1)
659 {
660 EGLDisplay dpy = nullptr;
661 auto result = gWrapperHook.wrapper.eglQuerySurface(dpy, nullptr, 0, nullptr);
662 ASSERT_EQ(EGL_FALSE, result);
663 }
664
665 /**
666 * @tc.name: EglQuerySurfaceImpl002
667 * @tc.desc:
668 * @tc.type: FUNC
669 */
HWTEST_F(EglWrapperEntryTest,EglQuerySurfaceImpl002,Level2)670 HWTEST_F(EglWrapperEntryTest, EglQuerySurfaceImpl002, Level2)
671 {
672 EGLint majorVersion;
673 EGLint minorVersion;
674 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
675 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
676 ASSERT_EQ(ret, EGL_TRUE);
677
678 auto result = gWrapperHook.wrapper.eglQuerySurface(dpy, nullptr, 0, nullptr);
679 ASSERT_EQ(EGL_FALSE, result);
680 }
681
682 /**
683 * @tc.name: EglQuerySurfaceImpl003
684 * @tc.desc:
685 * @tc.type: FUNC
686 */
HWTEST_F(EglWrapperEntryTest,EglQuerySurfaceImpl003,Level2)687 HWTEST_F(EglWrapperEntryTest, EglQuerySurfaceImpl003, Level2)
688 {
689 EGLint majorVersion;
690 EGLint minorVersion;
691 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
692 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
693 ASSERT_EQ(ret, EGL_TRUE);
694 EGLint value = 1;
695
696 auto result = gWrapperHook.wrapper.eglQuerySurface(dpy, nullptr, 0, &value);
697 ASSERT_EQ(EGL_FALSE, result);
698 }
699
700 /**
701 * @tc.name: EglSwapBuffersImpl001
702 * @tc.desc:
703 * @tc.type: FUNC
704 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersImpl001,Level1)705 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersImpl001, Level1)
706 {
707 EGLDisplay dpy = nullptr;
708 auto result = gWrapperHook.wrapper.eglSwapBuffers(dpy, nullptr);
709 ASSERT_EQ(EGL_FALSE, result);
710 }
711
712 /**
713 * @tc.name: EglSwapBuffersImpl002
714 * @tc.desc:
715 * @tc.type: FUNC
716 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersImpl002,Level1)717 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersImpl002, Level1)
718 {
719 EGLint majorVersion;
720 EGLint minorVersion;
721 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
722 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
723 ASSERT_EQ(ret, EGL_TRUE);
724
725 auto result = gWrapperHook.wrapper.eglSwapBuffers(dpy, nullptr);
726 ASSERT_EQ(EGL_FALSE, result);
727 }
728
729 /**
730 * @tc.name: EglTerminateImpl001
731 * @tc.desc:
732 * @tc.type: FUNC
733 */
HWTEST_F(EglWrapperEntryTest,EglTerminateImpl001,Level1)734 HWTEST_F(EglWrapperEntryTest, EglTerminateImpl001, Level1)
735 {
736 EGLDisplay dpy = nullptr;
737 auto result = gWrapperHook.wrapper.eglTerminate(dpy);
738 ASSERT_EQ(EGL_FALSE, result);
739 }
740
741 /**
742 * @tc.name: EglTerminateImpl002
743 * @tc.desc:
744 * @tc.type: FUNC
745 */
HWTEST_F(EglWrapperEntryTest,EglTerminateImpl002,Level2)746 HWTEST_F(EglWrapperEntryTest, EglTerminateImpl002, Level2)
747 {
748 EGLint majorVersion;
749 EGLint minorVersion;
750 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
751 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
752 ASSERT_EQ(ret, EGL_TRUE);
753
754 auto result = gWrapperHook.wrapper.eglTerminate(dpy);
755 ASSERT_NE(EGL_FALSE, result);
756 }
757
758 /**
759 * @tc.name: EglWaitGLImpl001
760 * @tc.desc:
761 * @tc.type: FUNC
762 */
HWTEST_F(EglWrapperEntryTest,EglWaitGLImpl001,Level1)763 HWTEST_F(EglWrapperEntryTest, EglWaitGLImpl001, Level1)
764 {
765 auto temp = gWrapperHook.isLoad;
766 gWrapperHook.isLoad = false;
767 auto result = gWrapperHook.wrapper.eglWaitGL();
768 ASSERT_EQ(EGL_FALSE, result);
769 gWrapperHook.isLoad = temp;
770 }
771
772
773 /**
774 * @tc.name: EglWaitGLImpl002
775 * @tc.desc:
776 * @tc.type: FUNC
777 */
HWTEST_F(EglWrapperEntryTest,EglWaitGLImpl002,Level2)778 HWTEST_F(EglWrapperEntryTest, EglWaitGLImpl002, Level2)
779 {
780 auto temp = gWrapperHook.isLoad;
781 gWrapperHook.isLoad = true;
782 auto result = gWrapperHook.wrapper.eglWaitGL();
783 ASSERT_NE(EGL_FALSE, result);
784 gWrapperHook.isLoad = temp;
785 }
786
787
788 /**
789 * @tc.name: EglWaitNativeImpl001
790 * @tc.desc:
791 * @tc.type: FUNC
792 */
HWTEST_F(EglWrapperEntryTest,EglWaitNativeImpl001,Level1)793 HWTEST_F(EglWrapperEntryTest, EglWaitNativeImpl001, Level1)
794 {
795 auto temp = gWrapperHook.isLoad;
796 gWrapperHook.isLoad = false;
797 auto result = gWrapperHook.wrapper.eglWaitNative(1);
798 ASSERT_EQ(EGL_FALSE, result);
799 gWrapperHook.isLoad = temp;
800 }
801
802 /**
803 * @tc.name: EglWaitNativeImpl002
804 * @tc.desc:
805 * @tc.type: FUNC
806 */
HWTEST_F(EglWrapperEntryTest,EglWaitNativeImpl002,Level2)807 HWTEST_F(EglWrapperEntryTest, EglWaitNativeImpl002, Level2)
808 {
809 auto temp = gWrapperHook.isLoad;
810 gWrapperHook.isLoad = true;
811 auto result = gWrapperHook.wrapper.eglWaitNative(1);
812 ASSERT_NE(EGL_FALSE, result);
813 gWrapperHook.isLoad = temp;
814 }
815
816 /**
817 * @tc.name: EglBindTexImageImpl001
818 * @tc.desc:
819 * @tc.type: FUNC
820 */
HWTEST_F(EglWrapperEntryTest,EglBindTexImageImpl001,Level1)821 HWTEST_F(EglWrapperEntryTest, EglBindTexImageImpl001, Level1)
822 {
823 EGLDisplay dpy = nullptr;
824 auto result = gWrapperHook.wrapper.eglBindTexImage(dpy, nullptr, 0);
825 ASSERT_EQ(EGL_FALSE, result);
826 }
827
828 /**
829 * @tc.name: EglBindTexImageImpl002
830 * @tc.desc:
831 * @tc.type: FUNC
832 */
HWTEST_F(EglWrapperEntryTest,EglBindTexImageImpl002,Level2)833 HWTEST_F(EglWrapperEntryTest, EglBindTexImageImpl002, Level2)
834 {
835 EGLint majorVersion;
836 EGLint minorVersion;
837 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
838 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
839 ASSERT_EQ(ret, EGL_TRUE);
840
841 auto result = gWrapperHook.wrapper.eglBindTexImage(dpy, nullptr, 0);
842 ASSERT_EQ(EGL_FALSE, result);
843 }
844
845 /**
846 * @tc.name: EglReleaseTexImageImpl001
847 * @tc.desc:
848 * @tc.type: FUNC
849 */
HWTEST_F(EglWrapperEntryTest,EglReleaseTexImageImpl001,Level1)850 HWTEST_F(EglWrapperEntryTest, EglReleaseTexImageImpl001, Level1)
851 {
852 EGLDisplay dpy = nullptr;
853 auto result = gWrapperHook.wrapper.eglReleaseTexImage(dpy, nullptr, 0);
854 ASSERT_EQ(EGL_FALSE, result);
855 }
856
857 /**
858 * @tc.name: EglReleaseTexImageImpl002
859 * @tc.desc:
860 * @tc.type: FUNC
861 */
HWTEST_F(EglWrapperEntryTest,EglReleaseTexImageImpl002,Level2)862 HWTEST_F(EglWrapperEntryTest, EglReleaseTexImageImpl002, Level2)
863 {
864 EGLint majorVersion;
865 EGLint minorVersion;
866 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
867 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
868 ASSERT_EQ(ret, EGL_TRUE);
869
870 auto result = gWrapperHook.wrapper.eglReleaseTexImage(dpy, nullptr, 0);
871 ASSERT_EQ(EGL_FALSE, result);
872 }
873
874 /**
875 * @tc.name: EglSurfaceAttribImpl001
876 * @tc.desc:
877 * @tc.type: FUNC
878 */
HWTEST_F(EglWrapperEntryTest,EglSurfaceAttribImpl001,Level1)879 HWTEST_F(EglWrapperEntryTest, EglSurfaceAttribImpl001, Level1)
880 {
881 EGLDisplay dpy = nullptr;
882 auto result = gWrapperHook.wrapper.eglSurfaceAttrib(dpy, nullptr, 0, 0);
883 ASSERT_EQ(EGL_FALSE, result);
884 }
885
886 /**
887 * @tc.name: EglSurfaceAttribImpl002
888 * @tc.desc:
889 * @tc.type: FUNC
890 */
HWTEST_F(EglWrapperEntryTest,EglSurfaceAttribImpl002,Level2)891 HWTEST_F(EglWrapperEntryTest, EglSurfaceAttribImpl002, Level2)
892 {
893 EGLint majorVersion;
894 EGLint minorVersion;
895 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
896 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
897 ASSERT_EQ(ret, EGL_TRUE);
898
899 auto result = gWrapperHook.wrapper.eglSurfaceAttrib(dpy, nullptr, 0, 0);
900 ASSERT_EQ(EGL_FALSE, result);
901 }
902
903 /**
904 * @tc.name: EglSwapIntervalImpl001
905 * @tc.desc:
906 * @tc.type: FUNC
907 */
HWTEST_F(EglWrapperEntryTest,EglSwapIntervalImpl001,Level1)908 HWTEST_F(EglWrapperEntryTest, EglSwapIntervalImpl001, Level1)
909 {
910 EGLDisplay dpy = nullptr;
911 auto result = gWrapperHook.wrapper.eglSwapInterval(dpy, 0);
912 ASSERT_EQ(EGL_FALSE, result);
913 }
914
915 /**
916 * @tc.name: EglSwapIntervalImpl002
917 * @tc.desc:
918 * @tc.type: FUNC
919 */
HWTEST_F(EglWrapperEntryTest,EglSwapIntervalImpl002,Level2)920 HWTEST_F(EglWrapperEntryTest, EglSwapIntervalImpl002, Level2)
921 {
922 EGLint majorVersion;
923 EGLint minorVersion;
924 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
925 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
926 ASSERT_EQ(ret, EGL_TRUE);
927
928 auto result = gWrapperHook.wrapper.eglSwapInterval(dpy, 0);
929 ASSERT_EQ(EGL_FALSE, result);
930 }
931
932 /**
933 * @tc.name: EglBindAPIImpl001
934 * @tc.desc:
935 * @tc.type: FUNC
936 */
HWTEST_F(EglWrapperEntryTest,EglBindAPIImpl001,Level1)937 HWTEST_F(EglWrapperEntryTest, EglBindAPIImpl001, Level1)
938 {
939 auto temp = gWrapperHook.isLoad;
940 gWrapperHook.isLoad = false;
941 auto result = gWrapperHook.wrapper.eglBindAPI(1);
942 ASSERT_EQ(EGL_FALSE, result);
943 gWrapperHook.isLoad = temp;
944 }
945
946 /**
947 * @tc.name: EglBindAPIImpl002
948 * @tc.desc:
949 * @tc.type: FUNC
950 */
HWTEST_F(EglWrapperEntryTest,EglBindAPIImpl002,Level2)951 HWTEST_F(EglWrapperEntryTest, EglBindAPIImpl002, Level2)
952 {
953 auto temp = gWrapperHook.isLoad;
954 gWrapperHook.isLoad = true;
955 auto result = gWrapperHook.wrapper.eglBindAPI(1);
956 ASSERT_EQ(EGL_FALSE, result);
957 gWrapperHook.isLoad = temp;
958 }
959
960 /**
961 * @tc.name: EglQueryAPIImpl001
962 * @tc.desc:
963 * @tc.type: FUNC
964 */
HWTEST_F(EglWrapperEntryTest,EglQueryAPIImpl001,Level1)965 HWTEST_F(EglWrapperEntryTest, EglQueryAPIImpl001, Level1)
966 {
967 auto temp = gWrapperHook.isLoad;
968 gWrapperHook.isLoad = false;
969 auto result = gWrapperHook.wrapper.eglQueryAPI();
970 ASSERT_EQ(EGL_OPENGL_ES_API, result);
971 gWrapperHook.isLoad = temp;
972 }
973
974 /**
975 * @tc.name: EglQueryAPIImpl002
976 * @tc.desc:
977 * @tc.type: FUNC
978 */
HWTEST_F(EglWrapperEntryTest,EglQueryAPIImpl002,Level2)979 HWTEST_F(EglWrapperEntryTest, EglQueryAPIImpl002, Level2)
980 {
981 auto temp = gWrapperHook.isLoad;
982 gWrapperHook.isLoad = true;
983 auto result = gWrapperHook.wrapper.eglQueryAPI();
984 ASSERT_EQ(EGL_OPENGL_ES_API, result);
985 gWrapperHook.isLoad = temp;
986 }
987
988 /**
989 * @tc.name: EglCreatePbufferFromClientBufferImpl001
990 * @tc.desc:
991 * @tc.type: FUNC
992 */
HWTEST_F(EglWrapperEntryTest,EglCreatePbufferFromClientBufferImpl001,Level1)993 HWTEST_F(EglWrapperEntryTest, EglCreatePbufferFromClientBufferImpl001, Level1)
994 {
995 EGLDisplay dpy = nullptr;
996 auto result = gWrapperHook.wrapper.eglCreatePbufferFromClientBuffer(dpy, 0, nullptr, nullptr, nullptr);
997 ASSERT_EQ(EGL_NO_SURFACE, result);
998 }
999
1000 /**
1001 * @tc.name: EglReleaseThreadImpl001
1002 * @tc.desc:
1003 * @tc.type: FUNC
1004 */
HWTEST_F(EglWrapperEntryTest,EglReleaseThreadImpl001,Level1)1005 HWTEST_F(EglWrapperEntryTest, EglReleaseThreadImpl001, Level1)
1006 {
1007 auto temp = gWrapperHook.isLoad;
1008 gWrapperHook.isLoad = false;
1009 auto result = gWrapperHook.wrapper.eglReleaseThread();
1010 ASSERT_EQ(EGL_TRUE, result);
1011 gWrapperHook.isLoad = temp;
1012 }
1013
1014 /**
1015 * @tc.name: EglReleaseThreadImpl002
1016 * @tc.desc:
1017 * @tc.type: FUNC
1018 */
HWTEST_F(EglWrapperEntryTest,EglReleaseThreadImpl002,Level2)1019 HWTEST_F(EglWrapperEntryTest, EglReleaseThreadImpl002, Level2)
1020 {
1021 auto temp = gWrapperHook.isLoad;
1022 gWrapperHook.isLoad = true;
1023 auto result = gWrapperHook.wrapper.eglReleaseThread();
1024 ASSERT_EQ(EGL_TRUE, result);
1025 gWrapperHook.isLoad = temp;
1026 }
1027
1028 /**
1029 * @tc.name: EglWaitClientImpl001
1030 * @tc.desc:
1031 * @tc.type: FUNC
1032 */
HWTEST_F(EglWrapperEntryTest,EglWaitClientImpl001,Level1)1033 HWTEST_F(EglWrapperEntryTest, EglWaitClientImpl001, Level1)
1034 {
1035 auto temp = gWrapperHook.isLoad;
1036 gWrapperHook.isLoad = false;
1037 auto result = gWrapperHook.wrapper.eglWaitClient();
1038 ASSERT_EQ(EGL_FALSE, result);
1039 gWrapperHook.isLoad = temp;
1040 }
1041
1042 /**
1043 * @tc.name: EglWaitClientImpl002
1044 * @tc.desc:
1045 * @tc.type: FUNC
1046 */
HWTEST_F(EglWrapperEntryTest,EglWaitClientImpl002,Level2)1047 HWTEST_F(EglWrapperEntryTest, EglWaitClientImpl002, Level2)
1048 {
1049 auto temp = gWrapperHook.isLoad;
1050 gWrapperHook.isLoad = true;
1051 auto result = gWrapperHook.wrapper.eglWaitClient();
1052 ASSERT_NE(EGL_FALSE, result);
1053 gWrapperHook.isLoad = temp;
1054 }
1055
1056 /**
1057 * @tc.name: EglCreateSyncImpl001
1058 * @tc.desc:
1059 * @tc.type: FUNC
1060 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncImpl001,Level1)1061 HWTEST_F(EglWrapperEntryTest, EglCreateSyncImpl001, Level1)
1062 {
1063 EGLDisplay dpy = nullptr;
1064 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1065 ASSERT_EQ(EGL_NO_SYNC, result);
1066 }
1067
1068 /**
1069 * @tc.name: EglCreateSyncImpl002
1070 * @tc.desc:
1071 * @tc.type: FUNC
1072 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncImpl002,Level2)1073 HWTEST_F(EglWrapperEntryTest, EglCreateSyncImpl002, Level2)
1074 {
1075 EGLint majorVersion;
1076 EGLint minorVersion;
1077 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1078 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1079 ASSERT_EQ(ret, EGL_TRUE);
1080
1081 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1082 ASSERT_EQ(EGL_NO_SYNC, result);
1083 }
1084
1085 /**
1086 * @tc.name: EglDestroySyncImpl001
1087 * @tc.desc:
1088 * @tc.type: FUNC
1089 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncImpl001,Level1)1090 HWTEST_F(EglWrapperEntryTest, EglDestroySyncImpl001, Level1)
1091 {
1092 EGLDisplay dpy = nullptr;
1093 auto result = gWrapperHook.wrapper.eglDestroySync(dpy, nullptr);
1094 ASSERT_EQ(EGL_FALSE, result);
1095 }
1096
1097 /**
1098 * @tc.name: EglDestroySyncImpl002
1099 * @tc.desc:
1100 * @tc.type: FUNC
1101 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncImpl002,Level2)1102 HWTEST_F(EglWrapperEntryTest, EglDestroySyncImpl002, Level2)
1103 {
1104 EGLint majorVersion;
1105 EGLint minorVersion;
1106 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1107 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1108 ASSERT_EQ(ret, EGL_TRUE);
1109
1110 auto result = gWrapperHook.wrapper.eglDestroySync(dpy, nullptr);
1111 ASSERT_EQ(EGL_FALSE, result);
1112 }
1113
1114 /**
1115 * @tc.name: EglClientWaitSyncImpl001
1116 * @tc.desc:
1117 * @tc.type: FUNC
1118 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncImpl001,Level1)1119 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncImpl001, Level1)
1120 {
1121 EGLDisplay dpy = nullptr;
1122 auto result = gWrapperHook.wrapper.eglClientWaitSync(dpy, nullptr, 0, 0);
1123 ASSERT_EQ(EGL_FALSE, result);
1124 }
1125
1126 /**
1127 * @tc.name: EglClientWaitSyncImpl002
1128 * @tc.desc:
1129 * @tc.type: FUNC
1130 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncImpl002,Level2)1131 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncImpl002, Level2)
1132 {
1133 EGLint majorVersion;
1134 EGLint minorVersion;
1135 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1136 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1137 ASSERT_EQ(ret, EGL_TRUE);
1138
1139 auto result = gWrapperHook.wrapper.eglClientWaitSync(dpy, nullptr, 0, 0);
1140 ASSERT_EQ(EGL_FALSE, result);
1141 }
1142
1143 /**
1144 * @tc.name: EglGetSyncAttribImpl001
1145 * @tc.desc:
1146 * @tc.type: FUNC
1147 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl001,Level1)1148 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl001, Level1)
1149 {
1150 EGLDisplay dpy = nullptr;
1151 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, nullptr);
1152 ASSERT_EQ(EGL_FALSE, result);
1153 }
1154
1155 /**
1156 * @tc.name: EglGetSyncAttribImpl002
1157 * @tc.desc:
1158 * @tc.type: FUNC
1159 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl002,Level2)1160 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl002, Level2)
1161 {
1162 EGLint majorVersion;
1163 EGLint minorVersion;
1164 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1165 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1166 ASSERT_EQ(ret, EGL_TRUE);
1167
1168 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, nullptr);
1169 ASSERT_EQ(EGL_FALSE, result);
1170 }
1171
1172 /**
1173 * @tc.name: EglGetSyncAttribImpl003
1174 * @tc.desc:
1175 * @tc.type: FUNC
1176 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl003,Level2)1177 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl003, Level2)
1178 {
1179 EGLint majorVersion;
1180 EGLint minorVersion;
1181 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1182 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1183 ASSERT_EQ(ret, EGL_TRUE);
1184 EGLAttrib value = 1;
1185
1186 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, &value);
1187 ASSERT_EQ(EGL_FALSE, result);
1188 }
1189
1190 /**
1191 * @tc.name: EglCreateImageImpl001
1192 * @tc.desc:
1193 * @tc.type: FUNC
1194 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl001,Level1)1195 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl001, Level1)
1196 {
1197 EGLDisplay dpy = nullptr;
1198 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1199 ASSERT_EQ(EGL_NO_IMAGE, result);
1200 }
1201
1202 /**
1203 * @tc.name: EglCreateImageImpl002
1204 * @tc.desc:
1205 * @tc.type: FUNC
1206 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl002,Level2)1207 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl002, Level2)
1208 {
1209 EGLint majorVersion;
1210 EGLint minorVersion;
1211 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1212 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1213 ASSERT_EQ(ret, EGL_TRUE);
1214
1215 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1216 ASSERT_EQ(EGL_NO_IMAGE, result);
1217 }
1218
1219 /**
1220 * @tc.name: EglDestroyImageImpl001
1221 * @tc.desc:
1222 * @tc.type: FUNC
1223 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl001,Level1)1224 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl001, Level1)
1225 {
1226 EGLDisplay dpy = nullptr;
1227 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1228 ASSERT_EQ(EGL_FALSE, result);
1229 }
1230
1231 /**
1232 * @tc.name: EglDestroyImageImpl002
1233 * @tc.desc:
1234 * @tc.type: FUNC
1235 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl002,Level2)1236 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl002, Level2)
1237 {
1238 EGLint majorVersion;
1239 EGLint minorVersion;
1240 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1241 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1242 ASSERT_EQ(ret, EGL_TRUE);
1243
1244 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1245 ASSERT_EQ(EGL_FALSE, result);
1246 }
1247
1248 /**
1249 * @tc.name: EglCreatePlatformWindowSurfaceImpl001
1250 * @tc.desc:
1251 * @tc.type: FUNC
1252 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl001,Level1)1253 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl001, Level1)
1254 {
1255 EGLDisplay dpy = nullptr;
1256 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1257 ASSERT_EQ(EGL_NO_SURFACE, result);
1258 }
1259
1260 /**
1261 * @tc.name: EglCreatePlatformWindowSurfaceImpl002
1262 * @tc.desc:
1263 * @tc.type: FUNC
1264 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl002,Level2)1265 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl002, Level2)
1266 {
1267 EGLint majorVersion;
1268 EGLint minorVersion;
1269 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1270 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1271 ASSERT_EQ(ret, EGL_TRUE);
1272
1273 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1274 ASSERT_EQ(EGL_NO_SURFACE, result);
1275 }
1276
1277 /**
1278 * @tc.name: EglCreatePlatformPixmapSurfaceImpl001
1279 * @tc.desc:
1280 * @tc.type: FUNC
1281 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl001,Level1)1282 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl001, Level1)
1283 {
1284 EGLDisplay dpy = nullptr;
1285 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1286 ASSERT_EQ(EGL_NO_SURFACE, result);
1287 }
1288
1289 /**
1290 * @tc.name: EglCreatePlatformPixmapSurfaceImpl002
1291 * @tc.desc:
1292 * @tc.type: FUNC
1293 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl002,Level2)1294 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl002, Level2)
1295 {
1296 EGLint majorVersion;
1297 EGLint minorVersion;
1298 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1299 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1300 ASSERT_EQ(ret, EGL_TRUE);
1301
1302 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1303 ASSERT_EQ(EGL_NO_SURFACE, result);
1304 }
1305
1306 /**
1307 * @tc.name: EglWaitSyncImpl001
1308 * @tc.desc:
1309 * @tc.type: FUNC
1310 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl001,Level1)1311 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl001, Level1)
1312 {
1313 EGLDisplay dpy = nullptr;
1314 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1315 ASSERT_EQ(EGL_FALSE, result);
1316 }
1317
1318 /**
1319 * @tc.name: EglWaitSyncImpl002
1320 * @tc.desc:
1321 * @tc.type: FUNC
1322 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl002,Level2)1323 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl002, Level2)
1324 {
1325 EGLint majorVersion;
1326 EGLint minorVersion;
1327 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1328 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1329 ASSERT_EQ(ret, EGL_TRUE);
1330
1331 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1332 ASSERT_EQ(EGL_FALSE, result);
1333 }
1334
1335 /**
1336 * @tc.name: EglLockSurfaceKHRImpl001
1337 * @tc.desc:
1338 * @tc.type: FUNC
1339 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl001,Level1)1340 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl001, Level1)
1341 {
1342 EGLDisplay dpy = nullptr;
1343 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1344 ASSERT_EQ(EGL_FALSE, result);
1345 }
1346
1347 /**
1348 * @tc.name: EglLockSurfaceKHRImpl002
1349 * @tc.desc:
1350 * @tc.type: FUNC
1351 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl002,Level2)1352 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl002, Level2)
1353 {
1354 EGLint majorVersion;
1355 EGLint minorVersion;
1356 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1357 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1358 ASSERT_EQ(ret, EGL_TRUE);
1359
1360 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1361 ASSERT_EQ(EGL_FALSE, result);
1362 }
1363
1364 /**
1365 * @tc.name: EglUnlockSurfaceKHRImpl001
1366 * @tc.desc:
1367 * @tc.type: FUNC
1368 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl001,Level1)1369 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl001, Level1)
1370 {
1371 EGLint majorVersion;
1372 EGLint minorVersion;
1373 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1374 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1375 ASSERT_EQ(ret, EGL_TRUE);
1376
1377 auto result = gWrapperHook.wrapper.eglUnlockSurfaceKHR(dpy, nullptr);
1378 ASSERT_EQ(EGL_FALSE, result);
1379 }
1380
1381 /**
1382 * @tc.name: EglUnlockSurfaceKHRImpl002
1383 * @tc.desc:
1384 * @tc.type: FUNC
1385 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl002,Level2)1386 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl002, Level2)
1387 {
1388 EGLint majorVersion;
1389 EGLint minorVersion;
1390 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1391 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1392 ASSERT_EQ(ret, EGL_TRUE);
1393
1394 auto result = gWrapperHook.wrapper.eglUnlockSurfaceKHR(dpy, nullptr);
1395 ASSERT_EQ(EGL_FALSE, result);
1396 }
1397
1398 /**
1399 * @tc.name: EglCreateImageKHRImpl001
1400 * @tc.desc:
1401 * @tc.type: FUNC
1402 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl001,Level1)1403 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl001, Level1)
1404 {
1405 EGLDisplay dpy = nullptr;
1406 auto result = gWrapperHook.wrapper.eglCreateImageKHR(dpy, 0, 0, nullptr, nullptr);
1407 ASSERT_EQ(EGL_NO_IMAGE_KHR, result);
1408 }
1409
1410 /**
1411 * @tc.name: EglCreateImageKHRImpl002
1412 * @tc.desc:
1413 * @tc.type: FUNC
1414 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl002,Level2)1415 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl002, Level2)
1416 {
1417 EGLint majorVersion;
1418 EGLint minorVersion;
1419 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1420 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1421 ASSERT_EQ(ret, EGL_TRUE);
1422
1423 auto result = gWrapperHook.wrapper.eglCreateImageKHR(dpy, 0, 0, nullptr, nullptr);
1424 ASSERT_EQ(EGL_NO_IMAGE_KHR, result);
1425 }
1426
1427 /**
1428 * @tc.name: EglDestroyImageKHRImpl001
1429 * @tc.desc:
1430 * @tc.type: FUNC
1431 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl001,Level1)1432 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl001, Level1)
1433 {
1434 EGLDisplay dpy = nullptr;
1435 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1436 ASSERT_EQ(EGL_FALSE, result);
1437 }
1438
1439 /**
1440 * @tc.name: EglDestroyImageKHRImpl002
1441 * @tc.desc:
1442 * @tc.type: FUNC
1443 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl002,Level2)1444 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl002, Level2)
1445 {
1446 EGLint majorVersion;
1447 EGLint minorVersion;
1448 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1449 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1450 ASSERT_EQ(ret, EGL_TRUE);
1451
1452 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1453 ASSERT_EQ(EGL_FALSE, result);
1454 }
1455
1456 /**
1457 * @tc.name: EglCreateSyncKHRImpl001
1458 * @tc.desc:
1459 * @tc.type: FUNC
1460 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl001,Level1)1461 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl001, Level1)
1462 {
1463 EGLDisplay dpy = nullptr;
1464 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1465 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1466 }
1467
1468 /**
1469 * @tc.name: EglCreateSyncKHRImpl002
1470 * @tc.desc:
1471 * @tc.type: FUNC
1472 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl002,Level2)1473 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl002, Level2)
1474 {
1475 EGLint majorVersion;
1476 EGLint minorVersion;
1477 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1478 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1479 ASSERT_EQ(ret, EGL_TRUE);
1480
1481 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1482 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1483 }
1484
1485 /**
1486 * @tc.name: EglDestroySyncKHRImpl001
1487 * @tc.desc:
1488 * @tc.type: FUNC
1489 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl001,Level1)1490 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl001, Level1)
1491 {
1492 EGLDisplay dpy = nullptr;
1493 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1494 ASSERT_EQ(EGL_FALSE, result);
1495 }
1496
1497 /**
1498 * @tc.name: EglDestroySyncKHRImpl002
1499 * @tc.desc:
1500 * @tc.type: FUNC
1501 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl002,Level2)1502 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl002, Level2)
1503 {
1504 EGLint majorVersion;
1505 EGLint minorVersion;
1506 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1507 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1508 ASSERT_EQ(ret, EGL_TRUE);
1509
1510 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1511 ASSERT_EQ(EGL_FALSE, result);
1512 }
1513
1514 /**
1515 * @tc.name: EglClientWaitSyncKHRImpl001
1516 * @tc.desc:
1517 * @tc.type: FUNC
1518 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl001,Level1)1519 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl001, Level1)
1520 {
1521 EGLDisplay dpy = nullptr;
1522 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1523 ASSERT_EQ(EGL_FALSE, result);
1524 }
1525
1526 /**
1527 * @tc.name: EglClientWaitSyncKHRImpl002
1528 * @tc.desc:
1529 * @tc.type: FUNC
1530 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl002,Level2)1531 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl002, Level2)
1532 {
1533 EGLint majorVersion;
1534 EGLint minorVersion;
1535 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1536 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1537 ASSERT_EQ(ret, EGL_TRUE);
1538
1539 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1540 ASSERT_EQ(EGL_FALSE, result);
1541 }
1542
1543 /**
1544 * @tc.name: EglGetSyncAttribKHRImpl001
1545 * @tc.desc:
1546 * @tc.type: FUNC
1547 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl001,Level1)1548 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl001, Level1)
1549 {
1550 EGLDisplay dpy = nullptr;
1551 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1552 ASSERT_EQ(EGL_FALSE, result);
1553 }
1554
1555 /**
1556 * @tc.name: EglGetSyncAttribKHRImpl002
1557 * @tc.desc:
1558 * @tc.type: FUNC
1559 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl002,Level2)1560 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl002, Level2)
1561 {
1562 EGLint majorVersion;
1563 EGLint minorVersion;
1564 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1565 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1566 ASSERT_EQ(ret, EGL_TRUE);
1567
1568 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1569 ASSERT_EQ(EGL_FALSE, result);
1570 }
1571
1572 /**
1573 * @tc.name: EglGetSyncAttribKHRImpl003
1574 * @tc.desc:
1575 * @tc.type: FUNC
1576 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl003,Level2)1577 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl003, Level2)
1578 {
1579 EGLint majorVersion;
1580 EGLint minorVersion;
1581 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1582 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1583 ASSERT_EQ(ret, EGL_TRUE);
1584 EGLint value = 1;
1585
1586 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, &value);
1587 ASSERT_EQ(EGL_FALSE, result);
1588 }
1589
1590 /**
1591 * @tc.name: EglSignalSyncKHRImpl001
1592 * @tc.desc:
1593 * @tc.type: FUNC
1594 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl001,Level1)1595 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl001, Level1)
1596 {
1597 EGLDisplay dpy = nullptr;
1598 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1599 ASSERT_EQ(EGL_FALSE, result);
1600 }
1601
1602 /**
1603 * @tc.name: EglSignalSyncKHRImpl002
1604 * @tc.desc:
1605 * @tc.type: FUNC
1606 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl002,Level2)1607 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl002, Level2)
1608 {
1609 EGLint majorVersion;
1610 EGLint minorVersion;
1611 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1612 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1613 ASSERT_EQ(ret, EGL_TRUE);
1614
1615 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1616 ASSERT_EQ(EGL_FALSE, result);
1617 }
1618
1619 /**
1620 * @tc.name: EglCreateStreamKHRImpl001
1621 * @tc.desc:
1622 * @tc.type: FUNC
1623 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl001,Level1)1624 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl001, Level1)
1625 {
1626 EGLDisplay dpy = nullptr;
1627 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1628 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1629 }
1630
1631 /**
1632 * @tc.name: EglCreateStreamKHRImpl002
1633 * @tc.desc:
1634 * @tc.type: FUNC
1635 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl002,Level2)1636 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl002, Level2)
1637 {
1638 EGLint majorVersion;
1639 EGLint minorVersion;
1640 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1641 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1642 ASSERT_EQ(ret, EGL_TRUE);
1643
1644 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1645 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1646 }
1647
1648
1649 /**
1650 * @tc.name: EglDestroyStreamKHRImpl001
1651 * @tc.desc:
1652 * @tc.type: FUNC
1653 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl001,Level1)1654 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl001, Level1)
1655 {
1656 EGLint majorVersion;
1657 EGLint minorVersion;
1658 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1659 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1660 ASSERT_EQ(ret, EGL_TRUE);
1661
1662 auto result = gWrapperHook.wrapper.eglDestroyStreamKHR(dpy, nullptr);
1663 ASSERT_EQ(EGL_FALSE, result);
1664 }
1665
1666 /**
1667 * @tc.name: EglDestroyStreamKHRImpl002
1668 * @tc.desc:
1669 * @tc.type: FUNC
1670 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl002,Level2)1671 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl002, Level2)
1672 {
1673 EGLint majorVersion;
1674 EGLint minorVersion;
1675 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1676 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1677 ASSERT_EQ(ret, EGL_TRUE);
1678
1679 auto result = gWrapperHook.wrapper.eglDestroyStreamKHR(dpy, nullptr);
1680 ASSERT_EQ(EGL_FALSE, result);
1681 }
1682
1683 /**
1684 * @tc.name: EglStreamAttribKHRImpl001
1685 * @tc.desc:
1686 * @tc.type: FUNC
1687 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl001,Level1)1688 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl001, Level1)
1689 {
1690 EGLDisplay dpy = nullptr;
1691 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1692 ASSERT_EQ(EGL_FALSE, result);
1693 }
1694
1695 /**
1696 * @tc.name: EglStreamAttribKHRImpl002
1697 * @tc.desc:
1698 * @tc.type: FUNC
1699 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl002,Level2)1700 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl002, Level2)
1701 {
1702 EGLint majorVersion;
1703 EGLint minorVersion;
1704 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1705 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1706 ASSERT_EQ(ret, EGL_TRUE);
1707
1708 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1709 ASSERT_EQ(EGL_FALSE, result);
1710 }
1711
1712 /**
1713 * @tc.name: EglQueryStreamKHRImpl001
1714 * @tc.desc:
1715 * @tc.type: FUNC
1716 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl001,Level1)1717 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl001, Level1)
1718 {
1719 EGLDisplay dpy = nullptr;
1720 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1721 ASSERT_EQ(EGL_FALSE, result);
1722 }
1723
1724 /**
1725 * @tc.name: EglQueryStreamKHRImpl002
1726 * @tc.desc:
1727 * @tc.type: FUNC
1728 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl002,Level2)1729 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl002, Level2)
1730 {
1731 EGLint majorVersion;
1732 EGLint minorVersion;
1733 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1734 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1735 ASSERT_EQ(ret, EGL_TRUE);
1736
1737 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1738 ASSERT_EQ(EGL_FALSE, result);
1739 }
1740
1741 /**
1742 * @tc.name: EglQueryStreamKHRImpl003
1743 * @tc.desc:
1744 * @tc.type: FUNC
1745 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl003,Level2)1746 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl003, Level2)
1747 {
1748 EGLint majorVersion;
1749 EGLint minorVersion;
1750 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1751 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1752 ASSERT_EQ(ret, EGL_TRUE);
1753 EGLint value = 1;
1754
1755 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, &value);
1756 ASSERT_EQ(EGL_FALSE, result);
1757 }
1758
1759 /**
1760 * @tc.name: EglQueryStreamu64KHRImpl001
1761 * @tc.desc:
1762 * @tc.type: FUNC
1763 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl001,Level1)1764 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl001, Level1)
1765 {
1766 EGLDisplay dpy = nullptr;
1767 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1768 ASSERT_EQ(EGL_FALSE, result);
1769 }
1770
1771 /**
1772 * @tc.name: EglQueryStreamu64KHRImpl002
1773 * @tc.desc:
1774 * @tc.type: FUNC
1775 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl002,Level2)1776 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl002, Level2)
1777 {
1778 EGLint majorVersion;
1779 EGLint minorVersion;
1780 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1781 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1782 ASSERT_EQ(ret, EGL_TRUE);
1783
1784 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1785 ASSERT_EQ(EGL_FALSE, result);
1786 }
1787
1788 /**
1789 * @tc.name: EglQueryStreamu64KHRImpl003
1790 * @tc.desc:
1791 * @tc.type: FUNC
1792 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl003,Level2)1793 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl003, Level2)
1794 {
1795 EGLint majorVersion;
1796 EGLint minorVersion;
1797 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1798 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1799 ASSERT_EQ(ret, EGL_TRUE);
1800 EGLuint64KHR value = 1;
1801
1802 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, &value);
1803 ASSERT_EQ(EGL_FALSE, result);
1804 }
1805
1806 /**
1807 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl001
1808 * @tc.desc:
1809 * @tc.type: FUNC
1810 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl001,Level1)1811 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl001, Level1)
1812 {
1813 EGLDisplay dpy = nullptr;
1814 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1815 ASSERT_EQ(EGL_FALSE, result);
1816 }
1817
1818 /**
1819 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl002
1820 * @tc.desc:
1821 * @tc.type: FUNC
1822 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl002,Level2)1823 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl002, Level2)
1824 {
1825 EGLint majorVersion;
1826 EGLint minorVersion;
1827 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1828 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1829 ASSERT_EQ(ret, EGL_TRUE);
1830
1831 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1832 ASSERT_EQ(EGL_FALSE, result);
1833 }
1834
1835 /**
1836 * @tc.name: EglStreamConsumerAcquireKHRImpl001
1837 * @tc.desc:
1838 * @tc.type: FUNC
1839 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl001,Level1)1840 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl001, Level1)
1841 {
1842 EGLDisplay dpy = nullptr;
1843 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1844 ASSERT_EQ(EGL_FALSE, result);
1845 }
1846
1847 /**
1848 * @tc.name: EglStreamConsumerAcquireKHRImpl002
1849 * @tc.desc:
1850 * @tc.type: FUNC
1851 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl002,Level2)1852 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl002, Level2)
1853 {
1854 EGLint majorVersion;
1855 EGLint minorVersion;
1856 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1857 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1858 ASSERT_EQ(ret, EGL_TRUE);
1859
1860 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1861 ASSERT_EQ(EGL_FALSE, result);
1862 }
1863
1864 /**
1865 * @tc.name: EglStreamConsumerReleaseKHRImpl001
1866 * @tc.desc:
1867 * @tc.type: FUNC
1868 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl001,Level1)1869 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl001, Level1)
1870 {
1871 EGLDisplay dpy = nullptr;
1872 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1873 ASSERT_EQ(EGL_FALSE, result);
1874 }
1875
1876 /**
1877 * @tc.name: EglStreamConsumerReleaseKHRImpl002
1878 * @tc.desc:
1879 * @tc.type: FUNC
1880 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl002,Level2)1881 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl002, Level2)
1882 {
1883 EGLint majorVersion;
1884 EGLint minorVersion;
1885 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1886 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1887 ASSERT_EQ(ret, EGL_TRUE);
1888
1889 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1890 ASSERT_EQ(EGL_FALSE, result);
1891 }
1892
1893 /**
1894 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl001
1895 * @tc.desc:
1896 * @tc.type: FUNC
1897 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl001,Level1)1898 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl001, Level1)
1899 {
1900 EGLDisplay dpy = nullptr;
1901 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1902 ASSERT_EQ(EGL_NO_SURFACE, result);
1903 }
1904
1905 /**
1906 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl002
1907 * @tc.desc:
1908 * @tc.type: FUNC
1909 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl002,Level2)1910 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl002, Level2)
1911 {
1912 EGLint majorVersion;
1913 EGLint minorVersion;
1914 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1915 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1916 ASSERT_EQ(ret, EGL_TRUE);
1917
1918 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1919 ASSERT_EQ(EGL_NO_SURFACE, result);
1920 }
1921
1922 /**
1923 * @tc.name: EglQueryStreamTimeKHRImpl001
1924 * @tc.desc:
1925 * @tc.type: FUNC
1926 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl001,Level1)1927 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl001, Level1)
1928 {
1929 EGLDisplay dpy = nullptr;
1930 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1931 ASSERT_EQ(EGL_FALSE, result);
1932 }
1933
1934 /**
1935 * @tc.name: EglQueryStreamTimeKHRImpl002
1936 * @tc.desc:
1937 * @tc.type: FUNC
1938 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl002,Level2)1939 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl002, Level2)
1940 {
1941 EGLint majorVersion;
1942 EGLint minorVersion;
1943 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1944 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1945 ASSERT_EQ(ret, EGL_TRUE);
1946
1947 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1948 ASSERT_EQ(EGL_FALSE, result);
1949 }
1950
1951 /**
1952 * @tc.name: EglQueryStreamTimeKHRImpl003
1953 * @tc.desc:
1954 * @tc.type: FUNC
1955 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl003,Level2)1956 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl003, Level2)
1957 {
1958 EGLint majorVersion;
1959 EGLint minorVersion;
1960 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1961 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1962 ASSERT_EQ(ret, EGL_TRUE);
1963 EGLTimeKHR value = 1;
1964
1965 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, &value);
1966 ASSERT_EQ(EGL_FALSE, result);
1967 }
1968
1969 /**
1970 * @tc.name: EglGetStreamFileDescriptorKHRImpl001
1971 * @tc.desc:
1972 * @tc.type: FUNC
1973 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl001,Level1)1974 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl001, Level1)
1975 {
1976 EGLDisplay dpy = nullptr;
1977 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
1978 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
1979 }
1980
1981 /**
1982 * @tc.name: EglGetStreamFileDescriptorKHRImpl002
1983 * @tc.desc:
1984 * @tc.type: FUNC
1985 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl002,Level2)1986 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl002, Level2)
1987 {
1988 EGLint majorVersion;
1989 EGLint minorVersion;
1990 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1991 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1992 ASSERT_EQ(ret, EGL_TRUE);
1993
1994 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
1995 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
1996 }
1997
1998
1999 /**
2000 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl001
2001 * @tc.desc:
2002 * @tc.type: FUNC
2003 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl001,Level1)2004 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl001, Level1)
2005 {
2006 EGLDisplay dpy = nullptr;
2007 auto result = gWrapperHook.wrapper.eglCreateStreamFromFileDescriptorKHR(dpy, EGL_NO_FILE_DESCRIPTOR_KHR);
2008 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
2009 }
2010
2011 /**
2012 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl002
2013 * @tc.desc:
2014 * @tc.type: FUNC
2015 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl002,Level2)2016 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl002, Level2)
2017 {
2018 EGLint majorVersion;
2019 EGLint minorVersion;
2020 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2021 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2022 ASSERT_EQ(ret, EGL_TRUE);
2023
2024 auto result = gWrapperHook.wrapper.eglCreateStreamFromFileDescriptorKHR(dpy, EGL_NO_FILE_DESCRIPTOR_KHR);
2025 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
2026 }
2027
2028 /**
2029 * @tc.name: EglWaitSyncKHRImpl001
2030 * @tc.desc:
2031 * @tc.type: FUNC
2032 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl001,Level1)2033 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl001, Level1)
2034 {
2035 EGLDisplay dpy = nullptr;
2036 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2037 ASSERT_EQ(EGL_FALSE, result);
2038 }
2039
2040 /**
2041 * @tc.name: EglWaitSyncKHRImpl002
2042 * @tc.desc:
2043 * @tc.type: FUNC
2044 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl002,Level2)2045 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl002, Level2)
2046 {
2047 EGLint majorVersion;
2048 EGLint minorVersion;
2049 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2050 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2051 ASSERT_EQ(ret, EGL_TRUE);
2052
2053 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2054 ASSERT_EQ(EGL_FALSE, result);
2055 }
2056
2057 /**
2058 * @tc.name: EglGetPlatformDisplayEXTImpl001
2059 * @tc.desc:
2060 * @tc.type: FUNC
2061 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl001,Level1)2062 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl001, Level1)
2063 {
2064 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGLNativeDisplayType(1), nullptr);
2065 ASSERT_EQ(EGL_NO_DISPLAY, result);
2066 }
2067
2068 /**
2069 * @tc.name: EglGetPlatformDisplayEXTImpl002
2070 * @tc.desc:
2071 * @tc.type: FUNC
2072 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl002,Level2)2073 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl002, Level2)
2074 {
2075 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGL_DEFAULT_DISPLAY, nullptr);
2076 ASSERT_EQ(EGL_NO_DISPLAY, result);
2077 }
2078
2079 /**
2080 * @tc.name: EglGetPlatformDisplayEXTImpl003
2081 * @tc.desc:
2082 * @tc.type: FUNC
2083 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl003,Level2)2084 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl003, Level2)
2085 {
2086 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(EGL_PLATFORM_OHOS_KHR, EGL_DEFAULT_DISPLAY, nullptr);
2087 ASSERT_NE(EGL_NO_DISPLAY, result);
2088 }
2089
2090 /**
2091 * @tc.name: EglSwapBuffersWithDamageKHRImpl001
2092 * @tc.desc:
2093 * @tc.type: FUNC
2094 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl001,Level1)2095 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl001, Level1)
2096 {
2097 EGLDisplay dpy = nullptr;
2098 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2099 ASSERT_EQ(EGL_FALSE, result);
2100 }
2101
2102 /**
2103 * @tc.name: EglSwapBuffersWithDamageKHRImpl002
2104 * @tc.desc:
2105 * @tc.type: FUNC
2106 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl002,Level2)2107 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl002, Level2)
2108 {
2109 EGLint majorVersion;
2110 EGLint minorVersion;
2111 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2112 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2113 ASSERT_EQ(ret, EGL_TRUE);
2114
2115 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2116 ASSERT_EQ(EGL_FALSE, result);
2117 }
2118
2119 /**
2120 * @tc.name: EglSetDamageRegionKHRImpl001
2121 * @tc.desc:
2122 * @tc.type: FUNC
2123 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl001,Level1)2124 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl001, Level1)
2125 {
2126 EGLDisplay dpy = nullptr;
2127 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2128 ASSERT_EQ(EGL_FALSE, result);
2129 }
2130
2131 /**
2132 * @tc.name: EglSetDamageRegionKHRImpl002
2133 * @tc.desc:
2134 * @tc.type: FUNC
2135 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl002,Level2)2136 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl002, Level2)
2137 {
2138 EGLint majorVersion;
2139 EGLint minorVersion;
2140 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2141 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2142 ASSERT_EQ(ret, EGL_TRUE);
2143
2144 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2145 ASSERT_EQ(EGL_FALSE, result);
2146 }
2147 } // OHOS::Rosen