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: EglTerminateImpl001
714 * @tc.desc:
715 * @tc.type: FUNC
716 */
HWTEST_F(EglWrapperEntryTest,EglTerminateImpl001,Level1)717 HWTEST_F(EglWrapperEntryTest, EglTerminateImpl001, Level1)
718 {
719 EGLDisplay dpy = nullptr;
720 auto result = gWrapperHook.wrapper.eglTerminate(dpy);
721 ASSERT_EQ(EGL_FALSE, result);
722 }
723
724 /**
725 * @tc.name: EglTerminateImpl002
726 * @tc.desc:
727 * @tc.type: FUNC
728 */
HWTEST_F(EglWrapperEntryTest,EglTerminateImpl002,Level2)729 HWTEST_F(EglWrapperEntryTest, EglTerminateImpl002, Level2)
730 {
731 EGLint majorVersion;
732 EGLint minorVersion;
733 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
734 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
735 ASSERT_EQ(ret, EGL_TRUE);
736
737 auto result = gWrapperHook.wrapper.eglTerminate(dpy);
738 ASSERT_NE(EGL_FALSE, result);
739 }
740
741 /**
742 * @tc.name: EglWaitGLImpl001
743 * @tc.desc:
744 * @tc.type: FUNC
745 */
HWTEST_F(EglWrapperEntryTest,EglWaitGLImpl001,Level1)746 HWTEST_F(EglWrapperEntryTest, EglWaitGLImpl001, Level1)
747 {
748 auto temp = gWrapperHook.isLoad;
749 gWrapperHook.isLoad = false;
750 auto result = gWrapperHook.wrapper.eglWaitGL();
751 ASSERT_EQ(EGL_FALSE, result);
752 gWrapperHook.isLoad = temp;
753 }
754
755
756 /**
757 * @tc.name: EglWaitGLImpl002
758 * @tc.desc:
759 * @tc.type: FUNC
760 */
HWTEST_F(EglWrapperEntryTest,EglWaitGLImpl002,Level2)761 HWTEST_F(EglWrapperEntryTest, EglWaitGLImpl002, Level2)
762 {
763 auto temp = gWrapperHook.isLoad;
764 gWrapperHook.isLoad = true;
765 auto result = gWrapperHook.wrapper.eglWaitGL();
766 ASSERT_NE(EGL_FALSE, result);
767 gWrapperHook.isLoad = temp;
768 }
769
770
771 /**
772 * @tc.name: EglWaitNativeImpl001
773 * @tc.desc:
774 * @tc.type: FUNC
775 */
HWTEST_F(EglWrapperEntryTest,EglWaitNativeImpl001,Level1)776 HWTEST_F(EglWrapperEntryTest, EglWaitNativeImpl001, Level1)
777 {
778 auto temp = gWrapperHook.isLoad;
779 gWrapperHook.isLoad = false;
780 auto result = gWrapperHook.wrapper.eglWaitNative(1);
781 ASSERT_EQ(EGL_FALSE, result);
782 gWrapperHook.isLoad = temp;
783 }
784
785 /**
786 * @tc.name: EglWaitNativeImpl002
787 * @tc.desc:
788 * @tc.type: FUNC
789 */
HWTEST_F(EglWrapperEntryTest,EglWaitNativeImpl002,Level2)790 HWTEST_F(EglWrapperEntryTest, EglWaitNativeImpl002, Level2)
791 {
792 auto temp = gWrapperHook.isLoad;
793 gWrapperHook.isLoad = true;
794 auto result = gWrapperHook.wrapper.eglWaitNative(1);
795 ASSERT_NE(EGL_FALSE, result);
796 gWrapperHook.isLoad = temp;
797 }
798
799 /**
800 * @tc.name: EglBindTexImageImpl001
801 * @tc.desc:
802 * @tc.type: FUNC
803 */
HWTEST_F(EglWrapperEntryTest,EglBindTexImageImpl001,Level1)804 HWTEST_F(EglWrapperEntryTest, EglBindTexImageImpl001, Level1)
805 {
806 EGLDisplay dpy = nullptr;
807 auto result = gWrapperHook.wrapper.eglBindTexImage(dpy, nullptr, 0);
808 ASSERT_EQ(EGL_FALSE, result);
809 }
810
811 /**
812 * @tc.name: EglBindTexImageImpl002
813 * @tc.desc:
814 * @tc.type: FUNC
815 */
HWTEST_F(EglWrapperEntryTest,EglBindTexImageImpl002,Level2)816 HWTEST_F(EglWrapperEntryTest, EglBindTexImageImpl002, Level2)
817 {
818 EGLint majorVersion;
819 EGLint minorVersion;
820 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
821 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
822 ASSERT_EQ(ret, EGL_TRUE);
823
824 auto result = gWrapperHook.wrapper.eglBindTexImage(dpy, nullptr, 0);
825 ASSERT_EQ(EGL_FALSE, result);
826 }
827
828 /**
829 * @tc.name: EglReleaseTexImageImpl001
830 * @tc.desc:
831 * @tc.type: FUNC
832 */
HWTEST_F(EglWrapperEntryTest,EglReleaseTexImageImpl001,Level1)833 HWTEST_F(EglWrapperEntryTest, EglReleaseTexImageImpl001, Level1)
834 {
835 EGLDisplay dpy = nullptr;
836 auto result = gWrapperHook.wrapper.eglReleaseTexImage(dpy, nullptr, 0);
837 ASSERT_EQ(EGL_FALSE, result);
838 }
839
840 /**
841 * @tc.name: EglReleaseTexImageImpl002
842 * @tc.desc:
843 * @tc.type: FUNC
844 */
HWTEST_F(EglWrapperEntryTest,EglReleaseTexImageImpl002,Level2)845 HWTEST_F(EglWrapperEntryTest, EglReleaseTexImageImpl002, Level2)
846 {
847 EGLint majorVersion;
848 EGLint minorVersion;
849 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
850 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
851 ASSERT_EQ(ret, EGL_TRUE);
852
853 auto result = gWrapperHook.wrapper.eglReleaseTexImage(dpy, nullptr, 0);
854 ASSERT_EQ(EGL_FALSE, result);
855 }
856
857 /**
858 * @tc.name: EglSurfaceAttribImpl001
859 * @tc.desc:
860 * @tc.type: FUNC
861 */
HWTEST_F(EglWrapperEntryTest,EglSurfaceAttribImpl001,Level1)862 HWTEST_F(EglWrapperEntryTest, EglSurfaceAttribImpl001, Level1)
863 {
864 EGLDisplay dpy = nullptr;
865 auto result = gWrapperHook.wrapper.eglSurfaceAttrib(dpy, nullptr, 0, 0);
866 ASSERT_EQ(EGL_FALSE, result);
867 }
868
869 /**
870 * @tc.name: EglSurfaceAttribImpl002
871 * @tc.desc:
872 * @tc.type: FUNC
873 */
HWTEST_F(EglWrapperEntryTest,EglSurfaceAttribImpl002,Level2)874 HWTEST_F(EglWrapperEntryTest, EglSurfaceAttribImpl002, Level2)
875 {
876 EGLint majorVersion;
877 EGLint minorVersion;
878 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
879 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
880 ASSERT_EQ(ret, EGL_TRUE);
881
882 auto result = gWrapperHook.wrapper.eglSurfaceAttrib(dpy, nullptr, 0, 0);
883 ASSERT_EQ(EGL_FALSE, result);
884 }
885
886 /**
887 * @tc.name: EglSwapIntervalImpl001
888 * @tc.desc:
889 * @tc.type: FUNC
890 */
HWTEST_F(EglWrapperEntryTest,EglSwapIntervalImpl001,Level1)891 HWTEST_F(EglWrapperEntryTest, EglSwapIntervalImpl001, Level1)
892 {
893 EGLDisplay dpy = nullptr;
894 auto result = gWrapperHook.wrapper.eglSwapInterval(dpy, 0);
895 ASSERT_EQ(EGL_FALSE, result);
896 }
897
898 /**
899 * @tc.name: EglSwapIntervalImpl002
900 * @tc.desc:
901 * @tc.type: FUNC
902 */
HWTEST_F(EglWrapperEntryTest,EglSwapIntervalImpl002,Level2)903 HWTEST_F(EglWrapperEntryTest, EglSwapIntervalImpl002, Level2)
904 {
905 EGLint majorVersion;
906 EGLint minorVersion;
907 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
908 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
909 ASSERT_EQ(ret, EGL_TRUE);
910
911 auto result = gWrapperHook.wrapper.eglSwapInterval(dpy, 0);
912 ASSERT_EQ(EGL_FALSE, result);
913 }
914
915 /**
916 * @tc.name: EglBindAPIImpl001
917 * @tc.desc:
918 * @tc.type: FUNC
919 */
HWTEST_F(EglWrapperEntryTest,EglBindAPIImpl001,Level1)920 HWTEST_F(EglWrapperEntryTest, EglBindAPIImpl001, Level1)
921 {
922 auto temp = gWrapperHook.isLoad;
923 gWrapperHook.isLoad = false;
924 auto result = gWrapperHook.wrapper.eglBindAPI(1);
925 ASSERT_EQ(EGL_FALSE, result);
926 gWrapperHook.isLoad = temp;
927 }
928
929 /**
930 * @tc.name: EglBindAPIImpl002
931 * @tc.desc:
932 * @tc.type: FUNC
933 */
HWTEST_F(EglWrapperEntryTest,EglBindAPIImpl002,Level2)934 HWTEST_F(EglWrapperEntryTest, EglBindAPIImpl002, Level2)
935 {
936 auto temp = gWrapperHook.isLoad;
937 gWrapperHook.isLoad = true;
938 auto result = gWrapperHook.wrapper.eglBindAPI(1);
939 ASSERT_EQ(EGL_FALSE, result);
940 gWrapperHook.isLoad = temp;
941 }
942
943 /**
944 * @tc.name: EglQueryAPIImpl001
945 * @tc.desc:
946 * @tc.type: FUNC
947 */
HWTEST_F(EglWrapperEntryTest,EglQueryAPIImpl001,Level1)948 HWTEST_F(EglWrapperEntryTest, EglQueryAPIImpl001, Level1)
949 {
950 auto temp = gWrapperHook.isLoad;
951 gWrapperHook.isLoad = false;
952 auto result = gWrapperHook.wrapper.eglQueryAPI();
953 ASSERT_EQ(EGL_OPENGL_ES_API, result);
954 gWrapperHook.isLoad = temp;
955 }
956
957 /**
958 * @tc.name: EglQueryAPIImpl002
959 * @tc.desc:
960 * @tc.type: FUNC
961 */
HWTEST_F(EglWrapperEntryTest,EglQueryAPIImpl002,Level2)962 HWTEST_F(EglWrapperEntryTest, EglQueryAPIImpl002, Level2)
963 {
964 auto temp = gWrapperHook.isLoad;
965 gWrapperHook.isLoad = true;
966 auto result = gWrapperHook.wrapper.eglQueryAPI();
967 ASSERT_EQ(EGL_OPENGL_ES_API, result);
968 gWrapperHook.isLoad = temp;
969 }
970
971 /**
972 * @tc.name: EglCreatePbufferFromClientBufferImpl001
973 * @tc.desc:
974 * @tc.type: FUNC
975 */
HWTEST_F(EglWrapperEntryTest,EglCreatePbufferFromClientBufferImpl001,Level1)976 HWTEST_F(EglWrapperEntryTest, EglCreatePbufferFromClientBufferImpl001, Level1)
977 {
978 EGLDisplay dpy = nullptr;
979 auto result = gWrapperHook.wrapper.eglCreatePbufferFromClientBuffer(dpy, 0, nullptr, nullptr, nullptr);
980 ASSERT_EQ(EGL_NO_SURFACE, result);
981 }
982
983 /**
984 * @tc.name: EglReleaseThreadImpl001
985 * @tc.desc:
986 * @tc.type: FUNC
987 */
HWTEST_F(EglWrapperEntryTest,EglReleaseThreadImpl001,Level1)988 HWTEST_F(EglWrapperEntryTest, EglReleaseThreadImpl001, Level1)
989 {
990 auto temp = gWrapperHook.isLoad;
991 gWrapperHook.isLoad = false;
992 auto result = gWrapperHook.wrapper.eglReleaseThread();
993 ASSERT_EQ(EGL_TRUE, result);
994 gWrapperHook.isLoad = temp;
995 }
996
997 /**
998 * @tc.name: EglReleaseThreadImpl002
999 * @tc.desc:
1000 * @tc.type: FUNC
1001 */
HWTEST_F(EglWrapperEntryTest,EglReleaseThreadImpl002,Level2)1002 HWTEST_F(EglWrapperEntryTest, EglReleaseThreadImpl002, Level2)
1003 {
1004 auto temp = gWrapperHook.isLoad;
1005 gWrapperHook.isLoad = true;
1006 auto result = gWrapperHook.wrapper.eglReleaseThread();
1007 ASSERT_EQ(EGL_TRUE, result);
1008 gWrapperHook.isLoad = temp;
1009 }
1010
1011 /**
1012 * @tc.name: EglWaitClientImpl001
1013 * @tc.desc:
1014 * @tc.type: FUNC
1015 */
HWTEST_F(EglWrapperEntryTest,EglWaitClientImpl001,Level1)1016 HWTEST_F(EglWrapperEntryTest, EglWaitClientImpl001, Level1)
1017 {
1018 auto temp = gWrapperHook.isLoad;
1019 gWrapperHook.isLoad = false;
1020 auto result = gWrapperHook.wrapper.eglWaitClient();
1021 ASSERT_EQ(EGL_FALSE, result);
1022 gWrapperHook.isLoad = temp;
1023 }
1024
1025 /**
1026 * @tc.name: EglWaitClientImpl002
1027 * @tc.desc:
1028 * @tc.type: FUNC
1029 */
HWTEST_F(EglWrapperEntryTest,EglWaitClientImpl002,Level2)1030 HWTEST_F(EglWrapperEntryTest, EglWaitClientImpl002, Level2)
1031 {
1032 auto temp = gWrapperHook.isLoad;
1033 gWrapperHook.isLoad = true;
1034 auto result = gWrapperHook.wrapper.eglWaitClient();
1035 ASSERT_NE(EGL_FALSE, result);
1036 gWrapperHook.isLoad = temp;
1037 }
1038
1039 /**
1040 * @tc.name: EglCreateSyncImpl001
1041 * @tc.desc:
1042 * @tc.type: FUNC
1043 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncImpl001,Level1)1044 HWTEST_F(EglWrapperEntryTest, EglCreateSyncImpl001, Level1)
1045 {
1046 EGLDisplay dpy = nullptr;
1047 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1048 ASSERT_EQ(EGL_NO_SYNC, result);
1049 }
1050
1051 /**
1052 * @tc.name: EglCreateSyncImpl002
1053 * @tc.desc:
1054 * @tc.type: FUNC
1055 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncImpl002,Level2)1056 HWTEST_F(EglWrapperEntryTest, EglCreateSyncImpl002, Level2)
1057 {
1058 EGLint majorVersion;
1059 EGLint minorVersion;
1060 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1061 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1062 ASSERT_EQ(ret, EGL_TRUE);
1063
1064 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1065 ASSERT_EQ(EGL_NO_SYNC, result);
1066 }
1067
1068 /**
1069 * @tc.name: EglDestroySyncImpl001
1070 * @tc.desc:
1071 * @tc.type: FUNC
1072 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncImpl001,Level1)1073 HWTEST_F(EglWrapperEntryTest, EglDestroySyncImpl001, Level1)
1074 {
1075 EGLDisplay dpy = nullptr;
1076 auto result = gWrapperHook.wrapper.eglDestroySync(dpy, nullptr);
1077 ASSERT_EQ(EGL_FALSE, result);
1078 }
1079
1080 /**
1081 * @tc.name: EglDestroySyncImpl002
1082 * @tc.desc:
1083 * @tc.type: FUNC
1084 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncImpl002,Level2)1085 HWTEST_F(EglWrapperEntryTest, EglDestroySyncImpl002, Level2)
1086 {
1087 EGLint majorVersion;
1088 EGLint minorVersion;
1089 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1090 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1091 ASSERT_EQ(ret, EGL_TRUE);
1092
1093 auto result = gWrapperHook.wrapper.eglDestroySync(dpy, nullptr);
1094 ASSERT_EQ(EGL_FALSE, result);
1095 }
1096
1097 /**
1098 * @tc.name: EglClientWaitSyncImpl001
1099 * @tc.desc:
1100 * @tc.type: FUNC
1101 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncImpl001,Level1)1102 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncImpl001, Level1)
1103 {
1104 EGLDisplay dpy = nullptr;
1105 auto result = gWrapperHook.wrapper.eglClientWaitSync(dpy, nullptr, 0, 0);
1106 ASSERT_EQ(EGL_FALSE, result);
1107 }
1108
1109 /**
1110 * @tc.name: EglClientWaitSyncImpl002
1111 * @tc.desc:
1112 * @tc.type: FUNC
1113 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncImpl002,Level2)1114 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncImpl002, Level2)
1115 {
1116 EGLint majorVersion;
1117 EGLint minorVersion;
1118 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1119 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1120 ASSERT_EQ(ret, EGL_TRUE);
1121
1122 auto result = gWrapperHook.wrapper.eglClientWaitSync(dpy, nullptr, 0, 0);
1123 ASSERT_EQ(EGL_FALSE, result);
1124 }
1125
1126 /**
1127 * @tc.name: EglGetSyncAttribImpl001
1128 * @tc.desc:
1129 * @tc.type: FUNC
1130 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl001,Level1)1131 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl001, Level1)
1132 {
1133 EGLDisplay dpy = nullptr;
1134 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, nullptr);
1135 ASSERT_EQ(EGL_FALSE, result);
1136 }
1137
1138 /**
1139 * @tc.name: EglGetSyncAttribImpl002
1140 * @tc.desc:
1141 * @tc.type: FUNC
1142 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl002,Level2)1143 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl002, Level2)
1144 {
1145 EGLint majorVersion;
1146 EGLint minorVersion;
1147 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1148 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1149 ASSERT_EQ(ret, EGL_TRUE);
1150
1151 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, nullptr);
1152 ASSERT_EQ(EGL_FALSE, result);
1153 }
1154
1155 /**
1156 * @tc.name: EglGetSyncAttribImpl003
1157 * @tc.desc:
1158 * @tc.type: FUNC
1159 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribImpl003,Level2)1160 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribImpl003, 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 EGLAttrib value = 1;
1168
1169 auto result = gWrapperHook.wrapper.eglGetSyncAttrib(dpy, nullptr, 0, &value);
1170 ASSERT_EQ(EGL_FALSE, result);
1171 }
1172
1173 /**
1174 * @tc.name: EglDupNativeFenceFDANDROIDImpl001
1175 * @tc.desc:
1176 * @tc.type: FUNC
1177 */
HWTEST_F(EglWrapperEntryTest,EglDupNativeFenceFDANDROIDImpl001,Level2)1178 HWTEST_F(EglWrapperEntryTest, EglDupNativeFenceFDANDROIDImpl001, Level2)
1179 {
1180 EGLint majorVersion;
1181 EGLint minorVersion;
1182 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1183 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1184 ASSERT_EQ(ret, EGL_TRUE);
1185
1186 auto result = gWrapperHook.wrapper.eglCreateSync(dpy, 0, nullptr);
1187 ASSERT_EQ(EGL_NO_SYNC, result);
1188
1189 auto result1 = gWrapperHook.wrapper.eglDupNativeFenceFDANDROID(dpy, result);
1190 ASSERT_EQ(EGL_NO_NATIVE_FENCE_FD_ANDROID, result1);
1191 }
1192
1193 /**
1194 * @tc.name: EglCreateImageImpl001
1195 * @tc.desc:
1196 * @tc.type: FUNC
1197 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl001,Level1)1198 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl001, Level1)
1199 {
1200 EGLDisplay dpy = nullptr;
1201 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1202 ASSERT_EQ(EGL_NO_IMAGE, result);
1203 }
1204
1205 /**
1206 * @tc.name: EglCreateImageImpl002
1207 * @tc.desc:
1208 * @tc.type: FUNC
1209 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageImpl002,Level2)1210 HWTEST_F(EglWrapperEntryTest, EglCreateImageImpl002, Level2)
1211 {
1212 EGLint majorVersion;
1213 EGLint minorVersion;
1214 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1215 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1216 ASSERT_EQ(ret, EGL_TRUE);
1217
1218 auto result = gWrapperHook.wrapper.eglCreateImage(dpy, nullptr, 0, nullptr, nullptr);
1219 ASSERT_EQ(EGL_NO_IMAGE, result);
1220 }
1221
1222 /**
1223 * @tc.name: EglDestroyImageImpl001
1224 * @tc.desc:
1225 * @tc.type: FUNC
1226 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl001,Level1)1227 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl001, Level1)
1228 {
1229 EGLDisplay dpy = nullptr;
1230 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1231 ASSERT_EQ(EGL_FALSE, result);
1232 }
1233
1234 /**
1235 * @tc.name: EglDestroyImageImpl002
1236 * @tc.desc:
1237 * @tc.type: FUNC
1238 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageImpl002,Level2)1239 HWTEST_F(EglWrapperEntryTest, EglDestroyImageImpl002, Level2)
1240 {
1241 EGLint majorVersion;
1242 EGLint minorVersion;
1243 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1244 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1245 ASSERT_EQ(ret, EGL_TRUE);
1246
1247 auto result = gWrapperHook.wrapper.eglDestroyImage(dpy, nullptr);
1248 ASSERT_EQ(EGL_FALSE, result);
1249 }
1250
1251 /**
1252 * @tc.name: EglCreatePlatformWindowSurfaceImpl001
1253 * @tc.desc:
1254 * @tc.type: FUNC
1255 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl001,Level1)1256 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl001, Level1)
1257 {
1258 EGLDisplay dpy = nullptr;
1259 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1260 ASSERT_EQ(EGL_NO_SURFACE, result);
1261 }
1262
1263 /**
1264 * @tc.name: EglCreatePlatformWindowSurfaceImpl002
1265 * @tc.desc:
1266 * @tc.type: FUNC
1267 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceImpl002,Level2)1268 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceImpl002, Level2)
1269 {
1270 EGLint majorVersion;
1271 EGLint minorVersion;
1272 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1273 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1274 ASSERT_EQ(ret, EGL_TRUE);
1275
1276 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurface(dpy, nullptr, nullptr, nullptr);
1277 ASSERT_EQ(EGL_NO_SURFACE, result);
1278 }
1279
1280 /**
1281 * @tc.name: EglCreatePlatformPixmapSurfaceImpl001
1282 * @tc.desc:
1283 * @tc.type: FUNC
1284 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl001,Level1)1285 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl001, Level1)
1286 {
1287 EGLDisplay dpy = nullptr;
1288 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1289 ASSERT_EQ(EGL_NO_SURFACE, result);
1290 }
1291
1292 /**
1293 * @tc.name: EglCreatePlatformPixmapSurfaceImpl002
1294 * @tc.desc:
1295 * @tc.type: FUNC
1296 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceImpl002,Level2)1297 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceImpl002, Level2)
1298 {
1299 EGLint majorVersion;
1300 EGLint minorVersion;
1301 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1302 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1303 ASSERT_EQ(ret, EGL_TRUE);
1304
1305 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurface(dpy, nullptr, nullptr, nullptr);
1306 ASSERT_EQ(EGL_NO_SURFACE, result);
1307 }
1308
1309 /**
1310 * @tc.name: EglWaitSyncImpl001
1311 * @tc.desc:
1312 * @tc.type: FUNC
1313 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl001,Level1)1314 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl001, Level1)
1315 {
1316 EGLDisplay dpy = nullptr;
1317 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1318 ASSERT_EQ(EGL_FALSE, result);
1319 }
1320
1321 /**
1322 * @tc.name: EglWaitSyncImpl002
1323 * @tc.desc:
1324 * @tc.type: FUNC
1325 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncImpl002,Level2)1326 HWTEST_F(EglWrapperEntryTest, EglWaitSyncImpl002, Level2)
1327 {
1328 EGLint majorVersion;
1329 EGLint minorVersion;
1330 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1331 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1332 ASSERT_EQ(ret, EGL_TRUE);
1333
1334 auto result = gWrapperHook.wrapper.eglWaitSync(dpy, nullptr, 0);
1335 ASSERT_EQ(EGL_FALSE, result);
1336 }
1337
1338 /**
1339 * @tc.name: EglLockSurfaceKHRImpl001
1340 * @tc.desc:
1341 * @tc.type: FUNC
1342 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl001,Level1)1343 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl001, Level1)
1344 {
1345 EGLDisplay dpy = nullptr;
1346 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1347 ASSERT_EQ(EGL_FALSE, result);
1348 }
1349
1350 /**
1351 * @tc.name: EglLockSurfaceKHRImpl002
1352 * @tc.desc:
1353 * @tc.type: FUNC
1354 */
HWTEST_F(EglWrapperEntryTest,EglLockSurfaceKHRImpl002,Level2)1355 HWTEST_F(EglWrapperEntryTest, EglLockSurfaceKHRImpl002, Level2)
1356 {
1357 EGLint majorVersion;
1358 EGLint minorVersion;
1359 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1360 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1361 ASSERT_EQ(ret, EGL_TRUE);
1362
1363 auto result = gWrapperHook.wrapper.eglLockSurfaceKHR(dpy, nullptr, nullptr);
1364 ASSERT_EQ(EGL_FALSE, result);
1365 }
1366
1367 /**
1368 * @tc.name: EglUnlockSurfaceKHRImpl001
1369 * @tc.desc:
1370 * @tc.type: FUNC
1371 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl001,Level1)1372 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl001, Level1)
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.eglUnlockSurfaceKHR(dpy, nullptr);
1381 ASSERT_EQ(EGL_FALSE, result);
1382 }
1383
1384 /**
1385 * @tc.name: EglUnlockSurfaceKHRImpl002
1386 * @tc.desc:
1387 * @tc.type: FUNC
1388 */
HWTEST_F(EglWrapperEntryTest,EglUnlockSurfaceKHRImpl002,Level2)1389 HWTEST_F(EglWrapperEntryTest, EglUnlockSurfaceKHRImpl002, Level2)
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: EglCreateImageKHRImpl001
1403 * @tc.desc:
1404 * @tc.type: FUNC
1405 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl001,Level1)1406 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl001, Level1)
1407 {
1408 EGLDisplay dpy = nullptr;
1409 auto result = gWrapperHook.wrapper.eglCreateImageKHR(dpy, 0, 0, nullptr, nullptr);
1410 ASSERT_EQ(EGL_NO_IMAGE_KHR, result);
1411 }
1412
1413 /**
1414 * @tc.name: EglCreateImageKHRImpl002
1415 * @tc.desc:
1416 * @tc.type: FUNC
1417 */
HWTEST_F(EglWrapperEntryTest,EglCreateImageKHRImpl002,Level2)1418 HWTEST_F(EglWrapperEntryTest, EglCreateImageKHRImpl002, Level2)
1419 {
1420 EGLint majorVersion;
1421 EGLint minorVersion;
1422 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1423 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1424 ASSERT_EQ(ret, EGL_TRUE);
1425
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: EglDestroyImageKHRImpl001
1432 * @tc.desc:
1433 * @tc.type: FUNC
1434 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl001,Level1)1435 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl001, Level1)
1436 {
1437 EGLDisplay dpy = nullptr;
1438 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1439 ASSERT_EQ(EGL_FALSE, result);
1440 }
1441
1442 /**
1443 * @tc.name: EglDestroyImageKHRImpl002
1444 * @tc.desc:
1445 * @tc.type: FUNC
1446 */
HWTEST_F(EglWrapperEntryTest,EglDestroyImageKHRImpl002,Level2)1447 HWTEST_F(EglWrapperEntryTest, EglDestroyImageKHRImpl002, Level2)
1448 {
1449 EGLint majorVersion;
1450 EGLint minorVersion;
1451 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1452 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1453 ASSERT_EQ(ret, EGL_TRUE);
1454
1455 auto result = gWrapperHook.wrapper.eglDestroyImageKHR(dpy, nullptr);
1456 ASSERT_EQ(EGL_FALSE, result);
1457 }
1458
1459 /**
1460 * @tc.name: EglCreateSyncKHRImpl001
1461 * @tc.desc:
1462 * @tc.type: FUNC
1463 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl001,Level1)1464 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl001, Level1)
1465 {
1466 EGLDisplay dpy = nullptr;
1467 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1468 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1469 }
1470
1471 /**
1472 * @tc.name: EglCreateSyncKHRImpl002
1473 * @tc.desc:
1474 * @tc.type: FUNC
1475 */
HWTEST_F(EglWrapperEntryTest,EglCreateSyncKHRImpl002,Level2)1476 HWTEST_F(EglWrapperEntryTest, EglCreateSyncKHRImpl002, Level2)
1477 {
1478 EGLint majorVersion;
1479 EGLint minorVersion;
1480 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1481 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1482 ASSERT_EQ(ret, EGL_TRUE);
1483
1484 auto result = gWrapperHook.wrapper.eglCreateSyncKHR(dpy, 0, nullptr);
1485 ASSERT_EQ(EGL_NO_SYNC_KHR, result);
1486 }
1487
1488 /**
1489 * @tc.name: EglDestroySyncKHRImpl001
1490 * @tc.desc:
1491 * @tc.type: FUNC
1492 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl001,Level1)1493 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl001, Level1)
1494 {
1495 EGLDisplay dpy = nullptr;
1496 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1497 ASSERT_EQ(EGL_FALSE, result);
1498 }
1499
1500 /**
1501 * @tc.name: EglDestroySyncKHRImpl002
1502 * @tc.desc:
1503 * @tc.type: FUNC
1504 */
HWTEST_F(EglWrapperEntryTest,EglDestroySyncKHRImpl002,Level2)1505 HWTEST_F(EglWrapperEntryTest, EglDestroySyncKHRImpl002, Level2)
1506 {
1507 EGLint majorVersion;
1508 EGLint minorVersion;
1509 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1510 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1511 ASSERT_EQ(ret, EGL_TRUE);
1512
1513 auto result = gWrapperHook.wrapper.eglDestroySyncKHR(dpy, nullptr);
1514 ASSERT_EQ(EGL_FALSE, result);
1515 }
1516
1517 /**
1518 * @tc.name: EglClientWaitSyncKHRImpl001
1519 * @tc.desc:
1520 * @tc.type: FUNC
1521 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl001,Level1)1522 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl001, Level1)
1523 {
1524 EGLDisplay dpy = nullptr;
1525 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1526 ASSERT_EQ(EGL_FALSE, result);
1527 }
1528
1529 /**
1530 * @tc.name: EglClientWaitSyncKHRImpl002
1531 * @tc.desc:
1532 * @tc.type: FUNC
1533 */
HWTEST_F(EglWrapperEntryTest,EglClientWaitSyncKHRImpl002,Level2)1534 HWTEST_F(EglWrapperEntryTest, EglClientWaitSyncKHRImpl002, Level2)
1535 {
1536 EGLint majorVersion;
1537 EGLint minorVersion;
1538 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1539 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1540 ASSERT_EQ(ret, EGL_TRUE);
1541
1542 auto result = gWrapperHook.wrapper.eglClientWaitSyncKHR(dpy, nullptr, 0, 0);
1543 ASSERT_EQ(EGL_FALSE, result);
1544 }
1545
1546 /**
1547 * @tc.name: EglGetSyncAttribKHRImpl001
1548 * @tc.desc:
1549 * @tc.type: FUNC
1550 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl001,Level1)1551 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl001, Level1)
1552 {
1553 EGLDisplay dpy = nullptr;
1554 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1555 ASSERT_EQ(EGL_FALSE, result);
1556 }
1557
1558 /**
1559 * @tc.name: EglGetSyncAttribKHRImpl002
1560 * @tc.desc:
1561 * @tc.type: FUNC
1562 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl002,Level2)1563 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl002, Level2)
1564 {
1565 EGLint majorVersion;
1566 EGLint minorVersion;
1567 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1568 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1569 ASSERT_EQ(ret, EGL_TRUE);
1570
1571 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, nullptr);
1572 ASSERT_EQ(EGL_FALSE, result);
1573 }
1574
1575 /**
1576 * @tc.name: EglGetSyncAttribKHRImpl003
1577 * @tc.desc:
1578 * @tc.type: FUNC
1579 */
HWTEST_F(EglWrapperEntryTest,EglGetSyncAttribKHRImpl003,Level2)1580 HWTEST_F(EglWrapperEntryTest, EglGetSyncAttribKHRImpl003, 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 EGLint value = 1;
1588
1589 auto result = gWrapperHook.wrapper.eglGetSyncAttribKHR(dpy, nullptr, 0, &value);
1590 ASSERT_EQ(EGL_FALSE, result);
1591 }
1592
1593 /**
1594 * @tc.name: EglSignalSyncKHRImpl001
1595 * @tc.desc:
1596 * @tc.type: FUNC
1597 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl001,Level1)1598 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl001, Level1)
1599 {
1600 EGLDisplay dpy = nullptr;
1601 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1602 ASSERT_EQ(EGL_FALSE, result);
1603 }
1604
1605 /**
1606 * @tc.name: EglSignalSyncKHRImpl002
1607 * @tc.desc:
1608 * @tc.type: FUNC
1609 */
HWTEST_F(EglWrapperEntryTest,EglSignalSyncKHRImpl002,Level2)1610 HWTEST_F(EglWrapperEntryTest, EglSignalSyncKHRImpl002, Level2)
1611 {
1612 EGLint majorVersion;
1613 EGLint minorVersion;
1614 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1615 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1616 ASSERT_EQ(ret, EGL_TRUE);
1617
1618 auto result = gWrapperHook.wrapper.eglSignalSyncKHR(dpy, nullptr, 0);
1619 ASSERT_EQ(EGL_FALSE, result);
1620 }
1621
1622 /**
1623 * @tc.name: EglCreateStreamKHRImpl001
1624 * @tc.desc:
1625 * @tc.type: FUNC
1626 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl001,Level1)1627 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl001, Level1)
1628 {
1629 EGLDisplay dpy = nullptr;
1630 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1631 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1632 }
1633
1634 /**
1635 * @tc.name: EglCreateStreamKHRImpl002
1636 * @tc.desc:
1637 * @tc.type: FUNC
1638 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamKHRImpl002,Level2)1639 HWTEST_F(EglWrapperEntryTest, EglCreateStreamKHRImpl002, Level2)
1640 {
1641 EGLint majorVersion;
1642 EGLint minorVersion;
1643 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1644 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1645 ASSERT_EQ(ret, EGL_TRUE);
1646
1647 auto result = gWrapperHook.wrapper.eglCreateStreamKHR(dpy, nullptr);
1648 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
1649 }
1650
1651
1652 /**
1653 * @tc.name: EglDestroyStreamKHRImpl001
1654 * @tc.desc:
1655 * @tc.type: FUNC
1656 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl001,Level1)1657 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl001, Level1)
1658 {
1659 EGLint majorVersion;
1660 EGLint minorVersion;
1661 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1662 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1663 ASSERT_EQ(ret, EGL_TRUE);
1664
1665 auto result = gWrapperHook.wrapper.eglDestroyStreamKHR(dpy, nullptr);
1666 ASSERT_EQ(EGL_FALSE, result);
1667 }
1668
1669 /**
1670 * @tc.name: EglDestroyStreamKHRImpl002
1671 * @tc.desc:
1672 * @tc.type: FUNC
1673 */
HWTEST_F(EglWrapperEntryTest,EglDestroyStreamKHRImpl002,Level2)1674 HWTEST_F(EglWrapperEntryTest, EglDestroyStreamKHRImpl002, Level2)
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: EglStreamAttribKHRImpl001
1688 * @tc.desc:
1689 * @tc.type: FUNC
1690 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl001,Level1)1691 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl001, Level1)
1692 {
1693 EGLDisplay dpy = nullptr;
1694 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1695 ASSERT_EQ(EGL_FALSE, result);
1696 }
1697
1698 /**
1699 * @tc.name: EglStreamAttribKHRImpl002
1700 * @tc.desc:
1701 * @tc.type: FUNC
1702 */
HWTEST_F(EglWrapperEntryTest,EglStreamAttribKHRImpl002,Level2)1703 HWTEST_F(EglWrapperEntryTest, EglStreamAttribKHRImpl002, Level2)
1704 {
1705 EGLint majorVersion;
1706 EGLint minorVersion;
1707 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1708 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1709 ASSERT_EQ(ret, EGL_TRUE);
1710
1711 auto result = gWrapperHook.wrapper.eglStreamAttribKHR(dpy, nullptr, 0, 0);
1712 ASSERT_EQ(EGL_FALSE, result);
1713 }
1714
1715 /**
1716 * @tc.name: EglQueryStreamKHRImpl001
1717 * @tc.desc:
1718 * @tc.type: FUNC
1719 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl001,Level1)1720 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl001, Level1)
1721 {
1722 EGLDisplay dpy = nullptr;
1723 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1724 ASSERT_EQ(EGL_FALSE, result);
1725 }
1726
1727 /**
1728 * @tc.name: EglQueryStreamKHRImpl002
1729 * @tc.desc:
1730 * @tc.type: FUNC
1731 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl002,Level2)1732 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl002, Level2)
1733 {
1734 EGLint majorVersion;
1735 EGLint minorVersion;
1736 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1737 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1738 ASSERT_EQ(ret, EGL_TRUE);
1739
1740 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, nullptr);
1741 ASSERT_EQ(EGL_FALSE, result);
1742 }
1743
1744 /**
1745 * @tc.name: EglQueryStreamKHRImpl003
1746 * @tc.desc:
1747 * @tc.type: FUNC
1748 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamKHRImpl003,Level2)1749 HWTEST_F(EglWrapperEntryTest, EglQueryStreamKHRImpl003, 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 EGLint value = 1;
1757
1758 auto result = gWrapperHook.wrapper.eglQueryStreamKHR(dpy, nullptr, 0, &value);
1759 ASSERT_EQ(EGL_FALSE, result);
1760 }
1761
1762 /**
1763 * @tc.name: EglQueryStreamu64KHRImpl001
1764 * @tc.desc:
1765 * @tc.type: FUNC
1766 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl001,Level1)1767 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl001, Level1)
1768 {
1769 EGLDisplay dpy = nullptr;
1770 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1771 ASSERT_EQ(EGL_FALSE, result);
1772 }
1773
1774 /**
1775 * @tc.name: EglQueryStreamu64KHRImpl002
1776 * @tc.desc:
1777 * @tc.type: FUNC
1778 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl002,Level2)1779 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl002, Level2)
1780 {
1781 EGLint majorVersion;
1782 EGLint minorVersion;
1783 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1784 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1785 ASSERT_EQ(ret, EGL_TRUE);
1786
1787 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, nullptr);
1788 ASSERT_EQ(EGL_FALSE, result);
1789 }
1790
1791 /**
1792 * @tc.name: EglQueryStreamu64KHRImpl003
1793 * @tc.desc:
1794 * @tc.type: FUNC
1795 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamu64KHRImpl003,Level2)1796 HWTEST_F(EglWrapperEntryTest, EglQueryStreamu64KHRImpl003, 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 EGLuint64KHR value = 1;
1804
1805 auto result = gWrapperHook.wrapper.eglQueryStreamu64KHR(dpy, nullptr, 0, &value);
1806 ASSERT_EQ(EGL_FALSE, result);
1807 }
1808
1809 /**
1810 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl001
1811 * @tc.desc:
1812 * @tc.type: FUNC
1813 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl001,Level1)1814 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl001, Level1)
1815 {
1816 EGLDisplay dpy = nullptr;
1817 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1818 ASSERT_EQ(EGL_FALSE, result);
1819 }
1820
1821 /**
1822 * @tc.name: EglStreamConsumerGLTextureExternalKHRImpl002
1823 * @tc.desc:
1824 * @tc.type: FUNC
1825 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerGLTextureExternalKHRImpl002,Level2)1826 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerGLTextureExternalKHRImpl002, Level2)
1827 {
1828 EGLint majorVersion;
1829 EGLint minorVersion;
1830 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1831 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1832 ASSERT_EQ(ret, EGL_TRUE);
1833
1834 auto result = gWrapperHook.wrapper.eglStreamConsumerGLTextureExternalKHR(dpy, nullptr);
1835 ASSERT_EQ(EGL_FALSE, result);
1836 }
1837
1838 /**
1839 * @tc.name: EglStreamConsumerAcquireKHRImpl001
1840 * @tc.desc:
1841 * @tc.type: FUNC
1842 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl001,Level1)1843 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl001, Level1)
1844 {
1845 EGLDisplay dpy = nullptr;
1846 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1847 ASSERT_EQ(EGL_FALSE, result);
1848 }
1849
1850 /**
1851 * @tc.name: EglStreamConsumerAcquireKHRImpl002
1852 * @tc.desc:
1853 * @tc.type: FUNC
1854 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerAcquireKHRImpl002,Level2)1855 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerAcquireKHRImpl002, Level2)
1856 {
1857 EGLint majorVersion;
1858 EGLint minorVersion;
1859 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1860 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1861 ASSERT_EQ(ret, EGL_TRUE);
1862
1863 auto result = gWrapperHook.wrapper.eglStreamConsumerAcquireKHR(dpy, nullptr);
1864 ASSERT_EQ(EGL_FALSE, result);
1865 }
1866
1867 /**
1868 * @tc.name: EglStreamConsumerReleaseKHRImpl001
1869 * @tc.desc:
1870 * @tc.type: FUNC
1871 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl001,Level1)1872 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl001, Level1)
1873 {
1874 EGLDisplay dpy = nullptr;
1875 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1876 ASSERT_EQ(EGL_FALSE, result);
1877 }
1878
1879 /**
1880 * @tc.name: EglStreamConsumerReleaseKHRImpl002
1881 * @tc.desc:
1882 * @tc.type: FUNC
1883 */
HWTEST_F(EglWrapperEntryTest,EglStreamConsumerReleaseKHRImpl002,Level2)1884 HWTEST_F(EglWrapperEntryTest, EglStreamConsumerReleaseKHRImpl002, Level2)
1885 {
1886 EGLint majorVersion;
1887 EGLint minorVersion;
1888 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1889 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1890 ASSERT_EQ(ret, EGL_TRUE);
1891
1892 auto result = gWrapperHook.wrapper.eglStreamConsumerReleaseKHR(dpy, nullptr);
1893 ASSERT_EQ(EGL_FALSE, result);
1894 }
1895
1896 /**
1897 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl001
1898 * @tc.desc:
1899 * @tc.type: FUNC
1900 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl001,Level1)1901 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl001, Level1)
1902 {
1903 EGLDisplay dpy = nullptr;
1904 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1905 ASSERT_EQ(EGL_NO_SURFACE, result);
1906 }
1907
1908 /**
1909 * @tc.name: EglCreateStreamProducerSurfaceKHRImpl002
1910 * @tc.desc:
1911 * @tc.type: FUNC
1912 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamProducerSurfaceKHRImpl002,Level2)1913 HWTEST_F(EglWrapperEntryTest, EglCreateStreamProducerSurfaceKHRImpl002, Level2)
1914 {
1915 EGLint majorVersion;
1916 EGLint minorVersion;
1917 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1918 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1919 ASSERT_EQ(ret, EGL_TRUE);
1920
1921 auto result = gWrapperHook.wrapper.eglCreateStreamProducerSurfaceKHR(dpy, nullptr, 0, nullptr);
1922 ASSERT_EQ(EGL_NO_SURFACE, result);
1923 }
1924
1925 /**
1926 * @tc.name: EglQueryStreamTimeKHRImpl001
1927 * @tc.desc:
1928 * @tc.type: FUNC
1929 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl001,Level1)1930 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl001, Level1)
1931 {
1932 EGLDisplay dpy = nullptr;
1933 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1934 ASSERT_EQ(EGL_FALSE, result);
1935 }
1936
1937 /**
1938 * @tc.name: EglQueryStreamTimeKHRImpl002
1939 * @tc.desc:
1940 * @tc.type: FUNC
1941 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl002,Level2)1942 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl002, Level2)
1943 {
1944 EGLint majorVersion;
1945 EGLint minorVersion;
1946 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1947 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1948 ASSERT_EQ(ret, EGL_TRUE);
1949
1950 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, nullptr);
1951 ASSERT_EQ(EGL_FALSE, result);
1952 }
1953
1954 /**
1955 * @tc.name: EglQueryStreamTimeKHRImpl003
1956 * @tc.desc:
1957 * @tc.type: FUNC
1958 */
HWTEST_F(EglWrapperEntryTest,EglQueryStreamTimeKHRImpl003,Level2)1959 HWTEST_F(EglWrapperEntryTest, EglQueryStreamTimeKHRImpl003, 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 EGLTimeKHR value = 1;
1967
1968 auto result = gWrapperHook.wrapper.eglQueryStreamTimeKHR(dpy, nullptr, 0, &value);
1969 ASSERT_EQ(EGL_FALSE, result);
1970 }
1971
1972 /**
1973 * @tc.name: EglGetStreamFileDescriptorKHRImpl001
1974 * @tc.desc:
1975 * @tc.type: FUNC
1976 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl001,Level1)1977 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl001, Level1)
1978 {
1979 EGLDisplay dpy = nullptr;
1980 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
1981 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
1982 }
1983
1984 /**
1985 * @tc.name: EglGetStreamFileDescriptorKHRImpl002
1986 * @tc.desc:
1987 * @tc.type: FUNC
1988 */
HWTEST_F(EglWrapperEntryTest,EglGetStreamFileDescriptorKHRImpl002,Level2)1989 HWTEST_F(EglWrapperEntryTest, EglGetStreamFileDescriptorKHRImpl002, Level2)
1990 {
1991 EGLint majorVersion;
1992 EGLint minorVersion;
1993 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
1994 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
1995 ASSERT_EQ(ret, EGL_TRUE);
1996
1997 auto result = gWrapperHook.wrapper.eglGetStreamFileDescriptorKHR(dpy, nullptr);
1998 ASSERT_EQ(EGL_NO_FILE_DESCRIPTOR_KHR, result);
1999 }
2000
2001
2002 /**
2003 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl001
2004 * @tc.desc:
2005 * @tc.type: FUNC
2006 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl001,Level1)2007 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl001, Level1)
2008 {
2009 EGLDisplay dpy = nullptr;
2010 auto result = gWrapperHook.wrapper.eglCreateStreamFromFileDescriptorKHR(dpy, EGL_NO_FILE_DESCRIPTOR_KHR);
2011 ASSERT_EQ(EGL_NO_STREAM_KHR, result);
2012 }
2013
2014 /**
2015 * @tc.name: EglCreateStreamFromFileDescriptorKHRImpl002
2016 * @tc.desc:
2017 * @tc.type: FUNC
2018 */
HWTEST_F(EglWrapperEntryTest,EglCreateStreamFromFileDescriptorKHRImpl002,Level2)2019 HWTEST_F(EglWrapperEntryTest, EglCreateStreamFromFileDescriptorKHRImpl002, Level2)
2020 {
2021 EGLint majorVersion;
2022 EGLint minorVersion;
2023 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2024 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2025 ASSERT_EQ(ret, EGL_TRUE);
2026
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: EglWaitSyncKHRImpl001
2033 * @tc.desc:
2034 * @tc.type: FUNC
2035 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl001,Level1)2036 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl001, Level1)
2037 {
2038 EGLDisplay dpy = nullptr;
2039 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2040 ASSERT_EQ(EGL_FALSE, result);
2041 }
2042
2043 /**
2044 * @tc.name: EglWaitSyncKHRImpl002
2045 * @tc.desc:
2046 * @tc.type: FUNC
2047 */
HWTEST_F(EglWrapperEntryTest,EglWaitSyncKHRImpl002,Level2)2048 HWTEST_F(EglWrapperEntryTest, EglWaitSyncKHRImpl002, Level2)
2049 {
2050 EGLint majorVersion;
2051 EGLint minorVersion;
2052 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2053 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2054 ASSERT_EQ(ret, EGL_TRUE);
2055
2056 auto result = gWrapperHook.wrapper.eglWaitSyncKHR(dpy, nullptr, 0);
2057 ASSERT_EQ(EGL_FALSE, result);
2058 }
2059
2060 /**
2061 * @tc.name: EglGetPlatformDisplayEXTImpl001
2062 * @tc.desc:
2063 * @tc.type: FUNC
2064 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl001,Level1)2065 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl001, Level1)
2066 {
2067 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGLNativeDisplayType(1), nullptr);
2068 ASSERT_EQ(EGL_NO_DISPLAY, result);
2069 }
2070
2071 /**
2072 * @tc.name: EglGetPlatformDisplayEXTImpl002
2073 * @tc.desc:
2074 * @tc.type: FUNC
2075 */
HWTEST_F(EglWrapperEntryTest,EglGetPlatformDisplayEXTImpl002,Level2)2076 HWTEST_F(EglWrapperEntryTest, EglGetPlatformDisplayEXTImpl002, Level2)
2077 {
2078 auto result = gWrapperHook.wrapper.eglGetPlatformDisplayEXT(0, EGL_DEFAULT_DISPLAY, nullptr);
2079 ASSERT_EQ(EGL_NO_DISPLAY, result);
2080 }
2081
2082 /**
2083 * @tc.name: EglSwapBuffersWithDamageKHRImpl001
2084 * @tc.desc:
2085 * @tc.type: FUNC
2086 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl001,Level1)2087 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl001, Level1)
2088 {
2089 EGLDisplay dpy = nullptr;
2090 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2091 ASSERT_EQ(EGL_FALSE, result);
2092 }
2093
2094 /**
2095 * @tc.name: EglSwapBuffersWithDamageKHRImpl002
2096 * @tc.desc:
2097 * @tc.type: FUNC
2098 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageKHRImpl002,Level2)2099 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageKHRImpl002, Level2)
2100 {
2101 EGLint majorVersion;
2102 EGLint minorVersion;
2103 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2104 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2105 ASSERT_EQ(ret, EGL_TRUE);
2106
2107 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageKHR(dpy, nullptr, nullptr, 0);
2108 ASSERT_EQ(EGL_FALSE, result);
2109 }
2110
2111 /**
2112 * @tc.name: EglSetDamageRegionKHRImpl001
2113 * @tc.desc:
2114 * @tc.type: FUNC
2115 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl001,Level1)2116 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl001, Level1)
2117 {
2118 EGLDisplay dpy = nullptr;
2119 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2120 ASSERT_EQ(EGL_FALSE, result);
2121 }
2122
2123 /**
2124 * @tc.name: EglSetDamageRegionKHRImpl002
2125 * @tc.desc:
2126 * @tc.type: FUNC
2127 */
HWTEST_F(EglWrapperEntryTest,EglSetDamageRegionKHRImpl002,Level2)2128 HWTEST_F(EglWrapperEntryTest, EglSetDamageRegionKHRImpl002, Level2)
2129 {
2130 EGLint majorVersion;
2131 EGLint minorVersion;
2132 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2133 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2134 ASSERT_EQ(ret, EGL_TRUE);
2135
2136 auto result = gWrapperHook.wrapper.eglSetDamageRegionKHR(dpy, nullptr, nullptr, 0);
2137 ASSERT_EQ(EGL_FALSE, result);
2138 }
2139
2140 /**
2141 * @tc.name: EglGetCompositorTimingSupportedANDROIDImpl001
2142 * @tc.desc:
2143 * @tc.type: FUNC
2144 */
HWTEST_F(EglWrapperEntryTest,EglGetCompositorTimingSupportedANDROIDImpl001,Level1)2145 HWTEST_F(EglWrapperEntryTest, EglGetCompositorTimingSupportedANDROIDImpl001, Level1)
2146 {
2147 EGLDisplay dpy = nullptr;
2148 auto result = gWrapperHook.wrapper.eglGetCompositorTimingSupportedANDROID(dpy, nullptr, 0);
2149 ASSERT_EQ(EGL_FALSE, result);
2150 }
2151
2152 /**
2153 * @tc.name: EglGetCompositorTimingSupportedANDROIDImpl002
2154 * @tc.desc:
2155 * @tc.type: FUNC
2156 */
HWTEST_F(EglWrapperEntryTest,EglGetCompositorTimingSupportedANDROIDImpl002,Level2)2157 HWTEST_F(EglWrapperEntryTest, EglGetCompositorTimingSupportedANDROIDImpl002, Level2)
2158 {
2159 EGLint majorVersion;
2160 EGLint minorVersion;
2161 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2162 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2163 ASSERT_EQ(ret, EGL_TRUE);
2164
2165 auto result = gWrapperHook.wrapper.eglGetCompositorTimingSupportedANDROID(dpy, nullptr, 0x3431);
2166 ASSERT_EQ(EGL_FALSE, result);
2167 }
2168
2169 /**
2170 * @tc.name: EglGetFrameTimestampSupportedANDROIDImpl001
2171 * @tc.desc:
2172 * @tc.type: FUNC
2173 */
HWTEST_F(EglWrapperEntryTest,EglGetFrameTimestampSupportedANDROIDImpl001,Level1)2174 HWTEST_F(EglWrapperEntryTest, EglGetFrameTimestampSupportedANDROIDImpl001, Level1)
2175 {
2176 EGLDisplay dpy = nullptr;
2177 EGLint timestamp = 1;
2178 auto result = gWrapperHook.wrapper.eglGetFrameTimestampSupportedANDROID(dpy, nullptr, timestamp);
2179 ASSERT_EQ(EGL_FALSE, result);
2180 }
2181
2182 /**
2183 * @tc.name: EglGetFrameTimestampSupportedANDROIDImpl002
2184 * @tc.desc:
2185 * @tc.type: FUNC
2186 */
HWTEST_F(EglWrapperEntryTest,EglGetFrameTimestampSupportedANDROIDImpl002,Level2)2187 HWTEST_F(EglWrapperEntryTest, EglGetFrameTimestampSupportedANDROIDImpl002, Level2)
2188 {
2189 EGLint majorVersion;
2190 EGLint minorVersion;
2191 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2192 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2193 ASSERT_EQ(ret, EGL_TRUE);
2194
2195 EGLint timestamp = 1;
2196 auto result = gWrapperHook.wrapper.eglGetFrameTimestampSupportedANDROID(dpy, nullptr, timestamp);
2197 ASSERT_EQ(EGL_FALSE, result);
2198 }
2199
2200 /**
2201 * @tc.name: EglPresentationTimeANDROIDImpl001
2202 * @tc.desc:
2203 * @tc.type: FUNC
2204 */
HWTEST_F(EglWrapperEntryTest,EglPresentationTimeANDROIDImpl001,Level1)2205 HWTEST_F(EglWrapperEntryTest, EglPresentationTimeANDROIDImpl001, Level1)
2206 {
2207 EGLDisplay dpy = nullptr;
2208 EGLnsecsANDROID time = 1;
2209 auto result = gWrapperHook.wrapper.eglPresentationTimeANDROID(dpy, nullptr, time);
2210 ASSERT_EQ(EGL_FALSE, result);
2211 }
2212
2213 /**
2214 * @tc.name: EglPresentationTimeANDROIDImpl002
2215 * @tc.desc:
2216 * @tc.type: FUNC
2217 */
HWTEST_F(EglWrapperEntryTest,EglPresentationTimeANDROIDImpl002,Level2)2218 HWTEST_F(EglWrapperEntryTest, EglPresentationTimeANDROIDImpl002, Level2)
2219 {
2220 EGLint majorVersion;
2221 EGLint minorVersion;
2222 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2223 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2224 ASSERT_EQ(ret, EGL_TRUE);
2225
2226 EGLnsecsANDROID time = 1;
2227 auto result = gWrapperHook.wrapper.eglPresentationTimeANDROID(dpy, nullptr, time);
2228 ASSERT_EQ(EGL_FALSE, result);
2229 }
2230
2231 /**
2232 * @tc.name: EglCreatePlatformWindowSurfaceEXTImpl001
2233 * @tc.desc:
2234 * @tc.type: FUNC
2235 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceEXTImpl001,Level1)2236 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceEXTImpl001, Level1)
2237 {
2238 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurfaceEXT(nullptr, nullptr, nullptr, nullptr);
2239 ASSERT_EQ(EGL_FALSE, result);
2240 }
2241
2242 /**
2243 * @tc.name: EglCreatePlatformWindowSurfaceEXTImpl002
2244 * @tc.desc:
2245 * @tc.type: FUNC
2246 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformWindowSurfaceEXTImpl002,Level2)2247 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformWindowSurfaceEXTImpl002, Level2)
2248 {
2249 EGLint majorVersion;
2250 EGLint minorVersion;
2251 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2252 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2253 ASSERT_EQ(ret, EGL_TRUE);
2254
2255 auto result = gWrapperHook.wrapper.eglCreatePlatformWindowSurfaceEXT(dpy, nullptr, nullptr, nullptr);
2256 ASSERT_EQ(EGL_FALSE, result);
2257 }
2258
2259 /**
2260 * @tc.name: EglCreatePlatformPixmapSurfaceEXTImpl001
2261 * @tc.desc:
2262 * @tc.type: FUNC
2263 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceEXTImpl001,Level1)2264 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceEXTImpl001, Level1)
2265 {
2266 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurfaceEXT(nullptr, nullptr, nullptr, nullptr);
2267 ASSERT_EQ(EGL_FALSE, result);
2268 }
2269
2270 /**
2271 * @tc.name: EglCreatePlatformPixmapSurfaceEXTImpl002
2272 * @tc.desc:
2273 * @tc.type: FUNC
2274 */
HWTEST_F(EglWrapperEntryTest,EglCreatePlatformPixmapSurfaceEXTImpl002,Level2)2275 HWTEST_F(EglWrapperEntryTest, EglCreatePlatformPixmapSurfaceEXTImpl002, Level2)
2276 {
2277 EGLint majorVersion;
2278 EGLint minorVersion;
2279 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2280 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2281 ASSERT_EQ(ret, EGL_TRUE);
2282
2283 auto result = gWrapperHook.wrapper.eglCreatePlatformPixmapSurfaceEXT(dpy, nullptr, nullptr, nullptr);
2284 ASSERT_EQ(EGL_FALSE, result);
2285 }
2286
2287 /**
2288 * @tc.name: EglSwapBuffersWithDamageEXTImpl001
2289 * @tc.desc:
2290 * @tc.type: FUNC
2291 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageEXTImpl001,Level1)2292 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageEXTImpl001, Level1)
2293 {
2294 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageEXT(nullptr, nullptr, nullptr, 1);
2295 ASSERT_EQ(EGL_FALSE, result);
2296 }
2297
2298 /**
2299 * @tc.name: EglSwapBuffersWithDamageEXTImpl002
2300 * @tc.desc:
2301 * @tc.type: FUNC
2302 */
HWTEST_F(EglWrapperEntryTest,EglSwapBuffersWithDamageEXTImpl002,Level2)2303 HWTEST_F(EglWrapperEntryTest, EglSwapBuffersWithDamageEXTImpl002, Level2)
2304 {
2305 EGLint majorVersion;
2306 EGLint minorVersion;
2307 EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
2308 EGLBoolean ret = eglInitialize(dpy, &majorVersion, &minorVersion);
2309 ASSERT_EQ(ret, EGL_TRUE);
2310
2311 auto result = gWrapperHook.wrapper.eglSwapBuffersWithDamageEXT(dpy, nullptr, nullptr, 1);
2312 ASSERT_EQ(EGL_FALSE, result);
2313 }
2314
2315 /**
2316 * @tc.name: EglGetNativeClientBufferANDROIDImpl001
2317 * @tc.desc:
2318 * @tc.type: FUNC
2319 */
HWTEST_F(EglWrapperEntryTest,EglGetNativeClientBufferANDROIDImpl001,Level1)2320 HWTEST_F(EglWrapperEntryTest, EglGetNativeClientBufferANDROIDImpl001, Level1)
2321 {
2322 auto result = gWrapperHook.wrapper.eglGetNativeClientBufferANDROID(nullptr);
2323 ASSERT_EQ(EGL_FALSE, result);
2324 }
2325 } // OHOS::Rosen