1/*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "napi/native_api.h"
17#include "native_common.h"
18#include <ace/xcomponent/native_interface_xcomponent.h>
19#include <EGL/egl.h>
20#include <EGL/eglext.h>
21#include <EGL/eglplatform.h>
22#include <GLES3/gl3.h>
23#define NO_ERR 0
24#define SUCCESS 1
25#define FAIL (-1)
26#define TRUE 1
27#define FALSE 0
28#define RGB_SIZE 0x08
29#define INIT_WIDTH 0x08
30#define INIT_HEIGHT 0x08
31#define GL_CLIENT_VERSION 0x02
32#define GL_MAJOR_VERSION_2 0x02
33#define GL_MAJOR_VERSION_3 0x03
34#define GL_MINOR_VERSION_0 0x00
35#define EGL_ONE 0x01
36#define GL_VERSION_15 0x0F
37#define GL_MAJOR_VERSION_MARK 0x0A
38typedef struct _MyEGLWindow {
39    EGLDisplay eglDisplay;
40    EGLSurface eglLSurface;
41    EGLContext eglContext;
42    EGLConfig eglConfig;
43    EGLint eglVersion;
44} MyEGLWindow;
45
46static napi_value createMyEglWindow(napi_env env, MyEGLWindow *myEGLWindow)
47{
48    if (myEGLWindow == nullptr) {
49        return nullptr;
50    }
51    myEGLWindow->eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
52    NAPI_ASSERT(env, myEGLWindow->eglDisplay != EGL_NO_DISPLAY, "eglInitialize error");
53    EGLint majorVersion = GL_MAJOR_VERSION_2;
54    EGLint minorVersion = GL_MINOR_VERSION_0;
55    EGLBoolean Ret = eglInitialize(myEGLWindow->eglDisplay, &majorVersion, &minorVersion);
56    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglInitialize error");
57    myEGLWindow->eglVersion = majorVersion * GL_MAJOR_VERSION_MARK + minorVersion;
58    EGLint clientVersion = majorVersion == GL_MAJOR_VERSION_3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT;
59    const EGLint configAttribs[] = {
60        EGL_RED_SIZE,   RGB_SIZE, EGL_GREEN_SIZE,      RGB_SIZE,      EGL_BLUE_SIZE,    RGB_SIZE,
61        EGL_ALPHA_SIZE, RGB_SIZE, EGL_RENDERABLE_TYPE, clientVersion, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
62        EGL_NONE,       EGL_NONE};
63    EGLint numConfigs = 0x00;
64    Ret = eglChooseConfig(myEGLWindow->eglDisplay, configAttribs, &myEGLWindow->eglConfig, EGL_ONE, &numConfigs);
65    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglChooseConfig error");
66    const EGLint surfaceAttribs[] = {EGL_WIDTH,          INIT_WIDTH,       EGL_HEIGHT,         INIT_HEIGHT,
67                                     EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
68                                     EGL_NONE,           EGL_NONE};
69    myEGLWindow->eglLSurface = eglCreatePbufferSurface(myEGLWindow->eglDisplay, myEGLWindow->eglConfig, surfaceAttribs);
70    NAPI_ASSERT(env, myEGLWindow->eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
71    const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, GL_CLIENT_VERSION, EGL_NONE, EGL_NONE};
72    myEGLWindow->eglContext =
73        eglCreateContext(myEGLWindow->eglDisplay, myEGLWindow->eglConfig, EGL_NO_CONTEXT, contextAttribs);
74    NAPI_ASSERT(env, myEGLWindow->eglContext != EGL_NO_CONTEXT, "eglCreateContext error");
75    Ret = eglMakeCurrent(myEGLWindow->eglDisplay, myEGLWindow->eglLSurface, myEGLWindow->eglLSurface,
76                         myEGLWindow->eglContext);
77    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglMakeCurrent error");
78    return nullptr;
79}
80
81static napi_value destroyMyEglWindow(napi_env env, MyEGLWindow *myEGLWindow)
82{
83    if (myEGLWindow == nullptr) {
84        return nullptr;
85    }
86    if (myEGLWindow->eglDisplay != EGL_NO_DISPLAY) {
87        EGLBoolean Ret = eglTerminate(myEGLWindow->eglDisplay);
88        NAPI_ASSERT_BASE(env, Ret == EGL_TRUE, "eglTerminate error", EGL_FALSE);
89    }
90    myEGLWindow->eglDisplay = EGL_NO_DISPLAY;
91    myEGLWindow->eglLSurface = EGL_NO_SURFACE;
92    myEGLWindow->eglContext = EGL_NO_CONTEXT;
93    myEGLWindow->eglConfig = nullptr;
94    return nullptr;
95}
96
97static napi_value eglGetErrorInit()
98{
99    EGLint eglError = NO_ERR;
100    do {
101        eglError = eglGetError();
102    } while (eglError != EGL_SUCCESS);
103    return nullptr;
104}
105static const EGLint surfaceAttr[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
106
107static const EGLint confAttr[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
108                                  EGL_BLUE_SIZE,    8,
109                                  EGL_GREEN_SIZE,   8,
110                                  EGL_RED_SIZE,     8,
111                                  EGL_ALPHA_SIZE,   8,
112                                  EGL_DEPTH_SIZE,   16,
113                                  EGL_NONE};
114
115static napi_value EglChooseConfig(napi_env env, napi_callback_info info)
116{
117    EGLint numConfigs;
118    EGLConfig config = nullptr;
119    EGLint config_size = 1;
120    EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
121    NAPI_ASSERT(env, display != EGL_NO_DISPLAY, "eglGetDisplay error");
122    eglInitialize(display, nullptr, nullptr);
123    EGLBoolean Ret = eglChooseConfig(display, confAttr, &config, config_size, &numConfigs);
124    NAPI_ASSERT(env, Ret == TRUE, "eglChooseConfig error");
125    eglReleaseThread();
126    eglTerminate(display);
127    napi_value result = nullptr;
128    napi_create_int32(env, SUCCESS, &result);
129    return result;
130}
131
132static napi_value EglChooseConfigAbnormal(napi_env env, napi_callback_info info)
133{
134    EGLint numConfigs;
135    EGLConfig config = nullptr;
136    EGLDisplay display = nullptr;
137    EGLint config_size = 1;
138    EGLBoolean Ret = eglChooseConfig(display, confAttr, &config, config_size, &numConfigs);
139    NAPI_ASSERT(env, Ret == FALSE, "eglChooseConfig error");
140    napi_value result = nullptr;
141    napi_create_int32(env, SUCCESS, &result);
142    return result;
143}
144
145static napi_value EglCopyBuffersAbnormal(napi_env env, napi_callback_info info)
146{
147    EGLDisplay m_eglDisplay = nullptr;
148    EGLConfig m_eglConf = nullptr;
149    EGLint numConfigs;
150    EGLint config_size = 1;
151    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
152    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
153    eglInitialize(m_eglDisplay, nullptr, nullptr);
154
155    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
156    EGLSurface m_eglSurface = nullptr;
157    EGLNativePixmapType mNativeDisplay = 0;
158    EGLBoolean Ret = eglCopyBuffers(m_eglDisplay, m_eglSurface, mNativeDisplay);
159    NAPI_ASSERT(env, Ret == FALSE, "eglCopyBuffers error");
160    eglDestroySurface(m_eglDisplay, m_eglSurface);
161    eglReleaseThread();
162    eglTerminate(m_eglDisplay);
163    napi_value result = nullptr;
164    napi_create_int32(env, SUCCESS, &result);
165    return result;
166}
167
168static napi_value EglCreateContext(napi_env env, napi_callback_info info)
169{
170    EGLDisplay m_eglDisplay = nullptr;
171    EGLConfig m_eglConf = nullptr;
172    EGLint numConfigs;
173    EGLint config_size = 1;
174    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
175    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
176    eglInitialize(m_eglDisplay, nullptr, nullptr);
177
178    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
179
180    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
181    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
182    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
183    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
184    NAPI_ASSERT(env, m_eglCtx != EGL_NO_CONTEXT, "eglCreateContext error");
185    eglDestroyContext(m_eglDisplay, m_eglCtx);
186    eglDestroySurface(m_eglDisplay, m_eglSurface);
187    eglReleaseThread();
188    eglTerminate(m_eglDisplay);
189    napi_value result = nullptr;
190    napi_create_int32(env, SUCCESS, &result);
191    return result;
192}
193
194static napi_value EglCreateContextAbnormal(napi_env env, napi_callback_info info)
195{
196    EGLDisplay m_eglDisplay = nullptr;
197    EGLConfig m_eglConf = nullptr;
198    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
199    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
200    NAPI_ASSERT(env, m_eglCtx == EGL_NO_CONTEXT, "eglCreateContext error");
201    eglDestroyContext(m_eglDisplay, m_eglCtx);
202    eglReleaseThread();
203    eglTerminate(m_eglDisplay);
204    napi_value result = nullptr;
205    napi_create_int32(env, SUCCESS, &result);
206    return result;
207}
208
209static napi_value EglCreatePbufferSurface(napi_env env, napi_callback_info info)
210{
211    EGLDisplay m_eglDisplay = nullptr;
212    EGLConfig m_eglConf = nullptr;
213    EGLint numConfigs;
214    EGLint config_size = 1;
215    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
216    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
217    eglInitialize(m_eglDisplay, nullptr, nullptr);
218    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
219    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
220    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
221    eglDestroySurface(m_eglDisplay, m_eglSurface);
222    eglReleaseThread();
223    eglTerminate(m_eglDisplay);
224    napi_value result = nullptr;
225    napi_create_int32(env, SUCCESS, &result);
226    return result;
227}
228
229static napi_value EglCreatePbufferSurfaceAbnormal(napi_env env, napi_callback_info info)
230{
231    EGLDisplay m_eglDisplay = nullptr;
232    EGLConfig m_eglConf = nullptr;
233    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
234    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
235    eglInitialize(m_eglDisplay, nullptr, nullptr);
236    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
237    NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreatePbufferSurface error");
238    eglDestroySurface(m_eglDisplay, m_eglSurface);
239    eglReleaseThread();
240    eglTerminate(m_eglDisplay);
241    napi_value result = nullptr;
242    napi_create_int32(env, SUCCESS, &result);
243    return result;
244}
245
246static napi_value EglCreatePixmapSurfaceAbnormal(napi_env env, napi_callback_info info)
247{
248    EGLDisplay m_eglDisplay = nullptr;
249    EGLConfig m_eglConf = nullptr;
250    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
251    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
252    eglInitialize(m_eglDisplay, nullptr, nullptr);
253    EGLNativePixmapType pixmap = 0;
254    EGLSurface m_eglSurface = eglCreatePixmapSurface(m_eglDisplay, m_eglConf, pixmap, surfaceAttr);
255    NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreatePixmapSurface error");
256    eglDestroySurface(m_eglDisplay, m_eglSurface);
257    eglReleaseThread();
258    eglTerminate(m_eglDisplay);
259    napi_value result = nullptr;
260    napi_create_int32(env, SUCCESS, &result);
261    return result;
262}
263
264static napi_value EglCreateWindowSurfaceAbnormal(napi_env env, napi_callback_info info)
265{
266    EGLDisplay m_eglDisplay = nullptr;
267    EGLConfig m_eglConf = nullptr;
268    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
269    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
270    eglInitialize(m_eglDisplay, nullptr, nullptr);
271    NativeWindowType window = 0;
272    EGLSurface m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConf, window, surfaceAttr);
273    NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreateWindowSurface error");
274    eglDestroySurface(m_eglDisplay, m_eglSurface);
275    eglReleaseThread();
276    eglTerminate(m_eglDisplay);
277    napi_value result = nullptr;
278    napi_create_int32(env, SUCCESS, &result);
279    return result;
280}
281
282static napi_value EglDestroyContext(napi_env env, napi_callback_info info)
283{
284    EGLDisplay m_eglDisplay = nullptr;
285    EGLConfig m_eglConf = nullptr;
286    EGLint numConfigs;
287    EGLint config_size = 1;
288    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
289    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
290    eglInitialize(m_eglDisplay, nullptr, nullptr);
291
292    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
293
294    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
295    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
296    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
297    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
298    EGLBoolean Ret = eglDestroyContext(m_eglDisplay, m_eglCtx);
299    NAPI_ASSERT(env, Ret == TRUE, "eglDestroyContext error");
300    eglDestroySurface(m_eglDisplay, m_eglSurface);
301    eglReleaseThread();
302    eglTerminate(m_eglDisplay);
303    napi_value result = nullptr;
304    napi_create_int32(env, SUCCESS, &result);
305    return result;
306}
307
308static napi_value EglDestroyContextAbnormal(napi_env env, napi_callback_info info)
309{
310    EGLDisplay m_eglDisplay = nullptr;
311    EGLConfig m_eglConf = nullptr;
312    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, nullptr);
313    EGLBoolean Ret = eglDestroyContext(m_eglDisplay, m_eglCtx);
314    NAPI_ASSERT(env, Ret == FALSE, "eglDestroyContext error");
315    eglReleaseThread();
316    eglTerminate(m_eglDisplay);
317    napi_value result = nullptr;
318    napi_create_int32(env, SUCCESS, &result);
319    return result;
320}
321
322static napi_value EglDestroySurface(napi_env env, napi_callback_info info)
323{
324    EGLDisplay m_eglDisplay = nullptr;
325    EGLConfig m_eglConf = nullptr;
326    EGLint numConfigs;
327    EGLint config_size = 1;
328    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
329    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
330    eglInitialize(m_eglDisplay, nullptr, nullptr);
331    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
332
333    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
334    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
335    EGLBoolean Ret = eglDestroySurface(m_eglDisplay, m_eglSurface);
336    NAPI_ASSERT(env, Ret == TRUE, "eglDestroySurface error");
337    eglReleaseThread();
338    eglTerminate(m_eglDisplay);
339    napi_value result = nullptr;
340    napi_create_int32(env, SUCCESS, &result);
341    return result;
342}
343
344static napi_value EglDestroySurfaceAbnormal(napi_env env, napi_callback_info info)
345{
346    EGLDisplay m_eglDisplay = nullptr;
347    EGLConfig m_eglConf = nullptr;
348    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
349    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
350    eglInitialize(m_eglDisplay, nullptr, nullptr);
351
352    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
353
354    EGLBoolean Ret = eglDestroySurface(m_eglDisplay, m_eglSurface);
355    NAPI_ASSERT(env, Ret == FALSE, "eglDestroySurface error");
356    eglReleaseThread();
357    eglTerminate(m_eglDisplay);
358    napi_value result = nullptr;
359    napi_create_int32(env, SUCCESS, &result);
360    return result;
361}
362
363static napi_value EglGetConfigAttrib(napi_env env, napi_callback_info info)
364{
365    EGLDisplay m_eglDisplay = nullptr;
366    EGLConfig m_eglConf[10];
367    EGLint numConfigs;
368    EGLint config_size = 10;
369    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
370    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
371    eglInitialize(m_eglDisplay, nullptr, nullptr);
372
373    eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
374    EGLBoolean Ret;
375    for (int i = 0; i < numConfigs; ++i) {
376        Ret = eglGetConfigAttrib(m_eglDisplay, m_eglConf[i], EGL_ALPHA_SIZE, &numConfigs);
377    }
378    NAPI_ASSERT(env, Ret == TRUE, "eglGetConfigAttrib error");
379    eglReleaseThread();
380    eglTerminate(m_eglDisplay);
381    napi_value result = nullptr;
382    napi_create_int32(env, SUCCESS, &result);
383    return result;
384}
385
386static napi_value EglGetConfigAttribAbnormal(napi_env env, napi_callback_info info)
387{
388    EGLDisplay m_eglDisplay = nullptr;
389    EGLConfig m_eglConf[10];
390    EGLint numConfigs;
391    EGLint config_size = 10;
392    eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
393    EGLBoolean Ret;
394    for (int i = 0; i < numConfigs; ++i) {
395        Ret = eglGetConfigAttrib(m_eglDisplay, m_eglConf[i], EGL_BUFFER_SIZE, &numConfigs);
396    }
397    NAPI_ASSERT(env, Ret == FALSE, "eglGetConfigAttrib error");
398    eglReleaseThread();
399    eglTerminate(m_eglDisplay);
400    napi_value result = nullptr;
401    napi_create_int32(env, SUCCESS, &result);
402    return result;
403}
404
405static napi_value EglGetConfigs(napi_env env, napi_callback_info info)
406{
407    EGLDisplay m_eglDisplay = nullptr;
408    EGLConfig m_eglConf[10];
409    EGLint numConfigs;
410    EGLint config_size = 10;
411    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
412    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
413    eglInitialize(m_eglDisplay, nullptr, nullptr);
414
415    EGLBoolean Ret = eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
416    NAPI_ASSERT(env, Ret == TRUE, "eglGetConfigs error");
417    eglReleaseThread();
418    eglTerminate(m_eglDisplay);
419    napi_value result = nullptr;
420    napi_create_int32(env, SUCCESS, &result);
421    return result;
422}
423
424static napi_value EglGetConfigsAbnormal(napi_env env, napi_callback_info info)
425{
426    EGLDisplay m_eglDisplay = nullptr;
427    EGLConfig m_eglConf[10];
428    EGLint numConfigs;
429    EGLint config_size = 10;
430
431    EGLBoolean Ret = eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
432    NAPI_ASSERT(env, Ret == FALSE, "eglGetConfigs error");
433    eglReleaseThread();
434    eglTerminate(m_eglDisplay);
435    napi_value result = nullptr;
436    napi_create_int32(env, SUCCESS, &result);
437    return result;
438}
439
440static napi_value EglGetCurrentDisplay(napi_env env, napi_callback_info info)
441{
442    EGLDisplay m_eglDisplay = nullptr;
443    EGLConfig m_eglConf = nullptr;
444    EGLint numConfigs;
445    EGLint config_size = 1;
446    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
447    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
448    eglInitialize(m_eglDisplay, nullptr, nullptr);
449
450    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
451
452    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
453    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
454    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
455    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
456    eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
457    m_eglDisplay = eglGetCurrentDisplay();
458    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
459    eglDestroyContext(m_eglDisplay, m_eglCtx);
460    eglDestroySurface(m_eglDisplay, m_eglSurface);
461    eglReleaseThread();
462    eglTerminate(m_eglDisplay);
463    napi_value result = nullptr;
464    napi_create_int32(env, SUCCESS, &result);
465    return result;
466}
467
468static napi_value EglGetCurrentDisplayAbnormal(napi_env env, napi_callback_info info)
469{
470    EGLDisplay m_eglDisplay = nullptr;
471    m_eglDisplay = eglGetCurrentDisplay();
472    NAPI_ASSERT(env, m_eglDisplay == EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
473    eglReleaseThread();
474    eglTerminate(m_eglDisplay);
475    napi_value result = nullptr;
476    napi_create_int32(env, SUCCESS, &result);
477    return result;
478}
479
480static napi_value EglGetCurrentSurface(napi_env env, napi_callback_info info)
481{
482    EGLDisplay m_eglDisplay = nullptr;
483    EGLConfig m_eglConf = nullptr;
484    EGLint numConfigs;
485    EGLint config_size = 1;
486    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
487    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
488    eglInitialize(m_eglDisplay, nullptr, nullptr);
489
490    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
491
492    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
493    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
494    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
495    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
496    eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
497    m_eglDisplay = eglGetCurrentDisplay();
498    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
499    m_eglSurface = eglGetCurrentSurface(EGL_DRAW);
500    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglGetCurrentSurface error");
501    eglDestroyContext(m_eglDisplay, m_eglCtx);
502    eglDestroySurface(m_eglDisplay, m_eglSurface);
503    eglReleaseThread();
504    eglTerminate(m_eglDisplay);
505    napi_value result = nullptr;
506    napi_create_int32(env, SUCCESS, &result);
507    return result;
508}
509
510static napi_value EglGetCurrentSurfaceAbnormal(napi_env env, napi_callback_info info)
511{
512    eglGetCurrentDisplay();
513    EGLSurface m_eglSurface = eglGetCurrentSurface(EGL_DRAW);
514    NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglGetCurrentSurface error");
515    napi_value result = nullptr;
516    napi_create_int32(env, SUCCESS, &result);
517    return result;
518}
519
520static napi_value EglGetDisplay(napi_env env, napi_callback_info info)
521{
522    EGLDisplay m_eglDisplay = nullptr;
523    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
524    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
525    eglReleaseThread();
526    eglTerminate(m_eglDisplay);
527    napi_value result = nullptr;
528    napi_create_int32(env, SUCCESS, &result);
529    return result;
530}
531
532static napi_value EglGetError(napi_env env, napi_callback_info info)
533{
534    EGLDisplay m_eglDisplay = nullptr;
535    EGLConfig m_eglConf = nullptr;
536    eglGetErrorInit();
537    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
538    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
539    NAPI_ASSERT(env, m_eglCtx == EGL_NO_CONTEXT, "eglGetCurrentSurface error");
540    EGLint Ret = eglGetError();
541    NAPI_ASSERT(env, Ret == EGL_BAD_DISPLAY, "eglGetError error");
542    eglReleaseThread();
543    eglTerminate(m_eglDisplay);
544    napi_value result = nullptr;
545    napi_create_int32(env, SUCCESS, &result);
546    return result;
547}
548
549typedef EGLBoolean (*PFNCREATEIMAGEKHR)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const int *);
550static napi_value EglGetProcAddress(napi_env env, napi_callback_info info)
551{
552    EGLDisplay m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
553    PFNCREATEIMAGEKHR createImageKHR = (PFNCREATEIMAGEKHR)eglGetProcAddress("eglCreateImageKHR");
554    NAPI_ASSERT(env, createImageKHR != nullptr, "eglGetProcAddress error");
555    eglReleaseThread();
556    eglTerminate(m_eglDisplay);
557    napi_value result = nullptr;
558    napi_create_int32(env, SUCCESS, &result);
559    return result;
560}
561
562static napi_value EglGetProcAddressAbnormal(napi_env env, napi_callback_info info)
563{
564    PFNCREATEIMAGEKHR createImageKHR = (PFNCREATEIMAGEKHR)eglGetProcAddress("eglCreateImageKHR1");
565    NAPI_ASSERT(env, createImageKHR == nullptr, "eglGetProcAddress error");
566    napi_value result = nullptr;
567    napi_create_int32(env, SUCCESS, &result);
568    return result;
569}
570
571static napi_value EglInitialize(napi_env env, napi_callback_info info)
572{
573    EGLDisplay m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
574    EGLBoolean Ret = eglInitialize(m_eglDisplay, nullptr, nullptr);
575    NAPI_ASSERT(env, Ret == TRUE, "eglGetProcAddress error");
576    eglReleaseThread();
577    eglTerminate(m_eglDisplay);
578    napi_value result = nullptr;
579    napi_create_int32(env, SUCCESS, &result);
580    return result;
581}
582
583static napi_value EglInitializeAbnormal(napi_env env, napi_callback_info info)
584{
585    EGLDisplay m_eglDisplay = nullptr;
586    EGLBoolean Ret = eglInitialize(m_eglDisplay, nullptr, nullptr);
587    NAPI_ASSERT(env, Ret == FALSE, "eglGetProcAddress error");
588    eglReleaseThread();
589    eglTerminate(m_eglDisplay);
590    napi_value result = nullptr;
591    napi_create_int32(env, SUCCESS, &result);
592    return result;
593}
594
595static napi_value EglMakeCurrent(napi_env env, napi_callback_info info)
596{
597    EGLDisplay m_eglDisplay = nullptr;
598    EGLConfig m_eglConf = nullptr;
599    EGLint numConfigs;
600    EGLint config_size = 1;
601    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
602    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
603    eglInitialize(m_eglDisplay, nullptr, nullptr);
604
605    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
606
607    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
608    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
609    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
610    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
611    EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
612    NAPI_ASSERT(env, Ret == TRUE, "eglMakeCurrent error");
613    eglDestroyContext(m_eglDisplay, m_eglCtx);
614    eglDestroySurface(m_eglDisplay, m_eglSurface);
615    eglReleaseThread();
616    eglTerminate(m_eglDisplay);
617    napi_value result = nullptr;
618    napi_create_int32(env, SUCCESS, &result);
619    return result;
620}
621
622static napi_value EglMakeCurrentAbnormal(napi_env env, napi_callback_info info)
623{
624    EGLDisplay m_eglDisplay = nullptr;
625    EGLSurface m_eglSurface = nullptr;
626    EGLContext m_eglCtx = nullptr;
627    EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
628    NAPI_ASSERT(env, Ret == FALSE, "eglMakeCurrent error");
629    eglDestroyContext(m_eglDisplay, m_eglCtx);
630    eglDestroySurface(m_eglDisplay, m_eglSurface);
631    eglReleaseThread();
632    eglTerminate(m_eglDisplay);
633    napi_value result = nullptr;
634    napi_create_int32(env, SUCCESS, &result);
635    return result;
636}
637
638static napi_value EglQueryContext(napi_env env, napi_callback_info info)
639{
640    EGLDisplay m_eglDisplay = nullptr;
641    EGLConfig m_eglConf = nullptr;
642    EGLint numConfigs;
643    EGLint config_size = 1;
644    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
645    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
646    eglInitialize(m_eglDisplay, nullptr, nullptr);
647
648    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
649
650    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
651    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
652    const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
653    EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
654    EGLBoolean Ret = eglQueryContext(m_eglDisplay, m_eglCtx, EGL_CONTEXT_CLIENT_VERSION, &numConfigs);
655    NAPI_ASSERT(env, Ret == TRUE, "eglQueryContext error");
656    eglDestroyContext(m_eglDisplay, m_eglCtx);
657    eglDestroySurface(m_eglDisplay, m_eglSurface);
658    eglReleaseThread();
659    eglTerminate(m_eglDisplay);
660    napi_value result = nullptr;
661    napi_create_int32(env, SUCCESS, &result);
662    return result;
663}
664
665static napi_value EglQueryContextAbnormal(napi_env env, napi_callback_info info)
666{
667    EGLDisplay m_eglDisplay = nullptr;
668    EGLConfig m_eglConf = nullptr;
669    EGLint numConfigs;
670    EGLint config_size = 1;
671    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
672    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
673    eglInitialize(m_eglDisplay, nullptr, nullptr);
674
675    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
676
677    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
678    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
679    EGLContext m_eglCtx = nullptr;
680    EGLBoolean Ret = eglQueryContext(m_eglDisplay, m_eglCtx, EGL_CONTEXT_CLIENT_VERSION, &numConfigs);
681    NAPI_ASSERT(env, Ret == FALSE, "eglQueryContext error");
682    eglDestroyContext(m_eglDisplay, m_eglCtx);
683    eglDestroySurface(m_eglDisplay, m_eglSurface);
684    eglReleaseThread();
685    eglTerminate(m_eglDisplay);
686    napi_value result = nullptr;
687    napi_create_int32(env, SUCCESS, &result);
688    return result;
689}
690
691static napi_value EglQueryString(napi_env env, napi_callback_info info)
692{
693    EGLDisplay m_eglDisplay = nullptr;
694    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
695    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
696    eglInitialize(m_eglDisplay, nullptr, nullptr);
697    const char *vendor = eglQueryString(m_eglDisplay, EGL_VENDOR);
698    NAPI_ASSERT(env, vendor != nullptr, "eglQueryString error");
699
700    eglTerminate(m_eglDisplay);
701    napi_value result = nullptr;
702    napi_create_int32(env, SUCCESS, &result);
703    return result;
704}
705
706static napi_value EglQueryStringAbnormal(napi_env env, napi_callback_info info)
707{
708    EGLDisplay m_eglDisplay = nullptr;
709    const char *vendor = eglQueryString(m_eglDisplay, EGL_VENDOR);
710    NAPI_ASSERT(env, vendor == nullptr, "eglQueryString error");
711
712    eglTerminate(m_eglDisplay);
713    napi_value result = nullptr;
714    napi_create_int32(env, SUCCESS, &result);
715    return result;
716}
717
718static napi_value EglQuerySurface(napi_env env, napi_callback_info info)
719{
720    EGLDisplay m_eglDisplay = nullptr;
721    EGLConfig m_eglConf = nullptr;
722    EGLint numConfigs;
723    EGLint config_size = 1;
724    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
725    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
726    eglInitialize(m_eglDisplay, nullptr, nullptr);
727    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
728
729    EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
730    NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
731    EGLint width;
732    EGLBoolean Ret = eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
733    NAPI_ASSERT(env, Ret == TRUE, "eglQuerySurface error");
734    eglDestroySurface(m_eglDisplay, m_eglSurface);
735    eglReleaseThread();
736    eglTerminate(m_eglDisplay);
737    napi_value result = nullptr;
738    napi_create_int32(env, SUCCESS, &result);
739    return result;
740}
741
742static napi_value EglQuerySurfaceAbnormal(napi_env env, napi_callback_info info)
743{
744    EGLDisplay m_eglDisplay = nullptr;
745    EGLConfig m_eglConf = nullptr;
746    EGLint numConfigs;
747    EGLint config_size = 1;
748    m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
749    NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
750    eglInitialize(m_eglDisplay, nullptr, nullptr);
751    eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
752
753    EGLSurface m_eglSurface = nullptr;
754    EGLint width;
755    EGLBoolean Ret = eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
756    NAPI_ASSERT(env, Ret == FALSE, "eglQuerySurface error");
757    napi_value result = nullptr;
758    napi_create_int32(env, SUCCESS, &result);
759    return result;
760}
761
762static napi_value EglSwapBuffers(napi_env env, napi_callback_info info)
763{
764    (void)info;
765    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
766    createMyEglWindow(env, &myEGLWindow);
767    EGLBoolean Ret = eglSwapBuffers(myEGLWindow.eglDisplay, myEGLWindow.eglLSurface);
768    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSwapBuffers error");
769    destroyMyEglWindow(env, &myEGLWindow);
770    napi_value result = nullptr;
771    napi_create_int32(env, SUCCESS, &result);
772    return result;
773}
774
775static napi_value EglSwapBuffersAbnormal(napi_env env, napi_callback_info info)
776{
777    (void)info;
778    eglGetErrorInit();
779    EGLBoolean Ret = eglSwapBuffers(EGL_NO_DISPLAY, EGL_NO_SURFACE);
780    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetError error");
781    EGLint eglError = eglGetError();
782    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
783    napi_value result = nullptr;
784    napi_create_int32(env, SUCCESS, &result);
785    return result;
786}
787
788static napi_value EglTerminate(napi_env env, napi_callback_info info)
789{
790    (void)info;
791    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
792    createMyEglWindow(env, &myEGLWindow);
793    EGLBoolean Ret = eglTerminate(myEGLWindow.eglDisplay);
794    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglTerminate error");
795    napi_value result = nullptr;
796    napi_create_int32(env, SUCCESS, &result);
797    return result;
798}
799
800static napi_value EglTerminateAbnormal(napi_env env, napi_callback_info info)
801{
802    (void)info;
803    eglGetErrorInit();
804    EGLBoolean Ret = eglTerminate(EGL_NO_DISPLAY);
805    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetError error");
806    EGLint eglError = eglGetError();
807    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
808    napi_value result = nullptr;
809    napi_create_int32(env, SUCCESS, &result);
810    return result;
811}
812
813static napi_value EglWaitGL(napi_env env, napi_callback_info info)
814{
815    (void)info;
816    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
817    createMyEglWindow(env, &myEGLWindow);
818    EGLBoolean Ret = eglWaitGL();
819    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitGL error");
820    destroyMyEglWindow(env, &myEGLWindow);
821    napi_value result = nullptr;
822    napi_create_int32(env, SUCCESS, &result);
823    return result;
824}
825
826static napi_value EglWaitNative(napi_env env, napi_callback_info info)
827{
828    (void)info;
829    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
830    createMyEglWindow(env, &myEGLWindow);
831    EGLBoolean Ret = eglWaitNative(EGL_CORE_NATIVE_ENGINE);
832    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitNative error");
833    destroyMyEglWindow(env, &myEGLWindow);
834    napi_value result = nullptr;
835    napi_create_int32(env, SUCCESS, &result);
836    return result;
837}
838
839static napi_value EglBindTexImage(napi_env env, napi_callback_info info)
840{
841    (void)info;
842    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
843    createMyEglWindow(env, &myEGLWindow);
844    const EGLint surfaceAttribs[] = {EGL_WIDTH,          INIT_WIDTH,       EGL_HEIGHT,         INIT_HEIGHT,
845                                     EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
846                                     EGL_NONE,           EGL_NONE};
847    EGLSurface eglLSurface = eglCreatePbufferSurface(myEGLWindow.eglDisplay, myEGLWindow.eglConfig, surfaceAttribs);
848    NAPI_ASSERT(env, eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
849    GLuint texture = GL_ZERO;
850    glGenTextures(GL_ONE, &texture);
851    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
852    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
853    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
854    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
855    EGLBoolean Ret = eglBindTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
856    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindTexImage error");
857    Ret = eglReleaseTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
858    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseTexImage error");
859    Ret = eglDestroySurface(myEGLWindow.eglDisplay, eglLSurface);
860    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySurface error");
861    destroyMyEglWindow(env, &myEGLWindow);
862    napi_value result = nullptr;
863    napi_create_int32(env, SUCCESS, &result);
864    return result;
865}
866
867static napi_value EglBindTexImageAbnormal(napi_env env, napi_callback_info info)
868{
869    (void)info;
870    EGLBoolean Ret = eglBindTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, 0x00);
871    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindTexImage error");
872    napi_value result = nullptr;
873    napi_create_int32(env, SUCCESS, &result);
874    return result;
875}
876
877static napi_value EglReleaseTexImage(napi_env env, napi_callback_info info)
878{
879    (void)info;
880    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
881    createMyEglWindow(env, &myEGLWindow);
882    const EGLint surfaceAttribs[] = {EGL_WIDTH,          INIT_WIDTH,       EGL_HEIGHT,         INIT_HEIGHT,
883                                     EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
884                                     EGL_NONE,           EGL_NONE};
885    EGLSurface eglLSurface = eglCreatePbufferSurface(myEGLWindow.eglDisplay, myEGLWindow.eglConfig, surfaceAttribs);
886    NAPI_ASSERT(env, eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
887    GLuint texture = GL_ZERO;
888    glGenTextures(GL_ONE, &texture);
889    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
890    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
891    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
892    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
893    EGLBoolean Ret = eglBindTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
894    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindTexImage error");
895    Ret = eglReleaseTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
896    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseTexImage error");
897    Ret = eglDestroySurface(myEGLWindow.eglDisplay, eglLSurface);
898    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySurface error");
899    destroyMyEglWindow(env, &myEGLWindow);
900    napi_value result = nullptr;
901    napi_create_int32(env, SUCCESS, &result);
902    return result;
903}
904
905static napi_value EglReleaseTexImageAbnormal(napi_env env, napi_callback_info info)
906{
907    (void)info;
908    EGLBoolean Ret = eglReleaseTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, 0x00);
909    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglReleaseTexImage error");
910    napi_value result = nullptr;
911    napi_create_int32(env, SUCCESS, &result);
912    return result;
913}
914
915static napi_value EglSurfaceAttrib(napi_env env, napi_callback_info info)
916{
917    (void)info;
918    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
919    createMyEglWindow(env, &myEGLWindow);
920    EGLBoolean Ret = eglSurfaceAttrib(myEGLWindow.eglDisplay, myEGLWindow.eglLSurface, EGL_MIPMAP_LEVEL, EGL_ONE);
921    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSurfaceAttrib error");
922    destroyMyEglWindow(env, &myEGLWindow);
923    napi_value result = nullptr;
924    napi_create_int32(env, SUCCESS, &result);
925    return result;
926}
927
928static napi_value EglSurfaceAttribAbnormal(napi_env env, napi_callback_info info)
929{
930    (void)info;
931    eglGetErrorInit();
932    EGLBoolean Ret = eglSurfaceAttrib(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_MIPMAP_LEVEL, EGL_ONE);
933    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglSurfaceAttrib error");
934    EGLint eglError = eglGetError();
935    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
936    napi_value result = nullptr;
937    napi_create_int32(env, SUCCESS, &result);
938    return result;
939}
940
941static napi_value EglSwapInterval(napi_env env, napi_callback_info info)
942{
943    (void)info;
944    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
945    createMyEglWindow(env, &myEGLWindow);
946    EGLBoolean Ret = eglSwapInterval(myEGLWindow.eglDisplay, EGL_ONE);
947    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSwapInterval error");
948    destroyMyEglWindow(env, &myEGLWindow);
949    napi_value result = nullptr;
950    napi_create_int32(env, SUCCESS, &result);
951    return result;
952}
953
954static napi_value EglSwapIntervalAbnormal(napi_env env, napi_callback_info info)
955{
956    (void)info;
957    eglGetErrorInit();
958    EGLBoolean Ret = eglSwapInterval(EGL_NO_DISPLAY, EGL_ONE);
959    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglSwapInterval error");
960    EGLint eglError = eglGetError();
961    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
962    napi_value result = nullptr;
963    napi_create_int32(env, SUCCESS, &result);
964    return result;
965}
966
967static napi_value EglBindAPI(napi_env env, napi_callback_info info)
968{
969    (void)info;
970    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
971    createMyEglWindow(env, &myEGLWindow);
972    EGLBoolean Ret = eglBindAPI(EGL_OPENGL_ES_API);
973    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindAPI error");
974    destroyMyEglWindow(env, &myEGLWindow);
975    napi_value result = nullptr;
976    napi_create_int32(env, SUCCESS, &result);
977    return result;
978}
979
980static napi_value EglBindAPIAbnormal(napi_env env, napi_callback_info info)
981{
982    (void)info;
983    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
984    createMyEglWindow(env, &myEGLWindow);
985    EGLBoolean Ret = eglBindAPI(EGL_OPENGL_API);
986    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindAPI error");
987    Ret = eglBindAPI(EGL_OPENVG_API);
988    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindAPI error");
989    destroyMyEglWindow(env, &myEGLWindow);
990    napi_value result = nullptr;
991    napi_create_int32(env, SUCCESS, &result);
992    return result;
993}
994
995static napi_value EglQueryAPI(napi_env env, napi_callback_info info)
996{
997    (void)info;
998    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
999    createMyEglWindow(env, &myEGLWindow);
1000    NAPI_ASSERT(env, eglQueryAPI() == EGL_OPENGL_ES_API, "eglQueryAPI error");
1001    destroyMyEglWindow(env, &myEGLWindow);
1002    napi_value result = nullptr;
1003    napi_create_int32(env, SUCCESS, &result);
1004    return result;
1005}
1006
1007static napi_value EglCreatePbufferFromClientBufferAbnormal(napi_env env, napi_callback_info info)
1008{
1009    (void)info;
1010    eglGetErrorInit();
1011    EGLSurface eglSurface =
1012        eglCreatePbufferFromClientBuffer(EGL_NO_DISPLAY, EGL_OPENVG_IMAGE, nullptr, nullptr, nullptr);
1013    NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePbufferFromClientBuffer error");
1014    EGLint eglError = eglGetError();
1015    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1016    napi_value result = nullptr;
1017    napi_create_int32(env, SUCCESS, &result);
1018    return result;
1019}
1020
1021static napi_value EglReleaseThread(napi_env env, napi_callback_info info)
1022{
1023    (void)info;
1024    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1025    createMyEglWindow(env, &myEGLWindow);
1026    EGLBoolean Ret = eglReleaseThread();
1027    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseThread error");
1028    destroyMyEglWindow(env, &myEGLWindow);
1029    napi_value result = nullptr;
1030    napi_create_int32(env, SUCCESS, &result);
1031    return result;
1032}
1033
1034static napi_value EglWaitClient(napi_env env, napi_callback_info info)
1035{
1036    (void)info;
1037    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1038    createMyEglWindow(env, &myEGLWindow);
1039    EGLBoolean Ret = eglWaitClient();
1040    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitClient error");
1041    destroyMyEglWindow(env, &myEGLWindow);
1042    napi_value result = nullptr;
1043    napi_create_int32(env, SUCCESS, &result);
1044    return result;
1045}
1046
1047static napi_value EglGetCurrentContext(napi_env env, napi_callback_info info)
1048{
1049    (void)info;
1050    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1051    createMyEglWindow(env, &myEGLWindow);
1052    EGLContext eglContext = eglGetCurrentContext();
1053    NAPI_ASSERT(env, eglContext != EGL_NO_CONTEXT, "eglGetCurrentContext error");
1054    destroyMyEglWindow(env, &myEGLWindow);
1055    napi_value result = nullptr;
1056    napi_create_int32(env, SUCCESS, &result);
1057    return result;
1058}
1059
1060static napi_value EglCreateSync(napi_env env, napi_callback_info info)
1061{
1062    (void)info;
1063    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1064    createMyEglWindow(env, &myEGLWindow);
1065    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1066        const EGLAttrib attr[] = {EGL_NONE};
1067        EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1068        NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1069        EGLBoolean Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1070        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1071    }
1072    destroyMyEglWindow(env, &myEGLWindow);
1073    napi_value result = nullptr;
1074    napi_create_int32(env, SUCCESS, &result);
1075    return result;
1076}
1077
1078static napi_value EglCreateSyncAbnormal(napi_env env, napi_callback_info info)
1079{
1080    (void)info;
1081    eglGetErrorInit();
1082    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1083    createMyEglWindow(env, &myEGLWindow);
1084    EGLSync eglSync = eglCreateSync(EGL_NO_DISPLAY, EGL_SYNC_FENCE, nullptr);
1085    NAPI_ASSERT(env, eglSync == EGL_NO_SYNC, "eglCreateSync error");
1086    EGLint eglError = eglGetError();
1087    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1088    destroyMyEglWindow(env, &myEGLWindow);
1089    napi_value result = nullptr;
1090    napi_create_int32(env, SUCCESS, &result);
1091    return result;
1092}
1093
1094static napi_value EglDestroySync(napi_env env, napi_callback_info info)
1095{
1096    (void)info;
1097    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1098    createMyEglWindow(env, &myEGLWindow);
1099    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1100        const EGLAttrib attr[] = {EGL_NONE};
1101        EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1102        NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1103        EGLBoolean Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1104        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1105    }
1106    destroyMyEglWindow(env, &myEGLWindow);
1107    napi_value result = nullptr;
1108    napi_create_int32(env, SUCCESS, &result);
1109    return result;
1110}
1111
1112static napi_value EglDestroySyncAbnormal(napi_env env, napi_callback_info info)
1113{
1114    (void)info;
1115    eglGetErrorInit();
1116    EGLBoolean Ret = eglDestroySync(EGL_NO_DISPLAY, EGL_NO_SYNC);
1117    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglDestroySync error");
1118    EGLint eglError = eglGetError();
1119    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1120    napi_value result = nullptr;
1121    napi_create_int32(env, SUCCESS, &result);
1122    return result;
1123}
1124
1125static napi_value EglClientWaitSync(napi_env env, napi_callback_info info)
1126{
1127    (void)info;
1128    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1129    createMyEglWindow(env, &myEGLWindow);
1130    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1131        const EGLAttrib attr[] = {EGL_NONE};
1132        EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1133        NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1134        EGLBoolean Ret = eglClientWaitSync(myEGLWindow.eglDisplay, eglSync, 0x00, EGL_FOREVER);
1135        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglClientWaitSync error");
1136        Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1137        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1138    }
1139    destroyMyEglWindow(env, &myEGLWindow);
1140    napi_value result = nullptr;
1141    napi_create_int32(env, SUCCESS, &result);
1142    return result;
1143}
1144
1145static napi_value EglClientWaitSyncAbnormal(napi_env env, napi_callback_info info)
1146{
1147    (void)info;
1148    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1149    createMyEglWindow(env, &myEGLWindow);
1150    EGLBoolean Ret = eglClientWaitSync(myEGLWindow.eglDisplay, EGL_NO_SYNC, 0x00, EGL_FOREVER);
1151    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglClientWaitSync error");
1152    napi_value result = nullptr;
1153    napi_create_int32(env, SUCCESS, &result);
1154    return result;
1155}
1156
1157static napi_value EglGetSyncAttrib(napi_env env, napi_callback_info info)
1158{
1159    (void)info;
1160    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1161    createMyEglWindow(env, &myEGLWindow);
1162    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1163        const EGLAttrib attr[] = {EGL_NONE};
1164        EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1165        NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1166        EGLAttrib value[1] = {0x00};
1167        EGLBoolean Ret = eglGetSyncAttrib(myEGLWindow.eglDisplay, eglSync, EGL_SYNC_TYPE, value);
1168        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglGetSyncAttrib error");
1169        Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1170        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1171    }
1172    destroyMyEglWindow(env, &myEGLWindow);
1173    napi_value result = nullptr;
1174    napi_create_int32(env, SUCCESS, &result);
1175    return result;
1176}
1177
1178static napi_value EglGetSyncAttribAbnormal(napi_env env, napi_callback_info info)
1179{
1180    (void)info;
1181    eglGetErrorInit();
1182    EGLAttrib value[1] = {0x00};
1183    EGLBoolean Ret = eglGetSyncAttrib(EGL_NO_DISPLAY, EGL_NO_SYNC, EGL_SYNC_TYPE, value);
1184    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetSyncAttrib error");
1185    EGLint eglError = eglGetError();
1186    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1187    napi_value result = nullptr;
1188    napi_create_int32(env, SUCCESS, &result);
1189    return result;
1190}
1191
1192static napi_value EglCreateImage(napi_env env, napi_callback_info info)
1193{
1194    (void)info;
1195    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1196    createMyEglWindow(env, &myEGLWindow);
1197    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1198        int texture = EGL_ONE;
1199        glBindTexture(GL_TEXTURE_2D, texture);
1200        glTexImage2D(GL_TEXTURE_2D, 0x00, GL_RGBA, INIT_WIDTH, INIT_HEIGHT, 0x00, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
1201        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1202        const EGLAttrib eglAttrib[] = {EGL_GL_TEXTURE_LEVEL, 0x00, EGL_NONE};
1203        EGLImage image = eglCreateImage(myEGLWindow.eglDisplay, myEGLWindow.eglContext, EGL_GL_TEXTURE_2D,
1204                                        (void *)(static_cast<intptr_t>(texture)), eglAttrib);
1205        NAPI_ASSERT(env, image != EGL_NO_IMAGE, "eglCreateImage error");
1206        EGLBoolean Ret = eglDestroyImage(myEGLWindow.eglDisplay, image);
1207        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroyImage error");
1208    }
1209    destroyMyEglWindow(env, &myEGLWindow);
1210    napi_value result = nullptr;
1211    napi_create_int32(env, SUCCESS, &result);
1212    return result;
1213}
1214
1215static napi_value EglCreateImageAbnormal(napi_env env, napi_callback_info info)
1216{
1217    (void)info;
1218    eglGetErrorInit();
1219    EGLImage image = eglCreateImage(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_GL_TEXTURE_2D, nullptr, nullptr);
1220    NAPI_ASSERT(env, image == EGL_NO_IMAGE, "eglCreateImage error");
1221    EGLint eglError = eglGetError();
1222    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1223    napi_value result = nullptr;
1224    napi_create_int32(env, SUCCESS, &result);
1225    return result;
1226}
1227
1228static napi_value EglDestroyImage(napi_env env, napi_callback_info info)
1229{
1230    (void)info;
1231    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1232    createMyEglWindow(env, &myEGLWindow);
1233    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1234        int texture = EGL_ONE;
1235        glBindTexture(GL_TEXTURE_2D, texture);
1236        glTexImage2D(GL_TEXTURE_2D, 0x00, GL_RGBA, INIT_WIDTH, INIT_HEIGHT, 0x00, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
1237        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1238        const EGLAttrib eglAttrib[] = {EGL_GL_TEXTURE_LEVEL, 0x00, EGL_NONE};
1239        EGLImage image = eglCreateImage(myEGLWindow.eglDisplay, myEGLWindow.eglContext, EGL_GL_TEXTURE_2D,
1240                                        (void *)(static_cast<intptr_t>(texture)), eglAttrib);
1241        NAPI_ASSERT(env, image != EGL_NO_IMAGE, "eglCreateImage error");
1242        EGLBoolean Ret = eglDestroyImage(myEGLWindow.eglDisplay, image);
1243        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroyImage error");
1244    }
1245    destroyMyEglWindow(env, &myEGLWindow);
1246    napi_value result = nullptr;
1247    napi_create_int32(env, SUCCESS, &result);
1248    return result;
1249}
1250
1251static napi_value EglDestroyImageAbnormal(napi_env env, napi_callback_info info)
1252{
1253    (void)info;
1254    eglGetErrorInit();
1255    EGLBoolean Ret = eglDestroyImage(EGL_NO_DISPLAY, EGL_NO_IMAGE);
1256    NAPI_ASSERT(env, Ret != EGL_TRUE, "eglDestroyImage error");
1257    EGLint eglError = eglGetError();
1258    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1259    napi_value result = nullptr;
1260    napi_create_int32(env, SUCCESS, &result);
1261    return result;
1262}
1263
1264static napi_value EglGetPlatformDisplay(napi_env env, napi_callback_info info)
1265{
1266    (void)info;
1267    EGLDisplay eglDisplay = eglGetPlatformDisplay(EGL_PLATFORM_OHOS_KHR, EGL_DEFAULT_DISPLAY, nullptr);
1268    NAPI_ASSERT(env, eglDisplay != EGL_NO_DISPLAY, "eglGetPlatformDisplay error");
1269    EGLBoolean Ret = eglTerminate(eglDisplay);
1270    NAPI_ASSERT(env, Ret == EGL_TRUE, "eglTerminate error");
1271    napi_value result = nullptr;
1272    napi_create_int32(env, SUCCESS, &result);
1273    return result;
1274}
1275
1276static napi_value EglGetPlatformDisplayAbnormal(napi_env env, napi_callback_info info)
1277{
1278    (void)info;
1279    eglGetErrorInit();
1280    EGLDisplay eglDisplay = eglGetPlatformDisplay(0x00, nullptr, nullptr);
1281    NAPI_ASSERT(env, eglDisplay == EGL_NO_DISPLAY, "eglGetPlatformDisplay error");
1282    EGLint eglError = eglGetError();
1283    NAPI_ASSERT(env, eglError == EGL_BAD_PARAMETER, "eglGetError error");
1284    napi_value result = nullptr;
1285    napi_create_int32(env, SUCCESS, &result);
1286    return result;
1287}
1288
1289static napi_value EglCreatePlatformWindowSurfaceAbnormal(napi_env env, napi_callback_info info)
1290{
1291    (void)info;
1292    eglGetErrorInit();
1293    EGLSurface eglSurface = eglCreatePlatformWindowSurface(EGL_NO_DISPLAY, nullptr, nullptr, nullptr);
1294    NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePlatformWindowSurface error");
1295    EGLint eglError = eglGetError();
1296    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1297    napi_value result = nullptr;
1298    napi_create_int32(env, SUCCESS, &result);
1299    return result;
1300}
1301
1302static napi_value EglCreatePlatformPixmapSurfaceAbnormal(napi_env env, napi_callback_info info)
1303{
1304    (void)info;
1305    eglGetErrorInit();
1306    EGLSurface eglSurface = eglCreatePlatformPixmapSurface(EGL_NO_DISPLAY, nullptr, nullptr, nullptr);
1307    NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePlatformPixmapSurface error");
1308    EGLint eglError = eglGetError();
1309    NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1310    napi_value result = nullptr;
1311    napi_create_int32(env, SUCCESS, &result);
1312    return result;
1313}
1314
1315static napi_value EglWaitSync(napi_env env, napi_callback_info info)
1316{
1317    (void)info;
1318    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1319    createMyEglWindow(env, &myEGLWindow);
1320    if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1321        const EGLAttrib attr[] = {EGL_NONE};
1322        EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1323        NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1324        EGLBoolean Ret = eglWaitSync(myEGLWindow.eglDisplay, eglSync, 0x00);
1325        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitSync error");
1326        Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1327        NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1328    }
1329    destroyMyEglWindow(env, &myEGLWindow);
1330    napi_value result = nullptr;
1331    napi_create_int32(env, SUCCESS, &result);
1332    return result;
1333}
1334
1335static napi_value EglWaitSyncAbnormal(napi_env env, napi_callback_info info)
1336{
1337    (void)info;
1338    MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1339    createMyEglWindow(env, &myEGLWindow);
1340    EGLBoolean Ret = eglWaitSync(myEGLWindow.eglDisplay, EGL_NO_SYNC, EGL_ONE);
1341    NAPI_ASSERT(env, Ret == EGL_FALSE, "eglWaitSync error");
1342    destroyMyEglWindow(env, &myEGLWindow);
1343    napi_value result = nullptr;
1344    napi_create_int32(env, SUCCESS, &result);
1345    return result;
1346}
1347
1348EXTERN_C_START
1349static napi_value Init(napi_env env, napi_value exports)
1350{
1351    napi_property_descriptor desc[] = {
1352        {"eglChooseConfig", nullptr, EglChooseConfig, nullptr, nullptr, nullptr, napi_default, nullptr},
1353        {"eglChooseConfigAbnormal", nullptr, EglChooseConfigAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1354        {"eglCopyBuffersAbnormal", nullptr, EglCopyBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1355        {"eglCreateContext", nullptr, EglCreateContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1356        {"eglCreateContextAbnormal", nullptr, EglCreateContextAbnormal, nullptr, nullptr, nullptr, napi_default,
1357         nullptr},
1358        {"eglCreatePbufferSurface", nullptr, EglCreatePbufferSurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1359        {"eglCreatePbufferSurfaceAbnormal", nullptr, EglCreatePbufferSurfaceAbnormal, nullptr, nullptr, nullptr,
1360         napi_default, nullptr},
1361        {"eglCreatePixmapSurfaceAbnormal", nullptr, EglCreatePixmapSurfaceAbnormal, nullptr, nullptr, nullptr,
1362         napi_default, nullptr},
1363        {"eglCreateWindowSurfaceAbnormal", nullptr, EglCreateWindowSurfaceAbnormal, nullptr, nullptr, nullptr,
1364         napi_default, nullptr},
1365        {"eglDestroyContext", nullptr, EglDestroyContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1366        {"eglDestroyContextAbnormal", nullptr, EglDestroyContextAbnormal, nullptr, nullptr, nullptr, napi_default,
1367         nullptr},
1368        {"eglDestroySurface", nullptr, EglDestroySurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1369        {"eglDestroySurfaceAbnormal", nullptr, EglDestroySurfaceAbnormal, nullptr, nullptr, nullptr, napi_default,
1370         nullptr},
1371        {"eglGetConfigAttrib", nullptr, EglGetConfigAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1372        {"eglGetConfigAttribAbnormal", nullptr, EglGetConfigAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1373         nullptr},
1374        {"eglGetConfigs", nullptr, EglGetConfigs, nullptr, nullptr, nullptr, napi_default, nullptr},
1375        {"eglGetConfigsAbnormal", nullptr, EglGetConfigsAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1376        {"eglGetCurrentDisplay", nullptr, EglGetCurrentDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1377        {"eglGetCurrentDisplayAbnormal", nullptr, EglGetCurrentDisplayAbnormal, nullptr, nullptr, nullptr, napi_default,
1378         nullptr},
1379        {"eglGetCurrentSurface", nullptr, EglGetCurrentSurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1380        {"eglGetCurrentSurfaceAbnormal", nullptr, EglGetCurrentSurfaceAbnormal, nullptr, nullptr, nullptr, napi_default,
1381         nullptr},
1382        {"eglGetDisplay", nullptr, EglGetDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1383        {"eglGetError", nullptr, EglGetError, nullptr, nullptr, nullptr, napi_default, nullptr},
1384        {"eglGetProcAddress", nullptr, EglGetProcAddress, nullptr, nullptr, nullptr, napi_default, nullptr},
1385        {"eglGetProcAddressAbnormal", nullptr, EglGetProcAddressAbnormal, nullptr, nullptr, nullptr, napi_default,
1386         nullptr},
1387        {"eglInitialize", nullptr, EglInitialize, nullptr, nullptr, nullptr, napi_default, nullptr},
1388        {"eglInitializeAbnormal", nullptr, EglInitializeAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1389        {"eglMakeCurrent", nullptr, EglMakeCurrent, nullptr, nullptr, nullptr, napi_default, nullptr},
1390        {"eglMakeCurrentAbnormal", nullptr, EglMakeCurrentAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1391        {"eglQueryContext", nullptr, EglQueryContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1392        {"eglQueryContextAbnormal", nullptr, EglQueryContextAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1393        {"eglQueryString", nullptr, EglQueryString, nullptr, nullptr, nullptr, napi_default, nullptr},
1394        {"eglQueryStringAbnormal", nullptr, EglQueryStringAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1395        {"eglQuerySurface", nullptr, EglQuerySurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1396        {"eglQuerySurfaceAbnormal", nullptr, EglQuerySurfaceAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1397        {"eglSwapBuffers", nullptr, EglSwapBuffers, nullptr, nullptr, nullptr, napi_default, nullptr},
1398        {"eglSwapBuffersAbnormal", nullptr, EglSwapBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1399        {"eglTerminate", nullptr, EglTerminate, nullptr, nullptr, nullptr, napi_default, nullptr},
1400        {"eglTerminateAbnormal", nullptr, EglTerminateAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1401        {"eglWaitGL", nullptr, EglWaitGL, nullptr, nullptr, nullptr, napi_default, nullptr},
1402        {"eglWaitNative", nullptr, EglWaitNative, nullptr, nullptr, nullptr, napi_default, nullptr},
1403        {"eglBindTexImage", nullptr, EglBindTexImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1404        {"eglBindTexImageAbnormal", nullptr, EglBindTexImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1405        {"eglReleaseTexImage", nullptr, EglReleaseTexImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1406        {"eglReleaseTexImageAbnormal", nullptr, EglReleaseTexImageAbnormal, nullptr, nullptr, nullptr, napi_default,
1407         nullptr},
1408        {"eglSurfaceAttrib", nullptr, EglSurfaceAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1409        {"eglSurfaceAttribAbnormal", nullptr, EglSurfaceAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1410         nullptr},
1411        {"eglSwapInterval", nullptr, EglSwapInterval, nullptr, nullptr, nullptr, napi_default, nullptr},
1412        {"eglSwapIntervalAbnormal", nullptr, EglSwapIntervalAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1413        {"eglBindAPI", nullptr, EglBindAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
1414        {"eglBindAPIAbnormal", nullptr, EglBindAPIAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1415        {"eglQueryAPI", nullptr, EglQueryAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
1416        {"eglCreatePbufferFromClientBufferAbnormal", nullptr, EglCreatePbufferFromClientBufferAbnormal, nullptr,
1417         nullptr, nullptr, napi_default, nullptr},
1418        {"eglReleaseThread", nullptr, EglReleaseThread, nullptr, nullptr, nullptr, napi_default, nullptr},
1419        {"eglWaitClient", nullptr, EglWaitClient, nullptr, nullptr, nullptr, napi_default, nullptr},
1420        {"eglGetCurrentContext", nullptr, EglGetCurrentContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1421        {"eglCreateSync", nullptr, EglCreateSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1422        {"eglCreateSyncAbnormal", nullptr, EglCreateSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1423        {"eglDestroySync", nullptr, EglDestroySync, nullptr, nullptr, nullptr, napi_default, nullptr},
1424        {"eglDestroySyncAbnormal", nullptr, EglDestroySyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1425        {"eglClientWaitSync", nullptr, EglClientWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1426        {"eglClientWaitSyncAbnormal", nullptr, EglClientWaitSyncAbnormal, nullptr, nullptr, nullptr, napi_default,
1427         nullptr},
1428        {"eglGetSyncAttrib", nullptr, EglGetSyncAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1429        {"eglGetSyncAttribAbnormal", nullptr, EglGetSyncAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1430         nullptr},
1431        {"eglCreateImage", nullptr, EglCreateImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1432        {"eglCreateImageAbnormal", nullptr, EglCreateImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1433        {"eglDestroyImage", nullptr, EglDestroyImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1434        {"eglDestroyImageAbnormal", nullptr, EglDestroyImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1435        {"eglGetPlatformDisplay", nullptr, EglGetPlatformDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1436        {"eglGetPlatformDisplayAbnormal", nullptr, EglGetPlatformDisplayAbnormal, nullptr, nullptr, nullptr,
1437         napi_default, nullptr},
1438        {"eglCreatePlatformWindowSurfaceAbnormal", nullptr, EglCreatePlatformWindowSurfaceAbnormal, nullptr, nullptr,
1439         nullptr, napi_default, nullptr},
1440        {"eglCreatePlatformPixmapSurfaceAbnormal", nullptr, EglCreatePlatformPixmapSurfaceAbnormal, nullptr, nullptr,
1441         nullptr, napi_default, nullptr},
1442        {"eglWaitSync", nullptr, EglWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1443        {"eglWaitSyncAbnormal", nullptr, EglWaitSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1444    };
1445    napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1446    return exports;
1447}
1448EXTERN_C_END
1449
1450static napi_module demoModule = {
1451    .nm_version = 1,
1452    .nm_flags = 0,
1453    .nm_filename = nullptr,
1454    .nm_register_func = Init,
1455    .nm_modname = "eglndk",
1456    .nm_priv = ((void *)0),
1457    .reserved = {0},
1458};
1459
1460extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
1461