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 "common/napi_helper.cpp"
17 #include "common/native_common.h"
18 #include "napi/native_api.h"
19 #include <cerrno>
20 #include <cfloat>
21 #include <clocale>
22 #include <cmath>
23 #include <cstdarg>
24 #include <cstdio>
25 #include <cstdlib>
26 #include <cstring>
27 #include <fcntl.h>
28 #include <malloc.h>
29 #include <unistd.h>
30 
31 #define PARAM_0 0
32 #define PARAM_1 1
33 #define MPARAM_1 (-1)
34 #define PARAM_2 2
35 #define PARAM_10 10
36 #define PARAM_31 31
37 #define PARAM_3 3
38 #define PARAM_5 5
39 #define PARAM_16 16
40 #define PARAM_60 60
41 #define PARAM_13 13
42 #define PARAM_99 99
43 #define PARAM_123 123
44 #define PARAM_20 20
45 #define PARAM_50 50
46 #define PARAM_100 100
47 #define PARAM_0777 0777
48 #define PARAM_1024 1024
49 #define PARAM_11 11
50 #define PARAM_321 321
51 #define PARAM_4 4
52 #define PARAM_31416 3.1416
53 #define PARAM_31416F 3.1416f
54 #define SIZEOF_CHAR(x) (sizeof(x) / sizeof(char))
55 
56 static const char *g_tempFile = "/data/storage/el2/base/files/fzl.txt";
57 static const char *g_tempLinkFile = "/data/storage/el2/base/files/fzl_link.txt";
58 static const char *TEMP_FILE_NEW = "/data/storage/el2/base/files/fzl_new.txt";
59 
60 extern "C" char *__fgets_chk(char *, int, FILE *, size_t);
Fgets_chk_One(napi_env env, napi_callback_info info)61 static napi_value Fgets_chk_One(napi_env env, napi_callback_info info)
62 {
63     FILE *fp = fopen(g_tempFile, "w+");
64     NAPI_ASSERT(env, fp != nullptr, "__fgets_chk fopen Error");
65     char src[] = "testfgetschk";
66     int len = strlen(src) + PARAM_1;
67     fputs(src, fp);
68     fseek(fp, PARAM_0, SEEK_SET);
69     char dest[100] = {0};
70     char *ret = __fgets_chk(dest, len, fp, sizeof(dest));
71     NAPI_ASSERT(env, ret != nullptr, "__fgets_chk Error");
72     fclose(fp);
73     remove(g_tempFile);
74     napi_value result = nullptr;
75     napi_create_int32(env, strcmp(dest, src) == PARAM_0, &result);
76     return result;
77 }
78 
79 extern "C" size_t __fread_chk(void *, size_t, size_t, FILE *, size_t);
Fread_Chk_One(napi_env env, napi_callback_info info)80 static napi_value Fread_Chk_One(napi_env env, napi_callback_info info)
81 {
82     FILE *fp = fopen(g_tempFile, "w+");
83     NAPI_ASSERT(env, fp != nullptr, "__fread_chk fopen Error");
84     char src[] = "testfreadchk";
85     fputs(src, fp);
86     fseek(fp, PARAM_0, SEEK_SET);
87     char dest[100] = {0};
88     size_t ret = __fread_chk(dest, PARAM_1, PARAM_20, fp, sizeof(dest));
89     NAPI_ASSERT(env, ret == strlen(src), "__fread_chk Error");
90     fclose(fp);
91     remove(g_tempFile);
92     napi_value result = nullptr;
93     napi_create_int32(env, strcmp(dest, src) == PARAM_0, &result);
94     return result;
95 }
96 
97 extern "C" ssize_t __pwrite_chk(int fd, const void *buf, size_t count, off_t offset, size_t buf_size);
Pwrite_Chk_One(napi_env env, napi_callback_info info)98 static napi_value Pwrite_Chk_One(napi_env env, napi_callback_info info)
99 {
100     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
101     FILE *fp = fdopen(fd, "w+");
102     NAPI_ASSERT(env, fp != nullptr, "__pwrite_chk fopen Error");
103     char src[100] = "testpwritechk";
104     size_t ret = __pwrite_chk(fd, src, strlen(src), PARAM_0, sizeof(src));
105     NAPI_ASSERT(env, ret == strlen(src), "__pwrite_chk Error");
106     fseek(fp, PARAM_0, SEEK_SET);
107     char dest[100] = {0};
108     __fread_chk(dest, PARAM_1, PARAM_20, fp, sizeof(dest));
109     fclose(fp);
110     remove(g_tempFile);
111     napi_value result = nullptr;
112     napi_create_int32(env, strcmp(dest, src) == PARAM_0, &result);
113     return result;
114 }
115 
116 extern "C" ssize_t __readlinkat_chk(int dirfd, const char *path, char *buf, size_t size, size_t buf_size);
Readlinkat_Chk_One(napi_env env, napi_callback_info info)117 static napi_value Readlinkat_Chk_One(napi_env env, napi_callback_info info)
118 {
119     FILE *fp = fopen(g_tempFile, "w+");
120     NAPI_ASSERT(env, fp != nullptr, "__readlinkat_chk fopen Error");
121     char src[100] = "testreadlinkatchk";
122     fputs(src, fp);
123     fseek(fp, PARAM_0, SEEK_SET);
124     int linkRet = symlink(g_tempFile, g_tempLinkFile);
125     NAPI_ASSERT(env, linkRet == PARAM_0, "Readlinkat_Chk_One symlink Error");
126     int fd = open(g_tempLinkFile, O_RDWR);
127     char dest[100] = {0};
128     size_t ret = __readlinkat_chk(fd, g_tempLinkFile, dest, strlen(src), sizeof(dest));
129     NAPI_ASSERT(env, strlen(dest) > PARAM_0, "__readlinkat_chk Error");
130     fclose(fp);
131     unlink(g_tempLinkFile);
132     unlink(g_tempFile);
133     remove(g_tempFile);
134     napi_value result = nullptr;
135     napi_create_int32(env, ret == strlen(src), &result);
136     return result;
137 }
138 
139 extern "C" int __snprintf_chk(char *dest, size_t supplied_size, int flags, size_t dst_len_from_compiler,
140                               const char *format, ...);
141 
Snprintf_Chk_One(napi_env env, napi_callback_info info)142 static napi_value Snprintf_Chk_One(napi_env env, napi_callback_info info)
143 {
144     char dest[100] = {0};
145     char src[] = "hello";
146     int ret = __snprintf_chk(dest, PARAM_50, PARAM_0, sizeof(dest), "%s", src);
147     if (ret == PARAM_5 && strcmp(dest, src) == 0) {
148         ret = PARAM_1;
149     }
150     napi_value result = nullptr;
151     napi_create_int32(env, ret, &result);
152     return result;
153 }
154 
155 extern "C" int __sprintf_chk(char *dest, int flags, size_t dst_len_from_compiler, const char *format, ...);
156 
Sprintf_Chk_One(napi_env env, napi_callback_info info)157 static napi_value Sprintf_Chk_One(napi_env env, napi_callback_info info)
158 {
159     char dest[100] = {0};
160     char src[] = "hello";
161     int ret = __sprintf_chk(dest, PARAM_0, sizeof(dest), "%s", src);
162     if (ret == PARAM_5 && strcmp(dest, src) == 0) {
163         ret = PARAM_1;
164     }
165     napi_value result = nullptr;
166     napi_create_int32(env, ret, &result);
167     return result;
168 }
169 
170 extern "C" int __vsnprintf_chk(char *dest, size_t supplied_size, int flags, size_t dst_len_from_compiler,
171                                const char *format, va_list va);
172 extern "C" int VsnprintfChkTest(const char *format, ...);
VsnprintfChkTest(const char *format, ...)173 int VsnprintfChkTest(const char *format, ...)
174 {
175     char dest[100] = {0};
176     va_list args;
177     va_start(args, format);
178     int ret = __vsnprintf_chk(dest, PARAM_50, PARAM_0, sizeof(dest), format, args);
179     va_end(args);
180     return ret;
181 }
182 
Vsnprintf_Chk_One(napi_env env, napi_callback_info info)183 static napi_value Vsnprintf_Chk_One(napi_env env, napi_callback_info info)
184 {
185     size_t ret = MPARAM_1;
186     char src[] = "hello";
187     ret = VsnprintfChkTest("%s", src);
188     napi_value result = nullptr;
189     napi_create_int32(env, ret == strlen(src), &result);
190     return result;
191 }
192 
193 extern "C" ssize_t __write_chk(int fd, const void *buf, size_t count, size_t buf_size);
Write_Chk_One(napi_env env, napi_callback_info info)194 static napi_value Write_Chk_One(napi_env env, napi_callback_info info)
195 {
196     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
197     FILE *fp = fdopen(fd, "w+");
198     NAPI_ASSERT(env, fp != nullptr, "__readlinkat_chk fopen Error");
199     char src[100] = "testwritechkchk";
200     int len = strlen(src) + PARAM_1;
201     size_t ret = __write_chk(fd, src, len, sizeof(src));
202     fseek(fp, PARAM_0, SEEK_SET);
203     char readBuf[100] = {0};
204     fgets(readBuf, len, fp);
205     fclose(fp);
206     remove(g_tempFile);
207     napi_value result = nullptr;
208     napi_create_int32(env, ret == strlen(readBuf) + PARAM_1, &result);
209     return result;
210 }
211 
Asprintf_One(napi_env env, napi_callback_info info)212 static napi_value Asprintf_One(napi_env env, napi_callback_info info)
213 {
214     char buf[] = "d";
215     char *testStr = nullptr;
216     int ret = MPARAM_1;
217     ret = asprintf(&testStr, "%s", buf);
218     ;
219     if (testStr) {
220         free(testStr);
221         testStr = nullptr;
222     }
223     napi_value result = nullptr;
224     napi_create_int32(env, ret, &result);
225     return result;
226 }
227 
ClearErr_One(napi_env env, napi_callback_info info)228 static napi_value ClearErr_One(napi_env env, napi_callback_info info)
229 {
230     int fd = open(g_tempFile, O_CREAT | O_RDONLY);
231     FILE *fp = fdopen(fd, "r+");
232     NAPI_ASSERT(env, fp != nullptr, "ClearErr_One fopen Error");
233     fputc('a', fp);
234     if (ferror(fp)) {
235         clearerr(fp);
236     }
237     int ret = MPARAM_1;
238     if (ferror(fp)) {
239         ret = PARAM_0;
240     } else {
241         ret = PARAM_1;
242     }
243     fclose(fp);
244     remove(g_tempFile);
245     napi_value result = nullptr;
246     napi_create_int32(env, ret, &result);
247     return result;
248 }
249 
Clearerr_Unlocked_One(napi_env env, napi_callback_info info)250 static napi_value Clearerr_Unlocked_One(napi_env env, napi_callback_info info)
251 {
252     int fd = open(g_tempFile, O_CREAT | O_RDONLY);
253     FILE *fp = fdopen(fd, "r+");
254     NAPI_ASSERT(env, fp != nullptr, "clearerr_unlocked open Error");
255     fputc('a', fp);
256     if (ferror_unlocked(fp)) {
257         clearerr_unlocked(fp);
258     }
259     int ret = MPARAM_1;
260     if (ferror_unlocked(fp)) {
261         ret = PARAM_0;
262     } else {
263         ret = PARAM_1;
264     }
265     fclose(fp);
266     remove(g_tempFile);
267     napi_value result = nullptr;
268     napi_create_int32(env, ret, &result);
269     return result;
270 }
271 
Dprintf_One(napi_env env, napi_callback_info info)272 static napi_value Dprintf_One(napi_env env, napi_callback_info info)
273 {
274     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
275     FILE *fp = fdopen(fd, "w");
276     NAPI_ASSERT(env, fp != nullptr, "dprintf open Error");
277     int ret = dprintf(fd, "%s", "hello world");
278     NAPI_ASSERT(env, ret > PARAM_0, "dprintf dprintf Error");
279     fclose(fp);
280     remove(g_tempFile);
281     napi_value result = nullptr;
282     napi_create_int32(env, ret == PARAM_11, &result);
283     return result;
284 }
285 
Fclose_One(napi_env env, napi_callback_info info)286 static napi_value Fclose_One(napi_env env, napi_callback_info info)
287 {
288     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
289     FILE *fp = fdopen(fd, "w");
290     NAPI_ASSERT(env, fp != nullptr, "fclose open Error");
291     fprintf(fp, "hello world");
292     int ret = fclose(fp);
293     remove(g_tempFile);
294     napi_value result = nullptr;
295     napi_create_int32(env, ret == PARAM_0, &result);
296     return result;
297 }
298 
Fdopen_One(napi_env env, napi_callback_info info)299 static napi_value Fdopen_One(napi_env env, napi_callback_info info)
300 {
301     errno = PARAM_0;
302     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
303     FILE *fp = fdopen(fd, "w");
304     NAPI_ASSERT(env, fp != nullptr, "fdopen open Error");
305     fprintf(fp, "hello world");
306     fclose(fp);
307     remove(g_tempFile);
308     napi_value result = nullptr;
309     napi_create_int32(env, errno == PARAM_0, &result);
310     return result;
311 }
312 
Feof_unlocked_One(napi_env env, napi_callback_info info)313 static napi_value Feof_unlocked_One(napi_env env, napi_callback_info info)
314 {
315     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
316     FILE *fp = fdopen(fd, "w+");
317     NAPI_ASSERT(env, fp != nullptr, "feof_unlocked fopen Error");
318     char src[] = "hello";
319     int ret = MPARAM_1;
320     fputs_unlocked(src, fp);
321     rewind(fp);
322     while (fgetc_unlocked(fp) != EOF) {
323     }
324     if (feof_unlocked(fp)) {
325         ret = PARAM_1;
326     }
327     fclose(fp);
328     remove(g_tempFile);
329     napi_value result = nullptr;
330     napi_create_int32(env, ret, &result);
331     return result;
332 }
333 
Ferror_One(napi_env env, napi_callback_info info)334 static napi_value Ferror_One(napi_env env, napi_callback_info info)
335 {
336     int fd = open(g_tempFile, O_CREAT | O_RDONLY);
337     FILE *fp = fdopen(fd, "r+");
338     NAPI_ASSERT(env, fp != nullptr, "ferror open Error");
339     fputc('a', fp);
340     int ret = MPARAM_1;
341     if (ferror(fp)) {
342         clearerr(fp);
343         ret = PARAM_1;
344     }
345     if (ferror(fp)) {
346         ret = PARAM_0;
347     } else {
348         ret = PARAM_1;
349     }
350     fclose(fp);
351     remove(g_tempFile);
352     napi_value result = nullptr;
353     napi_create_int32(env, ret, &result);
354     return result;
355 }
356 
Ferror_unlocked_One(napi_env env, napi_callback_info info)357 static napi_value Ferror_unlocked_One(napi_env env, napi_callback_info info)
358 {
359     int fd = open(g_tempFile, O_CREAT | O_RDONLY);
360     FILE *fp = fdopen(fd, "r+");
361     NAPI_ASSERT(env, fp != nullptr, "ferror_unlocked open Error");
362     fputc('a', fp);
363     int ret = MPARAM_1;
364     if (ferror_unlocked(fp)) {
365         clearerr_unlocked(fp);
366         ret = PARAM_1;
367     }
368     if (ferror_unlocked(fp)) {
369         ret = PARAM_0;
370     } else {
371         ret = PARAM_1;
372     }
373     fclose(fp);
374     remove(g_tempFile);
375     napi_value result = nullptr;
376     napi_create_int32(env, ret, &result);
377     return result;
378 }
379 
Fflush_One(napi_env env, napi_callback_info info)380 static napi_value Fflush_One(napi_env env, napi_callback_info info)
381 {
382     char dest[20] = {0};
383     FILE *fp = fopen(g_tempFile, "w+");
384     NAPI_ASSERT(env, fp != nullptr, "fflush fopen Error");
385     fputs("hello", fp);
386     fflush(fp);
387     rewind(fp);
388     fgets(dest, sizeof(dest), fp);
389     fclose(fp);
390     remove(g_tempFile);
391     napi_value result = nullptr;
392     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
393     return result;
394 }
395 
Fflush_unlocked_One(napi_env env, napi_callback_info info)396 static napi_value Fflush_unlocked_One(napi_env env, napi_callback_info info)
397 {
398     char dest[20] = {0};
399     FILE *fp = fopen(g_tempFile, "w+");
400     NAPI_ASSERT(env, fp != nullptr, "fflush_unlocked fopen Error");
401     fputs_unlocked("hello", fp);
402     fflush_unlocked(fp);
403     rewind(fp);
404     fgets_unlocked(dest, sizeof(dest), fp);
405     fclose(fp);
406     remove(g_tempFile);
407     napi_value result = nullptr;
408     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
409     return result;
410 }
411 
Fgetc_One(napi_env env, napi_callback_info info)412 static napi_value Fgetc_One(napi_env env, napi_callback_info info)
413 {
414     FILE *fp = fopen(g_tempFile, "w+");
415     NAPI_ASSERT(env, fp != nullptr, "fgetc fopen Error");
416     fputc('a', fp);
417     rewind(fp);
418     int ret = fgetc(fp);
419     fclose(fp);
420     remove(g_tempFile);
421     napi_value result = nullptr;
422     napi_create_int32(env, ret == 'a', &result);
423     return result;
424 }
425 
Fgetc_unlocked_One(napi_env env, napi_callback_info info)426 static napi_value Fgetc_unlocked_One(napi_env env, napi_callback_info info)
427 {
428     FILE *fp = fopen(g_tempFile, "w+");
429     NAPI_ASSERT(env, fp != nullptr, "fgetc_unlocked fopen Error");
430     fputc_unlocked('a', fp);
431     rewind(fp);
432     int ret = fgetc_unlocked(fp);
433     fclose(fp);
434     remove(g_tempFile);
435     napi_value result = nullptr;
436     napi_create_int32(env, ret == 'a', &result);
437     return result;
438 }
439 
Fgetin_One(napi_env env, napi_callback_info info)440 static napi_value Fgetin_One(napi_env env, napi_callback_info info)
441 {
442     FILE *fp = fopen(g_tempFile, "w+");
443     NAPI_ASSERT(env, fp != nullptr, "fgetin fopen Error");
444     fputs("helloworld", fp);
445     rewind(fp);
446     size_t plen = PARAM_0;
447     char *ret = fgetln(fp, &plen);
448     napi_value result = nullptr;
449     napi_create_int32(env, strcmp(ret, "helloworld") == PARAM_0 && strlen(ret) == plen, &result);
450     fclose(fp);
451     remove(g_tempFile);
452     return result;
453 }
454 
Fgetpos_One(napi_env env, napi_callback_info info)455 static napi_value Fgetpos_One(napi_env env, napi_callback_info info)
456 {
457     fpos_t pos;
458     FILE *fp = fopen(g_tempFile, "w");
459     NAPI_ASSERT(env, fp != nullptr, "fgetpos fopen Error");
460     fputs("helloworld", fp);
461     fseek(fp, PARAM_0, SEEK_END);
462     int ret = fgetpos(fp, &pos);
463     NAPI_ASSERT(env, ret == PARAM_0, "fgetpos Error");
464     rewind(fp);
465     ret = fgetpos(fp, &pos);
466     fclose(fp);
467     remove(g_tempFile);
468     napi_value result = nullptr;
469     napi_create_int32(env, ret == PARAM_0, &result);
470     return result;
471 }
472 
Fgetpos64_One(napi_env env, napi_callback_info info)473 static napi_value Fgetpos64_One(napi_env env, napi_callback_info info)
474 {
475     fpos64_t pos;
476     FILE *fp = fopen(g_tempFile, "w");
477     NAPI_ASSERT(env, fp != nullptr, "fgetpos64 fopen Error");
478     fputs("helloworld", fp);
479     fseek(fp, PARAM_0, SEEK_END);
480     int ret = fgetpos64(fp, &pos);
481     NAPI_ASSERT(env, ret == PARAM_0, "fgetpos64 Error");
482     rewind(fp);
483     ret = fgetpos64(fp, &pos);
484     fclose(fp);
485     remove(g_tempFile);
486     napi_value result = nullptr;
487     napi_create_int32(env, ret == PARAM_0, &result);
488     return result;
489 }
490 
Fgets_One(napi_env env, napi_callback_info info)491 static napi_value Fgets_One(napi_env env, napi_callback_info info)
492 {
493     char dest[20] = {0};
494     FILE *fp = fopen(g_tempFile, "w+");
495     NAPI_ASSERT(env, fp != nullptr, "fgets fopen Error");
496     fputs("hello", fp);
497     rewind(fp);
498     fgets(&dest[0], sizeof(dest), fp);
499     fclose(fp);
500     remove(g_tempFile);
501     napi_value result = nullptr;
502     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
503     return result;
504 }
505 
Fgets_unlocked_One(napi_env env, napi_callback_info info)506 static napi_value Fgets_unlocked_One(napi_env env, napi_callback_info info)
507 {
508     char dest[20] = {0};
509     FILE *fp = fopen(g_tempFile, "w+");
510     NAPI_ASSERT(env, fp != nullptr, "fgets_unlocked fopen Error");
511     fputs_unlocked("hello", fp);
512     rewind(fp);
513     fgets_unlocked(&dest[0], sizeof(dest), fp);
514     fclose(fp);
515     remove(g_tempFile);
516     napi_value result = nullptr;
517     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
518     return result;
519 }
520 
Fileno_One(napi_env env, napi_callback_info info)521 static napi_value Fileno_One(napi_env env, napi_callback_info info)
522 {
523     FILE *fp = fopen(g_tempFile, "w+");
524     NAPI_ASSERT(env, fp != nullptr, "fileno_unlocked fopen Error");
525     int ret = MPARAM_1;
526     if (fileno_unlocked(fp) == fileno(fp)) {
527         ret = PARAM_1;
528     }
529     fclose(fp);
530     remove(g_tempFile);
531     napi_value result = nullptr;
532     napi_create_int32(env, ret, &result);
533     return result;
534 }
535 
Fileno_unlocked_One(napi_env env, napi_callback_info info)536 static napi_value Fileno_unlocked_One(napi_env env, napi_callback_info info)
537 {
538     FILE *fp = fopen(g_tempFile, "w+");
539     NAPI_ASSERT(env, fp != nullptr, "fileno_unlocked fopen Error");
540     int ret = MPARAM_1;
541     if (fileno(fp) == fileno_unlocked(fp)) {
542         ret = PARAM_1;
543     }
544     fclose(fp);
545     remove(g_tempFile);
546     napi_value result = nullptr;
547     napi_create_int32(env, ret, &result);
548     return result;
549 }
550 
Flockfile_One(napi_env env, napi_callback_info info)551 static napi_value Flockfile_One(napi_env env, napi_callback_info info)
552 {
553     errno = PARAM_0;
554     puts("start do_child_one");
555     flockfile(stdout);
556     puts("after first flockfile");
557     flockfile(stdout);
558     puts("foo");
559     funlockfile(stdout);
560     puts("after first funlockfile");
561     funlockfile(stdout);
562     puts("all done");
563     napi_value result = nullptr;
564     napi_create_int32(env, errno == PARAM_0, &result);
565     return result;
566 }
567 
Fmemopen_One(napi_env env, napi_callback_info info)568 static napi_value Fmemopen_One(napi_env env, napi_callback_info info)
569 {
570     char src[] = "helloworld";
571     FILE *fp = fmemopen(src, sizeof(src), "r");
572     NAPI_ASSERT(env, fp != nullptr, "fmemopen Error");
573     const int bufferSize = PARAM_16;
574     char buf[bufferSize];
575     char *ret = fgets(buf, sizeof(buf), fp);
576     NAPI_ASSERT(env, ret != nullptr, "fmemopen fgets Error");
577     fclose(fp);
578     napi_value result = nullptr;
579     napi_create_int32(env, strcmp(src, ret) == PARAM_0, &result);
580     return result;
581 }
582 
Fopen_One(napi_env env, napi_callback_info info)583 static napi_value Fopen_One(napi_env env, napi_callback_info info)
584 {
585     errno = PARAM_0;
586     FILE *fp = fopen(g_tempFile, "w");
587     NAPI_ASSERT(env, fp != nullptr, "fopen Error");
588     fputc('a', fp);
589     fclose(fp);
590     remove(g_tempFile);
591     napi_value result = nullptr;
592     napi_create_int32(env, errno == PARAM_0, &result);
593     return result;
594 }
595 
Fopen64_One(napi_env env, napi_callback_info info)596 static napi_value Fopen64_One(napi_env env, napi_callback_info info)
597 {
598     errno = PARAM_0;
599     FILE *fp = fopen64(g_tempFile, "w");
600     NAPI_ASSERT(env, fp != nullptr, "fopen64 Error");
601     fputc('a', fp);
602     fclose(fp);
603     remove(g_tempFile);
604     napi_value result = nullptr;
605     napi_create_int32(env, errno == PARAM_0, &result);
606     return result;
607 }
608 
Fprintf_One(napi_env env, napi_callback_info info)609 static napi_value Fprintf_One(napi_env env, napi_callback_info info)
610 {
611     FILE *fp = fopen(g_tempFile, "w+");
612     NAPI_ASSERT(env, fp != nullptr, "fprintf fopen Error");
613     fprintf(fp, "%s", "helloworld");
614     int ret = MPARAM_1;
615     if (!ferror(fp)) {
616         ret = PARAM_1;
617     }
618     fclose(fp);
619     remove(g_tempFile);
620     napi_value result = nullptr;
621     napi_create_int32(env, ret == PARAM_1, &result);
622     return result;
623 }
624 
625 extern "C" int fpurge(FILE *);
Fpurge_One(napi_env env, napi_callback_info info)626 static napi_value Fpurge_One(napi_env env, napi_callback_info info)
627 {
628     FILE *fp = fopen(g_tempFile, "w+");
629     NAPI_ASSERT(env, fp != nullptr, "fpurge fopen Error");
630     fputs("helloworld", fp);
631     int ret = fpurge(fp);
632     fclose(fp);
633     remove(g_tempFile);
634     napi_value result = nullptr;
635     napi_create_int32(env, ret == PARAM_0, &result);
636     return result;
637 }
638 
Fputc_One(napi_env env, napi_callback_info info)639 static napi_value Fputc_One(napi_env env, napi_callback_info info)
640 {
641     FILE *fp = fopen(g_tempFile, "w+");
642     NAPI_ASSERT(env, fp != nullptr, "fputc fopen Error");
643     int ret = fputc('a', fp);
644     fclose(fp);
645     remove(g_tempFile);
646     napi_value result = nullptr;
647     napi_create_int32(env, ret == 'a', &result);
648     return result;
649 }
650 
Fputc_unlocked_One(napi_env env, napi_callback_info info)651 static napi_value Fputc_unlocked_One(napi_env env, napi_callback_info info)
652 {
653     FILE *fp = fopen(g_tempFile, "w+");
654     NAPI_ASSERT(env, fp != nullptr, "fputc_unlocked fopen Error");
655     int ret = fputc_unlocked('a', fp);
656     fclose(fp);
657     remove(g_tempFile);
658     napi_value result = nullptr;
659     napi_create_int32(env, ret == 'a', &result);
660     return result;
661 }
662 
Fputs_One(napi_env env, napi_callback_info info)663 static napi_value Fputs_One(napi_env env, napi_callback_info info)
664 {
665     char dest[20] = {0};
666     FILE *fp = fopen(g_tempFile, "w+");
667     NAPI_ASSERT(env, fp != nullptr, "fputs fopen Error");
668     fputs("hello", fp);
669     rewind(fp);
670     fgets(dest, sizeof(dest), fp);
671     fclose(fp);
672     remove(g_tempFile);
673     napi_value result = nullptr;
674     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
675     return result;
676 }
677 
Fputs_unlocked_One(napi_env env, napi_callback_info info)678 static napi_value Fputs_unlocked_One(napi_env env, napi_callback_info info)
679 {
680     char dest[20] = {0};
681     FILE *fp = fopen(g_tempFile, "w+");
682     NAPI_ASSERT(env, fp != nullptr, "fputs_unlocked fopen Error");
683     fputs_unlocked("hello", fp);
684     rewind(fp);
685     fgets_unlocked(dest, sizeof(dest), fp);
686     fclose(fp);
687     remove(g_tempFile);
688     napi_value result = nullptr;
689     napi_create_int32(env, strcmp(dest, "hello") == PARAM_0, &result);
690     return result;
691 }
692 
Fread_One(napi_env env, napi_callback_info info)693 static napi_value Fread_One(napi_env env, napi_callback_info info)
694 {
695     char dest[20] = {0};
696     FILE *fp = fopen(g_tempFile, "w+");
697     NAPI_ASSERT(env, fp != nullptr, "fread fopen Error");
698     size_t ret = fwrite("AB", PARAM_1, PARAM_2, fp);
699     NAPI_ASSERT(env, ret == 2U, "fread fwrite Error");
700     rewind(fp);
701     ret = fread(&dest[0], PARAM_1, PARAM_2, fp);
702     NAPI_ASSERT(env, ret == 2U, "fread Error");
703     fclose(fp);
704     remove(g_tempFile);
705     napi_value result = nullptr;
706     napi_create_int32(env, strcmp(dest, "AB") == PARAM_0, &result);
707     return result;
708 }
709 
Fread_unlocked_One(napi_env env, napi_callback_info info)710 static napi_value Fread_unlocked_One(napi_env env, napi_callback_info info)
711 {
712     char dest[20] = {0};
713     FILE *fp = fopen(g_tempFile, "w+");
714     NAPI_ASSERT(env, fp != nullptr, "fread_unlocked fopen Error");
715     size_t ret = fwrite_unlocked("AB", PARAM_1, PARAM_2, fp);
716     NAPI_ASSERT(env, ret == 2U, "fwrite_unlocked Error");
717     rewind(fp);
718     ret = fread_unlocked(&dest[0], PARAM_1, PARAM_2, fp);
719     NAPI_ASSERT(env, ret == 2U, "fread_unlocked Error");
720     fclose(fp);
721     remove(g_tempFile);
722     napi_value result = nullptr;
723     napi_create_int32(env, strcmp(dest, "AB") == PARAM_0, &result);
724     return result;
725 }
726 
Freopen_One(napi_env env, napi_callback_info info)727 static napi_value Freopen_One(napi_env env, napi_callback_info info)
728 {
729     errno = PARAM_0;
730     FILE *fp = fopen(g_tempFile, "w+");
731     NAPI_ASSERT(env, fp != nullptr, "freopen fopen Error");
732     fp = freopen(g_tempFile, "r+", fp);
733     NAPI_ASSERT(env, fp != nullptr, "freopen Error");
734     fclose(fp);
735     remove(g_tempFile);
736     napi_value result = nullptr;
737     napi_create_int32(env, errno == PARAM_0, &result);
738     return result;
739 }
740 
Freopen64_One(napi_env env, napi_callback_info info)741 static napi_value Freopen64_One(napi_env env, napi_callback_info info)
742 {
743     errno = PARAM_0;
744     FILE *fp = fopen64(g_tempFile, "w+");
745     NAPI_ASSERT(env, fp != nullptr, "freopen64 fopen Error");
746     fp = freopen64(g_tempFile, "r+", fp);
747     NAPI_ASSERT(env, fp != nullptr, "freopen64 Error");
748     fclose(fp);
749     remove(g_tempFile);
750     napi_value result = nullptr;
751     napi_create_int32(env, errno == PARAM_0, &result);
752     return result;
753 }
754 
Fscanf_One(napi_env env, napi_callback_info info)755 static napi_value Fscanf_One(napi_env env, napi_callback_info info)
756 {
757     char str[80];
758     float f;
759     FILE *fp = fopen(g_tempFile, "w+");
760     NAPI_ASSERT(env, fp != nullptr, "fscanf fopen Error");
761     fprintf(fp, "%f %s", PARAM_31416, "PI");
762     rewind(fp);
763     fscanf(fp, "%f", &f);
764     fscanf(fp, "%s", str);
765     fclose(fp);
766     remove(g_tempFile);
767     napi_value result = nullptr;
768     napi_create_int32(env, strcmp(str, "PI") == PARAM_0 && fabsf(f - PARAM_31416F) < FLT_EPSILON, &result);
769     return result;
770 }
771 
Fseek_One(napi_env env, napi_callback_info info)772 static napi_value Fseek_One(napi_env env, napi_callback_info info)
773 {
774     FILE *fp = fopen(g_tempFile, "w+");
775     NAPI_ASSERT(env, fp != nullptr, "fseek fopen Error");
776     const char src[] = "hello world";
777     fwrite(src, sizeof(char), strlen(src), fp);
778     fseek(fp, PARAM_4, SEEK_SET);
779     char ret = fgetc(fp);
780     fclose(fp);
781     remove(g_tempFile);
782     napi_value result = nullptr;
783     napi_create_int32(env, ret == 'o', &result);
784     return result;
785 }
786 
Fseeko_One(napi_env env, napi_callback_info info)787 static napi_value Fseeko_One(napi_env env, napi_callback_info info)
788 {
789     FILE *fp = fopen(g_tempFile, "w+");
790     NAPI_ASSERT(env, fp != nullptr, "fseeko fopen Error");
791     const char src[] = "hello world";
792     fwrite(src, sizeof(char), strlen(src), fp);
793     fseeko(fp, 4L, SEEK_SET);
794     char ret = fgetc(fp);
795     fclose(fp);
796     remove(g_tempFile);
797     napi_value result = nullptr;
798     napi_create_int32(env, ret == 'o', &result);
799     return result;
800 }
801 
Fseeko64_One(napi_env env, napi_callback_info info)802 static napi_value Fseeko64_One(napi_env env, napi_callback_info info)
803 {
804     FILE *fp = fopen(g_tempFile, "w+");
805     NAPI_ASSERT(env, fp != nullptr, "fseeko64 fopen Error");
806     const char src[] = "hello world";
807     fwrite(src, sizeof(char), strlen(src), fp);
808     fseeko64(fp, 4L, SEEK_SET);
809     char ret = fgetc(fp);
810     fclose(fp);
811     remove(g_tempFile);
812     napi_value result = nullptr;
813     napi_create_int32(env, ret == 'o', &result);
814     return result;
815 }
816 
Fsetpos_One(napi_env env, napi_callback_info info)817 static napi_value Fsetpos_One(napi_env env, napi_callback_info info)
818 {
819     long long a = PARAM_0;
820     fpos_t pos;
821     pos.__lldata = a;
822     FILE *fp = fopen(g_tempFile, "w+");
823     NAPI_ASSERT(env, fp != nullptr, "fsetpos fopen Error");
824     const char src[] = "hello world";
825     fwrite(src, sizeof(char), strlen(src), fp);
826     char dest[100] = {0};
827     int posValue = fsetpos(fp, &pos);
828     NAPI_ASSERT(env, posValue == PARAM_0, "fsetpos Error");
829     int ret = fread(dest, sizeof(char), sizeof(dest), fp);
830     fclose(fp);
831     remove(g_tempFile);
832     napi_value result = nullptr;
833     napi_create_int32(env, ret == strlen(src), &result);
834     return result;
835 }
836 
Fsetpos64_One(napi_env env, napi_callback_info info)837 static napi_value Fsetpos64_One(napi_env env, napi_callback_info info)
838 {
839     long long a = PARAM_0;
840     fpos_t pos;
841     pos.__lldata = a;
842     FILE *fp = fopen(g_tempFile, "w+");
843     NAPI_ASSERT(env, fp != nullptr, "fsetpos64 fopen Error");
844     const char src[] = "hello world";
845     fwrite(src, sizeof(char), strlen(src), fp);
846     char dest[100] = {0};
847     int posValue = fsetpos64(fp, &pos);
848     NAPI_ASSERT(env, posValue == PARAM_0, "fsetpos64 Error");
849     size_t ret = fread(dest, sizeof(char), sizeof(dest), fp);
850     fclose(fp);
851     remove(g_tempFile);
852     napi_value result = nullptr;
853     napi_create_int32(env, ret == strlen(dest), &result);
854     return result;
855 }
856 
Ftell_One(napi_env env, napi_callback_info info)857 static napi_value Ftell_One(napi_env env, napi_callback_info info)
858 {
859     FILE *fp = fopen(g_tempFile, "w+");
860     NAPI_ASSERT(env, fp != nullptr, "ftell fopen Error");
861     const char src[] = "hello world";
862     fwrite(src, sizeof(char), strlen(src), fp);
863     int fret = fseek(fp, PARAM_0, SEEK_SET);
864     NAPI_ASSERT(env, fret == PARAM_0, "ftell fseek Error");
865     long ret = ftell(fp);
866     fclose(fp);
867     remove(g_tempFile);
868     napi_value result = nullptr;
869     napi_create_int32(env, ret == PARAM_0, &result);
870     return result;
871 }
872 
Ftello_One(napi_env env, napi_callback_info info)873 static napi_value Ftello_One(napi_env env, napi_callback_info info)
874 {
875     FILE *fp = fopen(g_tempFile, "w+");
876     NAPI_ASSERT(env, fp != nullptr, "ftello fopen Error");
877     const char src[] = "hello world";
878     fwrite(src, sizeof(char), strlen(src), fp);
879     int fret = fseek(fp, PARAM_0, SEEK_SET);
880     NAPI_ASSERT(env, fret == PARAM_0, "ftello fseek Error");
881     off_t ret = ftello(fp);
882     fclose(fp);
883     remove(g_tempFile);
884     napi_value result = nullptr;
885     napi_create_int32(env, ret == (off_t)PARAM_0, &result);
886     return result;
887 }
888 
Ftello64_One(napi_env env, napi_callback_info info)889 static napi_value Ftello64_One(napi_env env, napi_callback_info info)
890 {
891     FILE *fp = fopen(g_tempFile, "w+");
892     NAPI_ASSERT(env, fp != nullptr, "ftello64 fopen Error");
893     const char src[] = "hello world";
894     fwrite(src, sizeof(char), strlen(src), fp);
895     int fret = fseek(fp, PARAM_0, SEEK_SET);
896     NAPI_ASSERT(env, fret == PARAM_0, "ftello64 fseek Error");
897     off64_t ret = ftello64(fp);
898     fclose(fp);
899     remove(g_tempFile);
900     napi_value result = nullptr;
901     napi_create_int32(env, ret == (off64_t)PARAM_0, &result);
902     return result;
903 }
904 
Ftrylockfile_One(napi_env env, napi_callback_info info)905 static napi_value Ftrylockfile_One(napi_env env, napi_callback_info info)
906 {
907     FILE *fp = fopen(g_tempFile, "w+");
908     NAPI_ASSERT(env, fp != nullptr, "ftrylockfile fopen Error");
909     int ret = MPARAM_1;
910     ret = ftrylockfile(fp);
911     fclose(fp);
912     remove(g_tempFile);
913     napi_value result = nullptr;
914     napi_create_int32(env, ret == PARAM_0, &result);
915     return result;
916 }
917 
Funlockfile_One(napi_env env, napi_callback_info info)918 static napi_value Funlockfile_One(napi_env env, napi_callback_info info)
919 {
920     errno = PARAM_0;
921     puts("start do_child_one");
922     flockfile(stdout);
923     puts("after first flockfile");
924     flockfile(stdout);
925     puts("foo");
926     funlockfile(stdout);
927     puts("after first funlockfile");
928     funlockfile(stdout);
929     puts("all done");
930     napi_value result = nullptr;
931     napi_create_int32(env, errno == PARAM_0, &result);
932     return result;
933 }
934 
Fwrite_One(napi_env env, napi_callback_info info)935 static napi_value Fwrite_One(napi_env env, napi_callback_info info)
936 {
937     char dest[20] = {0};
938     FILE *fp = fopen(g_tempFile, "w+");
939     NAPI_ASSERT(env, fp != nullptr, "fwrite fopen Error");
940     size_t ret = fwrite("AB", PARAM_1, PARAM_2, fp);
941     NAPI_ASSERT(env, ret == 2U, "fwrite Error");
942     rewind(fp);
943     ret = fread(&dest[0], PARAM_1, PARAM_2, fp);
944     NAPI_ASSERT(env, ret == 2U, "fwrite fread Error");
945     fclose(fp);
946     remove(g_tempFile);
947     napi_value result = nullptr;
948     napi_create_int32(env, strcmp(dest, "AB") == PARAM_0, &result);
949     return result;
950 }
951 
Fwrite_unlocked_One(napi_env env, napi_callback_info info)952 static napi_value Fwrite_unlocked_One(napi_env env, napi_callback_info info)
953 {
954     char dest[20] = {0};
955     FILE *fp = fopen(g_tempFile, "w+");
956     NAPI_ASSERT(env, fp != nullptr, "fwrite_unlocked fopen Error");
957     size_t ret = fwrite_unlocked("AB", PARAM_1, PARAM_2, fp);
958     NAPI_ASSERT(env, ret == 2U, "fwrite_unlocked Error");
959     rewind(fp);
960     ret = fread_unlocked(&dest[0], PARAM_1, PARAM_2, fp);
961     NAPI_ASSERT(env, ret == 2U, "fwrite_unlocked fread_unlocked Error");
962     fclose(fp);
963     remove(g_tempFile);
964     napi_value result = nullptr;
965     napi_create_int32(env, strcmp(dest, "AB") == PARAM_0, &result);
966     return result;
967 }
968 
Getc_One(napi_env env, napi_callback_info info)969 static napi_value Getc_One(napi_env env, napi_callback_info info)
970 {
971     FILE *fp = fopen(g_tempFile, "w+");
972     NAPI_ASSERT(env, fp != nullptr, "getc fopen Error");
973     fputc_unlocked('a', fp);
974     rewind(fp);
975     int ret = getc(fp);
976     fclose(fp);
977     remove(g_tempFile);
978     napi_value result = nullptr;
979     napi_create_int32(env, ret == 'a', &result);
980     return result;
981 }
982 
Getc_unlocked_One(napi_env env, napi_callback_info info)983 static napi_value Getc_unlocked_One(napi_env env, napi_callback_info info)
984 {
985     FILE *fp = fopen(g_tempFile, "w+");
986     NAPI_ASSERT(env, fp != nullptr, "getc_unlocked fopen Error");
987     fputc_unlocked('a', fp);
988     rewind(fp);
989     int ret = getc_unlocked(fp);
990     fclose(fp);
991     remove(g_tempFile);
992     napi_value result = nullptr;
993     napi_create_int32(env, ret == 'a', &result);
994     return result;
995 }
996 
GetChar_One(napi_env env, napi_callback_info info)997 static napi_value GetChar_One(napi_env env, napi_callback_info info)
998 {
999     FILE *fp = fopen(g_tempFile, "w");
1000     NAPI_ASSERT(env, fp != nullptr, "getchar fopen Error");
1001     char src[] = "getchar";
1002     fputs(src, fp);
1003     rewind(fp);
1004     FILE *fp1 = freopen(g_tempFile, "r", stdin);
1005     NAPI_ASSERT(env, fp1 != nullptr, "getchar freopen Error");
1006     int ret = getchar();
1007     fclose(fp);
1008     fclose(fp1);
1009     remove(g_tempFile);
1010     napi_value result = nullptr;
1011     napi_create_int32(env, ret == 'g', &result);
1012     return result;
1013 }
1014 
GetChar_unlocked_One(napi_env env, napi_callback_info info)1015 static napi_value GetChar_unlocked_One(napi_env env, napi_callback_info info)
1016 {
1017     FILE *fp = fopen(g_tempFile, "w");
1018     NAPI_ASSERT(env, fp != nullptr, "getchar_unlocked fopen Error");
1019     char src[] = "getchar";
1020     fputs(src, fp);
1021     rewind(fp);
1022     FILE *fp1 = freopen(g_tempFile, "r", stdin);
1023     NAPI_ASSERT(env, fp1 != nullptr, "getchar_unlocked freopen Error");
1024     int ret = getchar_unlocked();
1025     fclose(fp);
1026     fclose(fp1);
1027     remove(g_tempFile);
1028     napi_value result = nullptr;
1029     napi_create_int32(env, ret == 'g', &result);
1030     return result;
1031 }
1032 
PutC_unlocked_One(napi_env env, napi_callback_info info)1033 static napi_value PutC_unlocked_One(napi_env env, napi_callback_info info)
1034 {
1035     int ret = MPARAM_1;
1036     FILE *fp = fopen(g_tempFile, "w");
1037     NAPI_ASSERT(env, fp != nullptr, "PutC_unlocked_One fopen Error");
1038     char ch = 'p';
1039     ret = putc_unlocked(ch, fp);
1040     fclose(fp);
1041     remove(g_tempFile);
1042     napi_value result = nullptr;
1043     napi_create_int32(env, ret == 'p', &result);
1044     return result;
1045 }
1046 
PutChar_unlocked_One(napi_env env, napi_callback_info info)1047 static napi_value PutChar_unlocked_One(napi_env env, napi_callback_info info)
1048 {
1049     int ret = MPARAM_1;
1050     char ch[] = "this is putchar_unlocked_0100 test case, std output success!";
1051     int length = SIZEOF_CHAR(ch);
1052     for (int nLoop = PARAM_0; nLoop < length; nLoop++) {
1053         ret = putchar_unlocked(ch[nLoop]);
1054         NAPI_ASSERT(env, ret == ch[nLoop], "putChar_unlocked Error");
1055     }
1056     napi_value result = nullptr;
1057     napi_create_int32(env, PARAM_1, &result);
1058     return result;
1059 }
1060 
Getdelim_One(napi_env env, napi_callback_info info)1061 static napi_value Getdelim_One(napi_env env, napi_callback_info info)
1062 {
1063     char *line = nullptr;
1064     size_t len = PARAM_0;
1065     FILE *fp = fopen(g_tempFile, "w+");
1066     NAPI_ASSERT(env, fp != nullptr, "getdelim fopen Error");
1067     const char src[] = "hello,world";
1068     fwrite(src, sizeof(char), strlen(src), fp);
1069     int fret = fseek(fp, PARAM_0, SEEK_SET);
1070     NAPI_ASSERT(env, fret == PARAM_0, "getdelim fseek Error");
1071     ssize_t ret = getdelim(&line, &len, ',', fp);
1072     NAPI_ASSERT(env, ret > PARAM_0, "getdelim Error");
1073     fclose(fp);
1074     remove(g_tempFile);
1075     napi_value result = nullptr;
1076     napi_create_int32(env, strcmp(line, "hello,") == PARAM_0 && len > strlen("hello,"), &result);
1077     return result;
1078 }
1079 
Getline_One(napi_env env, napi_callback_info info)1080 static napi_value Getline_One(napi_env env, napi_callback_info info)
1081 {
1082     char *line = nullptr;
1083     size_t len = PARAM_0;
1084     FILE *fp = fopen(g_tempFile, "w+");
1085     NAPI_ASSERT(env, fp != nullptr, "getline fopen Error");
1086     const char src[] = "helloworld";
1087     fwrite(src, sizeof(char), strlen(src), fp);
1088     int fret = fseek(fp, PARAM_0, SEEK_SET);
1089     NAPI_ASSERT(env, fret == PARAM_0, "getline fseek Error");
1090     ssize_t ret = getline(&line, &len, fp);
1091     NAPI_ASSERT(env, ret > PARAM_0, "getline Error");
1092     fclose(fp);
1093     remove(g_tempFile);
1094     napi_value result = nullptr;
1095     napi_create_int32(env, strcmp(line, "helloworld") == PARAM_0 && ret == PARAM_10, &result);
1096     return result;
1097 }
1098 
Gets_One(napi_env env, napi_callback_info info)1099 static napi_value Gets_One(napi_env env, napi_callback_info info)
1100 {
1101     FILE *fp = fopen(g_tempFile, "w");
1102     NAPI_ASSERT(env, fp != nullptr, "gets fopen Error");
1103     char src[] = "gets";
1104     fputs(src, fp);
1105     fseek(fp, PARAM_0, SEEK_SET);
1106     FILE *fp1 = freopen(g_tempFile, "r", stdin);
1107     NAPI_ASSERT(env, fp1 != nullptr, "gets freopen Error");
1108     char dest[20] = {0};
1109     char *ret = gets(dest);
1110     fclose(fp);
1111     fclose(fp1);
1112     remove(g_tempFile);
1113     napi_value result = nullptr;
1114     napi_create_int32(env, strcmp(ret, "gets") == PARAM_0 && strcmp(dest, ret) == PARAM_0, &result);
1115     return result;
1116 }
1117 
Nrand48_One(napi_env env, napi_callback_info info)1118 static napi_value Nrand48_One(napi_env env, napi_callback_info info)
1119 {
1120     unsigned short s[3] = {1, 2, 3};
1121     int ret = PARAM_0;
1122     for (int i = PARAM_0; i < PARAM_10; i++) {
1123         for (int j = PARAM_0; j < PARAM_3; j++) {
1124             s[j] += i * PARAM_10;
1125         }
1126         long rev = nrand48(s);
1127         if (rev < pow(PARAM_2, PARAM_31) && rev > PARAM_0) {
1128             ret++;
1129         }
1130     }
1131     napi_value result = nullptr;
1132     napi_create_int32(env, ret == PARAM_10, &result);
1133     return result;
1134 }
1135 
Open_Memstream_One(napi_env env, napi_callback_info info)1136 static napi_value Open_Memstream_One(napi_env env, napi_callback_info info)
1137 {
1138     size_t len = PARAM_0;
1139     char *ptr = nullptr;
1140     FILE *fp = open_memstream(&ptr, &len);
1141     NAPI_ASSERT(env, fp != nullptr, "open_memstream Error");
1142     int value = fputs("hello, world!", fp);
1143     NAPI_ASSERT(env, value != EOF, "open_memstream fputs Error");
1144     fflush(fp);
1145     fclose(fp);
1146     free(ptr);
1147     ptr = nullptr;
1148     napi_value result = nullptr;
1149     napi_create_int32(env, strlen("hello, world!") == len, &result);
1150     return result;
1151 }
1152 
Perror_One(napi_env env, napi_callback_info info)1153 static napi_value Perror_One(napi_env env, napi_callback_info info)
1154 {
1155     int ret = MPARAM_1;
1156     FILE *fp = fopen(g_tempFile, "rb");
1157     if (fp == nullptr) {
1158         perror("The following error occurred");
1159         ret = PARAM_1;
1160     } else {
1161         fclose(fp);
1162         remove(g_tempFile);
1163     }
1164     napi_value result = nullptr;
1165     napi_create_int32(env, ret == PARAM_1, &result);
1166     return result;
1167 }
1168 
Printf_One(napi_env env, napi_callback_info info)1169 static napi_value Printf_One(napi_env env, napi_callback_info info)
1170 {
1171     int ret = printf("%s \n", "A string");
1172     napi_value result = nullptr;
1173     napi_create_int32(env, ret == PARAM_10, &result);
1174     return result;
1175 }
1176 
Putc_One(napi_env env, napi_callback_info info)1177 static napi_value Putc_One(napi_env env, napi_callback_info info)
1178 {
1179     int ret = MPARAM_1;
1180     FILE *fp = fopen(g_tempFile, "w");
1181     NAPI_ASSERT(env, fp != nullptr, "Putc_One fopen Error");
1182     char ch = 'p';
1183     ret = putc(ch, fp);
1184     fclose(fp);
1185     remove(g_tempFile);
1186     napi_value result = nullptr;
1187     napi_create_int32(env, ret == 'p', &result);
1188     return result;
1189 }
1190 
Putchar_One(napi_env env, napi_callback_info info)1191 static napi_value Putchar_One(napi_env env, napi_callback_info info)
1192 {
1193     int ret = MPARAM_1;
1194     char ch[] = "this is putchar_ont test case, std output success!";
1195     int length = SIZEOF_CHAR(ch);
1196     for (int nLoop = PARAM_0; nLoop < length; nLoop++) {
1197         ret = putchar(ch[nLoop]);
1198         NAPI_ASSERT(env, ret == ch[nLoop], "Putchar_One Error");
1199     }
1200     napi_value result = nullptr;
1201     napi_create_int32(env, PARAM_1, &result);
1202     return result;
1203 }
1204 
Putenv_One(napi_env env, napi_callback_info info)1205 static napi_value Putenv_One(napi_env env, napi_callback_info info)
1206 {
1207     char src[] = "test=Putenv_One";
1208     int ret = unsetenv("test");
1209     NAPI_ASSERT(env, ret == PARAM_0, "Putenv_One unsetenv Error");
1210     ret = putenv(src);
1211     NAPI_ASSERT(env, ret == PARAM_0, "Putenv_One putenv Error");
1212     char *test = getenv("test");
1213     NAPI_ASSERT(env, test != nullptr, "Putenv_One getenv Error");
1214     unsetenv("test");
1215     napi_value result = nullptr;
1216     napi_create_int32(env, strcmp("Putenv_One", test) == PARAM_0, &result);
1217     return result;
1218 }
1219 
Puts_One(napi_env env, napi_callback_info info)1220 static napi_value Puts_One(napi_env env, napi_callback_info info)
1221 {
1222     char src[] = "Puts_One";
1223     int ret = puts(src);
1224     NAPI_ASSERT(env, ret != EOF, "Puts_One puts Error");
1225     napi_value result = nullptr;
1226     napi_create_int32(env, ret == PARAM_0, &result);
1227     return result;
1228 }
1229 
Putw_One(napi_env env, napi_callback_info info)1230 static napi_value Putw_One(napi_env env, napi_callback_info info)
1231 {
1232     FILE *fp = fopen(g_tempFile, "w");
1233     NAPI_ASSERT(env, fp != nullptr, "Putw_One fopen Error");
1234     int ret = putw(PARAM_10, fp);
1235     NAPI_ASSERT(env, ret != EOF, "Putw_One putw Error");
1236     fclose(fp);
1237     remove(g_tempFile);
1238     napi_value result = nullptr;
1239     napi_create_int32(env, ret == PARAM_0, &result);
1240     return result;
1241 }
1242 
Remove_One(napi_env env, napi_callback_info info)1243 static napi_value Remove_One(napi_env env, napi_callback_info info)
1244 {
1245     FILE *fp = fopen(g_tempFile, "w");
1246     NAPI_ASSERT(env, fp != nullptr, "Remove_One fopen Error");
1247     fclose(fp);
1248     int ret = remove(g_tempFile);
1249     napi_value result = nullptr;
1250     napi_create_int32(env, ret == PARAM_0, &result);
1251     return result;
1252 }
1253 
Rename_One(napi_env env, napi_callback_info info)1254 static napi_value Rename_One(napi_env env, napi_callback_info info)
1255 {
1256     FILE *fp = fopen(g_tempFile, "w");
1257     NAPI_ASSERT(env, fp != nullptr, "Rename_One fopen Error");
1258     int ret = rename(g_tempFile, g_tempLinkFile);
1259     fclose(fp);
1260     remove(g_tempLinkFile);
1261     napi_value result = nullptr;
1262     napi_create_int32(env, ret == PARAM_0, &result);
1263     return result;
1264 }
1265 
Renameat_One(napi_env env, napi_callback_info info)1266 static napi_value Renameat_One(napi_env env, napi_callback_info info)
1267 {
1268     int oldfd = open(g_tempFile, O_CREAT, PARAM_0777);
1269     int newfd = open(TEMP_FILE_NEW, O_CREAT, PARAM_0777);
1270     NAPI_ASSERT(env, oldfd != EOF && newfd != EOF, "Renameat_One open Error");
1271     int ret = renameat(oldfd, g_tempFile, newfd, TEMP_FILE_NEW);
1272     close(oldfd);
1273     close(newfd);
1274     remove(g_tempFile);
1275     remove(TEMP_FILE_NEW);
1276     napi_value result = nullptr;
1277     napi_create_int32(env, ret == PARAM_0, &result);
1278     return result;
1279 }
1280 
Rewind_One(napi_env env, napi_callback_info info)1281 static napi_value Rewind_One(napi_env env, napi_callback_info info)
1282 {
1283     FILE *fp = fopen(g_tempFile, "w");
1284     NAPI_ASSERT(env, fp != nullptr, "Rewind_One fopen Error");
1285     char str[] = "test";
1286     fwrite(str, PARAM_1, sizeof(str), fp);
1287     rewind(fp);
1288     napi_value result = nullptr;
1289     napi_create_int32(env, feof(fp) == false, &result);
1290     fclose(fp);
1291     remove(g_tempFile);
1292     return result;
1293 }
1294 
Scanf_One(napi_env env, napi_callback_info info)1295 static napi_value Scanf_One(napi_env env, napi_callback_info info)
1296 {
1297     FILE *fp = fopen(g_tempFile, "w");
1298     NAPI_ASSERT(env, fp != nullptr, "Scanf_One fopen Error");
1299     char str[] = "testscanf";
1300     fputs(str, fp);
1301     fseek(fp, PARAM_0, SEEK_SET);
1302     FILE *fp1 = freopen(g_tempFile, "r", stdin);
1303     NAPI_ASSERT(env, fp1 != nullptr, "Scanf_One freopen Error");
1304     char ch[50] = {0};
1305     int ret = scanf("%s", ch);
1306     NAPI_ASSERT(env, ret == PARAM_1, "scanf Error");
1307     fclose(fp);
1308     fclose(fp1);
1309     remove(g_tempFile);
1310     napi_value result = nullptr;
1311     napi_create_int32(env, strcmp(ch, "testscanf") == PARAM_0, &result);
1312     return result;
1313 }
1314 
Setvbuf_One(napi_env env, napi_callback_info info)1315 static napi_value Setvbuf_One(napi_env env, napi_callback_info info)
1316 {
1317     FILE *fp = fopen(g_tempFile, "w");
1318     NAPI_ASSERT(env, fp != nullptr, "Setvbuf_One fopen Error");
1319     char buff[1024] = {0};
1320     int ret = setvbuf(fp, buff, _IOFBF, PARAM_1024);
1321     fclose(fp);
1322     remove(g_tempFile);
1323     napi_value result = nullptr;
1324     napi_create_int32(env, ret == PARAM_0, &result);
1325     return result;
1326 }
1327 
Snprintf_One(napi_env env, napi_callback_info info)1328 static napi_value Snprintf_One(napi_env env, napi_callback_info info)
1329 {
1330     char dest[100] = {0};
1331     int ret = MPARAM_1;
1332     ret = snprintf(dest, PARAM_100, "The half of %d is %d", PARAM_60, PARAM_60 / PARAM_2);
1333     napi_value result = nullptr;
1334     napi_create_int32(env, ret == PARAM_20, &result);
1335     return result;
1336 }
1337 
Sprintf_One(napi_env env, napi_callback_info info)1338 static napi_value Sprintf_One(napi_env env, napi_callback_info info)
1339 {
1340     char dest[50] = {0};
1341     int ret = MPARAM_1;
1342     ret = sprintf(dest, "%d plus %d is %d", PARAM_5, PARAM_3, PARAM_5 + PARAM_3);
1343     napi_value result = nullptr;
1344     napi_create_int32(env, ret == PARAM_13, &result);
1345     return result;
1346 }
1347 
Sscanf_One(napi_env env, napi_callback_info info)1348 static napi_value Sscanf_One(napi_env env, napi_callback_info info)
1349 {
1350     const char src[] = "Rudolph is 12 years old";
1351     char dest[20] = {0};
1352     int i;
1353     int ret = MPARAM_1;
1354     ret = sscanf(src, "%s %*s %d", dest, &i);
1355     napi_value result = nullptr;
1356     napi_create_int32(env, ret == PARAM_2, &result);
1357     return result;
1358 }
1359 
Stderr_One(napi_env env, napi_callback_info info)1360 static napi_value Stderr_One(napi_env env, napi_callback_info info)
1361 {
1362     int ret = fileno(stderr);
1363     napi_value result = nullptr;
1364     napi_create_int32(env, ret == PARAM_2, &result);
1365     return result;
1366 }
Stdin_One(napi_env env, napi_callback_info info)1367 static napi_value Stdin_One(napi_env env, napi_callback_info info)
1368 {
1369     int ret = fileno(stdin);
1370     napi_value result = nullptr;
1371     napi_create_int32(env, ret == PARAM_0, &result);
1372     return result;
1373 }
Stdout_One(napi_env env, napi_callback_info info)1374 static napi_value Stdout_One(napi_env env, napi_callback_info info)
1375 {
1376     int ret = fileno(stdout);
1377     napi_value result = nullptr;
1378     napi_create_int32(env, ret == PARAM_1, &result);
1379     return result;
1380 }
1381 
Tempnam_One(napi_env env, napi_callback_info info)1382 static napi_value Tempnam_One(napi_env env, napi_callback_info info)
1383 {
1384     const char *TEMP_PATH = "/data/storage/el2/base/files/";
1385     const char *TEMP_NAME = "temp";
1386     char *ret = tempnam(TEMP_PATH, TEMP_NAME);
1387     NAPI_ASSERT(env, ret != nullptr, "Tempnam_One tempnam Error");
1388     napi_value result = nullptr;
1389     napi_create_int32(env, strstr(ret, TEMP_NAME) != nullptr, &result);
1390     return result;
1391 }
1392 
Tmpname_One(napi_env env, napi_callback_info info)1393 static napi_value Tmpname_One(napi_env env, napi_callback_info info)
1394 {
1395     char buffer[L_tmpnam];
1396     char *ret = tmpnam(buffer);
1397     napi_value result = nullptr;
1398     napi_create_int32(env, ret != nullptr && strlen(ret) > PARAM_0, &result);
1399     return result;
1400 }
1401 
Ungetc_One(napi_env env, napi_callback_info info)1402 static napi_value Ungetc_One(napi_env env, napi_callback_info info)
1403 {
1404     FILE *fp = fopen(g_tempFile, "w+");
1405     NAPI_ASSERT(env, fp != nullptr, "ungetc fopen Error");
1406     int ch = 'a';
1407     putc(ch, fp);
1408     fseek(fp, PARAM_0, SEEK_SET);
1409     int ret = ungetc(ch, fp);
1410     ret = getc(fp);
1411     fclose(fp);
1412     remove(g_tempFile);
1413     napi_value result = nullptr;
1414     napi_create_int32(env, ret == 'a', &result);
1415     return result;
1416 }
1417 
1418 extern "C" int Vasprintf_Test(const char *format, ...);
Vasprintf_Test(const char *format, ...)1419 int Vasprintf_Test(const char *format, ...)
1420 {
1421     va_list args;
1422     va_start(args, format);
1423     char ta[] = " ";
1424     char *temp = ta;
1425     vasprintf(&temp, format, args);
1426     va_end(args);
1427     return strcmp(temp, "value is 123 and 321.") == PARAM_0;
1428 }
1429 
Vasprintf_One(napi_env env, napi_callback_info info)1430 static napi_value Vasprintf_One(napi_env env, napi_callback_info info)
1431 {
1432     int ret = Vasprintf_Test("value is %d and %d.", PARAM_123, PARAM_321);
1433     napi_value result = nullptr;
1434     napi_create_int32(env, ret, &result);
1435     return result;
1436 }
1437 
1438 extern "C" int Vdprintf_Test(int fd, const char *format, ...);
Vdprintf_Test(int fd, const char *format, ...)1439 int Vdprintf_Test(int fd, const char *format, ...)
1440 {
1441     va_list args;
1442     va_start(args, format);
1443     int ret = MPARAM_1;
1444     ret = vdprintf(fd, format, args);
1445     va_end(args);
1446     return ret;
1447 }
1448 
Vdprintf_One(napi_env env, napi_callback_info info)1449 static napi_value Vdprintf_One(napi_env env, napi_callback_info info)
1450 {
1451     int fd = open(g_tempFile, O_CREAT | O_RDWR, PARAM_0777);
1452     NAPI_ASSERT(env, fd != EOF, "vdprintf open Error");
1453     char value[] = "asdf";
1454     char dest[20] = {0};
1455     int ret = MPARAM_1;
1456     ret = Vdprintf_Test(fd, "%s", value);
1457     NAPI_ASSERT(env, ret >= PARAM_0, "vdprintf Error");
1458     FILE *fp = fdopen(fd, "r");
1459     rewind(fp);
1460     fread(dest, sizeof(char), sizeof(dest), fp);
1461     fclose(fp);
1462     close(fd);
1463     remove(g_tempFile);
1464     napi_value result = nullptr;
1465     napi_create_int32(env, strcmp(dest, "asdf") == PARAM_0, &result);
1466     return result;
1467 }
1468 
1469 extern "C" int Vfprintf_Test(const char *file_name, const char *format, const char *want_reuslt, ...);
Vfprintf_Test(const char *file_name, const char *format, const char *want_reuslt, ...)1470 int Vfprintf_Test(const char *file_name, const char *format, const char *want_reuslt, ...)
1471 {
1472     FILE *fp = fopen(file_name, "w+");
1473     va_list args;
1474     va_start(args, want_reuslt);
1475     vfprintf(fp, format, args);
1476     va_end(args);
1477     rewind(fp);
1478     char dest[100] = {0};
1479     fread(dest, sizeof(char), sizeof(dest), fp);
1480     fclose(fp);
1481     remove(file_name);
1482     return strcmp(dest, want_reuslt) == PARAM_0;
1483 }
1484 
Vfprintf_One(napi_env env, napi_callback_info info)1485 static napi_value Vfprintf_One(napi_env env, napi_callback_info info)
1486 {
1487     int ret = Vfprintf_Test(g_tempFile, "value is %s and %s", "value is qwe and 1", "qwe", "1");
1488     napi_value result = nullptr;
1489     napi_create_int32(env, ret, &result);
1490     return result;
1491 }
1492 
1493 extern "C" int Vfscanf_Test(FILE *fp, const char *format, ...);
Vfscanf_Test(FILE *fp, const char *format, ...)1494 int Vfscanf_Test(FILE *fp, const char *format, ...)
1495 {
1496     va_list args;
1497     va_start(args, format);
1498     int result = vfscanf(fp, format, args);
1499     va_end(args);
1500     return result;
1501 }
1502 
Vfscanf_One(napi_env env, napi_callback_info info)1503 static napi_value Vfscanf_One(napi_env env, napi_callback_info info)
1504 {
1505     FILE *fp = fopen(g_tempFile, "w+");
1506     NAPI_ASSERT(env, fp != nullptr, "Vfscanf_One fopen Error");
1507     fprintf(fp, "%s %d", "vfscanftest", PARAM_123);
1508     rewind(fp);
1509     char dest[100] = {0};
1510     int val = PARAM_0;
1511     int ret = MPARAM_1;
1512     ret = Vfscanf_Test(fp, "%s %d", dest, &val);
1513     NAPI_ASSERT(env, ret >= PARAM_0, "vfscanf Error");
1514     fclose(fp);
1515     remove(g_tempFile);
1516     napi_value result = nullptr;
1517     napi_create_int32(env, strcmp(dest, "vfscanftest") == PARAM_0, &result);
1518     return result;
1519 }
1520 
1521 extern "C" int Vprintf_Test(const char *format, ...);
Vprintf_Test(const char *format, ...)1522 int Vprintf_Test(const char *format, ...)
1523 {
1524     va_list args;
1525     va_start(args, format);
1526     int result = vprintf(format, args);
1527     char want[] = "This is the 1th test for vprintf";
1528     va_end(args);
1529     return result == strlen(want);
1530 }
1531 
Vprintf_One(napi_env env, napi_callback_info info)1532 static napi_value Vprintf_One(napi_env env, napi_callback_info info)
1533 {
1534     int ret = Vprintf_Test("This is the %dth test for vprintf", PARAM_1);
1535     napi_value result = nullptr;
1536     napi_create_int32(env, ret, &result);
1537     return result;
1538 }
1539 
1540 extern "C" int Vsnprintf_test(const char *want_reuslt, size_t n, const char *format, const char *func_name, ...);
Vsnprintf_test(const char *want_reuslt, size_t n, const char *format, const char *func_name, ...)1541 int Vsnprintf_test(const char *want_reuslt, size_t n, const char *format, const char *func_name, ...)
1542 {
1543     va_list args;
1544     va_start(args, func_name);
1545     char s[n];
1546     int result = vsnprintf(s, n, format, args);
1547     va_end(args);
1548     return (strcmp(s, want_reuslt) == PARAM_0) && (result == n - PARAM_1);
1549 }
1550 
Vsnprintf_One(napi_env env, napi_callback_info info)1551 static napi_value Vsnprintf_One(napi_env env, napi_callback_info info)
1552 {
1553     int ret = Vsnprintf_test("value is use", PARAM_13, "value is %s", "Vsnprintf_One", "use");
1554     napi_value result = nullptr;
1555     napi_create_int32(env, ret, &result);
1556     return result;
1557 }
1558 
1559 extern "C" int Vsscanf_Test(const char *str, const char *format, ...);
Vsscanf_Test(const char *str, const char *format, ...)1560 int Vsscanf_Test(const char *str, const char *format, ...)
1561 {
1562     va_list args;
1563     va_start(args, format);
1564     int result = vsscanf(str, format, args);
1565     va_end(args);
1566     return result;
1567 }
1568 
Vsscanf_One(napi_env env, napi_callback_info info)1569 static napi_value Vsscanf_One(napi_env env, napi_callback_info info)
1570 {
1571     int val;
1572     char dest[1024] = {0};
1573     int ret = Vsscanf_Test("99 bottles of beer on the wall", " %d %s ", &val, dest);
1574     napi_value result = nullptr;
1575     napi_create_int32(env, ret == PARAM_2 && val == PARAM_99 && strcmp(dest, "bottles") == PARAM_0, &result);
1576     return result;
1577 }
1578 
1579 EXTERN_C_START
Init(napi_env env, napi_value exports)1580 static napi_value Init(napi_env env, napi_value exports)
1581 {
1582     napi_property_descriptor desc[] = {
1583         {"Fgets_chk_One", nullptr, Fgets_chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1584         {"Fread_Chk_One", nullptr, Fread_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1585         {"Pwrite_Chk_One", nullptr, Pwrite_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1586         {"Readlinkat_Chk_One", nullptr, Readlinkat_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1587         {"Snprintf_Chk_One", nullptr, Snprintf_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1588         {"Sprintf_Chk_One", nullptr, Sprintf_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1589         {"Vsnprintf_Chk_One", nullptr, Vsnprintf_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1590         {"Write_Chk_One", nullptr, Write_Chk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1591         {"Asprintf_One", nullptr, Asprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1592         {"ClearErr_One", nullptr, ClearErr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1593         {"Clearerr_Unlocked_One", nullptr, Clearerr_Unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1594         {"Dprintf_One", nullptr, Dprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1595         {"Fclose_One", nullptr, Fclose_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1596         {"Fdopen_One", nullptr, Fdopen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1597         {"Feof_unlocked_One", nullptr, Feof_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1598         {"Ferror_One", nullptr, Ferror_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1599         {"Ferror_unlocked_One", nullptr, Ferror_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1600         {"Fflush_One", nullptr, Fflush_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1601         {"Fflush_unlocked_One", nullptr, Fflush_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1602         {"Fgetc_One", nullptr, Fgetc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1603         {"Fgetc_unlocked_One", nullptr, Fgetc_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1604         {"Fgetin_One", nullptr, Fgetin_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1605         {"Fgetpos_One", nullptr, Fgetpos_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1606         {"Fgetpos64_One", nullptr, Fgetpos64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1607         {"Fgets_One", nullptr, Fgets_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1608         {"Fgets_unlocked_One", nullptr, Fgets_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1609         {"Fileno_One", nullptr, Fileno_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1610         {"Fileno_unlocked_One", nullptr, Fileno_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1611         {"Flockfile_One", nullptr, Flockfile_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1612         {"Fmemopen_One", nullptr, Fmemopen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1613         {"Fopen_One", nullptr, Fopen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1614         {"Fopen64_One", nullptr, Fopen64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1615         {"Fprintf_One", nullptr, Fprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1616         {"Fpurge_One", nullptr, Fpurge_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1617         {"Fputc_One", nullptr, Fputc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1618         {"Fputc_unlocked_One", nullptr, Fputc_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1619         {"Fputs_One", nullptr, Fputs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1620         {"Fputs_unlocked_One", nullptr, Fputs_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1621         {"Fread_One", nullptr, Fread_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1622         {"Fread_unlocked_One", nullptr, Fread_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1623         {"Freopen_One", nullptr, Freopen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1624         {"Freopen64_One", nullptr, Freopen64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1625         {"Fscanf_One", nullptr, Fscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1626         {"Fseek_One", nullptr, Fseek_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1627         {"Fseeko_One", nullptr, Fseeko_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1628         {"Fseeko64_One", nullptr, Fseeko64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1629         {"Fsetpos_One", nullptr, Fsetpos_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1630         {"Fsetpos64_One", nullptr, Fsetpos64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1631         {"Ftell_One", nullptr, Ftell_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1632         {"Ftello_One", nullptr, Ftello_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1633         {"Ftello64_One", nullptr, Ftello64_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1634         {"Ftrylockfile_One", nullptr, Ftrylockfile_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1635         {"Funlockfile_One", nullptr, Funlockfile_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1636         {"Fwrite_One", nullptr, Fwrite_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1637         {"Fwrite_unlocked_One", nullptr, Fwrite_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1638         {"Getc_One", nullptr, Getc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1639         {"Getc_unlocked_One", nullptr, Getc_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1640         {"GetChar_One", nullptr, GetChar_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1641         {"GetChar_unlocked_One", nullptr, GetChar_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1642         {"PutC_unlocked_One", nullptr, PutC_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1643         {"PutChar_unlocked_One", nullptr, PutChar_unlocked_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1644         {"Getdelim_One", nullptr, Getdelim_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1645         {"Getline_One", nullptr, Getline_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1646         {"Gets_One", nullptr, Gets_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1647         {"Nrand48_One", nullptr, Nrand48_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1648         {"Open_Memstream_One", nullptr, Open_Memstream_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1649         {"Perror_One", nullptr, Perror_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1650         {"Printf_One", nullptr, Printf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1651         {"Putc_One", nullptr, Putc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1652         {"Putchar_One", nullptr, Putchar_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1653         {"Putenv_One", nullptr, Putenv_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1654         {"Puts_One", nullptr, Puts_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1655         {"Putw_One", nullptr, Putw_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1656         {"Remove_One", nullptr, Remove_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1657         {"Rename_One", nullptr, Rename_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1658         {"Renameat_One", nullptr, Renameat_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1659         {"Rewind_One", nullptr, Rewind_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1660         {"Scanf_One", nullptr, Scanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1661         {"Setvbuf_One", nullptr, Setvbuf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1662         {"Snprintf_One", nullptr, Snprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1663         {"Sprintf_One", nullptr, Sprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1664         {"Sscanf_One", nullptr, Sscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1665         {"Stderr_One", nullptr, Stderr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1666         {"Stdin_One", nullptr, Stdin_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1667         {"Stdout_One", nullptr, Stdout_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1668         {"Tempnam_One", nullptr, Tempnam_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1669         {"Tmpname_One", nullptr, Tmpname_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1670         {"Ungetc_One", nullptr, Ungetc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1671         {"Vasprintf_One", nullptr, Vasprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1672         {"Vdprintf_One", nullptr, Vdprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1673         {"Vfprintf_One", nullptr, Vfprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1674         {"Vfscanf_One", nullptr, Vfscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1675         {"Vprintf_One", nullptr, Vprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1676         {"Vsnprintf_One", nullptr, Vsnprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1677         {"Vsscanf_One", nullptr, Vsscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1678 
1679     };
1680     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1681     return exports;
1682 }
1683 
1684 EXTERN_C_END
1685 
1686 static napi_module demoModule = {
1687     .nm_version = 1,
1688     .nm_flags = 0,
1689     .nm_filename = nullptr,
1690     .nm_register_func = Init,
1691     .nm_modname = "stdiondk1",
1692     .nm_priv = ((void *)0),
1693     .reserved = {0},
1694 };
1695 
RegisterEntryModule(void)1696 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
1697