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 <cstdio>
24 #include <cstdlib>
25 #include <cstring>
26 #include <ctime>
27 #include <cwchar>
28 #include <fcntl.h>
29 #include <memory.h>
30 #include <unistd.h>
31 #include <securec.h>
32 
33 #define PARAM_0 0
34 #define PARAM_1 1
35 #define MPARAM_1 (-1)
36 #define PARAM_2 2
37 #define PARAM_3 3
38 #define PARAM_314 3.14
39 #define PARAM_4 4
40 #define PARAM_25 25
41 #define PARAM_31 31
42 #define PARAM_32 32
43 #define PARAM_6 6
44 #define PARAM_7 7
45 #define PARAM_10 10
46 #define PARAM_13 13
47 #define PARAM_16 16
48 #define PARAM_17 17
49 #define PARAM_5 5
50 #define PARAM_80 80
51 #define PARAM_0777 0777
52 #define PARAM_250068492 250068492
53 #define PARAM_2064035584 2064035584
54 #define PARAM_208622688 208622688
55 #define PARAM_7340031 7340031
56 #define PARAM_1856892505 1856892505
57 #define PARAM_6358606123 6358606123
58 #define MPARAM_208340076 (-208340076)
59 #define PARAM_2001 2001
60 #define PARAM_6340800 6340800
61 #define MPARAM_36242240 (-3624224)
62 #define SIZE_100 100
63 #define ARRY_MAX 128
64 #define ZERO 0x0
65 #define PARAM_11 11
66 #define PARAM_20 20
67 #define PARAM_14 14
68 #define PARAM_18 18
69 #define ERRON_0 0
70 #define MINUSONE (-1)
71 #define SUCCESS 1
72 #define FAILD (-1)
73 #define SIZE_256 256
74 #define PARAM_12 12
75 
76 #define SIZEOF_WCHAR(x) (sizeof(x) / sizeof(wchar_t))
77 static const char *TEMP_FILE = "/data/storage/el2/base/files/fzl.txt";
78 
Btowc_One(napi_env env, napi_callback_info info)79 static napi_value Btowc_One(napi_env env, napi_callback_info info)
80 {
81     wint_t ret = btowc('6');
82     NAPI_ASSERT(env, ret == L'6', "btowc Error");
83     ret = btowc('A');
84     NAPI_ASSERT(env, ret == L'A', "btowc Error");
85     ret = btowc('&');
86     NAPI_ASSERT(env, ret == L'&', "btowc Error");
87     napi_value result = nullptr;
88     napi_create_int32(env, SUCCESS, &result);
89     return result;
90 }
91 
Btowc_Two(napi_env env, napi_callback_info info)92 static napi_value Btowc_Two(napi_env env, napi_callback_info info)
93 {
94     wint_t ret = btowc(EOF);
95     napi_value result = nullptr;
96     napi_create_int32(env, ret == WEOF, &result);
97     return result;
98 }
99 
Mbtowc_One(napi_env env, napi_callback_info info)100 static napi_value Mbtowc_One(napi_env env, napi_callback_info info)
101 {
102     const char *test = "musl";
103     wchar_t wc[ARRY_MAX];
104     size_t ret = mbtowc(wc, test, PARAM_1);
105     napi_value result = nullptr;
106     napi_create_int32(env, ret == SUCCESS && wc[PARAM_0] == L'm', &result);
107     return result;
108 }
109 
Mbtowc_Two(napi_env env, napi_callback_info info)110 static napi_value Mbtowc_Two(napi_env env, napi_callback_info info)
111 {
112     wchar_t wc[ARRY_MAX];
113     errno = 0;
114     int ret = mbtowc(wc, nullptr, MINUSONE);
115     napi_value result = nullptr;
116     napi_create_int32(env, ret == SUCCESS && errno == EBADF, &result);
117     return result;
118 }
119 
Fputwc_One(napi_env env, napi_callback_info info)120 static napi_value Fputwc_One(napi_env env, napi_callback_info info)
121 {
122     wchar_t mb_one_bytes = L'h';
123     FILE *fp = fopen(TEMP_FILE, "w");
124     NAPI_ASSERT(env, fp != nullptr, "Fputwc_One fopen Error");
125     int ret = PARAM_0;
126     if (fp) {
127         ret = fputwc(mb_one_bytes, fp);
128         fclose(fp);
129         remove(TEMP_FILE);
130     }
131     napi_value result = nullptr;
132     napi_create_int32(env, static_cast<wchar_t>(ret) == mb_one_bytes, &result);
133     return result;
134 }
135 
Fputws_One(napi_env env, napi_callback_info info)136 static napi_value Fputws_One(napi_env env, napi_callback_info info)
137 {
138     char wstr[SIZE_100] = {PARAM_0};
139     FILE *fp = fopen(TEMP_FILE, "w+");
140     NAPI_ASSERT(env, fp != nullptr, "Fputws_One fopen Error");
141     int ret = PARAM_0;
142     int rsize = PARAM_0;
143     if (fp) {
144         ret = fputws(L"This is a test", fp);
145         fseek(fp, PARAM_0, SEEK_SET);
146         rsize = fread(wstr, sizeof(char), SIZE_100, fp);
147         fclose(fp);
148         remove(TEMP_FILE);
149     }
150     napi_value result = nullptr;
151     napi_create_int32(env, rsize == ret, &result);
152     return result;
153 }
154 
Fwide_One(napi_env env, napi_callback_info info)155 static napi_value Fwide_One(napi_env env, napi_callback_info info)
156 {
157     errno = PARAM_0;
158     FILE *fp = fopen(TEMP_FILE, "w+");
159     NAPI_ASSERT(env, fp != nullptr, "Fwide_One fopen Error");
160     int ret = PARAM_0;
161     if (fp) {
162         ret = fwide(fp, PARAM_5);
163         fclose(fp);
164         remove(TEMP_FILE);
165     }
166     napi_value result = nullptr;
167     napi_create_int32(env, ret > PARAM_0 && errno == ERRON_0, &result);
168     return result;
169 }
170 
Fwide_Two(napi_env env, napi_callback_info info)171 static napi_value Fwide_Two(napi_env env, napi_callback_info info)
172 {
173     errno = PARAM_0;
174     FILE *fp = fopen(TEMP_FILE, "w+");
175     NAPI_ASSERT(env, fp != nullptr, "Fwide_Two fopen Error");
176     int ret = PARAM_0;
177     if (fp) {
178         ret = fwide(fp, PARAM_0);
179         fclose(fp);
180         remove(TEMP_FILE);
181     }
182     napi_value result = nullptr;
183     napi_create_int32(env, ret == ERRON_0 && errno == ERRON_0, &result);
184     return result;
185 }
186 
Fwprintf_One(napi_env env, napi_callback_info info)187 static napi_value Fwprintf_One(napi_env env, napi_callback_info info)
188 {
189     setlocale(LC_ALL, "en_US.UTF-8");
190     int ret = fwprintf(stdout, L"This is a test\n");
191     napi_value result = nullptr;
192     napi_create_int32(env, ret == wcslen(L"This is a test\n"), &result);
193     return result;
194 }
195 
Fwprintf_Two(napi_env env, napi_callback_info info)196 static napi_value Fwprintf_Two(napi_env env, napi_callback_info info)
197 {
198     setlocale(LC_ALL, "en_US.UTF-8");
199     int ret = fwprintf(stderr, L"This is a test\n");
200     napi_value result = nullptr;
201     napi_create_int32(env, ret == wcslen(L"This is a test\n"), &result);
202     return result;
203 }
204 
Wprintf_One(napi_env env, napi_callback_info info)205 static napi_value Wprintf_One(napi_env env, napi_callback_info info)
206 {
207     int ret = wprintf(L"%ls", L"This is a test");
208     napi_value result = nullptr;
209     napi_create_int32(env, ret == wcslen(L"This is a test"), &result);
210     return result;
211 }
212 
Wprintf_Two(napi_env env, napi_callback_info info)213 static napi_value Wprintf_Two(napi_env env, napi_callback_info info)
214 {
215     int ret = wprintf(L"%lc", L'a');
216     napi_value result = nullptr;
217     napi_create_int32(env, ret == SUCCESS, &result);
218     return result;
219 }
220 
Fwscanf_One(napi_env env, napi_callback_info info)221 static napi_value Fwscanf_One(napi_env env, napi_callback_info info)
222 {
223     int fd = open(TEMP_FILE, O_CREAT | O_RDWR, PARAM_0777);
224     int ret = PARAM_0;
225     FILE *fp = fdopen(fd, "w+");
226     if (fp) {
227         wchar_t wstr[PARAM_10] = {PARAM_0};
228         setlocale(LC_ALL, "en_US.UTF-8");
229         fwprintf(fp, L"%ls", L"test");
230         rewind(fp);
231         ret = fwscanf(fp, L"%ls", wstr);
232         fclose(fp);
233         remove(TEMP_FILE);
234     }
235     close(fd);
236     napi_value result = nullptr;
237     napi_create_int32(env, ret == SUCCESS, &result);
238     return result;
239 }
240 
Fwscanf_Two(napi_env env, napi_callback_info info)241 static napi_value Fwscanf_Two(napi_env env, napi_callback_info info)
242 {
243     int fd = open(TEMP_FILE, O_CREAT | O_RDWR, PARAM_0777);
244     int ret = PARAM_0;
245     FILE *fp = fdopen(fd, "w+");
246     if (fp) {
247         wchar_t wstr[50] = {PARAM_0};
248         fwprintf(fp, L"%ls", L"Summation");
249         rewind(fp);
250         ret = fwscanf(fp, L"%ls %lc", wstr);
251         fclose(fp);
252         remove(TEMP_FILE);
253     }
254     close(fd);
255     napi_value result = nullptr;
256     napi_create_int32(env, ret == SUCCESS, &result);
257     return result;
258 }
259 
Swprintf_One(napi_env env, napi_callback_info info)260 static napi_value Swprintf_One(napi_env env, napi_callback_info info)
261 {
262     wchar_t wbuf[SIZE_100] = {PARAM_0};
263     int ret = swprintf(wbuf, SIZE_100, L"%ls", L"This is test");
264     napi_value result = nullptr;
265     napi_create_int32(env, ret == wcslen(L"This is test"), &result);
266     return result;
267 }
268 
Swprintf_Two(napi_env env, napi_callback_info info)269 static napi_value Swprintf_Two(napi_env env, napi_callback_info info)
270 {
271     wchar_t wbuf[SIZE_100] = {PARAM_0};
272     int ret = swprintf(wbuf, SIZE_100, L"%s", "xyz");
273     napi_value result = nullptr;
274     napi_create_int32(env, ret == strlen("xyz"), &result);
275     return result;
276 }
277 
Swscanf_One(napi_env env, napi_callback_info info)278 static napi_value Swscanf_One(napi_env env, napi_callback_info info)
279 {
280     wchar_t wstr[] = L"swscanf 123";
281     wchar_t wtmp[PARAM_20];
282     setlocale(LC_ALL, "en_US.UTF-8");
283     int ret = swscanf(wstr, L"%ls", wtmp);
284     napi_value result = nullptr;
285     napi_create_int32(env, ret == SUCCESS, &result);
286     return result;
287 }
288 
Swscanf_Two(napi_env env, napi_callback_info info)289 static napi_value Swscanf_Two(napi_env env, napi_callback_info info)
290 {
291     wchar_t buffer[SIZE_100] = L"Theta \u03b8";
292     wchar_t symbol, desc[PARAM_10];
293     setlocale(LC_ALL, "en_US.UTF-8");
294     int ret = swscanf(buffer, L"%ls %lc", desc, &symbol);
295     napi_value result = nullptr;
296     napi_create_int32(env, ret == PARAM_2, &result);
297     return result;
298 }
299 
Mbrtowc_One(napi_env env, napi_callback_info info)300 static napi_value Mbrtowc_One(napi_env env, napi_callback_info info)
301 {
302     const char pt[] = "mbrtowc example";
303     wchar_t dest;
304     mbstate_t mbs;
305     mbrlen(nullptr, PARAM_0, &mbs);
306     int length = mbrtowc(&dest, pt, sizeof(pt), &mbs);
307     napi_value result = nullptr;
308     napi_create_int32(env, length == SUCCESS, &result);
309     return result;
310 }
311 
Mbsinit_One(napi_env env, napi_callback_info info)312 static napi_value Mbsinit_One(napi_env env, napi_callback_info info)
313 {
314     char buffer[PARAM_80];
315     mbstate_t mbst;
316     memset_s(&mbst, sizeof(mbst), 0, sizeof(mbst));
317     const wchar_t wcs[] = L"mbsinit";
318     const wchar_t *p = nullptr;
319     p = wcs;
320     int ret = mbsinit(&mbst);
321     memset_s(&mbst, sizeof(mbst), 0, sizeof(mbst));
322     memset_s(&buffer, sizeof(buffer), 0, sizeof(buffer));
323     wcsrtombs(buffer, &p, PARAM_80, &mbst);
324     napi_value result = nullptr;
325     napi_create_int32(env, ret == SUCCESS, &result);
326     return result;
327 }
328 
Mbstowcs_One(napi_env env, napi_callback_info info)329 static napi_value Mbstowcs_One(napi_env env, napi_callback_info info)
330 {
331     const int TEST_BUFFER_SIZE = ARRY_MAX;
332     const char *src = "mbstowcs_One";
333     wchar_t dst[TEST_BUFFER_SIZE];
334     memset(dst, ZERO, sizeof(wchar_t) * TEST_BUFFER_SIZE);
335     size_t ret = mbstowcs(dst, src, strlen(src));
336     napi_value result = nullptr;
337     napi_create_int32(env, ret == strlen(src), &result);
338     return result;
339 }
340 
Mbsrtowcs_One(napi_env env, napi_callback_info info)341 static napi_value Mbsrtowcs_One(napi_env env, napi_callback_info info)
342 {
343     setlocale(LC_ALL, "en_US.utf8");
344     const char *src = "\u0763\u0757";
345     wchar_t dest[PARAM_20];
346     mbstate_t ps = mbstate_t();
347     int max = PARAM_10;
348     int ret = mbsrtowcs(dest, &src, max, &ps);
349     napi_value result = nullptr;
350     napi_create_int32(env, ret == PARAM_2, &result);
351     return result;
352 }
353 
Mbsnrtowcs_One(napi_env env, napi_callback_info info)354 static napi_value Mbsnrtowcs_One(napi_env env, napi_callback_info info)
355 {
356     setlocale(LC_ALL, "en_US.utf8");
357     const char *src = "\u0763\u0757";
358     wchar_t dest[PARAM_20];
359     mbstate_t ps = mbstate_t();
360     int max = PARAM_10;
361     int ret = mbsnrtowcs(dest, &src, max, max, &ps);
362     napi_value result = nullptr;
363     napi_create_int32(env, ret == PARAM_2, &result);
364     return result;
365 }
366 
OpenWmemstream_One(napi_env env, napi_callback_info info)367 static napi_value OpenWmemstream_One(napi_env env, napi_callback_info info)
368 {
369     size_t len = PARAM_0;
370     wchar_t *ptr = nullptr;
371     FILE *fp = open_wmemstream(&ptr, &len);
372     if (fp) {
373         fputws(L"hello, world!", fp);
374         fclose(fp);
375     }
376     free(ptr);
377     ptr = nullptr;
378     napi_value result = nullptr;
379     napi_create_int32(env, wcslen(L"hello, world!") == len, &result);
380     return result;
381 }
382 
Putwc_One(napi_env env, napi_callback_info info)383 static napi_value Putwc_One(napi_env env, napi_callback_info info)
384 {
385     wint_t ret = MINUSONE;
386     FILE *fp = fopen(TEMP_FILE, "w");
387     NAPI_ASSERT(env, fp != nullptr, "Putwc_One fopen Error");
388     wchar_t wc = L'p';
389     ret = putwc(wc, fp);
390     fclose(fp);
391     remove(TEMP_FILE);
392     napi_value result = nullptr;
393     napi_create_int32(env, static_cast<wchar_t>(ret) == L'p', &result);
394     return result;
395 }
396 
PutWChar_One(napi_env env, napi_callback_info info)397 static napi_value PutWChar_One(napi_env env, napi_callback_info info)
398 {
399     wint_t ret = MINUSONE;
400     wchar_t wch[] = L"this is putwchar_0100 test case, std output success!";
401     int length = SIZEOF_WCHAR(wch);
402     for (int nLoop = PARAM_0; nLoop < length; nLoop++) {
403         ret = putwchar(wch[nLoop]);
404         NAPI_ASSERT(env, static_cast<wchar_t>(ret) == wch[nLoop], "putwchar Error");
405     }
406     napi_value result = nullptr;
407     napi_create_int32(env, SUCCESS, &result);
408     return result;
409 }
410 
Towlower_One(napi_env env, napi_callback_info info)411 static napi_value Towlower_One(napi_env env, napi_callback_info info)
412 {
413     wchar_t wc = L'A';
414     wint_t wt = PARAM_0;
415     wt = towlower(wc);
416     napi_value result = nullptr;
417     napi_create_int32(env, wt == L'a', &result);
418     return result;
419 }
420 
Towupper_One(napi_env env, napi_callback_info info)421 static napi_value Towupper_One(napi_env env, napi_callback_info info)
422 {
423     wchar_t wc = L'a';
424     wint_t wt = PARAM_0;
425     wt = towupper(wc);
426     napi_value result = nullptr;
427     napi_create_int32(env, wt == L'A', &result);
428     return result;
429 }
430 
Ungetwc_One(napi_env env, napi_callback_info info)431 static napi_value Ungetwc_One(napi_env env, napi_callback_info info)
432 {
433     FILE *fp = fopen(TEMP_FILE, "w+");
434     NAPI_ASSERT(env, fp != nullptr, "ungetwc fopen Error");
435     wint_t wc = L'a';
436     putwc(wc, fp);
437     fseek(fp, PARAM_0, SEEK_SET);
438     wint_t ret = ungetwc(wc, fp);
439     ret = getwc(fp);
440     fclose(fp);
441     remove(TEMP_FILE);
442     napi_value result = nullptr;
443     napi_create_int32(env, static_cast<wchar_t>(ret) == L'a', &result);
444     return result;
445 }
446 
Wcpcpy_One(napi_env env, napi_callback_info info)447 static napi_value Wcpcpy_One(napi_env env, napi_callback_info info)
448 {
449     wchar_t src[] = L"Source string";
450     wchar_t dst[PARAM_14] = {PARAM_0};
451     wcpcpy(dst, src);
452     napi_value result = nullptr;
453     napi_create_int32(env, wcscmp(src, dst) == ERRON_0, &result);
454     return result;
455 }
456 
Wcpncpy_One(napi_env env, napi_callback_info info)457 static napi_value Wcpncpy_One(napi_env env, napi_callback_info info)
458 {
459     wchar_t src[] = L"Source string";
460     wchar_t dst[PARAM_18] = {PARAM_0};
461     size_t src_len = PARAM_13;
462     wcpncpy(dst, src, src_len + PARAM_1);
463     napi_value result = nullptr;
464     napi_create_int32(env, wcscmp(src, dst) == ERRON_0, &result);
465     return result;
466 }
467 
Wcrtomb_One(napi_env env, napi_callback_info info)468 static napi_value Wcrtomb_One(napi_env env, napi_callback_info info)
469 {
470     wchar_t wcs = L'A';
471     char s[PARAM_20];
472     mbstate_t pr;
473     memset(&pr, PARAM_0, sizeof(pr));
474     int ret = MINUSONE;
475     ret = wcrtomb(s, wcs, &pr);
476     NAPI_ASSERT(env, ret == SUCCESS, "wcrtomb Error");
477     napi_value result = nullptr;
478     napi_create_int32(env, strcmp(s, "A") == ERRON_0, &result);
479 
480     return result;
481 }
482 
Wcscasecmp_One(napi_env env, napi_callback_info info)483 static napi_value Wcscasecmp_One(napi_env env, napi_callback_info info)
484 {
485     int ret = MINUSONE;
486     ret = wcscasecmp(L"hello1", L"HELLO2");
487     NAPI_ASSERT(env, ret < PARAM_0, "wcscasecmp Error");
488     ret = wcscasecmp(L"hello2", L"HELLO1");
489     NAPI_ASSERT(env, ret > PARAM_0, "wcscasecmp Error");
490     ret = wcscasecmp(L"hello", L"HELLO");
491     NAPI_ASSERT(env, ret == ERRON_0, "wcscasecmp Error");
492     napi_value result = nullptr;
493     napi_create_int32(env, ret == ERRON_0, &result);
494     return result;
495 }
496 
Wcscasecmpl_One(napi_env env, napi_callback_info info)497 static napi_value Wcscasecmpl_One(napi_env env, napi_callback_info info)
498 {
499     int ret = MINUSONE;
500     locale_t localInfo = nullptr;
501     ret = wcscasecmp_l(L"hello1", L"HELLO2", localInfo);
502     NAPI_ASSERT(env, ret < PARAM_0, "wcscasecmp_l Error");
503     ret = wcscasecmp_l(L"hello2", L"HELLO1", localInfo);
504     NAPI_ASSERT(env, ret > PARAM_0, "wcscasecmp_l Error");
505     ret = wcscasecmp_l(L"hello", L"HELLO", localInfo);
506     NAPI_ASSERT(env, ret == ERRON_0, "wcscasecmp_l Error");
507     napi_value result = nullptr;
508     napi_create_int32(env, ret == ERRON_0, &result);
509     return result;
510 }
511 
Wcscat_One(napi_env env, napi_callback_info info)512 static napi_value Wcscat_One(napi_env env, napi_callback_info info)
513 {
514     wchar_t wcs[PARAM_80];
515     wcscpy(wcs, L"these ");
516     wcscat(wcs, L"wide strings ");
517     wcscat(wcs, L"are ");
518     wcscat(wcs, L"concatenated.");
519     napi_value result = nullptr;
520     napi_create_int32(env, wcscmp(wcs, L"these wide strings are concatenated.") == ERRON_0, &result);
521     return result;
522 }
523 
Wcschr_One(napi_env env, napi_callback_info info)524 static napi_value Wcschr_One(napi_env env, napi_callback_info info)
525 {
526     wchar_t wcs[] = L"This is a sample wide string";
527     wchar_t *pwc = nullptr;
528     pwc = wcschr(wcs, L's');
529     napi_value result = nullptr;
530     napi_create_int32(env, pwc - wcs + PARAM_1 == PARAM_4, &result);
531     return result;
532 }
533 
Wcscmp_One(napi_env env, napi_callback_info info)534 static napi_value Wcscmp_One(napi_env env, napi_callback_info info)
535 {
536     int ret = MINUSONE;
537     ret = wcscmp(L"ABCD", L"ABCE");
538     NAPI_ASSERT(env, ret < PARAM_0, "wcscmp Error");
539     ret = wcscmp(L"ABCE", L"ABCD");
540     NAPI_ASSERT(env, ret > PARAM_0, "wcscmp Error");
541     ret = wcscmp(L"test wcscmp", L"test wcscmp");
542     NAPI_ASSERT(env, ret == ERRON_0, "wcscmp Error");
543     napi_value result = nullptr;
544     napi_create_int32(env, ret == ERRON_0, &result);
545     return result;
546 }
547 
Wcscoll_One(napi_env env, napi_callback_info info)548 static napi_value Wcscoll_One(napi_env env, napi_callback_info info)
549 {
550     setlocale(LC_COLLATE, "en_US.utf8");
551     int ret = wcscoll(L"år", L"ängel");
552     napi_value result = nullptr;
553     napi_create_int32(env, ret == SUCCESS, &result);
554     return result;
555 }
556 
Wcscolll_One(napi_env env, napi_callback_info info)557 static napi_value Wcscolll_One(napi_env env, napi_callback_info info)
558 {
559     int ret = MINUSONE;
560     locale_t localInfo = nullptr;
561     ret = wcscoll_l(L"abcdefg", L"abcdef", localInfo);
562     NAPI_ASSERT(env, ret > PARAM_0, "wcscoll_l Error");
563     ret = wcscoll_l(L"abcde", L"abcdef", localInfo);
564     NAPI_ASSERT(env, ret < PARAM_0, "wcscoll_l Error");
565     ret = wcscoll_l(L"abcdef", L"abcdef", localInfo);
566     napi_value result = nullptr;
567     napi_create_int32(env, ret == ERRON_0, &result);
568     return result;
569 }
570 
Wcscpy_One(napi_env env, napi_callback_info info)571 static napi_value Wcscpy_One(napi_env env, napi_callback_info info)
572 {
573     wchar_t wcs[] = L"wcscpy test";
574     wchar_t des[40];
575     wcscpy(des, wcs);
576     napi_value result = nullptr;
577     napi_create_int32(env, wcscmp(wcs, des) == ERRON_0, &result);
578     return result;
579 }
580 
Wcscspn_One(napi_env env, napi_callback_info info)581 static napi_value Wcscspn_One(napi_env env, napi_callback_info info)
582 {
583     wchar_t wcs[] = L"fcba73";
584     wchar_t keys[] = L"1234567890";
585     int ret = MINUSONE;
586     ret = wcscspn(wcs, keys);
587     napi_value result = nullptr;
588     napi_create_int32(env, ret == PARAM_4, &result);
589     return result;
590 }
591 
Wcsdup_One(napi_env env, napi_callback_info info)592 static napi_value Wcsdup_One(napi_env env, napi_callback_info info)
593 {
594     wchar_t src[] = L"wcsdup";
595     wchar_t *ret = wcsdup(src);
596     NAPI_ASSERT(env, ret != nullptr, "wcsdup Error");
597     napi_value result = nullptr;
598     napi_create_int32(env, wcscmp(src, ret) == ERRON_0, &result);
599     return result;
600 }
601 
Wcsftime_One(napi_env env, napi_callback_info info)602 static napi_value Wcsftime_One(napi_env env, napi_callback_info info)
603 {
604     int ret = MINUSONE;
605     time_t rawtime;
606     struct tm *timeinfo;
607     wchar_t buffer[PARAM_80];
608     time(&rawtime);
609     timeinfo = localtime(&rawtime);
610     ret = wcsftime(buffer, PARAM_80, L"Now it's %I:%M%p.", timeinfo);
611     napi_value result = nullptr;
612     napi_create_int32(env, ret == PARAM_17, &result);
613     return result;
614 }
615 
Wcsftimel_One(napi_env env, napi_callback_info info)616 static napi_value Wcsftimel_One(napi_env env, napi_callback_info info)
617 {
618     int ret = MINUSONE;
619     time_t rtime;
620     struct tm *timeinfo;
621     wchar_t buffer[PARAM_80];
622     time(&rtime);
623     timeinfo = localtime(&rtime);
624     locale_t newlocale_ = newlocale(LC_ALL_MASK, "en_US", nullptr);
625     ret = wcsftime_l(buffer, PARAM_80, L"%I:%M%p", timeinfo, newlocale_);
626     if (newlocale_) {
627         freelocale(newlocale_);
628         newlocale_ = nullptr;
629     }
630     napi_value result = nullptr;
631     napi_create_int32(env, ret == PARAM_7, &result);
632     return result;
633 }
634 
Wcslen_One(napi_env env, napi_callback_info info)635 static napi_value Wcslen_One(napi_env env, napi_callback_info info)
636 {
637     wchar_t str[] = L"wcslen";
638     size_t ret = PARAM_6;
639     napi_value result = nullptr;
640     napi_create_int32(env, ret == wcslen(str), &result);
641     return result;
642 }
643 
Wcsncasecmp_One(napi_env env, napi_callback_info info)644 static napi_value Wcsncasecmp_One(napi_env env, napi_callback_info info)
645 {
646     int ret = MINUSONE;
647     ret = wcsncasecmp(L"hello1", L"HELLO2", PARAM_6);
648     NAPI_ASSERT(env, ret < PARAM_0, "wcsncasecmp Error");
649     ret = wcsncasecmp(L"hello2", L"HELLO1", PARAM_6);
650     NAPI_ASSERT(env, ret > PARAM_0, "wcsncasecmp Error");
651     ret = wcsncasecmp(L"hello1", L"HELLO2", PARAM_5);
652     napi_value result = nullptr;
653     napi_create_int32(env, ret == ERRON_0, &result);
654     return result;
655 }
656 
Wcsncasecmpl_One(napi_env env, napi_callback_info info)657 static napi_value Wcsncasecmpl_One(napi_env env, napi_callback_info info)
658 {
659     int ret = MINUSONE;
660     ret = wcsncasecmp_l(L"hello1", L"HELLO2", PARAM_6, nullptr);
661     NAPI_ASSERT(env, ret < PARAM_0, "wcsncasecmp_l Error");
662     ret = wcsncasecmp_l(L"hello2", L"HELLO1", PARAM_6, nullptr);
663     NAPI_ASSERT(env, ret > PARAM_0, "wcsncasecmp_l Error");
664     ret = wcsncasecmp_l(L"hello1", L"HELLO2", PARAM_5, nullptr);
665     napi_value result = nullptr;
666     napi_create_int32(env, ret == ERRON_0, &result);
667     return result;
668 }
669 
Wcsncat_One(napi_env env, napi_callback_info info)670 static napi_value Wcsncat_One(napi_env env, napi_callback_info info)
671 {
672     wchar_t dst[PARAM_32] = {PARAM_0};
673     wchar_t *ret = wcsncat(dst, L"hello, world!", PARAM_5);
674     napi_value result = nullptr;
675     napi_create_int32(env, wcscmp(dst, ret) == ERRON_0, &result);
676     return result;
677 }
678 
Wcsncmp_One(napi_env env, napi_callback_info info)679 static napi_value Wcsncmp_One(napi_env env, napi_callback_info info)
680 {
681     int ret = MINUSONE;
682     ret = wcsncmp(L"aaaa", L"aaab", PARAM_4);
683     NAPI_ASSERT(env, ret < PARAM_0, "wcsncmp Error");
684     ret = wcsncmp(L"aaab", L"aaaa", PARAM_4);
685     NAPI_ASSERT(env, ret > PARAM_0, "wcsncmp Error");
686     ret = wcsncmp(L"aaaa", L"aaab", PARAM_3);
687     NAPI_ASSERT(env, ret == ERRON_0, "wcsncmp Error");
688     napi_value result = nullptr;
689     napi_create_int32(env, ret == ERRON_0, &result);
690     return result;
691 }
692 
Wcsncpy_One(napi_env env, napi_callback_info info)693 static napi_value Wcsncpy_One(napi_env env, napi_callback_info info)
694 {
695     const wchar_t src[] = L"Hello";
696     wchar_t buf[SIZEOF_WCHAR(src) + PARAM_1];
697     wmemset(buf, L'A', SIZEOF_WCHAR(buf));
698     wchar_t *ret = static_cast<wchar_t *>(buf);
699 
700     napi_value result = nullptr;
701     napi_create_int32(env, ret == wcsncpy(ret, src, SIZEOF_WCHAR(src)), &result);
702     return result;
703 }
704 
Wcsnlen_One(napi_env env, napi_callback_info info)705 static napi_value Wcsnlen_One(napi_env env, napi_callback_info info)
706 {
707     const wchar_t *wc = L"ABCDEF";
708     size_t want = PARAM_6;
709     size_t ret = wcsnlen(wc, PARAM_6);
710     napi_value result = nullptr;
711     napi_create_int32(env, ret == want, &result);
712     return result;
713 }
714 
Wcsnrtombs_One(napi_env env, napi_callback_info info)715 static napi_value Wcsnrtombs_One(napi_env env, napi_callback_info info)
716 {
717     const wchar_t src[] = L"test wcsnrtombs";
718     const wchar_t *p;
719     mbstate_t mbs;
720     char buffer[PARAM_32];
721     int wn = PARAM_4;
722     int n = PARAM_4;
723     mbrlen(nullptr, PARAM_0, &mbs);
724     memset(buffer, PARAM_0, sizeof(buffer));
725     p = src;
726     int ret = wcsnrtombs(buffer, &p, wn, n, &mbs);
727     NAPI_ASSERT(env, ret > PARAM_0, "wcsnrtombs Error");
728     napi_value result = nullptr;
729     napi_create_int32(env, strcmp(buffer, "test") == ERRON_0, &result);
730     return result;
731 }
732 
Wcspbrk_One(napi_env env, napi_callback_info info)733 static napi_value Wcspbrk_One(napi_env env, napi_callback_info info)
734 {
735     wchar_t s[] = L"hello, world!";
736     wchar_t *ret = wcspbrk(s, L"abch");
737     NAPI_ASSERT(env, ret != nullptr, "wcspbrk Error");
738     napi_value result = nullptr;
739     napi_create_int32(env, wcscmp(ret, s) == ERRON_0, &result);
740     return result;
741 }
742 
Wcsrchr_One(napi_env env, napi_callback_info info)743 static napi_value Wcsrchr_One(napi_env env, napi_callback_info info)
744 {
745     wchar_t ch[] = L"hello, world";
746     wchar_t *ret = wcsrchr(ch, L'h');
747     NAPI_ASSERT(env, ret != nullptr, "wcsrchr Error");
748     napi_value result = nullptr;
749     napi_create_int32(env, wcscmp(ret, ch) == ERRON_0, &result);
750     return result;
751 }
752 
Wcsrtombs_One(napi_env env, napi_callback_info info)753 static napi_value Wcsrtombs_One(napi_env env, napi_callback_info info)
754 {
755     char str[SIZE_256] = {PARAM_0};
756     size_t want = PARAM_6;
757     const wchar_t *src = L"ABCDEF";
758     size_t ret = wcsrtombs(str, &src, PARAM_10, nullptr);
759     napi_value result = nullptr;
760     napi_create_int32(env, ret == want, &result);
761     return result;
762 }
763 
Wcsspn_One(napi_env env, napi_callback_info info)764 static napi_value Wcsspn_One(napi_env env, napi_callback_info info)
765 {
766     size_t ret = wcsspn(L"hello world", L"abcdefghijklmnopqrstuvwxyz");
767     size_t want = 5U;
768     napi_value result = nullptr;
769     napi_create_int32(env, ret == want, &result);
770     return result;
771 }
772 
Wcsstr_One(napi_env env, napi_callback_info info)773 static napi_value Wcsstr_One(napi_env env, napi_callback_info info)
774 {
775     wchar_t wcs[] = L"This is a simple string";
776     wchar_t *ret = nullptr;
777     ret = wcsstr(wcs, L"simple");
778     NAPI_ASSERT(env, ret != nullptr, "wcsstr Error");
779     wcsncpy(ret, L"sample", PARAM_6);
780     napi_value result = nullptr;
781     napi_create_int32(env, wcscmp(ret, L"sample string") == ERRON_0, &result);
782     return result;
783 }
784 
Wcstod_One(napi_env env, napi_callback_info info)785 static napi_value Wcstod_One(napi_env env, napi_callback_info info)
786 {
787     wchar_t str0[] = L"3.14wcstod";
788     wchar_t *end = nullptr;
789     wchar_t str1[] = L"wcstod";
790     double ret = wcstod(str0, &end);
791     NAPI_ASSERT(env, (fabs(ret - PARAM_314) < DBL_EPSILON), "wcstod Error");
792     napi_value result = nullptr;
793     napi_create_int32(env, wcscmp(end, str1) == ERRON_0, &result);
794     return result;
795 }
796 
Wcstof_One(napi_env env, napi_callback_info info)797 static napi_value Wcstof_One(napi_env env, napi_callback_info info)
798 {
799     wchar_t str0[] = L"3.14wcstof";
800     wchar_t *end = nullptr;
801     wchar_t str1[] = L"wcstof";
802     float ret = wcstof(str0, &end);
803     NAPI_ASSERT(env, (fabsf(ret - 3.14f) < FLT_EPSILON), "wcstof Error");
804     napi_value result = nullptr;
805     napi_create_int32(env, wcscmp(end, str1) == ERRON_0, &result);
806     return result;
807 }
808 
Wcstok_One(napi_env env, napi_callback_info info)809 static napi_value Wcstok_One(napi_env env, napi_callback_info info)
810 {
811     wchar_t str[] = L"parrot,owl.sparrow,pigeon,crow";
812     wchar_t delim[] = L",.";
813     wchar_t *ptr;
814     wchar_t *ret = wcstok(str, delim, &ptr);
815     NAPI_ASSERT(env, ret != nullptr, "wcstok Error");
816     napi_value result = nullptr;
817     napi_create_int32(env, wcscmp(ret, L"parrot") == ERRON_0, &result);
818     return result;
819 }
820 
Wcstol_One(napi_env env, napi_callback_info info)821 static napi_value Wcstol_One(napi_env env, napi_callback_info info)
822 {
823     wchar_t wsNumbers[] = L"2001 60c0c0 -1101110100110100100000 0x6fffff";
824     wchar_t *pEnd = nullptr;
825     long int li1 = wcstol(wsNumbers, &pEnd, PARAM_10);
826     long int li2 = wcstol(pEnd, &pEnd, PARAM_16);
827     long int li3 = wcstol(pEnd, &pEnd, PARAM_2);
828     long int li4 = wcstol(pEnd, nullptr, PARAM_0);
829     napi_value result = nullptr;
830     napi_create_int32(env, li1 == PARAM_2001 && li2 == PARAM_6340800 && li3 == MPARAM_36242240 && li4 == PARAM_7340031,
831                       &result);
832     return result;
833 }
834 
Wcstold_One(napi_env env, napi_callback_info info)835 static napi_value Wcstold_One(napi_env env, napi_callback_info info)
836 {
837     wchar_t str0[] = L"3.14wcstold";
838     wchar_t *end = nullptr;
839     wchar_t str1[] = L"wcstold";
840     long double ret = wcstold(str0, &end);
841     NAPI_ASSERT(env, (fabsl(ret - 3.14L) < LDBL_EPSILON), "wcstold Error");
842     napi_value result = nullptr;
843     napi_create_int32(env, wcscmp(end, str1) == ERRON_0, &result);
844     return result;
845 }
846 
Wcstoll_One(napi_env env, napi_callback_info info)847 static napi_value Wcstoll_One(napi_env env, napi_callback_info info)
848 {
849     wchar_t wsNumbers[] = L"1856892505 17b00a12b -01100011010110000010001101100 0x6fffff";
850     wchar_t *pEnd = nullptr;
851     long long int lli1 = wcstoll(wsNumbers, &pEnd, PARAM_10);
852     long long int lli2 = wcstoll(pEnd, &pEnd, PARAM_16);
853     long long int lli3 = wcstoll(pEnd, &pEnd, PARAM_2);
854     long long int lli4 = wcstoll(pEnd, nullptr, PARAM_0);
855     napi_value result = nullptr;
856     napi_create_int32(
857         env, lli1 == PARAM_1856892505 && lli2 == PARAM_6358606123 && lli3 == MPARAM_208340076 && lli4 == PARAM_7340031,
858         &result);
859     return result;
860 }
861 
Wcstombs_One(napi_env env, napi_callback_info info)862 static napi_value Wcstombs_One(napi_env env, napi_callback_info info)
863 {
864     const wchar_t str[] = L"wcstombs example";
865     char buffer[PARAM_32];
866     int ret = wcstombs(buffer, str, sizeof(buffer));
867     napi_value result = nullptr;
868     napi_create_int32(env, ret == wcslen(L"wcstombs example"), &result);
869     return result;
870 }
871 
Wcstoul_One(napi_env env, napi_callback_info info)872 static napi_value Wcstoul_One(napi_env env, napi_callback_info info)
873 {
874     unsigned long want = PARAM_25;
875     unsigned long ret = wcstoul(L"25", nullptr, PARAM_0);
876     napi_value result = nullptr;
877     napi_create_int32(env, ret == want, &result);
878     return result;
879 }
880 
Wcstoull_One(napi_env env, napi_callback_info info)881 static napi_value Wcstoull_One(napi_env env, napi_callback_info info)
882 {
883     wchar_t wsNumbers[] = L"250068492 7b06af00 1100011011110101010001100000 0x6fffff";
884     wchar_t *pEnd;
885     unsigned long long int ulli1 = wcstoull(wsNumbers, &pEnd, PARAM_10);
886     unsigned long long int ulli2 = wcstoull(pEnd, &pEnd, PARAM_16);
887     unsigned long long int ulli3 = wcstoull(pEnd, &pEnd, PARAM_2);
888     unsigned long long int ulli4 = wcstoull(pEnd, nullptr, PARAM_0);
889     napi_value result = nullptr;
890     napi_create_int32(env,
891                       ulli1 == PARAM_250068492 && ulli2 == PARAM_2064035584 && ulli3 == PARAM_208622688 &&
892                           ulli4 == PARAM_7340031,
893                       &result);
894     return result;
895 }
896 
Wcswcs_One(napi_env env, napi_callback_info info)897 static napi_value Wcswcs_One(napi_env env, napi_callback_info info)
898 {
899     wchar_t wstr[] = L"abcd";
900     wchar_t wch[] = L"a";
901     wchar_t *q = wcswcs(wstr, wch);
902     napi_value result = nullptr;
903     napi_create_int32(env, q - wstr == ERRON_0, &result);
904     return result;
905 }
906 
Wcswidth_One(napi_env env, napi_callback_info info)907 static napi_value Wcswidth_One(napi_env env, napi_callback_info info)
908 {
909     int want = PARAM_2;
910     int ret = wcswidth(L"abc", want);
911     napi_value result = nullptr;
912     napi_create_int32(env, ret == want, &result);
913     return result;
914 }
915 
Wcsxfrm_One(napi_env env, napi_callback_info info)916 static napi_value Wcsxfrm_One(napi_env env, napi_callback_info info)
917 {
918     wchar_t wc[] = L"ABCD";
919     wchar_t src[PARAM_20] = {PARAM_0};
920     size_t ret = wcsxfrm(src, wc, PARAM_5);
921     napi_value result = nullptr;
922     napi_create_int32(env, ret == wcslen(wc), &result);
923     return result;
924 }
925 
Wcsxfrml_One(napi_env env, napi_callback_info info)926 static napi_value Wcsxfrml_One(napi_env env, napi_callback_info info)
927 {
928     locale_t localInfo = nullptr;
929     wchar_t wc[] = L"ABCD";
930     wchar_t src[PARAM_20] = {PARAM_0};
931     size_t ret = wcsxfrm_l(src, wc, PARAM_5, localInfo);
932     napi_value result = nullptr;
933     napi_create_int32(env, ret == wcslen(wc), &result);
934     return result;
935 }
936 
Wctob_One(napi_env env, napi_callback_info info)937 static napi_value Wctob_One(napi_env env, napi_callback_info info)
938 {
939     wchar_t c = L'A';
940     int ret = wctob(c);
941     napi_value result = nullptr;
942     napi_create_int32(env, ret == 'A', &result);
943     return result;
944 }
945 
Wctomb_One(napi_env env, napi_callback_info info)946 static napi_value Wctomb_One(napi_env env, napi_callback_info info)
947 {
948     char byte[SIZE_256] = {PARAM_0};
949     int ret = wctomb(byte, L'h');
950     napi_value result = nullptr;
951     napi_create_int32(env, ret == SUCCESS, &result);
952     return result;
953 }
954 
Wcwidth_One(napi_env env, napi_callback_info info)955 static napi_value Wcwidth_One(napi_env env, napi_callback_info info)
956 {
957     int ret = MINUSONE;
958     const int INPUT_VALUE[PARAM_12] = {0x0300, 0x20dd, 0x00ad,  0x200b,  0x4e00, 0x9fff,
959                                        0x3400, 0x4dbf, 0x20000, 0x2a6df, 0xac00, 0xd7a3};
960     ret = wcwidth(INPUT_VALUE[PARAM_0]);
961     NAPI_ASSERT(env, ret == ERRON_0, "wcwidth Error");
962     ret = wcwidth(INPUT_VALUE[PARAM_1]);
963     NAPI_ASSERT(env, ret == ERRON_0, "wcwidth Error");
964     ret = wcwidth(INPUT_VALUE[PARAM_2]);
965     NAPI_ASSERT(env, ret == SUCCESS, "wcwidth Error");
966     ret = wcwidth(INPUT_VALUE[PARAM_3]);
967     NAPI_ASSERT(env, ret == ERRON_0, "wcwidth Error");
968     ret = wcwidth(INPUT_VALUE[PARAM_4]);
969     NAPI_ASSERT(env, ret == PARAM_2, "wcwidth Error");
970     ret = wcwidth(INPUT_VALUE[PARAM_11]);
971     NAPI_ASSERT(env, ret == PARAM_2, "wcwidth Error");
972     napi_value result = nullptr;
973     napi_create_int32(env, ret == PARAM_2, &result);
974     return result;
975 }
976 
Wmemchr_One(napi_env env, napi_callback_info info)977 static napi_value Wmemchr_One(napi_env env, napi_callback_info info)
978 {
979     wchar_t wcs[] = L"Example wide string";
980     wchar_t *ret = wmemchr(wcs, L'p', wcslen(wcs));
981     NAPI_ASSERT(env, ret != nullptr, "wcwidth Error");
982     napi_value result = nullptr;
983     napi_create_int32(env, wcscmp(ret, L"ple wide string") == ERRON_0, &result);
984     return result;
985 }
986 
Wmemcmp_One(napi_env env, napi_callback_info info)987 static napi_value Wmemcmp_One(napi_env env, napi_callback_info info)
988 {
989     int ret = MINUSONE;
990     wchar_t str[] = L"ABCDEFG";
991     wchar_t tar[] = L"ABCDEFF";
992     ret = wmemcmp(str, tar, wcslen(str));
993     NAPI_ASSERT(env, ret == SUCCESS, "wmemcmp Error");
994     ret = wmemcmp(tar, str, wcslen(str));
995     NAPI_ASSERT(env, ret == MPARAM_1, "wmemcmp Error");
996     ret = wmemcmp(str, str, wcslen(str));
997     NAPI_ASSERT(env, ret == ERRON_0, "wmemcmp Error");
998     napi_value result = nullptr;
999     napi_create_int32(env, ret == ERRON_0, &result);
1000     return result;
1001 }
1002 
Wmemcpy_One(napi_env env, napi_callback_info info)1003 static napi_value Wmemcpy_One(napi_env env, napi_callback_info info)
1004 {
1005     wchar_t dest[PARAM_3];
1006     wchar_t src[] = L"aaa";
1007     wchar_t *ret = wmemcpy(dest, src, PARAM_3);
1008     NAPI_ASSERT(env, ret != nullptr, "wmemcpy Error");
1009     napi_value result = nullptr;
1010     napi_create_int32(env, wcsncmp(dest, src, PARAM_3) == ERRON_0, &result);
1011     return result;
1012 }
1013 
Wmemmove_One(napi_env env, napi_callback_info info)1014 static napi_value Wmemmove_One(napi_env env, napi_callback_info info)
1015 {
1016     wchar_t src[] = L"This is a c test for wmemmove function";
1017     wchar_t *dest = &src[PARAM_0];
1018     wchar_t *ret = wmemmove(dest, src, PARAM_5);
1019     NAPI_ASSERT(env, ret != nullptr, "wmemmove Error");
1020     napi_value result = nullptr;
1021     napi_create_int32(env, ret == dest, &result);
1022     return result;
1023 }
1024 
Wmemset_One(napi_env env, napi_callback_info info)1025 static napi_value Wmemset_One(napi_env env, napi_callback_info info)
1026 {
1027     wchar_t wcs[] = L"almost every programmer should know wmemset!";
1028     wchar_t *ret = wmemset(wcs, L'-', PARAM_6);
1029     NAPI_ASSERT(env, ret != nullptr, "wmemset Error");
1030     napi_value result = nullptr;
1031     napi_create_int32(env, wcscmp(ret, L"------ every programmer should know wmemset!") == ERRON_0, &result);
1032     return result;
1033 }
1034 
1035 extern "C" int Vfwprintf_Test(const wchar_t *format, ...);
Vfwprintf_Test(FILE *stream, const wchar_t *format, ...)1036 int Vfwprintf_Test(FILE *stream, const wchar_t *format, ...)
1037 {
1038     va_list args;
1039     va_start(args, format);
1040     int ret = vfwprintf(stream, format, args);
1041     va_end(args);
1042     return ret;
1043 }
Vfwprintf_One(napi_env env, napi_callback_info info)1044 static napi_value Vfwprintf_One(napi_env env, napi_callback_info info)
1045 {
1046     FILE *fp = fopen(TEMP_FILE, "w");
1047     NAPI_ASSERT(env, fp != nullptr, "Vfwprintf_One fopen Error");
1048     int ret = MINUSONE;
1049     ret = Vfwprintf_Test(fp, L"Call with %d variable argument.\n", PARAM_1);
1050     NAPI_ASSERT(env, ret = PARAM_31, "vfwprintf Error");
1051     ret = Vfwprintf_Test(fp, L"Call with %d variable %ls.\n", PARAM_2, L"arguments");
1052     fclose(fp);
1053     remove(TEMP_FILE);
1054     napi_value result = nullptr;
1055     napi_create_int32(env, ret == PARAM_32, &result);
1056     return result;
1057 }
1058 
1059 extern "C" int Vswprintf_Test(const wchar_t *format, ...);
Vswprintf_Test(const wchar_t *format, ...)1060 int Vswprintf_Test(const wchar_t *format, ...)
1061 {
1062     wchar_t buffer[SIZE_256];
1063     va_list args;
1064     va_start(args, format);
1065     int ret = vswprintf(buffer, SIZE_256, format, args);
1066     fputws(buffer, stdout);
1067     va_end(args);
1068     return ret;
1069 }
1070 
Vswprintf_One(napi_env env, napi_callback_info info)1071 static napi_value Vswprintf_One(napi_env env, napi_callback_info info)
1072 {
1073     wchar_t str[] = L"test string has %d wide characters.\n";
1074     size_t ret = MINUSONE;
1075     ret = Vswprintf_Test(str, wcslen(str));
1076     napi_value result = nullptr;
1077     napi_create_int32(env, ret == wcslen(str), &result);
1078     return result;
1079 }
1080 
1081 extern "C" int Vwscanf_Test(const wchar_t *format, ...);
Vwscanf_Test(const wchar_t *format, ...)1082 int Vwscanf_Test(const wchar_t *format, ...)
1083 {
1084     va_list args;
1085     va_start(args, format);
1086     int ret = vwscanf(format, args);
1087     va_end(args);
1088     return ret;
1089 }
1090 
Vwscanf_One(napi_env env, napi_callback_info info)1091 static napi_value Vwscanf_One(napi_env env, napi_callback_info info)
1092 {
1093     FILE *fp = fopen(TEMP_FILE, "w");
1094     NAPI_ASSERT(env, fp != nullptr, "Vwscanf_One fopen Error");
1095     wchar_t wstr[] = L"vwscanf";
1096     fputws(wstr, fp);
1097     fseek(fp, PARAM_0, SEEK_SET);
1098     FILE *fp1 = freopen(TEMP_FILE, "r", stdin);
1099     NAPI_ASSERT(env, fp1 != nullptr, "Vwscanf_One freopen Error");
1100     wchar_t wch[PARAM_20];
1101     int ret = Vwscanf_Test(L"%ls", wch);
1102     NAPI_ASSERT(env, ret == SUCCESS, "vwscanf Error");
1103     fclose(fp);
1104     fclose(fp1);
1105     remove(TEMP_FILE);
1106     napi_value result = nullptr;
1107     napi_create_int32(env, wcscmp(wch, wstr) == ERRON_0, &result);
1108     return result;
1109 }
1110 
1111 extern "C" int Vwprintf_Test(const wchar_t *format, ...);
Vwprintf_Test(const wchar_t *format, ...)1112 int Vwprintf_Test(const wchar_t *format, ...)
1113 {
1114     va_list args;
1115     va_start(args, format);
1116     int ret = vwprintf(format, args);
1117     va_end(args);
1118     return ret;
1119 }
Vwprintf_One(napi_env env, napi_callback_info info)1120 static napi_value Vwprintf_One(napi_env env, napi_callback_info info)
1121 {
1122     int ret = MINUSONE;
1123     ret = Vwprintf_Test(L"Call with %d variable %ls.\n", PARAM_2, L"arguments");
1124     napi_value result = nullptr;
1125     napi_create_int32(env, ret == PARAM_32, &result);
1126     return result;
1127 }
1128 
1129 extern "C" int Vfwscanf_Test(FILE *fp, const wchar_t *format, ...);
Vfwscanf_Test(FILE *fp, const wchar_t *format, ...)1130 int Vfwscanf_Test(FILE *fp, const wchar_t *format, ...)
1131 {
1132     va_list args;
1133     va_start(args, format);
1134     int result = vfwscanf(fp, format, args);
1135     va_end(args);
1136     return result;
1137 }
1138 
Vfwscanf_One(napi_env env, napi_callback_info info)1139 static napi_value Vfwscanf_One(napi_env env, napi_callback_info info)
1140 {
1141     setlocale(LC_ALL, "en_US.UTF-8");
1142     wchar_t symbol[] = L"\u0915\u0916\u0917\u0918\u0919";
1143     wchar_t names[PARAM_5][PARAM_5] = {L"Ka", L"Kha", L"Ga", L"Gha", L"Nga"};
1144     FILE *fp = fopen(TEMP_FILE, "w+");
1145     NAPI_ASSERT(env, fp != nullptr, "vfwscanf fopen Error");
1146     for (int i = PARAM_0; i < PARAM_5; i++) {
1147         fwprintf(fp, L"%lc %ls ", symbol[i], names[i]);
1148     }
1149     fseek(fp, PARAM_0, SEEK_SET);
1150     wchar_t ch, str[PARAM_5];
1151     int ret = PARAM_0;
1152     for (ret = PARAM_0; ret < PARAM_5; ret++) {
1153         Vfwscanf_Test(fp, L"%lc %ls ", &ch, str);
1154         NAPI_ASSERT(env, wcscmp(str, names[ret]) == ERRON_0, "vfwscanf Error");
1155     }
1156     fclose(fp);
1157     remove(TEMP_FILE);
1158     napi_value result = nullptr;
1159     napi_create_int32(env, ret == PARAM_5, &result);
1160     return result;
1161 }
1162 
Getwchar_One(napi_env env, napi_callback_info info)1163 static napi_value Getwchar_One(napi_env env, napi_callback_info info)
1164 {
1165     FILE *fp = fopen(TEMP_FILE, "w");
1166     NAPI_ASSERT(env, fp != nullptr, "Getwchar_One fopen Error");
1167     wchar_t wstr[] = L"getwchar";
1168     fputws(wstr, fp);
1169     fseek(fp, PARAM_0, SEEK_SET);
1170     FILE *fp1 = freopen(TEMP_FILE, "r", stdin);
1171     NAPI_ASSERT(env, fp1 != nullptr, "Getwchar_One freopen Error");
1172     wint_t ret = getwchar();
1173     fclose(fp);
1174     fclose(fp1);
1175     remove(TEMP_FILE);
1176     napi_value result = nullptr;
1177     napi_create_int32(env, static_cast<wchar_t>(ret) == L'g', &result);
1178     return result;
1179 }
1180 
Wscanf_One(napi_env env, napi_callback_info info)1181 static napi_value Wscanf_One(napi_env env, napi_callback_info info)
1182 {
1183     FILE *fp = fopen(TEMP_FILE, "w");
1184     NAPI_ASSERT(env, fp != nullptr, "Wscanf_One fopen Error");
1185     wchar_t wstr[] = L"testwscanf";
1186     fputws(wstr, fp);
1187     fseek(fp, PARAM_0, SEEK_SET);
1188     FILE *fp1 = freopen(TEMP_FILE, "r", stdin);
1189     NAPI_ASSERT(env, fp1 != nullptr, "Wscanf_One freopen Error");
1190     wchar_t wch[50] = {PARAM_0};
1191     int ret = wscanf(L"%ls", wch);
1192     NAPI_ASSERT(env, ret == SUCCESS, "wscanf Error");
1193     fclose(fp);
1194     fclose(fp1);
1195     remove(TEMP_FILE);
1196     napi_value result = nullptr;
1197     napi_create_int32(env, wcscmp(wch, L"testwscanf") == ERRON_0, &result);
1198     return result;
1199 }
1200 
1201 EXTERN_C_START
Init(napi_env env, napi_value exports)1202 static napi_value Init(napi_env env, napi_value exports)
1203 {
1204     napi_property_descriptor desc[] = {
1205         {"Btowc_One", nullptr, Btowc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1206         {"Btowc_Two", nullptr, Btowc_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1207         {"Fputwc_One", nullptr, Fputwc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1208         {"Fputws_One", nullptr, Fputws_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1209         {"Fwide_One", nullptr, Fwide_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1210         {"Fwide_Two", nullptr, Fwide_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1211         {"Fwprintf_One", nullptr, Fwprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1212         {"Fwprintf_Two", nullptr, Fwprintf_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1213         {"Fwscanf_One", nullptr, Fwscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1214         {"Fwscanf_Two", nullptr, Fwscanf_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1215         {"Getwchar_One", nullptr, Getwchar_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1216         {"Mbrtowc_One", nullptr, Mbrtowc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1217         {"Mbsinit_One", nullptr, Mbsinit_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1218         {"Mbsnrtowcs_One", nullptr, Mbsnrtowcs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1219         {"Mbsrtowcs_One", nullptr, Mbsrtowcs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1220         {"Mbstowcs_One", nullptr, Mbstowcs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1221         {"Mbtowc_One", nullptr, Mbtowc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1222         {"Mbtowc_Two", nullptr, Mbtowc_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1223         {"OpenWmemstream_One", nullptr, OpenWmemstream_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1224         {"Putwc_One", nullptr, Putwc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1225         {"PutWChar_One", nullptr, PutWChar_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1226         {"Swprintf_One", nullptr, Swprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1227         {"Swprintf_Two", nullptr, Swprintf_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1228         {"Swscanf_One", nullptr, Swscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1229         {"Swscanf_Two", nullptr, Swscanf_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1230         {"Towlower_One", nullptr, Towlower_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1231         {"Towupper_One", nullptr, Towupper_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1232         {"Ungetwc_One", nullptr, Ungetwc_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1233         {"Vfwprintf_One", nullptr, Vfwprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1234         {"Vfwscanf_One", nullptr, Vfwscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1235         {"Vswprintf_One", nullptr, Vswprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1236         {"Vwprintf_One", nullptr, Vwprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1237         {"Vwscanf_One", nullptr, Vwscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1238         {"Wcpcpy_One", nullptr, Wcpcpy_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1239         {"Wcpncpy_One", nullptr, Wcpncpy_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1240         {"Wcrtomb_One", nullptr, Wcrtomb_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1241         {"Wcscasecmp_One", nullptr, Wcscasecmp_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1242         {"Wcscasecmpl_One", nullptr, Wcscasecmpl_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1243         {"Wcscat_One", nullptr, Wcscat_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1244         {"Wcschr_One", nullptr, Wcschr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1245         {"Wcscmp_One", nullptr, Wcscmp_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1246         {"Wcscoll_One", nullptr, Wcscoll_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1247         {"Wcscolll_One", nullptr, Wcscolll_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1248         {"Wcscpy_One", nullptr, Wcscpy_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1249         {"Wcscspn_One", nullptr, Wcscspn_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1250         {"Wcsdup_One", nullptr, Wcsdup_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1251         {"Wcsftime_One", nullptr, Wcsftime_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1252         {"Wcsftimel_One", nullptr, Wcsftimel_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1253         {"Wcslen_One", nullptr, Wcslen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1254         {"Wcsncasecmp_One", nullptr, Wcsncasecmp_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1255         {"Wcsncasecmpl_One", nullptr, Wcsncasecmpl_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1256         {"Wcsncat_One", nullptr, Wcsncat_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1257         {"Wcsncmp_One", nullptr, Wcsncmp_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1258         {"Wcsncpy_One", nullptr, Wcsncpy_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1259         {"Wcsnlen_One", nullptr, Wcsnlen_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1260         {"Wcsnrtombs_One", nullptr, Wcsnrtombs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1261         {"Wcspbrk_One", nullptr, Wcspbrk_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1262         {"Wcsrchr_One", nullptr, Wcsrchr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1263         {"Wcsrtombs_One", nullptr, Wcsrtombs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1264         {"Wcsspn_One", nullptr, Wcsspn_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1265         {"Wcsstr_One", nullptr, Wcsstr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1266         {"Wcstod_One", nullptr, Wcstod_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1267         {"Wcstof_One", nullptr, Wcstof_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1268         {"Wcstok_One", nullptr, Wcstok_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1269         {"Wcstol_One", nullptr, Wcstol_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1270         {"Wcstold_One", nullptr, Wcstold_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1271         {"Wcstoll_One", nullptr, Wcstoll_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1272         {"Wcstombs_One", nullptr, Wcstombs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1273         {"Wcstoul_One", nullptr, Wcstoul_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1274         {"Wcstoull_One", nullptr, Wcstoull_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1275         {"Wcswcs_One", nullptr, Wcswcs_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1276         {"Wcswidth_One", nullptr, Wcswidth_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1277         {"Wcsxfrm_One", nullptr, Wcsxfrm_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1278         {"Wcsxfrml_One", nullptr, Wcsxfrml_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1279         {"Wctob_One", nullptr, Wctob_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1280         {"Wctomb_One", nullptr, Wctomb_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1281         {"Wcwidth_One", nullptr, Wcwidth_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1282         {"Wmemchr_One", nullptr, Wmemchr_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1283         {"Wmemcmp_One", nullptr, Wmemcmp_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1284         {"Wmemcpy_One", nullptr, Wmemcpy_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1285         {"Wmemmove_One", nullptr, Wmemmove_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1286         {"Wmemset_One", nullptr, Wmemset_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1287         {"Wprintf_One", nullptr, Wprintf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1288         {"Wprintf_Two", nullptr, Wprintf_Two, nullptr, nullptr, nullptr, napi_default, nullptr},
1289         {"Wscanf_One", nullptr, Wscanf_One, nullptr, nullptr, nullptr, napi_default, nullptr},
1290     };
1291     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1292     return exports;
1293 }
1294 
1295 EXTERN_C_END
1296 
1297 static napi_module demoModule = {
1298     .nm_version = 1,
1299     .nm_flags = 0,
1300     .nm_filename = nullptr,
1301     .nm_register_func = Init,
1302     .nm_modname = "wcharndk1",
1303     .nm_priv = ((void *)0),
1304     .reserved = {0},
1305 };
1306 
RegisterEntryModule(void)1307 extern "C" __attribute__((constructor)) void RegisterEntryModule(void) { napi_module_register(&demoModule); }
1308