1 /*
2 * Copyright (c) 2021-2022 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 "napi/native_common.h"
17 #include "napi/native_api.h"
18 #include "napi/native_node_api.h"
19 #include "securec.h"
20 #include "test.h"
21 #include "test_common.h"
22 #include "utils/log.h"
23 #ifdef FOR_JERRYSCRIPT_TEST
24 #include "jerryscript-core.h"
25 #endif
26
27 static constexpr int32_t NAPI_UT_BUFFER_SIZE = 64;
28
29 class NapiExtTest : public NativeEngineTest {
30 public:
SetUpTestCase()31 static void SetUpTestCase()
32 {
33 GTEST_LOG_(INFO) << "NapiExtTest SetUpTestCase";
34 }
35
TearDownTestCase()36 static void TearDownTestCase()
37 {
38 GTEST_LOG_(INFO) << "NapiExtTest TearDownTestCase";
39 }
40
SetUp()41 void SetUp() override {}
TearDown()42 void TearDown() override {}
43 };
44
45 /**
46 * @tc.name: UndefinedTest
47 * @tc.desc: Test undefined type.
48 * @tc.type: FUNC
49 */
50 HWTEST_F(NapiExtTest, CreateBufferTest001, testing::ext::TestSize.Level1)
51 {
52 napi_env env = (napi_env)engine_;
53
54 napi_value buffer = nullptr;
55 void* bufferPtr = nullptr;
56 size_t bufferSize = NAPI_UT_BUFFER_SIZE;
57 napi_create_buffer(env, bufferSize, &bufferPtr, &buffer);
58 void* tmpBufferPtr = nullptr;
59 size_t bufferLength = 0;
60 napi_get_buffer_info(env, buffer, &tmpBufferPtr, &bufferLength);
61
62 ASSERT_EQ(bufferPtr, tmpBufferPtr);
63 ASSERT_EQ(bufferSize, bufferLength);
64 }
65
66 HWTEST_F(NapiExtTest, CreateBufferTest002, testing::ext::TestSize.Level1)
67 {
68 napi_env env = (napi_env)engine_;
69
70 napi_value buffer = nullptr;
71 void* bufferPtr = nullptr;
72 size_t bufferSize = -1;
73 napi_status creatresult = napi_create_buffer(env, bufferSize, &bufferPtr, &buffer);
74
75 ASSERT_EQ(creatresult, napi_status::napi_invalid_arg);
76 ASSERT_EQ(bufferPtr, nullptr);
77 }
78
79 HWTEST_F(NapiExtTest, CreateBufferTest003, testing::ext::TestSize.Level1)
80 {
81 napi_env env = (napi_env)engine_;
82
83 napi_value buffer = nullptr;
84 void* bufferPtr = nullptr;
85 const char bufferdata[] = "for test";
86 const char* data = bufferdata;
87 size_t bufferSize = NAPI_UT_BUFFER_SIZE;
88 napi_create_buffer_copy(env, bufferSize, data, &bufferPtr, &buffer);
89
90 void* tmpBufferPtr = nullptr;
91 size_t bufferLength = 0;
92 napi_get_buffer_info(env, buffer, &tmpBufferPtr, &bufferLength);
93
94 ASSERT_EQ(bufferPtr, tmpBufferPtr);
95 ASSERT_EQ(bufferSize, bufferLength);
96 ASSERT_EQ(0, memcmp(bufferdata, bufferPtr, bufferSize));
97 }
98
99 HWTEST_F(NapiExtTest, CreateBufferTest004, testing::ext::TestSize.Level1)
100 {
101 napi_env env = (napi_env)engine_;
102
103 napi_value buffer = nullptr;
104 void* bufferPtr = nullptr;
105 const char* data = nullptr;
106 size_t bufferSize = -1;
107 napi_status creatresult = napi_create_buffer_copy(env, bufferSize, data, &bufferPtr, &buffer);
108
109 ASSERT_EQ(creatresult, napi_status::napi_invalid_arg);
110 ASSERT_EQ(bufferPtr, nullptr);
111 }
112
113 HWTEST_F(NapiExtTest, CreateBufferTest005, testing::ext::TestSize.Level1)
114 {
115 napi_env env = (napi_env)engine_;
116
117 napi_value buffer = nullptr;
118 char testStr[] = "test";
119 void* bufferPtr = testStr;
120
121 size_t bufferSize = NAPI_UT_BUFFER_SIZE;
122 napi_create_external_buffer(
__anon40fe77970102(napi_env env, void* data, void* hint) 123 env, bufferSize, bufferPtr, [](napi_env env, void* data, void* hint) {}, (void*)testStr, &buffer);
124
125 void* tmpBufferPtr = nullptr;
126 size_t bufferLength = 0;
127 napi_get_buffer_info(env, buffer, &tmpBufferPtr, &bufferLength);
128 bool isBuffer = false;
129 napi_is_buffer(env, buffer, &isBuffer);
130
131 ASSERT_EQ(bufferSize, bufferLength);
132 }
133
134 HWTEST_F(NapiExtTest, IsBufferTest001, testing::ext::TestSize.Level1)
135 {
136 napi_env env = (napi_env)engine_;
137
138 napi_value buffer = nullptr;
139 void* bufferPtr = nullptr;
140 size_t bufferSize = NAPI_UT_BUFFER_SIZE;
141 bool isBuffer = false;
142
143 napi_create_buffer(env, bufferSize, &bufferPtr, &buffer);
144
145 void* tmpBufferPtr = nullptr;
146 size_t bufferLength = 0;
147 napi_get_buffer_info(env, buffer, &tmpBufferPtr, &bufferLength);
148 napi_is_buffer(env, buffer, &isBuffer);
149
150 ASSERT_TRUE(isBuffer);
151 }
152
153 HWTEST_F(NapiExtTest, IsBufferTest002, testing::ext::TestSize.Level1)
154 {
155 napi_env env = (napi_env)engine_;
156
157 napi_value buffer = nullptr;
158 void* bufferPtr = nullptr;
159 size_t bufferSize = -1;
160 bool isBuffer = false;
161
162 napi_create_buffer(env, bufferSize, &bufferPtr, &buffer);
163
164 void* tmpBufferPtr = nullptr;
165 size_t bufferLength = 0;
166 napi_get_buffer_info(env, buffer, &tmpBufferPtr, &bufferLength);
167 napi_is_buffer(env, buffer, &isBuffer);
168
169 ASSERT_EQ(isBuffer, false);
170 }
171
172 /**
173 * @tc.name: StringTestAce
174 * @tc.desc: Test string type.
175 * @tc.type: FUNC
176 */
177 HWTEST_F(NapiExtTest, StringTest001, testing::ext::TestSize.Level1)
178 {
179 napi_env env = (napi_env)engine_;
180 const char16_t testStr[] = u"中文,English,123456,!@#$%$#^%&12345";
181 int testStrLength = static_cast<int>(std::char_traits<char16_t>::length(testStr));
182 napi_value result = nullptr;
183 ASSERT_CHECK_CALL(napi_create_string_utf16(env, testStr, testStrLength, &result));
184 ASSERT_CHECK_VALUE_TYPE(env, result, napi_string);
185
186 char16_t* buffer = nullptr;
187 size_t bufferSize = 0;
188 size_t strLength = 0;
189 ASSERT_CHECK_CALL(napi_get_value_string_utf16(env, result, nullptr, 0, &bufferSize));
190 ASSERT_GT(bufferSize, (size_t)0);
__anon40fe77970202null191 buffer = new char16_t[bufferSize + 1] { 0 };
192 ASSERT_CHECK_CALL(napi_get_value_string_utf16(env, result, buffer, bufferSize + 1, &strLength));
193 for (int i = 0; i < testStrLength; i++) {
194 ASSERT_EQ(testStr[i], buffer[i]);
195 }
196 ASSERT_EQ(testStrLength, strLength);
197 delete[] buffer;
198 buffer = nullptr;
199 char16_t* bufferShort = nullptr;
200 int bufferShortSize = 3;
__anon40fe77970302null201 bufferShort = new char16_t[bufferShortSize] { 0 };
202 ASSERT_CHECK_CALL(napi_get_value_string_utf16(env, result, bufferShort, bufferShortSize, &strLength));
203 for (int i = 0; i < bufferShortSize; i++) {
204 if (i == (bufferShortSize - 1)) {
205 ASSERT_EQ(0, bufferShort[i]);
206 } else {
207 ASSERT_EQ(testStr[i], bufferShort[i]);
208 }
209 }
210 ASSERT_EQ(testStrLength, strLength);
211 delete[] bufferShort;
212 bufferShort = nullptr;
213 }
214
215 HWTEST_F(NapiExtTest, IsDetachedArrayBufferTest001, testing::ext::TestSize.Level1)
216 {
217 static constexpr size_t arrayBufferSize = 1024;
218 napi_env env = (napi_env)engine_;
219 napi_value arrayBuffer = nullptr;
220 void* arrayBufferPtr = nullptr;
221 napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
222
223 bool result = false;
224 ASSERT_CHECK_CALL(napi_is_detached_arraybuffer(env, arrayBuffer, &result));
225
226 auto out = napi_detach_arraybuffer(env, arrayBuffer);
227 if (out == napi_ok) {
228 arrayBufferPtr = nullptr;
229 }
230 ASSERT_EQ(out, napi_ok);
231
232 result = false;
233 ASSERT_CHECK_CALL(napi_is_detached_arraybuffer(env, arrayBuffer, &result));
234 ASSERT_TRUE(result);
235 }
236
237 #if (defined(FOR_JERRYSCRIPT_TEST)) && (JERRY_API_MINOR_VERSION <= 3)
238 // jerryscript 2.3 do nothing
239 #else
240 // jerryscript 2.4 or quickjs or V8
241
242 static constexpr size_t NAPI_UT_STR_LENGTH = 30;
243
244 /**
245 * @tc.name: BigIntTest
246 * @tc.desc: Test number type.
247 * @tc.type: FUNC
248 */
249 HWTEST_F(NapiExtTest, BigIntTest001, testing::ext::TestSize.Level1)
250 {
251 napi_env env = (napi_env)engine_;
252 // uint64
253 {
254 uint64_t testValue = UINT64_MAX;
255 napi_value result = nullptr;
256 bool flag = false;
257 ASSERT_CHECK_CALL(napi_create_bigint_uint64(env, testValue, &result));
258 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
259
260 uint64_t resultValue = 0;
261 ASSERT_CHECK_CALL(napi_get_value_bigint_uint64(env, result, &resultValue, &flag));
262 ASSERT_EQ(resultValue, UINT64_MAX);
263 ASSERT_TRUE(flag);
264 }
265 {
266 uint64_t testValue = 0xffffffffffffffff;
267 napi_value result = nullptr;
268 ASSERT_CHECK_CALL(napi_create_bigint_uint64(env, testValue, &result));
269 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
270 bool flag = false;
271 uint64_t resultValue = 0;
272 ASSERT_CHECK_CALL(napi_get_value_bigint_uint64(env, result, &resultValue, &flag));
273 ASSERT_EQ(resultValue, testValue);
274 ASSERT_TRUE(flag);
275 }
276 {
277 uint64_t testValue = 9007199254740991;
278 napi_value result = nullptr;
279 ASSERT_CHECK_CALL(napi_create_bigint_uint64(env, testValue, &result));
280 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
281 bool flag = false;
282 uint64_t resultValue = 0;
283 ASSERT_CHECK_CALL(napi_get_value_bigint_uint64(env, result, &resultValue, &flag));
284 ASSERT_EQ(resultValue, testValue);
285 ASSERT_TRUE(flag);
286 }
287 }
288
289 HWTEST_F(NapiExtTest, BigIntTest002, testing::ext::TestSize.Level1)
290 {
291 napi_env env = (napi_env)engine_;
292 // int64
293 {
294 int64_t testValue = INT64_MAX;
295 napi_value result = nullptr;
296 bool flag = false;
297 ASSERT_CHECK_CALL(napi_create_bigint_int64(env, testValue, &result));
298 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
299
300 int64_t resultValue = 0;
301 ASSERT_CHECK_CALL(napi_get_value_bigint_int64(env, result, &resultValue, &flag));
302 ASSERT_EQ(resultValue, INT64_MAX);
303 ASSERT_TRUE(flag);
304 }
305 {
306 int64_t testValue = 9007199254740991;
307 napi_value result = nullptr;
308 ASSERT_CHECK_CALL(napi_create_bigint_int64(env, testValue, &result));
309 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
310 bool flag = false;
311 int64_t resultValue = 0;
312 ASSERT_CHECK_CALL(napi_get_value_bigint_int64(env, result, &resultValue, &flag));
313 ASSERT_EQ(resultValue, testValue);
314 ASSERT_TRUE(flag);
315 }
316 {
317 int64_t testValue = -1;
318 napi_value result = nullptr;
319 ASSERT_CHECK_CALL(napi_create_bigint_int64(env, testValue, &result));
320 ASSERT_CHECK_VALUE_TYPE(env, result, napi_bigint);
321 bool flag = false;
322 int64_t resultValue = 0;
323 ASSERT_CHECK_CALL(napi_get_value_bigint_int64(env, result, &resultValue, &flag));
324 ASSERT_EQ(resultValue, testValue);
325 ASSERT_TRUE(flag);
326 }
327 }
328
329 HWTEST_F(NapiExtTest, BigIntWordsTest001, testing::ext::TestSize.Level1)
330 {
331 napi_env env = (napi_env)engine_;
332 int signBit = 0;
333 size_t wordCount = 4;
334 uint64_t words[] = { 0xFFFFFFFFFFFFFFFF, 34ULL, 56ULL, 0xFFFFFFFFFFFFFFFF };
335 uint64_t wordsOut[] = { 0ULL, 0ULL, 0ULL, 0ULL };
336 napi_value result = nullptr;
337 ASSERT_CHECK_CALL(napi_create_bigint_words(env, signBit, wordCount, words, &result));
338
339 ASSERT_CHECK_CALL(napi_get_value_bigint_words(env, result, &signBit, &wordCount, wordsOut));
340
341 ASSERT_EQ(signBit, 0);
342 ASSERT_EQ(wordCount, 4);
343 ASSERT_EQ(words[0], wordsOut[0]);
344 ASSERT_EQ(words[1], wordsOut[1]);
345 ASSERT_EQ(words[2], wordsOut[2]);
346 ASSERT_EQ(words[3], wordsOut[3]);
347 }
348
349 HWTEST_F(NapiExtTest, BigIntWordsTest002, testing::ext::TestSize.Level1)
350 {
351 napi_env env = (napi_env)engine_;
352 int signBit = 0;
353 size_t wordCount = 5;
354 uint64_t words[] = { 12ULL, 34ULL, 56ULL, 78ULL, 90ULL };
355 uint64_t wordsOut[] = { 0ULL, 0ULL, 0ULL, 0ULL, 0ULL };
356 napi_value result = nullptr;
357 ASSERT_CHECK_CALL(napi_create_bigint_words(env, signBit, wordCount, words, &result));
358
359 ASSERT_CHECK_CALL(napi_get_value_bigint_words(env, result, &signBit, &wordCount, wordsOut));
360
361 ASSERT_EQ(signBit, 0);
362 ASSERT_EQ(wordCount, 5);
363 for (size_t i = 0; i < wordCount; i++) {
364 ASSERT_EQ(words[i], wordsOut[i]);
365 }
366 }
367
368 HWTEST_F(NapiExtTest, BigIntWordsTest003, testing::ext::TestSize.Level1)
369 {
370 napi_env env = (napi_env)engine_;
371 int signBit = 1;
372 size_t wordCount = 4;
373 uint64_t words[] = { 0xFFFFFFFFFFFFFFFF, 34ULL, 56ULL, 0xFFFFFFFFFFFFFFFF };
374 uint64_t wordsOut[] = { 0ULL, 0ULL, 0ULL, 0ULL };
375 napi_value result = nullptr;
376 ASSERT_CHECK_CALL(napi_create_bigint_words(env, signBit, wordCount, words, &result));
377
378 ASSERT_CHECK_CALL(napi_get_value_bigint_words(env, result, &signBit, &wordCount, wordsOut));
379
380 ASSERT_EQ(signBit, 1);
381 ASSERT_EQ(wordCount, 4);
382 ASSERT_EQ(words[0], wordsOut[0]);
383 ASSERT_EQ(words[1], wordsOut[1]);
384 ASSERT_EQ(words[2], wordsOut[2]);
385 ASSERT_EQ(words[3], wordsOut[3]);
386 }
387
388 HWTEST_F(NapiExtTest, BigIntWordsTest004, testing::ext::TestSize.Level1)
389 {
390 napi_env env = (napi_env)engine_;
391 int signBit = 1;
392 size_t wordCount = 5;
393 uint64_t words[] = { 12ULL, 34ULL, 56ULL, 78ULL, 0x000000FF98765432 };
394 uint64_t wordsOut[] = { 0ULL, 0ULL, 0ULL, 0ULL, 0ULL };
395 napi_value result = nullptr;
396 ASSERT_CHECK_CALL(napi_create_bigint_words(env, signBit, wordCount, words, &result));
397
398 ASSERT_CHECK_CALL(napi_get_value_bigint_words(env, result, &signBit, &wordCount, wordsOut));
399
400 ASSERT_EQ(signBit, 1);
401 ASSERT_EQ(wordCount, 5);
402 for (size_t i = 0; i < wordCount; i++) {
403 ASSERT_EQ(words[i], wordsOut[i]);
404 }
405 }
406
407 HWTEST_F(NapiExtTest, FreezeObjectTest001, testing::ext::TestSize.Level1)
408 {
409 constexpr int dataSize = 60;
410 napi_env env = (napi_env)engine_;
411 napi_value object = nullptr;
412 napi_create_object(env, &object);
413
414 const char testStr[] = "1234567";
415 napi_value strAttribute = nullptr;
416 napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute);
417 napi_set_named_property(env, object, "strAttribute", strAttribute);
418
419 int32_t testNumber = 12345;
420 napi_value numberAttribute = nullptr;
421 napi_create_int32(env, testNumber, &numberAttribute);
422 napi_set_named_property(env, object, "numberAttribute", numberAttribute);
423
424 ASSERT_CHECK_CALL(napi_object_freeze(env, object));
425
426 int32_t testNumber2 = 111111;
427 napi_value numberAttribute2 = nullptr;
428 napi_create_int32(env, testNumber2, &numberAttribute2);
429 ASSERT_CHECK_CALL(napi_set_named_property(env, object, "test", numberAttribute2));
430
431 napi_key_collection_mode keyMode = napi_key_own_only;
432 napi_key_filter keyFilter = napi_key_all_properties;
433 napi_key_conversion keyConversion = napi_key_keep_numbers;
434 napi_value propNames = nullptr;
435 ASSERT_CHECK_CALL(napi_get_all_property_names(env, object, keyMode, keyFilter, keyConversion, &propNames));
436
437 uint32_t arrayLength = 0;
438 ASSERT_CHECK_CALL(napi_get_array_length(env, propNames, &arrayLength));
439 ASSERT_EQ(arrayLength, (uint32_t)2);
440
441 char names[2][30];
442 memset_s(names, dataSize, 0, dataSize);
443 auto ret = memcpy_s(names[0], strlen("strAttribute"), "strAttribute", strlen("strAttribute"));
444 ASSERT_EQ(ret, EOK);
445 ret = memcpy_s(names[1], strlen("numberAttribute"), "numberAttribute", strlen("numberAttribute"));
446 ASSERT_EQ(ret, EOK);
447 for (uint32_t i = 0; i < arrayLength; i++) {
448 bool hasElement = false;
449 ASSERT_CHECK_CALL(napi_has_element(env, propNames, i, &hasElement));
450
451 napi_value propName = nullptr;
452 ASSERT_CHECK_CALL(napi_get_element(env, propNames, i, &propName));
453 ASSERT_CHECK_VALUE_TYPE(env, propName, napi_string);
454
455 size_t testStrLength = NAPI_UT_STR_LENGTH;
456 char testStrInner[NAPI_UT_STR_LENGTH + 1];
457 size_t outStrLength = 0;
458 memset_s(testStrInner, testStrLength + 1, 0, testStrLength + 1);
459 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, propName, testStrInner, testStrLength, &outStrLength));
460
461 int ret = strcmp(testStrInner, names[i]);
462 ASSERT_EQ(ret, 0);
463 }
464 }
465
466 HWTEST_F(NapiExtTest, SealObjectTest001, testing::ext::TestSize.Level1)
467 {
468 napi_env env = (napi_env)engine_;
469 napi_value object = nullptr;
470
471 napi_create_object(env, &object);
472
473 const char testStr[] = "1234567";
474 napi_value strAttribute = nullptr;
475 napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute);
476 napi_set_named_property(env, object, "strAttribute", strAttribute);
477
478 int32_t testNumber = 12345;
479 napi_value numberAttribute = nullptr;
480 napi_create_int32(env, testNumber, &numberAttribute);
481 napi_set_named_property(env, object, "numberAttribute", numberAttribute);
482
483 ASSERT_CHECK_CALL(napi_object_seal(env, object));
484
485 int32_t testNumber2 = 111111;
486 napi_value numberAttribute2 = nullptr;
487 napi_create_int32(env, testNumber2, &numberAttribute2);
488 ASSERT_CHECK_CALL(napi_set_named_property(env, object, "test", numberAttribute2));
489
490 napi_key_collection_mode keyMode = napi_key_own_only;
491 napi_key_filter keyFilter = napi_key_all_properties;
492 napi_key_conversion keyConversion = napi_key_keep_numbers;
493 napi_value propNames = nullptr;
494 ASSERT_CHECK_CALL(napi_get_all_property_names(env, object, keyMode, keyFilter, keyConversion, &propNames));
495
496 uint32_t arrayLength = 0;
497 ASSERT_CHECK_CALL(napi_get_array_length(env, propNames, &arrayLength));
498 ASSERT_EQ(arrayLength, (uint32_t)2);
499
500 char names[2][NAPI_UT_STR_LENGTH];
501 memset_s(names, NAPI_UT_STR_LENGTH * 2, 0, NAPI_UT_STR_LENGTH * 2);
502 auto ret = memcpy_s(names[0], strlen("strAttribute"), "strAttribute", strlen("strAttribute"));
503 ASSERT_EQ(ret, EOK);
504 ret = memcpy_s(names[1], strlen("numberAttribute"), "numberAttribute", strlen("numberAttribute"));
505 ASSERT_EQ(ret, EOK);
506
507 for (uint32_t i = 0; i < arrayLength; i++) {
508 bool hasElement = false;
509 ASSERT_CHECK_CALL(napi_has_element(env, propNames, i, &hasElement));
510
511 napi_value propName = nullptr;
512 ASSERT_CHECK_CALL(napi_get_element(env, propNames, i, &propName));
513 ASSERT_CHECK_VALUE_TYPE(env, propName, napi_string);
514
515 size_t testStrLength = NAPI_UT_STR_LENGTH;
516 char testStrInner[NAPI_UT_STR_LENGTH + 1];
517 size_t outStrLength = 0;
518 memset_s(testStrInner, testStrLength + 1, 0, testStrLength + 1);
519 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, propName, testStrInner, testStrLength, &outStrLength));
520
521 int ret = strcmp(testStrInner, names[i]);
522 ASSERT_EQ(ret, 0);
523 }
524 }
525
526 HWTEST_F(NapiExtTest, AllPropertyNamesTest001, testing::ext::TestSize.Level1)
527 {
528 napi_env env = (napi_env)engine_;
529 napi_key_collection_mode keyMode = napi_key_own_only;
530 napi_key_filter keyFilter = napi_key_all_properties;
531 napi_key_conversion keyConversion = napi_key_keep_numbers;
532 napi_value result = nullptr;
533 napi_value propNames = nullptr;
534
535 ASSERT_CHECK_CALL(napi_create_object(env, &result));
536 ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
537
538 const char testStr[] = "1234567";
539 napi_value strAttribute = nullptr;
540 napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute);
541 napi_set_named_property(env, result, "strAttribute", strAttribute);
542
543 int32_t testNumber = 12345;
544 napi_value numberAttribute = nullptr;
545 napi_create_int32(env, testNumber, &numberAttribute);
546 napi_set_named_property(env, result, "numberAttribute", numberAttribute);
547
548 ASSERT_CHECK_CALL(napi_get_all_property_names(env, result, keyMode, keyFilter, keyConversion, &propNames));
549
550 ASSERT_CHECK_VALUE_TYPE(env, propNames, napi_object);
551 bool isArray = false;
552 ASSERT_CHECK_CALL(napi_is_array(env, propNames, &isArray));
553 ASSERT_TRUE(isArray);
554 uint32_t arrayLength = 0;
555 ASSERT_CHECK_CALL(napi_get_array_length(env, propNames, &arrayLength));
556 ASSERT_EQ(arrayLength, (uint32_t)2);
557
558 char names[2][NAPI_UT_STR_LENGTH];
559 memset_s(names, NAPI_UT_STR_LENGTH * 2, 0, NAPI_UT_STR_LENGTH * 2);
560 auto ret = memcpy_s(names[0], strlen("strAttribute"), "strAttribute", strlen("strAttribute"));
561 ASSERT_EQ(ret, EOK);
562 ret = memcpy_s(names[1], strlen("numberAttribute"), "numberAttribute", strlen("numberAttribute"));
563 ASSERT_EQ(ret, EOK);
564
565 for (uint32_t i = 0; i < arrayLength; i++) {
566 bool hasElement = false;
567 ASSERT_CHECK_CALL(napi_has_element(env, propNames, i, &hasElement));
568
569 napi_value propName = nullptr;
570 ASSERT_CHECK_CALL(napi_get_element(env, propNames, i, &propName));
571 ASSERT_CHECK_VALUE_TYPE(env, propName, napi_string);
572
573 size_t testStrLength = NAPI_UT_STR_LENGTH;
574 char testStrInner[NAPI_UT_STR_LENGTH + 1];
575 size_t outStrLength = 0;
576 memset_s(testStrInner, testStrLength + 1, 0, testStrLength + 1);
577 ASSERT_CHECK_CALL(napi_get_value_string_utf8(env, propName, testStrInner, testStrLength, &outStrLength));
578
579 int ret = strcmp(testStrInner, names[i]);
580 ASSERT_EQ(ret, 0);
581 }
582 }
583
584 HWTEST_F(NapiExtTest, TagObjectTest001, testing::ext::TestSize.Level1)
585 {
586 napi_env env = (napi_env)engine_;
587 napi_value object = nullptr;
588 const napi_type_tag typeTag = { 0xFFFFFFFFFFFFFFFF, 34ULL };
589
590 ASSERT_CHECK_CALL(napi_create_object(env, &object));
591
592 ASSERT_CHECK_CALL(napi_type_tag_object(env, object, &typeTag));
593
594 bool checkResult = false;
595
596 ASSERT_CHECK_CALL(napi_check_object_type_tag(env, object, &typeTag, &checkResult));
597 ASSERT_TRUE(checkResult);
598 }
599 #endif
600
601 HWTEST_F(NapiExtTest, GetDateTest001, testing::ext::TestSize.Level1)
602 {
603 napi_env env = (napi_env)engine_;
604 napi_value createResult = nullptr;
605 double time = 202110181203150;
606
607 ASSERT_CHECK_CALL(napi_create_date(env, time, &createResult));
608
609 double getTime = false;
610
611 ASSERT_CHECK_CALL(napi_get_date_value(env, createResult, &getTime));
612 bool result = false;
613 if (time == getTime) {
614 result = true;
615 }
616 ASSERT_TRUE(result);
617 }
618
619 HWTEST_F(NapiExtTest, IsDateTest001, testing::ext::TestSize.Level1)
620 {
621 napi_env env = (napi_env)engine_;
622 napi_value createResult = nullptr;
623 double time = 202110181203150;
624
625 ASSERT_CHECK_CALL(napi_create_date(env, time, &createResult));
626
627 bool result = false;
628
629 ASSERT_CHECK_CALL(napi_is_date(env, createResult, &result));
630
631 ASSERT_TRUE(result);
632 }
633
634 /**
635 * @tc.name: ACE_napi_adjust_external_memory_test.
636 * @tc.desc: Test napi_adjust_external_memory.
637 * @tc.type: FUNC
638 */
639 HWTEST_F(NapiExtTest, AdjustExternalMemoryTest001, testing::ext::TestSize.Level1)
640 {
641 HILOG_INFO("%{public}s", "ACE_napi_adjust_external_memory_test start");
642 napi_env env = (napi_env)engine_;
643 int64_t changeInBytes = 32;
644 int64_t adjustedValue = 32;
645 napi_status ret = napi_adjust_external_memory(env, changeInBytes, &adjustedValue);
646 ASSERT_EQ(ret, napi_ok);
647 HILOG_INFO("%{public}s", "ACE_napi_adjust_external_memory_test end");
648 }
649
650 /**
651 * @tc.name: ACE_napi_async_init_Test.
652 * @tc.desc: Test napi_async_init, napi_async_destroy.
653 * @tc.type: FUNC
654 */
655 HWTEST_F(NapiExtTest, AsyncInitTest001, testing::ext::TestSize.Level1)
656 {
657 HILOG_INFO("ACE_napi_async_init_Test_001 start");
658
659 napi_env env = (napi_env)engine_;
660
661 napi_value resourceName;
662 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, "ACE_napi_async_init_Test_001",
663 NAPI_AUTO_LENGTH, &resourceName));
664
665 napi_async_context context = nullptr;
666 napi_status ret = napi_async_init(env, nullptr, resourceName, &context);
667 ASSERT_EQ(ret, napi_ok);
668 EXPECT_NE(context, nullptr);
669
670 ret = napi_async_destroy(env, context);
671 ASSERT_EQ(ret, napi_ok);
672
673 HILOG_INFO("ACE_napi_async_init_Test_001 end");
674 }
675
676 /**
677 * @tc.name: ACE_napi_open_callback_scope_Test
678 * @tc.desc: Test napi_open_callback_scope, napi_close_callback_scope.
679 * @tc.type: FUNC
680 */
681 HWTEST_F(NapiExtTest, OpenCallbackScopeTest001, testing::ext::TestSize.Level1)
682 {
683 HILOG_INFO("ACE_napi_open_callback_scope_Test_001 start");
684
685 napi_env env = (napi_env)engine_;
686
687 auto callbackScopeManager = engine_->GetCallbackScopeManager();
688 ASSERT_NE(callbackScopeManager, nullptr);
689
690 int openCallbackScopesBefore = callbackScopeManager->GetOpenCallbackScopes();
691 int asyncCallbackScopeDepthBefore = callbackScopeManager->GetAsyncCallbackScopeDepth();
692
693 napi_value resourceName;
694 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &resourceName));
695
696 napi_async_context context;
697 NAPI_CALL_RETURN_VOID(env, napi_async_init(env, nullptr, resourceName, &context));
698
699 napi_callback_scope scope = nullptr;
700 napi_status ret = napi_open_callback_scope(env, NULL, context, &scope);
701 EXPECT_EQ(ret, napi_ok);
702 EXPECT_NE(scope, nullptr);
703
704 int openCallbackScopes = callbackScopeManager->GetOpenCallbackScopes();
705 int asyncCallbackScopeDepth = callbackScopeManager->GetAsyncCallbackScopeDepth();
706 EXPECT_EQ(openCallbackScopes, (openCallbackScopesBefore + 1));
707 EXPECT_EQ(asyncCallbackScopeDepth, (asyncCallbackScopeDepthBefore + 1));
708
709 ret = napi_close_callback_scope(env, scope);
710 EXPECT_EQ(ret, napi_ok);
711
712 int openCallbackScopesAfter = callbackScopeManager->GetOpenCallbackScopes();
713 int asyncCallbackScopeDepthAfter = callbackScopeManager->GetAsyncCallbackScopeDepth();
714 EXPECT_EQ(openCallbackScopesAfter, openCallbackScopesBefore);
715 EXPECT_EQ(asyncCallbackScopeDepthAfter, asyncCallbackScopeDepthBefore);
716
717 NAPI_CALL_RETURN_VOID(env, napi_async_destroy(env, context));
718
719 HILOG_INFO("ACE_napi_open_callback_scope_Test_001 end");
720 }
721
722 /**
723 * @tc.name: ACE_napi_open_callback_scope_Test
724 * @tc.desc: Test napi_open_callback_scope, napi_close_callback_scope.
725 * @tc.type: FUNC
726 */
727 HWTEST_F(NapiExtTest, OpenCallbackScopeTest002, testing::ext::TestSize.Level1)
728 {
729 HILOG_INFO("ACE_napi_open_callback_scope_Test_002 start");
730
731 napi_env env = (napi_env)engine_;
732
733 auto callbackScopeManager = engine_->GetCallbackScopeManager();
734 ASSERT_NE(callbackScopeManager, nullptr);
735
736 int openCallbackScopesBefore = callbackScopeManager->GetOpenCallbackScopes();
737 int asyncCallbackScopeDepthBefore = callbackScopeManager->GetAsyncCallbackScopeDepth();
738
739 napi_value resourceName;
740 NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env, "test", NAPI_AUTO_LENGTH, &resourceName));
741
742 napi_async_context context;
743 NAPI_CALL_RETURN_VOID(env, napi_async_init(env, nullptr, resourceName, &context));
744
745 napi_callback_scope scope = nullptr;
746 napi_status ret = napi_open_callback_scope(env, NULL, context, &scope);
747 EXPECT_EQ(ret, napi_ok);
748 EXPECT_NE(scope, nullptr);
749
750 int openCallbackScopes1 = callbackScopeManager->GetOpenCallbackScopes();
751 int asyncCallbackScopeDepth1 = callbackScopeManager->GetAsyncCallbackScopeDepth();
752
753 // Open a internal callback scope
754 auto scope2 = callbackScopeManager->Open(engine_);
755 int openCallbackScopes2 = callbackScopeManager->GetOpenCallbackScopes();
756 int asyncCallbackScopeDepth2 = callbackScopeManager->GetAsyncCallbackScopeDepth();
757
758 EXPECT_NE(scope2, nullptr);
759 EXPECT_EQ(openCallbackScopes2, openCallbackScopes1);
760 EXPECT_EQ(asyncCallbackScopeDepth2, (asyncCallbackScopeDepth1 + 1));
761
762 callbackScopeManager->Close(scope2);
763 int openCallbackScopes2After = callbackScopeManager->GetOpenCallbackScopes();
764 int asyncCallbackScopeDepth2After = callbackScopeManager->GetAsyncCallbackScopeDepth();
765
766 EXPECT_EQ(openCallbackScopes2After, openCallbackScopes1);
767 EXPECT_EQ(asyncCallbackScopeDepth2After, asyncCallbackScopeDepth1);
768
769 ret = napi_close_callback_scope(env, scope);
770 EXPECT_EQ(ret, napi_ok);
771
772 int openCallbackScopes1After = callbackScopeManager->GetOpenCallbackScopes();
773 int asyncCallbackScopeDepth1After = callbackScopeManager->GetAsyncCallbackScopeDepth();
774
775 EXPECT_EQ(openCallbackScopes1After, openCallbackScopesBefore);
776 EXPECT_EQ(asyncCallbackScopeDepth1After, asyncCallbackScopeDepthBefore);
777
778 NAPI_CALL_RETURN_VOID(env, napi_async_destroy(env, context));
779
780 HILOG_INFO("ACE_napi_open_callback_scope_Test_002 end");
781 }
782
TestFatalException(napi_env env,napi_callback_info info)783 static napi_value TestFatalException(napi_env env, napi_callback_info info)
784 {
785 napi_value err;
786 size_t argc = 1;
787
788 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &err, nullptr, nullptr));
789 NAPI_CALL(env, napi_fatal_exception(env, err));
790 return nullptr;
791 }
792
793 /**
794 * @tc.name: FatalException
795 * @tc.desc: Test FatalException Func.
796 * @tc.type: FUNC
797 */
798 HWTEST_F(NapiExtTest, FatalExceptionTest001, testing::ext::TestSize.Level1)
799 {
800 napi_env env = (napi_env)engine_;
801 ASSERT_EQ(TestFatalException(env, nullptr), nullptr);
802 }
803
804 HWTEST_F(NapiExtTest, AddFinalizerTest001, testing::ext::TestSize.Level1)
805 {
806 HILOG_INFO("add_finalizer_test_0100 start");
807 napi_env env = (napi_env)engine_;
808
809 napi_value object;
810 NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &object));
811
812 static bool testValue = false;
813 const char* testStr = "test";
814 napi_ref ref = nullptr;
815 napi_add_finalizer(
__anon40fe77970402(napi_env env, void* data, void* hint) 816 env, object, (void*)testStr, [](napi_env env, void* data, void* hint) {
817 testValue = true;
818 }, nullptr, &ref);
819
820 napi_delete_reference(env, ref);
821 ASSERT_TRUE(testValue);
822 HILOG_INFO("add_finalizer_test_0100 end");
823 }
824
825 typedef struct {
826 size_t value;
827 bool print;
828 napi_ref js_cb_ref;
829 } AddonData;
830
DeleteAddonData(napi_env env,void * raw_data,void * hint)831 static void DeleteAddonData(napi_env env, void* raw_data, void* hint)
832 {
833 AddonData* data = (AddonData*)raw_data;
834 if (data->print) {
835 printf("deleting addon data\n");
836 }
837 if (data->js_cb_ref != NULL) {
838 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref));
839 }
840 free(data);
841 }
842
SetPrintOnDelete(napi_env env,napi_callback_info info)843 static napi_value SetPrintOnDelete(napi_env env, napi_callback_info info)
844 {
845 AddonData* data;
846 NAPI_CALL(env, napi_get_instance_data(env, (void**)&data));
847 data->print = true;
848 return NULL;
849 }
850
TestFinalizer(napi_env env,void * raw_data,void * hint)851 static void TestFinalizer(napi_env env, void* raw_data, void* hint)
852 {
853 (void)raw_data;
854 (void)hint;
855
856 AddonData* data;
857 napi_value jsResult;
858 NAPI_CALL_RETURN_VOID(env, napi_get_instance_data(env, (void**)&data));
859 napi_value js_cb, undefined;
860 NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, data->js_cb_ref, &js_cb));
861 NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined));
862 NAPI_CALL_RETURN_VOID(env, napi_call_function(env, undefined, js_cb, 0, NULL, &jsResult));
863
864 NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, data->js_cb_ref));
865 data->js_cb_ref = NULL;
866 }
867
ObjectWithFinalizer(napi_env env,napi_callback_info info)868 static napi_value ObjectWithFinalizer(napi_env env, napi_callback_info info)
869 {
870 HILOG_INFO("%{public}s", "start.");
871 AddonData* data;
872
873 napi_value result, js_cb;
874 size_t argc = 1;
875
876 auto func = [](napi_env env, napi_callback_info info) -> napi_value {
877 HILOG_INFO("%{public}s", "function called");
878 return nullptr;
879 };
880
881 napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &js_cb);
882
883 NAPI_CALL(env, napi_get_instance_data(env, (void**)&data));
884 NAPI_ASSERT(env, data->js_cb_ref == NULL, "reference must be NULL");
885 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &js_cb, NULL, NULL));
886 NAPI_CALL(env, napi_create_object(env, &result));
887 NAPI_CALL(env, napi_add_finalizer(env, result, NULL, TestFinalizer, NULL, NULL));
888 NAPI_CALL(env, napi_create_reference(env, js_cb, 1, &data->js_cb_ref));
889 HILOG_INFO("%{public}s", "end.");
890 return nullptr;
891 }
892
893 HWTEST_F(NapiExtTest, InstanceDataTest_001, testing::ext::TestSize.Level1)
894 {
895 napi_env env = (napi_env)engine_;
896 // Set instance data
897 AddonData* data = (AddonData*)malloc(sizeof(*data));
898 data->value = 41;
899 data->print = false;
900 data->js_cb_ref = NULL;
901 ASSERT_CHECK_CALL(napi_set_instance_data(env, data, DeleteAddonData, NULL));
902
903 // Test get instance data
904 AddonData* get_data = nullptr;
905 ASSERT_CHECK_CALL(napi_get_instance_data(env, (void**)&get_data));
906 ++get_data->value;
907 const size_t expectValue = 42;
908 ASSERT_EQ(get_data->value, expectValue);
909
910 // Test finalizer
911 SetPrintOnDelete(env, nullptr);
912 ObjectWithFinalizer(env, nullptr);
913 }
914