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