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 <stdint.h>
19 #include <string>
20 #include <stdio.h>
21 #include <vector>
22 #include <malloc.h>
23 #include <ctime>
24 #include <thread>
25 #include <uv.h>
26
27 static napi_ref test_reference = NULL;
28 const int TAG_NUMBER = 666;
29
add_returned_status(napi_env env,const char * key,napi_value object,const char * expected_message,napi_status expected_status,napi_status actual_status)30 static void add_returned_status(napi_env env,
31 const char* key,
32 napi_value object,
33 const char* expected_message,
34 napi_status expected_status,
35 napi_status actual_status)
36 {
37 char napi_message_string[100] = "";
38 napi_value prop_value;
39
40 if (actual_status != expected_status) {
41 printf("Invalid status [%d]", actual_status);
42 }
43
44 NAPI_CALL_RETURN_VOID(env,
45 napi_create_string_utf8(env,
46 (actual_status == expected_status ?
47 expected_message :
48 napi_message_string),
49 NAPI_AUTO_LENGTH,
50 &prop_value));
51 NAPI_CALL_RETURN_VOID(env,
52 napi_set_named_property(env,
53 object,
54 key,
55 prop_value));
56 }
57
add_last_status(napi_env env,const char * key,napi_value return_value)58 static void add_last_status(napi_env env, const char* key, napi_value return_value)
59 {
60 napi_value prop_value;
61 const napi_extended_error_info* p_last_error;
62 NAPI_CALL_RETURN_VOID(env, napi_get_last_error_info(env, &p_last_error));
63
64 NAPI_CALL_RETURN_VOID(env,
65 napi_create_string_utf8(env,
66 (p_last_error->error_message == NULL ?
67 "napi_ok" :
68 p_last_error->error_message),
69 NAPI_AUTO_LENGTH,
70 &prop_value));
71 NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env,
72 return_value,
73 key,
74 prop_value));
75 }
76
getLastErrorInfo(napi_env env,napi_callback_info info)77 static napi_value getLastErrorInfo(napi_env env, napi_callback_info info)
78 {
79 napi_value value;
80 NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
81 double double_value;
82 napi_status status = napi_get_value_double(env, value, &double_value);
83 NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
84 const napi_extended_error_info * error_info = 0;
85 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
86
87 NAPI_ASSERT(env, error_info->error_code == status,
88 "Last error info code should match last status");
89 NAPI_ASSERT(env, error_info->error_message,
90 "Last error info message should not be null");
91 napi_value _value;
92 NAPI_CALL(env, napi_create_int32(env, error_info->error_code, &_value));
93 return _value;
94 }
95
cleanUpErrorInfo(napi_env env,napi_callback_info info)96 static napi_value cleanUpErrorInfo(napi_env env, napi_callback_info info)
97 {
98 const napi_extended_error_info * error_info = 0;
99 NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
100
101 napi_value result;
102 bool is_ok = error_info->error_code == napi_ok;
103 NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
104
105 return result;
106 }
107
throwExistingError(napi_env env,napi_callback_info info)108 static napi_value throwExistingError(napi_env env, napi_callback_info info)
109 {
110 napi_value code = nullptr;
111 napi_value message = nullptr;
112 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
113 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
114 napi_value error = nullptr;
115 napi_create_error(env, code, message, &error);
116 NAPI_ASSERT(env, error != nullptr, "error succes");
117 bool isError = false;
118 napi_is_error(env, error, &isError);
119 NAPI_ASSERT(env, isError, "error succes");
120
121 NAPI_CALL(env, napi_throw(env, error));
122
123 napi_value _value;
124 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
125 return _value;
126 }
127
throwError(napi_env env,napi_callback_info info)128 static napi_value throwError(napi_env env, napi_callback_info info)
129 {
130 napi_value code = nullptr;
131 napi_value message = nullptr;
132 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
133 napi_create_string_latin1(env, "test error", NAPI_AUTO_LENGTH, &message);
134 napi_value error = nullptr;
135 napi_create_error(env, code, message, &error);
136 NAPI_ASSERT(env, error != nullptr, "error succes");
137 bool isError = false;
138 napi_is_error(env, error, &isError);
139 NAPI_ASSERT(env, isError, "error succes");
140 napi_throw_error(env, "500", "Common error");
141 napi_value _value;
142 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
143 return _value;
144 }
145
throwTypeError(napi_env env,napi_callback_info info)146 static napi_value throwTypeError(napi_env env, napi_callback_info info)
147 {
148 napi_value code = nullptr;
149 napi_value message = nullptr;
150 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
151 napi_create_string_latin1(env, "type error 500", NAPI_AUTO_LENGTH, &message);
152 napi_value error = nullptr;
153 napi_create_type_error(env, code, message, &error);
154 NAPI_ASSERT(env, error != nullptr, "error succes");
155 bool isError = false;
156 napi_is_error(env, error, &isError);
157 NAPI_ASSERT(env, isError, "error succes");
158 napi_throw_type_error(env, NULL, "type error1");
159
160 napi_value _value;
161 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
162 return _value;
163 }
164
throwRangeError(napi_env env,napi_callback_info info)165 static napi_value throwRangeError(napi_env env, napi_callback_info info)
166 {
167 napi_value code = nullptr;
168 napi_value message = nullptr;
169 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
170 napi_create_string_latin1(env, "range error 500", NAPI_AUTO_LENGTH, &message);
171 napi_value error = nullptr;
172 napi_create_range_error(env, code, message, &error);
173 NAPI_ASSERT(env, error != nullptr, "error succes");
174 bool isError = false;
175 napi_is_error(env, error, &isError);
176 NAPI_ASSERT(env, isError, "error succes");
177 napi_throw_range_error(env, NULL, "range error");
178
179 napi_value _value;
180 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
181 return _value;
182 }
183
isError(napi_env env,napi_callback_info info)184 static napi_value isError(napi_env env, napi_callback_info info)
185 {
186 size_t argc = 1;
187 napi_value args[1];
188 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
189
190 bool r;
191 NAPI_CALL(env, napi_is_error(env, args[0], &r));
192
193 napi_value result;
194 NAPI_CALL(env, napi_get_boolean(env, r, &result));
195
196 return result;
197 }
198
createError(napi_env env,napi_callback_info info)199 static napi_value createError(napi_env env, napi_callback_info info)
200 {
201 napi_value code = nullptr;
202 napi_value message = nullptr;
203
204 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
205 napi_create_string_latin1(env, "common error", NAPI_AUTO_LENGTH, &message);
206
207 napi_value error = nullptr;
208 napi_create_error(env, code, message, &error);
209 NAPI_ASSERT(env, error != nullptr, "error succes");
210
211 napi_value _value;
212 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
213 return _value;
214 }
215
createTypeError(napi_env env,napi_callback_info info)216 static napi_value createTypeError(napi_env env, napi_callback_info info)
217 {
218 napi_value code = nullptr;
219 napi_value message = nullptr;
220 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
221 napi_create_string_latin1(env, "type error", NAPI_AUTO_LENGTH, &message);
222 napi_value error = nullptr;
223 napi_create_type_error(env, code, message, &error);
224 NAPI_ASSERT(env, error != nullptr, "error succes");
225
226 napi_value _value;
227 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
228 return _value;
229 }
230
createRangeError(napi_env env,napi_callback_info info)231 static napi_value createRangeError(napi_env env, napi_callback_info info)
232 {
233 napi_value code = nullptr;
234 napi_value message = nullptr;
235 napi_create_string_latin1(env, "500", NAPI_AUTO_LENGTH, &code);
236 napi_create_string_latin1(env, "range error", NAPI_AUTO_LENGTH, &message);
237 napi_value error = nullptr;
238 napi_create_range_error(env, code, message, &error);
239
240 NAPI_ASSERT(env, error != nullptr, "error succes");
241
242 napi_value _value;
243 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
244 return _value;
245 }
246
getAndClearLastException(napi_env env,napi_callback_info info)247 static napi_value getAndClearLastException(napi_env env, napi_callback_info info)
248 {
249 napi_value code = nullptr;
250 napi_value message = nullptr;
251 napi_create_string_latin1(env, "600", NAPI_AUTO_LENGTH, &code);
252 napi_create_string_latin1(env, "tag range error", NAPI_AUTO_LENGTH, &message);
253
254 napi_value error = nullptr;
255 napi_create_range_error(env, code, message, &error);
256 NAPI_ASSERT(env, error != nullptr, "tag error succes");
257
258 bool isError = false;
259 napi_is_error(env, error, &isError);
260 NAPI_ASSERT(env, isError, "tag isError 1");
261
262 napi_value ex;
263 napi_get_and_clear_last_exception(env, &ex);
264
265 bool exceptionWasPending = true;
266 napi_is_exception_pending(env, &exceptionWasPending);
267 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 1");
268
269 napi_throw(env, error);
270
271 napi_is_exception_pending(env, &exceptionWasPending);
272 NAPI_ASSERT(env, exceptionWasPending, "tag exceptionWasPending 2");
273
274 napi_value ex1;
275 napi_get_and_clear_last_exception(env, &ex1);
276 isError = false;
277 napi_is_error(env, ex1, &isError);
278 NAPI_ASSERT(env, isError, "tag isError 2");
279
280 napi_is_exception_pending(env, &exceptionWasPending);
281 NAPI_ASSERT(env, !exceptionWasPending, "tag !exceptionWasPending 3");
282
283 return ex1;
284 }
285
isExceptionPending(napi_env env,napi_callback_info info)286 static napi_value isExceptionPending(napi_env env, napi_callback_info info)
287 {
288 bool exceptionWasPending = false;
289 napi_is_exception_pending(env, &exceptionWasPending);
290
291 NAPI_ASSERT(env, exceptionWasPending, "error succes");
292
293 napi_value _value;
294 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
295 return _value;
296 }
297
openAndCloseHandleScope(napi_env env,napi_callback_info info)298 static napi_value openAndCloseHandleScope(napi_env env, napi_callback_info info)
299 {
300 napi_handle_scope scope;
301 NAPI_CALL(env, napi_open_handle_scope(env, &scope));
302 napi_value output = NULL;
303 NAPI_CALL(env, napi_create_object(env, &output));
304 NAPI_CALL(env, napi_close_handle_scope(env, scope));
305 return output;
306 }
307
openAndCloseEscapableHandleScope(napi_env env,napi_callback_info info)308 static napi_value openAndCloseEscapableHandleScope(napi_env env, napi_callback_info info)
309 {
310 napi_escapable_handle_scope scope;
311 NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
312 napi_value output = NULL;
313 napi_value escapee = NULL;
314 NAPI_CALL(env, napi_create_object(env, &output));
315 NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
316 NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
317 return escapee;
318 }
319
createReference(napi_env env,napi_callback_info info)320 static napi_value createReference(napi_env env, napi_callback_info info)
321 {
322 napi_value result = nullptr;
323
324 napi_create_int32(env, TAG_NUMBER, &result);
325 NAPI_CALL(env, napi_create_reference(env, result, 1, &test_reference));
326 napi_value value;
327 NAPI_CALL(env, napi_create_int32(env, 0, &value));
328 return value;
329 }
330
getAndDeleteReference(napi_env env,napi_callback_info info)331 static napi_value getAndDeleteReference(napi_env env, napi_callback_info info)
332 {
333 NAPI_ASSERT(env, test_reference != NULL,
334 "A reference must have been created.");
335
336 napi_value refValue = nullptr;
337 napi_get_reference_value(env, test_reference, &refValue);
338
339 int32_t value = 0;
340 napi_get_value_int32(env, refValue, &value);
341 NAPI_ASSERT(env, value == TAG_NUMBER,
342 "refValue expect equal to 666.");
343
344 NAPI_CALL(env, napi_delete_reference(env, test_reference));
345 test_reference = NULL;
346 return NULL;
347 }
348
referenceRefAndUnref(napi_env env,napi_callback_info info)349 static napi_value referenceRefAndUnref(napi_env env, napi_callback_info info)
350 {
351 napi_value result = nullptr;
352 napi_ref resultRef = nullptr;
353 uint32_t resultRefCount = 0;
354
355 napi_create_object(env, &result);
356 napi_create_reference(env, result, 1, &resultRef);
357
358 napi_reference_ref(env, resultRef, &resultRefCount);
359 NAPI_ASSERT(env, resultRefCount == 2,
360 "resultRefCount expect equal to 2");
361 napi_reference_unref(env, resultRef, &resultRefCount);
362 NAPI_ASSERT(env, resultRefCount == 1,
363 "resultRefCount expect equal to 1.");
364
365 napi_value refValue = nullptr;
366 napi_get_reference_value(env, resultRef, &refValue);
367 NAPI_ASSERT(env, refValue != NULL,
368 "A reference must have been created.");
369 napi_delete_reference(env, resultRef);
370
371 napi_value _value;
372 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
373
374 return _value;
375 }
376
createArrayAndGetLength(napi_env env,napi_callback_info info)377 static napi_value createArrayAndGetLength(napi_env env, napi_callback_info info)
378 {
379 size_t argc = 1;
380 napi_value args[1];
381 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
382
383 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
384
385 napi_valuetype valuetype0;
386 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
387
388 NAPI_ASSERT(env, valuetype0 == napi_object,
389 "Wrong type of arguments. Expects an array as first argument.");
390
391 napi_value ret;
392 NAPI_CALL(env, napi_create_array(env, &ret));
393
394 uint32_t i, length;
395 NAPI_CALL(env, napi_get_array_length(env, args[0], &length));
396
397 for (i = 0; i < length; i++) {
398 napi_value e;
399 NAPI_CALL(env, napi_get_element(env, args[0], i, &e));
400 NAPI_CALL(env, napi_set_element(env, ret, i, e));
401 }
402 return ret;
403 }
404
getArrayWithLength(napi_env env,napi_callback_info info)405 static napi_value getArrayWithLength(napi_env env, napi_callback_info info)
406 {
407 size_t argc = 1;
408 napi_value args[1];
409 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
410
411 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
412
413 napi_valuetype valuetype0;
414 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
415
416 NAPI_ASSERT(env, valuetype0 == napi_object,
417 "Wrong type of arguments. Expects an integer the first argument.");
418
419 uint32_t array_length = 0;
420 NAPI_CALL(env, napi_get_array_length(env, args[0], &array_length));
421 NAPI_ASSERT(env, array_length == 2, "array_length expect equal to 2");
422
423 napi_value ret;
424 NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret));
425 for (uint32_t i = 0; i < array_length * 2; i++) {
426 napi_value e;
427 NAPI_CALL(env, napi_create_uint32(env, i, &e));
428 NAPI_CALL(env, napi_set_element(env, ret, i, e));
429 }
430
431 return ret;
432 }
433
createExternal(napi_env env,napi_callback_info info)434 static napi_value createExternal(napi_env env, napi_callback_info info)
435 {
436 const char testStr[] = "test";
437 napi_value external = nullptr;
438 napi_create_external(
439 env, (void*)testStr,
440 [](napi_env env, void* data, void* hint) {},
441 (void*)testStr, &external);
442 void* tempExternal = nullptr;
443 NAPI_CALL(env, napi_get_value_external(env, external, &tempExternal));
444 NAPI_ASSERT(env, tempExternal != nullptr, "tempExternal expect not equal to nullptr");
445 NAPI_ASSERT(env, tempExternal == testStr, "tempExternal expect equal to testStr");
446
447 napi_value _value;
448 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
449
450 return _value;
451 }
452
createExternalArraybuffer(napi_env env,napi_callback_info info)453 static napi_value createExternalArraybuffer(napi_env env, napi_callback_info info)
454 {
455 int* testInt = (int*)malloc(sizeof(int));
456 *testInt = TAG_NUMBER;
457 napi_value external = nullptr;
458 size_t arrayBufferSize = 1024;
459
460 napi_create_external_arraybuffer(
461 env, (void*)testInt, arrayBufferSize,
462 [](napi_env env, void* data, void* hint) {
463 int* temp = static_cast<int*>(data);
464 free(temp);
465 temp = nullptr;
466 },
467 (void*)testInt, &external);
468
469 return external;
470 }
471
createObject(napi_env env,napi_callback_info info)472 static napi_value createObject(napi_env env, napi_callback_info info)
473 {
474 napi_value result = nullptr;
475 NAPI_CALL(env, napi_create_object(env, &result));
476 NAPI_ASSERT(env, result != nullptr, "napi_create_object");
477 return result;
478 }
479
createSymbol(napi_env env,napi_callback_info info)480 static napi_value createSymbol(napi_env env, napi_callback_info info)
481 {
482 size_t argc = 1;
483 napi_value args[1];
484 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
485
486 napi_value description = NULL;
487 if (argc >= 1) {
488 napi_valuetype valuetype;
489 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
490
491 NAPI_ASSERT(env, valuetype == napi_string,
492 "Wrong type of arguments. Expects a string.");
493
494 description = args[0];
495 }
496
497 napi_value symbol;
498 NAPI_CALL(env, napi_create_symbol(env, description, &symbol));
499
500 napi_valuetype valuetypeSymbol;
501 NAPI_CALL(env, napi_typeof(env, symbol, &valuetypeSymbol));
502
503 NAPI_ASSERT(env, valuetypeSymbol == napi_symbol,
504 "Wrong type of arguments. Expects a string.");
505 napi_value _value;
506 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
507
508 return _value;
509 }
510
createTypeArray(napi_env env,napi_callback_info info)511 static napi_value createTypeArray(napi_env env, napi_callback_info info)
512 {
513 napi_value arrayBuffer = nullptr;
514 void* arrayBufferPtr = nullptr;
515 size_t arrayBufferSize = 16;
516 size_t typedArrayLength = 4;
517 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
518
519 void* tmpArrayBufferPtr = nullptr;
520 size_t arrayBufferLength = 0;
521 napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
522
523 NAPI_ASSERT(env, arrayBufferPtr == tmpArrayBufferPtr, "napi_get_arraybuffer_info success");
524 NAPI_ASSERT(env, arrayBufferSize == arrayBufferLength, "napi_create_arraybuffer success");
525
526 napi_value _value;
527 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &_value);
528
529 return _value;
530 }
531
createDataView(napi_env env,napi_callback_info info)532 static napi_value createDataView(napi_env env, napi_callback_info info)
533 {
534 napi_value arrayBuffer = nullptr;
535 void* arrayBufferPtr = nullptr;
536 size_t arrayBufferSize = 16;
537 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
538 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "napi_create_arraybuffer success");
539 bool isArrayBuffer = false;
540 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
541 NAPI_ASSERT(env, isArrayBuffer, " napi_is_arraybuffer success");
542
543 napi_value result = nullptr;
544 NAPI_CALL(env, napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result));
545
546 bool isDataView = false;
547 napi_is_dataview(env, result, &isDataView);
548 NAPI_ASSERT(env, isDataView, " napi_is_dataview success");
549
550 return result;
551 }
552
createAndGetInt32(napi_env env,napi_callback_info info)553 static napi_value createAndGetInt32(napi_env env, napi_callback_info info)
554 {
555 size_t argc = 1;
556 napi_value args[1];
557 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
558
559 int32_t value;
560 NAPI_CALL(env, napi_get_value_int32(env, args[0], &value));
561
562 napi_value output;
563 NAPI_CALL(env, napi_create_int32(env, value, &output));
564
565 return output;
566 }
567
createAndGetUInt32(napi_env env,napi_callback_info info)568 static napi_value createAndGetUInt32(napi_env env, napi_callback_info info)
569 {
570 size_t argc = 1;
571 napi_value args[1];
572 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
573
574 uint32_t value;
575 NAPI_CALL(env, napi_get_value_uint32(env, args[0], &value));
576
577 napi_value output;
578 NAPI_CALL(env, napi_create_uint32(env, value, &output));
579
580 return output;
581 }
582
createAndGetInt64(napi_env env,napi_callback_info info)583 static napi_value createAndGetInt64(napi_env env, napi_callback_info info)
584 {
585 size_t argc = 1;
586 napi_value args[1];
587 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
588
589 int64_t value;
590 NAPI_CALL(env, napi_get_value_int64(env, args[0], &value));
591
592 napi_value output;
593 NAPI_CALL(env, napi_create_int64(env, (double)value, &output));
594
595 return output;
596 }
597
createDouble(napi_env env,napi_callback_info info)598 static napi_value createDouble(napi_env env, napi_callback_info info)
599 {
600 size_t argc = 1;
601 napi_value args[1];
602 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
603
604 double value;
605 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
606
607 napi_value output;
608 NAPI_CALL(env, napi_create_double(env, value, &output));
609
610 return output;
611 }
612
createAndGetStringLatin1(napi_env env,napi_callback_info info)613 static napi_value createAndGetStringLatin1(napi_env env, napi_callback_info info)
614 {
615 size_t argc = 1;
616 napi_value args[1];
617 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
618
619 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
620
621 napi_valuetype valuetype;
622 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
623
624 NAPI_ASSERT(env, valuetype == napi_string,
625 "Wrong type of argment. Expects a string.");
626
627 char buffer[128];
628 size_t buffer_size = 128;
629 size_t copied = 0;
630
631 NAPI_CALL(env,
632 napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
633 NAPI_ASSERT(env, copied == 3, "napi_get_value_string_latin1 fail");
634
635 napi_value output;
636 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
637
638 return output;
639 }
640
createAndGetStringUtf8(napi_env env,napi_callback_info info)641 static napi_value createAndGetStringUtf8(napi_env env, napi_callback_info info)
642 {
643 size_t argc = 1;
644 napi_value args[1];
645 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
646
647 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
648
649 napi_valuetype valuetype;
650 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
651
652 NAPI_ASSERT(env, valuetype == napi_string,
653 "Wrong type of argment. Expects a string.");
654
655 char buffer[128];
656 size_t buffer_size = 128;
657 size_t copied = 0;
658
659 NAPI_CALL(env,
660 napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
661 NAPI_ASSERT(env, copied == 2, "napi_get_value_string_utf8 fail");
662
663 napi_value output;
664 NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
665
666 return output;
667 }
668
getPrototype(napi_env env,napi_callback_info info)669 static napi_value getPrototype(napi_env env, napi_callback_info info)
670 {
671 napi_value testWrapClass = nullptr;
672 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
673 napi_value thisVar = nullptr;
674 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
675 return thisVar;
676 }, nullptr, 0, nullptr, &testWrapClass);
677
678 napi_value customClassPrototype = nullptr;
679 NAPI_CALL(env, napi_get_prototype(env, testWrapClass, &customClassPrototype));
680 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
681
682 return customClassPrototype;
683 }
684
getPrototype2(napi_env env,napi_callback_info info)685 static napi_value getPrototype2(napi_env env, napi_callback_info info)
686 {
687 size_t argc = 1;
688 napi_value args[1];
689 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
690
691 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
692
693 napi_valuetype valuetype;
694 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
695
696 NAPI_ASSERT(env, valuetype == napi_function,
697 "Wrong type of argment. Expects a napi_function.");
698
699 napi_value customClassPrototype = nullptr;
700 NAPI_CALL(env, napi_get_prototype(env, args[0], &customClassPrototype));
701 NAPI_ASSERT(env, customClassPrototype != nullptr, "napi_get_prototype fail");
702
703 return customClassPrototype;
704 }
705
getTypedArrayInfo(napi_env env,napi_callback_info info)706 static napi_value getTypedArrayInfo(napi_env env, napi_callback_info info)
707 {
708 napi_value arrayBuffer = nullptr;
709 void* arrayBufferPtr = nullptr;
710 size_t arrayBufferSize = 16;
711 size_t typedArrayLength = 4;
712 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
713 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getTypedArrayInfo napi_create_arraybuffer fail");
714 bool isArrayBuffer = false;
715 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
716 NAPI_ASSERT(env, isArrayBuffer, "getTypedArrayInfo napi_is_arraybuffer fail");
717 napi_value result;
718 napi_create_typedarray(env, napi_int32_array, typedArrayLength, arrayBuffer, 0, &result);
719
720 bool isTypedArray = false;
721 napi_is_typedarray(env, result, &isTypedArray);
722 NAPI_ASSERT(env, isTypedArray, "getTypedArrayInfo napi_is_dataview fail");
723
724 napi_typedarray_type type;
725 size_t length = 0;
726 void* data = nullptr;
727 napi_value retArrayBuffer;
728 size_t byteOffset = -1;
729 NAPI_CALL(env, napi_get_typedarray_info(env, result, &type, &length, &data, &retArrayBuffer, &byteOffset));
730 NAPI_ASSERT(env, type == napi_int32_array, "napi_get_typedarray_info success 0");
731 NAPI_ASSERT(env, length == arrayBufferSize, "napi_get_typedarray_info success 1");
732 NAPI_ASSERT(env, data == arrayBufferPtr, "napi_get_dataview_info success 2");
733
734 bool retIsArrayBuffer = false;
735 NAPI_CALL(env, napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer));
736 void* tmpArrayBufferPtr = nullptr;
737 size_t arrayBufferLength = 0;
738 NAPI_CALL(env, napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength));
739
740 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 3");
741
742 napi_value _value;
743 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
744 return _value;
745 }
746
getDataViewInfo(napi_env env,napi_callback_info info)747 static napi_value getDataViewInfo(napi_env env, napi_callback_info info)
748 {
749 napi_value arrayBuffer = nullptr;
750 void* arrayBufferPtr = nullptr;
751 size_t arrayBufferSize = 1024;
752 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
753 NAPI_ASSERT(env, arrayBufferPtr != nullptr, "getDataViewInfo napi_create_arraybuffer fail");
754 bool isArrayBuffer = false;
755 napi_is_arraybuffer(env, arrayBuffer, &isArrayBuffer);
756 NAPI_ASSERT(env, isArrayBuffer, "getDataViewInfo napi_is_arraybuffer fail");
757 napi_value result = nullptr;
758 napi_create_dataview(env, arrayBufferSize, arrayBuffer, 0, &result);
759
760 bool isDataView = false;
761 napi_is_dataview(env, result, &isDataView);
762 NAPI_ASSERT(env, isDataView, "getDataViewInfo napi_is_dataview fail");
763
764 napi_value retArrayBuffer = nullptr;
765 void* data = nullptr;
766 size_t byteLength = 0;
767 size_t byteOffset = -1;
768 napi_get_dataview_info(env, result, &byteLength, &data, &retArrayBuffer, &byteOffset);
769
770 bool retIsArrayBuffer = false;
771 napi_is_arraybuffer(env, retArrayBuffer, &retIsArrayBuffer);
772 void* tmpArrayBufferPtr = nullptr;
773 size_t arrayBufferLength = 0;
774 napi_get_arraybuffer_info(env, retArrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
775
776 NAPI_ASSERT(env, arrayBufferLength == arrayBufferSize, "napi_get_dataview_info success 0");
777 NAPI_ASSERT(env, arrayBufferPtr == data, "napi_get_dataview_info success 1");
778 NAPI_ASSERT(env, byteOffset == 0, "napi_get_dataview_info success 2");
779
780 napi_value _value;
781 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
782 return _value;
783 }
784
getValueBool(napi_env env,napi_callback_info info)785 static napi_value getValueBool(napi_env env, napi_callback_info info)
786 {
787 size_t argc = 1;
788 napi_value args[1];
789 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
790
791 bool value;
792 NAPI_CALL(env, napi_get_value_bool(env, args[0], &value));
793
794 napi_value output;
795 NAPI_CALL(env, napi_get_boolean(env, value, &output));
796
797 return output;
798 }
799
getValueDouble(napi_env env,napi_callback_info info)800 static napi_value getValueDouble(napi_env env, napi_callback_info info)
801 {
802 size_t argc = 1;
803 napi_value args[1];
804 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
805
806 double value;
807 NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
808
809 napi_value output;
810 NAPI_CALL(env, napi_create_double(env, value, &output));
811
812 return output;
813 }
814
getValueExternal(napi_env env,napi_callback_info info)815 static napi_value getValueExternal(napi_env env, napi_callback_info info)
816 {
817 const char testStr[] = "test";
818 napi_value external = nullptr;
819 napi_create_external(
820 env, (void*)testStr,
821 [](napi_env env, void* data, void* hint) {},
822 (void*)testStr, &external);
823 void* tempExternal = nullptr;
824 napi_get_value_external(env, external, &tempExternal);
825
826 NAPI_ASSERT(env, tempExternal == testStr, "napi_get_value_external true");
827
828 napi_value _value;
829 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
830
831 return _value;
832 }
833
getNull(napi_env env,napi_callback_info info)834 static napi_value getNull(napi_env env, napi_callback_info info)
835 {
836 napi_value result = nullptr;
837 NAPI_CALL(env, napi_get_null(env, &result));
838 NAPI_ASSERT(env, result != nullptr, "napi_get_null success");
839 napi_valuetype type;
840 NAPI_CALL(env, napi_typeof(env, result, &type));
841 NAPI_ASSERT(env, type == napi_null, "napi_get_null fail");
842
843 napi_value _value;
844 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
845
846 return _value;
847 }
848
getUndefined(napi_env env,napi_callback_info info)849 static napi_value getUndefined(napi_env env, napi_callback_info info)
850 {
851 napi_value result = nullptr;
852 NAPI_CALL(env, napi_get_undefined(env, &result));
853 NAPI_ASSERT(env, result != nullptr, "napi_get_undefined success");
854 napi_valuetype type;
855 NAPI_CALL(env, napi_typeof(env, result, &type));
856 NAPI_ASSERT(env, type == napi_undefined, "napi_get_undefined fail");
857
858 napi_value _value;
859 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
860
861 return _value;
862 }
863
coerceToBool(napi_env env,napi_callback_info info)864 static napi_value coerceToBool(napi_env env, napi_callback_info info)
865 {
866 size_t argc = 1;
867 napi_value args[1];
868 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
869
870 napi_value output;
871 NAPI_CALL(env, napi_coerce_to_bool(env, args[0], &output));
872
873 return output;
874 }
875
coerceToNumber(napi_env env,napi_callback_info info)876 static napi_value coerceToNumber(napi_env env, napi_callback_info info)
877 {
878 size_t argc = 1;
879 napi_value args[1];
880 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
881
882 napi_value output;
883 NAPI_CALL(env, napi_coerce_to_number(env, args[0], &output));
884
885 return output;
886 }
887
coerceToObject(napi_env env,napi_callback_info info)888 static napi_value coerceToObject(napi_env env, napi_callback_info info)
889 {
890 size_t argc = 1;
891 napi_value args[1];
892 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
893
894 napi_value output;
895 NAPI_CALL(env, napi_coerce_to_object(env, args[0], &output));
896
897 return output;
898 }
899
coerceToString(napi_env env,napi_callback_info info)900 static napi_value coerceToString(napi_env env, napi_callback_info info)
901 {
902 size_t argc = 1;
903 napi_value args[1];
904 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
905
906 napi_value output;
907 NAPI_CALL(env, napi_coerce_to_string(env, args[0], &output));
908
909 return output;
910 }
911
instanceOf(napi_env env,napi_callback_info info)912 static napi_value instanceOf(napi_env env, napi_callback_info info)
913 {
914 napi_value customClass = nullptr;
915
916 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH,
917 [](napi_env env, napi_callback_info info) -> napi_value {
918 napi_value thisVar = nullptr;
919 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
920 return thisVar;
921 }, nullptr, 0, nullptr, &customClass);
922
923 napi_value customClassPrototype = nullptr;
924 napi_get_prototype(env, customClass, &customClassPrototype);
925
926 napi_value customInstance = nullptr;
927 NAPI_CALL(env, napi_new_instance(env, customClass, 0, nullptr, &customInstance));
928
929 bool isInstanceOf = false;
930 NAPI_CALL(env, napi_instanceof(env, customInstance, customClass, &isInstanceOf));
931
932 NAPI_ASSERT(env, isInstanceOf, "isInstanceOf success");
933
934 napi_value result;
935 NAPI_CALL(env, napi_get_boolean(env, isInstanceOf, &result));
936
937 return result;
938 }
939
isArray(napi_env env,napi_callback_info info)940 static napi_value isArray(napi_env env, napi_callback_info info)
941 {
942 napi_value array = nullptr;
943 napi_create_array(env, &array);
944 NAPI_ASSERT(env, array != nullptr, "napi_get_undefined success");
945 bool isArray = false;
946 napi_is_array(env, array, &isArray);
947 NAPI_ASSERT(env, isArray, "napi_is_arrayd success");
948
949 napi_value _value;
950 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
951 return _value;
952 }
953
isDate(napi_env env,napi_callback_info info)954 static napi_value isDate(napi_env env, napi_callback_info info)
955 {
956 napi_value date, result;
957 size_t argc = 1;
958 bool is_date = false;
959
960 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &date, NULL, NULL));
961 NAPI_CALL(env, napi_is_date(env, date, &is_date));
962 NAPI_CALL(env, napi_get_boolean(env, is_date, &result));
963
964 return result;
965 }
966
strictEquals(napi_env env,napi_callback_info info)967 static napi_value strictEquals(napi_env env, napi_callback_info info)
968 {
969 const char* testStringStr = "test";
970 napi_value testString = nullptr;
971 napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
972 bool isStrictEquals = false;
973 napi_strict_equals(env, testString, testString, &isStrictEquals);
974 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 0");
975
976 napi_value testObject = nullptr;
977 napi_create_object(env, &testObject);
978 isStrictEquals = false;
979 napi_strict_equals(env, testObject, testObject, &isStrictEquals);
980 NAPI_ASSERT(env, isStrictEquals, "napi_strict_equals success 1");
981
982 napi_value napi_number1 = nullptr;
983 napi_value napi_number2 = nullptr;
984 napi_create_double(env, 10.1, &napi_number1);
985 napi_create_int32(env, 10, &napi_number2);
986 isStrictEquals = true;
987 napi_strict_equals(env, napi_number1, napi_number2, &isStrictEquals);
988 NAPI_ASSERT(env, !isStrictEquals, "napi_strict_equals success 2");
989
990 napi_value _value;
991 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
992 return _value;
993 }
994
getPropertyNames(napi_env env,napi_callback_info info)995 static napi_value getPropertyNames(napi_env env, napi_callback_info info)
996 {
997 napi_value result = nullptr;
998 NAPI_CALL(env, napi_create_object(env, &result));
999
1000 NAPI_ASSERT(env, result != nullptr, "napi_create_object success");
1001
1002 const char testStr[] = "1234567";
1003 napi_value strAttribute = nullptr;
1004
1005 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1006 NAPI_ASSERT(env, strAttribute != nullptr, "napi_create_string_utf8 success");
1007
1008 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1009 bool hasNamedProperty = false;
1010 NAPI_CALL(env, napi_has_named_property(env, result, "strAttribute", &hasNamedProperty));
1011 NAPI_ASSERT(env, hasNamedProperty, "napi_has_named_property fail");
1012
1013 napi_value retStrAttribute = nullptr;
1014 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1015 NAPI_ASSERT(env, retStrAttribute != nullptr, "napi_get_named_property success");
1016 napi_valuetype type;
1017 NAPI_CALL(env, napi_typeof(env, retStrAttribute, &type));
1018 NAPI_ASSERT(env, type == napi_string, "napi_get_named_property fail");
1019 napi_value res;
1020 napi_coerce_to_number(env, retStrAttribute, &res);
1021 int32_t num = 0;
1022 napi_get_value_int32(env, res, &num);
1023 NAPI_ASSERT(env, num == 1234567, "getPropertyNames fail");
1024
1025 napi_value _value;
1026 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1027 return _value;
1028 }
1029
setProperty(napi_env env,napi_callback_info info)1030 static napi_value setProperty(napi_env env,
1031 napi_callback_info info)
1032 {
1033 napi_status status;
1034 napi_value object, key, value;
1035
1036 NAPI_CALL(env, napi_create_object(env, &object));
1037
1038 NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
1039
1040 NAPI_CALL(env, napi_create_object(env, &value));
1041
1042 status = napi_set_property(NULL, object, key, value);
1043
1044 add_returned_status(env,
1045 "envIsNull",
1046 object,
1047 "Invalid argument",
1048 napi_invalid_arg,
1049 status);
1050
1051 napi_set_property(env, NULL, key, value);
1052
1053 add_last_status(env, "objectIsNull", object);
1054
1055 napi_set_property(env, object, NULL, value);
1056
1057 add_last_status(env, "keyIsNull", object);
1058
1059 napi_set_property(env, object, key, NULL);
1060
1061 add_last_status(env, "valueIsNull", object);
1062
1063 return object;
1064 }
1065
getProperty(napi_env env,napi_callback_info info)1066 static napi_value getProperty(napi_env env,
1067 napi_callback_info info)
1068 {
1069 napi_status status;
1070 napi_value object, key, result;
1071
1072 NAPI_CALL(env, napi_create_object(env, &object));
1073
1074 NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &key));
1075
1076 NAPI_CALL(env, napi_create_object(env, &result));
1077
1078 status = napi_get_property(NULL, object, key, &result);
1079
1080 add_returned_status(env,
1081 "envIsNull",
1082 object,
1083 "Invalid argument",
1084 napi_invalid_arg,
1085 status);
1086
1087 napi_get_property(env, NULL, key, &result);
1088
1089 add_last_status(env, "objectIsNull", object);
1090
1091 napi_get_property(env, object, NULL, &result);
1092
1093 add_last_status(env, "keyIsNull", object);
1094
1095 napi_get_property(env, object, key, NULL);
1096
1097 add_last_status(env, "resultIsNull", object);
1098
1099 return object;
1100 }
1101
hasProperty(napi_env env,napi_callback_info info)1102 static napi_value hasProperty(napi_env env, napi_callback_info info)
1103 {
1104 napi_value result = nullptr;
1105 NAPI_CALL(env, napi_create_object(env, &result));
1106
1107 const char testStr[] = "1234567";
1108 napi_value strAttribute = nullptr;
1109 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
1110 NAPI_CALL(env, napi_set_named_property(env, result, "strAttribute", strAttribute));
1111
1112 napi_value retStrAttribute = nullptr;
1113 NAPI_CALL(env, napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
1114
1115 int32_t testNumber = 12345;
1116 napi_value numberAttribute = nullptr;
1117 NAPI_CALL(env, napi_create_int32(env, testNumber, &numberAttribute));
1118 NAPI_CALL(env, napi_set_named_property(env, result, "numberAttribute", numberAttribute));
1119
1120 napi_value propNames = nullptr;
1121 NAPI_CALL(env, napi_get_property_names(env, result, &propNames));
1122 NAPI_ASSERT(env, propNames != nullptr, "napi_get_property_names success");
1123
1124 bool isArray = false;
1125 NAPI_CALL(env, napi_is_array(env, propNames, &isArray));
1126 NAPI_ASSERT(env, isArray, "napi_is_array success");
1127
1128 uint32_t arrayLength = 0;
1129 NAPI_CALL(env, napi_get_array_length(env, propNames, &arrayLength));
1130
1131 for (uint32_t i = 0; i < arrayLength; i++) {
1132 bool hasElement = false;
1133 NAPI_CALL(env, napi_has_element(env, propNames, i, &hasElement));
1134 NAPI_ASSERT(env, hasElement, "napi_has_element success");
1135
1136 napi_value propName = nullptr;
1137 NAPI_CALL(env, napi_get_element(env, propNames, i, &propName));
1138 NAPI_ASSERT(env, propName != nullptr, "napi_get_element success");
1139
1140 bool hasProp = false;
1141 napi_has_property(env, result, propName, &hasProp);
1142 NAPI_ASSERT(env, hasProp, "napi_get_element success");
1143
1144 napi_value propValue = nullptr;
1145 napi_get_property(env, result, propName, &propValue);
1146 NAPI_ASSERT(env, propValue != nullptr, "napi_get_property success");
1147 }
1148
1149 bool deletion = false;
1150 NAPI_CALL(env, napi_delete_element(env, propNames, 1, &deletion));
1151 NAPI_ASSERT(env, deletion, "napi_delete_element fail");
1152 bool hasElement = true;
1153 NAPI_CALL(env, napi_has_element(env, propNames, 1, &hasElement));
1154 NAPI_ASSERT(env, !hasElement, "napi_has_element fail");
1155
1156 napi_value _value;
1157 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1158 return _value;
1159 }
1160
setAndDeleteProperty(napi_env env,napi_callback_info info)1161 static napi_value setAndDeleteProperty(napi_env env, napi_callback_info info)
1162 {
1163 size_t argc = 2;
1164 napi_value args[2];
1165
1166 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1167 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1168
1169 napi_valuetype valuetype0;
1170 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1171 NAPI_ASSERT(env, valuetype0 == napi_object,
1172 "Wrong type of arguments. Expects an object as first argument.");
1173
1174 napi_valuetype valuetype1;
1175 NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
1176 NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
1177 "Wrong type of arguments. Expects a string or symbol as second.");
1178
1179 const char testStr[] = "cKey";
1180 napi_value cKey;
1181 napi_value cValue;
1182 NAPI_CALL(env, napi_create_string_utf8(env, testStr, strlen(testStr), &cKey));
1183 NAPI_CALL(env, napi_create_int32(env, 3, &cValue));
1184 NAPI_CALL(env, napi_set_property(env, args[0], cKey, cValue));
1185
1186 bool hasProp = false;
1187 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1188 NAPI_ASSERT(env, hasProp, "setAndDeleteProperty napi_has_property fail 1");
1189
1190 bool result;
1191 napi_value ret;
1192 NAPI_CALL(env, napi_delete_property(env, args[0], cKey, &result));
1193 NAPI_CALL(env, napi_get_boolean(env, result, &ret));
1194 NAPI_CALL(env, napi_has_property(env, args[0], cKey, &hasProp));
1195 NAPI_ASSERT(env, !hasProp, "setAndDeleteProperty napi_has_property fail 2");
1196
1197 napi_value _value;
1198 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1199 return _value;
1200 }
1201
hasOwnProperty(napi_env env,napi_callback_info info)1202 static napi_value hasOwnProperty(napi_env env, napi_callback_info info)
1203 {
1204 size_t argc = 2;
1205 napi_value args[2];
1206 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1207
1208 NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
1209
1210 napi_valuetype valuetype0;
1211 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
1212
1213 NAPI_ASSERT(env, valuetype0 == napi_object,
1214 "Wrong type of arguments. Expects an object as first argument.");
1215
1216 bool has_property;
1217 NAPI_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property));
1218
1219 napi_value ret;
1220 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1221
1222 return ret;
1223 }
1224
setNamedProperty(napi_env env,napi_callback_info info)1225 static napi_value setNamedProperty(napi_env env, napi_callback_info info)
1226 {
1227 size_t argc = 3;
1228 napi_value args[3];
1229 char key[256] = "";
1230 size_t key_length;
1231 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1232
1233 NAPI_ASSERT(env, argc >= 3, "Wrong number of arguments");
1234
1235 napi_valuetype value_type0;
1236 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1237
1238 NAPI_ASSERT(env, value_type0 == napi_object,
1239 "Wrong type of arguments. Expects an object as first argument.");
1240
1241 napi_valuetype value_type1;
1242 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1243
1244 NAPI_ASSERT(env, value_type1 == napi_string,
1245 "Wrong type of arguments. Expects a string as second.");
1246
1247 NAPI_CALL(env,
1248 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1249 key[255] = 0;
1250 NAPI_ASSERT(env, key_length <= 255,
1251 "Cannot accommodate keys longer than 255 bytes");
1252
1253 NAPI_CALL(env, napi_set_named_property(env, args[0], key, args[2]));
1254
1255 napi_value value_true;
1256 NAPI_CALL(env, napi_get_boolean(env, true, &value_true));
1257
1258 return value_true;
1259 }
1260
getNamedProperty(napi_env env,napi_callback_info info)1261 static napi_value getNamedProperty(napi_env env, napi_callback_info info)
1262 {
1263 size_t argc = 2;
1264 napi_value args[2];
1265 char key[256] = "";
1266 size_t key_length;
1267 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1268
1269 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1270
1271 napi_valuetype value_type0;
1272 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1273
1274 NAPI_ASSERT(env, value_type0 == napi_object,
1275 "Wrong type of arguments. Expects an object as first argument.");
1276
1277 napi_valuetype value_type1;
1278 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1279
1280 NAPI_ASSERT(env, value_type1 == napi_string,
1281 "Wrong type of arguments. Expects a string as second.");
1282
1283 napi_value object = args[0];
1284 NAPI_CALL(env,
1285 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1286 key[255] = 0;
1287 NAPI_ASSERT(env, key_length <= 255,
1288 "Cannot accommodate keys longer than 255 bytes");
1289 napi_value output;
1290 NAPI_CALL(env, napi_get_named_property(env, object, key, &output));
1291
1292 return output;
1293 }
1294
hasNamedProperty(napi_env env,napi_callback_info info)1295 static napi_value hasNamedProperty(napi_env env, napi_callback_info info)
1296 {
1297 size_t argc = 2;
1298 napi_value args[2];
1299 char key[256] = "";
1300 size_t key_length;
1301 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1302
1303 NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
1304
1305 napi_valuetype value_type0;
1306 NAPI_CALL(env, napi_typeof(env, args[0], &value_type0));
1307
1308 NAPI_ASSERT(env, value_type0 == napi_object,
1309 "Wrong type of arguments. Expects an object as first argument.");
1310
1311 napi_valuetype value_type1;
1312 NAPI_CALL(env, napi_typeof(env, args[1], &value_type1));
1313
1314 NAPI_ASSERT(env, value_type1 == napi_string || value_type1 == napi_symbol,
1315 "Wrong type of arguments. Expects a string as second.");
1316
1317 NAPI_CALL(env,
1318 napi_get_value_string_utf8(env, args[1], key, 255, &key_length));
1319 key[255] = 0;
1320 NAPI_ASSERT(env, key_length <= 255,
1321 "Cannot accommodate keys longer than 255 bytes");
1322
1323 bool has_property;
1324 NAPI_CALL(env, napi_has_named_property(env, args[0], key, &has_property));
1325
1326 napi_value ret;
1327 NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
1328
1329 return ret;
1330 }
1331
setElement(napi_env env,napi_callback_info info)1332 static napi_value setElement(napi_env env, napi_callback_info info)
1333 {
1334 napi_value return_value, object;
1335
1336 NAPI_CALL(env, napi_create_object(env, &return_value));
1337 NAPI_CALL(env, napi_create_object(env, &object));
1338
1339 add_returned_status(env,
1340 "envIsNull",
1341 return_value,
1342 "Invalid argument",
1343 napi_invalid_arg,
1344 napi_set_element(NULL, object, 0, object));
1345
1346 napi_set_element(env, NULL, 0, object);
1347 add_last_status(env, "objectIsNull", return_value);
1348
1349
1350 napi_set_property(env, object, 0, NULL);
1351 add_last_status(env, "valueIsNull", return_value);
1352
1353 return return_value;
1354 }
1355
getElement(napi_env env,napi_callback_info info)1356 static napi_value getElement(napi_env env, napi_callback_info info)
1357 {
1358 napi_value return_value, object, prop;
1359
1360 NAPI_CALL(env, napi_create_object(env, &return_value));
1361 NAPI_CALL(env, napi_create_object(env, &object));
1362
1363 add_returned_status(env,
1364 "envIsNull",
1365 return_value,
1366 "Invalid argument",
1367 napi_invalid_arg,
1368 napi_get_element(NULL, object, 0, &prop));
1369
1370 napi_get_property(env, NULL, 0, &prop);
1371 add_last_status(env, "objectIsNull", return_value);
1372
1373 napi_get_property(env, object, 0, NULL);
1374 add_last_status(env, "valueIsNull", return_value);
1375
1376 return return_value;
1377 }
1378
TestBoolValuedElementApi(napi_env env,napi_status (* api)(napi_env,napi_value,uint32_t,bool *))1379 static napi_value TestBoolValuedElementApi(napi_env env,
1380 napi_status (* api)(napi_env, napi_value, uint32_t, bool*))
1381 {
1382 napi_value return_value, object;
1383 bool result;
1384
1385 NAPI_CALL(env, napi_create_object(env, &return_value));
1386 NAPI_CALL(env, napi_create_object(env, &object));
1387
1388 add_returned_status(env,
1389 "envIsNull",
1390 return_value,
1391 "Invalid argument",
1392 napi_invalid_arg,
1393 api(NULL, object, 0, &result));
1394
1395 api(env, NULL, 0, &result);
1396 add_last_status(env, "objectIsNull", return_value);
1397
1398 api(env, object, 0, NULL);
1399 add_last_status(env, "valueIsNull", return_value);
1400
1401 return return_value;
1402 }
1403
hasElement(napi_env env,napi_callback_info info)1404 static napi_value hasElement(napi_env env, napi_callback_info info)
1405 {
1406 return TestBoolValuedElementApi(env, napi_has_element);
1407 }
1408
deleteElement(napi_env env,napi_callback_info info)1409 static napi_value deleteElement(napi_env env, napi_callback_info info)
1410 {
1411 return TestBoolValuedElementApi(env, napi_delete_element);
1412 }
1413
defineProperties(napi_env env,napi_callback_info info)1414 static napi_value defineProperties(napi_env env, napi_callback_info info)
1415 {
1416 napi_value object, return_value;
1417
1418 napi_property_descriptor desc = {"prop", NULL, defineProperties, NULL, NULL, NULL, napi_enumerable, NULL};
1419
1420 NAPI_CALL(env, napi_create_object(env, &object));
1421 NAPI_CALL(env, napi_create_object(env, &return_value));
1422
1423 add_returned_status(env,
1424 "envIsNull",
1425 return_value,
1426 "Invalid argument",
1427 napi_invalid_arg,
1428 napi_define_properties(NULL, object, 1, &desc));
1429
1430 napi_define_properties(env, NULL, 1, &desc);
1431 add_last_status(env, "objectIsNull", return_value);
1432
1433 napi_define_properties(env, object, 1, NULL);
1434 add_last_status(env, "descriptorListIsNull", return_value);
1435
1436 desc.utf8name = NULL;
1437 napi_define_properties(env, object, 1, NULL);
1438 add_last_status(env, "utf8nameIsNull", return_value);
1439 desc.utf8name = "prop";
1440
1441 desc.method = NULL;
1442 napi_define_properties(env, object, 1, NULL);
1443 add_last_status(env, "methodIsNull", return_value);
1444 desc.method = defineProperties;
1445
1446 return return_value;
1447 }
1448
MyConstructor(napi_env env,napi_callback_info info)1449 static napi_value MyConstructor(napi_env env, napi_callback_info info)
1450 {
1451 napi_value thisVar = nullptr;
1452 size_t argc = 0;
1453 napi_value constructor = nullptr;
1454 napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr);
1455 napi_get_new_target(env, info, &constructor);
1456 if (constructor == nullptr) {
1457 napi_throw_error(env, nullptr, "is not new instance");
1458 }
1459 return thisVar;
1460 }
1461
wrap(napi_env env,napi_callback_info info)1462 static napi_value wrap(napi_env env, napi_callback_info info)
1463 {
1464 napi_value testClass = nullptr;
1465 napi_define_class(
1466 env, "TestClass", NAPI_AUTO_LENGTH,
1467 [](napi_env env, napi_callback_info info) -> napi_value {
1468 napi_value thisVar = nullptr;
1469 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1470
1471 return thisVar;
1472 },
1473 nullptr, 0, nullptr, &testClass);
1474
1475 napi_value instanceValue = nullptr;
1476 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1477
1478 const char* testStr = "test";
1479 napi_wrap(
1480 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1481
1482 napi_value _value;
1483 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1484 return _value;
1485 }
1486
unwrap(napi_env env,napi_callback_info info)1487 static napi_value unwrap(napi_env env, napi_callback_info info)
1488 {
1489 napi_value testClass = nullptr;
1490 napi_define_class(
1491 env, "TestClass", NAPI_AUTO_LENGTH,
1492 [](napi_env env, napi_callback_info info) -> napi_value {
1493 napi_value thisVar = nullptr;
1494 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1495
1496 return thisVar;
1497 },
1498 nullptr, 0, nullptr, &testClass);
1499
1500 napi_value instanceValue = nullptr;
1501 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1502
1503 const char* testStr = "test";
1504 napi_wrap(
1505 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1506
1507 const char* tmpTestStr = nullptr;
1508 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1509 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1510
1511 napi_value _value;
1512 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1513 return _value;
1514 }
1515
removeWrap(napi_env env,napi_callback_info info)1516 static napi_value removeWrap(napi_env env, napi_callback_info info)
1517 {
1518 napi_value testClass = nullptr;
1519 napi_define_class(
1520 env, "TestClass", NAPI_AUTO_LENGTH,
1521 [](napi_env env, napi_callback_info info) -> napi_value {
1522 napi_value thisVar = nullptr;
1523 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1524
1525 return thisVar;
1526 },
1527 nullptr, 0, nullptr, &testClass);
1528
1529 napi_value instanceValue = nullptr;
1530 napi_new_instance(env, testClass, 0, nullptr, &instanceValue);
1531
1532 const char* testStr = "test";
1533 napi_wrap(
1534 env, instanceValue, (void*)testStr, [](napi_env env, void* data, void* hint) {}, nullptr, nullptr);
1535
1536 const char* tmpTestStr = nullptr;
1537 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr));
1538 NAPI_ASSERT(env, tmpTestStr == testStr, "napi_unwrap fail");
1539
1540 const char* tmpTestStr1 = nullptr;
1541 napi_remove_wrap(env, instanceValue, (void**)&tmpTestStr1);
1542 NAPI_ASSERT(env, tmpTestStr1 == testStr, "napi_remove_wrap fail 1");
1543
1544 NAPI_CALL(env, napi_unwrap(env, instanceValue, (void**)&tmpTestStr1));
1545 NAPI_ASSERT(env, tmpTestStr1 == nullptr, "napi_remove_wrap fail");
1546
1547 napi_value _value;
1548 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1549 return _value;
1550 }
1551
getVersion(napi_env env,napi_callback_info info)1552 static napi_value getVersion(napi_env env, napi_callback_info info)
1553 {
1554 uint32_t version;
1555 napi_value result;
1556 NAPI_CALL(env, napi_get_version(env, &version));
1557 NAPI_CALL(env, napi_create_uint32(env, version, &result));
1558 return result;
1559 }
1560
createPromise(napi_env env,napi_callback_info info)1561 static napi_value createPromise(napi_env env, napi_callback_info info)
1562 {
1563 napi_deferred deferred = nullptr;
1564 napi_value promise = nullptr;
1565 napi_create_promise(env, &deferred, &promise);
1566 NAPI_ASSERT(env, deferred != nullptr, "create promise success");
1567 NAPI_ASSERT(env, promise != nullptr, "create promise success");
1568
1569 napi_value _value;
1570 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1571 return _value;
1572 }
1573
resolveAndRejectDeferred(napi_env env,napi_callback_info info)1574 static napi_value resolveAndRejectDeferred(napi_env env, napi_callback_info info)
1575 {
1576 napi_deferred deferred = nullptr;
1577 napi_value promise = nullptr;
1578 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1579
1580 bool isPromise = false;
1581 napi_is_promise(env, promise, &isPromise);
1582
1583 napi_value undefined = nullptr;
1584 napi_get_undefined(env, &undefined);
1585 NAPI_CALL(env, napi_resolve_deferred(env, deferred, undefined));
1586
1587 napi_value _value;
1588 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1589 return _value;
1590 }
1591
isPromise(napi_env env,napi_callback_info info)1592 static napi_value isPromise(napi_env env, napi_callback_info info)
1593 {
1594 napi_deferred deferred = nullptr;
1595 napi_value promise = nullptr;
1596 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1597
1598 bool isPromise = false;
1599 NAPI_CALL(env, napi_is_promise(env, promise, &isPromise));
1600 NAPI_ASSERT(env, isPromise, "napi_is_promise success");
1601
1602 napi_value _value;
1603 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1604 return _value;
1605 }
1606
runScript(napi_env env,napi_callback_info info)1607 static napi_value runScript(napi_env env, napi_callback_info info)
1608 {
1609 napi_value script, result;
1610 size_t argc = 1;
1611
1612 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &script, NULL, NULL));
1613
1614 NAPI_CALL(env, napi_run_script(env, script, &result));
1615
1616 return result;
1617 }
1618
getUvEventLoop(napi_env env,napi_callback_info info)1619 static napi_value getUvEventLoop(napi_env env, napi_callback_info info)
1620 {
1621 struct uv_loop_s* loop = nullptr;
1622
1623 NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
1624 NAPI_ASSERT(env, loop != nullptr, "napi_get_uv_event_loop fail");
1625
1626 return nullptr;
1627 }
1628
TestLatin1(napi_env env,napi_callback_info info)1629 static napi_value TestLatin1(napi_env env, napi_callback_info info)
1630 {
1631 size_t argc = 1;
1632 napi_value args[1];
1633 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
1634
1635 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1636
1637 napi_valuetype valuetype;
1638 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1639
1640 NAPI_ASSERT(env, valuetype == napi_string,
1641 "Wrong type of argment. Expects a string.");
1642
1643 char buffer[128];
1644 size_t buffer_size = 128;
1645 size_t copied;
1646
1647 NAPI_CALL(env,
1648 napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
1649
1650 napi_value output;
1651 NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
1652
1653 return output;
1654 }
1655 // test the napi function
napCreateArrayBuffer(napi_env env,napi_callback_info info)1656 static napi_value napCreateArrayBuffer(napi_env env, napi_callback_info info)
1657 {
1658 napi_value arrayBuffer = nullptr;
1659 void* arrayBufferPtr = nullptr;
1660 size_t arrayBufferSize = 1024;
1661 napi_status status = napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
1662 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1663 NAPI_ASSERT(env, arrayBuffer != nullptr, "success create_arrayBuffer");
1664
1665 return arrayBuffer;
1666 }
1667
napiGetCbInfo(napi_env env,napi_callback_info info)1668 static napi_value napiGetCbInfo(napi_env env, napi_callback_info info)
1669 {
1670 size_t argc = 1;
1671 napi_value args[1];
1672 napi_status status = napi_get_cb_info(env, info, &argc, args, NULL, NULL);
1673 NAPI_ASSERT(env, status == napi_ok, "get_cb_info ok");
1674 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
1675 double value;
1676 napi_get_value_double(env, args[0], &value);
1677
1678 napi_valuetype valuetype;
1679 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
1680 NAPI_ASSERT(env, valuetype == napi_number, "Wrong type of argment. Expects a nunber.");
1681
1682 napi_value returnValue;
1683 napi_status statusDouble = napi_create_double(env, value, &returnValue);
1684 NAPI_ASSERT(env, statusDouble == napi_ok, "success to napi_create_double");
1685
1686 return returnValue;
1687 }
1688
naiGetArrayBufferInfo(napi_env env,napi_callback_info info)1689 static napi_value naiGetArrayBufferInfo(napi_env env, napi_callback_info info)
1690 {
1691 // the value to return
1692 napi_value arrayBuffer;
1693 napi_status status;
1694 void* yourPointer = nullptr;
1695 size_t arrayBufferSize = 1024;
1696 status = napi_create_arraybuffer(env, arrayBufferSize, &yourPointer, &arrayBuffer);
1697 NAPI_ASSERT(env, status == napi_ok, "success to napi_create_arraybuffer");
1698
1699 void* tmpArrayBufferPtr = nullptr;
1700 size_t arrayBufferLength = 0;
1701 status = napi_get_arraybuffer_info(env, arrayBuffer, &tmpArrayBufferPtr, &arrayBufferLength);
1702 NAPI_ASSERT(env, status == napi_ok, "success to napi_get_arraybuffer_info");
1703
1704 napi_value arrayLength;
1705 // return the length of array js type int
1706 NAPI_CALL(env, napi_create_int32(env, arrayBufferLength, &arrayLength));
1707
1708 return arrayLength;
1709 }
1710
napiDefineClass(napi_env env,napi_callback_info info)1711 static napi_value napiDefineClass(napi_env env, napi_callback_info info)
1712 {
1713 napi_value testWrapClass = nullptr;
1714 napi_define_class(env, "TestWrapClass", NAPI_AUTO_LENGTH, [](napi_env env, napi_callback_info info) -> napi_value {
1715 napi_value thisVar = nullptr;
1716 napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
1717 return thisVar;
1718 }, nullptr, 0, nullptr, &testWrapClass);
1719
1720 napi_value instanceValue = nullptr;
1721 napi_new_instance(env, testWrapClass, 0, nullptr, &instanceValue);
1722 NAPI_ASSERT(env, instanceValue != nullptr, "success napiDefineClass");
1723 napi_value value;
1724 NAPI_CALL(env, napi_create_int32(env, 0, &value));
1725
1726 return value;
1727 }
1728
napiRunScriptPath(napi_env env,napi_callback_info info)1729 static napi_value napiRunScriptPath(napi_env env, napi_callback_info info)
1730 {
1731 napi_value value;
1732 const char* path = "index/page";
1733 napi_status status = napi_run_script_path(env, path, &value);
1734 NAPI_ASSERT(env, status == napi_ok, "napi_run_script_path ok");
1735 NAPI_ASSERT(env, value == nullptr, "napi_run_script_path fail");
1736
1737 napi_value _value;
1738 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1739
1740 return _value;
1741 }
1742
napiGetNodeVersion(napi_env env,napi_callback_info info)1743 static napi_value napiGetNodeVersion(napi_env env, napi_callback_info info)
1744 {
1745 napi_value value;
1746 const napi_node_version* version;
1747 napi_get_node_version(env, &version);
1748 const char* release = version->release;
1749 napi_status status = napi_create_string_utf8(env, release, strlen(release), &value);
1750 NAPI_ASSERT(env, status == napi_ok, "napi_create_string_utf8 ok");
1751 napi_value _value;
1752 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1753
1754 return _value;
1755 }
1756
napiCallThreadsafeFunction(napi_env env,napi_callback_info info)1757 static napi_value napiCallThreadsafeFunction(napi_env env, napi_callback_info info)
1758 {
1759 void* data = nullptr;
1760 napi_threadsafe_function func = (napi_threadsafe_function)data;
1761 napi_threadsafe_function_call_mode blockMode = napi_tsfn_nonblocking;
1762 void* context = nullptr;
1763 napi_status status = napi_get_threadsafe_function_context(func, &context);
1764 NAPI_ASSERT(env, status != napi_ok, "napi_get_threadsafe_function_context fail");
1765 static int32_t gSendData = 0;
1766 napi_call_threadsafe_function(func, &gSendData, blockMode);
1767 status = napi_call_threadsafe_function(func, &gSendData, blockMode);
1768 NAPI_ASSERT(env, status != napi_ok, "napi_call_threadsafe_function fail");
1769 napi_release_threadsafe_function(func, napi_tsfn_release);
1770 napi_value value;
1771 NAPI_CALL(env, napi_create_int32(env, 0, &value));
1772
1773 return value;
1774 }
1775
napiCreateThreadsafeFunction(napi_env env,napi_callback_info info)1776 static napi_value napiCreateThreadsafeFunction(napi_env env, napi_callback_info info)
1777 {
1778 napi_threadsafe_function tsFunc = nullptr;
1779 napi_value resourceName = 0;
1780 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1781 int32_t callJstCbDataTestId = 101;
1782 int32_t finalCbtDataTestID = 1001;
1783 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
1784 0, 1, &callJstCbDataTestId, nullptr,
1785 &finalCbtDataTestID, nullptr, &tsFunc);
1786 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
1787
1788 napi_acquire_threadsafe_function(tsFunc);
1789 status = napi_unref_threadsafe_function(env, tsFunc);
1790 NAPI_ASSERT(env, status != napi_ok, "napi_unref_threadsafe_function failed");
1791
1792 napi_value _value;
1793 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1794
1795 return _value;
1796 }
1797
1798 struct AddonData {
1799 napi_async_work asyncWork = nullptr;
1800 napi_deferred deferred = nullptr;
1801 napi_ref callback = nullptr;
1802 double args = 0;
1803 double result = 0;
1804 };
AddExecuteCB(napi_env env,void * data)1805 static void AddExecuteCB(napi_env env, void *data) {
1806 AddonData *addonData = (AddonData *)data;
1807 addonData->result = addonData->args;
1808 }
1809
AddCallbackCompleteCB(napi_env env,napi_status status,void * data)1810 static void AddCallbackCompleteCB(napi_env env, napi_status status, void *data) {
1811 AddonData *addonData = (AddonData *)data;
1812 napi_value callback = nullptr;
1813 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, addonData->callback, &callback));
1814 napi_value result = nullptr;
1815 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
1816 napi_value callbackResult = nullptr;
1817
1818 int32_t ret = 0;
1819 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, nullptr, callback, 1, &result, &callbackResult));
1820 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, callbackResult, &ret));
1821 NAPI_ASSERT_RETURN_VOID(env, ret == 2000, "AddCallbackCompleteCB failed");
1822
1823 if (addonData->callback != nullptr) {
1824 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, addonData->callback));
1825 }
1826
1827 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
1828 free(addonData);
1829 }
1830
testAsyncWork(napi_env env,napi_callback_info info)1831 static napi_value testAsyncWork(napi_env env, napi_callback_info info) {
1832 size_t argc = 2;
1833 napi_value args[2];
1834 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1835
1836 struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
1837 if (addonData == nullptr) {
1838 return nullptr;
1839 }
1840
1841 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
1842 NAPI_CALL(env, napi_create_reference(env, args[1], 1, &addonData->callback));
1843
1844 napi_value resourceName = nullptr;
1845 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName));
1846 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB, AddCallbackCompleteCB,
1847 (void *)addonData, &addonData->asyncWork));
1848
1849 NAPI_CALL(env, napi_queue_async_work(env, addonData->asyncWork));
1850
1851 napi_value _value = 0;
1852 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1853 return _value;
1854 }
1855
AddPromiseCompleteCB(napi_env env,napi_status status,void * data)1856 static void AddPromiseCompleteCB(napi_env env, napi_status status, void *data) {
1857 AddonData *addonData = (AddonData *)data;
1858 napi_value result = nullptr;
1859 NAPI_CALL_RETURN_VOID(env, napi_create_double(env, addonData->result, &result));
1860 if (addonData->result > 0) {
1861 NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, addonData->deferred, result));
1862 } else {
1863 NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, addonData->deferred, result));
1864 }
1865
1866 NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, addonData->asyncWork));
1867 free(addonData);
1868 addonData = nullptr;
1869 }
1870
testPromise(napi_env env,napi_callback_info info)1871 static napi_value testPromise(napi_env env, napi_callback_info info)
1872 {
1873 size_t argc = 1;
1874 napi_value args[1];
1875 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
1876
1877 napi_value promise = nullptr;
1878 napi_deferred deferred = nullptr;
1879 NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
1880
1881 struct AddonData* addonData = (struct AddonData*)malloc(sizeof(struct AddonData));
1882 if (addonData == nullptr) {
1883 return nullptr;
1884 }
1885 addonData->deferred = deferred;
1886
1887 NAPI_CALL(env, napi_get_value_double(env, args[0], &addonData->args));
1888
1889 napi_value resourceName = nullptr;
1890 NAPI_CALL(env, napi_create_string_utf8(env, "AsyncCallback", NAPI_AUTO_LENGTH, &resourceName));
1891 NAPI_CALL(env, napi_create_async_work(env, nullptr, resourceName, AddExecuteCB,
1892 AddPromiseCompleteCB, (void *)addonData, &addonData->asyncWork));
1893
1894 napi_queue_async_work(env, addonData->asyncWork);
1895
1896 return promise;
1897 }
1898
napiCancelAsyncWork(napi_env env,napi_callback_info info)1899 static napi_value napiCancelAsyncWork(napi_env env, napi_callback_info info)
1900 {
1901 napi_async_work work = nullptr;
1902 napi_value resourceName = nullptr;
1903 napi_create_string_utf8(env, "AsyncWorkTest", NAPI_AUTO_LENGTH, &resourceName);
1904 napi_create_async_work(env, nullptr, resourceName, [](napi_env value, void* data) {},
1905 [](napi_env env, napi_status status, void* data) {
1906 napi_async_work workData = (napi_async_work)data;
1907 napi_delete_async_work(env, workData);
1908 }, work, &work);
1909 napi_queue_async_work(env, work);
1910 NAPI_CALL(env, napi_cancel_async_work(env, work));
1911 napi_value value;
1912 NAPI_CALL(env, napi_create_int32(env, 0, &value));
1913
1914 return value;
1915 }
1916
SayHello(napi_env env,napi_callback_info info)1917 static napi_value SayHello(napi_env env, napi_callback_info info)
1918 {
1919 printf("Hello\n");
1920 napi_value ret;
1921 NAPI_CALL(env, napi_create_int32(env, TAG_NUMBER, &ret));
1922 return ret;
1923 }
1924
napiCreateFunction(napi_env env,napi_callback_info info)1925 static napi_value napiCreateFunction(napi_env env, napi_callback_info info)
1926 {
1927 napi_value funcValue = nullptr;
1928 napi_status status = napi_create_function(env, "func", NAPI_AUTO_LENGTH, SayHello, NULL, &funcValue);
1929 NAPI_ASSERT(env, funcValue != nullptr, "napi_create_function fail");
1930 NAPI_ASSERT(env, status == napi_ok, "napi_create_function fail");
1931 napi_value value;
1932 NAPI_CALL(env, napi_create_int32(env, 1, &value));
1933
1934 return funcValue;
1935 }
1936
napiRefthreadSafeFunction(napi_env env,napi_callback_info info)1937 static napi_value napiRefthreadSafeFunction(napi_env env, napi_callback_info info)
1938 {
1939 napi_threadsafe_function tsFunc = nullptr;
1940 napi_value resourceName = 0;
1941 napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName);
1942 int32_t callJsCbDataTestId = 101;
1943 int32_t finalCbDataTestId = 1001;
1944 napi_status status = napi_create_threadsafe_function(env, nullptr, nullptr, resourceName,
1945 0, 1, &callJsCbDataTestId,
1946 nullptr, &finalCbDataTestId, nullptr, &tsFunc);
1947 NAPI_ASSERT(env, status != napi_ok, "napi_create_threadsafe_function failed");
1948
1949 status = napi_ref_threadsafe_function(env, tsFunc);
1950 NAPI_ASSERT(env, status != napi_ok, "napi_ref_threadsafe_function");
1951 napi_value _value;
1952 NAPI_CALL(env, napi_create_int32(env, 0, &_value));
1953
1954 return _value;
1955 }
1956
napiCreateDate(napi_env env,napi_callback_info info)1957 static napi_value napiCreateDate(napi_env env, napi_callback_info info)
1958 {
1959 napi_value createResult = nullptr;
1960 double time = 202110181203150;
1961 napi_status status = napi_create_date(env, time, &createResult);
1962 NAPI_ASSERT(env, status == napi_ok, "napi_create_date success");
1963 double getTime = false;
1964 napi_get_date_value(env, createResult, &getTime);
1965 bool result = false;
1966 if (time == getTime) {
1967 result = true;
1968 }
1969 napi_value value;
1970 NAPI_CALL(env, napi_create_int32(env, result, &value));
1971
1972 return value;
1973 }
1974
napiCreateBigintUint64(napi_env env,napi_callback_info info)1975 static napi_value napiCreateBigintUint64(napi_env env, napi_callback_info info)
1976 {
1977 uint64_t testValue = UINT64_MAX;
1978 napi_value result = nullptr;
1979 napi_create_bigint_uint64(env, testValue, &result);
1980
1981 uint64_t resultValue = 0;
1982 bool flag = false;
1983 napi_get_value_bigint_uint64(env, result, &resultValue, &flag);
1984 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
1985 napi_value value;
1986 NAPI_CALL(env, napi_create_int32(env, flag, &value));
1987
1988 return value;
1989 }
1990
napiCreateBigintInt64(napi_env env,napi_callback_info info)1991 static napi_value napiCreateBigintInt64(napi_env env, napi_callback_info info)
1992 {
1993 int64_t testValue = INT64_MAX;
1994 napi_value result = nullptr;
1995 napi_create_bigint_int64(env, testValue, &result);
1996 int64_t resultValue = 0;
1997 bool flag = false;
1998 napi_get_value_bigint_int64(env, result, &resultValue, &flag);
1999 NAPI_ASSERT(env, resultValue == testValue, "napi_get_value_bigint_int64 failed");
2000 napi_value value;
2001 NAPI_CALL(env, napi_create_int32(env, flag, &value));
2002
2003 return value;
2004 }
2005
napiCreateBigintWords(napi_env env,napi_callback_info info)2006 static napi_value napiCreateBigintWords(napi_env env, napi_callback_info info)
2007 {
2008 int signBit = 0;
2009 size_t wordCount = 4;
2010 uint64_t words[] = {0ULL, 34ULL, 56ULL, 2ULL};
2011 uint64_t wordsOut[] = {0ULL, 0ULL, 0ULL, 0ULL};
2012 napi_value result = nullptr;
2013 NAPI_CALL(env, napi_create_bigint_words(env, signBit, wordCount, words, &result));
2014 int retSignBit = -1;
2015 size_t retWordCount = 4;
2016 NAPI_CALL(env, napi_get_value_bigint_words(env, result, &retSignBit, &retWordCount, wordsOut));
2017 bool testResult = true;
2018 if (retSignBit != signBit || retWordCount != wordCount) {
2019 testResult = false;
2020 }
2021 for (size_t i = 0; i < wordCount; i++) {
2022 if (wordsOut[i] != words[i]) {
2023 testResult = false;
2024 break;
2025 }
2026 }
2027 napi_value value;
2028 NAPI_CALL(env, napi_create_int32(env, testResult, &value));
2029
2030 return value;
2031 }
2032
callFunction(napi_env env,napi_callback_info info)2033 static napi_value callFunction(napi_env env, napi_callback_info info)
2034 {
2035 size_t argc = 1;
2036 napi_value args[1];
2037 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
2038
2039 NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
2040
2041 napi_valuetype valuetype;
2042 NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
2043
2044 NAPI_ASSERT(env, valuetype == napi_function,
2045 "Wrong type of argment. Expects a string.");
2046 napi_value ret;
2047 NAPI_CALL(env, napi_call_function(env, nullptr, args[0], 0, nullptr, &ret));
2048 return ret;
2049 }
2050
getGlobal(napi_env env,napi_callback_info info)2051 static napi_value getGlobal(napi_env env, napi_callback_info info)
2052 {
2053 napi_value result = nullptr;
2054 NAPI_CALL(env, napi_get_global(env, &result));
2055 NAPI_ASSERT(env, result != nullptr, "napi_get_global failed");
2056 return nullptr;
2057 }
2058
2059 napi_threadsafe_function tsfn;
2060 napi_ref functionRef;
CallJs(napi_env env,napi_value js_cb,void * context,void * data)2061 static void CallJs(napi_env env, napi_value js_cb, void *context, void *data) {
2062
2063 napi_value undefined;
2064 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
2065 napi_value cb;
2066 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, functionRef, &cb));
2067
2068 napi_value ret;
2069 int32_t num = 0;
2070 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, cb, 0, nullptr, &ret));
2071 NAPI_CALL_RETURN_VOID(env, napi_get_value_int32(env, ret, &num));
2072 NAPI_ASSERT_RETURN_VOID(env, num == TAG_NUMBER, "CallJs fail");
2073 }
2074
ThreadSafeTest(napi_env env,napi_callback_info info)2075 static napi_value ThreadSafeTest(napi_env env, napi_callback_info info) {
2076 size_t argc = 1;
2077 napi_value js_cb, work_name;
2078 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL));
2079 napi_create_reference(env, js_cb, 1, &functionRef);
2080
2081 NAPI_CALL(env, napi_create_string_utf8(env, "work_name", NAPI_AUTO_LENGTH, &work_name));
2082
2083 napi_valuetype valueType = napi_undefined;
2084 NAPI_CALL(env, napi_typeof(env, js_cb, &valueType));
2085 NAPI_ASSERT(env, valueType == napi_function, "valueType expect equal to napi_function");
2086
2087 const char context[] = "context";
2088 NAPI_CALL(env, napi_create_threadsafe_function(
2089 env, js_cb, NULL, work_name, 0, 1, NULL, NULL, (void*)context, CallJs, &tsfn));
2090 void* retContext = nullptr;
2091 NAPI_CALL(env, napi_get_threadsafe_function_context(tsfn, &retContext));
2092 NAPI_ASSERT(env, retContext == context, "napi_get_threadsafe_function_context failed");
2093
2094 napi_acquire_threadsafe_function(tsfn);
2095 napi_call_threadsafe_function(tsfn, NULL, napi_tsfn_blocking);
2096
2097 NAPI_CALL(env, napi_ref_threadsafe_function(env, tsfn));
2098 NAPI_CALL(env, napi_unref_threadsafe_function(env, tsfn));
2099 NAPI_CALL(env, napi_release_threadsafe_function(tsfn, napi_tsfn_release));
2100 napi_value _value;
2101 NAPI_CALL(env, napi_create_int32(env, 1, &_value));
2102 return _value;
2103 }
2104
2105 EXTERN_C_START
2106
Init(napi_env env,napi_value exports)2107 static napi_value Init(napi_env env, napi_value exports)
2108 {
2109 napi_property_descriptor properties[] = {
2110 DECLARE_NAPI_FUNCTION("getLastErrorInfo", getLastErrorInfo),
2111 DECLARE_NAPI_FUNCTION("cleanUpErrorInfo", cleanUpErrorInfo),
2112 DECLARE_NAPI_FUNCTION("throwExistingError", throwExistingError),
2113 DECLARE_NAPI_FUNCTION("throwError", throwError),
2114 DECLARE_NAPI_FUNCTION("throwTypeError", throwTypeError),
2115 DECLARE_NAPI_FUNCTION("throwRangeError", throwRangeError),
2116 DECLARE_NAPI_FUNCTION("isError", isError),
2117 DECLARE_NAPI_FUNCTION("createError", createError),
2118 DECLARE_NAPI_FUNCTION("createTypeError", createTypeError),
2119 DECLARE_NAPI_FUNCTION("createRangeError", createRangeError),
2120 DECLARE_NAPI_FUNCTION("getAndClearLastException", getAndClearLastException),
2121 DECLARE_NAPI_FUNCTION("isExceptionPending", isExceptionPending),
2122 DECLARE_NAPI_FUNCTION("openAndCloseHandleScope", openAndCloseHandleScope),
2123 DECLARE_NAPI_FUNCTION("openAndCloseEscapableHandleScope", openAndCloseEscapableHandleScope),
2124 DECLARE_NAPI_FUNCTION("createReference", createReference),
2125 DECLARE_NAPI_FUNCTION("getAndDeleteReference", getAndDeleteReference),
2126 DECLARE_NAPI_FUNCTION("referenceRefAndUnref", referenceRefAndUnref),
2127 DECLARE_NAPI_FUNCTION("createArrayAndGetLength", createArrayAndGetLength),
2128 DECLARE_NAPI_FUNCTION("getArrayWithLength", getArrayWithLength),
2129 DECLARE_NAPI_FUNCTION("createExternal", createExternal),
2130 DECLARE_NAPI_FUNCTION("createExternalArraybuffer", createExternalArraybuffer),
2131 DECLARE_NAPI_FUNCTION("createObject", createObject),
2132 DECLARE_NAPI_FUNCTION("createSymbol", createSymbol),
2133 DECLARE_NAPI_FUNCTION("createTypeArray", createTypeArray),
2134 DECLARE_NAPI_FUNCTION("createDataView", createDataView),
2135 DECLARE_NAPI_FUNCTION("createAndGetInt32", createAndGetInt32),
2136 DECLARE_NAPI_FUNCTION("createAndGetUInt32", createAndGetUInt32),
2137 DECLARE_NAPI_FUNCTION("createAndGetInt64", createAndGetInt64),
2138 DECLARE_NAPI_FUNCTION("createDouble", createDouble),
2139 DECLARE_NAPI_FUNCTION("createAndGetStringLatin1", createAndGetStringLatin1),
2140 DECLARE_NAPI_FUNCTION("createAndGetStringUtf8", createAndGetStringUtf8),
2141 DECLARE_NAPI_FUNCTION("getPrototype", getPrototype),
2142 DECLARE_NAPI_FUNCTION("getPrototype2", getPrototype2),
2143 DECLARE_NAPI_FUNCTION("getTypedArrayInfo", getTypedArrayInfo),
2144 DECLARE_NAPI_FUNCTION("getDataViewInfo", getDataViewInfo),
2145 DECLARE_NAPI_FUNCTION("getValueBool", getValueBool),
2146 DECLARE_NAPI_FUNCTION("getValueDouble", getValueDouble),
2147 DECLARE_NAPI_FUNCTION("getValueExternal", getValueExternal),
2148 DECLARE_NAPI_FUNCTION("getNull", getNull),
2149 DECLARE_NAPI_FUNCTION("getUndefined", getUndefined),
2150 DECLARE_NAPI_FUNCTION("coerceToBool", coerceToBool),
2151 DECLARE_NAPI_FUNCTION("coerceToNumber", coerceToNumber),
2152 DECLARE_NAPI_FUNCTION("coerceToObject", coerceToObject),
2153 DECLARE_NAPI_FUNCTION("coerceToString", coerceToString),
2154 DECLARE_NAPI_FUNCTION("instanceOf", instanceOf),
2155 DECLARE_NAPI_FUNCTION("isArray", isArray),
2156 DECLARE_NAPI_FUNCTION("isDate", isDate),
2157 DECLARE_NAPI_FUNCTION("strictEquals", strictEquals),
2158 DECLARE_NAPI_FUNCTION("getPropertyNames", getPropertyNames),
2159 DECLARE_NAPI_FUNCTION("setProperty", setProperty),
2160 DECLARE_NAPI_FUNCTION("getProperty", getProperty),
2161 DECLARE_NAPI_FUNCTION("hasProperty", hasProperty),
2162 DECLARE_NAPI_FUNCTION("setAndDeleteProperty", setAndDeleteProperty),
2163 DECLARE_NAPI_FUNCTION("hasOwnProperty", hasOwnProperty),
2164 DECLARE_NAPI_FUNCTION("setNamedProperty", setNamedProperty),
2165 DECLARE_NAPI_FUNCTION("getNamedProperty", getNamedProperty),
2166 DECLARE_NAPI_FUNCTION("hasNamedProperty", hasNamedProperty),
2167 DECLARE_NAPI_FUNCTION("setElement", setElement),
2168 DECLARE_NAPI_FUNCTION("getElement", getElement),
2169 DECLARE_NAPI_FUNCTION("hasElement", hasElement),
2170 DECLARE_NAPI_FUNCTION("deleteElement", deleteElement),
2171 DECLARE_NAPI_FUNCTION("defineProperties", defineProperties),
2172 DECLARE_NAPI_FUNCTION("wrap", wrap),
2173 DECLARE_NAPI_FUNCTION("unwrap", unwrap),
2174 DECLARE_NAPI_FUNCTION("removeWrap", removeWrap),
2175 DECLARE_NAPI_FUNCTION("getVersion", getVersion),
2176 DECLARE_NAPI_FUNCTION("createPromise", createPromise),
2177 DECLARE_NAPI_FUNCTION("resolveAndRejectDeferred", resolveAndRejectDeferred),
2178 DECLARE_NAPI_FUNCTION("isPromise", isPromise),
2179 DECLARE_NAPI_FUNCTION("TestLatin1", TestLatin1),
2180 DECLARE_NAPI_FUNCTION("runScript", runScript),
2181 DECLARE_NAPI_FUNCTION("getUvEventLoop", getUvEventLoop),
2182 DECLARE_NAPI_FUNCTION("napCreateArrayBuffer", napCreateArrayBuffer),
2183 DECLARE_NAPI_FUNCTION("naiGetArrayBufferInfo", naiGetArrayBufferInfo),
2184 DECLARE_NAPI_FUNCTION("napiDefineClass", napiDefineClass),
2185 DECLARE_NAPI_FUNCTION("napiRunScriptPath", napiRunScriptPath),
2186 DECLARE_NAPI_FUNCTION("napiGetNodeVersion", napiGetNodeVersion),
2187 DECLARE_NAPI_FUNCTION("napiCallThreadsafeFunction", napiCallThreadsafeFunction),
2188 DECLARE_NAPI_FUNCTION("napiCreateThreadsafeFunction", napiCreateThreadsafeFunction),
2189 DECLARE_NAPI_FUNCTION("napiRefthreadSafeFunction", napiRefthreadSafeFunction),
2190 DECLARE_NAPI_FUNCTION("napiCreateDate", napiCreateDate),
2191 DECLARE_NAPI_FUNCTION("napiCreateBigintUint64", napiCreateBigintUint64),
2192 DECLARE_NAPI_FUNCTION("napiCreateBigintInt64", napiCreateBigintInt64),
2193 DECLARE_NAPI_FUNCTION("napiCreateBigintWords", napiCreateBigintWords),
2194 DECLARE_NAPI_FUNCTION("napiGetCbInfo", napiGetCbInfo),
2195 { "napiCancelAsyncWork", nullptr, napiCancelAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
2196 { "testAsyncWork", nullptr, testAsyncWork, nullptr, nullptr, nullptr, napi_default, nullptr },
2197 { "testPromise", nullptr, testPromise, nullptr, nullptr, nullptr, napi_default, nullptr },
2198 { "napiCreateFunction", nullptr, napiCreateFunction, nullptr, nullptr, nullptr, napi_default, nullptr },
2199 DECLARE_NAPI_FUNCTION("getGlobal", getGlobal),
2200 DECLARE_NAPI_FUNCTION("callFunction", callFunction),
2201 DECLARE_NAPI_FUNCTION("ThreadSafeTest", ThreadSafeTest),
2202 };
2203 NAPI_CALL(env, napi_define_properties(env, exports, sizeof(properties) / sizeof(properties[0]), properties));
2204
2205 napi_property_descriptor descClass[] = {
2206 DECLARE_NAPI_FUNCTION("sayHello", SayHello),
2207 };
2208 napi_value myClass;
2209 napi_define_class(env, "myClass", NAPI_AUTO_LENGTH, MyConstructor, nullptr,
2210 sizeof(descClass) / sizeof(descClass[0]), descClass, &myClass);
2211 napi_set_named_property(env, exports, "myClass", myClass);
2212 return exports;
2213 }
2214
2215 EXTERN_C_END
2216
2217 static napi_module demoModule = {
2218 .nm_version = 1,
2219 .nm_flags = 0,
2220 .nm_filename = nullptr,
2221 .nm_register_func = Init,
2222 .nm_modname = "napitest",
2223 .nm_priv = ((void *)0),
2224 .reserved = {0},
2225 };
2226
RegisterModule(void)2227 extern "C" __attribute__((constructor)) void RegisterModule(void)
2228 {
2229 napi_module_register(&demoModule);
2230 }
2231