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 "napi/native_node_api.h"
19 #include "securec.h"
20 #include <stdint.h>
21 #include <string>
22 #include <stdio.h>
23 #include <vector>
24 #include <malloc.h>
25 #include <ctime>
26 #include <thread>
27 #include <uv.h>
28
29 static napi_ref test_reference = NULL;
30 const int TAG_NUMBER = 666;
31 const int NUMBER_FIVE = 5;
32 static int g_delCount = 0;
33 static int g_cleanupHookCount = 0;
34 static napi_env g_sharedEnv = nullptr;
35 static napi_deferred g_deferred = nullptr;
36
37 struct InstanceData {
38 size_t value;
39 bool print;
40 napi_ref jsCbRef;
41 };
42
43 struct InstanceAddonData {
44 napi_ref jsCbRef;
45 napi_ref jsTsfnFinalizerRef;
46 napi_threadsafe_function tsfn;
47 uv_thread_t thread;
48 };
49
50 struct AsyncData {
51 uv_async_t async;
52 napi_env env;
53 napi_async_cleanup_hook_handle handle;
54 };
55
56 struct AddonData {
57 napi_async_work asyncWork = nullptr;
58 napi_deferred deferred = nullptr;
59 napi_ref callback = nullptr;
60 double args = 0;
61 double result = 0;
62 };
63
add_returned_status(napi_env env,const char * key,napi_value object,const char * expected_message,napi_status expected_status,napi_status actual_status)64 static void add_returned_status(napi_env env,
65 const char* key,
66 napi_value object,
67 const char* expected_message,
68 napi_status expected_status,
69 napi_status actual_status)
70 {
71 char napi_message_string[100] = "";
72 napi_value prop_value;
73
74 if (actual_status != expected_status) {
75 printf("Invalid status [%d]", actual_status);
76 }
77
78 NAPI_CALL_RETURN_VOID(env,
79 napi_create_string_utf8(env,
80 (actual_status == expected_status ?
81 expected_message :
82 napi_message_string),
83 NAPI_AUTO_LENGTH,
84 &prop_value));
85 NAPI_CALL_RETURN_VOID(env,
86 napi_set_named_property(env,
87 object,
88 key,
89 prop_value));
90 }
91
add_last_status(napi_env env,const char * key,napi_value return_value)92 static void add_last_status(napi_env env, const char* key, napi_value return_value)
93 {
94 napi_value prop_value;
95 const napi_extended_error_info* p_last_error;
96 NAPI_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error));
97
98 NAPI_CALL_RETURN_VOID(env,
99 napi_create_string_utf8(env,
100 (p_last_error->error_message == nullptr ?
101 "napi_ok" :
102 p_last_error->error_message),
103 NAPI_AUTO_LENGTH,
104 &prop_value));
105 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env,
106 return_value,
107 key,
108 prop_value));
109 }
110
getLastErrorInfo(napi_env env,napi_callback_info info)111 static napi_value getLastErrorInfo(napi_env env, napi_callback_info info)
112 {
113 napi_value value;
114 NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
115 double double_value;
116 napi_status status = napi_get_value_double(env, value, &double_value);
117 NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
118 const napi_extended_error_info * error_info = 0;
119 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
120
121 NAPI_ASSERT(env, error_info->error_code == status,
122 "Last error info code should match last status");
123 NAPI_ASSERT(env, error_info->error_message,
124 "Last error info message should not be null");
125 napi_value _value;
126 NAPI_CALL(env, napi_create_int32(env, error_info->error_code, &_value));
127 return _value;
128 }
129
cleanUpErrorInfo(napi_env env,napi_callback_info info)130 static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info)
131 {
132 const napi_extended_error_info * error_info = 0;
133 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
134
135 napi_value result;
136 bool is_ok = error_info->error_code == napi_ok;
137 NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
138
139 return result;
140 }
141
throwExistingError(napi_env env,napi_callback_info info)142 static napi_value throwExistingError(napi_env env, napi_callback_info info)
143 {
144 napi_value code = nullptr;
145 napi_value message = nullptr;
146 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
147 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
148 napi_value error = nullptr;
149 napi_create_error(env, code, message, &error);
150 NAPI_ASSERT(env, error != nullptr, "error succes");
151 bool isError = false;
152 napi_is_error(env, error, &isError);
153 NAPI_ASSERT(env, isError, "error succes");
154
155 NAPI_CALL(env, napi_throw(env, error));
156
157 napi_value _value;
158 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
159 return _value;
160 }
161
throwError(napi_env env,napi_callback_info info)162 static napi_value throwError(napi_env env, napi_callback_info info)
163 {
164 napi_value code = nullptr;
165 napi_value message = nullptr;
166 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
167 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
168 napi_value error = nullptr;
169 napi_create_error(env, code, message, &error);
170 NAPI_ASSERT(env, error != nullptr, "error succes");
171 bool isError = false;
172 napi_is_error(env, error, &isError);
173 NAPI_ASSERT(env, isError, "error succes");
174 napi_throw_error(env, "500", "Common error");
175 napi_value _value;
176 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
177 return _value;
178 }
179
throwTypeError(napi_env env,napi_callback_info info)180 static napi_value throwTypeError(napi_env env, napi_callback_info info)
181 {
182 napi_value code = nullptr;
183 napi_value message = nullptr;
184 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
185 napi_create_string_latin1(env, "type error 500", NAPI_AUTO_LENGTH, &message);
186 napi_value error = nullptr;
187 napi_create_type_error(env, code, message, &error);
188 NAPI_ASSERT(env, error != nullptr, "error succes");
189 bool isError = false;
190 napi_is_error(env, error, &isError);
191 NAPI_ASSERT(env, isError, "error succes");
192 napi_throw_type_error(env, nullptr, "type error1");
193
194 napi_value _value;
195 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
196 return _value;
197 }
198
throwRangeError(napi_env env,napi_callback_info info)199 static napi_value throwRangeError(napi_env env, napi_callback_info info)
200 {
201 napi_value code = nullptr;
202 napi_value message = nullptr;
203 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
204 napi_create_string_latin1(env, "range error 500", NAPI_AUTO_LENGTH, &message);
205 napi_value error = nullptr;
206 napi_create_range_error(env, code, message, &error);
207 NAPI_ASSERT(env, error != nullptr, "error succes");
208 bool isError = false;
209 napi_is_error(env, error, &isError);
210 NAPI_ASSERT(env, isError, "error succes");
211 napi_throw_range_error(env, nullptr, "range error");
212
213 napi_value _value;
214 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
215 return _value;
216 }
217
isError(napi_env env,napi_callback_info info)218 static napi_value isError(napi_env env, napi_callback_info info)
219 {
220 size_t argc = 1;
221 napi_value args[1];
222 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
223
224 bool r;
225 NAPI_CALL(env, napi_is_error(env, args[0], &r));
226
227 napi_value result;
228 NAPI_CALL(env, napi_get_boolean(env, r, &result));
229
230 return result;
231 }
232
createError(napi_env env,napi_callback_info info)233 static napi_value createError(napi_env env, napi_callback_info info)
234 {
235 napi_value code = nullptr;
236 napi_value message = nullptr;
237
238 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
239 napi_create_string_latin1(env, "common error", NAPI_AUTO_LENGTH, &message);
240
241 napi_value error = nullptr;
242 napi_create_error(env, code, message, &error);
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
createTypeError(napi_env env,napi_callback_info info)250 static napi_value createTypeError(napi_env env, napi_callback_info info)
251 {
252 napi_value code = nullptr;
253 napi_value message = nullptr;
254 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
255 napi_create_string_latin1(env, "type error", NAPI_AUTO_LENGTH, &message);
256 napi_value error = nullptr;
257 napi_create_type_error(env, code, message, &error);
258 NAPI_ASSERT(env, error != nullptr, "error succes");
259
260 napi_value _value;
261 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
262 return _value;
263 }
264
createRangeError(napi_env env,napi_callback_info info)265 static napi_value createRangeError(napi_env env, napi_callback_info info)
266 {
267 napi_value code = nullptr;
268 napi_value message = nullptr;
269 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
270 napi_create_string_latin1(env, "range error", NAPI_AUTO_LENGTH, &message);
271 napi_value error = nullptr;
272 napi_create_range_error(env, code, message, &error);
273
274 NAPI_ASSERT(env, error != nullptr, "error succes");
275
276 napi_value _value;
277 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
278 return _value;
279 }
280
getAndClearLastException(napi_env env,napi_callback_info info)281 static napi_value getAndClearLastException(napi_env env, napi_callback_info info)
282 {
283 napi_value code = nullptr;
284 napi_value message = nullptr;
285 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
286 napi_create_string_latin1(env, "tag range error", NAPI_AUTO_LENGTH, &message);
287
288 napi_value error = nullptr;
289 napi_create_range_error(env, code, message, &error);
290 NAPI_ASSERT(env, error != nullptr, "tag error succes");
291
292 bool isError = false;
293 napi_is_error(env, error, &isError);
294 NAPI_ASSERT(env, isError, "tag isError 1");
295
296 napi_value ex;
297 napi_get_and_clear_last_exception(env, &ex);
298
299 bool exceptionWasPending = true;
300 napi_is_exception_pending(env, &exceptionWasPending);
301 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 1");
302
303 napi_throw(env, error);
304
305 napi_is_exception_pending(env, &exceptionWasPending);
306 NAPI_ASSERT(env, exceptionWasPending, "tag exceptionWasPending 2");
307
308 napi_value ex1;
309 napi_get_and_clear_last_exception(env, &ex1);
310 isError = false;
311 napi_is_error(env, ex1, &isError);
312 NAPI_ASSERT(env, isError, "tag isError 2");
313
314 napi_is_exception_pending(env, &exceptionWasPending);
315 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 3");
316
317 return ex1;
318 }
319
isExceptionPending(napi_env env,napi_callback_info info)320 static napi_value isExceptionPending(napi_env env, napi_callback_info info)
321 {
322 bool exceptionWasPending = true;
323 napi_is_exception_pending(env, &exceptionWasPending);
324
325 NAPI_ASSERT(env, !exceptionWasPending, "isExceptionPending failed");
326
327 napi_value _value;
328 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
329 return _value;
330 }
331
openAndCloseHandleScope(napi_env env,napi_callback_info info)332 static napi_value openAndCloseHandleScope(napi_env env, napi_callback_info info)
333 {
334 napi_handle_scope scope;
335 napi_status openStatus = napi_open_handle_scope(env, &scope);
336 napi_value output = nullptr;
337 napi_status createStatus = napi_create_object(env, &output);
338 napi_status closeStatus = napi_close_handle_scope(env, scope);
339 if (openStatus == napi_ok && createStatus == napi_ok && closeStatus == napi_ok) {
340 napi_value undefined;
341 napi_get_undefined(env, &undefined);
342 return undefined;
343 }
344 return output;
345 }
346
openAndCloseEscapableHandleScope(napi_env env,napi_callback_info info)347 static napi_value openAndCloseEscapableHandleScope(napi_env env, napi_callback_info info)
348 {
349 napi_escapable_handle_scope scope;
350 NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
351 napi_value output = nullptr;
352 napi_value escapee = nullptr;
353 NAPI_CALL(env, napi_create_object(env, &output));
354 NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
355 NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
356 return escapee;
357 }
358
createReference(napi_env env,napi_callback_info info)359 static napi_value createReference(napi_env env, napi_callback_info info)
360 {
361 napi_value result = nullptr;
362
363 napi_create_int32(env, TAG_NUMBER, &result);
364 NAPI_CALL(env, napi_create_reference(env, result, 1, &test_reference));
365 napi_value value;
366 NAPI_CALL(env, napi_create_int32(env, 0, &value));
367 return value;
368 }
369
getAndDeleteReference(napi_env env,napi_callback_info info)370 static napi_value getAndDeleteReference(napi_env env, napi_callback_info info)
371 {
372 NAPI_ASSERT(env, test_reference != nullptr,
373 "A reference must have been created.");
374
375 napi_value refValue = nullptr;
376 napi_get_reference_value(env, test_reference, &refValue);
377
378 int32_t value = 0;
379 napi_get_value_int32(env, refValue, &value);
380 NAPI_ASSERT(env, value == TAG_NUMBER,
381 "refValue expect equal to 666.");
382
383 NAPI_CALL(env, napi_delete_reference(env, test_reference));
384 test_reference = nullptr;
385 return nullptr;
386 }
387
referenceRefAndUnref(napi_env env,napi_callback_info info)388 static napi_value referenceRefAndUnref(napi_env env, napi_callback_info info)
389 {
390 napi_value result = nullptr;
391 napi_ref resultRef = nullptr;
392 uint32_t resultRefCount = 0;
393
394 napi_create_object(env, &result);
395 napi_create_reference(env, result, 1, &resultRef);
396
397 napi_reference_ref(env, resultRef, &resultRefCount);
398 NAPI_ASSERT(env, resultRefCount == 2,
399 "resultRefCount expect equal to 2");
400 napi_reference_unref(env, resultRef, &resultRefCount);
401 NAPI_ASSERT(env, resultRefCount == 1,
402 "resultRefCount expect equal to 1.");
403
404 napi_value refValue = nullptr;
405 napi_get_reference_value(env, resultRef, &refValue);
406 NAPI_ASSERT(env, refValue != nullptr,
407 "A reference must have been created.");
408 napi_delete_reference(env, resultRef);
409
410 napi_value _value;
411 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
412
413 return _value;
414 }
415
createArrayAndGetLength(napi_env env,napi_callback_info info)416 static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info)
417 {
418 size_t argc = 1;
419 napi_value args[1];
420 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
421
422 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
423
424 napi_valuetype valuetype0;
425 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
426
427 NAPI_ASSERT(env, valuetype0 == napi_object,
428 "Wrong type of arguments. Expects an array as first argument.");
429
430 napi_value ret;
431 NAPI_CALL(env, napi_create_array(env, &ret));
432
433 uint32_t i, length;
434 NAPI_CALL(env, napi_get_array_length(env, args[0], &length));
435
436 for (i = 0; i < length; i++) {
437 napi_value e;
438 NAPI_CALL(env, napi_get_element(env, args[0], i, &e));
439 NAPI_CALL(env, napi_set_element(env, ret, i, e));
440 }
441 return ret;
442 }
443
getArrayWithLength(napi_env env,napi_callback_info info)444 static napi_value getArrayWithLength(napi_env env, napi_callback_info info)
445 {
446 size_t argc = 1;
447 napi_value args[1];
448 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
449
450 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
451
452 napi_valuetype valuetype0;
453 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
454
455 NAPI_ASSERT(env, valuetype0 == napi_object,
456 "Wrong type of arguments. Expects an integer the first argument.");
457
458 uint32_t array_length = 0;
459 NAPI_CALL(env, napi_get_array_length(env, args[0], &array_length));
460 NAPI_ASSERT(env, array_length == 2, "array_length expect equal to 2");
461
462 napi_value ret;
463 NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret));
464 for (uint32_t i = 0; i < array_length * 2; i++) {
465 napi_value e;
466 NAPI_CALL(env, napi_create_uint32(env, i, &e));
467 NAPI_CALL(env, napi_set_element(env, ret, i, e));
468 }
469
470 return ret;
471 }
472
createExternal(napi_env env,napi_callback_info info)473 static napi_value createExternal(napi_env env, napi_callback_info info)
474 {
475 const char testStr[] = "test";
476 napi_value external = nullptr;
477 napi_create_external(
478 env, (void*)testStr,
479 [](napi_env env, void* data, void* hint) {},
480 (void*)testStr, &external);
481 void* tempExternal = nullptr;
482 NAPI_CALL(env, napi_get_value_external(env, external, &tempExternal));
483 NAPI_ASSERT(env, tempExternal != nullptr, "tempExternal expect not equal to nullptr");
484 NAPI_ASSERT(env, tempExternal == testStr, "tempExternal expect equal to testStr");
485
486 napi_value _value;
487 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
488
489 return _value;
490 }
491
createExternalArraybuffer(napi_env env,napi_callback_info info)492 static napi_value createExternalArraybuffer(napi_env env, napi_callback_info info)
493 {
494 int* testInt = (int*)malloc(sizeof(int));
495 *testInt = TAG_NUMBER;
496 napi_value external = nullptr;
497 size_t arrayBufferSize = 1024;
498
499 napi_create_external_arraybuffer(
500 env, (void*)testInt, arrayBufferSize,
501 [](napi_env env, void* data, void* hint) {
502 int* temp = static_cast<int*>(data);
503 free(temp);
504 temp = nullptr;
505 },
506 (void*)testInt, &external);
507
508 return external;
509 }
510
createObject(napi_env env,napi_callback_info info)511 static napi_value createObject(napi_env env, napi_callback_info info)
512 {
513 napi_value result = nullptr;
514 NAPI_CALL(env, napi_create_object(env, &result));
515 NAPI_ASSERT(env, result != nullptr, "napi_create_object");
516 return result;
517 }
518
createSymbol(napi_env env,napi_callback_info info)519 static napi_value createSymbol(napi_env env, napi_callback_info info)
520 {
521 size_t argc = 1;
522 napi_value args[1];
523 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
524
525 napi_value description = nullptr;
526 if (argc >= 1) {
527 napi_valuetype valuetype;
528 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
529
530 NAPI_ASSERT(env, valuetype == napi_string,
531 "Wrong type of arguments. Expects a string.");
532
533 description = args[0];
534 }
535
536 napi_value symbol;
537 NAPI_CALL(env, napi_create_symbol(env, description, &symbol));
538
539 napi_valuetype valuetypeSymbol;
540 NAPI_CALL(env, napi_typeof(env, symbol, &valuetypeSymbol));
541
542 NAPI_ASSERT(env, valuetypeSymbol == napi_symbol,
543 "Wrong type of arguments. Expects a string.");
544 napi_value _value;
545 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
546
547 return _value;
548 }
549
createTypeArray(napi_env env,napi_callback_info info)550 static napi_value createTypeArray(napi_env env, napi_callback_info info)
551 {
552 napi_value arrayBuffer = nullptr;
553 void* arrayBufferPtr = nullptr;
554 size_t arrayBufferSize = 16;
555 size_t typedArrayLength = 4;
556 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
557
558 void* tmpArrayBufferPtr = nullptr;
559 size_t arrayBufferLength = 0;
560 napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
561
562 NAPI_ASSERT(env, arrayBufferPtr == tmpArrayBufferPtr, "napi_get_arraybuffer_info success");
563 NAPI_ASSERT(env, arrayBufferSize == arrayBufferLength, "napi_create_arraybuffer success");
564
565 napi_value _value;
566 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &_value);
567
568 return _value;
569 }
570
createDataView(napi_env env,napi_callback_info info)571 static napi_value createDataView(napi_env env, napi_callback_info info)
572 {
573 napi_value arrayBuffer = nullptr;
574 void* arrayBufferPtr = nullptr;
575 size_t arrayBufferSize = 16;
576 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
577 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "napi_create_arraybuffer success");
578 bool isArrayBuffer = false;
579 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
580 NAPI_ASSERT(env, isArrayBuffer, " napi_is_arraybuffer success");
581
582 napi_value result = nullptr;
583 NAPI_CALL(env, napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result));
584
585 bool isDataView = false;
586 napi_is_dataview(env, result, &isDataView);
587 NAPI_ASSERT(env, isDataView, " napi_is_dataview success");
588
589 return result;
590 }
591
createAndGetInt32(napi_env env,napi_callback_info info)592 static napi_value createAndGetInt32(napi_env env, napi_callback_info info)
593 {
594 size_t argc = 1;
595 napi_value args[1];
596 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
597
598 int32_t value;
599 NAPI_CALL(env, napi_get_value_int32(env, args[0], &value));
600
601 napi_value output;
602 NAPI_CALL(env, napi_create_int32(env, value, &output));
603
604 return output;
605 }
606
createAndGetUInt32(napi_env env,napi_callback_info info)607 static napi_value createAndGetUInt32(napi_env env, napi_callback_info info)
608 {
609 size_t argc = 1;
610 napi_value args[1];
611 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
612
613 uint32_t value;
614 NAPI_CALL(env, napi_get_value_uint32(env, args[0], &value));
615
616 napi_value output;
617 NAPI_CALL(env, napi_create_uint32(env, value, &output));
618
619 return output;
620 }
621
createAndGetInt64(napi_env env,napi_callback_info info)622 static napi_value createAndGetInt64(napi_env env, napi_callback_info info)
623 {
624 size_t argc = 1;
625 napi_value args[1];
626 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
627
628 int64_t value;
629 NAPI_CALL(env, napi_get_value_int64(env, args[0], &value));
630
631 napi_value output;
632 NAPI_CALL(env, napi_create_int64(env, (double)value, &output));
633
634 return output;
635 }
636
createDouble(napi_env env,napi_callback_info info)637 static napi_value createDouble(napi_env env, napi_callback_info info)
638 {
639 size_t argc = 1;
640 napi_value args[1];
641 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
642
643 double value;
644 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
645
646 napi_value output;
647 NAPI_CALL(env, napi_create_double(env, value, &output));
648
649 return output;
650 }
651
createAndGetStringLatin1(napi_env env,napi_callback_info info)652 static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info)
653 {
654 size_t argc = 1;
655 napi_value args[1];
656 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
657
658 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
659
660 napi_valuetype valuetype;
661 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
662
663 NAPI_ASSERT(env, valuetype == napi_string,
664 "Wrong type of argment. Expects a string.");
665
666 char buffer[128];
667 size_t bufferSize = 128;
668 size_t copied = 0;
669
670 NAPI_CALL(env,
671 napi_get_value_string_latin1(env, args[0], buffer, bufferSize, &copied));
672 NAPI_ASSERT(env, copied == 3, "napi_get_value_string_latin1 fail");
673
674 napi_value output;
675 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
676
677 return output;
678 }
679
createAndGetStringUtf8(napi_env env,napi_callback_info info)680 static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
681 {
682 size_t argc = 1;
683 napi_value args[1];
684 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
685
686 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
687
688 napi_valuetype valuetype;
689 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
690
691 NAPI_ASSERT(env, valuetype == napi_string,
692 "Wrong type of argment. Expects a string.");
693
694 char buffer[128];
695 size_t bufferSize = 128;
696 size_t copied = 0;
697
698 NAPI_CALL(env,
699 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
700 NAPI_ASSERT(env, copied == 2, "napi_get_value_string_utf8 fail");
701
702 napi_value output;
703 NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
704
705 return output;
706 }
707
StringUtf8OfLengthLeZero(napi_env env,napi_callback_info info)708 static napi_value StringUtf8OfLengthLeZero(napi_env env, napi_callback_info info)
709 {
710 size_t argc = 1;
711 napi_value args[1];
712 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
713
714 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
715
716 napi_valuetype valueType;
717 NAPI_CALL(env, napi_typeof(env, args[0], &valueType));
718
719 NAPI_ASSERT(env, valueType == napi_string,
720 "Wrong type of argment. Expects a string.");
721
722 char buffer[128];
723 size_t bufferSize = 128;
724 size_t copied = 0;
725
726 NAPI_CALL(env,
727 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
728
729 napi_value output;
730 NAPI_CALL(env, napi_create_string_utf8(env, buffer, -1, &output));
731
732 return output;
733 }
734
CreateAndGetStringUtf16(napi_env env,napi_callback_info info)735 static napi_value CreateAndGetStringUtf16(napi_env env, napi_callback_info info)
736 {
737 size_t argc = 1;
738 napi_value args[1];
739 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
740
741 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments.");
742
743 napi_valuetype valuetype;
744 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
745
746 NAPI_ASSERT(env, valuetype == napi_string, "Expect a string.");
747
748 char16_t buffer[128]; // 128: char16_t type of element size
749 size_t bufferSize = 128; // 128: char16_t type of element size
750 size_t copied = 0;
751
752 NAPI_CALL(env, napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
753
754 napi_value result;
755 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &result));
756
757 return result;
758 }
759
StringUtf16OfCase(napi_env env,napi_callback_info info)760 static napi_value StringUtf16OfCase(napi_env env, napi_callback_info info)
761 {
762 size_t argc = 1;
763 napi_value args[1];
764 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
765
766 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments.");
767
768 napi_valuetype valuetype;
769 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
770
771 NAPI_ASSERT(env, valuetype == napi_string, "Expects a string.");
772
773 char16_t buffer[5]; // 5: char16_t type of element size
774 size_t bufferSize = 5; // 5: char16_t type of element size
775 size_t copied = 0;
776
777 NAPI_CALL(env,
778 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
779
780 napi_value result;
781 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &result));
782
783 return result;
784 }
785
StringUtf16OfLengthLeZero(napi_env env,napi_callback_info info)786 static napi_value StringUtf16OfLengthLeZero(napi_env env, napi_callback_info info)
787 {
788 size_t argc = 1;
789 napi_value args[1];
790 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
791
792 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
793
794 napi_valuetype valueType;
795 NAPI_CALL(env, napi_typeof(env, args[0], &valueType));
796
797 NAPI_ASSERT(env, valueType == napi_string, "Expects a string.");
798
799 char16_t buffer[128];
800 size_t bufferSize = 128;
801 size_t copied = 0;
802
803 NAPI_CALL(env,
804 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
805
806 napi_value result;
807 NAPI_CALL(env, napi_create_string_utf16(env, buffer, -1, &result));
808
809 return result;
810 }
811
StringUtf16OfLengthEqOne(napi_env env,napi_callback_info info)812 static napi_value StringUtf16OfLengthEqOne(napi_env env, napi_callback_info info)
813 {
814 size_t argc = 1;
815 napi_value args[1];
816 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
817
818 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
819
820 char16_t buffer[128];
821 size_t bufferSize = 1;
822 size_t copied = 1;
823
824 NAPI_CALL(env,
825 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
826
827 napi_value value;
828 NAPI_CALL(env, napi_create_int32(env, copied, &value));
829 return value;
830 }
831
832 static const napi_type_tag typeTags[NUMBER_FIVE] = {
833 {0xdaf987b3cc62481a, 0xb745b0497f299531},
834 {0xbb7936c374084d9b, 0xa9548d0762eeedb9},
835 {0xa5ed9ce2e4c00c38, 0xa9548d0762eeedb1},
836 {0, 0},
837 {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a},
838 };
839
TypeTaggedInstance(napi_env env,napi_callback_info info)840 static napi_value TypeTaggedInstance(napi_env env, napi_callback_info info)
841 {
842 size_t argc = 1;
843 uint32_t typeIndex = 0;
844 napi_value instance = nullptr;
845 napi_value whichType = nullptr;
846 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &whichType, nullptr, nullptr));
847 NAPI_CALL(env, napi_get_value_uint32(env, whichType, &typeIndex));
848 NAPI_ASSERT(env, typeIndex <= NUMBER_FIVE, "typeIndex out of range");
849 NAPI_CALL(env, napi_create_object(env, &instance));
850
851 NAPI_CALL(env, napi_type_tag_object(env, instance, &typeTags[typeIndex]));
852 return instance;
853 }
854
CheckTypeTag(napi_env env,napi_callback_info info)855 static napi_value CheckTypeTag(napi_env env, napi_callback_info info)
856 {
857 size_t argc = 2;
858 bool result;
859 napi_value argv[2];
860 napi_value jsResult = nullptr;
861 uint32_t typeIndex;
862
863 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
864
865 NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &typeIndex));
866
867 NAPI_ASSERT(env, typeIndex <= NUMBER_FIVE, "typeIndex out of range");
868
869 NAPI_CALL(env, napi_check_object_type_tag(env, argv[1], &typeTags[typeIndex], &result));
870 NAPI_CALL(env, napi_get_boolean(env, result, &jsResult));
871
872 return jsResult;
873 }
874
getPrototype(napi_env env,napi_callback_info info)875 static napi_value getPrototype(napi_env env, napi_callback_info info)
876 {
877 napi_value testWrapClass = nullptr;
878 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
879 napi_value thisVar = nullptr;
880 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
881 return thisVar;
882 }, nullptr, 0, nullptr, &testWrapClass);
883
884 napi_value customClassPrototype = nullptr;
885 NAPI_CALL(env, napi_get_prototype(env, testWrapClass, &customClassPrototype));
886 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
887
888 return customClassPrototype;
889 }
890
getPrototype2(napi_env env,napi_callback_info info)891 static napi_value getPrototype2(napi_env env, napi_callback_info info)
892 {
893 size_t argc = 1;
894 napi_value args[1];
895 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
896
897 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
898
899 napi_valuetype valuetype;
900 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
901
902 NAPI_ASSERT(env, valuetype == napi_function,
903 "Wrong type of argment. Expects a napi_function.");
904
905 napi_value customClassPrototype = nullptr;
906 NAPI_CALL(env, napi_get_prototype(env, args[0], &customClassPrototype));
907 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
908
909 return customClassPrototype;
910 }
911
getTypedArrayInfo(napi_env env,napi_callback_info info)912 static napi_value getTypedArrayInfo(napi_env env, napi_callback_info info)
913 {
914 napi_value arrayBuffer = nullptr;
915 void* arrayBufferPtr = nullptr;
916 size_t arrayBufferSize = 16;
917 size_t typedArrayLength = 4;
918 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
919 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getTypedArrayInfo napi_create_arraybuffer fail");
920 bool isArrayBuffer = false;
921 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
922 NAPI_ASSERT(env, isArrayBuffer, "getTypedArrayInfo napi_is_arraybuffer fail");
923 napi_value result;
924 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &result);
925
926 bool isTypedArray = false;
927 napi_is_typedarray(env, result, &isTypedArray);
928 NAPI_ASSERT(env, isTypedArray, "getTypedArrayInfo napi_is_dataview fail");
929
930 napi_typedarray_type type;
931 size_t length = 0;
932 void* data = nullptr;
933 napi_value retArrayBuffer;
934 size_t byteOffset = -1;
935 NAPI_CALL(env, napi_get_typedarray_info(env, result, &type, &length, &data, &retArrayBuffer, &byteOffset));
936 NAPI_ASSERT(env, type == napi_int32_array, "napi_get_typedarray_info success 0");
937 NAPI_ASSERT(env, length == arrayBufferSize, "napi_get_typedarray_info success 1");
938 NAPI_ASSERT(env, data == arrayBufferPtr, "napi_get_dataview_info success 2");
939
940 bool retIsArrayBuffer = false;
941 NAPI_CALL(env, napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer));
942 void* tmpArrayBufferPtr = nullptr;
943 size_t arrayBufferLength = 0;
944 NAPI_CALL(env, napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength));
945
946 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 3");
947
948 napi_value _value;
949 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
950 return _value;
951 }
952
getDataViewInfo(napi_env env,napi_callback_info info)953 static napi_value getDataViewInfo(napi_env env, napi_callback_info info)
954 {
955 napi_value arrayBuffer = nullptr;
956 void* arrayBufferPtr = nullptr;
957 size_t arrayBufferSize = 1024;
958 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
959 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getDataViewInfo napi_create_arraybuffer fail");
960 bool isArrayBuffer = false;
961 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
962 NAPI_ASSERT(env, isArrayBuffer, "getDataViewInfo napi_is_arraybuffer fail");
963 napi_value result = nullptr;
964 napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result);
965
966 bool isDataView = false;
967 napi_is_dataview(env, result, &isDataView);
968 NAPI_ASSERT(env, isDataView, "getDataViewInfo napi_is_dataview fail");
969
970 napi_value retArrayBuffer = nullptr;
971 void* data = nullptr;
972 size_t byteLength = 0;
973 size_t byteOffset = -1;
974 napi_get_dataview_info(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
975
976 bool retIsArrayBuffer = false;
977 napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer);
978 void* tmpArrayBufferPtr = nullptr;
979 size_t arrayBufferLength = 0;
980 napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
981
982 NAPI_ASSERT(env, arrayBufferLength == arrayBufferSize, "napi_get_dataview_info success 0");
983 NAPI_ASSERT(env, arrayBufferPtr == data, "napi_get_dataview_info success 1");
984 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 2");
985
986 napi_value _value;
987 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
988 return _value;
989 }
990
getValueBool(napi_env env,napi_callback_info info)991 static napi_value getValueBool(napi_env env, napi_callback_info info)
992 {
993 size_t argc = 1;
994 napi_value args[1];
995 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
996
997 bool value;
998 NAPI_CALL(env, napi_get_value_bool(env, args[0], &value));
999
1000 napi_value output;
1001 NAPI_CALL(env, napi_get_boolean(env, value, &output));
1002
1003 return output;
1004 }
1005
getValueDouble(napi_env env,napi_callback_info info)1006 static napi_value getValueDouble(napi_env env, napi_callback_info info)
1007 {
1008 size_t argc = 1;
1009 napi_value args[1];
1010 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1011
1012 double value;
1013 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
1014
1015 napi_value output;
1016 NAPI_CALL(env, napi_create_double(env, value, &output));
1017
1018 return output;
1019 }
1020
getValueExternal(napi_env env,napi_callback_info info)1021 static napi_value getValueExternal(napi_env env, napi_callback_info info)
1022 {
1023 const char testStr[] = "test";
1024 napi_value external = nullptr;
1025 napi_create_external(
1026 env, (void*)testStr,
1027 [](napi_env env, void* data, void* hint) {},
1028 (void*)testStr, &external);
1029 void* tempExternal = nullptr;
1030 napi_get_value_external(env, external, &tempExternal);
1031
1032 NAPI_ASSERT(env, tempExternal == testStr, "napi_get_value_external true");
1033
1034 napi_value _value;
1035 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1036
1037 return _value;
1038 }
1039
getNull(napi_env env,napi_callback_info info)1040 static napi_value getNull(napi_env env, napi_callback_info info)
1041 {
1042 napi_value result = nullptr;
1043 NAPI_CALL(env, napi_get_null(env, &result));
1044 NAPI_ASSERT(env, result != nullptr, "napi_get_null success");
1045 napi_valuetype type;
1046 NAPI_CALL(env, napi_typeof(env, result, &type));
1047 NAPI_ASSERT(env, type == napi_null, "napi_get_null fail");
1048
1049 napi_value _value;
1050 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1051
1052 return _value;
1053 }
1054
getUndefined(napi_env env,napi_callback_info info)1055 static napi_value getUndefined(napi_env env, napi_callback_info info)
1056 {
1057 napi_value result = nullptr;
1058 NAPI_CALL(env, napi_get_undefined(env, &result));
1059 NAPI_ASSERT(env, result != nullptr, "napi_get_undefined success");
1060 napi_valuetype type;
1061 NAPI_CALL(env, napi_typeof(env, result, &type));
1062 NAPI_ASSERT(env, type == napi_undefined, "napi_get_undefined fail");
1063
1064 napi_value _value;
1065 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1066
1067 return _value;
1068 }
1069
coerceToBool(napi_env env,napi_callback_info info)1070 static napi_value coerceToBool(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, nullptr, nullptr));
1075
1076 napi_value output;
1077 NAPI_CALL(env, napi_coerce_to_bool(env, args[0], &output));
1078
1079 return output;
1080 }
1081
coerceToNumber(napi_env env,napi_callback_info info)1082 static napi_value coerceToNumber(napi_env env, napi_callback_info info)
1083 {
1084 size_t argc = 1;
1085 napi_value args[1];
1086 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1087
1088 napi_value output;
1089 NAPI_CALL(env, napi_coerce_to_number(env, args[0], &output));
1090
1091 return output;
1092 }
1093
coerceToObject(napi_env env,napi_callback_info info)1094 static napi_value coerceToObject(napi_env env, napi_callback_info info)
1095 {
1096 size_t argc = 1;
1097 napi_value args[1];
1098 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1099
1100 napi_value output;
1101 NAPI_CALL(env, napi_coerce_to_object(env, args[0], &output));
1102
1103 return output;
1104 }
1105
coerceToString(napi_env env,napi_callback_info info)1106 static napi_value coerceToString(napi_env env, napi_callback_info info)
1107 {
1108 size_t argc = 1;
1109 napi_value args[1];
1110 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1111
1112 napi_value output;
1113 NAPI_CALL(env, napi_coerce_to_string(env, args[0], &output));
1114
1115 return output;
1116 }
1117
instanceOf(napi_env env,napi_callback_info info)1118 static napi_value instanceOf(napi_env env, napi_callback_info info)
1119 {
1120 napi_value customClass = nullptr;
1121
1122 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH,
1123 [](napi_env env, napi_callback_info info) -> napi_value {
1124 napi_value thisVar = nullptr;
1125 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1126 return thisVar;
1127 }, nullptr, 0, nullptr, &customClass);
1128
1129 napi_value customClassPrototype = nullptr;
1130 napi_get_prototype(env, customClass, &customClassPrototype);
1131
1132 napi_value customInstance = nullptr;
1133 NAPI_CALL(env, napi_new_instance(env, customClass, 0, nullptr, &customInstance));
1134
1135 bool isInstanceOf = false;
1136 NAPI_CALL(env, napi_instanceof(env, customInstance, customClass, &isInstanceOf));
1137
1138 NAPI_ASSERT(env, isInstanceOf, "isInstanceOf success");
1139
1140 napi_value result;
1141 NAPI_CALL(env, napi_get_boolean(env, isInstanceOf, &result));
1142
1143 return result;
1144 }
1145
isArray(napi_env env,napi_callback_info info)1146 static napi_value isArray(napi_env env, napi_callback_info info)
1147 {
1148 napi_value array = nullptr;
1149 napi_create_array(env, &array);
1150 NAPI_ASSERT(env, array != nullptr, "napi_get_undefined success");
1151 bool isArray = false;
1152 napi_is_array(env, array, &isArray);
1153 NAPI_ASSERT(env, isArray, "napi_is_arrayd success");
1154
1155 napi_value _value;
1156 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1157 return _value;
1158 }
1159
isDate(napi_env env,napi_callback_info info)1160 static napi_value isDate(napi_env env, napi_callback_info info)
1161 {
1162 napi_value date, result;
1163 size_t argc = 1;
1164 bool is_date = false;
1165
1166 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &date, nullptr, nullptr));
1167 NAPI_CALL(env, napi_is_date(env, date, &is_date));
1168 NAPI_CALL(env, napi_get_boolean(env, is_date, &result));
1169
1170 return result;
1171 }
1172
strictEquals(napi_env env,napi_callback_info info)1173 static napi_value strictEquals(napi_env env, napi_callback_info info)
1174 {
1175 const char* testStringStr = "test";
1176 napi_value testString = nullptr;
1177 napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
1178 bool isStrictEquals = false;
1179 napi_strict_equals(env, testString, testString, &isStrictEquals);
1180 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 0");
1181
1182 napi_value testObject = nullptr;
1183 napi_create_object(env, &testObject);
1184 isStrictEquals = false;
1185 napi_strict_equals(env, testObject, testObject, &isStrictEquals);
1186 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 1");
1187
1188 napi_value napi_number1 = nullptr;
1189 napi_value napi_number2 = nullptr;
1190 napi_create_double(env, 10.1, &napi_number1);
1191 napi_create_int32(env, 10, &napi_number2);
1192 isStrictEquals = true;
1193 napi_strict_equals(env, napi_number1, napi_number2, &isStrictEquals);
1194 NAPI_ASSERT(env, !isStrictEquals, "napi_strict_equals success 2");
1195
1196 napi_value _value;
1197 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1198 return _value;
1199 }
1200
getPropertyNames(napi_env env,napi_callback_info info)1201 static napi_value getPropertyNames(napi_env env, napi_callback_info info)
1202 {
1203 napi_value result = nullptr;
1204 NAPI_CALL(env, napi_create_object(env, &result));
1205
1206 NAPI_ASSERT(env, result != nullptr, "napi_create_object success");
1207
1208 const char testStr[] = "1234567";
1209 napi_value strAttribute = nullptr;
1210
1211 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1212 NAPI_ASSERT(env, strAttribute != nullptr, "napi_create_string_utf8 success");
1213
1214 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1215 bool hasNamedProperty = false;
1216 NAPI_CALL(env, napi_has_named_property(env, result, "strAttribute", &hasNamedProperty));
1217 NAPI_ASSERT(env, hasNamedProperty, "napi_has_named_property fail");
1218
1219 napi_value retStrAttribute = nullptr;
1220 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1221 NAPI_ASSERT(env, retStrAttribute != nullptr, "napi_get_named_property success");
1222 napi_valuetype type;
1223 NAPI_CALL(env, napi_typeof(env, retStrAttribute, &type));
1224 NAPI_ASSERT(env, type == napi_string, "napi_get_named_property fail");
1225 napi_value res;
1226 napi_coerce_to_number(env, retStrAttribute, &res);
1227 int32_t num = 0;
1228 napi_get_value_int32(env, res, &num);
1229 NAPI_ASSERT(env, num == 1234567, "getPropertyNames fail");
1230
1231 napi_value _value;
1232 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1233 return _value;
1234 }
1235
setProperty(napi_env env,napi_callback_info info)1236 static napi_value setProperty(napi_env env,
1237 napi_callback_info info)
1238 {
1239 napi_status status;
1240 napi_value object, key, value;
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, &value));
1247
1248 status = napi_set_property(nullptr, object, key, value);
1249
1250 add_returned_status(env,
1251 "envIsNull",
1252 object,
1253 "Invalid argument",
1254 napi_invalid_arg,
1255 status);
1256
1257 napi_set_property(env, nullptr, key, value);
1258
1259 add_last_status(env, "objectIsNull", object);
1260
1261 napi_set_property(env, object, nullptr, value);
1262
1263 add_last_status(env, "keyIsNull", object);
1264
1265 napi_set_property(env, object, key, nullptr);
1266
1267 add_last_status(env, "valueIsNull", object);
1268
1269 return object;
1270 }
1271
getProperty(napi_env env,napi_callback_info info)1272 static napi_value getProperty(napi_env env,
1273 napi_callback_info info)
1274 {
1275 napi_status status;
1276 napi_value object, key, result;
1277
1278 NAPI_CALL(env, napi_create_object(env, &object));
1279
1280 NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
1281
1282 NAPI_CALL(env, napi_create_object(env, &result));
1283
1284 status = napi_get_property(nullptr, object, key, &result);
1285
1286 add_returned_status(env,
1287 "envIsNull",
1288 object,
1289 "Invalid argument",
1290 napi_invalid_arg,
1291 status);
1292
1293 napi_get_property(env, nullptr, key, &result);
1294
1295 add_last_status(env, "objectIsNull", object);
1296
1297 napi_get_property(env, object, nullptr, &result);
1298
1299 add_last_status(env, "keyIsNull", object);
1300
1301 napi_get_property(env, object, key, nullptr);
1302
1303 add_last_status(env, "resultIsNull", object);
1304
1305 return object;
1306 }
1307
hasProperty(napi_env env,napi_callback_info info)1308 static napi_value hasProperty(napi_env env, napi_callback_info info)
1309 {
1310 napi_value result = nullptr;
1311 NAPI_CALL(env, napi_create_object(env, &result));
1312
1313 const char testStr[] = "1234567";
1314 napi_value strAttribute = nullptr;
1315 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1316 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1317
1318 napi_value retStrAttribute = nullptr;
1319 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1320
1321 int32_t testNumber = 12345;
1322 napi_value numberAttribute = nullptr;
1323 NAPI_CALL(env, napi_create_int32(env, testNumber, &numberAttribute));
1324 NAPI_CALL(env, napi_set_named_property(env, result, "numberAttribute", numberAttribute));
1325
1326 napi_value propNames = nullptr;
1327 NAPI_CALL(env, napi_get_property_names(env, result, &propNames));
1328 NAPI_ASSERT(env, propNames != nullptr, "napi_get_property_names success");
1329
1330 bool isArray = false;
1331 NAPI_CALL(env, napi_is_array(env, propNames, &isArray));
1332 NAPI_ASSERT(env, isArray, "napi_is_array success");
1333
1334 uint32_t arrayLength = 0;
1335 NAPI_CALL(env, napi_get_array_length(env, propNames, &arrayLength));
1336
1337 for (uint32_t i = 0; i < arrayLength; i++) {
1338 bool hasElement = false;
1339 NAPI_CALL(env, napi_has_element(env, propNames, i, &hasElement));
1340 NAPI_ASSERT(env, hasElement, "napi_has_element success");
1341
1342 napi_value propName = nullptr;
1343 NAPI_CALL(env, napi_get_element(env, propNames, i, &propName));
1344 NAPI_ASSERT(env, propName != nullptr, "napi_get_element success");
1345
1346 bool hasProp = false;
1347 napi_has_property(env, result, propName, &hasProp);
1348 NAPI_ASSERT(env, hasProp, "napi_get_element success");
1349
1350 napi_value propValue = nullptr;
1351 napi_get_property(env, result, propName, &propValue);
1352 NAPI_ASSERT(env, propValue != nullptr, "napi_get_property success");
1353 }
1354
1355 bool deletion = false;
1356 NAPI_CALL(env, napi_delete_element(env, propNames, 1, &deletion));
1357 NAPI_ASSERT(env, deletion, "napi_delete_element fail");
1358 bool hasElement = true;
1359 NAPI_CALL(env, napi_has_element(env, propNames, 1, &hasElement));
1360 NAPI_ASSERT(env, !hasElement, "napi_has_element fail");
1361
1362 napi_value _value;
1363 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1364 return _value;
1365 }
1366
setAndDeleteProperty(napi_env env,napi_callback_info info)1367 static napi_value setAndDeleteProperty(napi_env env, napi_callback_info info)
1368 {
1369 size_t argc = 2;
1370 napi_value args[2];
1371
1372 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1373 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1374
1375 napi_valuetype valuetype0;
1376 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1377 NAPI_ASSERT(env, valuetype0 == napi_object,
1378 "Wrong type of arguments. Expects an object as first argument.");
1379
1380 napi_valuetype valuetype1;
1381 NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
1382 NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
1383 "Wrong type of arguments. Expects a string or symbol as second.");
1384
1385 const char testStr[] = "cKey";
1386 napi_value cKey;
1387 napi_value cValue;
1388 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &cKey));
1389 NAPI_CALL(env, napi_create_int32(env, 3, &cValue));
1390 NAPI_CALL(env, napi_set_property(env, args[0], cKey, cValue));
1391
1392 bool hasProp = false;
1393 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1394 NAPI_ASSERT(env, hasProp, "setAndDeleteProperty napi_has_property fail 1");
1395
1396 bool result;
1397 napi_value ret;
1398 NAPI_CALL(env, napi_delete_property(env, args[0], cKey, &result));
1399 NAPI_CALL(env, napi_get_boolean(env, result, &ret));
1400 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1401 NAPI_ASSERT(env, !hasProp, "setAndDeleteProperty napi_has_property fail 2");
1402
1403 napi_value _value;
1404 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1405 return _value;
1406 }
1407
hasOwnProperty(napi_env env,napi_callback_info info)1408 static napi_value hasOwnProperty(napi_env env, napi_callback_info info)
1409 {
1410 size_t argc = 2;
1411 napi_value args[2];
1412 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1413
1414 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1415
1416 napi_valuetype valuetype0;
1417 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1418
1419 NAPI_ASSERT(env, valuetype0 == napi_object,
1420 "Wrong type of arguments. Expects an object as first argument.");
1421
1422 bool has_property;
1423 NAPI_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property));
1424
1425 napi_value ret;
1426 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1427
1428 return ret;
1429 }
1430
setNamedProperty(napi_env env,napi_callback_info info)1431 static napi_value setNamedProperty(napi_env env, napi_callback_info info)
1432 {
1433 size_t argc = 3;
1434 napi_value args[3];
1435 char key[256] = "";
1436 size_t key_length;
1437 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1438
1439 NAPI_ASSERT(env, argc >= 3, "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_CALL(env,
1454 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1455 key[255] = 0;
1456 NAPI_ASSERT(env, key_length <= 255,
1457 "Cannot accommodate keys longer than 255 bytes");
1458
1459 NAPI_CALL(env, napi_set_named_property(env, args[0], key, args[2]));
1460
1461 napi_value value_true;
1462 NAPI_CALL(env, napi_get_boolean(env, true, &value_true));
1463
1464 return value_true;
1465 }
1466
getNamedProperty(napi_env env,napi_callback_info info)1467 static napi_value getNamedProperty(napi_env env, napi_callback_info info)
1468 {
1469 size_t argc = 2;
1470 napi_value args[2];
1471 char key[256] = "";
1472 size_t key_length;
1473 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1474
1475 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1476
1477 napi_valuetype value_type0;
1478 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1479
1480 NAPI_ASSERT(env, value_type0 == napi_object,
1481 "Wrong type of arguments. Expects an object as first argument.");
1482
1483 napi_valuetype value_type1;
1484 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1485
1486 NAPI_ASSERT(env, value_type1 == napi_string,
1487 "Wrong type of arguments. Expects a string as second.");
1488
1489 napi_value object = args[0];
1490 NAPI_CALL(env,
1491 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1492 key[255] = 0;
1493 NAPI_ASSERT(env, key_length <= 255,
1494 "Cannot accommodate keys longer than 255 bytes");
1495 napi_value output;
1496 NAPI_CALL(env, napi_get_named_property(env, object, key, &output));
1497
1498 return output;
1499 }
1500
hasNamedProperty(napi_env env,napi_callback_info info)1501 static napi_value hasNamedProperty(napi_env env, napi_callback_info info)
1502 {
1503 size_t argc = 2;
1504 napi_value args[2];
1505 char key[256] = "";
1506 size_t key_length;
1507 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1508
1509 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1510
1511 napi_valuetype value_type0;
1512 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1513
1514 NAPI_ASSERT(env, value_type0 == napi_object,
1515 "Wrong type of arguments. Expects an object as first argument.");
1516
1517 napi_valuetype value_type1;
1518 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1519
1520 NAPI_ASSERT(env, value_type1 == napi_string || value_type1 == napi_symbol,
1521 "Wrong type of arguments. Expects a string as second.");
1522
1523 NAPI_CALL(env,
1524 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1525 key[255] = 0;
1526 NAPI_ASSERT(env, key_length <= 255,
1527 "Cannot accommodate keys longer than 255 bytes");
1528
1529 bool has_property;
1530 NAPI_CALL(env, napi_has_named_property(env, args[0], key, &has_property));
1531
1532 napi_value ret;
1533 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1534
1535 return ret;
1536 }
1537
setElement(napi_env env,napi_callback_info info)1538 static napi_value setElement(napi_env env, napi_callback_info info)
1539 {
1540 napi_value return_value, object;
1541
1542 NAPI_CALL(env, napi_create_object(env, &return_value));
1543 NAPI_CALL(env, napi_create_object(env, &object));
1544
1545 add_returned_status(env,
1546 "envIsNull",
1547 return_value,
1548 "Invalid argument",
1549 napi_invalid_arg,
1550 napi_set_element(nullptr, object, 0, object));
1551
1552 napi_set_element(env, nullptr, 0, object);
1553 add_last_status(env, "objectIsNull", return_value);
1554
1555
1556 napi_set_property(env, object, 0, nullptr);
1557 add_last_status(env, "valueIsNull", return_value);
1558
1559 return return_value;
1560 }
1561
getElement(napi_env env,napi_callback_info info)1562 static napi_value getElement(napi_env env, napi_callback_info info)
1563 {
1564 napi_value return_value, object, prop;
1565
1566 NAPI_CALL(env, napi_create_object(env, &return_value));
1567 NAPI_CALL(env, napi_create_object(env, &object));
1568
1569 add_returned_status(env,
1570 "envIsNull",
1571 return_value,
1572 "Invalid argument",
1573 napi_invalid_arg,
1574 napi_get_element(nullptr, object, 0, &prop));
1575
1576 napi_get_property(env, nullptr, 0, &prop);
1577 add_last_status(env, "objectIsNull", return_value);
1578
1579 napi_get_property(env, object, 0, nullptr);
1580 add_last_status(env, "valueIsNull", return_value);
1581
1582 return return_value;
1583 }
1584
TestBoolValuedElementApi(napi_env env,napi_status (* api)(napi_env,napi_value,uint32_t,bool *))1585 static napi_value TestBoolValuedElementApi(napi_env env,
1586 napi_status (* api)(napi_env, napi_value, uint32_t, bool*))
1587 {
1588 napi_value return_value, object;
1589 bool result;
1590
1591 NAPI_CALL(env, napi_create_object(env, &return_value));
1592 NAPI_CALL(env, napi_create_object(env, &object));
1593
1594 add_returned_status(env,
1595 "envIsNull",
1596 return_value,
1597 "Invalid argument",
1598 napi_invalid_arg,
1599 api(nullptr, object, 0, &result));
1600
1601 api(env, nullptr, 0, &result);
1602 add_last_status(env, "objectIsNull", return_value);
1603
1604 api(env, object, 0, nullptr);
1605 add_last_status(env, "valueIsNull", return_value);
1606
1607 return return_value;
1608 }
1609
hasElement(napi_env env,napi_callback_info info)1610 static napi_value hasElement(napi_env env, napi_callback_info info)
1611 {
1612 return TestBoolValuedElementApi(env, napi_has_element);
1613 }
1614
deleteElement(napi_env env,napi_callback_info info)1615 static napi_value deleteElement(napi_env env, napi_callback_info info)
1616 {
1617 return TestBoolValuedElementApi(env, napi_delete_element);
1618 }
1619
defineProperties(napi_env env,napi_callback_info info)1620 static napi_value defineProperties(napi_env env, napi_callback_info info)
1621 {
1622 napi_value object, return_value;
1623
1624 napi_property_descriptor desc = {"prop", NULL, defineProperties, NULL, NULL, NULL, napi_enumerable, NULL};
1625
1626 NAPI_CALL(env, napi_create_object(env, &object));
1627 NAPI_CALL(env, napi_create_object(env, &return_value));
1628
1629 add_returned_status(env,
1630 "envIsNull",
1631 return_value,
1632 "Invalid argument",
1633 napi_invalid_arg,
1634 napi_define_properties(nullptr, object, 1, &desc));
1635
1636 napi_define_properties(env, nullptr, 1, &desc);
1637 add_last_status(env, "objectIsNull", return_value);
1638
1639 napi_define_properties(env, object, 1, nullptr);
1640 add_last_status(env, "descriptorListIsNull", return_value);
1641
1642 desc.utf8name = nullptr;
1643 napi_define_properties(env, object, 1, nullptr);
1644 add_last_status(env, "utf8nameIsNull", return_value);
1645 desc.utf8name = "prop";
1646
1647 desc.method = nullptr;
1648 napi_define_properties(env, object, 1, nullptr);
1649 add_last_status(env, "methodIsNull", return_value);
1650 desc.method = defineProperties;
1651
1652 return return_value;
1653 }
1654
MyConstructor(napi_env env,napi_callback_info info)1655 static napi_value MyConstructor(napi_env env, napi_callback_info info)
1656 {
1657 napi_value thisVar = nullptr;
1658 size_t argc = 0;
1659 napi_value constructor = nullptr;
1660 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1661 napi_get_new_target(env, info, &constructor);
1662 if (constructor == nullptr) {
1663 napi_throw_error(env, nullptr, "is not new instance");
1664 }
1665 return thisVar;
1666 }
1667
NewTargetTest(napi_env env,napi_callback_info info)1668 static napi_value NewTargetTest(napi_env env, napi_callback_info info)
1669 {
1670 bool isConstructor = true;
1671 napi_value constructor = nullptr;
1672 napi_get_new_target(env, info, &constructor);
1673 if (constructor == nullptr) {
1674 napi_throw_error(env, nullptr, "is not new instance");
1675 isConstructor = false;
1676 }
1677 napi_value value;
1678 NAPI_CALL(env, napi_get_boolean(env, isConstructor, &value));
1679
1680 return value;
1681 }
1682
wrap(napi_env env,napi_callback_info info)1683 static napi_value wrap(napi_env env, napi_callback_info info)
1684 {
1685 napi_value testClass = nullptr;
1686 napi_define_class(
1687 env, "TestClass", NAPI_AUTO_LENGTH,
1688 [](napi_env env, napi_callback_info info) -> napi_value {
1689 napi_value thisVar = nullptr;
1690 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1691
1692 return thisVar;
1693 },
1694 nullptr, 0, nullptr, &testClass);
1695
1696 napi_value instanceValue = nullptr;
1697 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1698
1699 const char* testStr = "test";
1700 napi_wrap(
1701 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1702
1703 napi_value _value;
1704 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1705 return _value;
1706 }
1707
unwrap(napi_env env,napi_callback_info info)1708 static napi_value unwrap(napi_env env, napi_callback_info info)
1709 {
1710 napi_value testClass = nullptr;
1711 napi_define_class(
1712 env, "TestClass", NAPI_AUTO_LENGTH,
1713 [](napi_env env, napi_callback_info info) -> napi_value {
1714 napi_value thisVar = nullptr;
1715 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1716
1717 return thisVar;
1718 },
1719 nullptr, 0, nullptr, &testClass);
1720
1721 napi_value instanceValue = nullptr;
1722 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1723
1724 const char* testStr = "test";
1725 napi_wrap(
1726 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1727
1728 const char* tmpTestStr = nullptr;
1729 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1730 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1731
1732 napi_value _value;
1733 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1734 return _value;
1735 }
1736
removeWrap(napi_env env,napi_callback_info info)1737 static napi_value removeWrap(napi_env env, napi_callback_info info)
1738 {
1739 napi_value testClass = nullptr;
1740 napi_define_class(
1741 env, "TestClass", NAPI_AUTO_LENGTH,
1742 [](napi_env env, napi_callback_info info) -> napi_value {
1743 napi_value thisVar = nullptr;
1744 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1745
1746 return thisVar;
1747 },
1748 nullptr, 0, nullptr, &testClass);
1749
1750 napi_value instanceValue = nullptr;
1751 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1752
1753 const char* testStr = "test";
1754 napi_wrap(
1755 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1756
1757 const char* tmpTestStr = nullptr;
1758 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1759 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1760
1761 const char* tmpTestStr1 = nullptr;
1762 napi_remove_wrap(env, instanceValue, (void**)&tmpTestStr1);
1763 NAPI_ASSERT(env, tmpTestStr1 == testStr, "napi_remove_wrap fail 1");
1764
1765 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr1));
1766 NAPI_ASSERT(env, tmpTestStr1 == nullptr, "napi_remove_wrap fail");
1767
1768 napi_value _value;
1769 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1770 return _value;
1771 }
1772
getVersion(napi_env env,napi_callback_info info)1773 static napi_value getVersion(napi_env env, napi_callback_info info)
1774 {
1775 uint32_t version;
1776 napi_value result;
1777 NAPI_CALL(env, napi_get_version(env, &version));
1778 NAPI_CALL(env, napi_create_uint32(env, version, &result));
1779 return result;
1780 }
1781
createPromise(napi_env env,napi_callback_info info)1782 static napi_value createPromise(napi_env env, napi_callback_info info)
1783 {
1784 napi_deferred deferred = nullptr;
1785 napi_value promise = nullptr;
1786 napi_create_promise(env, &deferred, &promise);
1787 NAPI_ASSERT(env, deferred != nullptr, "create promise success");
1788 NAPI_ASSERT(env, promise != nullptr, "create promise success");
1789
1790 napi_value _value;
1791 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1792 return _value;
1793 }
1794
resolveAndRejectDeferred(napi_env env,napi_callback_info info)1795 static napi_value resolveAndRejectDeferred(napi_env env, napi_callback_info info)
1796 {
1797 napi_deferred deferred = nullptr;
1798 napi_value promise = nullptr;
1799 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1800
1801 bool isPromise = false;
1802 napi_is_promise(env, promise, &isPromise);
1803
1804 napi_value undefined = nullptr;
1805 napi_get_undefined(env, &undefined);
1806 NAPI_CALL(env, napi_resolve_deferred(env, deferred, undefined));
1807
1808 napi_value _value;
1809 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1810 return _value;
1811 }
1812
isPromise(napi_env env,napi_callback_info info)1813 static napi_value isPromise(napi_env env, napi_callback_info info)
1814 {
1815 napi_deferred deferred = nullptr;
1816 napi_value promise = nullptr;
1817 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1818
1819 bool isPromise = false;
1820 NAPI_CALL(env, napi_is_promise(env, promise, &isPromise));
1821 NAPI_ASSERT(env, isPromise, "napi_is_promise success");
1822
1823 napi_value _value;
1824 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1825 return _value;
1826 }
1827
runScript(napi_env env,napi_callback_info info)1828 static napi_value runScript(napi_env env, napi_callback_info info)
1829 {
1830 napi_value script, result;
1831 size_t argc = 1;
1832
1833 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &script, nullptr, nullptr));
1834
1835 NAPI_CALL(env, napi_run_script(env, script, &result));
1836
1837 return result;
1838 }
1839
getUvEventLoop(napi_env env,napi_callback_info info)1840 static napi_value getUvEventLoop(napi_env env, napi_callback_info info)
1841 {
1842 struct uv_loop_s* loop = nullptr;
1843
1844 NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
1845 NAPI_ASSERT(env, loop != nullptr, "napi_get_uv_event_loop fail");
1846
1847 return nullptr;
1848 }
1849
TestLatin1(napi_env env,napi_callback_info info)1850 static napi_value TestLatin1(napi_env env, napi_callback_info info)
1851 {
1852 size_t argc = 1;
1853 napi_value args[1];
1854 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1855
1856 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1857
1858 napi_valuetype valuetype;
1859 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1860
1861 NAPI_ASSERT(env, valuetype == napi_string,
1862 "Wrong type of argment. Expects a string.");
1863
1864 char buffer[128];
1865 size_t bufferSize = 128;
1866 size_t copied;
1867
1868 NAPI_CALL(env,
1869 napi_get_value_string_latin1(env, args[0], buffer, bufferSize, &copied));
1870
1871 napi_value output;
1872 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
1873
1874 return output;
1875 }
1876
TestUtf8(napi_env env,napi_callback_info info)1877 static napi_value TestUtf8(napi_env env, napi_callback_info info)
1878 {
1879 size_t argc = 1;
1880 napi_value args[1];
1881 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1882
1883 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
1884
1885 napi_valuetype valuetype;
1886 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1887
1888 NAPI_ASSERT(env, valuetype == napi_string,
1889 "Wrong type of argment. Expects a string.");
1890
1891 char buffer[128];
1892 size_t bufferSize = 128;
1893 size_t copied;
1894
1895 NAPI_CALL(env,
1896 napi_get_value_string_utf8(env, args[0], buffer, bufferSize, &copied));
1897
1898 napi_value output;
1899 NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
1900
1901 return output;
1902 }
1903
TestUtf16(napi_env env,napi_callback_info info)1904 static napi_value TestUtf16(napi_env env, napi_callback_info info)
1905 {
1906 size_t argc = 1;
1907 napi_value args[1];
1908 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1909
1910 NAPI_ASSERT(env, argc == 1, "Expects one argument.");
1911
1912 napi_valuetype valuetype;
1913 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1914
1915 NAPI_ASSERT(env, valuetype == napi_string,
1916 "Wrong type of argment. Expects a string.");
1917
1918 char16_t buffer[128];
1919 size_t bufferSize = 128;
1920 size_t copied;
1921
1922 NAPI_CALL(env,
1923 napi_get_value_string_utf16(env, args[0], buffer, bufferSize, &copied));
1924
1925 napi_value output;
1926 NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
1927
1928 return output;
1929 }
1930 // test the napi function
napCreateArrayBuffer(napi_env env,napi_callback_info info)1931 static napi_value napCreateArrayBuffer(napi_env env, napi_callback_info info)
1932 {
1933 napi_value arrayBuffer = nullptr;
1934 void* arrayBufferPtr = nullptr;
1935 size_t arrayBufferSize = 1024;
1936 napi_status status = napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1937 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1938 NAPI_ASSERT(env, arrayBuffer != nullptr, "success create_arrayBuffer");
1939
1940 return arrayBuffer;
1941 }
1942
napiGetCbInfo(napi_env env,napi_callback_info info)1943 static napi_value napiGetCbInfo(napi_env env, napi_callback_info info)
1944 {
1945 size_t argc = 1;
1946 napi_value args[1];
1947 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1948 NAPI_ASSERT(env, status == napi_ok, "get_cb_info ok");
1949 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1950 double value;
1951 napi_get_value_double(env, args[0], &value);
1952
1953 napi_valuetype valuetype;
1954 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1955 NAPI_ASSERT(env, valuetype == napi_number, "Wrong type of argment. Expects a nunber.");
1956
1957 napi_value returnValue;
1958 napi_status statusDouble = napi_create_double(env, value, &returnValue);
1959 NAPI_ASSERT(env, statusDouble == napi_ok, "success to napi_create_double");
1960
1961 return returnValue;
1962 }
1963
naiGetArrayBufferInfo(napi_env env,napi_callback_info info)1964 static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info)
1965 {
1966 // the value to return
1967 napi_value arrayBuffer;
1968 napi_status status;
1969 void* yourPointer = nullptr;
1970 size_t arrayBufferSize = 1024;
1971 status = napi_create_arraybuffer(env, arrayBufferSize, &yourPointer, &arrayBuffer);
1972 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1973
1974 void* tmpArrayBufferPtr = nullptr;
1975 size_t arrayBufferLength = 0;
1976 status = napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
1977 NAPI_ASSERT(env, status == napi_ok, "success to napi_get_arraybuffer_info");
1978
1979 napi_value arrayLength;
1980 // return the length of array js type int
1981 NAPI_CALL(env, napi_create_int32(env, arrayBufferLength, &arrayLength));
1982
1983 return arrayLength;
1984 }
1985
napiDefineClass(napi_env env,napi_callback_info info)1986 static napi_value napiDefineClass(napi_env env, napi_callback_info info)
1987 {
1988 napi_value testWrapClass = nullptr;
1989 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
1990 napi_value thisVar = nullptr;
1991 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1992 return thisVar;
1993 }, nullptr, 0, nullptr, &testWrapClass);
1994
1995 napi_value instanceValue = nullptr;
1996 napi_new_instance(env, testWrapClass, 0, nullptr, &instanceValue);
1997 NAPI_ASSERT(env, instanceValue != nullptr, "success napiDefineClass");
1998 napi_value value;
1999 NAPI_CALL(env, napi_create_int32(env, 0, &value));
2000
2001 return value;
2002 }
2003
napiRunScriptPath(napi_env env,napi_callback_info info)2004 static napi_value napiRunScriptPath(napi_env env, napi_callback_info info)
2005 {
2006 napi_value value;
2007 const char* path = "pages/index.ets";
2008 napi_status status = napi_run_script_path(env, path, &value);
2009 NAPI_ASSERT(env, status == napi_ok, "napi_run_script_path ok");
2010 NAPI_ASSERT(env, value != nullptr, "napi_run_script_path success");
2011
2012 napi_value _value;
2013 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2014
2015 return _value;
2016 }
2017
napiLoadModule(napi_env env,napi_callback_info info)2018 static napi_value napiLoadModule(napi_env env, napi_callback_info info)
2019 {
2020 napi_value value;
2021 const char* path = "@ohos.hilog";
2022 napi_status status = napi_load_module(env, path, &value);
2023 NAPI_ASSERT(env, status == napi_ok, "napi_load_module ok");
2024 NAPI_ASSERT(env, value != nullptr, "napi_load_module success");
2025
2026 napi_value _value;
2027 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2028
2029 return _value;
2030 }
2031
napiGetNodeVersion(napi_env env,napi_callback_info info)2032 static napi_value napiGetNodeVersion(napi_env env, napi_callback_info info)
2033 {
2034 napi_value value;
2035 const napi_node_version* version;
2036 napi_get_node_version(env, &version);
2037 const char* release = version->release;
2038 napi_status status = napi_create_string_utf8(env, release, strlen(release), &value);
2039 NAPI_ASSERT(env, status == napi_ok, "napi_create_string_utf8 ok");
2040 napi_value _value;
2041 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2042
2043 return _value;
2044 }
2045
napiCallThreadsafeFunction(napi_env env,napi_callback_info info)2046 static napi_value napiCallThreadsafeFunction(napi_env env, napi_callback_info info)
2047 {
2048 void* data = nullptr;
2049 napi_threadsafe_function func = (napi_threadsafe_function)data;
2050 napi_threadsafe_function_call_mode blockMode = napi_tsfn_nonblocking;
2051 void* context = nullptr;
2052 napi_status status = napi_get_threadsafe_function_context(func, &context);
2053 NAPI_ASSERT(env, status != napi_ok, "napi_get_threadsafe_function_context fail");
2054 static int32_t gSendData = 0;
2055 napi_call_threadsafe_function(func, &gSendData, blockMode);
2056 status = napi_call_threadsafe_function(func, &gSendData, blockMode);
2057 NAPI_ASSERT(env, status != napi_ok, "napi_call_threadsafe_function fail");
2058 napi_release_threadsafe_function(func, napi_tsfn_release);
2059 napi_value value;
2060 NAPI_CALL(env, napi_create_int32(env, 0, &value));
2061
2062 return value;
2063 }
2064
napiCreateThreadsafeFunction(napi_env env,napi_callback_info info)2065 static napi_value napiCreateThreadsafeFunction(napi_env env, napi_callback_info info)
2066 {
2067 napi_threadsafe_function tsFunc = nullptr;
2068 napi_value resourceName = 0;
2069 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2070 int32_t callJstCbDataTestId = 101;
2071 int32_t finalCbtDataTestID = 1001;
2072 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
2073 0, 1, &callJstCbDataTestId, nullptr,
2074 &finalCbtDataTestID, nullptr, &tsFunc);
2075 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
2076
2077 napi_acquire_threadsafe_function(tsFunc);
2078 status = napi_unref_threadsafe_function(env, tsFunc);
2079 NAPI_ASSERT(env, status != napi_ok, "napi_unref_threadsafe_function failed");
2080
2081 napi_value _value;
2082 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2083
2084 return _value;
2085 }
2086
AddExecuteCB(napi_env env,void * data)2087 static void AddExecuteCB(napi_env env, void *data) {
2088 AddonData *addonData = (AddonData *)data;
2089 addonData->result = addonData->args;
2090 }
2091
AddCallbackCompleteCB(napi_env env,napi_status status,void * data)2092 static void AddCallbackCompleteCB(napi_env env, napi_status status, void *data) {
2093 AddonData *addonData = (AddonData *)data;
2094 napi_value callback = nullptr;
2095 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, addonData->callback, &callback));
2096 napi_value result = nullptr;
2097 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
2098 napi_value callbackResult = nullptr;
2099
2100 int32_t ret = 0;
2101 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, 1, &result, &callbackResult));
2102 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, callbackResult, &ret));
2103 NAPI_ASSERT_RETURN_VOID(env, ret == 2000, "AddCallbackCompleteCB failed");
2104
2105 if (addonData->callback != nullptr) {
2106 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, addonData->callback));
2107 }
2108
2109 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
2110 free(addonData);
2111 }
2112
testAsyncWork(napi_env env,napi_callback_info info)2113 static napi_value testAsyncWork(napi_env env, napi_callback_info info) {
2114 size_t argc = 2;
2115 napi_value args[2];
2116 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2117
2118 AddonData* addonData = reinterpret_cast<AddonData*>(malloc(sizeof(AddonData)));
2119 if (addonData == nullptr) {
2120 return nullptr;
2121 }
2122
2123 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
2124 NAPI_CALL(env, napi_create_reference(env, args[1], 1, &addonData->callback));
2125
2126 napi_value resourceName = nullptr;
2127 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName));
2128 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB, AddCallbackCompleteCB,
2129 (void *)addonData, &addonData->asyncWork));
2130
2131 NAPI_CALL(env, napi_queue_async_work(env, addonData->asyncWork));
2132
2133 napi_value _value = 0;
2134 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2135 return _value;
2136 }
2137
AddPromiseCompleteCB(napi_env env,napi_status status,void * data)2138 static void AddPromiseCompleteCB(napi_env env, napi_status status, void *data) {
2139 AddonData *addonData = (AddonData *)data;
2140 napi_value result = nullptr;
2141 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
2142 if (addonData->result > 0) {
2143 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, addonData->deferred, result));
2144 } else {
2145 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, addonData->deferred, result));
2146 }
2147
2148 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
2149 free(addonData);
2150 addonData = nullptr;
2151 }
2152
testPromise(napi_env env,napi_callback_info info)2153 static napi_value testPromise(napi_env env, napi_callback_info info)
2154 {
2155 size_t argc = 1;
2156 napi_value args[1];
2157 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2158
2159 napi_value promise = nullptr;
2160 napi_deferred deferred = nullptr;
2161 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
2162
2163 AddonData* addonData = reinterpret_cast<AddonData*>(malloc(sizeof(AddonData)));
2164 if (addonData == nullptr) {
2165 return nullptr;
2166 }
2167 addonData->deferred = deferred;
2168
2169 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
2170
2171 napi_value resourceName = nullptr;
2172 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncCallback", NAPI_AUTO_LENGTH, &resourceName));
2173 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB,
2174 AddPromiseCompleteCB, (void *)addonData, &addonData->asyncWork));
2175
2176 napi_queue_async_work(env, addonData->asyncWork);
2177
2178 return promise;
2179 }
2180
napiCancelAsyncWork(napi_env env,napi_callback_info info)2181 static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
2182 {
2183 napi_async_work work = nullptr;
2184 napi_value resourceName = nullptr;
2185 napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName);
2186 napi_create_async_work(env, nullptr, resourceName, [](napi_env value, void* data) {},
2187 [](napi_env env, napi_status status, void* data) {}, nullptr, &work);
2188 NAPI_CALL(env, napi_cancel_async_work(env, work));
2189 napi_delete_async_work(env, work);
2190 napi_value value;
2191 NAPI_CALL(env, napi_create_int32(env, 0, &value));
2192
2193 return value;
2194 }
2195
SayHello(napi_env env,napi_callback_info info)2196 static napi_value SayHello(napi_env env, napi_callback_info info)
2197 {
2198 printf("Hello\n");
2199 napi_value ret;
2200 NAPI_CALL(env, napi_create_int32(env, TAG_NUMBER, &ret));
2201 return ret;
2202 }
2203
napiCreateFunction(napi_env env,napi_callback_info info)2204 static napi_value napiCreateFunction(napi_env env, napi_callback_info info)
2205 {
2206 napi_value funcValue = nullptr;
2207 napi_status status = napi_create_function(env, "func", NAPI_AUTO_LENGTH, SayHello, nullptr, &funcValue);
2208 NAPI_ASSERT(env, funcValue != nullptr, "napi_create_function fail");
2209 NAPI_ASSERT(env, status == napi_ok, "napi_create_function fail");
2210 napi_value value;
2211 NAPI_CALL(env, napi_create_int32(env, 1, &value));
2212
2213 return funcValue;
2214 }
2215
NapiCreateFunctionTwo(napi_env env,napi_callback_info info)2216 static napi_value NapiCreateFunctionTwo(napi_env env, napi_callback_info info)
2217 {
2218 napi_value resultValue = nullptr;
2219 napi_status status = napi_create_function(env, nullptr, NAPI_AUTO_LENGTH, SayHello, nullptr, &resultValue);
2220 if (resultValue == nullptr) {
2221 napi_throw_error(env, nullptr, "napi_create_function fail");
2222 return nullptr;
2223 }
2224 if (status != napi_ok) {
2225 napi_throw_error(env, nullptr, "napi_create_function fail");
2226 return nullptr;
2227 }
2228 napi_value value;
2229 NAPI_CALL(env, napi_create_int32(env, 1, &value));
2230
2231 return resultValue;
2232 }
2233
napiRefthreadSafeFunction(napi_env env,napi_callback_info info)2234 static napi_value napiRefthreadSafeFunction(napi_env env, napi_callback_info info)
2235 {
2236 napi_threadsafe_function tsFunc = nullptr;
2237 napi_value resourceName = 0;
2238 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
2239 int32_t callJsCbDataTestId = 101;
2240 int32_t finalCbDataTestId = 1001;
2241 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
2242 0, 1, &callJsCbDataTestId,
2243 nullptr, &finalCbDataTestId, nullptr, &tsFunc);
2244 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
2245
2246 status = napi_ref_threadsafe_function(env, tsFunc);
2247 NAPI_ASSERT(env, status != napi_ok, "napi_ref_threadsafe_function");
2248 napi_value _value;
2249 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
2250
2251 return _value;
2252 }
2253
napiCreateDate(napi_env env,napi_callback_info info)2254 static napi_value napiCreateDate(napi_env env, napi_callback_info info)
2255 {
2256 napi_value createResult = nullptr;
2257 double time = 202110181203150;
2258 napi_status status = napi_create_date(env, time, &createResult);
2259 NAPI_ASSERT(env, status == napi_ok, "napi_create_date success");
2260 double getTime = false;
2261 napi_get_date_value(env, createResult, &getTime);
2262 bool result = false;
2263 if (time == getTime) {
2264 result = true;
2265 }
2266 napi_value value;
2267 NAPI_CALL(env, napi_create_int32(env, result, &value));
2268
2269 return value;
2270 }
2271
napiCreateBigintUint64(napi_env env,napi_callback_info info)2272 static napi_value napiCreateBigintUint64(napi_env env, napi_callback_info info)
2273 {
2274 uint64_t testValue = UINT64_MAX;
2275 napi_value result = nullptr;
2276 napi_create_bigint_uint64(env, testValue, &result);
2277
2278 uint64_t resultValue = 0;
2279 bool flag = false;
2280 napi_get_value_bigint_uint64(env, result, &resultValue, &flag);
2281 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
2282 napi_value value;
2283 NAPI_CALL(env, napi_create_int32(env, flag, &value));
2284
2285 return value;
2286 }
2287
napiCreateBigintInt64(napi_env env,napi_callback_info info)2288 static napi_value napiCreateBigintInt64(napi_env env, napi_callback_info info)
2289 {
2290 int64_t testValue = INT64_MAX;
2291 napi_value result = nullptr;
2292 napi_create_bigint_int64(env, testValue, &result);
2293 int64_t resultValue = 0;
2294 bool flag = false;
2295 napi_get_value_bigint_int64(env, result, &resultValue, &flag);
2296 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
2297 napi_value value;
2298 NAPI_CALL(env, napi_create_int32(env, flag, &value));
2299
2300 return value;
2301 }
2302
napiCreateBigintWords(napi_env env,napi_callback_info info)2303 static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info)
2304 {
2305 int signBit = 0;
2306 size_t wordCount = 4;
2307 uint64_t words[] = {0ULL, 34ULL, 56ULL, 2ULL};
2308 uint64_t wordsOut[] = {0ULL, 0ULL, 0ULL, 0ULL};
2309 napi_value result = nullptr;
2310 NAPI_CALL(env, napi_create_bigint_words(env, signBit, wordCount, words, &result));
2311 int retSignBit = -1;
2312 size_t retWordCount = 4;
2313 NAPI_CALL(env, napi_get_value_bigint_words(env, result, &retSignBit, &retWordCount, wordsOut));
2314 bool testResult = true;
2315 if (retSignBit != signBit || retWordCount != wordCount) {
2316 testResult = false;
2317 }
2318 for (size_t i = 0; i < wordCount; i++) {
2319 if (wordsOut[i] != words[i]) {
2320 testResult = false;
2321 break;
2322 }
2323 }
2324 napi_value value;
2325 NAPI_CALL(env, napi_create_int32(env, testResult, &value));
2326
2327 return value;
2328 }
2329
callFunction(napi_env env,napi_callback_info info)2330 static napi_value callFunction(napi_env env, napi_callback_info info)
2331 {
2332 size_t argc = 1;
2333 napi_value args[1];
2334 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2335
2336 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
2337
2338 napi_valuetype valuetype;
2339 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
2340
2341 NAPI_ASSERT(env, valuetype == napi_function,
2342 "Wrong type of argment. Expects a string.");
2343 napi_value ret;
2344 NAPI_CALL(env, napi_call_function(env, nullptr, args[0], 0, nullptr, &ret));
2345 return ret;
2346 }
2347
getGlobal(napi_env env,napi_callback_info info)2348 static napi_value getGlobal(napi_env env, napi_callback_info info)
2349 {
2350 napi_value result = nullptr;
2351 NAPI_CALL(env, napi_get_global(env, &result));
2352 NAPI_ASSERT(env, result != nullptr, "napi_get_global failed");
2353 return nullptr;
2354 }
2355
2356 napi_threadsafe_function tsfn;
2357 napi_ref functionRef;
CallJs(napi_env env,napi_value jsCb,void * context,void * data)2358 static void CallJs(napi_env env, napi_value jsCb, void *context, void *data) {
2359
2360 napi_value undefined;
2361 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2362 napi_value cb;
2363 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, functionRef, &cb));
2364
2365 napi_value ret;
2366 int32_t num = 0;
2367 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, cb, 0, nullptr, &ret));
2368 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, ret, &num));
2369 NAPI_ASSERT_RETURN_VOID(env, num == TAG_NUMBER, "CallJs fail");
2370 }
2371
ThreadSafeTest(napi_env env,napi_callback_info info)2372 static napi_value ThreadSafeTest(napi_env env, napi_callback_info info) {
2373 size_t argc = 1;
2374 napi_value jsCb, work_name;
2375 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &jsCb, nullptr, nullptr));
2376 napi_create_reference(env, jsCb, 1, &functionRef);
2377
2378 NAPI_CALL(env, napi_create_string_utf8(env, "work_name", NAPI_AUTO_LENGTH, &work_name));
2379
2380 napi_valuetype valueType = napi_undefined;
2381 NAPI_CALL(env, napi_typeof(env, jsCb, &valueType));
2382 NAPI_ASSERT(env, valueType == napi_function, "valueType expect equal to napi_function");
2383
2384 const char* context = "context";
2385 NAPI_CALL(env, napi_create_threadsafe_function(env, jsCb, nullptr, work_name, 0, 1, nullptr, nullptr,
2386 const_cast<void*>(reinterpret_cast<const void*>(context)), CallJs, &tsfn));
2387 void* retContext = nullptr;
2388 NAPI_CALL(env, napi_get_threadsafe_function_context(tsfn, &retContext));
2389 NAPI_ASSERT(env, retContext == context, "napi_get_threadsafe_function_context failed");
2390
2391 napi_acquire_threadsafe_function(tsfn);
2392 napi_call_threadsafe_function(tsfn, nullptr, napi_tsfn_blocking);
2393
2394 NAPI_CALL(env, napi_ref_threadsafe_function(env, tsfn));
2395 NAPI_CALL(env, napi_unref_threadsafe_function(env, tsfn));
2396 NAPI_CALL(env, napi_release_threadsafe_function(tsfn, napi_tsfn_release));
2397 napi_value _value;
2398 NAPI_CALL(env, napi_create_int32(env, 1, &_value));
2399 return _value;
2400 }
2401
NoopDeleter(napi_env env,void * data,void * finalizeHint)2402 static void NoopDeleter(napi_env env, void* data, [[maybe_unused]] void* finalizeHint)
2403 {
2404 g_delCount++;
2405 }
2406
2407 static const char TEST_STR[] =
2408 "Where there is a will, there is a way.";
2409
DelTest(napi_env env,void * data,void * finalizeHint)2410 static void DelTest(napi_env env, void* data, [[maybe_unused]] void* finalizeHint)
2411 {
2412 free(data);
2413 g_delCount++;
2414 }
2415
CreateBuffer(napi_env env,napi_callback_info info)2416 static napi_value CreateBuffer(napi_env env, napi_callback_info info)
2417 {
2418 const unsigned int bufferSize = sizeof(TEST_STR);
2419 char* copyPtr;
2420 napi_value napiBuffer;
2421 napi_status status = napi_create_buffer(env, bufferSize, (void**)(©Ptr), &napiBuffer);
2422 if (status != napi_ok) {
2423 napi_throw_error(env, nullptr, "Failed to create buffer");
2424 return nullptr;
2425 }
2426 NAPI_ASSERT(env, copyPtr, "Unable to duplicate static text for CreateBuffer.");
2427 int ret = memcpy_s(copyPtr, bufferSize, TEST_STR, strlen(TEST_STR) + 1);
2428 NAPI_ASSERT(env, ret == 0, "memcpy_s failed");
2429 return napiBuffer;
2430 }
2431
CreateExternalBuffer(napi_env env,napi_callback_info info)2432 static napi_value CreateExternalBuffer(napi_env env, napi_callback_info info)
2433 {
2434 char* copyPtr = strdup(TEST_STR);
2435 napi_value napiBuffer;
2436 const unsigned int bufferSize = sizeof(TEST_STR);
2437
2438 NAPI_ASSERT(env, copyPtr, "Unable to duplicate static text for CreateExternalBuffer.");
2439 NAPI_CALL(env,
2440 napi_create_external_buffer(env,
2441 bufferSize,
2442 copyPtr,
2443 DelTest,
2444 nullptr /* finalizeHint */,
2445 &napiBuffer));
2446 return napiBuffer;
2447 }
2448
BufferCopy(napi_env env,napi_callback_info info)2449 static napi_value BufferCopy(napi_env env, napi_callback_info info)
2450 {
2451 const unsigned int bufferSize = sizeof(TEST_STR);
2452 napi_value napiBuffer;
2453 void* dataPtr = nullptr;
2454 napi_status status = napi_create_buffer_copy(env, bufferSize, TEST_STR, &dataPtr, &napiBuffer);
2455 if (status != napi_ok) {
2456 napi_throw_error(env, nullptr, "Failed to create buffer");
2457 return nullptr;
2458 }
2459 return napiBuffer;
2460 }
2461
IsBuffer(napi_env env,napi_callback_info info)2462 static napi_value IsBuffer(napi_env env, napi_callback_info info)
2463 {
2464 napi_value args[1];
2465 size_t argc = 1;
2466 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2467 napi_throw_error(env, nullptr, "Failed to parse arguments");
2468 return nullptr;
2469 }
2470 NAPI_ASSERT(env, argc == 1, "The number of arguments provided is incorrect.");
2471 napi_value napiBuffer = args[0];
2472 bool result;
2473 napi_status status = napi_is_buffer(env, napiBuffer, &result);
2474 if (status != napi_ok) {
2475 napi_throw_error(env, nullptr, "The parameter instance is not of type buffer.");
2476 }
2477 napi_value returnValue;
2478 NAPI_CALL(env, napi_get_boolean(env, result, &returnValue));
2479 return returnValue;
2480 }
2481
GetBufferInfo(napi_env env,napi_callback_info info)2482 static napi_value GetBufferInfo(napi_env env, napi_callback_info info)
2483 {
2484 size_t argc = 1;
2485 napi_value args[1];
2486 const unsigned int bufferSize = sizeof(TEST_STR);
2487 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2488 napi_throw_error(env, nullptr, "Failed to parse arguments");
2489 return nullptr;
2490 }
2491 NAPI_ASSERT(env, argc == 1, "Incorrect number of parameters.");
2492 napi_value napiBuffer = args[0];
2493 char *bufferData;
2494 napi_value returnValue;
2495 size_t bufferLength;
2496 if (napi_get_buffer_info(env, napiBuffer, (void**)(&bufferData), &bufferLength) != napi_ok) {
2497 napi_throw_error(env, nullptr, "Failed to get buffer info.");
2498 return nullptr;
2499 }
2500 NAPI_CALL(env, napi_get_boolean(env,
2501 !strcmp(bufferData, TEST_STR) && bufferLength == bufferSize,
2502 &returnValue));
2503 return returnValue;
2504 }
2505
StaticBuffer(napi_env env,napi_callback_info info)2506 static napi_value StaticBuffer(napi_env env, napi_callback_info info)
2507 {
2508 napi_value napiBuffer;
2509 const unsigned int bufferSize = sizeof(TEST_STR);
2510 NAPI_CALL(env,
2511 napi_create_external_buffer(env,
2512 bufferSize,
2513 (void*)TEST_STR,
2514 NoopDeleter,
2515 nullptr /* finalizeHint */,
2516 &napiBuffer));
2517 return napiBuffer;
2518 }
2519
GetSymbolNames(napi_env env,napi_callback_info info)2520 static napi_value GetSymbolNames(napi_env env, napi_callback_info info)
2521 {
2522 size_t argc = 1;
2523 napi_value args[1];
2524 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2525 napi_throw_error(env, nullptr, "Failed to parse arguments");
2526 return nullptr;
2527 }
2528 if (argc < 1) {
2529 napi_throw_error(env, nullptr, "Wrong number of arguments");
2530 return nullptr;
2531 }
2532 napi_valuetype valueType0;
2533 NAPI_CALL(env, napi_typeof(env, args[0], &valueType0));
2534 if (valueType0 != napi_object) {
2535 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2536 return nullptr;
2537 }
2538 napi_value output;
2539 NAPI_CALL(env,
2540 napi_get_all_property_names(env,
2541 args[0],
2542 napi_key_include_prototypes,
2543 napi_key_skip_strings,
2544 napi_key_numbers_to_strings,
2545 &output));
2546 return output;
2547 }
2548
GetEnumerableWritableNames(napi_env env,napi_callback_info info)2549 static napi_value GetEnumerableWritableNames(napi_env env, napi_callback_info info)
2550 {
2551 size_t argc = 1;
2552 napi_value args[1];
2553 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2554 napi_throw_error(env, nullptr, "Failed to parse arguments");
2555 return nullptr;
2556 }
2557 if (argc < 1) {
2558 napi_throw_error(env, nullptr, "Wrong number of arguments");
2559 return nullptr;
2560 }
2561 napi_valuetype valueType0;
2562 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2563 napi_throw_error(env, nullptr, "Failed to get argument type");
2564 return nullptr;
2565 }
2566 if (valueType0 != napi_object) {
2567 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2568 return nullptr;
2569 }
2570 napi_value output;
2571 NAPI_CALL(env,
2572 napi_get_all_property_names(env,
2573 args[0],
2574 napi_key_include_prototypes,
2575 static_cast<napi_key_filter>(napi_key_writable | napi_key_enumerable),
2576 napi_key_numbers_to_strings,
2577 &output));
2578 return output;
2579 }
2580
GetOwnWritableNames(napi_env env,napi_callback_info info)2581 static napi_value GetOwnWritableNames(napi_env env, napi_callback_info info)
2582 {
2583 size_t argc = 1;
2584 napi_value args[1];
2585 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2586 napi_throw_error(env, nullptr, "Failed to parse arguments");
2587 return nullptr;
2588 }
2589 if (argc < 1) {
2590 napi_throw_error(env, nullptr, "Wrong number of arguments");
2591 return nullptr;
2592 }
2593 napi_valuetype valueType0;
2594 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2595 napi_throw_error(env, nullptr, "Failed to get argument type");
2596 return nullptr;
2597 }
2598 if (valueType0 != napi_object) {
2599 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2600 return nullptr;
2601 }
2602 napi_value output;
2603 NAPI_CALL(env,
2604 napi_get_all_property_names(env,
2605 args[0],
2606 napi_key_own_only,
2607 napi_key_writable,
2608 napi_key_numbers_to_strings,
2609 &output));
2610 return output;
2611 }
2612
GetEnumerableConfigurableNames(napi_env env,napi_callback_info info)2613 static napi_value GetEnumerableConfigurableNames(napi_env env, napi_callback_info info)
2614 {
2615 size_t argc = 1;
2616 napi_value args[1];
2617 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2618 napi_throw_error(env, nullptr, "Failed to parse arguments");
2619 return nullptr;
2620 }
2621 if (argc < 1) {
2622 napi_throw_error(env, nullptr, "Wrong number of arguments");
2623 return nullptr;
2624 }
2625 napi_valuetype valueType0;
2626 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2627 napi_throw_error(env, nullptr, "Failed to get argument type");
2628 return nullptr;
2629 }
2630 if (valueType0 != napi_object) {
2631 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2632 return nullptr;
2633 }
2634 napi_value output;
2635 NAPI_CALL(env,
2636 napi_get_all_property_names(env,
2637 args[0],
2638 napi_key_include_prototypes,
2639 static_cast<napi_key_filter>(napi_key_enumerable | napi_key_configurable),
2640 napi_key_numbers_to_strings,
2641 &output));
2642 return output;
2643 }
2644
GetOwnConfigurableNames(napi_env env,napi_callback_info info)2645 static napi_value GetOwnConfigurableNames(napi_env env, napi_callback_info info)
2646 {
2647 size_t argc = 1;
2648 napi_value args[1];
2649 if (napi_get_cb_info(env, info, &argc, args, nullptr, nullptr) != napi_ok) {
2650 napi_throw_error(env, nullptr, "Failed to parse arguments");
2651 return nullptr;
2652 }
2653 if (argc < 1) {
2654 napi_throw_error(env, nullptr, "Wrong number of arguments");
2655 return nullptr;
2656 }
2657 napi_valuetype valueType0;
2658 if (napi_typeof(env, args[0], &valueType0) != napi_ok) {
2659 napi_throw_error(env, nullptr, "Failed to get argument type");
2660 return nullptr;
2661 }
2662 if (valueType0 != napi_object) {
2663 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an object as first argument.");
2664 return nullptr;
2665 }
2666 napi_value output;
2667 NAPI_CALL(env,
2668 napi_get_all_property_names(env,
2669 args[0],
2670 napi_key_own_only,
2671 napi_key_configurable,
2672 napi_key_numbers_to_strings,
2673 &output));
2674 return output;
2675 }
2676
GetAllPropertyNames(napi_env env,napi_callback_info info)2677 static napi_value GetAllPropertyNames(napi_env env, napi_callback_info info)
2678 {
2679 napi_value returnValue, props;
2680 NAPI_CALL(env, napi_create_object(env, &returnValue));
2681 add_returned_status(env,
2682 "envIsNull",
2683 returnValue,
2684 "Invalid argument",
2685 napi_invalid_arg,
2686 napi_get_all_property_names(nullptr,
2687 returnValue,
2688 napi_key_own_only,
2689 napi_key_writable,
2690 napi_key_keep_numbers,
2691 &props));
2692 napi_get_all_property_names(env,
2693 nullptr,
2694 napi_key_own_only,
2695 napi_key_writable,
2696 napi_key_keep_numbers,
2697 &props);
2698 add_last_status(env, "objectIsNull", returnValue);
2699 napi_get_all_property_names(env,
2700 returnValue,
2701 napi_key_own_only,
2702 napi_key_writable,
2703 napi_key_keep_numbers,
2704 nullptr);
2705 add_last_status(env, "valueIsNull", returnValue);
2706 return returnValue;
2707 }
2708
FreezeTest(napi_env env,napi_callback_info info)2709 static napi_value FreezeTest(napi_env env, napi_callback_info info)
2710 {
2711 size_t argc = 1;
2712 napi_value args[1];
2713 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2714
2715 // Check if argument is an object
2716 napi_value objectConstructor;
2717 napi_status status = napi_get_named_property(env, args[0], "Object", &objectConstructor);
2718 if (status != napi_ok) {
2719 napi_throw_error(env, nullptr, "Argument must be an object");
2720 }
2721 // Freeze the object
2722 napi_value object = args[0];
2723 NAPI_CALL(env, napi_object_freeze(env, object));
2724 return object;
2725 }
2726
SealTest(napi_env env,napi_callback_info info)2727 static napi_value SealTest(napi_env env, napi_callback_info info)
2728 {
2729 size_t argc = 1;
2730 napi_value args[1];
2731 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2732
2733 // Check if argument is an object
2734 napi_value objectConstructor;
2735 napi_status status = napi_get_named_property(env, args[0], "Object", &objectConstructor);
2736 if (status != napi_ok) {
2737 napi_throw_error(env, nullptr, "Argument must be an object");
2738 }
2739 // Seal the object
2740 napi_value object = args[0];
2741 NAPI_CALL(env, napi_object_seal(env, object));
2742
2743 return object;
2744 }
2745
FinalizeCallback(napi_env env,void * finalizeData,void * finalizeHint)2746 void FinalizeCallback(napi_env env, void* finalizeData, void* finalizeHint)
2747 {
2748 free(finalizeData);
2749 }
2750
External(napi_env env,napi_callback_info info)2751 static napi_value External(napi_env env, napi_callback_info info)
2752 {
2753 const uint8_t parraySize = 3;
2754 void* externalData = malloc(parraySize * sizeof(int8_t));
2755
2756 //Sets the three elements of the array that are used to create an ArrayBuffer object
2757 ((int8_t*)externalData)[0] = 0; // 0 means that the first value of the created array is 0
2758 ((int8_t*)externalData)[1] = 1; // 1 means that the second value of the created array is 1
2759 ((int8_t*)externalData)[2] = 2; // 2 means that the third value of the created array is 2
2760
2761 napi_value outputBuffer;
2762 napi_status status = napi_create_external_arraybuffer(env,
2763 externalData,
2764 parraySize * sizeof(int8_t),
2765 FinalizeCallback,
2766 nullptr, // finalizeHint
2767 &outputBuffer);
2768 if (status != napi_ok) {
2769 napi_throw_error(env, nullptr, "Failed to create external arraybuffer");
2770 return nullptr;
2771 }
2772 napi_value outputArray;
2773 status = napi_create_typedarray(env,
2774 napi_int8_array,
2775 parraySize,
2776 outputBuffer,
2777 0,
2778 &outputArray);
2779 if (status != napi_ok) {
2780 napi_throw_error(env, nullptr, "Failed to create typedarray");
2781 return nullptr;
2782 }
2783 return outputArray;
2784 }
2785
DetachTest(napi_env env,napi_callback_info info)2786 static napi_value DetachTest(napi_env env, napi_callback_info info)
2787 {
2788 size_t argc = 1;
2789 napi_value args[1];
2790 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2791 NAPI_ASSERT(env, argc == 1, "The number of arguments provided is incorrect.");
2792 void* data;
2793 size_t length;
2794 napi_typedarray_type type;
2795 napi_value arrayBuffer;
2796 NAPI_CALL(env, napi_get_typedarray_info(env, args[0], &type, &length, &data, &arrayBuffer, nullptr));
2797
2798 NAPI_CALL(env, napi_detach_arraybuffer(env, arrayBuffer));
2799 return nullptr;
2800 }
2801
IsDetachedTest(napi_env env,napi_callback_info info)2802 napi_value IsDetachedTest(napi_env env, napi_callback_info info)
2803 {
2804 size_t argc = 1;
2805 napi_value args[1];
2806 napi_status status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
2807 if (status != napi_ok || argc != 1) {
2808 napi_throw_error(env, nullptr, "Wrong number of arguments.");
2809 return nullptr;
2810 }
2811 bool isArraybuffer;
2812 status = napi_is_arraybuffer(env, args[0], &isArraybuffer);
2813 if (status != napi_ok || !isArraybuffer) {
2814 napi_throw_error(env, nullptr, "Wrong type of arguments. Expects an array buffer as first argument.");
2815 return nullptr;
2816 }
2817 bool isDetached;
2818 status = napi_is_detached_arraybuffer(env, args[0], &isDetached);
2819 if (status != napi_ok) {
2820 napi_throw_error(env, nullptr, "Failed to check if array buffer is detached.");
2821 return nullptr;
2822 }
2823 napi_value result;
2824 status = napi_get_boolean(env, isDetached, &result);
2825 if (status != napi_ok) {
2826 napi_throw_error(env, nullptr, "Failed to create boolean result.");
2827 return nullptr;
2828 }
2829 return result;
2830 }
2831
AsyncDestroyCb(napi_env env,void * data,void * hint)2832 static void AsyncDestroyCb(napi_env env, void *data, void *hint)
2833 {
2834 napi_status status = napi_async_destroy(env, (napi_async_context) data);
2835 // We cannot use NAPI_ASSERT_RETURN_VOID because we need to have a JS
2836 // stack below in order to use exceptions.
2837 if (status != napi_ok) {
2838 napi_throw_error(env, nullptr, "napi_async_destroy is failed");
2839 return;
2840 }
2841 }
2842
CreateAsyncResource(napi_env env,napi_callback_info info)2843 static napi_value CreateAsyncResource(napi_env env, napi_callback_info info)
2844 {
2845 napi_value asyncContextWrap;
2846 NAPI_CALL(env, napi_create_object(env, &asyncContextWrap));
2847
2848 size_t argc = 2; // Number of parameters is 2
2849 napi_value args[2]; // Number of parameters is 2
2850 size_t parameterCount = 2; // Number of parameters is 2
2851 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2852
2853 napi_value resource = args[0];
2854 napi_value jsDestroyOnFinalizer = args[1];
2855 napi_valuetype resourceType;
2856 NAPI_CALL(env, napi_typeof(env, resource, &resourceType));
2857 if (resourceType != napi_object) {
2858 resource = nullptr;
2859 }
2860
2861 napi_value resourceName;
2862 NAPI_CALL(env,
2863 napi_create_string_utf8(env, "test_async", NAPI_AUTO_LENGTH, &resourceName));
2864
2865 napi_async_context context;
2866 NAPI_CALL(env, napi_async_init(env, resource, resourceName, &context));
2867
2868 bool destroyOnFinalizer = true;
2869 if (argc == parameterCount) {
2870 NAPI_CALL(env, napi_get_value_bool(env, jsDestroyOnFinalizer, &destroyOnFinalizer));
2871 }
2872 if (resourceType == napi_object && destroyOnFinalizer) {
2873 NAPI_CALL(env,
2874 napi_add_finalizer(env, resource, reinterpret_cast<void*>(context), AsyncDestroyCb, nullptr, nullptr));
2875 }
2876 NAPI_CALL(env,
2877 napi_wrap(env, asyncContextWrap, context, [](napi_env env, void *data, void *hint) {}, nullptr, nullptr));
2878 return asyncContextWrap;
2879 }
2880
DestroyAsyncResource(napi_env env,napi_callback_info info)2881 static napi_value DestroyAsyncResource(napi_env env, napi_callback_info info)
2882 {
2883 size_t argc = 1;
2884 napi_value args[1];
2885
2886 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2887 NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
2888
2889 napi_value asyncContextWrap = args[0];
2890
2891 napi_async_context asyncContext;
2892 NAPI_CALL(env, napi_remove_wrap(env, asyncContextWrap, (void **)&asyncContext));
2893 NAPI_CALL(env, napi_async_destroy(env, asyncContext));
2894
2895 return asyncContextWrap;
2896 }
2897
RunInCallbackScope(napi_env env,napi_callback_info info)2898 static napi_value RunInCallbackScope(napi_env env, napi_callback_info info)
2899 {
2900 size_t argc;
2901 constexpr size_t parameterCount = 3;
2902 napi_value args[parameterCount];
2903 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr));
2904 NAPI_ASSERT(env, argc == parameterCount, "Wrong number of arguments");
2905
2906 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
2907
2908 napi_valuetype valuetype;
2909 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
2910 NAPI_ASSERT(env, valuetype == napi_object,
2911 "Wrong type of arguments. Expects an object as first argument.");
2912
2913 NAPI_CALL(env, napi_typeof(env, args[1], &valuetype));
2914 NAPI_ASSERT(env, valuetype == napi_string,
2915 "Wrong type of arguments. Expects a string as second argument.");
2916 constexpr size_t parameterTwo = 2;
2917 NAPI_CALL(env, napi_typeof(env, args[parameterTwo], &valuetype));
2918 NAPI_ASSERT(env, valuetype == napi_function,
2919 "Wrong type of arguments. Expects a function as third argument.");
2920
2921 napi_async_context context;
2922 NAPI_CALL(env, napi_async_init(env, args[0], args[1], &context));
2923
2924 napi_callback_scope scope = nullptr;
2925 NAPI_CALL(env, napi_open_callback_scope(env, args[0], context, &scope));
2926
2927 // If the function has an exception pending after the call that is ok
2928 // so we don't use NAPI_CALL as we must close the callback scope
2929 // regardless.
2930 napi_value result = nullptr;
2931 napi_status functionCallResult =
2932 napi_call_function(env, args[0], args[parameterTwo], 0, nullptr, &result);
2933 if (functionCallResult != napi_ok) {
2934 GET_AND_THROW_LAST_ERROR(env);
2935 }
2936
2937 NAPI_CALL(env, napi_close_callback_scope(env, scope));
2938 NAPI_CALL(env, napi_async_destroy(env, context));
2939
2940 return result;
2941 }
2942
Callback(uv_work_t * req,int ignored)2943 static void Callback(uv_work_t *req, [[maybe_unused]] int ignored)
2944 {
2945 napi_env env = g_sharedEnv;
2946
2947 napi_handle_scope handleScope = nullptr;
2948 NAPI_CALL_RETURN_VOID(env, napi_open_handle_scope(env, &handleScope));
2949
2950 napi_value resourceName;
2951 NAPI_CALL_RETURN_VOID(env,
2952 napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &resourceName));
2953 napi_async_context context;
2954 NAPI_CALL_RETURN_VOID(env,
2955 napi_async_init(env, nullptr, resourceName, &context));
2956
2957 napi_value resourceObject;
2958 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &resourceObject));
2959
2960 napi_value undefinedValue;
2961 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefinedValue));
2962
2963 napi_callback_scope scope = nullptr;
2964 NAPI_CALL_RETURN_VOID(env,
2965 napi_open_callback_scope(env, resourceObject, context, &scope));
2966
2967 NAPI_CALL_RETURN_VOID(env,
2968 napi_resolve_deferred(env, g_deferred, undefinedValue));
2969
2970 NAPI_CALL_RETURN_VOID(env, napi_close_callback_scope(env, scope));
2971
2972 NAPI_CALL_RETURN_VOID(env, napi_close_handle_scope(env, handleScope));
2973 NAPI_CALL_RETURN_VOID(env, napi_async_destroy(env, context));
2974 free(req);
2975 }
2976
NoopWork(uv_work_t * work)2977 static void NoopWork([[maybe_unused]] uv_work_t *work)
2978 {
2979 return;
2980 }
2981
TestResolveAsync(napi_env env,napi_callback_info info)2982 static napi_value TestResolveAsync(napi_env env, napi_callback_info info)
2983 {
2984 napi_value promise = nullptr;
2985 if (g_deferred == nullptr) {
2986 g_sharedEnv = env;
2987 NAPI_CALL(env, napi_create_promise(env, &g_deferred, &promise));
2988
2989 uv_loop_t *loop = nullptr;
2990 NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
2991
2992 uv_work_t* req = reinterpret_cast<uv_work_t*>(malloc(sizeof(uv_work_t)));
2993 uv_queue_work(loop,
2994 req,
2995 NoopWork,
2996 Callback);
2997 }
2998 return promise;
2999 }
3000
CallCbAndDeleteRef(napi_env env,napi_ref * optionalRef)3001 static void CallCbAndDeleteRef(napi_env env, napi_ref *optionalRef)
3002 {
3003 napi_value jsCb;
3004 napi_value undefined;
3005
3006 if (optionalRef == nullptr) {
3007 InstanceAddonData *data;
3008 napi_get_instance_data(env, (void **)&data);
3009 optionalRef = &data->jsCbRef;
3010 }
3011
3012 napi_get_reference_value(env, *optionalRef, &jsCb);
3013 napi_get_undefined(env, &undefined);
3014 napi_call_function(env, undefined, jsCb, 0, nullptr, nullptr);
3015 napi_delete_reference(env, *optionalRef);
3016
3017 *optionalRef = nullptr;
3018 }
3019
EstablishCallbackRef(napi_env env,napi_callback_info info)3020 static bool EstablishCallbackRef(napi_env env, napi_callback_info info)
3021 {
3022 InstanceAddonData *data;
3023 size_t argc = 1;
3024 napi_value jsCb;
3025
3026 napi_get_instance_data(env, (void **)&data);
3027
3028 napi_get_cb_info(env, info, &argc, &jsCb, nullptr, nullptr);
3029 napi_create_reference(env, jsCb, 1, &data->jsCbRef);
3030
3031 return true;
3032 }
3033
AsyncWorkCbExecute(napi_env env,void * data)3034 static void AsyncWorkCbExecute([[maybe_unused]] napi_env env, [[maybe_unused]] void* data)
3035 {
3036 return;
3037 }
3038
AsyncWorkCbComplete(napi_env env,napi_status status,void * data)3039 static void AsyncWorkCbComplete(napi_env env,
3040 [[maybe_unused]] napi_status status,
3041 [[maybe_unused]] void* data)
3042 {
3043 CallCbAndDeleteRef(env, nullptr);
3044 }
3045
DeleteAddonData(napi_env env,void * rawData,void * hint)3046 static void DeleteAddonData(napi_env env, void* rawData, void* hint)
3047 {
3048 InstanceData* data = reinterpret_cast<InstanceData*>(rawData);
3049 if (data->print) {
3050 printf("deleting addon data\n");
3051 }
3052 if (data->jsCbRef != nullptr) {
3053 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, data->jsCbRef));
3054 }
3055 free(data);
3056 }
3057
NapiSetInstanceData(napi_env env,napi_callback_info info)3058 static napi_value NapiSetInstanceData(napi_env env, napi_callback_info info)
3059 {
3060 InstanceData* data = reinterpret_cast<InstanceData*>(malloc(sizeof(*data)));
3061 data->value = 1;
3062 data->print = true;
3063 data->jsCbRef = nullptr;
3064
3065 NAPI_CALL(env, napi_set_instance_data(env, data, DeleteAddonData, nullptr));
3066
3067 InstanceData* getData = nullptr;
3068 NAPI_CALL(env, napi_get_instance_data(env, (void**)&getData));
3069 ++getData->value;
3070 const size_t expectValue = 2;
3071
3072 bool res = true;
3073 NAPI_ASSERT(env, getData->value == expectValue, "napi_get_instance_data failed");
3074
3075 napi_value value;
3076 NAPI_CALL(env, napi_create_int32(env, res, &value));
3077
3078 return value;
3079 }
3080
AsyncWorkCallback(napi_env env,napi_callback_info info)3081 static napi_value AsyncWorkCallback(napi_env env, napi_callback_info info)
3082 {
3083 if (EstablishCallbackRef(env, info)) {
3084 napi_value resourceName;
3085 napi_async_work work;
3086
3087 NAPI_CALL(env,
3088 napi_create_string_utf8(
3089 env, "AsyncIncrement", NAPI_AUTO_LENGTH, &resourceName));
3090 NAPI_CALL(env,
3091 napi_create_async_work(
3092 env, nullptr, resourceName, AsyncWorkCbExecute, AsyncWorkCbComplete,
3093 nullptr, &work));
3094 NAPI_CALL(env, napi_queue_async_work(env, work));
3095 }
3096
3097 return nullptr;
3098 }
3099
MustNotCall(napi_async_cleanup_hook_handle hook,void * arg)3100 static void MustNotCall(napi_async_cleanup_hook_handle hook, void* arg)
3101 {
3102 return;
3103 }
3104
CreateAsyncData()3105 static AsyncData* CreateAsyncData()
3106 {
3107 AsyncData* data = reinterpret_cast<AsyncData*>(malloc(sizeof(AsyncData)));
3108 data->handle = nullptr;
3109 return data;
3110 }
3111
AfterCleanupHookTwo(uv_handle_t * handle)3112 static void AfterCleanupHookTwo(uv_handle_t* handle)
3113 {
3114 g_cleanupHookCount++;
3115 AsyncData* data = reinterpret_cast<AsyncData*>(handle->data);
3116 napi_status status = napi_remove_async_cleanup_hook(data->handle);
3117 if (status != napi_ok) {
3118 napi_throw_error(data->env, nullptr, "napi_remove_async_cleanup_hook is failed");
3119 return;
3120 }
3121 free(data);
3122 }
3123
AfterCleanupHookOne(uv_async_t * async)3124 static void AfterCleanupHookOne(uv_async_t* async)
3125 {
3126 g_cleanupHookCount++;
3127 uv_close((uv_handle_t*)async, AfterCleanupHookTwo);
3128 }
3129
AsyncCleanupHook(napi_async_cleanup_hook_handle handle,void * arg)3130 static void AsyncCleanupHook(napi_async_cleanup_hook_handle handle, void* arg)
3131 {
3132 g_cleanupHookCount++;
3133 AsyncData* data = reinterpret_cast<AsyncData*>(arg);
3134 uv_loop_t* loop = nullptr;
3135 napi_status status = napi_get_uv_event_loop(data->env, &loop);
3136 if (status != napi_ok) {
3137 napi_throw_error(data->env, nullptr, "napi_get_uv_event_loop is failed");
3138 return;
3139 }
3140 int err = uv_async_init(loop, &data->async, AfterCleanupHookOne);
3141 if (err != 0) {
3142 napi_throw_error(data->env, nullptr, "uv_async_init is failed");
3143 return;
3144 }
3145
3146 data->async.data = data;
3147 data->handle = handle;
3148 uv_async_send(&data->async);
3149 }
3150
ObjectFinalizer(napi_env env,void * data,void * hint)3151 static void ObjectFinalizer(napi_env env, void* data, void* hint)
3152 {
3153 const int cleanupHookCount = 6;
3154 if (g_cleanupHookCount != cleanupHookCount) {
3155 napi_throw_error(env, nullptr, "cleanup_hook_count is error");
3156 return;
3157 }
3158
3159 napi_ref *ref = reinterpret_cast<napi_ref *>(data);
3160 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, *ref));
3161 free(ref);
3162 }
3163
CreateObjectWrap(napi_env env)3164 static void CreateObjectWrap(napi_env env)
3165 {
3166 napi_value jsObj;
3167 napi_ref *ref = reinterpret_cast<napi_ref *>(malloc(sizeof(napi_ref)));
3168 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsObj));
3169 NAPI_CALL_RETURN_VOID(
3170 env, napi_wrap(env, jsObj, ref, ObjectFinalizer, nullptr, ref));
3171 // create a strong reference so that the finalizer is called at shutdown.
3172 NAPI_CALL_RETURN_VOID(env, napi_reference_ref(env, *ref, nullptr));
3173 }
3174
NapiAsyncCleanUpHook(napi_env env,napi_callback_info exports)3175 static napi_value NapiAsyncCleanUpHook(napi_env env, napi_callback_info exports)
3176 {
3177 // Reinitialize the static variable to be compatible with musl libc.
3178 g_cleanupHookCount = 0;
3179 // Create object wrap before cleanup hooks.
3180 CreateObjectWrap(env);
3181
3182 {
3183 AsyncData* data = CreateAsyncData();
3184 data->env = env;
3185 napi_add_async_cleanup_hook(env, AsyncCleanupHook, data, &data->handle);
3186 }
3187
3188 {
3189 AsyncData* data = CreateAsyncData();
3190 data->env = env;
3191 napi_add_async_cleanup_hook(env, AsyncCleanupHook, data, nullptr);
3192 }
3193
3194 {
3195 napi_async_cleanup_hook_handle mustNotCallHandle;
3196 napi_add_async_cleanup_hook(
3197 env, MustNotCall, nullptr, &mustNotCallHandle);
3198 napi_remove_async_cleanup_hook(mustNotCallHandle);
3199 }
3200
3201 // Create object wrap after cleanup hooks.
3202 CreateObjectWrap(env);
3203
3204 return nullptr;
3205 }
3206
Cleanup(void * arg)3207 static void Cleanup(void* arg)
3208 {
3209 g_cleanupHookCount++;
3210 printf("Cleanup(%d)\n", *reinterpret_cast<int*>(arg));
3211 }
3212
CustomObjectFinalizer(napi_env env,void * data,void * hint)3213 static void CustomObjectFinalizer(napi_env env, void* data, void* hint)
3214 {
3215 // cleanup is called once.
3216 if (g_cleanupHookCount != 1) {
3217 napi_throw_error(env, nullptr, "cleanup_hook_count is error");
3218 return;
3219 }
3220
3221 napi_ref *ref = reinterpret_cast<napi_ref *>(data);
3222 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, *ref));
3223 free(ref);
3224 }
3225
ObjectWrapper(napi_env env)3226 static void ObjectWrapper(napi_env env)
3227 {
3228 napi_value jsObj;
3229 napi_ref *ref = reinterpret_cast<napi_ref *>(malloc(sizeof(napi_ref)));
3230 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &jsObj));
3231 NAPI_CALL_RETURN_VOID(
3232 env, napi_wrap(env, jsObj, ref, CustomObjectFinalizer, nullptr, ref));
3233 // create a strong reference so that the finalizer is called at shutdown.
3234 NAPI_CALL_RETURN_VOID(env, napi_reference_ref(env, *ref, nullptr));
3235 }
3236
NapiEnvCleanUpHook(napi_env env,napi_callback_info exports)3237 static napi_value NapiEnvCleanUpHook(napi_env env, napi_callback_info exports)
3238 {
3239 // Create object wrap before cleanup hooks.
3240 g_cleanupHookCount = 0;
3241 static int argValue = 42;
3242 static int argValueRemoved = 17;
3243 ObjectWrapper(env);
3244
3245 napi_add_env_cleanup_hook(env, Cleanup, &argValueRemoved);
3246 napi_add_env_cleanup_hook(env, Cleanup, &argValue);
3247 napi_remove_env_cleanup_hook(env, Cleanup, &argValueRemoved);
3248
3249 // Create object wrap after cleanup hooks.
3250 CreateObjectWrap(env);
3251
3252 return nullptr;
3253 }
3254
GetModuleFileName(napi_env env,napi_callback_info info)3255 static napi_value GetModuleFileName(napi_env env, napi_callback_info info)
3256 {
3257 const char *filename;
3258 napi_value result;
3259 node_api_get_module_file_name(env, &filename);
3260 napi_create_string_utf8(env, filename, NAPI_AUTO_LENGTH, &result);
3261 return result;
3262 }
3263
AsyncWorkWithQos(napi_env env,napi_callback_info info)3264 static napi_value AsyncWorkWithQos(napi_env env, napi_callback_info info)
3265 {
3266 size_t argc = 2;
3267 napi_value args[2];
3268 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
3269
3270 AddonData* addonData = reinterpret_cast<AddonData*>(malloc(sizeof(AddonData)));
3271 if (addonData == nullptr) {
3272 return nullptr;
3273 }
3274
3275 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
3276 NAPI_CALL(env, napi_create_reference(env, args[1], 1, &addonData->callback));
3277
3278 napi_value resourceName = nullptr;
3279 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncWorkWithQosTest", NAPI_AUTO_LENGTH, &resourceName));
3280 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB, AddCallbackCompleteCB,
3281 (void *)addonData, &addonData->asyncWork));
3282
3283 NAPI_CALL(env, napi_queue_async_work_with_qos(env, addonData->asyncWork, napi_qos_default));
3284
3285 napi_value _value = 0;
3286 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
3287 return _value;
3288 }
3289
TestDetachCallback(napi_env env,void * nativeObject,void * hint)3290 static void* TestDetachCallback(napi_env env, void* nativeObject, void* hint)
3291 {
3292 printf("this is detach callback");
3293 return nativeObject;
3294 }
3295
TestAttachCallback(napi_env env,void * nativeObject,void * hint)3296 static napi_value TestAttachCallback(napi_env env, void* nativeObject, void* hint)
3297 {
3298 printf("this is attach callback");
3299 napi_value object = nullptr;
3300 napi_value number = nullptr;
3301 uint32_t data = 0;
3302 if (hint != nullptr) {
3303 object = reinterpret_cast<napi_value>(nativeObject);
3304 data = 2000; // 2000 : Is number.
3305 napi_create_uint32(env, data, &number);
3306 } else {
3307 napi_create_object(env, &object);
3308 data = 1000; // 1000 : Is number.
3309 napi_create_uint32(env, data, &number);
3310 }
3311 napi_set_named_property(env, object, "number", number);
3312 return object;
3313 }
3314
CoerceToNativeBindingObject(napi_env env,napi_callback_info info)3315 static napi_value CoerceToNativeBindingObject(napi_env env, napi_callback_info info)
3316 {
3317 napi_value object = nullptr;
3318 napi_create_object(env, &object);
3319 napi_value hint = nullptr;
3320 napi_create_object(env, &hint);
3321 napi_status status = napi_coerce_to_native_binding_object(env, object,
3322 TestDetachCallback, TestAttachCallback, reinterpret_cast<void*>(object), reinterpret_cast<void*>(hint));
3323 NAPI_ASSERT(env, status == napi_ok, "napi_coerce_to_native_binding_object fail");
3324
3325 napi_value undefined = nullptr;
3326 napi_get_undefined(env, &undefined);
3327 napi_value data = nullptr;
3328 napi_serialize(env, object, undefined, undefined, false, true, &data);
3329 NAPI_ASSERT(env, data != nullptr, " The data is nullptr");
3330 napi_value result = nullptr;
3331 napi_deserialize(env, data, &result);
3332 napi_valuetype valuetype;
3333 NAPI_CALL(env, napi_typeof(env, result, &valuetype));
3334 NAPI_ASSERT(env, valuetype == napi_object, "Wrong type of argment. Expects a object.");
3335 napi_delete_serialization_data(env, data);
3336 napi_value number = nullptr;
3337 napi_get_named_property(env, result, "number", &number);
3338 napi_valuetype valuetype1;
3339 NAPI_CALL(env, napi_typeof(env, number, &valuetype1));
3340 NAPI_ASSERT(env, valuetype1 == napi_number, "Wrong type of argment. Expects a number.");
3341
3342 return number;
3343 }
3344
CreateWithPropertiesTestGetter(napi_env env,napi_callback_info info)3345 static napi_value CreateWithPropertiesTestGetter(napi_env env, napi_callback_info info)
3346 {
3347 napi_value res;
3348 napi_get_boolean(env, false, &res);
3349 return res;
3350 }
3351
CreateWithPropertiesTestSetter(napi_env env,napi_callback_info info)3352 static napi_value CreateWithPropertiesTestSetter(napi_env env, napi_callback_info info)
3353 {
3354 napi_value res;
3355 napi_get_boolean(env, true, &res);
3356 return res;
3357 }
3358
CreateObjectWithProperties(napi_env env,napi_callback_info info)3359 static napi_value CreateObjectWithProperties(napi_env env, napi_callback_info info)
3360 {
3361 napi_value excep;
3362 NAPI_CALL(env, napi_get_and_clear_last_exception(env, &excep));
3363 napi_value val_false;
3364 napi_value val_true;
3365 NAPI_CALL(env, napi_get_boolean(env, false, &val_false));
3366 NAPI_CALL(env, napi_get_boolean(env, true, &val_true));
3367 napi_property_descriptor desc1[] = {
3368 DECLARE_NAPI_DEFAULT_PROPERTY("x", val_true),
3369 };
3370 napi_value obj1;
3371 NAPI_CALL(env, napi_create_object_with_properties(env, &obj1, 1, desc1));
3372 napi_valuetype valuetype1;
3373 NAPI_CALL(env, napi_typeof(env, obj1, &valuetype1));
3374 napi_value obj2;
3375 napi_property_descriptor desc2[] = {
3376 DECLARE_NAPI_DEFAULT_PROPERTY("a", val_false),
3377 DECLARE_NAPI_GETTER_SETTER("b", CreateWithPropertiesTestGetter, CreateWithPropertiesTestSetter),
3378 DECLARE_NAPI_DEFAULT_PROPERTY("c", obj1),
3379 };
3380 NAPI_CALL(env, napi_create_object_with_properties(env, &obj2, 3, desc2)); // 3 : The property count.
3381 napi_valuetype valuetype2;
3382 NAPI_CALL(env, napi_typeof(env, obj2, &valuetype2));
3383 NAPI_ASSERT(env, valuetype1 == napi_object, "Wrong type of argment. Expects a object.");
3384 NAPI_ASSERT(env, valuetype2 == napi_object, "Wrong type of argment. Expects a object.");
3385 auto checkPropertyEqualsTo = [env] (napi_value obj, const char *keyStr, napi_value expect) -> bool {
3386 napi_value result;
3387 napi_get_named_property(env, obj, keyStr, &result);
3388 bool equal = false;
3389 napi_strict_equals(env, result, expect, &equal);
3390 return equal;
3391 };
3392
3393 bool equalRes = false;
3394 // get obj1.x == true
3395 equalRes = checkPropertyEqualsTo(obj1, "x", val_true);
3396 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3397 // set obj1.x = false
3398 NAPI_CALL(env, napi_set_named_property(env, obj1, "x", val_false));
3399 // get obj1.x == false
3400 equalRes = checkPropertyEqualsTo(obj1, "x", val_false);
3401 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3402 // get obj2.a == false
3403 equalRes = checkPropertyEqualsTo(obj2, "a", val_false);
3404 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3405 // get obj2.b == false
3406 equalRes = checkPropertyEqualsTo(obj2, "b", val_false);
3407 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3408 // set obj2.b = true (useless)
3409 NAPI_CALL(env, napi_set_named_property(env, obj2, "b", val_true));
3410 // get obj2.b == false
3411 equalRes = checkPropertyEqualsTo(obj2, "b", val_false);
3412 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3413 // get obj2.c == obj1
3414 equalRes = checkPropertyEqualsTo(obj2, "c", obj1);
3415 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3416 // get obj2.c.x == false
3417 napi_value val_res;
3418 NAPI_CALL(env, napi_get_named_property(env, obj2, "c", &val_res));
3419 equalRes = checkPropertyEqualsTo(val_res, "x", val_false);
3420 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3421
3422 napi_value _value = 0;
3423 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
3424 return _value;
3425 }
3426
CreateObjectWithNamedProperties(napi_env env,napi_callback_info info)3427 static napi_value CreateObjectWithNamedProperties(napi_env env, napi_callback_info info)
3428 {
3429 napi_value excep;
3430 NAPI_CALL(env, napi_get_and_clear_last_exception(env, &excep));
3431 napi_value val_false;
3432 napi_value val_true;
3433 NAPI_CALL(env, napi_get_boolean(env, false, &val_false));
3434 NAPI_CALL(env, napi_get_boolean(env, true, &val_true));
3435 const char *keys1[] = {
3436 "x",
3437 };
3438 const napi_value values1[] = {
3439 val_true,
3440 };
3441 napi_value obj1;
3442 NAPI_CALL(env, napi_create_object_with_named_properties(env, &obj1, 1, keys1, values1));
3443 napi_value obj2;
3444 const char *keys2[] = {
3445 "a",
3446 "b",
3447 };
3448 const napi_value values2[] = {
3449 val_false,
3450 obj1,
3451 };
3452
3453 NAPI_CALL(env, napi_create_object_with_named_properties(env, &obj2, 2, keys2, values2)); // 2 : The property count.
3454 napi_valuetype valuetype1;
3455 napi_valuetype valuetype2;
3456 NAPI_CALL(env, napi_typeof(env, obj1, &valuetype1));
3457 NAPI_CALL(env, napi_typeof(env, obj2, &valuetype2));
3458 NAPI_ASSERT(env, valuetype1 == napi_object, "Wrong type of argment. Expects a object.");
3459 NAPI_ASSERT(env, valuetype2 == napi_object, "Wrong type of argment. Expects a object.");
3460
3461 auto checkPropertyEqualsTo = [env] (napi_value obj, const char *keyStr, napi_value expect) -> bool {
3462 napi_value result;
3463 napi_get_named_property(env, obj, keyStr, &result);
3464 bool equal = false;
3465 napi_strict_equals(env, result, expect, &equal);
3466 return equal;
3467 };
3468
3469 bool equalRes = false;
3470 // get obj1.x == true
3471 equalRes = checkPropertyEqualsTo(obj1, "x", val_true);
3472 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3473 // set obj1.x = false
3474 NAPI_CALL(env, napi_set_named_property(env, obj1, "x", val_false));
3475 // get obj1.x == false
3476 equalRes = checkPropertyEqualsTo(obj1, "x", val_false);
3477 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3478 // get obj2.a == false
3479 equalRes = checkPropertyEqualsTo(obj2, "a", val_false);
3480 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3481 // get obj2.b == obj1
3482 equalRes = checkPropertyEqualsTo(obj2, "b", obj1);
3483 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3484 // get obj2.b.x == false
3485 napi_value val_res;
3486 NAPI_CALL(env, napi_get_named_property(env, obj2, "b", &val_res));
3487 equalRes = checkPropertyEqualsTo(val_res, "x", val_false);
3488 NAPI_ASSERT(env, equalRes == true, "equalRes is false.");
3489
3490 napi_value _value = 0;
3491 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
3492 return _value;
3493 }
3494
MakeCallback(napi_env env,napi_callback_info info)3495 static napi_value MakeCallback(napi_env env, napi_callback_info info)
3496 {
3497 size_t argc = 10; // 10 : max arguments.
3498 size_t n;
3499 napi_value args[10]; // 10 : max arguments.
3500 // NOLINTNEXTLINE (readability/null_usage)
3501 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
3502 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
3503 napi_value async_context_wrap = args[0];
3504 napi_value recv = args[1];
3505 napi_value func = args[2]; // 2 : create async resouce arguments count.
3506 napi_value argv[7]; // 7 : remain arguments.
3507 for (n = 3; n < argc; n += 1) { // 3 : reserved arguments.
3508 argv[n - 3] = args[n]; // 3 : reserved arguments.
3509 }
3510 napi_valuetype func_type;
3511 NAPI_CALL(env, napi_typeof(env, func, &func_type));
3512 napi_async_context context;
3513 NAPI_CALL(env, napi_unwrap(env, async_context_wrap, (void **)&context));
3514 napi_value result;
3515 if (func_type == napi_function) {
3516 NAPI_CALL(env,
3517 napi_make_callback(env, context, recv, func, argc - 3, argv, &result)); // 3 : reserved arguments.
3518 } else {
3519 NAPI_ASSERT(env, false, "Unexpected argument type");
3520 }
3521 return result;
3522 }
3523
MakeCallbackOne(napi_env env,napi_callback_info info)3524 static napi_value MakeCallbackOne(napi_env env, napi_callback_info info)
3525 {
3526 size_t argc = 10; // 10 : max arguments.
3527 size_t n;
3528 napi_value args[10]; // 10 : max arguments.
3529 // NOLINTNEXTLINE (readability/null_usage)
3530 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
3531 NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
3532 napi_value resource = args[0];
3533 napi_value recv = args[1];
3534 napi_value func = args[2];
3535 napi_value argv[7]; // 7 : remain arguments.
3536 for (n = 3; n < argc; n += 1) { // 3 : reserved arguments.
3537 argv[n - 3] = args[n]; // 3 : reserved arguments.
3538 }
3539
3540 napi_valuetype func_type;
3541 NAPI_CALL(env, napi_typeof(env, func, &func_type));
3542
3543 napi_value resource_name;
3544 NAPI_CALL(env, napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &resource_name));
3545
3546 napi_async_context context;
3547 NAPI_CALL(env, napi_async_init(env, resource, resource_name, &context));
3548
3549 napi_value result;
3550 if (func_type == napi_function) {
3551 NAPI_CALL(env,
3552 napi_make_callback(env, context, recv, func, argc - 3, argv, &result)); // 3 : reserved arguments.
3553 } else {
3554 NAPI_ASSERT(env, false, "Unexpected argument type");
3555 }
3556
3557 NAPI_CALL(env, napi_async_destroy(env, context));
3558 return result;
3559 }
3560
3561 EXTERN_C_START
3562
Init(napi_env env,napi_value exports)3563 static napi_value Init(napi_env env, napi_value exports)
3564 {
3565 napi_value theValue;
3566 NAPI_CALL(env, napi_create_string_utf8(env, TEST_STR, sizeof(TEST_STR), &theValue));
3567 NAPI_CALL(env, napi_set_named_property(env, exports, "testStr", theValue));
3568 napi_property_descriptor properties[] = {
3569 DECLARE_NAPI_FUNCTION("getLastErrorInfo", getLastErrorInfo),
3570 DECLARE_NAPI_FUNCTION("cleanUpErrorInfo", cleanUpErrorInfo),
3571 DECLARE_NAPI_FUNCTION("throwExistingError", throwExistingError),
3572 DECLARE_NAPI_FUNCTION("throwError", throwError),
3573 DECLARE_NAPI_FUNCTION("throwTypeError", throwTypeError),
3574 DECLARE_NAPI_FUNCTION("throwRangeError", throwRangeError),
3575 DECLARE_NAPI_FUNCTION("isError", isError),
3576 DECLARE_NAPI_FUNCTION("createError", createError),
3577 DECLARE_NAPI_FUNCTION("createTypeError", createTypeError),
3578 DECLARE_NAPI_FUNCTION("createRangeError", createRangeError),
3579 DECLARE_NAPI_FUNCTION("getAndClearLastException", getAndClearLastException),
3580 DECLARE_NAPI_FUNCTION("isExceptionPending", isExceptionPending),
3581 DECLARE_NAPI_FUNCTION("openAndCloseHandleScope", openAndCloseHandleScope),
3582 DECLARE_NAPI_FUNCTION("openAndCloseEscapableHandleScope", openAndCloseEscapableHandleScope),
3583 DECLARE_NAPI_FUNCTION("createReference", createReference),
3584 DECLARE_NAPI_FUNCTION("getAndDeleteReference", getAndDeleteReference),
3585 DECLARE_NAPI_FUNCTION("referenceRefAndUnref", referenceRefAndUnref),
3586 DECLARE_NAPI_FUNCTION("createArrayAndGetLength", createArrayAndGetLength),
3587 DECLARE_NAPI_FUNCTION("getArrayWithLength", getArrayWithLength),
3588 DECLARE_NAPI_FUNCTION("createExternal", createExternal),
3589 DECLARE_NAPI_FUNCTION("createExternalArraybuffer", createExternalArraybuffer),
3590 DECLARE_NAPI_FUNCTION("createObject", createObject),
3591 DECLARE_NAPI_FUNCTION("createSymbol", createSymbol),
3592 DECLARE_NAPI_FUNCTION("createTypeArray", createTypeArray),
3593 DECLARE_NAPI_FUNCTION("createDataView", createDataView),
3594 DECLARE_NAPI_FUNCTION("createAndGetInt32", createAndGetInt32),
3595 DECLARE_NAPI_FUNCTION("createAndGetUInt32", createAndGetUInt32),
3596 DECLARE_NAPI_FUNCTION("createAndGetInt64", createAndGetInt64),
3597 DECLARE_NAPI_FUNCTION("createDouble", createDouble),
3598 DECLARE_NAPI_FUNCTION("createAndGetStringLatin1", createAndGetStringLatin1),
3599 DECLARE_NAPI_FUNCTION("createAndGetStringUtf8", createAndGetStringUtf8),
3600 DECLARE_NAPI_FUNCTION("getPrototype", getPrototype),
3601 DECLARE_NAPI_FUNCTION("getPrototype2", getPrototype2),
3602 DECLARE_NAPI_FUNCTION("getTypedArrayInfo", getTypedArrayInfo),
3603 DECLARE_NAPI_FUNCTION("getDataViewInfo", getDataViewInfo),
3604 DECLARE_NAPI_FUNCTION("getValueBool", getValueBool),
3605 DECLARE_NAPI_FUNCTION("getValueDouble", getValueDouble),
3606 DECLARE_NAPI_FUNCTION("getValueExternal", getValueExternal),
3607 DECLARE_NAPI_FUNCTION("getNull", getNull),
3608 DECLARE_NAPI_FUNCTION("getUndefined", getUndefined),
3609 DECLARE_NAPI_FUNCTION("coerceToBool", coerceToBool),
3610 DECLARE_NAPI_FUNCTION("coerceToNumber", coerceToNumber),
3611 DECLARE_NAPI_FUNCTION("coerceToObject", coerceToObject),
3612 DECLARE_NAPI_FUNCTION("coerceToString", coerceToString),
3613 DECLARE_NAPI_FUNCTION("instanceOf", instanceOf),
3614 DECLARE_NAPI_FUNCTION("isArray", isArray),
3615 DECLARE_NAPI_FUNCTION("isDate", isDate),
3616 DECLARE_NAPI_FUNCTION("strictEquals", strictEquals),
3617 DECLARE_NAPI_FUNCTION("getPropertyNames", getPropertyNames),
3618 DECLARE_NAPI_FUNCTION("setProperty", setProperty),
3619 DECLARE_NAPI_FUNCTION("getProperty", getProperty),
3620 DECLARE_NAPI_FUNCTION("hasProperty", hasProperty),
3621 DECLARE_NAPI_FUNCTION("setAndDeleteProperty", setAndDeleteProperty),
3622 DECLARE_NAPI_FUNCTION("hasOwnProperty", hasOwnProperty),
3623 DECLARE_NAPI_FUNCTION("setNamedProperty", setNamedProperty),
3624 DECLARE_NAPI_FUNCTION("getNamedProperty", getNamedProperty),
3625 DECLARE_NAPI_FUNCTION("hasNamedProperty", hasNamedProperty),
3626 DECLARE_NAPI_FUNCTION("setElement", setElement),
3627 DECLARE_NAPI_FUNCTION("getElement", getElement),
3628 DECLARE_NAPI_FUNCTION("hasElement", hasElement),
3629 DECLARE_NAPI_FUNCTION("deleteElement", deleteElement),
3630 DECLARE_NAPI_FUNCTION("defineProperties", defineProperties),
3631 DECLARE_NAPI_FUNCTION("wrap", wrap),
3632 DECLARE_NAPI_FUNCTION("unwrap", unwrap),
3633 DECLARE_NAPI_FUNCTION("removeWrap", removeWrap),
3634 DECLARE_NAPI_FUNCTION("getVersion", getVersion),
3635 DECLARE_NAPI_FUNCTION("createPromise", createPromise),
3636 DECLARE_NAPI_FUNCTION("resolveAndRejectDeferred", resolveAndRejectDeferred),
3637 DECLARE_NAPI_FUNCTION("isPromise", isPromise),
3638 DECLARE_NAPI_FUNCTION("TestLatin1", TestLatin1),
3639 DECLARE_NAPI_FUNCTION("TestUtf16", TestUtf16),
3640 DECLARE_NAPI_FUNCTION("TestUtf8", TestUtf8),
3641 DECLARE_NAPI_FUNCTION("runScript", runScript),
3642 DECLARE_NAPI_FUNCTION("getUvEventLoop", getUvEventLoop),
3643 DECLARE_NAPI_FUNCTION("napCreateArrayBuffer", napCreateArrayBuffer),
3644 DECLARE_NAPI_FUNCTION("naiGetArrayBufferInfo", naiGetArrayBufferInfo),
3645 DECLARE_NAPI_FUNCTION("napiDefineClass", napiDefineClass),
3646 DECLARE_NAPI_FUNCTION("napiRunScriptPath", napiRunScriptPath),
3647 DECLARE_NAPI_FUNCTION("napiGetNodeVersion", napiGetNodeVersion),
3648 DECLARE_NAPI_FUNCTION("napiCallThreadsafeFunction", napiCallThreadsafeFunction),
3649 DECLARE_NAPI_FUNCTION("napiCreateThreadsafeFunction", napiCreateThreadsafeFunction),
3650 DECLARE_NAPI_FUNCTION("napiRefthreadSafeFunction", napiRefthreadSafeFunction),
3651 DECLARE_NAPI_FUNCTION("napiCreateDate", napiCreateDate),
3652 DECLARE_NAPI_FUNCTION("napiCreateBigintUint64", napiCreateBigintUint64),
3653 DECLARE_NAPI_FUNCTION("napiCreateBigintInt64", napiCreateBigintInt64),
3654 DECLARE_NAPI_FUNCTION("napiCreateBigintWords", napiCreateBigintWords),
3655 DECLARE_NAPI_FUNCTION("napiGetCbInfo", napiGetCbInfo),
3656 DECLARE_NAPI_FUNCTION("checkTypeTag", CheckTypeTag),
3657 DECLARE_NAPI_FUNCTION("typeTaggedInstance", TypeTaggedInstance),
3658 DECLARE_NAPI_FUNCTION("stringUtf16OfCase", StringUtf16OfCase),
3659 DECLARE_NAPI_FUNCTION("createAndGetStringUtf16", CreateAndGetStringUtf16),
3660 { "napiCancelAsyncWork", nullptr, napiCancelAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
3661 { "testAsyncWork", nullptr, testAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
3662 { "testPromise", nullptr, testPromise, nullptr, nullptr, nullptr, napi_default, nullptr },
3663 { "napiCreateFunction", nullptr, napiCreateFunction, nullptr, nullptr, nullptr, napi_default, nullptr },
3664 { "NapiCreateFunctionTwo", nullptr, NapiCreateFunctionTwo, nullptr, nullptr, nullptr, napi_default, nullptr },
3665 DECLARE_NAPI_FUNCTION("getGlobal", getGlobal),
3666 DECLARE_NAPI_FUNCTION("callFunction", callFunction),
3667 DECLARE_NAPI_FUNCTION("ThreadSafeTest", ThreadSafeTest),
3668 DECLARE_NAPI_FUNCTION("CreateBuffer", CreateBuffer),
3669 DECLARE_NAPI_FUNCTION("CreateExternalBuffer", CreateExternalBuffer),
3670 DECLARE_NAPI_FUNCTION("BufferCopy", BufferCopy),
3671 DECLARE_NAPI_FUNCTION("IsBuffer", IsBuffer),
3672 DECLARE_NAPI_FUNCTION("GetBufferInfo", GetBufferInfo),
3673 DECLARE_NAPI_FUNCTION("GetAllPropertyNames", GetAllPropertyNames),
3674 DECLARE_NAPI_FUNCTION("GetSymbolNames", GetSymbolNames),
3675 DECLARE_NAPI_FUNCTION("GetEnumerableWritableNames", GetEnumerableWritableNames),
3676 DECLARE_NAPI_FUNCTION("GetOwnWritableNames", GetOwnWritableNames),
3677 DECLARE_NAPI_FUNCTION("GetEnumerableConfigurableNames", GetEnumerableConfigurableNames),
3678 DECLARE_NAPI_FUNCTION("GetOwnConfigurableNames", GetOwnConfigurableNames),
3679 DECLARE_NAPI_FUNCTION("FreezeTest", FreezeTest),
3680 DECLARE_NAPI_FUNCTION("SealTest", SealTest),
3681 DECLARE_NAPI_FUNCTION("StaticBuffer", StaticBuffer),
3682 DECLARE_NAPI_FUNCTION("External", External),
3683 DECLARE_NAPI_FUNCTION("DetachTest", DetachTest),
3684 DECLARE_NAPI_FUNCTION("IsDetachedTest", IsDetachedTest),
3685 DECLARE_NAPI_FUNCTION("stringUtf16OfLengthLeZero", StringUtf16OfLengthLeZero),
3686 DECLARE_NAPI_FUNCTION("stringUtf16OfLengthEqOne", StringUtf16OfLengthEqOne),
3687 DECLARE_NAPI_FUNCTION("stringUtf8OfLengthLeZero", StringUtf8OfLengthLeZero),
3688 DECLARE_NAPI_FUNCTION("NewTargetTest", NewTargetTest),
3689 DECLARE_NAPI_FUNCTION("napiLoadModule", napiLoadModule),
3690 DECLARE_NAPI_FUNCTION("createAsyncResource", CreateAsyncResource),
3691 DECLARE_NAPI_FUNCTION("destroyAsyncResource", DestroyAsyncResource),
3692 DECLARE_NAPI_FUNCTION("runInCallbackScope", RunInCallbackScope),
3693 DECLARE_NAPI_FUNCTION("testResolveAsync", TestResolveAsync),
3694 DECLARE_NAPI_FUNCTION("napiSetInstanceData", NapiSetInstanceData),
3695 DECLARE_NAPI_FUNCTION("asyncWorkCallback", AsyncWorkCallback),
3696 DECLARE_NAPI_FUNCTION("napiAsyncCleanUpHook", NapiAsyncCleanUpHook),
3697 DECLARE_NAPI_FUNCTION("napiEnvCleanUpHook", NapiEnvCleanUpHook),
3698 DECLARE_NAPI_FUNCTION("getModuleFileName", GetModuleFileName),
3699 DECLARE_NAPI_FUNCTION("asyncWorkWithQos", AsyncWorkWithQos),
3700 DECLARE_NAPI_FUNCTION("coerceToNativeBindingObject", CoerceToNativeBindingObject),
3701 DECLARE_NAPI_FUNCTION("createObjectWithProperties", CreateObjectWithProperties),
3702 DECLARE_NAPI_FUNCTION("createObjectWithNamedProperties", CreateObjectWithNamedProperties),
3703 DECLARE_NAPI_FUNCTION("makeCallback", MakeCallback),
3704 DECLARE_NAPI_FUNCTION("makeCallbackOne", MakeCallbackOne),
3705 };
3706 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
3707
3708 napi_property_descriptor descClass[] = {
3709 DECLARE_NAPI_FUNCTION("sayHello", SayHello),
3710 };
3711 napi_value myClass;
3712 napi_define_class(env, "myClass", NAPI_AUTO_LENGTH, MyConstructor, nullptr,
3713 sizeof(descClass) / sizeof(descClass[0]), descClass, &myClass);
3714 napi_set_named_property(env, exports, "myClass", myClass);
3715 return exports;
3716 }
3717
3718 EXTERN_C_END
3719
3720 static napi_module demoModule = {
3721 .nm_version = 1,
3722 .nm_flags = 0,
3723 .nm_filename = nullptr,
3724 .nm_register_func = Init,
3725 .nm_modname = "napitest",
3726 .nm_priv = ((void *)0),
3727 .reserved = {0},
3728 };
3729
RegisterModule(void)3730 extern "C" __attribute__((constructor)) void RegisterModule(void)
3731 {
3732 napi_module_register(&demoModule);
3733 }
3734