1 /*
2 * Copyright (c) 2021 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/native_common.h"
17 #include "napi/native_api.h"
18 #include "securec.h"
19 #include <stdint.h>
20 #include <string>
21 #include <stdio.h>
22 #include <vector>
23 #include <malloc.h>
24 #include <ctime>
25 #include <thread>
26 #include <uv.h>
27
28 static napi_ref test_reference = NULL;
29 const int TAG_NUMBER = 666;
30 const int NUMBER_FIVE = 5;
31 static int g_delCount = 0;
32
add_returned_status(napi_env env,const char * key,napi_value object,const char * expected_message,napi_status expected_status,napi_status actual_status)33 static void add_returned_status(napi_env env,
34 const char* key,
35 napi_value object,
36 const char* expected_message,
37 napi_status expected_status,
38 napi_status actual_status)
39 {
40 char napi_message_string[100] = "";
41 napi_value prop_value;
42
43 if (actual_status != expected_status) {
44 printf("Invalid status [%d]", actual_status);
45 }
46
47 NAPI_CALL_RETURN_VOID(env,
48 napi_create_string_utf8(env,
49 (actual_status == expected_status ?
50 expected_message :
51 napi_message_string),
52 NAPI_AUTO_LENGTH,
53 &prop_value));
54 NAPI_CALL_RETURN_VOID(env,
55 napi_set_named_property(env,
56 object,
57 key,
58 prop_value));
59 }
60
add_last_status(napi_env env,const char * key,napi_value return_value)61 static void add_last_status(napi_env env, const char* key, napi_value return_value)
62 {
63 napi_value prop_value;
64 const napi_extended_error_info* p_last_error;
65 NAPI_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error));
66
67 NAPI_CALL_RETURN_VOID(env,
68 napi_create_string_utf8(env,
69 (p_last_error->error_message == NULL ?
70 "napi_ok" :
71 p_last_error->error_message),
72 NAPI_AUTO_LENGTH,
73 &prop_value));
74 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env,
75 return_value,
76 key,
77 prop_value));
78 }
79
getLastErrorInfo(napi_env env,napi_callback_info info)80 static napi_value getLastErrorInfo(napi_env env, napi_callback_info info)
81 {
82 napi_value value;
83 NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
84 double double_value;
85 napi_status status = napi_get_value_double(env, value, &double_value);
86 NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
87 const napi_extended_error_info * error_info = 0;
88 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
89
90 NAPI_ASSERT(env, error_info->error_code == status,
91 "Last error info code should match last status");
92 NAPI_ASSERT(env, error_info->error_message,
93 "Last error info message should not be null");
94 napi_value _value;
95 NAPI_CALL(env, napi_create_int32(env, error_info->error_code, &_value));
96 return _value;
97 }
98
cleanUpErrorInfo(napi_env env,napi_callback_info info)99 static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info)
100 {
101 const napi_extended_error_info * error_info = 0;
102 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
103
104 napi_value result;
105 bool is_ok = error_info->error_code == napi_ok;
106 NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
107
108 return result;
109 }
110
throwExistingError(napi_env env,napi_callback_info info)111 static napi_value throwExistingError(napi_env env, napi_callback_info info)
112 {
113 napi_value code = nullptr;
114 napi_value message = nullptr;
115 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
116 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
117 napi_value error = nullptr;
118 napi_create_error(env, code, message, &error);
119 NAPI_ASSERT(env, error != nullptr, "error succes");
120 bool isError = false;
121 napi_is_error(env, error, &isError);
122 NAPI_ASSERT(env, isError, "error succes");
123
124 NAPI_CALL(env, napi_throw(env, error));
125
126 napi_value _value;
127 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
128 return _value;
129 }
130
throwError(napi_env env,napi_callback_info info)131 static napi_value throwError(napi_env env, napi_callback_info info)
132 {
133 napi_value code = nullptr;
134 napi_value message = nullptr;
135 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
136 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
137 napi_value error = nullptr;
138 napi_create_error(env, code, message, &error);
139 NAPI_ASSERT(env, error != nullptr, "error succes");
140 bool isError = false;
141 napi_is_error(env, error, &isError);
142 NAPI_ASSERT(env, isError, "error succes");
143 napi_throw_error(env, "500", "Common error");
144 napi_value _value;
145 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
146 return _value;
147 }
148
throwTypeError(napi_env env,napi_callback_info info)149 static napi_value throwTypeError(napi_env env, napi_callback_info info)
150 {
151 napi_value code = nullptr;
152 napi_value message = nullptr;
153 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
154 napi_create_string_latin1(env, "type error 500", NAPI_AUTO_LENGTH, &message);
155 napi_value error = nullptr;
156 napi_create_type_error(env, code, message, &error);
157 NAPI_ASSERT(env, error != nullptr, "error succes");
158 bool isError = false;
159 napi_is_error(env, error, &isError);
160 NAPI_ASSERT(env, isError, "error succes");
161 napi_throw_type_error(env, NULL, "type error1");
162
163 napi_value _value;
164 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
165 return _value;
166 }
167
throwRangeError(napi_env env,napi_callback_info info)168 static napi_value throwRangeError(napi_env env, napi_callback_info info)
169 {
170 napi_value code = nullptr;
171 napi_value message = nullptr;
172 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
173 napi_create_string_latin1(env, "range error 500", NAPI_AUTO_LENGTH, &message);
174 napi_value error = nullptr;
175 napi_create_range_error(env, code, message, &error);
176 NAPI_ASSERT(env, error != nullptr, "error succes");
177 bool isError = false;
178 napi_is_error(env, error, &isError);
179 NAPI_ASSERT(env, isError, "error succes");
180 napi_throw_range_error(env, NULL, "range error");
181
182 napi_value _value;
183 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
184 return _value;
185 }
186
isError(napi_env env,napi_callback_info info)187 static napi_value isError(napi_env env, napi_callback_info info)
188 {
189 size_t argc = 1;
190 napi_value args[1];
191 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
192
193 bool r;
194 NAPI_CALL(env, napi_is_error(env, args[0], &r));
195
196 napi_value result;
197 NAPI_CALL(env, napi_get_boolean(env, r, &result));
198
199 return result;
200 }
201
createError(napi_env env,napi_callback_info info)202 static napi_value createError(napi_env env, napi_callback_info info)
203 {
204 napi_value code = nullptr;
205 napi_value message = nullptr;
206
207 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
208 napi_create_string_latin1(env, "common error", NAPI_AUTO_LENGTH, &message);
209
210 napi_value error = nullptr;
211 napi_create_error(env, code, message, &error);
212 NAPI_ASSERT(env, error != nullptr, "error succes");
213
214 napi_value _value;
215 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
216 return _value;
217 }
218
createTypeError(napi_env env,napi_callback_info info)219 static napi_value createTypeError(napi_env env, napi_callback_info info)
220 {
221 napi_value code = nullptr;
222 napi_value message = nullptr;
223 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
224 napi_create_string_latin1(env, "type error", NAPI_AUTO_LENGTH, &message);
225 napi_value error = nullptr;
226 napi_create_type_error(env, code, message, &error);
227 NAPI_ASSERT(env, error != nullptr, "error succes");
228
229 napi_value _value;
230 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
231 return _value;
232 }
233
createRangeError(napi_env env,napi_callback_info info)234 static napi_value createRangeError(napi_env env, napi_callback_info info)
235 {
236 napi_value code = nullptr;
237 napi_value message = nullptr;
238 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
239 napi_create_string_latin1(env, "range error", NAPI_AUTO_LENGTH, &message);
240 napi_value error = nullptr;
241 napi_create_range_error(env, code, message, &error);
242
243 NAPI_ASSERT(env, error != nullptr, "error succes");
244
245 napi_value _value;
246 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
247 return _value;
248 }
249
getAndClearLastException(napi_env env,napi_callback_info info)250 static napi_value getAndClearLastException(napi_env env, napi_callback_info info)
251 {
252 napi_value code = nullptr;
253 napi_value message = nullptr;
254 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
255 napi_create_string_latin1(env, "tag range error", NAPI_AUTO_LENGTH, &message);
256
257 napi_value error = nullptr;
258 napi_create_range_error(env, code, message, &error);
259 NAPI_ASSERT(env, error != nullptr, "tag error succes");
260
261 bool isError = false;
262 napi_is_error(env, error, &isError);
263 NAPI_ASSERT(env, isError, "tag isError 1");
264
265 napi_value ex;
266 napi_get_and_clear_last_exception(env, &ex);
267
268 bool exceptionWasPending = true;
269 napi_is_exception_pending(env, &exceptionWasPending);
270 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 1");
271
272 napi_throw(env, error);
273
274 napi_is_exception_pending(env, &exceptionWasPending);
275 NAPI_ASSERT(env, exceptionWasPending, "tag exceptionWasPending 2");
276
277 napi_value ex1;
278 napi_get_and_clear_last_exception(env, &ex1);
279 isError = false;
280 napi_is_error(env, ex1, &isError);
281 NAPI_ASSERT(env, isError, "tag isError 2");
282
283 napi_is_exception_pending(env, &exceptionWasPending);
284 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 3");
285
286 return ex1;
287 }
288
isExceptionPending(napi_env env,napi_callback_info info)289 static napi_value isExceptionPending(napi_env env, napi_callback_info info)
290 {
291 bool exceptionWasPending = true;
292 napi_is_exception_pending(env, &exceptionWasPending);
293
294 NAPI_ASSERT(env, !exceptionWasPending, "isExceptionPending failed");
295
296 napi_value _value;
297 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
298 return _value;
299 }
300
openAndCloseHandleScope(napi_env env,napi_callback_info info)301 static napi_value openAndCloseHandleScope(napi_env env, napi_callback_info info)
302 {
303 napi_handle_scope scope;
304 NAPI_CALL(env, napi_open_handle_scope(env, &scope));
305 napi_value output = NULL;
306 NAPI_CALL(env, napi_create_object(env, &output));
307 NAPI_CALL(env, napi_close_handle_scope(env, scope));
308 return output;
309 }
310
openAndCloseEscapableHandleScope(napi_env env,napi_callback_info info)311 static napi_value openAndCloseEscapableHandleScope(napi_env env, napi_callback_info info)
312 {
313 napi_escapable_handle_scope scope;
314 NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
315 napi_value output = NULL;
316 napi_value escapee = NULL;
317 NAPI_CALL(env, napi_create_object(env, &output));
318 NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
319 NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
320 return escapee;
321 }
322
createReference(napi_env env,napi_callback_info info)323 static napi_value createReference(napi_env env, napi_callback_info info)
324 {
325 napi_value result = nullptr;
326
327 napi_create_int32(env, TAG_NUMBER, &result);
328 NAPI_CALL(env, napi_create_reference(env, result, 1, &test_reference));
329 napi_value value;
330 NAPI_CALL(env, napi_create_int32(env, 0, &value));
331 return value;
332 }
333
getAndDeleteReference(napi_env env,napi_callback_info info)334 static napi_value getAndDeleteReference(napi_env env, napi_callback_info info)
335 {
336 NAPI_ASSERT(env, test_reference != NULL,
337 "A reference must have been created.");
338
339 napi_value refValue = nullptr;
340 napi_get_reference_value(env, test_reference, &refValue);
341
342 int32_t value = 0;
343 napi_get_value_int32(env, refValue, &value);
344 NAPI_ASSERT(env, value == TAG_NUMBER,
345 "refValue expect equal to 666.");
346
347 NAPI_CALL(env, napi_delete_reference(env, test_reference));
348 test_reference = NULL;
349 return NULL;
350 }
351
referenceRefAndUnref(napi_env env,napi_callback_info info)352 static napi_value referenceRefAndUnref(napi_env env, napi_callback_info info)
353 {
354 napi_value result = nullptr;
355 napi_ref resultRef = nullptr;
356 uint32_t resultRefCount = 0;
357
358 napi_create_object(env, &result);
359 napi_create_reference(env, result, 1, &resultRef);
360
361 napi_reference_ref(env, resultRef, &resultRefCount);
362 NAPI_ASSERT(env, resultRefCount == 2,
363 "resultRefCount expect equal to 2");
364 napi_reference_unref(env, resultRef, &resultRefCount);
365 NAPI_ASSERT(env, resultRefCount == 1,
366 "resultRefCount expect equal to 1.");
367
368 napi_value refValue = nullptr;
369 napi_get_reference_value(env, resultRef, &refValue);
370 NAPI_ASSERT(env, refValue != NULL,
371 "A reference must have been created.");
372 napi_delete_reference(env, resultRef);
373
374 napi_value _value;
375 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
376
377 return _value;
378 }
379
createArrayAndGetLength(napi_env env,napi_callback_info info)380 static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info)
381 {
382 size_t argc = 1;
383 napi_value args[1];
384 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
385
386 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
387
388 napi_valuetype valuetype0;
389 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
390
391 NAPI_ASSERT(env, valuetype0 == napi_object,
392 "Wrong type of arguments. Expects an array as first argument.");
393
394 napi_value ret;
395 NAPI_CALL(env, napi_create_array(env, &ret));
396
397 uint32_t i, length;
398 NAPI_CALL(env, napi_get_array_length(env, args[0], &length));
399
400 for (i = 0; i < length; i++) {
401 napi_value e;
402 NAPI_CALL(env, napi_get_element(env, args[0], i, &e));
403 NAPI_CALL(env, napi_set_element(env, ret, i, e));
404 }
405 return ret;
406 }
407
getArrayWithLength(napi_env env,napi_callback_info info)408 static napi_value getArrayWithLength(napi_env env, napi_callback_info info)
409 {
410 size_t argc = 1;
411 napi_value args[1];
412 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
413
414 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
415
416 napi_valuetype valuetype0;
417 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
418
419 NAPI_ASSERT(env, valuetype0 == napi_object,
420 "Wrong type of arguments. Expects an integer the first argument.");
421
422 uint32_t array_length = 0;
423 NAPI_CALL(env, napi_get_array_length(env, args[0], &array_length));
424 NAPI_ASSERT(env, array_length == 2, "array_length expect equal to 2");
425
426 napi_value ret;
427 NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret));
428 for (uint32_t i = 0; i < array_length * 2; i++) {
429 napi_value e;
430 NAPI_CALL(env, napi_create_uint32(env, i, &e));
431 NAPI_CALL(env, napi_set_element(env, ret, i, e));
432 }
433
434 return ret;
435 }
436
createExternal(napi_env env,napi_callback_info info)437 static napi_value createExternal(napi_env env, napi_callback_info info)
438 {
439 const char testStr[] = "test";
440 napi_value external = nullptr;
441 napi_create_external(
442 env, (void*)testStr,
443 [](napi_env env, void* data, void* hint) {},
444 (void*)testStr, &external);
445 void* tempExternal = nullptr;
446 NAPI_CALL(env, napi_get_value_external(env, external, &tempExternal));
447 NAPI_ASSERT(env, tempExternal != nullptr, "tempExternal expect not equal to nullptr");
448 NAPI_ASSERT(env, tempExternal == testStr, "tempExternal expect equal to testStr");
449
450 napi_value _value;
451 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
452
453 return _value;
454 }
455
createExternalArraybuffer(napi_env env,napi_callback_info info)456 static napi_value createExternalArraybuffer(napi_env env, napi_callback_info info)
457 {
458 int* testInt = (int*)malloc(sizeof(int));
459 *testInt = TAG_NUMBER;
460 napi_value external = nullptr;
461 size_t arrayBufferSize = 1024;
462
463 napi_create_external_arraybuffer(
464 env, (void*)testInt, arrayBufferSize,
465 [](napi_env env, void* data, void* hint) {
466 int* temp = static_cast<int*>(data);
467 free(temp);
468 temp = nullptr;
469 },
470 (void*)testInt, &external);
471
472 return external;
473 }
474
createObject(napi_env env,napi_callback_info info)475 static napi_value createObject(napi_env env, napi_callback_info info)
476 {
477 napi_value result = nullptr;
478 NAPI_CALL(env, napi_create_object(env, &result));
479 NAPI_ASSERT(env, result != nullptr, "napi_create_object");
480 return result;
481 }
482
createSymbol(napi_env env,napi_callback_info info)483 static napi_value createSymbol(napi_env env, napi_callback_info info)
484 {
485 size_t argc = 1;
486 napi_value args[1];
487 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
488
489 napi_value description = NULL;
490 if (argc >= 1) {
491 napi_valuetype valuetype;
492 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
493
494 NAPI_ASSERT(env, valuetype == napi_string,
495 "Wrong type of arguments. Expects a string.");
496
497 description = args[0];
498 }
499
500 napi_value symbol;
501 NAPI_CALL(env, napi_create_symbol(env, description, &symbol));
502
503 napi_valuetype valuetypeSymbol;
504 NAPI_CALL(env, napi_typeof(env, symbol, &valuetypeSymbol));
505
506 NAPI_ASSERT(env, valuetypeSymbol == napi_symbol,
507 "Wrong type of arguments. Expects a string.");
508 napi_value _value;
509 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
510
511 return _value;
512 }
513
createTypeArray(napi_env env,napi_callback_info info)514 static napi_value createTypeArray(napi_env env, napi_callback_info info)
515 {
516 napi_value arrayBuffer = nullptr;
517 void* arrayBufferPtr = nullptr;
518 size_t arrayBufferSize = 16;
519 size_t typedArrayLength = 4;
520 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
521
522 void* tmpArrayBufferPtr = nullptr;
523 size_t arrayBufferLength = 0;
524 napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
525
526 NAPI_ASSERT(env, arrayBufferPtr == tmpArrayBufferPtr, "napi_get_arraybuffer_info success");
527 NAPI_ASSERT(env, arrayBufferSize == arrayBufferLength, "napi_create_arraybuffer success");
528
529 napi_value _value;
530 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &_value);
531
532 return _value;
533 }
534
createDataView(napi_env env,napi_callback_info info)535 static napi_value createDataView(napi_env env, napi_callback_info info)
536 {
537 napi_value arrayBuffer = nullptr;
538 void* arrayBufferPtr = nullptr;
539 size_t arrayBufferSize = 16;
540 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
541 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "napi_create_arraybuffer success");
542 bool isArrayBuffer = false;
543 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
544 NAPI_ASSERT(env, isArrayBuffer, " napi_is_arraybuffer success");
545
546 napi_value result = nullptr;
547 NAPI_CALL(env, napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result));
548
549 bool isDataView = false;
550 napi_is_dataview(env, result, &isDataView);
551 NAPI_ASSERT(env, isDataView, " napi_is_dataview success");
552
553 return result;
554 }
555
createAndGetInt32(napi_env env,napi_callback_info info)556 static napi_value createAndGetInt32(napi_env env, napi_callback_info info)
557 {
558 size_t argc = 1;
559 napi_value args[1];
560 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
561
562 int32_t value;
563 NAPI_CALL(env, napi_get_value_int32(env, args[0], &value));
564
565 napi_value output;
566 NAPI_CALL(env, napi_create_int32(env, value, &output));
567
568 return output;
569 }
570
createAndGetUInt32(napi_env env,napi_callback_info info)571 static napi_value createAndGetUInt32(napi_env env, napi_callback_info info)
572 {
573 size_t argc = 1;
574 napi_value args[1];
575 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
576
577 uint32_t value;
578 NAPI_CALL(env, napi_get_value_uint32(env, args[0], &value));
579
580 napi_value output;
581 NAPI_CALL(env, napi_create_uint32(env, value, &output));
582
583 return output;
584 }
585
createAndGetInt64(napi_env env,napi_callback_info info)586 static napi_value createAndGetInt64(napi_env env, napi_callback_info info)
587 {
588 size_t argc = 1;
589 napi_value args[1];
590 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
591
592 int64_t value;
593 NAPI_CALL(env, napi_get_value_int64(env, args[0], &value));
594
595 napi_value output;
596 NAPI_CALL(env, napi_create_int64(env, (double)value, &output));
597
598 return output;
599 }
600
createDouble(napi_env env,napi_callback_info info)601 static napi_value createDouble(napi_env env, napi_callback_info info)
602 {
603 size_t argc = 1;
604 napi_value args[1];
605 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
606
607 double value;
608 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
609
610 napi_value output;
611 NAPI_CALL(env, napi_create_double(env, value, &output));
612
613 return output;
614 }
615
createAndGetStringLatin1(napi_env env,napi_callback_info info)616 static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info)
617 {
618 size_t argc = 1;
619 napi_value args[1];
620 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
621
622 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
623
624 napi_valuetype valuetype;
625 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
626
627 NAPI_ASSERT(env, valuetype == napi_string,
628 "Wrong type of argment. Expects a string.");
629
630 char buffer[128];
631 size_t bufferSize = 128;
632 size_t copied = 0;
633
634 NAPI_CALL(env,
635 napi_get_value_string_latin1(env, args[0], buffer, bufferSize, &copied));
636 NAPI_ASSERT(env, copied == 3, "napi_get_value_string_latin1 fail");
637
638 napi_value output;
639 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
640
641 return output;
642 }
643
createAndGetStringUtf8(napi_env env,napi_callback_info info)644 static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
645 {
646 size_t argc = 1;
647 napi_value args[1];
648 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
649
650 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
651
652 napi_valuetype valuetype;
653 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
654
655 NAPI_ASSERT(env, valuetype == napi_string,
656 "Wrong type of argment. Expects a string.");
657
658 char buffer[128];
659 size_t bufferSize = 128;
660 size_t copied = 0;
661
662 NAPI_CALL(env,
663 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
664 NAPI_ASSERT(env, copied == 2, "napi_get_value_string_utf8 fail");
665
666 napi_value output;
667 NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
668
669 return output;
670 }
671
StringUtf8OfLengthLeZero(napi_env env,napi_callback_info info)672 static napi_value StringUtf8OfLengthLeZero(napi_env env, napi_callback_info info)
673 {
674 size_t argc = 1;
675 napi_value args[1];
676 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
677
678 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
679
680 napi_valuetype valueType;
681 NAPI_CALL(env, napi_typeof(env, args[0], &valueType));
682
683 NAPI_ASSERT(env, valueType == napi_string,
684 "Wrong type of argment. Expects a string.");
685
686 char buffer[128];
687 size_t bufferSize = 128;
688 size_t copied = 0;
689
690 NAPI_CALL(env,
691 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
692
693 napi_value output;
694 NAPI_CALL(env, napi_create_string_utf8(env, buffer, -1, &output));
695
696 return output;
697 }
698
CreateAndGetStringUtf16(napi_env env,napi_callback_info info)699 static napi_value CreateAndGetStringUtf16(napi_env env, napi_callback_info info)
700 {
701 size_t argc = 1;
702 napi_value args[1];
703 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
704
705 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments.");
706
707 napi_valuetype valuetype;
708 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
709
710 NAPI_ASSERT(env, valuetype == napi_string, "Expect a string.");
711
712 char16_t buffer[128]; // 128: char16_t type of element size
713 size_t bufferSize = 128; // 128: char16_t type of element size
714 size_t copied = 0;
715
716 NAPI_CALL(env, napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
717
718 napi_value result;
719 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &result));
720
721 return result;
722 }
723
StringUtf16OfCase(napi_env env,napi_callback_info info)724 static napi_value StringUtf16OfCase(napi_env env, napi_callback_info info)
725 {
726 size_t argc = 1;
727 napi_value args[1];
728 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
729
730 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments.");
731
732 napi_valuetype valuetype;
733 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
734
735 NAPI_ASSERT(env, valuetype == napi_string, "Expects a string.");
736
737 char16_t buffer[5]; // 5: char16_t type of element size
738 size_t bufferSize = 5; // 5: char16_t type of element size
739 size_t copied = 0;
740
741 NAPI_CALL(env,
742 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
743
744 napi_value result;
745 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &result));
746
747 return result;
748 }
749
StringUtf16OfLengthLeZero(napi_env env,napi_callback_info info)750 static napi_value StringUtf16OfLengthLeZero(napi_env env, napi_callback_info info)
751 {
752 size_t argc = 1;
753 napi_value args[1];
754 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
755
756 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
757
758 napi_valuetype valueType;
759 NAPI_CALL(env, napi_typeof(env, args[0], &valueType));
760
761 NAPI_ASSERT(env, valueType == napi_string, "Expects a string.");
762
763 char16_t buffer[128];
764 size_t bufferSize = 128;
765 size_t copied = 0;
766
767 NAPI_CALL(env,
768 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
769
770 napi_value result;
771 NAPI_CALL(env, napi_create_string_utf16(env, buffer, -1, &result));
772
773 return result;
774 }
775
StringUtf16OfLengthEqOne(napi_env env,napi_callback_info info)776 static napi_value StringUtf16OfLengthEqOne(napi_env env, napi_callback_info info)
777 {
778 size_t argc = 1;
779 napi_value args[1];
780 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
781
782 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
783
784 char16_t buffer[128];
785 size_t bufferSize = 1;
786 size_t copied = 1;
787
788 NAPI_CALL(env,
789 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
790
791 napi_value value;
792 NAPI_CALL(env, napi_create_int32(env, copied, &value));
793 return value;
794 }
795
796 static const napi_type_tag typeTags[NUMBER_FIVE] = {
797 {0xdaf987b3cc62481a, 0xb745b0497f299531},
798 {0xbb7936c374084d9b, 0xa9548d0762eeedb9},
799 {0xa5ed9ce2e4c00c38, 0xa9548d0762eeedb1},
800 {0, 0},
801 {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a},
802 };
803
TypeTaggedInstance(napi_env env,napi_callback_info info)804 static napi_value TypeTaggedInstance(napi_env env, napi_callback_info info)
805 {
806 size_t argc = 1;
807 uint32_t typeIndex = 0;
808 napi_value instance = nullptr;
809 napi_value whichType = nullptr;
810 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &whichType, NULL, NULL));
811 NAPI_CALL(env, napi_get_value_uint32(env, whichType, &typeIndex));
812 NAPI_ASSERT(env, typeIndex <= NUMBER_FIVE, "typeIndex out of range");
813 NAPI_CALL(env, napi_create_object(env, &instance));
814
815 NAPI_CALL(env, napi_type_tag_object(env, instance, &typeTags[typeIndex]));
816 return instance;
817 }
818
CheckTypeTag(napi_env env,napi_callback_info info)819 static napi_value CheckTypeTag(napi_env env, napi_callback_info info)
820 {
821 size_t argc = 2;
822 bool result;
823 napi_value argv[2];
824 napi_value jsResult = nullptr;
825 uint32_t typeIndex;
826
827 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
828
829 NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &typeIndex));
830
831 NAPI_ASSERT(env, typeIndex <= NUMBER_FIVE, "typeIndex out of range");
832
833 NAPI_CALL(env, napi_check_object_type_tag(env, argv[1], &typeTags[typeIndex], &result));
834 NAPI_CALL(env, napi_get_boolean(env, result, &jsResult));
835
836 return jsResult;
837 }
838
getPrototype(napi_env env,napi_callback_info info)839 static napi_value getPrototype(napi_env env, napi_callback_info info)
840 {
841 napi_value testWrapClass = nullptr;
842 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
843 napi_value thisVar = nullptr;
844 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
845 return thisVar;
846 }, nullptr, 0, nullptr, &testWrapClass);
847
848 napi_value customClassPrototype = nullptr;
849 NAPI_CALL(env, napi_get_prototype(env, testWrapClass, &customClassPrototype));
850 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
851
852 return customClassPrototype;
853 }
854
getPrototype2(napi_env env,napi_callback_info info)855 static napi_value getPrototype2(napi_env env, napi_callback_info info)
856 {
857 size_t argc = 1;
858 napi_value args[1];
859 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
860
861 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
862
863 napi_valuetype valuetype;
864 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
865
866 NAPI_ASSERT(env, valuetype == napi_function,
867 "Wrong type of argment. Expects a napi_function.");
868
869 napi_value customClassPrototype = nullptr;
870 NAPI_CALL(env, napi_get_prototype(env, args[0], &customClassPrototype));
871 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
872
873 return customClassPrototype;
874 }
875
getTypedArrayInfo(napi_env env,napi_callback_info info)876 static napi_value getTypedArrayInfo(napi_env env, napi_callback_info info)
877 {
878 napi_value arrayBuffer = nullptr;
879 void* arrayBufferPtr = nullptr;
880 size_t arrayBufferSize = 16;
881 size_t typedArrayLength = 4;
882 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
883 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getTypedArrayInfo napi_create_arraybuffer fail");
884 bool isArrayBuffer = false;
885 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
886 NAPI_ASSERT(env, isArrayBuffer, "getTypedArrayInfo napi_is_arraybuffer fail");
887 napi_value result;
888 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &result);
889
890 bool isTypedArray = false;
891 napi_is_typedarray(env, result, &isTypedArray);
892 NAPI_ASSERT(env, isTypedArray, "getTypedArrayInfo napi_is_dataview fail");
893
894 napi_typedarray_type type;
895 size_t length = 0;
896 void* data = nullptr;
897 napi_value retArrayBuffer;
898 size_t byteOffset = -1;
899 NAPI_CALL(env, napi_get_typedarray_info(env, result, &type, &length, &data, &retArrayBuffer, &byteOffset));
900 NAPI_ASSERT(env, type == napi_int32_array, "napi_get_typedarray_info success 0");
901 NAPI_ASSERT(env, length == arrayBufferSize, "napi_get_typedarray_info success 1");
902 NAPI_ASSERT(env, data == arrayBufferPtr, "napi_get_dataview_info success 2");
903
904 bool retIsArrayBuffer = false;
905 NAPI_CALL(env, napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer));
906 void* tmpArrayBufferPtr = nullptr;
907 size_t arrayBufferLength = 0;
908 NAPI_CALL(env, napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength));
909
910 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 3");
911
912 napi_value _value;
913 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
914 return _value;
915 }
916
getDataViewInfo(napi_env env,napi_callback_info info)917 static napi_value getDataViewInfo(napi_env env, napi_callback_info info)
918 {
919 napi_value arrayBuffer = nullptr;
920 void* arrayBufferPtr = nullptr;
921 size_t arrayBufferSize = 1024;
922 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
923 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getDataViewInfo napi_create_arraybuffer fail");
924 bool isArrayBuffer = false;
925 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
926 NAPI_ASSERT(env, isArrayBuffer, "getDataViewInfo napi_is_arraybuffer fail");
927 napi_value result = nullptr;
928 napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result);
929
930 bool isDataView = false;
931 napi_is_dataview(env, result, &isDataView);
932 NAPI_ASSERT(env, isDataView, "getDataViewInfo napi_is_dataview fail");
933
934 napi_value retArrayBuffer = nullptr;
935 void* data = nullptr;
936 size_t byteLength = 0;
937 size_t byteOffset = -1;
938 napi_get_dataview_info(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
939
940 bool retIsArrayBuffer = false;
941 napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer);
942 void* tmpArrayBufferPtr = nullptr;
943 size_t arrayBufferLength = 0;
944 napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
945
946 NAPI_ASSERT(env, arrayBufferLength == arrayBufferSize, "napi_get_dataview_info success 0");
947 NAPI_ASSERT(env, arrayBufferPtr == data, "napi_get_dataview_info success 1");
948 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 2");
949
950 napi_value _value;
951 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
952 return _value;
953 }
954
getValueBool(napi_env env,napi_callback_info info)955 static napi_value getValueBool(napi_env env, napi_callback_info info)
956 {
957 size_t argc = 1;
958 napi_value args[1];
959 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
960
961 bool value;
962 NAPI_CALL(env, napi_get_value_bool(env, args[0], &value));
963
964 napi_value output;
965 NAPI_CALL(env, napi_get_boolean(env, value, &output));
966
967 return output;
968 }
969
getValueDouble(napi_env env,napi_callback_info info)970 static napi_value getValueDouble(napi_env env, napi_callback_info info)
971 {
972 size_t argc = 1;
973 napi_value args[1];
974 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
975
976 double value;
977 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
978
979 napi_value output;
980 NAPI_CALL(env, napi_create_double(env, value, &output));
981
982 return output;
983 }
984
getValueExternal(napi_env env,napi_callback_info info)985 static napi_value getValueExternal(napi_env env, napi_callback_info info)
986 {
987 const char testStr[] = "test";
988 napi_value external = nullptr;
989 napi_create_external(
990 env, (void*)testStr,
991 [](napi_env env, void* data, void* hint) {},
992 (void*)testStr, &external);
993 void* tempExternal = nullptr;
994 napi_get_value_external(env, external, &tempExternal);
995
996 NAPI_ASSERT(env, tempExternal == testStr, "napi_get_value_external true");
997
998 napi_value _value;
999 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1000
1001 return _value;
1002 }
1003
getNull(napi_env env,napi_callback_info info)1004 static napi_value getNull(napi_env env, napi_callback_info info)
1005 {
1006 napi_value result = nullptr;
1007 NAPI_CALL(env, napi_get_null(env, &result));
1008 NAPI_ASSERT(env, result != nullptr, "napi_get_null success");
1009 napi_valuetype type;
1010 NAPI_CALL(env, napi_typeof(env, result, &type));
1011 NAPI_ASSERT(env, type == napi_null, "napi_get_null fail");
1012
1013 napi_value _value;
1014 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1015
1016 return _value;
1017 }
1018
getUndefined(napi_env env,napi_callback_info info)1019 static napi_value getUndefined(napi_env env, napi_callback_info info)
1020 {
1021 napi_value result = nullptr;
1022 NAPI_CALL(env, napi_get_undefined(env, &result));
1023 NAPI_ASSERT(env, result != nullptr, "napi_get_undefined success");
1024 napi_valuetype type;
1025 NAPI_CALL(env, napi_typeof(env, result, &type));
1026 NAPI_ASSERT(env, type == napi_undefined, "napi_get_undefined fail");
1027
1028 napi_value _value;
1029 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1030
1031 return _value;
1032 }
1033
coerceToBool(napi_env env,napi_callback_info info)1034 static napi_value coerceToBool(napi_env env, napi_callback_info info)
1035 {
1036 size_t argc = 1;
1037 napi_value args[1];
1038 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1039
1040 napi_value output;
1041 NAPI_CALL(env, napi_coerce_to_bool(env, args[0], &output));
1042
1043 return output;
1044 }
1045
coerceToNumber(napi_env env,napi_callback_info info)1046 static napi_value coerceToNumber(napi_env env, napi_callback_info info)
1047 {
1048 size_t argc = 1;
1049 napi_value args[1];
1050 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1051
1052 napi_value output;
1053 NAPI_CALL(env, napi_coerce_to_number(env, args[0], &output));
1054
1055 return output;
1056 }
1057
coerceToObject(napi_env env,napi_callback_info info)1058 static napi_value coerceToObject(napi_env env, napi_callback_info info)
1059 {
1060 size_t argc = 1;
1061 napi_value args[1];
1062 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1063
1064 napi_value output;
1065 NAPI_CALL(env, napi_coerce_to_object(env, args[0], &output));
1066
1067 return output;
1068 }
1069
coerceToString(napi_env env,napi_callback_info info)1070 static napi_value coerceToString(napi_env env, napi_callback_info info)
1071 {
1072 size_t argc = 1;
1073 napi_value args[1];
1074 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1075
1076 napi_value output;
1077 NAPI_CALL(env, napi_coerce_to_string(env, args[0], &output));
1078
1079 return output;
1080 }
1081
instanceOf(napi_env env,napi_callback_info info)1082 static napi_value instanceOf(napi_env env, napi_callback_info info)
1083 {
1084 napi_value customClass = nullptr;
1085
1086 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH,
1087 [](napi_env env, napi_callback_info info) -> napi_value {
1088 napi_value thisVar = nullptr;
1089 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1090 return thisVar;
1091 }, nullptr, 0, nullptr, &customClass);
1092
1093 napi_value customClassPrototype = nullptr;
1094 napi_get_prototype(env, customClass, &customClassPrototype);
1095
1096 napi_value customInstance = nullptr;
1097 NAPI_CALL(env, napi_new_instance(env, customClass, 0, nullptr, &customInstance));
1098
1099 bool isInstanceOf = false;
1100 NAPI_CALL(env, napi_instanceof(env, customInstance, customClass, &isInstanceOf));
1101
1102 NAPI_ASSERT(env, isInstanceOf, "isInstanceOf success");
1103
1104 napi_value result;
1105 NAPI_CALL(env, napi_get_boolean(env, isInstanceOf, &result));
1106
1107 return result;
1108 }
1109
isArray(napi_env env,napi_callback_info info)1110 static napi_value isArray(napi_env env, napi_callback_info info)
1111 {
1112 napi_value array = nullptr;
1113 napi_create_array(env, &array);
1114 NAPI_ASSERT(env, array != nullptr, "napi_get_undefined success");
1115 bool isArray = false;
1116 napi_is_array(env, array, &isArray);
1117 NAPI_ASSERT(env, isArray, "napi_is_arrayd success");
1118
1119 napi_value _value;
1120 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1121 return _value;
1122 }
1123
isDate(napi_env env,napi_callback_info info)1124 static napi_value isDate(napi_env env, napi_callback_info info)
1125 {
1126 napi_value date, result;
1127 size_t argc = 1;
1128 bool is_date = false;
1129
1130 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL));
1131 NAPI_CALL(env, napi_is_date(env, date, &is_date));
1132 NAPI_CALL(env, napi_get_boolean(env, is_date, &result));
1133
1134 return result;
1135 }
1136
strictEquals(napi_env env,napi_callback_info info)1137 static napi_value strictEquals(napi_env env, napi_callback_info info)
1138 {
1139 const char* testStringStr = "test";
1140 napi_value testString = nullptr;
1141 napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
1142 bool isStrictEquals = false;
1143 napi_strict_equals(env, testString, testString, &isStrictEquals);
1144 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 0");
1145
1146 napi_value testObject = nullptr;
1147 napi_create_object(env, &testObject);
1148 isStrictEquals = false;
1149 napi_strict_equals(env, testObject, testObject, &isStrictEquals);
1150 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 1");
1151
1152 napi_value napi_number1 = nullptr;
1153 napi_value napi_number2 = nullptr;
1154 napi_create_double(env, 10.1, &napi_number1);
1155 napi_create_int32(env, 10, &napi_number2);
1156 isStrictEquals = true;
1157 napi_strict_equals(env, napi_number1, napi_number2, &isStrictEquals);
1158 NAPI_ASSERT(env, !isStrictEquals, "napi_strict_equals success 2");
1159
1160 napi_value _value;
1161 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1162 return _value;
1163 }
1164
getPropertyNames(napi_env env,napi_callback_info info)1165 static napi_value getPropertyNames(napi_env env, napi_callback_info info)
1166 {
1167 napi_value result = nullptr;
1168 NAPI_CALL(env, napi_create_object(env, &result));
1169
1170 NAPI_ASSERT(env, result != nullptr, "napi_create_object success");
1171
1172 const char testStr[] = "1234567";
1173 napi_value strAttribute = nullptr;
1174
1175 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1176 NAPI_ASSERT(env, strAttribute != nullptr, "napi_create_string_utf8 success");
1177
1178 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1179 bool hasNamedProperty = false;
1180 NAPI_CALL(env, napi_has_named_property(env, result, "strAttribute", &hasNamedProperty));
1181 NAPI_ASSERT(env, hasNamedProperty, "napi_has_named_property fail");
1182
1183 napi_value retStrAttribute = nullptr;
1184 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1185 NAPI_ASSERT(env, retStrAttribute != nullptr, "napi_get_named_property success");
1186 napi_valuetype type;
1187 NAPI_CALL(env, napi_typeof(env, retStrAttribute, &type));
1188 NAPI_ASSERT(env, type == napi_string, "napi_get_named_property fail");
1189 napi_value res;
1190 napi_coerce_to_number(env, retStrAttribute, &res);
1191 int32_t num = 0;
1192 napi_get_value_int32(env, res, &num);
1193 NAPI_ASSERT(env, num == 1234567, "getPropertyNames fail");
1194
1195 napi_value _value;
1196 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1197 return _value;
1198 }
1199
setProperty(napi_env env,napi_callback_info info)1200 static napi_value setProperty(napi_env env,
1201 napi_callback_info info)
1202 {
1203 napi_status status;
1204 napi_value object, key, value;
1205
1206 NAPI_CALL(env, napi_create_object(env, &object));
1207
1208 NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
1209
1210 NAPI_CALL(env, napi_create_object(env, &value));
1211
1212 status = napi_set_property(NULL, object, key, value);
1213
1214 add_returned_status(env,
1215 "envIsNull",
1216 object,
1217 "Invalid argument",
1218 napi_invalid_arg,
1219 status);
1220
1221 napi_set_property(env, NULL, key, value);
1222
1223 add_last_status(env, "objectIsNull", object);
1224
1225 napi_set_property(env, object, NULL, value);
1226
1227 add_last_status(env, "keyIsNull", object);
1228
1229 napi_set_property(env, object, key, NULL);
1230
1231 add_last_status(env, "valueIsNull", object);
1232
1233 return object;
1234 }
1235
getProperty(napi_env env,napi_callback_info info)1236 static napi_value getProperty(napi_env env,
1237 napi_callback_info info)
1238 {
1239 napi_status status;
1240 napi_value object, key, result;
1241
1242 NAPI_CALL(env, napi_create_object(env, &object));
1243
1244 NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
1245
1246 NAPI_CALL(env, napi_create_object(env, &result));
1247
1248 status = napi_get_property(NULL, object, key, &result);
1249
1250 add_returned_status(env,
1251 "envIsNull",
1252 object,
1253 "Invalid argument",
1254 napi_invalid_arg,
1255 status);
1256
1257 napi_get_property(env, NULL, key, &result);
1258
1259 add_last_status(env, "objectIsNull", object);
1260
1261 napi_get_property(env, object, NULL, &result);
1262
1263 add_last_status(env, "keyIsNull", object);
1264
1265 napi_get_property(env, object, key, NULL);
1266
1267 add_last_status(env, "resultIsNull", object);
1268
1269 return object;
1270 }
1271
hasProperty(napi_env env,napi_callback_info info)1272 static napi_value hasProperty(napi_env env, napi_callback_info info)
1273 {
1274 napi_value result = nullptr;
1275 NAPI_CALL(env, napi_create_object(env, &result));
1276
1277 const char testStr[] = "1234567";
1278 napi_value strAttribute = nullptr;
1279 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1280 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1281
1282 napi_value retStrAttribute = nullptr;
1283 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1284
1285 int32_t testNumber = 12345;
1286 napi_value numberAttribute = nullptr;
1287 NAPI_CALL(env, napi_create_int32(env, testNumber, &numberAttribute));
1288 NAPI_CALL(env, napi_set_named_property(env, result, "numberAttribute", numberAttribute));
1289
1290 napi_value propNames = nullptr;
1291 NAPI_CALL(env, napi_get_property_names(env, result, &propNames));
1292 NAPI_ASSERT(env, propNames != nullptr, "napi_get_property_names success");
1293
1294 bool isArray = false;
1295 NAPI_CALL(env, napi_is_array(env, propNames, &isArray));
1296 NAPI_ASSERT(env, isArray, "napi_is_array success");
1297
1298 uint32_t arrayLength = 0;
1299 NAPI_CALL(env, napi_get_array_length(env, propNames, &arrayLength));
1300
1301 for (uint32_t i = 0; i < arrayLength; i++) {
1302 bool hasElement = false;
1303 NAPI_CALL(env, napi_has_element(env, propNames, i, &hasElement));
1304 NAPI_ASSERT(env, hasElement, "napi_has_element success");
1305
1306 napi_value propName = nullptr;
1307 NAPI_CALL(env, napi_get_element(env, propNames, i, &propName));
1308 NAPI_ASSERT(env, propName != nullptr, "napi_get_element success");
1309
1310 bool hasProp = false;
1311 napi_has_property(env, result, propName, &hasProp);
1312 NAPI_ASSERT(env, hasProp, "napi_get_element success");
1313
1314 napi_value propValue = nullptr;
1315 napi_get_property(env, result, propName, &propValue);
1316 NAPI_ASSERT(env, propValue != nullptr, "napi_get_property success");
1317 }
1318
1319 bool deletion = false;
1320 NAPI_CALL(env, napi_delete_element(env, propNames, 1, &deletion));
1321 NAPI_ASSERT(env, deletion, "napi_delete_element fail");
1322 bool hasElement = true;
1323 NAPI_CALL(env, napi_has_element(env, propNames, 1, &hasElement));
1324 NAPI_ASSERT(env, !hasElement, "napi_has_element fail");
1325
1326 napi_value _value;
1327 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1328 return _value;
1329 }
1330
setAndDeleteProperty(napi_env env,napi_callback_info info)1331 static napi_value setAndDeleteProperty(napi_env env, napi_callback_info info)
1332 {
1333 size_t argc = 2;
1334 napi_value args[2];
1335
1336 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1337 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1338
1339 napi_valuetype valuetype0;
1340 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1341 NAPI_ASSERT(env, valuetype0 == napi_object,
1342 "Wrong type of arguments. Expects an object as first argument.");
1343
1344 napi_valuetype valuetype1;
1345 NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
1346 NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
1347 "Wrong type of arguments. Expects a string or symbol as second.");
1348
1349 const char testStr[] = "cKey";
1350 napi_value cKey;
1351 napi_value cValue;
1352 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &cKey));
1353 NAPI_CALL(env, napi_create_int32(env, 3, &cValue));
1354 NAPI_CALL(env, napi_set_property(env, args[0], cKey, cValue));
1355
1356 bool hasProp = false;
1357 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1358 NAPI_ASSERT(env, hasProp, "setAndDeleteProperty napi_has_property fail 1");
1359
1360 bool result;
1361 napi_value ret;
1362 NAPI_CALL(env, napi_delete_property(env, args[0], cKey, &result));
1363 NAPI_CALL(env, napi_get_boolean(env, result, &ret));
1364 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1365 NAPI_ASSERT(env, !hasProp, "setAndDeleteProperty napi_has_property fail 2");
1366
1367 napi_value _value;
1368 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1369 return _value;
1370 }
1371
hasOwnProperty(napi_env env,napi_callback_info info)1372 static napi_value hasOwnProperty(napi_env env, napi_callback_info info)
1373 {
1374 size_t argc = 2;
1375 napi_value args[2];
1376 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1377
1378 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1379
1380 napi_valuetype valuetype0;
1381 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1382
1383 NAPI_ASSERT(env, valuetype0 == napi_object,
1384 "Wrong type of arguments. Expects an object as first argument.");
1385
1386 bool has_property;
1387 NAPI_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property));
1388
1389 napi_value ret;
1390 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1391
1392 return ret;
1393 }
1394
setNamedProperty(napi_env env,napi_callback_info info)1395 static napi_value setNamedProperty(napi_env env, napi_callback_info info)
1396 {
1397 size_t argc = 3;
1398 napi_value args[3];
1399 char key[256] = "";
1400 size_t key_length;
1401 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1402
1403 NAPI_ASSERT(env, argc >= 3, "Wrong number of arguments");
1404
1405 napi_valuetype value_type0;
1406 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1407
1408 NAPI_ASSERT(env, value_type0 == napi_object,
1409 "Wrong type of arguments. Expects an object as first argument.");
1410
1411 napi_valuetype value_type1;
1412 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1413
1414 NAPI_ASSERT(env, value_type1 == napi_string,
1415 "Wrong type of arguments. Expects a string as second.");
1416
1417 NAPI_CALL(env,
1418 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1419 key[255] = 0;
1420 NAPI_ASSERT(env, key_length <= 255,
1421 "Cannot accommodate keys longer than 255 bytes");
1422
1423 NAPI_CALL(env, napi_set_named_property(env, args[0], key, args[2]));
1424
1425 napi_value value_true;
1426 NAPI_CALL(env, napi_get_boolean(env, true, &value_true));
1427
1428 return value_true;
1429 }
1430
getNamedProperty(napi_env env,napi_callback_info info)1431 static napi_value getNamedProperty(napi_env env, napi_callback_info info)
1432 {
1433 size_t argc = 2;
1434 napi_value args[2];
1435 char key[256] = "";
1436 size_t key_length;
1437 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1438
1439 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1440
1441 napi_valuetype value_type0;
1442 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1443
1444 NAPI_ASSERT(env, value_type0 == napi_object,
1445 "Wrong type of arguments. Expects an object as first argument.");
1446
1447 napi_valuetype value_type1;
1448 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1449
1450 NAPI_ASSERT(env, value_type1 == napi_string,
1451 "Wrong type of arguments. Expects a string as second.");
1452
1453 napi_value object = args[0];
1454 NAPI_CALL(env,
1455 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1456 key[255] = 0;
1457 NAPI_ASSERT(env, key_length <= 255,
1458 "Cannot accommodate keys longer than 255 bytes");
1459 napi_value output;
1460 NAPI_CALL(env, napi_get_named_property(env, object, key, &output));
1461
1462 return output;
1463 }
1464
hasNamedProperty(napi_env env,napi_callback_info info)1465 static napi_value hasNamedProperty(napi_env env, napi_callback_info info)
1466 {
1467 size_t argc = 2;
1468 napi_value args[2];
1469 char key[256] = "";
1470 size_t key_length;
1471 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1472
1473 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1474
1475 napi_valuetype value_type0;
1476 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1477
1478 NAPI_ASSERT(env, value_type0 == napi_object,
1479 "Wrong type of arguments. Expects an object as first argument.");
1480
1481 napi_valuetype value_type1;
1482 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1483
1484 NAPI_ASSERT(env, value_type1 == napi_string || value_type1 == napi_symbol,
1485 "Wrong type of arguments. Expects a string as second.");
1486
1487 NAPI_CALL(env,
1488 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1489 key[255] = 0;
1490 NAPI_ASSERT(env, key_length <= 255,
1491 "Cannot accommodate keys longer than 255 bytes");
1492
1493 bool has_property;
1494 NAPI_CALL(env, napi_has_named_property(env, args[0], key, &has_property));
1495
1496 napi_value ret;
1497 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1498
1499 return ret;
1500 }
1501
setElement(napi_env env,napi_callback_info info)1502 static napi_value setElement(napi_env env, napi_callback_info info)
1503 {
1504 napi_value return_value, object;
1505
1506 NAPI_CALL(env, napi_create_object(env, &return_value));
1507 NAPI_CALL(env, napi_create_object(env, &object));
1508
1509 add_returned_status(env,
1510 "envIsNull",
1511 return_value,
1512 "Invalid argument",
1513 napi_invalid_arg,
1514 napi_set_element(NULL, object, 0, object));
1515
1516 napi_set_element(env, NULL, 0, object);
1517 add_last_status(env, "objectIsNull", return_value);
1518
1519
1520 napi_set_property(env, object, 0, NULL);
1521 add_last_status(env, "valueIsNull", return_value);
1522
1523 return return_value;
1524 }
1525
getElement(napi_env env,napi_callback_info info)1526 static napi_value getElement(napi_env env, napi_callback_info info)
1527 {
1528 napi_value return_value, object, prop;
1529
1530 NAPI_CALL(env, napi_create_object(env, &return_value));
1531 NAPI_CALL(env, napi_create_object(env, &object));
1532
1533 add_returned_status(env,
1534 "envIsNull",
1535 return_value,
1536 "Invalid argument",
1537 napi_invalid_arg,
1538 napi_get_element(NULL, object, 0, &prop));
1539
1540 napi_get_property(env, NULL, 0, &prop);
1541 add_last_status(env, "objectIsNull", return_value);
1542
1543 napi_get_property(env, object, 0, NULL);
1544 add_last_status(env, "valueIsNull", return_value);
1545
1546 return return_value;
1547 }
1548
TestBoolValuedElementApi(napi_env env,napi_status (* api)(napi_env,napi_value,uint32_t,bool *))1549 static napi_value TestBoolValuedElementApi(napi_env env,
1550 napi_status (* api)(napi_env, napi_value, uint32_t, bool*))
1551 {
1552 napi_value return_value, object;
1553 bool result;
1554
1555 NAPI_CALL(env, napi_create_object(env, &return_value));
1556 NAPI_CALL(env, napi_create_object(env, &object));
1557
1558 add_returned_status(env,
1559 "envIsNull",
1560 return_value,
1561 "Invalid argument",
1562 napi_invalid_arg,
1563 api(NULL, object, 0, &result));
1564
1565 api(env, NULL, 0, &result);
1566 add_last_status(env, "objectIsNull", return_value);
1567
1568 api(env, object, 0, NULL);
1569 add_last_status(env, "valueIsNull", return_value);
1570
1571 return return_value;
1572 }
1573
hasElement(napi_env env,napi_callback_info info)1574 static napi_value hasElement(napi_env env, napi_callback_info info)
1575 {
1576 return TestBoolValuedElementApi(env, napi_has_element);
1577 }
1578
deleteElement(napi_env env,napi_callback_info info)1579 static napi_value deleteElement(napi_env env, napi_callback_info info)
1580 {
1581 return TestBoolValuedElementApi(env, napi_delete_element);
1582 }
1583
defineProperties(napi_env env,napi_callback_info info)1584 static napi_value defineProperties(napi_env env, napi_callback_info info)
1585 {
1586 napi_value object, return_value;
1587
1588 napi_property_descriptor desc = {"prop", NULL, defineProperties, NULL, NULL, NULL, napi_enumerable, NULL};
1589
1590 NAPI_CALL(env, napi_create_object(env, &object));
1591 NAPI_CALL(env, napi_create_object(env, &return_value));
1592
1593 add_returned_status(env,
1594 "envIsNull",
1595 return_value,
1596 "Invalid argument",
1597 napi_invalid_arg,
1598 napi_define_properties(NULL, object, 1, &desc));
1599
1600 napi_define_properties(env, NULL, 1, &desc);
1601 add_last_status(env, "objectIsNull", return_value);
1602
1603 napi_define_properties(env, object, 1, NULL);
1604 add_last_status(env, "descriptorListIsNull", return_value);
1605
1606 desc.utf8name = NULL;
1607 napi_define_properties(env, object, 1, NULL);
1608 add_last_status(env, "utf8nameIsNull", return_value);
1609 desc.utf8name = "prop";
1610
1611 desc.method = NULL;
1612 napi_define_properties(env, object, 1, NULL);
1613 add_last_status(env, "methodIsNull", return_value);
1614 desc.method = defineProperties;
1615
1616 return return_value;
1617 }
1618
MyConstructor(napi_env env,napi_callback_info info)1619 static napi_value MyConstructor(napi_env env, napi_callback_info info)
1620 {
1621 napi_value thisVar = nullptr;
1622 size_t argc = 0;
1623 napi_value constructor = nullptr;
1624 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1625 napi_get_new_target(env, info, &constructor);
1626 if (constructor == nullptr) {
1627 napi_throw_error(env, nullptr, "is not new instance");
1628 }
1629 return thisVar;
1630 }
1631
NewTargetTest(napi_env env,napi_callback_info info)1632 static napi_value NewTargetTest(napi_env env, napi_callback_info info)
1633 {
1634 bool isConstructor = true;
1635 napi_value constructor = nullptr;
1636 napi_get_new_target(env, info, &constructor);
1637 if (constructor == nullptr) {
1638 napi_throw_error(env, nullptr, "is not new instance");
1639 isConstructor = false;
1640 }
1641 napi_value value;
1642 NAPI_CALL(env, napi_get_boolean(env, isConstructor, &value));
1643
1644 return value;
1645 }
1646
wrap(napi_env env,napi_callback_info info)1647 static napi_value wrap(napi_env env, napi_callback_info info)
1648 {
1649 napi_value testClass = nullptr;
1650 napi_define_class(
1651 env, "TestClass", NAPI_AUTO_LENGTH,
1652 [](napi_env env, napi_callback_info info) -> napi_value {
1653 napi_value thisVar = nullptr;
1654 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1655
1656 return thisVar;
1657 },
1658 nullptr, 0, nullptr, &testClass);
1659
1660 napi_value instanceValue = nullptr;
1661 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1662
1663 const char* testStr = "test";
1664 napi_wrap(
1665 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1666
1667 napi_value _value;
1668 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1669 return _value;
1670 }
1671
unwrap(napi_env env,napi_callback_info info)1672 static napi_value unwrap(napi_env env, napi_callback_info info)
1673 {
1674 napi_value testClass = nullptr;
1675 napi_define_class(
1676 env, "TestClass", NAPI_AUTO_LENGTH,
1677 [](napi_env env, napi_callback_info info) -> napi_value {
1678 napi_value thisVar = nullptr;
1679 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1680
1681 return thisVar;
1682 },
1683 nullptr, 0, nullptr, &testClass);
1684
1685 napi_value instanceValue = nullptr;
1686 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1687
1688 const char* testStr = "test";
1689 napi_wrap(
1690 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1691
1692 const char* tmpTestStr = nullptr;
1693 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1694 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1695
1696 napi_value _value;
1697 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1698 return _value;
1699 }
1700
removeWrap(napi_env env,napi_callback_info info)1701 static napi_value removeWrap(napi_env env, napi_callback_info info)
1702 {
1703 napi_value testClass = nullptr;
1704 napi_define_class(
1705 env, "TestClass", NAPI_AUTO_LENGTH,
1706 [](napi_env env, napi_callback_info info) -> napi_value {
1707 napi_value thisVar = nullptr;
1708 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1709
1710 return thisVar;
1711 },
1712 nullptr, 0, nullptr, &testClass);
1713
1714 napi_value instanceValue = nullptr;
1715 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1716
1717 const char* testStr = "test";
1718 napi_wrap(
1719 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1720
1721 const char* tmpTestStr = nullptr;
1722 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1723 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1724
1725 const char* tmpTestStr1 = nullptr;
1726 napi_remove_wrap(env, instanceValue, (void**)&tmpTestStr1);
1727 NAPI_ASSERT(env, tmpTestStr1 == testStr, "napi_remove_wrap fail 1");
1728
1729 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr1));
1730 NAPI_ASSERT(env, tmpTestStr1 == nullptr, "napi_remove_wrap fail");
1731
1732 napi_value _value;
1733 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1734 return _value;
1735 }
1736
getVersion(napi_env env,napi_callback_info info)1737 static napi_value getVersion(napi_env env, napi_callback_info info)
1738 {
1739 uint32_t version;
1740 napi_value result;
1741 NAPI_CALL(env, napi_get_version(env, &version));
1742 NAPI_CALL(env, napi_create_uint32(env, version, &result));
1743 return result;
1744 }
1745
createPromise(napi_env env,napi_callback_info info)1746 static napi_value createPromise(napi_env env, napi_callback_info info)
1747 {
1748 napi_deferred deferred = nullptr;
1749 napi_value promise = nullptr;
1750 napi_create_promise(env, &deferred, &promise);
1751 NAPI_ASSERT(env, deferred != nullptr, "create promise success");
1752 NAPI_ASSERT(env, promise != nullptr, "create promise success");
1753
1754 napi_value _value;
1755 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1756 return _value;
1757 }
1758
resolveAndRejectDeferred(napi_env env,napi_callback_info info)1759 static napi_value resolveAndRejectDeferred(napi_env env, napi_callback_info info)
1760 {
1761 napi_deferred deferred = nullptr;
1762 napi_value promise = nullptr;
1763 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1764
1765 bool isPromise = false;
1766 napi_is_promise(env, promise, &isPromise);
1767
1768 napi_value undefined = nullptr;
1769 napi_get_undefined(env, &undefined);
1770 NAPI_CALL(env, napi_resolve_deferred(env, deferred, undefined));
1771
1772 napi_value _value;
1773 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1774 return _value;
1775 }
1776
isPromise(napi_env env,napi_callback_info info)1777 static napi_value isPromise(napi_env env, napi_callback_info info)
1778 {
1779 napi_deferred deferred = nullptr;
1780 napi_value promise = nullptr;
1781 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1782
1783 bool isPromise = false;
1784 NAPI_CALL(env, napi_is_promise(env, promise, &isPromise));
1785 NAPI_ASSERT(env, isPromise, "napi_is_promise success");
1786
1787 napi_value _value;
1788 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1789 return _value;
1790 }
1791
runScript(napi_env env,napi_callback_info info)1792 static napi_value runScript(napi_env env, napi_callback_info info)
1793 {
1794 napi_value script, result;
1795 size_t argc = 1;
1796
1797 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &script, NULL, NULL));
1798
1799 NAPI_CALL(env, napi_run_script(env, script, &result));
1800
1801 return result;
1802 }
1803
getUvEventLoop(napi_env env,napi_callback_info info)1804 static napi_value getUvEventLoop(napi_env env, napi_callback_info info)
1805 {
1806 struct uv_loop_s* loop = nullptr;
1807
1808 NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
1809 NAPI_ASSERT(env, loop != nullptr, "napi_get_uv_event_loop fail");
1810
1811 return nullptr;
1812 }
1813
TestLatin1(napi_env env,napi_callback_info info)1814 static napi_value TestLatin1(napi_env env, napi_callback_info info)
1815 {
1816 size_t argc = 1;
1817 napi_value args[1];
1818 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1819
1820 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1821
1822 napi_valuetype valuetype;
1823 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1824
1825 NAPI_ASSERT(env, valuetype == napi_string,
1826 "Wrong type of argment. Expects a string.");
1827
1828 char buffer[128];
1829 size_t bufferSize = 128;
1830 size_t copied;
1831
1832 NAPI_CALL(env,
1833 napi_get_value_string_latin1(env, args[0], buffer, bufferSize, &copied));
1834
1835 napi_value output;
1836 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
1837
1838 return output;
1839 }
1840
TestUtf8(napi_env env,napi_callback_info info)1841 static napi_value TestUtf8(napi_env env, napi_callback_info info)
1842 {
1843 size_t argc = 1;
1844 napi_value args[1];
1845 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1846
1847 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
1848
1849 napi_valuetype valuetype;
1850 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1851
1852 NAPI_ASSERT(env, valuetype == napi_string,
1853 "Wrong type of argment. Expects a string.");
1854
1855 char buffer[128];
1856 size_t bufferSize = 128;
1857 size_t copied;
1858
1859 NAPI_CALL(env,
1860 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
1861
1862 napi_value output;
1863 NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
1864
1865 return output;
1866 }
1867
TestUtf16(napi_env env,napi_callback_info info)1868 static napi_value TestUtf16(napi_env env, napi_callback_info info)
1869 {
1870 size_t argc = 1;
1871 napi_value args[1];
1872 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1873
1874 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
1875
1876 napi_valuetype valuetype;
1877 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1878
1879 NAPI_ASSERT(env, valuetype == napi_string,
1880 "Wrong type of argment. Expects a string.");
1881
1882 char16_t buffer[128];
1883 size_t bufferSize = 128;
1884 size_t copied;
1885
1886 NAPI_CALL(env,
1887 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
1888
1889 napi_value output;
1890 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
1891
1892 return output;
1893 }
1894 // test the napi function
napCreateArrayBuffer(napi_env env,napi_callback_info info)1895 static napi_value napCreateArrayBuffer(napi_env env, napi_callback_info info)
1896 {
1897 napi_value arrayBuffer = nullptr;
1898 void* arrayBufferPtr = nullptr;
1899 size_t arrayBufferSize = 1024;
1900 napi_status status = napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1901 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1902 NAPI_ASSERT(env, arrayBuffer != nullptr, "success create_arrayBuffer");
1903
1904 return arrayBuffer;
1905 }
1906
napiGetCbInfo(napi_env env,napi_callback_info info)1907 static napi_value napiGetCbInfo(napi_env env, napi_callback_info info)
1908 {
1909 size_t argc = 1;
1910 napi_value args[1];
1911 napi_status status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
1912 NAPI_ASSERT(env, status == napi_ok, "get_cb_info ok");
1913 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1914 double value;
1915 napi_get_value_double(env, args[0], &value);
1916
1917 napi_valuetype valuetype;
1918 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1919 NAPI_ASSERT(env, valuetype == napi_number, "Wrong type of argment. Expects a nunber.");
1920
1921 napi_value returnValue;
1922 napi_status statusDouble = napi_create_double(env, value, &returnValue);
1923 NAPI_ASSERT(env, statusDouble == napi_ok, "success to napi_create_double");
1924
1925 return returnValue;
1926 }
1927
naiGetArrayBufferInfo(napi_env env,napi_callback_info info)1928 static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info)
1929 {
1930 // the value to return
1931 napi_value arrayBuffer;
1932 napi_status status;
1933 void* yourPointer = nullptr;
1934 size_t arrayBufferSize = 1024;
1935 status = napi_create_arraybuffer(env, arrayBufferSize, &yourPointer, &arrayBuffer);
1936 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1937
1938 void* tmpArrayBufferPtr = nullptr;
1939 size_t arrayBufferLength = 0;
1940 status = napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
1941 NAPI_ASSERT(env, status == napi_ok, "success to napi_get_arraybuffer_info");
1942
1943 napi_value arrayLength;
1944 // return the length of array js type int
1945 NAPI_CALL(env, napi_create_int32(env, arrayBufferLength, &arrayLength));
1946
1947 return arrayLength;
1948 }
1949
napiDefineClass(napi_env env,napi_callback_info info)1950 static napi_value napiDefineClass(napi_env env, napi_callback_info info)
1951 {
1952 napi_value testWrapClass = nullptr;
1953 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
1954 napi_value thisVar = nullptr;
1955 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1956 return thisVar;
1957 }, nullptr, 0, nullptr, &testWrapClass);
1958
1959 napi_value instanceValue = nullptr;
1960 napi_new_instance(env, testWrapClass, 0, nullptr, &instanceValue);
1961 NAPI_ASSERT(env, instanceValue != nullptr, "success napiDefineClass");
1962 napi_value value;
1963 NAPI_CALL(env, napi_create_int32(env, 0, &value));
1964
1965 return value;
1966 }
1967
napiRunScriptPath(napi_env env,napi_callback_info info)1968 static napi_value napiRunScriptPath(napi_env env, napi_callback_info info)
1969 {
1970 napi_value value;
1971 const char* path = "index/page";
1972 napi_status status = napi_run_script_path(env, path, &value);
1973 NAPI_ASSERT(env, status == napi_ok, "napi_run_script_path ok");
1974 NAPI_ASSERT(env, value == nullptr, "napi_run_script_path fail");
1975
1976 napi_value _value;
1977 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1978
1979 return _value;
1980 }
1981
napiGetNodeVersion(napi_env env,napi_callback_info info)1982 static napi_value napiGetNodeVersion(napi_env env, napi_callback_info info)
1983 {
1984 napi_value value;
1985 const napi_node_version* version;
1986 napi_get_node_version(env, &version);
1987 const char* release = version->release;
1988 napi_status status = napi_create_string_utf8(env, release, strlen(release), &value);
1989 NAPI_ASSERT(env, status == napi_ok, "napi_create_string_utf8 ok");
1990 napi_value _value;
1991 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1992
1993 return _value;
1994 }
1995
napiCallThreadsafeFunction(napi_env env,napi_callback_info info)1996 static napi_value napiCallThreadsafeFunction(napi_env env, napi_callback_info info)
1997 {
1998 void* data = nullptr;
1999 napi_threadsafe_function func = (napi_threadsafe_function)data;
2000 napi_threadsafe_function_call_mode blockMode = napi_tsfn_nonblocking;
2001 void* context = nullptr;
2002 napi_status status = napi_get_threadsafe_function_context(func, &context);
2003 NAPI_ASSERT(env, status != napi_ok, "napi_get_threadsafe_function_context fail");
2004 static int32_t gSendData = 0;
2005 napi_call_threadsafe_function(func, &gSendData, blockMode);
2006 status = napi_call_threadsafe_function(func, &gSendData, blockMode);
2007 NAPI_ASSERT(env, status != napi_ok, "napi_call_threadsafe_function fail");
2008 napi_release_threadsafe_function(func, napi_tsfn_release);
2009 napi_value value;
2010 NAPI_CALL(env, napi_create_int32(env, 0, &value));
2011
2012 return value;
2013 }
2014
napiCreateThreadsafeFunction(napi_env env,napi_callback_info info)2015 static napi_value napiCreateThreadsafeFunction(napi_env env, napi_callback_info info)
2016 {
2017 napi_threadsafe_function tsFunc = nullptr;
2018 napi_value resourceName = 0;
2019 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2020 int32_t callJstCbDataTestId = 101;
2021 int32_t finalCbtDataTestID = 1001;
2022 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
2023 0, 1, &callJstCbDataTestId, nullptr,
2024 &finalCbtDataTestID, nullptr, &tsFunc);
2025 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
2026
2027 napi_acquire_threadsafe_function(tsFunc);
2028 status = napi_unref_threadsafe_function(env, tsFunc);
2029 NAPI_ASSERT(env, status != napi_ok, "napi_unref_threadsafe_function failed");
2030
2031 napi_value _value;
2032 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2033
2034 return _value;
2035 }
2036
2037 struct AddonData {
2038 napi_async_work asyncWork = nullptr;
2039 napi_deferred deferred = nullptr;
2040 napi_ref callback = nullptr;
2041 double args = 0;
2042 double result = 0;
2043 };
AddExecuteCB(napi_env env,void * data)2044 static void AddExecuteCB(napi_env env, void *data) {
2045 AddonData *addonData = (AddonData *)data;
2046 addonData->result = addonData->args;
2047 }
2048
AddCallbackCompleteCB(napi_env env,napi_status status,void * data)2049 static void AddCallbackCompleteCB(napi_env env, napi_status status, void *data) {
2050 AddonData *addonData = (AddonData *)data;
2051 napi_value callback = nullptr;
2052 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, addonData->callback, &callback));
2053 napi_value result = nullptr;
2054 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
2055 napi_value callbackResult = nullptr;
2056
2057 int32_t ret = 0;
2058 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, 1, &result, &callbackResult));
2059 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, callbackResult, &ret));
2060 NAPI_ASSERT_RETURN_VOID(env, ret == 2000, "AddCallbackCompleteCB failed");
2061
2062 if (addonData->callback != nullptr) {
2063 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, addonData->callback));
2064 }
2065
2066 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
2067 free(addonData);
2068 }
2069
testAsyncWork(napi_env env,napi_callback_info info)2070 static napi_value testAsyncWork(napi_env env, napi_callback_info info) {
2071 size_t argc = 2;
2072 napi_value args[2];
2073 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2074
2075 struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
2076 if (addonData == nullptr) {
2077 return nullptr;
2078 }
2079
2080 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
2081 NAPI_CALL(env, napi_create_reference(env, args[1], 1, &addonData->callback));
2082
2083 napi_value resourceName = nullptr;
2084 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName));
2085 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB, AddCallbackCompleteCB,
2086 (void *)addonData, &addonData->asyncWork));
2087
2088 NAPI_CALL(env, napi_queue_async_work(env, addonData->asyncWork));
2089
2090 napi_value _value = 0;
2091 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2092 return _value;
2093 }
2094
AddPromiseCompleteCB(napi_env env,napi_status status,void * data)2095 static void AddPromiseCompleteCB(napi_env env, napi_status status, void *data) {
2096 AddonData *addonData = (AddonData *)data;
2097 napi_value result = nullptr;
2098 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
2099 if (addonData->result > 0) {
2100 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, addonData->deferred, result));
2101 } else {
2102 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, addonData->deferred, result));
2103 }
2104
2105 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
2106 free(addonData);
2107 addonData = nullptr;
2108 }
2109
testPromise(napi_env env,napi_callback_info info)2110 static napi_value testPromise(napi_env env, napi_callback_info info)
2111 {
2112 size_t argc = 1;
2113 napi_value args[1];
2114 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2115
2116 napi_value promise = nullptr;
2117 napi_deferred deferred = nullptr;
2118 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2119
2120 struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
2121 if (addonData == nullptr) {
2122 return nullptr;
2123 }
2124 addonData->deferred = deferred;
2125
2126 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
2127
2128 napi_value resourceName = nullptr;
2129 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncCallback", NAPI_AUTO_LENGTH, &resourceName));
2130 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB,
2131 AddPromiseCompleteCB, (void *)addonData, &addonData->asyncWork));
2132
2133 napi_queue_async_work(env, addonData->asyncWork);
2134
2135 return promise;
2136 }
2137
napiCancelAsyncWork(napi_env env,napi_callback_info info)2138 static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
2139 {
2140 napi_async_work work = nullptr;
2141 napi_value resourceName = nullptr;
2142 napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName);
2143 napi_create_async_work(env, nullptr, resourceName, [](napi_env value, void* data) {},
2144 [](napi_env env, napi_status status, void* data) {}, nullptr, &work);
2145 NAPI_CALL(env, napi_cancel_async_work(env, work));
2146 napi_delete_async_work(env, work);
2147 napi_value value;
2148 NAPI_CALL(env, napi_create_int32(env, 0, &value));
2149
2150 return value;
2151 }
2152
SayHello(napi_env env,napi_callback_info info)2153 static napi_value SayHello(napi_env env, napi_callback_info info)
2154 {
2155 printf("Hello\n");
2156 napi_value ret;
2157 NAPI_CALL(env, napi_create_int32(env, TAG_NUMBER, &ret));
2158 return ret;
2159 }
2160
napiCreateFunction(napi_env env,napi_callback_info info)2161 static napi_value napiCreateFunction(napi_env env, napi_callback_info info)
2162 {
2163 napi_value funcValue = nullptr;
2164 napi_status status = napi_create_function(env, "func", NAPI_AUTO_LENGTH, SayHello, NULL, &funcValue);
2165 NAPI_ASSERT(env, funcValue != nullptr, "napi_create_function fail");
2166 NAPI_ASSERT(env, status == napi_ok, "napi_create_function fail");
2167 napi_value value;
2168 NAPI_CALL(env, napi_create_int32(env, 1, &value));
2169
2170 return funcValue;
2171 }
2172
NapiCreateFunctionTwo(napi_env env,napi_callback_info info)2173 static napi_value NapiCreateFunctionTwo(napi_env env, napi_callback_info info)
2174 {
2175 napi_value resultValue = nullptr;
2176 napi_status status = napi_create_function(env, nullptr, NAPI_AUTO_LENGTH, SayHello, nullptr, &resultValue);
2177 if (resultValue == nullptr) {
2178 napi_throw_error(env, nullptr, "napi_create_function fail");
2179 return nullptr;
2180 }
2181 if (status != napi_ok) {
2182 napi_throw_error(env, nullptr, "napi_create_function fail");
2183 return nullptr;
2184 }
2185 napi_value value;
2186 NAPI_CALL(env, napi_create_int32(env, 1, &value));
2187
2188 return resultValue;
2189 }
2190
napiRefthreadSafeFunction(napi_env env,napi_callback_info info)2191 static napi_value napiRefthreadSafeFunction(napi_env env, napi_callback_info info)
2192 {
2193 napi_threadsafe_function tsFunc = nullptr;
2194 napi_value resourceName = 0;
2195 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2196 int32_t callJsCbDataTestId = 101;
2197 int32_t finalCbDataTestId = 1001;
2198 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
2199 0, 1, &callJsCbDataTestId,
2200 nullptr, &finalCbDataTestId, nullptr, &tsFunc);
2201 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
2202
2203 status = napi_ref_threadsafe_function(env, tsFunc);
2204 NAPI_ASSERT(env, status != napi_ok, "napi_ref_threadsafe_function");
2205 napi_value _value;
2206 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2207
2208 return _value;
2209 }
2210
napiCreateDate(napi_env env,napi_callback_info info)2211 static napi_value napiCreateDate(napi_env env, napi_callback_info info)
2212 {
2213 napi_value createResult = nullptr;
2214 double time = 202110181203150;
2215 napi_status status = napi_create_date(env, time, &createResult);
2216 NAPI_ASSERT(env, status == napi_ok, "napi_create_date success");
2217 double getTime = false;
2218 napi_get_date_value(env, createResult, &getTime);
2219 bool result = false;
2220 if (time == getTime) {
2221 result = true;
2222 }
2223 napi_value value;
2224 NAPI_CALL(env, napi_create_int32(env, result, &value));
2225
2226 return value;
2227 }
2228
napiCreateBigintUint64(napi_env env,napi_callback_info info)2229 static napi_value napiCreateBigintUint64(napi_env env, napi_callback_info info)
2230 {
2231 uint64_t testValue = UINT64_MAX;
2232 napi_value result = nullptr;
2233 napi_create_bigint_uint64(env, testValue, &result);
2234
2235 uint64_t resultValue = 0;
2236 bool flag = false;
2237 napi_get_value_bigint_uint64(env, result, &resultValue, &flag);
2238 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
2239 napi_value value;
2240 NAPI_CALL(env, napi_create_int32(env, flag, &value));
2241
2242 return value;
2243 }
2244
napiCreateBigintInt64(napi_env env,napi_callback_info info)2245 static napi_value napiCreateBigintInt64(napi_env env, napi_callback_info info)
2246 {
2247 int64_t testValue = INT64_MAX;
2248 napi_value result = nullptr;
2249 napi_create_bigint_int64(env, testValue, &result);
2250 int64_t resultValue = 0;
2251 bool flag = false;
2252 napi_get_value_bigint_int64(env, result, &resultValue, &flag);
2253 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
2254 napi_value value;
2255 NAPI_CALL(env, napi_create_int32(env, flag, &value));
2256
2257 return value;
2258 }
2259
napiCreateBigintWords(napi_env env,napi_callback_info info)2260 static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info)
2261 {
2262 int signBit = 0;
2263 size_t wordCount = 4;
2264 uint64_t words[] = {0ULL, 34ULL, 56ULL, 2ULL};
2265 uint64_t wordsOut[] = {0ULL, 0ULL, 0ULL, 0ULL};
2266 napi_value result = nullptr;
2267 NAPI_CALL(env, napi_create_bigint_words(env, signBit, wordCount, words, &result));
2268 int retSignBit = -1;
2269 size_t retWordCount = 4;
2270 NAPI_CALL(env, napi_get_value_bigint_words(env, result, &retSignBit, &retWordCount, wordsOut));
2271 bool testResult = true;
2272 if (retSignBit != signBit || retWordCount != wordCount) {
2273 testResult = false;
2274 }
2275 for (size_t i = 0; i < wordCount; i++) {
2276 if (wordsOut[i] != words[i]) {
2277 testResult = false;
2278 break;
2279 }
2280 }
2281 napi_value value;
2282 NAPI_CALL(env, napi_create_int32(env, testResult, &value));
2283
2284 return value;
2285 }
2286
callFunction(napi_env env,napi_callback_info info)2287 static napi_value callFunction(napi_env env, napi_callback_info info)
2288 {
2289 size_t argc = 1;
2290 napi_value args[1];
2291 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
2292
2293 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
2294
2295 napi_valuetype valuetype;
2296 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
2297
2298 NAPI_ASSERT(env, valuetype == napi_function,
2299 "Wrong type of argment. Expects a string.");
2300 napi_value ret;
2301 NAPI_CALL(env, napi_call_function(env, nullptr, args[0], 0, nullptr, &ret));
2302 return ret;
2303 }
2304
getGlobal(napi_env env,napi_callback_info info)2305 static napi_value getGlobal(napi_env env, napi_callback_info info)
2306 {
2307 napi_value result = nullptr;
2308 NAPI_CALL(env, napi_get_global(env, &result));
2309 NAPI_ASSERT(env, result != nullptr, "napi_get_global failed");
2310 return nullptr;
2311 }
2312
2313 napi_threadsafe_function tsfn;
2314 napi_ref functionRef;
CallJs(napi_env env,napi_value js_cb,void * context,void * data)2315 static void CallJs(napi_env env, napi_value js_cb, void *context, void *data) {
2316
2317 napi_value undefined;
2318 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2319 napi_value cb;
2320 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, functionRef, &cb));
2321
2322 napi_value ret;
2323 int32_t num = 0;
2324 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, cb, 0, nullptr, &ret));
2325 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, ret, &num));
2326 NAPI_ASSERT_RETURN_VOID(env, num == TAG_NUMBER, "CallJs fail");
2327 }
2328
ThreadSafeTest(napi_env env,napi_callback_info info)2329 static napi_value ThreadSafeTest(napi_env env, napi_callback_info info) {
2330 size_t argc = 1;
2331 napi_value js_cb, work_name;
2332 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL));
2333 napi_create_reference(env, js_cb, 1, &functionRef);
2334
2335 NAPI_CALL(env, napi_create_string_utf8(env, "work_name", NAPI_AUTO_LENGTH, &work_name));
2336
2337 napi_valuetype valueType = napi_undefined;
2338 NAPI_CALL(env, napi_typeof(env, js_cb, &valueType));
2339 NAPI_ASSERT(env, valueType == napi_function, "valueType expect equal to napi_function");
2340
2341 const char context[] = "context";
2342 NAPI_CALL(env, napi_create_threadsafe_function(
2343 env, js_cb, NULL, work_name, 0, 1, NULL, NULL, (void*)context, CallJs, &tsfn));
2344 void* retContext = nullptr;
2345 NAPI_CALL(env, napi_get_threadsafe_function_context(tsfn, &retContext));
2346 NAPI_ASSERT(env, retContext == context, "napi_get_threadsafe_function_context failed");
2347
2348 napi_acquire_threadsafe_function(tsfn);
2349 napi_call_threadsafe_function(tsfn, NULL, napi_tsfn_blocking);
2350
2351 NAPI_CALL(env, napi_ref_threadsafe_function(env, tsfn));
2352 NAPI_CALL(env, napi_unref_threadsafe_function(env, tsfn));
2353 NAPI_CALL(env, napi_release_threadsafe_function(tsfn, napi_tsfn_release));
2354 napi_value _value;
2355 NAPI_CALL(env, napi_create_int32(env, 1, &_value));
2356 return _value;
2357 }
2358
NoopDeleter(napi_env env,void * data,void * finalizeHint)2359 static void NoopDeleter(napi_env env, void* data, void* finalizeHint)
2360 {
2361 (void)finalizeHint;
2362 g_delCount++;
2363 }
2364
2365 static const char TEST_STR[] =
2366 "Where there is a will, there is a way.";
2367
DelTest(napi_env env,void * data,void * finalizeHint)2368 static void DelTest(napi_env env, void* data, void* finalizeHint)
2369 {
2370 (void)finalizeHint;
2371 free(data);
2372 g_delCount++;
2373 }
2374
CreateBuffer(napi_env env,napi_callback_info info)2375 static napi_value CreateBuffer(napi_env env, napi_callback_info info)
2376 {
2377 const unsigned int bufferSize = sizeof(TEST_STR);
2378 char* copyPtr;
2379 napi_value napiBuffer;
2380 napi_status status = napi_create_buffer(env, bufferSize, (void**)(©Ptr), &napiBuffer);
2381 if (status != napi_ok) {
2382 napi_throw_error(env, nullptr, "Failed to create buffer");
2383 return nullptr;
2384 }
2385 NAPI_ASSERT(env, copyPtr, "Unable to duplicate static text for CreateBuffer.");
2386 int ret = memcpy_s(copyPtr, bufferSize, TEST_STR, strlen(TEST_STR) + 1);
2387 NAPI_ASSERT(env, ret == 0, "memcpy_s failed");
2388 return napiBuffer;
2389 }
2390
CreateExternalBuffer(napi_env env,napi_callback_info info)2391 static napi_value CreateExternalBuffer(napi_env env, napi_callback_info info)
2392 {
2393 char* copyPtr = strdup(TEST_STR);
2394 napi_value napiBuffer;
2395 const unsigned int bufferSize = sizeof(TEST_STR);
2396
2397 NAPI_ASSERT(env, copyPtr, "Unable to duplicate static text for CreateExternalBuffer.");
2398 NAPI_CALL(env,
2399 napi_create_external_buffer(env,
2400 bufferSize,
2401 copyPtr,
2402 DelTest,
2403 nullptr /* finalizeHint */,
2404 &napiBuffer));
2405 return napiBuffer;
2406 }
2407
BufferCopy(napi_env env,napi_callback_info info)2408 static napi_value BufferCopy(napi_env env, napi_callback_info info)
2409 {
2410 const unsigned int bufferSize = sizeof(TEST_STR);
2411 napi_value napiBuffer;
2412 void* dataPtr = nullptr;
2413 napi_status status = napi_create_buffer_copy(env, bufferSize, TEST_STR, &dataPtr, &napiBuffer);
2414 if (status != napi_ok) {
2415 napi_throw_error(env, nullptr, "Failed to create buffer");
2416 return nullptr;
2417 }
2418 return napiBuffer;
2419 }
2420
IsBuffer(napi_env env,napi_callback_info info)2421 static napi_value IsBuffer(napi_env env, napi_callback_info info)
2422 {
2423 napi_value args[1];
2424 size_t argc = 1;
2425 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2426 napi_throw_error(env, nullptr, "Failed to parse arguments");
2427 return nullptr;
2428 }
2429 NAPI_ASSERT(env, argc == 1, "The number of arguments provided is incorrect.");
2430 napi_value napiBuffer = args[0];
2431 bool result;
2432 napi_status status = napi_is_buffer(env, napiBuffer, &result);
2433 if (status != napi_ok) {
2434 napi_throw_error(env, nullptr, "The parameter instance is not of type buffer.");
2435 }
2436 napi_value returnValue;
2437 NAPI_CALL(env, napi_get_boolean(env, result, &returnValue));
2438 return returnValue;
2439 }
2440
GetBufferInfo(napi_env env,napi_callback_info info)2441 static napi_value GetBufferInfo(napi_env env, napi_callback_info info)
2442 {
2443 size_t argc = 1;
2444 napi_value args[1];
2445 const unsigned int bufferSize = sizeof(TEST_STR);
2446 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2447 napi_throw_error(env, nullptr, "Failed to parse arguments");
2448 return nullptr;
2449 }
2450 NAPI_ASSERT(env, argc == 1, "Incorrect number of parameters.");
2451 napi_value napiBuffer = args[0];
2452 char *bufferData;
2453 napi_value returnValue;
2454 size_t bufferLength;
2455 if (napi_get_buffer_info(env, napiBuffer, (void**)(&bufferData), &bufferLength) != napi_ok) {
2456 napi_throw_error(env, nullptr, "Failed to get buffer info.");
2457 return nullptr;
2458 }
2459 NAPI_CALL(env, napi_get_boolean(env,
2460 !strcmp(bufferData, TEST_STR) && bufferLength == bufferSize,
2461 &returnValue));
2462 return returnValue;
2463 }
2464
StaticBuffer(napi_env env,napi_callback_info info)2465 static napi_value StaticBuffer(napi_env env, napi_callback_info info)
2466 {
2467 napi_value napiBuffer;
2468 const unsigned int bufferSize = sizeof(TEST_STR);
2469 NAPI_CALL(env,
2470 napi_create_external_buffer(env,
2471 bufferSize,
2472 (void*)TEST_STR,
2473 NoopDeleter,
2474 nullptr /* finalizeHint */,
2475 &napiBuffer));
2476 return napiBuffer;
2477 }
2478
GetSymbolNames(napi_env env,napi_callback_info info)2479 static napi_value GetSymbolNames(napi_env env, napi_callback_info info)
2480 {
2481 size_t argc = 1;
2482 napi_value args[1];
2483 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2484 napi_throw_error(env, nullptr, "Failed to parse arguments");
2485 return nullptr;
2486 }
2487 if (argc < 1) {
2488 napi_throw_error(env, nullptr, "Wrong number of arguments");
2489 return nullptr;
2490 }
2491 napi_valuetype valueType0;
2492 NAPI_CALL(env, napi_typeof(env, args[0], &valueType0));
2493 if (valueType0 != napi_object) {
2494 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2495 return nullptr;
2496 }
2497 napi_value output;
2498 NAPI_CALL(env,
2499 napi_get_all_property_names(env,
2500 args[0],
2501 napi_key_include_prototypes,
2502 napi_key_skip_strings,
2503 napi_key_numbers_to_strings,
2504 &output));
2505 return output;
2506 }
2507
GetEnumerableWritableNames(napi_env env,napi_callback_info info)2508 static napi_value GetEnumerableWritableNames(napi_env env, napi_callback_info info)
2509 {
2510 size_t argc = 1;
2511 napi_value args[1];
2512 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2513 napi_throw_error(env, nullptr, "Failed to parse arguments");
2514 return nullptr;
2515 }
2516 if (argc < 1) {
2517 napi_throw_error(env, nullptr, "Wrong number of arguments");
2518 return nullptr;
2519 }
2520 napi_valuetype valueType0;
2521 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2522 napi_throw_error(env, nullptr, "Failed to get argument type");
2523 return nullptr;
2524 }
2525 if (valueType0 != napi_object) {
2526 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2527 return nullptr;
2528 }
2529 napi_value output;
2530 NAPI_CALL(env,
2531 napi_get_all_property_names(env,
2532 args[0],
2533 napi_key_include_prototypes,
2534 static_cast<napi_key_filter>(napi_key_writable | napi_key_enumerable),
2535 napi_key_numbers_to_strings,
2536 &output));
2537 return output;
2538 }
2539
GetOwnWritableNames(napi_env env,napi_callback_info info)2540 static napi_value GetOwnWritableNames(napi_env env, napi_callback_info info)
2541 {
2542 size_t argc = 1;
2543 napi_value args[1];
2544 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2545 napi_throw_error(env, nullptr, "Failed to parse arguments");
2546 return nullptr;
2547 }
2548 if (argc < 1) {
2549 napi_throw_error(env, nullptr, "Wrong number of arguments");
2550 return nullptr;
2551 }
2552 napi_valuetype valueType0;
2553 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2554 napi_throw_error(env, nullptr, "Failed to get argument type");
2555 return nullptr;
2556 }
2557 if (valueType0 != napi_object) {
2558 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2559 return nullptr;
2560 }
2561 napi_value output;
2562 NAPI_CALL(env,
2563 napi_get_all_property_names(env,
2564 args[0],
2565 napi_key_own_only,
2566 napi_key_writable,
2567 napi_key_numbers_to_strings,
2568 &output));
2569 return output;
2570 }
2571
GetEnumerableConfigurableNames(napi_env env,napi_callback_info info)2572 static napi_value GetEnumerableConfigurableNames(napi_env env, napi_callback_info info)
2573 {
2574 size_t argc = 1;
2575 napi_value args[1];
2576 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2577 napi_throw_error(env, nullptr, "Failed to parse arguments");
2578 return nullptr;
2579 }
2580 if (argc < 1) {
2581 napi_throw_error(env, nullptr, "Wrong number of arguments");
2582 return nullptr;
2583 }
2584 napi_valuetype valueType0;
2585 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2586 napi_throw_error(env, nullptr, "Failed to get argument type");
2587 return nullptr;
2588 }
2589 if (valueType0 != napi_object) {
2590 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2591 return nullptr;
2592 }
2593 napi_value output;
2594 NAPI_CALL(env,
2595 napi_get_all_property_names(env,
2596 args[0],
2597 napi_key_include_prototypes,
2598 static_cast<napi_key_filter>(napi_key_enumerable | napi_key_configurable),
2599 napi_key_numbers_to_strings,
2600 &output));
2601 return output;
2602 }
2603
GetOwnConfigurableNames(napi_env env,napi_callback_info info)2604 static napi_value GetOwnConfigurableNames(napi_env env, napi_callback_info info)
2605 {
2606 size_t argc = 1;
2607 napi_value args[1];
2608 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2609 napi_throw_error(env, nullptr, "Failed to parse arguments");
2610 return nullptr;
2611 }
2612 if (argc < 1) {
2613 napi_throw_error(env, nullptr, "Wrong number of arguments");
2614 return nullptr;
2615 }
2616 napi_valuetype valueType0;
2617 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2618 napi_throw_error(env, nullptr, "Failed to get argument type");
2619 return nullptr;
2620 }
2621 if (valueType0 != napi_object) {
2622 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2623 return nullptr;
2624 }
2625 napi_value output;
2626 NAPI_CALL(env,
2627 napi_get_all_property_names(env,
2628 args[0],
2629 napi_key_own_only,
2630 napi_key_configurable,
2631 napi_key_numbers_to_strings,
2632 &output));
2633 return output;
2634 }
2635
GetAllPropertyNames(napi_env env,napi_callback_info info)2636 static napi_value GetAllPropertyNames(napi_env env, napi_callback_info info)
2637 {
2638 napi_value returnValue, props;
2639 NAPI_CALL(env, napi_create_object(env, &returnValue));
2640 add_returned_status(env,
2641 "envIsNull",
2642 returnValue,
2643 "Invalid argument",
2644 napi_invalid_arg,
2645 napi_get_all_property_names(nullptr,
2646 returnValue,
2647 napi_key_own_only,
2648 napi_key_writable,
2649 napi_key_keep_numbers,
2650 &props));
2651 napi_get_all_property_names(env,
2652 nullptr,
2653 napi_key_own_only,
2654 napi_key_writable,
2655 napi_key_keep_numbers,
2656 &props);
2657 add_last_status(env, "objectIsNull", returnValue);
2658 napi_get_all_property_names(env,
2659 returnValue,
2660 napi_key_own_only,
2661 napi_key_writable,
2662 napi_key_keep_numbers,
2663 nullptr);
2664 add_last_status(env, "valueIsNull", returnValue);
2665 return returnValue;
2666 }
2667
FreezeTest(napi_env env,napi_callback_info info)2668 static napi_value FreezeTest(napi_env env, napi_callback_info info)
2669 {
2670 size_t argc = 1;
2671 napi_value args[1];
2672 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2673
2674 // Check if argument is an object
2675 napi_value objectConstructor;
2676 napi_status status = napi_get_named_property(env, args[0], "Object", &objectConstructor);
2677 if (status != napi_ok) {
2678 napi_throw_error(env, nullptr, "Argument must be an object");
2679 }
2680 // Freeze the object
2681 napi_value object = args[0];
2682 NAPI_CALL(env, napi_object_freeze(env, object));
2683 return object;
2684 }
2685
SealTest(napi_env env,napi_callback_info info)2686 static napi_value SealTest(napi_env env, napi_callback_info info)
2687 {
2688 size_t argc = 1;
2689 napi_value args[1];
2690 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2691
2692 // Check if argument is an object
2693 napi_value objectConstructor;
2694 napi_status status = napi_get_named_property(env, args[0], "Object", &objectConstructor);
2695 if (status != napi_ok) {
2696 napi_throw_error(env, nullptr, "Argument must be an object");
2697 }
2698 // Seal the object
2699 napi_value object = args[0];
2700 NAPI_CALL(env, napi_object_seal(env, object));
2701
2702 return object;
2703 }
2704
FinalizeCallback(napi_env env,void * finalizeData,void * finalizeHint)2705 void FinalizeCallback(napi_env env, void* finalizeData, void* finalizeHint)
2706 {
2707 free(finalizeData);
2708 }
2709
External(napi_env env,napi_callback_info info)2710 static napi_value External(napi_env env, napi_callback_info info)
2711 {
2712 const uint8_t parraySize = 3;
2713 void* externalData = malloc(parraySize * sizeof(int8_t));
2714
2715 //Sets the three elements of the array that are used to create an ArrayBuffer object
2716 ((int8_t*)externalData)[0] = 0; // 0 means that the first value of the created array is 0
2717 ((int8_t*)externalData)[1] = 1; // 1 means that the second value of the created array is 1
2718 ((int8_t*)externalData)[2] = 2; // 2 means that the third value of the created array is 2
2719
2720 napi_value outputBuffer;
2721 napi_status status = napi_create_external_arraybuffer(env,
2722 externalData,
2723 parraySize * sizeof(int8_t),
2724 FinalizeCallback,
2725 nullptr, // finalizeHint
2726 &outputBuffer);
2727 if (status != napi_ok) {
2728 napi_throw_error(env, nullptr, "Failed to create external arraybuffer");
2729 return nullptr;
2730 }
2731 napi_value outputArray;
2732 status = napi_create_typedarray(env,
2733 napi_int8_array,
2734 parraySize,
2735 outputBuffer,
2736 0,
2737 &outputArray);
2738 if (status != napi_ok) {
2739 napi_throw_error(env, nullptr, "Failed to create typedarray");
2740 return nullptr;
2741 }
2742 return outputArray;
2743 }
2744
DetachTest(napi_env env,napi_callback_info info)2745 static napi_value DetachTest(napi_env env, napi_callback_info info)
2746 {
2747 size_t argc = 1;
2748 napi_value args[1];
2749 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2750 NAPI_ASSERT(env, argc == 1, "The number of arguments provided is incorrect.");
2751 void* data;
2752 size_t length;
2753 napi_typedarray_type type;
2754 napi_value arrayBuffer;
2755 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &type, &length, &data, &arrayBuffer, nullptr));
2756
2757 NAPI_CALL(env, napi_detach_arraybuffer(env, arrayBuffer));
2758 return nullptr;
2759 }
2760
IsDetachedTest(napi_env env,napi_callback_info info)2761 napi_value IsDetachedTest(napi_env env, napi_callback_info info)
2762 {
2763 size_t argc = 1;
2764 napi_value args[1];
2765 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
2766 if (status != napi_ok || argc != 1) {
2767 napi_throw_error(env, nullptr, "Wrong number of arguments.");
2768 return nullptr;
2769 }
2770 bool isArraybuffer;
2771 status = napi_is_arraybuffer(env, args[0], &isArraybuffer);
2772 if (status != napi_ok || !isArraybuffer) {
2773 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an array buffer as first argument.");
2774 return nullptr;
2775 }
2776 bool isDetached;
2777 status = napi_is_detached_arraybuffer(env, args[0], &isDetached);
2778 if (status != napi_ok) {
2779 napi_throw_error(env, nullptr, "Failed to check if array buffer is detached.");
2780 return nullptr;
2781 }
2782 napi_value result;
2783 status = napi_get_boolean(env, isDetached, &result);
2784 if (status != napi_ok) {
2785 napi_throw_error(env, nullptr, "Failed to create boolean result.");
2786 return nullptr;
2787 }
2788 return result;
2789 }
2790
2791 EXTERN_C_START
2792
Init(napi_env env,napi_value exports)2793 static napi_value Init(napi_env env, napi_value exports)
2794 {
2795 napi_value theValue;
2796 NAPI_CALL(env, napi_create_string_utf8(env, TEST_STR, sizeof(TEST_STR), &theValue));
2797 NAPI_CALL(env, napi_set_named_property(env, exports, "testStr", theValue));
2798 napi_property_descriptor properties[] = {
2799 DECLARE_NAPI_FUNCTION("getLastErrorInfo", getLastErrorInfo),
2800 DECLARE_NAPI_FUNCTION("cleanUpErrorInfo", cleanUpErrorInfo),
2801 DECLARE_NAPI_FUNCTION("throwExistingError", throwExistingError),
2802 DECLARE_NAPI_FUNCTION("throwError", throwError),
2803 DECLARE_NAPI_FUNCTION("throwTypeError", throwTypeError),
2804 DECLARE_NAPI_FUNCTION("throwRangeError", throwRangeError),
2805 DECLARE_NAPI_FUNCTION("isError", isError),
2806 DECLARE_NAPI_FUNCTION("createError", createError),
2807 DECLARE_NAPI_FUNCTION("createTypeError", createTypeError),
2808 DECLARE_NAPI_FUNCTION("createRangeError", createRangeError),
2809 DECLARE_NAPI_FUNCTION("getAndClearLastException", getAndClearLastException),
2810 DECLARE_NAPI_FUNCTION("isExceptionPending", isExceptionPending),
2811 DECLARE_NAPI_FUNCTION("openAndCloseHandleScope", openAndCloseHandleScope),
2812 DECLARE_NAPI_FUNCTION("openAndCloseEscapableHandleScope", openAndCloseEscapableHandleScope),
2813 DECLARE_NAPI_FUNCTION("createReference", createReference),
2814 DECLARE_NAPI_FUNCTION("getAndDeleteReference", getAndDeleteReference),
2815 DECLARE_NAPI_FUNCTION("referenceRefAndUnref", referenceRefAndUnref),
2816 DECLARE_NAPI_FUNCTION("createArrayAndGetLength", createArrayAndGetLength),
2817 DECLARE_NAPI_FUNCTION("getArrayWithLength", getArrayWithLength),
2818 DECLARE_NAPI_FUNCTION("createExternal", createExternal),
2819 DECLARE_NAPI_FUNCTION("createExternalArraybuffer", createExternalArraybuffer),
2820 DECLARE_NAPI_FUNCTION("createObject", createObject),
2821 DECLARE_NAPI_FUNCTION("createSymbol", createSymbol),
2822 DECLARE_NAPI_FUNCTION("createTypeArray", createTypeArray),
2823 DECLARE_NAPI_FUNCTION("createDataView", createDataView),
2824 DECLARE_NAPI_FUNCTION("createAndGetInt32", createAndGetInt32),
2825 DECLARE_NAPI_FUNCTION("createAndGetUInt32", createAndGetUInt32),
2826 DECLARE_NAPI_FUNCTION("createAndGetInt64", createAndGetInt64),
2827 DECLARE_NAPI_FUNCTION("createDouble", createDouble),
2828 DECLARE_NAPI_FUNCTION("createAndGetStringLatin1", createAndGetStringLatin1),
2829 DECLARE_NAPI_FUNCTION("createAndGetStringUtf8", createAndGetStringUtf8),
2830 DECLARE_NAPI_FUNCTION("getPrototype", getPrototype),
2831 DECLARE_NAPI_FUNCTION("getPrototype2", getPrototype2),
2832 DECLARE_NAPI_FUNCTION("getTypedArrayInfo", getTypedArrayInfo),
2833 DECLARE_NAPI_FUNCTION("getDataViewInfo", getDataViewInfo),
2834 DECLARE_NAPI_FUNCTION("getValueBool", getValueBool),
2835 DECLARE_NAPI_FUNCTION("getValueDouble", getValueDouble),
2836 DECLARE_NAPI_FUNCTION("getValueExternal", getValueExternal),
2837 DECLARE_NAPI_FUNCTION("getNull", getNull),
2838 DECLARE_NAPI_FUNCTION("getUndefined", getUndefined),
2839 DECLARE_NAPI_FUNCTION("coerceToBool", coerceToBool),
2840 DECLARE_NAPI_FUNCTION("coerceToNumber", coerceToNumber),
2841 DECLARE_NAPI_FUNCTION("coerceToObject", coerceToObject),
2842 DECLARE_NAPI_FUNCTION("coerceToString", coerceToString),
2843 DECLARE_NAPI_FUNCTION("instanceOf", instanceOf),
2844 DECLARE_NAPI_FUNCTION("isArray", isArray),
2845 DECLARE_NAPI_FUNCTION("isDate", isDate),
2846 DECLARE_NAPI_FUNCTION("strictEquals", strictEquals),
2847 DECLARE_NAPI_FUNCTION("getPropertyNames", getPropertyNames),
2848 DECLARE_NAPI_FUNCTION("setProperty", setProperty),
2849 DECLARE_NAPI_FUNCTION("getProperty", getProperty),
2850 DECLARE_NAPI_FUNCTION("hasProperty", hasProperty),
2851 DECLARE_NAPI_FUNCTION("setAndDeleteProperty", setAndDeleteProperty),
2852 DECLARE_NAPI_FUNCTION("hasOwnProperty", hasOwnProperty),
2853 DECLARE_NAPI_FUNCTION("setNamedProperty", setNamedProperty),
2854 DECLARE_NAPI_FUNCTION("getNamedProperty", getNamedProperty),
2855 DECLARE_NAPI_FUNCTION("hasNamedProperty", hasNamedProperty),
2856 DECLARE_NAPI_FUNCTION("setElement", setElement),
2857 DECLARE_NAPI_FUNCTION("getElement", getElement),
2858 DECLARE_NAPI_FUNCTION("hasElement", hasElement),
2859 DECLARE_NAPI_FUNCTION("deleteElement", deleteElement),
2860 DECLARE_NAPI_FUNCTION("defineProperties", defineProperties),
2861 DECLARE_NAPI_FUNCTION("wrap", wrap),
2862 DECLARE_NAPI_FUNCTION("unwrap", unwrap),
2863 DECLARE_NAPI_FUNCTION("removeWrap", removeWrap),
2864 DECLARE_NAPI_FUNCTION("getVersion", getVersion),
2865 DECLARE_NAPI_FUNCTION("createPromise", createPromise),
2866 DECLARE_NAPI_FUNCTION("resolveAndRejectDeferred", resolveAndRejectDeferred),
2867 DECLARE_NAPI_FUNCTION("isPromise", isPromise),
2868 DECLARE_NAPI_FUNCTION("TestLatin1", TestLatin1),
2869 DECLARE_NAPI_FUNCTION("TestUtf16", TestUtf16),
2870 DECLARE_NAPI_FUNCTION("TestUtf8", TestUtf8),
2871 DECLARE_NAPI_FUNCTION("runScript", runScript),
2872 DECLARE_NAPI_FUNCTION("getUvEventLoop", getUvEventLoop),
2873 DECLARE_NAPI_FUNCTION("napCreateArrayBuffer", napCreateArrayBuffer),
2874 DECLARE_NAPI_FUNCTION("naiGetArrayBufferInfo", naiGetArrayBufferInfo),
2875 DECLARE_NAPI_FUNCTION("napiDefineClass", napiDefineClass),
2876 DECLARE_NAPI_FUNCTION("napiRunScriptPath", napiRunScriptPath),
2877 DECLARE_NAPI_FUNCTION("napiGetNodeVersion", napiGetNodeVersion),
2878 DECLARE_NAPI_FUNCTION("napiCallThreadsafeFunction", napiCallThreadsafeFunction),
2879 DECLARE_NAPI_FUNCTION("napiCreateThreadsafeFunction", napiCreateThreadsafeFunction),
2880 DECLARE_NAPI_FUNCTION("napiRefthreadSafeFunction", napiRefthreadSafeFunction),
2881 DECLARE_NAPI_FUNCTION("napiCreateDate", napiCreateDate),
2882 DECLARE_NAPI_FUNCTION("napiCreateBigintUint64", napiCreateBigintUint64),
2883 DECLARE_NAPI_FUNCTION("napiCreateBigintInt64", napiCreateBigintInt64),
2884 DECLARE_NAPI_FUNCTION("napiCreateBigintWords", napiCreateBigintWords),
2885 DECLARE_NAPI_FUNCTION("napiGetCbInfo", napiGetCbInfo),
2886 DECLARE_NAPI_FUNCTION("checkTypeTag", CheckTypeTag),
2887 DECLARE_NAPI_FUNCTION("typeTaggedInstance", TypeTaggedInstance),
2888 DECLARE_NAPI_FUNCTION("stringUtf16OfCase", StringUtf16OfCase),
2889 DECLARE_NAPI_FUNCTION("createAndGetStringUtf16", CreateAndGetStringUtf16),
2890 { "napiCancelAsyncWork", nullptr, napiCancelAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
2891 { "testAsyncWork", nullptr, testAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
2892 { "testPromise", nullptr, testPromise, nullptr, nullptr, nullptr, napi_default, nullptr },
2893 { "napiCreateFunction", nullptr, napiCreateFunction, nullptr, nullptr, nullptr, napi_default, nullptr },
2894 { "NapiCreateFunctionTwo", nullptr, NapiCreateFunctionTwo, nullptr, nullptr, nullptr, napi_default, nullptr },
2895 DECLARE_NAPI_FUNCTION("getGlobal", getGlobal),
2896 DECLARE_NAPI_FUNCTION("callFunction", callFunction),
2897 DECLARE_NAPI_FUNCTION("ThreadSafeTest", ThreadSafeTest),
2898 DECLARE_NAPI_FUNCTION("CreateBuffer", CreateBuffer),
2899 DECLARE_NAPI_FUNCTION("CreateExternalBuffer", CreateExternalBuffer),
2900 DECLARE_NAPI_FUNCTION("BufferCopy", BufferCopy),
2901 DECLARE_NAPI_FUNCTION("IsBuffer", IsBuffer),
2902 DECLARE_NAPI_FUNCTION("GetBufferInfo", GetBufferInfo),
2903 DECLARE_NAPI_FUNCTION("GetAllPropertyNames", GetAllPropertyNames),
2904 DECLARE_NAPI_FUNCTION("GetSymbolNames", GetSymbolNames),
2905 DECLARE_NAPI_FUNCTION("GetEnumerableWritableNames", GetEnumerableWritableNames),
2906 DECLARE_NAPI_FUNCTION("GetOwnWritableNames", GetOwnWritableNames),
2907 DECLARE_NAPI_FUNCTION("GetEnumerableConfigurableNames", GetEnumerableConfigurableNames),
2908 DECLARE_NAPI_FUNCTION("GetOwnConfigurableNames", GetOwnConfigurableNames),
2909 DECLARE_NAPI_FUNCTION("FreezeTest", FreezeTest),
2910 DECLARE_NAPI_FUNCTION("SealTest", SealTest),
2911 DECLARE_NAPI_FUNCTION("StaticBuffer", StaticBuffer),
2912 DECLARE_NAPI_FUNCTION("External", External),
2913 DECLARE_NAPI_FUNCTION("DetachTest", DetachTest),
2914 DECLARE_NAPI_FUNCTION("IsDetachedTest", IsDetachedTest),
2915 DECLARE_NAPI_FUNCTION("stringUtf16OfLengthLeZero", StringUtf16OfLengthLeZero),
2916 DECLARE_NAPI_FUNCTION("stringUtf16OfLengthEqOne", StringUtf16OfLengthEqOne),
2917 DECLARE_NAPI_FUNCTION("stringUtf8OfLengthLeZero", StringUtf8OfLengthLeZero),
2918 DECLARE_NAPI_FUNCTION("NewTargetTest", NewTargetTest),
2919 };
2920 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
2921
2922 napi_property_descriptor descClass[] = {
2923 DECLARE_NAPI_FUNCTION("sayHello", SayHello),
2924 };
2925 napi_value myClass;
2926 napi_define_class(env, "myClass", NAPI_AUTO_LENGTH, MyConstructor, nullptr,
2927 sizeof(descClass) / sizeof(descClass[0]), descClass, &myClass);
2928 napi_set_named_property(env, exports, "myClass", myClass);
2929 return exports;
2930 }
2931
2932 EXTERN_C_END
2933
2934 static napi_module demoModule = {
2935 .nm_version = 1,
2936 .nm_flags = 0,
2937 .nm_filename = nullptr,
2938 .nm_register_func = Init,
2939 .nm_modname = "napitest",
2940 .nm_priv = ((void *)0),
2941 .reserved = {0},
2942 };
2943
RegisterModule(void)2944 extern "C" __attribute__((constructor)) void RegisterModule(void)
2945 {
2946 napi_module_register(&demoModule);
2947 }
2948