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: EglDupNativeFenceFDANDROIDImpl001
1192 * @tc.desc:
1193 * @tc.type: FUNC
1194 */
HWTEST_F(EglWrapperEntryTest,EglDupNativeFenceFDANDROIDImpl001,Level2)1195 HWTEST_F(EglWrapperEntryTest, EglDupNativeFenceFDANDROIDImpl001, Level2)
1196 {
1197 EGLint majorVersion;
1198 EGLint minorVersion;
1199 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1200 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1201 ASSERT_EQ(ret, EGL_TRUE);
1202
1203 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1204 ASSERT_EQ(EGL_NO_SYNC, result);
1205
1206 auto result1 = gWrapperHook.wrapper.eglDupNativeFenceFDANDROID(dpy, result);
1207 ASSERT_EQ(EGL_NO_NATIVE_FENCE_FD_ANDROID, result1);
1208 }
1209
1210 /**
1211 * @tc.name: EglCreateImageImpl001
1212 * @tc.desc:
1213 * @tc.type: FUNC
1214 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl001,Level1)1215 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl001, Level1)
1216 {
1217 EGLDisplay dpy = nullptr;
1218 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1219 ASSERT_EQ(EGL_NO_IMAGE, result);
1220 }
1221
1222 /**
1223 * @tc.name: EglCreateImageImpl002
1224 * @tc.desc:
1225 * @tc.type: FUNC
1226 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl002,Level2)1227 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl002, Level2)
1228 {
1229 EGLint majorVersion;
1230 EGLint minorVersion;
1231 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1232 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1233 ASSERT_EQ(ret, EGL_TRUE);
1234
1235 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1236 ASSERT_EQ(EGL_NO_IMAGE, result);
1237 }
1238
1239 /**
1240 * @tc.name: EglDestroyImageImpl001
1241 * @tc.desc:
1242 * @tc.type: FUNC
1243 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl001,Level1)1244 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl001, Level1)
1245 {
1246 EGLDisplay dpy = nullptr;
1247 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1248 ASSERT_EQ(EGL_FALSE, result);
1249 }
1250
1251 /**
1252 * @tc.name: EglDestroyImageImpl002
1253 * @tc.desc:
1254 * @tc.type: FUNC
1255 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl002,Level2)1256 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl002, Level2)
1257 {
1258 EGLint majorVersion;
1259 EGLint minorVersion;
1260 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1261 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1262 ASSERT_EQ(ret, EGL_TRUE);
1263
1264 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1265 ASSERT_EQ(EGL_FALSE, result);
1266 }
1267
1268 /**
1269 * @tc.name: EglCreatePlatformWindowSurfaceImpl001
1270 * @tc.desc:
1271 * @tc.type: FUNC
1272 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl001,Level1)1273 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl001, Level1)
1274 {
1275 EGLDisplay dpy = nullptr;
1276 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1277 ASSERT_EQ(EGL_NO_SURFACE, result);
1278 }
1279
1280 /**
1281 * @tc.name: EglCreatePlatformWindowSurfaceImpl002
1282 * @tc.desc:
1283 * @tc.type: FUNC
1284 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl002,Level2)1285 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl002, Level2)
1286 {
1287 EGLint majorVersion;
1288 EGLint minorVersion;
1289 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1290 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1291 ASSERT_EQ(ret, EGL_TRUE);
1292
1293 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1294 ASSERT_EQ(EGL_NO_SURFACE, result);
1295 }
1296
1297 /**
1298 * @tc.name: EglCreatePlatformPixmapSurfaceImpl001
1299 * @tc.desc:
1300 * @tc.type: FUNC
1301 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl001,Level1)1302 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl001, Level1)
1303 {
1304 EGLDisplay dpy = nullptr;
1305 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1306 ASSERT_EQ(EGL_NO_SURFACE, result);
1307 }
1308
1309 /**
1310 * @tc.name: EglCreatePlatformPixmapSurfaceImpl002
1311 * @tc.desc:
1312 * @tc.type: FUNC
1313 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl002,Level2)1314 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl002, Level2)
1315 {
1316 EGLint majorVersion;
1317 EGLint minorVersion;
1318 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1319 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1320 ASSERT_EQ(ret, EGL_TRUE);
1321
1322 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1323 ASSERT_EQ(EGL_NO_SURFACE, result);
1324 }
1325
1326 /**
1327 * @tc.name: EglWaitSyncImpl001
1328 * @tc.desc:
1329 * @tc.type: FUNC
1330 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl001,Level1)1331 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl001, Level1)
1332 {
1333 EGLDisplay dpy = nullptr;
1334 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1335 ASSERT_EQ(EGL_FALSE, result);
1336 }
1337
1338 /**
1339 * @tc.name: EglWaitSyncImpl002
1340 * @tc.desc:
1341 * @tc.type: FUNC
1342 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl002,Level2)1343 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl002, Level2)
1344 {
1345 EGLint majorVersion;
1346 EGLint minorVersion;
1347 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1348 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1349 ASSERT_EQ(ret, EGL_TRUE);
1350
1351 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1352 ASSERT_EQ(EGL_FALSE, result);
1353 }
1354
1355 /**
1356 * @tc.name: EglLockSurfaceKHRImpl001
1357 * @tc.desc:
1358 * @tc.type: FUNC
1359 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl001,Level1)1360 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl001, Level1)
1361 {
1362 EGLDisplay dpy = nullptr;
1363 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1364 ASSERT_EQ(EGL_FALSE, result);
1365 }
1366
1367 /**
1368 * @tc.name: EglLockSurfaceKHRImpl002
1369 * @tc.desc:
1370 * @tc.type: FUNC
1371 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl002,Level2)1372 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl002, Level2)
1373 {
1374 EGLint majorVersion;
1375 EGLint minorVersion;
1376 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1377 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1378 ASSERT_EQ(ret, EGL_TRUE);
1379
1380 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1381 ASSERT_EQ(EGL_FALSE, result);
1382 }
1383
1384 /**
1385 * @tc.name: EglUnlockSurfaceKHRImpl001
1386 * @tc.desc:
1387 * @tc.type: FUNC
1388 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl001,Level1)1389 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl001, Level1)
1390 {
1391 EGLint majorVersion;
1392 EGLint minorVersion;
1393 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1394 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1395 ASSERT_EQ(ret, EGL_TRUE);
1396
1397 auto result = gWrapperHook.wrapper.eglUnlockSurfaceKHR(dpy, nullptr);
1398 ASSERT_EQ(EGL_FALSE, result);
1399 }
1400
1401 /**
1402 * @tc.name: EglUnlockSurfaceKHRImpl002
1403 * @tc.desc:
1404 * @tc.type: FUNC
1405 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl002,Level2)1406 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl002, Level2)
1407 {
1408 EGLint majorVersion;
1409 EGLint minorVersion;
1410 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1411 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1412 ASSERT_EQ(ret, EGL_TRUE);
1413
1414 auto result = gWrapperHook.wrapper.eglUnlockSurfaceKHR(dpy, nullptr);
1415 ASSERT_EQ(EGL_FALSE, result);
1416 }
1417
1418 /**
1419 * @tc.name: EglCreateImageKHRImpl001
1420 * @tc.desc:
1421 * @tc.type: FUNC
1422 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl001,Level1)1423 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl001, Level1)
1424 {
1425 EGLDisplay dpy = nullptr;
1426 auto result = gWrapperHook.wrapper.eglCreateImageKHR(dpy, 0, 0, nullptr, nullptr);
1427 ASSERT_EQ(EGL_NO_IMAGE_KHR, result);
1428 }
1429
1430 /**
1431 * @tc.name: EglCreateImageKHRImpl002
1432 * @tc.desc:
1433 * @tc.type: FUNC
1434 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl002,Level2)1435 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl002, Level2)
1436 {
1437 EGLint majorVersion;
1438 EGLint minorVersion;
1439 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1440 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1441 ASSERT_EQ(ret, EGL_TRUE);
1442
1443 auto result = gWrapperHook.wrapper.eglCreateImageKHR(dpy, 0, 0, nullptr, nullptr);
1444 ASSERT_EQ(EGL_NO_IMAGE_KHR, result);
1445 }
1446
1447 /**
1448 * @tc.name: EglDestroyImageKHRImpl001
1449 * @tc.desc:
1450 * @tc.type: FUNC
1451 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl001,Level1)1452 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl001, Level1)
1453 {
1454 EGLDisplay dpy = nullptr;
1455 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1456 ASSERT_EQ(EGL_FALSE, result);
1457 }
1458
1459 /**
1460 * @tc.name: EglDestroyImageKHRImpl002
1461 * @tc.desc:
1462 * @tc.type: FUNC
1463 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl002,Level2)1464 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl002, Level2)
1465 {
1466 EGLint majorVersion;
1467 EGLint minorVersion;
1468 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1469 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1470 ASSERT_EQ(ret, EGL_TRUE);
1471
1472 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1473 ASSERT_EQ(EGL_FALSE, result);
1474 }
1475
1476 /**
1477 * @tc.name: EglCreateSyncKHRImpl001
1478 * @tc.desc:
1479 * @tc.type: FUNC
1480 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl001,Level1)1481 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl001, Level1)
1482 {
1483 EGLDisplay dpy = nullptr;
1484 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1485 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1486 }
1487
1488 /**
1489 * @tc.name: EglCreateSyncKHRImpl002
1490 * @tc.desc:
1491 * @tc.type: FUNC
1492 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl002,Level2)1493 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl002, Level2)
1494 {
1495 EGLint majorVersion;
1496 EGLint minorVersion;
1497 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1498 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1499 ASSERT_EQ(ret, EGL_TRUE);
1500
1501 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1502 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1503 }
1504
1505 /**
1506 * @tc.name: EglDestroySyncKHRImpl001
1507 * @tc.desc:
1508 * @tc.type: FUNC
1509 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl001,Level1)1510 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl001, Level1)
1511 {
1512 EGLDisplay dpy = nullptr;
1513 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1514 ASSERT_EQ(EGL_FALSE, result);
1515 }
1516
1517 /**
1518 * @tc.name: EglDestroySyncKHRImpl002
1519 * @tc.desc:
1520 * @tc.type: FUNC
1521 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl002,Level2)1522 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl002, Level2)
1523 {
1524 EGLint majorVersion;
1525 EGLint minorVersion;
1526 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1527 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1528 ASSERT_EQ(ret, EGL_TRUE);
1529
1530 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1531 ASSERT_EQ(EGL_FALSE, result);
1532 }
1533
1534 /**
1535 * @tc.name: EglClientWaitSyncKHRImpl001
1536 * @tc.desc:
1537 * @tc.type: FUNC
1538 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl001,Level1)1539 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl001, Level1)
1540 {
1541 EGLDisplay dpy = nullptr;
1542 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1543 ASSERT_EQ(EGL_FALSE, result);
1544 }
1545
1546 /**
1547 * @tc.name: EglClientWaitSyncKHRImpl002
1548 * @tc.desc:
1549 * @tc.type: FUNC
1550 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl002,Level2)1551 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl002, Level2)
1552 {
1553 EGLint majorVersion;
1554 EGLint minorVersion;
1555 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1556 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1557 ASSERT_EQ(ret, EGL_TRUE);
1558
1559 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1560 ASSERT_EQ(EGL_FALSE, result);
1561 }
1562
1563 /**
1564 * @tc.name: EglGetSyncAttribKHRImpl001
1565 * @tc.desc:
1566 * @tc.type: FUNC
1567 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl001,Level1)1568 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl001, Level1)
1569 {
1570 EGLDisplay dpy = nullptr;
1571 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1572 ASSERT_EQ(EGL_FALSE, result);
1573 }
1574
1575 /**
1576 * @tc.name: EglGetSyncAttribKHRImpl002
1577 * @tc.desc:
1578 * @tc.type: FUNC
1579 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl002,Level2)1580 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl002, Level2)
1581 {
1582 EGLint majorVersion;
1583 EGLint minorVersion;
1584 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1585 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1586 ASSERT_EQ(ret, EGL_TRUE);
1587
1588 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1589 ASSERT_EQ(EGL_FALSE, result);
1590 }
1591
1592 /**
1593 * @tc.name: EglGetSyncAttribKHRImpl003
1594 * @tc.desc:
1595 * @tc.type: FUNC
1596 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl003,Level2)1597 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl003, Level2)
1598 {
1599 EGLint majorVersion;
1600 EGLint minorVersion;
1601 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1602 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1603 ASSERT_EQ(ret, EGL_TRUE);
1604 EGLint value = 1;
1605
1606 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, &value);
1607 ASSERT_EQ(EGL_FALSE, result);
1608 }
1609
1610 /**
1611 * @tc.name: EglSignalSyncKHRImpl001
1612 * @tc.desc:
1613 * @tc.type: FUNC
1614 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl001,Level1)1615 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl001, Level1)
1616 {
1617 EGLDisplay dpy = nullptr;
1618 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1619 ASSERT_EQ(EGL_FALSE, result);
1620 }
1621
1622 /**
1623 * @tc.name: EglSignalSyncKHRImpl002
1624 * @tc.desc:
1625 * @tc.type: FUNC
1626 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl002,Level2)1627 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl002, Level2)
1628 {
1629 EGLint majorVersion;
1630 EGLint minorVersion;
1631 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1632 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1633 ASSERT_EQ(ret, EGL_TRUE);
1634
1635 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1636 ASSERT_EQ(EGL_FALSE, result);
1637 }
1638
1639 /**
1640 * @tc.name: EglCreateStreamKHRImpl001
1641 * @tc.desc:
1642 * @tc.type: FUNC
1643 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl001,Level1)1644 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl001, Level1)
1645 {
1646 EGLDisplay dpy = nullptr;
1647 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1648 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1649 }
1650
1651 /**
1652 * @tc.name: EglCreateStreamKHRImpl002
1653 * @tc.desc:
1654 * @tc.type: FUNC
1655 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl002,Level2)1656 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl002, Level2)
1657 {
1658 EGLint majorVersion;
1659 EGLint minorVersion;
1660 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1661 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1662 ASSERT_EQ(ret, EGL_TRUE);
1663
1664 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1665 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1666 }
1667
1668
1669 /**
1670 * @tc.name: EglDestroyStreamKHRImpl001
1671 * @tc.desc:
1672 * @tc.type: FUNC
1673 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl001,Level1)1674 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl001, Level1)
1675 {
1676 EGLint majorVersion;
1677 EGLint minorVersion;
1678 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1679 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1680 ASSERT_EQ(ret, EGL_TRUE);
1681
1682 auto result = gWrapperHook.wrapper.eglDestroyStreamKHR(dpy, nullptr);
1683 ASSERT_EQ(EGL_FALSE, result);
1684 }
1685
1686 /**
1687 * @tc.name: EglDestroyStreamKHRImpl002
1688 * @tc.desc:
1689 * @tc.type: FUNC
1690 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl002,Level2)1691 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl002, Level2)
1692 {
1693 EGLint majorVersion;
1694 EGLint minorVersion;
1695 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1696 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1697 ASSERT_EQ(ret, EGL_TRUE);
1698
1699 auto result = gWrapperHook.wrapper.eglDestroyStreamKHR(dpy, nullptr);
1700 ASSERT_EQ(EGL_FALSE, result);
1701 }
1702
1703 /**
1704 * @tc.name: EglStreamAttribKHRImpl001
1705 * @tc.desc:
1706 * @tc.type: FUNC
1707 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl001,Level1)1708 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl001, Level1)
1709 {
1710 EGLDisplay dpy = nullptr;
1711 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1712 ASSERT_EQ(EGL_FALSE, result);
1713 }
1714
1715 /**
1716 * @tc.name: EglStreamAttribKHRImpl002
1717 * @tc.desc:
1718 * @tc.type: FUNC
1719 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl002,Level2)1720 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl002, Level2)
1721 {
1722 EGLint majorVersion;
1723 EGLint minorVersion;
1724 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1725 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1726 ASSERT_EQ(ret, EGL_TRUE);
1727
1728 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1729 ASSERT_EQ(EGL_FALSE, result);
1730 }
1731
1732 /**
1733 * @tc.name: EglQueryStreamKHRImpl001
1734 * @tc.desc:
1735 * @tc.type: FUNC
1736 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl001,Level1)1737 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl001, Level1)
1738 {
1739 EGLDisplay dpy = nullptr;
1740 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1741 ASSERT_EQ(EGL_FALSE, result);
1742 }
1743
1744 /**
1745 * @tc.name: EglQueryStreamKHRImpl002
1746 * @tc.desc:
1747 * @tc.type: FUNC
1748 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl002,Level2)1749 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl002, Level2)
1750 {
1751 EGLint majorVersion;
1752 EGLint minorVersion;
1753 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1754 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1755 ASSERT_EQ(ret, EGL_TRUE);
1756
1757 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1758 ASSERT_EQ(EGL_FALSE, result);
1759 }
1760
1761 /**
1762 * @tc.name: EglQueryStreamKHRImpl003
1763 * @tc.desc:
1764 * @tc.type: FUNC
1765 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl003,Level2)1766 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl003, Level2)
1767 {
1768 EGLint majorVersion;
1769 EGLint minorVersion;
1770 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1771 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1772 ASSERT_EQ(ret, EGL_TRUE);
1773 EGLint value = 1;
1774
1775 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, &value);
1776 ASSERT_EQ(EGL_FALSE, result);
1777 }
1778
1779 /**
1780 * @tc.name: EglQueryStreamu64KHRImpl001
1781 * @tc.desc:
1782 * @tc.type: FUNC
1783 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl001,Level1)1784 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl001, Level1)
1785 {
1786 EGLDisplay dpy = nullptr;
1787 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1788 ASSERT_EQ(EGL_FALSE, result);
1789 }
1790
1791 /**
1792 * @tc.name: EglQueryStreamu64KHRImpl002
1793 * @tc.desc:
1794 * @tc.type: FUNC
1795 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl002,Level2)1796 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl002, Level2)
1797 {
1798 EGLint majorVersion;
1799 EGLint minorVersion;
1800 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1801 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1802 ASSERT_EQ(ret, EGL_TRUE);
1803
1804 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1805 ASSERT_EQ(EGL_FALSE, result);
1806 }
1807
1808 /**
1809 * @tc.name: EglQueryStreamu64KHRImpl003
1810 * @tc.desc:
1811 * @tc.type: FUNC
1812 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl003,Level2)1813 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl003, Level2)
1814 {
1815 EGLint majorVersion;
1816 EGLint minorVersion;
1817 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1818 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1819 ASSERT_EQ(ret, EGL_TRUE);
1820 EGLuint64KHR value = 1;
1821
1822 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, &value);
1823 ASSERT_EQ(EGL_FALSE, result);
1824 }
1825
1826 /**
1827 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl001
1828 * @tc.desc:
1829 * @tc.type: FUNC
1830 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl001,Level1)1831 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl001, Level1)
1832 {
1833 EGLDisplay dpy = nullptr;
1834 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1835 ASSERT_EQ(EGL_FALSE, result);
1836 }
1837
1838 /**
1839 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl002
1840 * @tc.desc:
1841 * @tc.type: FUNC
1842 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl002,Level2)1843 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl002, Level2)
1844 {
1845 EGLint majorVersion;
1846 EGLint minorVersion;
1847 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1848 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1849 ASSERT_EQ(ret, EGL_TRUE);
1850
1851 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1852 ASSERT_EQ(EGL_FALSE, result);
1853 }
1854
1855 /**
1856 * @tc.name: EglStreamConsumerAcquireKHRImpl001
1857 * @tc.desc:
1858 * @tc.type: FUNC
1859 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl001,Level1)1860 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl001, Level1)
1861 {
1862 EGLDisplay dpy = nullptr;
1863 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1864 ASSERT_EQ(EGL_FALSE, result);
1865 }
1866
1867 /**
1868 * @tc.name: EglStreamConsumerAcquireKHRImpl002
1869 * @tc.desc:
1870 * @tc.type: FUNC
1871 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl002,Level2)1872 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl002, Level2)
1873 {
1874 EGLint majorVersion;
1875 EGLint minorVersion;
1876 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1877 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1878 ASSERT_EQ(ret, EGL_TRUE);
1879
1880 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1881 ASSERT_EQ(EGL_FALSE, result);
1882 }
1883
1884 /**
1885 * @tc.name: EglStreamConsumerReleaseKHRImpl001
1886 * @tc.desc:
1887 * @tc.type: FUNC
1888 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl001,Level1)1889 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl001, Level1)
1890 {
1891 EGLDisplay dpy = nullptr;
1892 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1893 ASSERT_EQ(EGL_FALSE, result);
1894 }
1895
1896 /**
1897 * @tc.name: EglStreamConsumerReleaseKHRImpl002
1898 * @tc.desc:
1899 * @tc.type: FUNC
1900 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl002,Level2)1901 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl002, Level2)
1902 {
1903 EGLint majorVersion;
1904 EGLint minorVersion;
1905 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1906 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1907 ASSERT_EQ(ret, EGL_TRUE);
1908
1909 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1910 ASSERT_EQ(EGL_FALSE, result);
1911 }
1912
1913 /**
1914 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl001
1915 * @tc.desc:
1916 * @tc.type: FUNC
1917 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl001,Level1)1918 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl001, Level1)
1919 {
1920 EGLDisplay dpy = nullptr;
1921 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1922 ASSERT_EQ(EGL_NO_SURFACE, result);
1923 }
1924
1925 /**
1926 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl002
1927 * @tc.desc:
1928 * @tc.type: FUNC
1929 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl002,Level2)1930 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl002, Level2)
1931 {
1932 EGLint majorVersion;
1933 EGLint minorVersion;
1934 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1935 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1936 ASSERT_EQ(ret, EGL_TRUE);
1937
1938 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1939 ASSERT_EQ(EGL_NO_SURFACE, result);
1940 }
1941
1942 /**
1943 * @tc.name: EglQueryStreamTimeKHRImpl001
1944 * @tc.desc:
1945 * @tc.type: FUNC
1946 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl001,Level1)1947 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl001, Level1)
1948 {
1949 EGLDisplay dpy = nullptr;
1950 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1951 ASSERT_EQ(EGL_FALSE, result);
1952 }
1953
1954 /**
1955 * @tc.name: EglQueryStreamTimeKHRImpl002
1956 * @tc.desc:
1957 * @tc.type: FUNC
1958 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl002,Level2)1959 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl002, Level2)
1960 {
1961 EGLint majorVersion;
1962 EGLint minorVersion;
1963 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1964 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1965 ASSERT_EQ(ret, EGL_TRUE);
1966
1967 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1968 ASSERT_EQ(EGL_FALSE, result);
1969 }
1970
1971 /**
1972 * @tc.name: EglQueryStreamTimeKHRImpl003
1973 * @tc.desc:
1974 * @tc.type: FUNC
1975 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl003,Level2)1976 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl003, Level2)
1977 {
1978 EGLint majorVersion;
1979 EGLint minorVersion;
1980 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1981 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1982 ASSERT_EQ(ret, EGL_TRUE);
1983 EGLTimeKHR value = 1;
1984
1985 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, &value);
1986 ASSERT_EQ(EGL_FALSE, result);
1987 }
1988
1989 /**
1990 * @tc.name: EglGetStreamFileDescriptorKHRImpl001
1991 * @tc.desc:
1992 * @tc.type: FUNC
1993 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl001,Level1)1994 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl001, Level1)
1995 {
1996 EGLDisplay dpy = nullptr;
1997 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
1998 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
1999 }
2000
2001 /**
2002 * @tc.name: EglGetStreamFileDescriptorKHRImpl002
2003 * @tc.desc:
2004 * @tc.type: FUNC
2005 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl002,Level2)2006 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl002, Level2)
2007 {
2008 EGLint majorVersion;
2009 EGLint minorVersion;
2010 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2011 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2012 ASSERT_EQ(ret, EGL_TRUE);
2013
2014 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
2015 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
2016 }
2017
2018
2019 /**
2020 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl001
2021 * @tc.desc:
2022 * @tc.type: FUNC
2023 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl001,Level1)2024 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl001, Level1)
2025 {
2026 EGLDisplay dpy = nullptr;
2027 auto result = gWrapperHook.wrapper.eglCreateStreamFromFileDescriptorKHR(dpy, EGL_NO_FILE_DESCRIPTOR_KHR);
2028 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
2029 }
2030
2031 /**
2032 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl002
2033 * @tc.desc:
2034 * @tc.type: FUNC
2035 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl002,Level2)2036 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl002, Level2)
2037 {
2038 EGLint majorVersion;
2039 EGLint minorVersion;
2040 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2041 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2042 ASSERT_EQ(ret, EGL_TRUE);
2043
2044 auto result = gWrapperHook.wrapper.eglCreateStreamFromFileDescriptorKHR(dpy, EGL_NO_FILE_DESCRIPTOR_KHR);
2045 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
2046 }
2047
2048 /**
2049 * @tc.name: EglWaitSyncKHRImpl001
2050 * @tc.desc:
2051 * @tc.type: FUNC
2052 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl001,Level1)2053 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl001, Level1)
2054 {
2055 EGLDisplay dpy = nullptr;
2056 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2057 ASSERT_EQ(EGL_FALSE, result);
2058 }
2059
2060 /**
2061 * @tc.name: EglWaitSyncKHRImpl002
2062 * @tc.desc:
2063 * @tc.type: FUNC
2064 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl002,Level2)2065 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl002, Level2)
2066 {
2067 EGLint majorVersion;
2068 EGLint minorVersion;
2069 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2070 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2071 ASSERT_EQ(ret, EGL_TRUE);
2072
2073 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2074 ASSERT_EQ(EGL_FALSE, result);
2075 }
2076
2077 /**
2078 * @tc.name: EglGetPlatformDisplayEXTImpl001
2079 * @tc.desc:
2080 * @tc.type: FUNC
2081 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl001,Level1)2082 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl001, Level1)
2083 {
2084 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGLNativeDisplayType(1), nullptr);
2085 ASSERT_EQ(EGL_NO_DISPLAY, result);
2086 }
2087
2088 /**
2089 * @tc.name: EglGetPlatformDisplayEXTImpl002
2090 * @tc.desc:
2091 * @tc.type: FUNC
2092 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl002,Level2)2093 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl002, Level2)
2094 {
2095 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGL_DEFAULT_DISPLAY, nullptr);
2096 ASSERT_EQ(EGL_NO_DISPLAY, result);
2097 }
2098
2099 /**
2100 * @tc.name: EglSwapBuffersWithDamageKHRImpl001
2101 * @tc.desc:
2102 * @tc.type: FUNC
2103 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl001,Level1)2104 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl001, Level1)
2105 {
2106 EGLDisplay dpy = nullptr;
2107 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2108 ASSERT_EQ(EGL_FALSE, result);
2109 }
2110
2111 /**
2112 * @tc.name: EglSwapBuffersWithDamageKHRImpl002
2113 * @tc.desc:
2114 * @tc.type: FUNC
2115 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl002,Level2)2116 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl002, Level2)
2117 {
2118 EGLint majorVersion;
2119 EGLint minorVersion;
2120 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2121 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2122 ASSERT_EQ(ret, EGL_TRUE);
2123
2124 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2125 ASSERT_EQ(EGL_FALSE, result);
2126 }
2127
2128 /**
2129 * @tc.name: EglSetDamageRegionKHRImpl001
2130 * @tc.desc:
2131 * @tc.type: FUNC
2132 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl001,Level1)2133 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl001, Level1)
2134 {
2135 EGLDisplay dpy = nullptr;
2136 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2137 ASSERT_EQ(EGL_FALSE, result);
2138 }
2139
2140 /**
2141 * @tc.name: EglSetDamageRegionKHRImpl002
2142 * @tc.desc:
2143 * @tc.type: FUNC
2144 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl002,Level2)2145 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl002, Level2)
2146 {
2147 EGLint majorVersion;
2148 EGLint minorVersion;
2149 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2150 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2151 ASSERT_EQ(ret, EGL_TRUE);
2152
2153 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2154 ASSERT_EQ(EGL_FALSE, result);
2155 }
2156
2157 /**
2158 * @tc.name: EglGetCompositorTimingSupportedANDROIDImpl001
2159 * @tc.desc:
2160 * @tc.type: FUNC
2161 */
HWTEST_F(EglWrapperEntryTest,EglGetCompositorTimingSupportedANDROIDImpl001,Level1)2162 HWTEST_F(EglWrapperEntryTest, EglGetCompositorTimingSupportedANDROIDImpl001, Level1)
2163 {
2164 EGLDisplay dpy = nullptr;
2165 auto result = gWrapperHook.wrapper.eglGetCompositorTimingSupportedANDROID(dpy, nullptr, 0);
2166 ASSERT_EQ(EGL_FALSE, result);
2167 }
2168
2169 /**
2170 * @tc.name: EglGetCompositorTimingSupportedANDROIDImpl002
2171 * @tc.desc:
2172 * @tc.type: FUNC
2173 */
HWTEST_F(EglWrapperEntryTest,EglGetCompositorTimingSupportedANDROIDImpl002,Level2)2174 HWTEST_F(EglWrapperEntryTest, EglGetCompositorTimingSupportedANDROIDImpl002, Level2)
2175 {
2176 EGLint majorVersion;
2177 EGLint minorVersion;
2178 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2179 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2180 ASSERT_EQ(ret, EGL_TRUE);
2181
2182 auto result = gWrapperHook.wrapper.eglGetCompositorTimingSupportedANDROID(dpy, nullptr, 0x3431);
2183 ASSERT_EQ(EGL_FALSE, result);
2184 }
2185
2186 /**
2187 * @tc.name: EglGetFrameTimestampSupportedANDROIDImpl001
2188 * @tc.desc:
2189 * @tc.type: FUNC
2190 */
HWTEST_F(EglWrapperEntryTest,EglGetFrameTimestampSupportedANDROIDImpl001,Level1)2191 HWTEST_F(EglWrapperEntryTest, EglGetFrameTimestampSupportedANDROIDImpl001, Level1)
2192 {
2193 EGLDisplay dpy = nullptr;
2194 EGLint timestamp = 1;
2195 auto result = gWrapperHook.wrapper.eglGetFrameTimestampSupportedANDROID(dpy, nullptr, timestamp);
2196 ASSERT_EQ(EGL_FALSE, result);
2197 }
2198
2199 /**
2200 * @tc.name: EglGetFrameTimestampSupportedANDROIDImpl002
2201 * @tc.desc:
2202 * @tc.type: FUNC
2203 */
HWTEST_F(EglWrapperEntryTest,EglGetFrameTimestampSupportedANDROIDImpl002,Level2)2204 HWTEST_F(EglWrapperEntryTest, EglGetFrameTimestampSupportedANDROIDImpl002, Level2)
2205 {
2206 EGLint majorVersion;
2207 EGLint minorVersion;
2208 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2209 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2210 ASSERT_EQ(ret, EGL_TRUE);
2211
2212 EGLint timestamp = 1;
2213 auto result = gWrapperHook.wrapper.eglGetFrameTimestampSupportedANDROID(dpy, nullptr, timestamp);
2214 ASSERT_EQ(EGL_FALSE, result);
2215 }
2216
2217 /**
2218 * @tc.name: EglPresentationTimeANDROIDImpl001
2219 * @tc.desc:
2220 * @tc.type: FUNC
2221 */
HWTEST_F(EglWrapperEntryTest,EglPresentationTimeANDROIDImpl001,Level1)2222 HWTEST_F(EglWrapperEntryTest, EglPresentationTimeANDROIDImpl001, Level1)
2223 {
2224 EGLDisplay dpy = nullptr;
2225 EGLnsecsANDROID time = 1;
2226 auto result = gWrapperHook.wrapper.eglPresentationTimeANDROID(dpy, nullptr, time);
2227 ASSERT_EQ(EGL_FALSE, result);
2228 }
2229
2230 /**
2231 * @tc.name: EglPresentationTimeANDROIDImpl002
2232 * @tc.desc:
2233 * @tc.type: FUNC
2234 */
HWTEST_F(EglWrapperEntryTest,EglPresentationTimeANDROIDImpl002,Level2)2235 HWTEST_F(EglWrapperEntryTest, EglPresentationTimeANDROIDImpl002, Level2)
2236 {
2237 EGLint majorVersion;
2238 EGLint minorVersion;
2239 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2240 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2241 ASSERT_EQ(ret, EGL_TRUE);
2242
2243 EGLnsecsANDROID time = 1;
2244 auto result = gWrapperHook.wrapper.eglPresentationTimeANDROID(dpy, nullptr, time);
2245 ASSERT_EQ(EGL_FALSE, result);
2246 }
2247
2248 /**
2249 * @tc.name: EglCreatePlatformWindowSurfaceEXTImpl001
2250 * @tc.desc:
2251 * @tc.type: FUNC
2252 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceEXTImpl001,Level1)2253 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceEXTImpl001, Level1)
2254 {
2255 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurfaceEXT(nullptr, nullptr, nullptr, nullptr);
2256 ASSERT_EQ(EGL_FALSE, result);
2257 }
2258
2259 /**
2260 * @tc.name: EglCreatePlatformWindowSurfaceEXTImpl002
2261 * @tc.desc:
2262 * @tc.type: FUNC
2263 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceEXTImpl002,Level2)2264 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceEXTImpl002, Level2)
2265 {
2266 EGLint majorVersion;
2267 EGLint minorVersion;
2268 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2269 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2270 ASSERT_EQ(ret, EGL_TRUE);
2271
2272 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurfaceEXT(dpy, nullptr, nullptr, nullptr);
2273 ASSERT_EQ(EGL_FALSE, result);
2274 }
2275
2276 /**
2277 * @tc.name: EglCreatePlatformPixmapSurfaceEXTImpl001
2278 * @tc.desc:
2279 * @tc.type: FUNC
2280 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceEXTImpl001,Level1)2281 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceEXTImpl001, Level1)
2282 {
2283 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurfaceEXT(nullptr, nullptr, nullptr, nullptr);
2284 ASSERT_EQ(EGL_FALSE, result);
2285 }
2286
2287 /**
2288 * @tc.name: EglCreatePlatformPixmapSurfaceEXTImpl002
2289 * @tc.desc:
2290 * @tc.type: FUNC
2291 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceEXTImpl002,Level2)2292 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceEXTImpl002, Level2)
2293 {
2294 EGLint majorVersion;
2295 EGLint minorVersion;
2296 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2297 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2298 ASSERT_EQ(ret, EGL_TRUE);
2299
2300 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurfaceEXT(dpy, nullptr, nullptr, nullptr);
2301 ASSERT_EQ(EGL_FALSE, result);
2302 }
2303
2304 /**
2305 * @tc.name: EglSwapBuffersWithDamageEXTImpl001
2306 * @tc.desc:
2307 * @tc.type: FUNC
2308 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageEXTImpl001,Level1)2309 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageEXTImpl001, Level1)
2310 {
2311 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageEXT(nullptr, nullptr, nullptr, 1);
2312 ASSERT_EQ(EGL_FALSE, result);
2313 }
2314
2315 /**
2316 * @tc.name: EglSwapBuffersWithDamageEXTImpl002
2317 * @tc.desc:
2318 * @tc.type: FUNC
2319 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageEXTImpl002,Level2)2320 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageEXTImpl002, Level2)
2321 {
2322 EGLint majorVersion;
2323 EGLint minorVersion;
2324 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2325 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2326 ASSERT_EQ(ret, EGL_TRUE);
2327
2328 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageEXT(dpy, nullptr, nullptr, 1);
2329 ASSERT_EQ(EGL_FALSE, result);
2330 }
2331
2332 /**
2333 * @tc.name: EglGetNativeClientBufferANDROIDImpl001
2334 * @tc.desc:
2335 * @tc.type: FUNC
2336 */
HWTEST_F(EglWrapperEntryTest,EglGetNativeClientBufferANDROIDImpl001,Level1)2337 HWTEST_F(EglWrapperEntryTest, EglGetNativeClientBufferANDROIDImpl001, Level1)
2338 {
2339 auto result = gWrapperHook.wrapper.eglGetNativeClientBufferANDROID(nullptr);
2340 ASSERT_EQ(EGL_FALSE, result);
2341 }
2342 } // OHOS::Rosen