1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "test.h"
17 #include "napi/native_api.h"
18 #include "napi/native_node_api.h"
19 #include "napi_helper.h"
20 #include <securec.h>
21 #include "tools/log.h"
22 
23 #define ASSERT_CHECK_CALL(call)   \
24     {                             \
25         ASSERT_EQ(call, napi_ok); \
26     }
27 
28 #define ASSERT_CHECK_VALUE_TYPE(env, value, type)               \
29     {                                                           \
30         napi_valuetype valueType = napi_undefined;              \
31         ASSERT_TRUE(value != nullptr);                          \
32         ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
33         ASSERT_EQ(valueType, type);                             \
34     }
35 
36 using namespace Commonlibrary::Concurrent::Common::Helper;
37 
38 HWTEST_F(NativeEngineTest, IsStringTest001, testing::ext::TestSize.Level0)
39 {
40     napi_env env = (napi_env)engine_;
41     napi_value value = nullptr;
42     std::string str = "test";
43     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value);
44     bool res;
45     res = NapiHelper::IsString(env, value);
46     ASSERT_TRUE(res);
47 }
48 
49 HWTEST_F(NativeEngineTest, IsNotUndefinedTest001, testing::ext::TestSize.Level0)
50 {
51     napi_env env = (napi_env)engine_;
52     napi_value value = nullptr;
53     ASSERT_CHECK_CALL(napi_get_undefined(env, &value));
54     bool res;
55     res = NapiHelper::IsNotUndefined(env, value) ? false : true;
56     ASSERT_TRUE(res);
57 }
58 
59 HWTEST_F(NativeEngineTest, IsNotUndefinedTest002, testing::ext::TestSize.Level0)
60 {
61     napi_env env = (napi_env)engine_;
62     napi_value param = nullptr;
63     std::string str = "test";
64     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &param);
65     env = nullptr;
66     bool res = NapiHelper::IsNotUndefined(env, param);
67     ASSERT_FALSE(res);
68 }
69 
70 HWTEST_F(NativeEngineTest, IsArrayTest001, testing::ext::TestSize.Level0)
71 {
72     napi_env env = (napi_env)engine_;
73 
74     napi_value result = nullptr;
75     ASSERT_CHECK_CALL(napi_create_object(env, &result));
76     ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
77 
78     const char testStr[] = "1234567";
79     napi_value strAttribute = nullptr;
80     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
81     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
82     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "strAttribute", strAttribute));
83 
84     napi_value retStrAttribute = nullptr;
85     ASSERT_CHECK_CALL(napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
86     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
87 
88     int32_t testNumber = 12345; // 12345 : indicates any number
89     napi_value numberAttribute = nullptr;
90     ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
91     ASSERT_CHECK_VALUE_TYPE(env, numberAttribute, napi_number);
92     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "numberAttribute", numberAttribute));
93 
94     napi_value propNames = nullptr;
95     ASSERT_CHECK_CALL(napi_get_property_names(env, result, &propNames));
96     ASSERT_CHECK_VALUE_TYPE(env, propNames, napi_object);
97     bool isArray = false;
98     isArray = NapiHelper::IsArray(env, propNames);
99 
100     ASSERT_TRUE(isArray);
101 }
102 
103 HWTEST_F(NativeEngineTest, IsArrayTest002, testing::ext::TestSize.Level0)
104 {
105     napi_env env = (napi_env)engine_;
106     napi_value propNames = nullptr;
107     bool res = NapiHelper::IsArray(env, propNames);
108 
109     ASSERT_FALSE(res);
110 }
111 
112 HWTEST_F(NativeEngineTest, IsArrayTest003, testing::ext::TestSize.Level0)
113 {
114     napi_env env = (napi_env)engine_;
115 
116     napi_value result = nullptr;
117     ASSERT_CHECK_CALL(napi_create_object(env, &result));
118     ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
119 
120     const char testStr[] = "1234567";
121     napi_value strAttribute = nullptr;
122     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
123 
124     bool res = NapiHelper::IsArray(env, strAttribute);
125 
126     ASSERT_FALSE(res);
127 }
128 
129 HWTEST_F(NativeEngineTest, IsFunctionTest001, testing::ext::TestSize.Level0)
130 {
131     napi_env env = (napi_env)engine_;
132 
__anon35c8744e0102(napi_env env, napi_callback_info info) 133     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
134         return nullptr;
135     };
136 
137     napi_value value = nullptr;
138     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &value);
139     ASSERT_NE(value, nullptr);
140     bool res;
141     res = NapiHelper::IsFunction(env, value);
142     ASSERT_TRUE(res);
143 }
144 
145 HWTEST_F(NativeEngineTest, GetCallbackInfoArgc001, testing::ext::TestSize.Level0)
146 {
147     napi_env env = (napi_env)engine_;
148 
__anon35c8744e0202(napi_env env, napi_callback_info info) 149     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
150         napi_value thisVar;
151         napi_value* argv = nullptr;
152         size_t argc = 0;
153         void* data = nullptr;
154 
155         argc = NapiHelper::GetCallbackInfoArgc(env, info);
156         if (argc > 0) {
157             argv = new napi_value[argc];
158         }
159         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
160 
161         napi_value result = nullptr;
162         napi_create_object(env, &result);
163 
164         napi_value messageKey = nullptr;
165         const char* messageKeyStr = "message";
166         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
167         napi_value messageValue = nullptr;
168         const char* messageValueStr = "OK";
169         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
170         napi_set_property(env, result, messageKey, messageValue);
171 
172         if (argv != nullptr) {
173             delete []argv;
174         }
175         return result;
176     };
177 
178     napi_value funcValue = nullptr;
179     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
180     ASSERT_NE(funcValue, nullptr);
181 
182     bool result = false;
183     napi_is_callable(env, funcValue, &result);
184     ASSERT_TRUE(result);
185 }
186 
187 HWTEST_F(NativeEngineTest, GetNamePropertyInParentPort001, testing::ext::TestSize.Level0)
188 {
189     napi_env env = (napi_env)engine_;
190 
191     napi_value result = nullptr;
192     napi_ref resultRef = nullptr;
193 
194     napi_create_object(env, &result);
195     resultRef = NapiHelper::CreateReference(env, result, 1);
196 
197     napi_value value = nullptr;
198 
199     value = NapiHelper::GetNamePropertyInParentPort(env, resultRef, "test");
200     ASSERT_TRUE(value != nullptr);
201 }
202 
203 HWTEST_F(NativeEngineTest, GetUndefinedValue001, testing::ext::TestSize.Level0)
204 {
205     napi_env env = (napi_env)engine_;
206     napi_value value = nullptr;
207 
208     value = NapiHelper::GetUndefinedValue(env);
209     bool res = false;
210     res = NapiHelper::IsNotUndefined(env, value) ? false : true;
211     ASSERT_TRUE(res);
212 }
213 
214 HWTEST_F(NativeEngineTest, IsCallable001, testing::ext::TestSize.Level0)
215 {
216     napi_env env = (napi_env)engine_;
217 
__anon35c8744e0302(napi_env env, napi_callback_info info) 218     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
219         napi_value thisVar;
220         napi_value* argv = nullptr;
221         size_t argc = 0;
222         void* data = nullptr;
223 
224         napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
225         if (argc > 0) {
226             argv = new napi_value[argc];
227         }
228         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
229 
230         napi_value result = nullptr;
231         napi_create_object(env, &result);
232 
233         napi_value messageKey = nullptr;
234         const char* messageKeyStr = "message";
235         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
236         napi_value messageValue = nullptr;
237         const char* messageValueStr = "OK";
238         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
239         napi_set_property(env, result, messageKey, messageValue);
240 
241         if (argv != nullptr) {
242             delete []argv;
243         }
244         return result;
245     };
246 
247     napi_value funcValue = nullptr;
248     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
249     ASSERT_NE(funcValue, nullptr);
250 
251     bool result = false;
252     result = NapiHelper::IsCallable(env, funcValue);
253     ASSERT_TRUE(result);
254 }
255 
256 HWTEST_F(NativeEngineTest, IsCallable002, testing::ext::TestSize.Level0)
257 {
258     napi_env env = (napi_env)engine_;
259 
__anon35c8744e0402(napi_env env, napi_callback_info info) 260     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
261         napi_value thisVar;
262         napi_value* argv = nullptr;
263         size_t argc = 0;
264         void* data = nullptr;
265 
266         napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
267         if (argc > 0) {
268             argv = new napi_value[argc];
269         }
270         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
271 
272         napi_value result = nullptr;
273         napi_create_object(env, &result);
274 
275         napi_value messageKey = nullptr;
276         const char* messageKeyStr = "message";
277         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
278         napi_value messageValue = nullptr;
279         const char* messageValueStr = "OK";
280         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
281         napi_set_property(env, result, messageKey, messageValue);
282 
283         if (argv != nullptr) {
284             delete []argv;
285         }
286         return result;
287     };
288 
289     napi_value funcValue = nullptr;
290     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
291     ASSERT_NE(funcValue, nullptr);
292 
293     napi_ref resultRef = nullptr;
294     resultRef = NapiHelper::CreateReference(env, funcValue, 1);
295 
296     bool result = false;
297     result = NapiHelper::IsCallable(env, resultRef);
298     ASSERT_TRUE(result);
299 }
300 
301 HWTEST_F(NativeEngineTest, IsCallable003, testing::ext::TestSize.Level0)
302 {
303     napi_env env = (napi_env)engine_;
304 
__anon35c8744e0502(napi_env env, napi_callback_info info) 305     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
306         return nullptr;
307     };
308 
309     napi_value funcValue = nullptr;
310     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
311     ASSERT_NE(funcValue, nullptr);
312 
313     napi_ref resultRef = nullptr;
314 
315     bool result = false;
316     result = NapiHelper::IsCallable(env, resultRef);
317     ASSERT_FALSE(result);
318 }
319 
320 HWTEST_F(NativeEngineTest, SetNamePropertyInGlobal001, testing::ext::TestSize.Level0)
321 {
322     napi_env env = (napi_env)engine_;
323 
324     const char testStr[] = "1234567";
325     napi_value strAttribute = nullptr;
326     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
327     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
328 
329 
330     NapiHelper::SetNamePropertyInGlobal(env, "strAttribute", strAttribute);
331     napi_value result = nullptr;
332     result = NapiHelper::GetGlobalObject(env);
333 
334     napi_value retStrAttribute = nullptr;
335     ASSERT_CHECK_CALL(napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
336     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
337 }
338 
339 HWTEST_F(NativeEngineTest, IsObject001, testing::ext::TestSize.Level0)
340 {
341     napi_env env = (napi_env)engine_;
342     napi_value value = nullptr;
343 
344     napi_create_object(env, &value);
345     bool res = false;
346     res = NapiHelper::IsObject(env, value);
347     ASSERT_TRUE(res);
348 }
349 
350 HWTEST_F(NativeEngineTest, GetString001, testing::ext::TestSize.Level0)
351 {
352     napi_env env = (napi_env)engine_;
353     napi_value value = nullptr;
354 
355     std::string str = "test";
356     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value);
357     bool res = false;
358     res = NapiHelper::IsString(env, value);
359     ASSERT_TRUE(res);
360 
361     std::string s = NapiHelper::GetString(env, value);
362     ASSERT_EQ(str, s);
363 }
364 
365 HWTEST_F(NativeEngineTest, GetString002, testing::ext::TestSize.Level0)
366 {
367     napi_env env = (napi_env)engine_;
368     napi_value value = nullptr;
369 
370     size_t MAX_CHAR_LENGTH = 1025;
371     char* buffer = new char[MAX_CHAR_LENGTH];
372     memset_s(buffer, MAX_CHAR_LENGTH, 1, MAX_CHAR_LENGTH);
373     napi_create_string_utf8(env, buffer, MAX_CHAR_LENGTH, &value);
374 
375     char* script = NapiHelper::GetChars(env, value);
376     size_t len = strlen(script);
377     delete[] script;
378     delete[] buffer;
379     ASSERT_EQ(len, 1024);
380 }
381 
382 HWTEST_F(NativeEngineTest, CreateBooleanValue001, testing::ext::TestSize.Level0)
383 {
384     napi_env env = (napi_env)engine_;
385     napi_value value = nullptr;
386 
387     value = NapiHelper::CreateBooleanValue(env, true);
388     ASSERT_CHECK_VALUE_TYPE(env, value, napi_boolean);
389 }
390 
391 HWTEST_F(NativeEngineTest, GetGlobalObject001, testing::ext::TestSize.Level0)
392 {
393     napi_env env = (napi_env)engine_;
394     napi_value value = nullptr;
395 
396     value = NapiHelper::GetGlobalObject(env);
397     ASSERT_CHECK_VALUE_TYPE(env, value, napi_object);
398 }
399 
400 HWTEST_F(NativeEngineTest, CreateReference001, testing::ext::TestSize.Level0)
401 {
402     napi_env env = (napi_env)engine_;
403 
404     napi_value result = nullptr;
405     napi_ref resultRef = nullptr;
406 
407     napi_create_object(env, &result);
408     resultRef = NapiHelper::CreateReference(env, result, 1);
409 
410     uint32_t resultRefCount = 0;
411 
412     napi_reference_ref(env, resultRef, &resultRefCount);
413     ASSERT_EQ(resultRefCount, (uint32_t)2); // 2 : means count of resultRef
414 
415     napi_reference_unref(env, resultRef, &resultRefCount);
416     ASSERT_EQ(resultRefCount, (uint32_t)1);
417 
418     NapiHelper::DeleteReference(env, resultRef);
419 }
420 
421 HWTEST_F(NativeEngineTest, CreateUint32001, testing::ext::TestSize.Level0)
422 {
423     napi_env env = (napi_env)engine_;
424     uint32_t testValue = UINT32_MAX;
425     napi_value result = nullptr;
426     result = NapiHelper::CreateUint32(env, testValue);
427     ASSERT_CHECK_VALUE_TYPE(env, result, napi_number);
428 }
429 
430 HWTEST_F(NativeEngineTest, GetLibUV001, testing::ext::TestSize.Level0)
431 {
432     napi_env env = (napi_env)engine_;
433     uv_loop_t* loop;
434     loop = NapiHelper::GetLibUV(env);
435 
436     ASSERT_NE(loop, nullptr);
437 }
438 
439 HWTEST_F(NativeEngineTest, GetReferenceValue001, testing::ext::TestSize.Level0)
440 {
441     napi_env env = (napi_env)engine_;
442 
443     napi_value result = nullptr;
444     napi_ref resultRef = nullptr;
445 
446     napi_create_object(env, &result);
447     napi_create_reference(env, result, 1, &resultRef);
448 
449     napi_value refValue = nullptr;
450 
451     refValue = NapiHelper::GetReferenceValue(env, resultRef);
452 
453     ASSERT_NE(refValue, nullptr);
454 
455     NapiHelper::DeleteReference(env, resultRef);
456 }
457 
458 HWTEST_F(NativeEngineTest, DeleteReference001, testing::ext::TestSize.Level0)
459 {
460     napi_env env = (napi_env)engine_;
461 
462     napi_value result = nullptr;
463     napi_ref resultRef = nullptr;
464 
465     napi_create_object(env, &result);
466     napi_create_reference(env, result, 1, &resultRef);
467     ASSERT_NE(resultRef, nullptr);
468 
469     NapiHelper::DeleteReference(env, resultRef);
470 }
471 
472 HWTEST_F(NativeEngineTest, GetNameProperty001, testing::ext::TestSize.Level0)
473 {
474     napi_env env = (napi_env)engine_;
475 
476     const char testStr[] = "1234567";
477     napi_value strAttribute = nullptr;
478     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
479     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
480 
481 
482     NapiHelper::SetNamePropertyInGlobal(env, "strAttribute", strAttribute);
483     napi_value result = nullptr;
484     result = NapiHelper::GetGlobalObject(env);
485 
486     napi_value retStrAttribute = nullptr;
487     retStrAttribute = NapiHelper::GetNameProperty(env, result, "strAttribute");
488     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
489 }
490 
491 HWTEST_F(NativeEngineTest, GetBooleanValue001, testing::ext::TestSize.Level0)
492 {
493     napi_env env = (napi_env)engine_;
494     napi_value result = nullptr;
495     result = NapiHelper::CreateBooleanValue(env, true);
496     ASSERT_CHECK_VALUE_TYPE(env, result, napi_boolean);
497 
498     bool resultValue = false;
499     resultValue = NapiHelper::GetBooleanValue(env, result);
500     ASSERT_TRUE(resultValue);
501 }
502 
503 HWTEST_F(NativeEngineTest, StrictEqual001, testing::ext::TestSize.Level0)
504 {
505     napi_env env = (napi_env)engine_;
506 
507     const char* testStringStr = "test";
508     napi_value testString = nullptr;
509     napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
510     bool isStrictEquals = false;
511 
512     isStrictEquals = NapiHelper::StrictEqual(env, testString, testString);
513     ASSERT_TRUE(isStrictEquals);
514 }
515 
516 HWTEST_F(NativeEngineTest, GetConstructorName001, testing::ext::TestSize.Level0)
517 {
518     napi_env env = (napi_env)engine_;
519 
520     napi_value testClass = nullptr;
521     napi_define_class(
522         env, "TestClass", NAPI_AUTO_LENGTH,
__anon35c8744e0602(napi_env env, napi_callback_info info) 523         [](napi_env env, napi_callback_info info) -> napi_value {
524             napi_value thisVar = nullptr;
525             napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
526 
527             return thisVar;
528         }, nullptr, 0, nullptr, &testClass);
529 
530     napi_value testInstance = nullptr;
531     ASSERT_CHECK_CALL(napi_new_instance(env, testClass, 0, nullptr, &testInstance));
532     napi_set_named_property(env, testInstance, "constructor", testClass);
533     std::string resVal = NapiHelper::GetConstructorName(env, testInstance);
534     ASSERT_EQ(resVal, "TestClass");
535 }
536 
537 HWTEST_F(NativeEngineTest, IsTypeForNapiValueTest001, testing::ext::TestSize.Level0)
538 {
539     napi_env env = (napi_env)engine_;
540     napi_value param = nullptr;
541     ASSERT_FALSE(NapiHelper::IsTypeForNapiValue(env, param, napi_undefined));
542 }
543 
544 HWTEST_F(NativeEngineTest, IsTypeForNapiValueTest002, testing::ext::TestSize.Level0)
545 {
546     napi_env env = (napi_env)engine_;
547     napi_value param = nullptr;
548     std::string str = "test";
549     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &param);
550     env = nullptr;
551     ASSERT_FALSE(NapiHelper::IsTypeForNapiValue(env, param, napi_string));
552 }
553 
554 HWTEST_F(NativeEngineTest, IsNumberTest001, testing::ext::TestSize.Level0)
555 {
556     napi_env env = (napi_env)engine_;
557     int32_t testNumber = 12345;
558     napi_value numberAttribute = nullptr;
559     ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
560 
561     bool res = NapiHelper::IsNumber(env, numberAttribute);
562     ASSERT_TRUE(res);
563 }
564 
565 HWTEST_F(NativeEngineTest, IsArrayBufferTest001, testing::ext::TestSize.Level0)
566 {
567     napi_env env = (napi_env)engine_;
568     napi_value arrayBuffer = nullptr;
569     void* arrayBufferPtr = nullptr;
570     size_t arrayBufferSize = 1024;
571     napi_create_arraybuffer(env, arrayBufferSize, &arrayBufferPtr, &arrayBuffer);
572     ASSERT_NE(arrayBuffer, nullptr);
573     ASSERT_NE(arrayBufferPtr, nullptr);
574 
575     bool res = NapiHelper::IsArrayBuffer(env, arrayBuffer);
576     ASSERT_TRUE(res);
577 }
578 
579 HWTEST_F(NativeEngineTest, IsArrayBufferTest002, testing::ext::TestSize.Level0)
580 {
581     napi_env env = (napi_env)engine_;
582     napi_value arraybuffer = nullptr;
583 
584     bool res = NapiHelper::IsArrayBuffer(env, arraybuffer);
585     ASSERT_FALSE(res);
586 }
587 
588 HWTEST_F(NativeEngineTest, IsArrayBufferTest003, testing::ext::TestSize.Level0)
589 {
590     napi_env env = (napi_env)engine_;
591     int32_t testNumber = 12345;
592     napi_value numberAttribute = nullptr;
593     ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
594 
595     bool res = NapiHelper::IsArrayBuffer(env, numberAttribute);
596     ASSERT_FALSE(res);
597 }
598 
599 HWTEST_F(NativeEngineTest, IsAsyncFunctionTest001, testing::ext::TestSize.Level0)
600 {
601     napi_env env = (napi_env)engine_;
602     napi_value value = nullptr;
603 
604     bool res = NapiHelper::IsAsyncFunction(env, value);
605     ASSERT_FALSE(res);
606 }
607 
608 HWTEST_F(NativeEngineTest, IsConcurrentFunctionTest001, testing::ext::TestSize.Level0)
609 {
610     napi_env env = (napi_env)engine_;
611     napi_value value = nullptr;
612 
613     bool res = NapiHelper::IsConcurrentFunction(env, value);
614     ASSERT_FALSE(res);
615 }
616 
617 HWTEST_F(NativeEngineTest, IsGeneratorFunctionTest001, testing::ext::TestSize.Level0)
618 {
619     napi_env env = (napi_env)engine_;
620     napi_value value = nullptr;
621 
622     bool res = NapiHelper::IsGeneratorFunction(env, value);
623     ASSERT_FALSE(res);
624 }
625 
626 HWTEST_F(NativeEngineTest, IsStrictEqualTest001, testing::ext::TestSize.Level0)
627 {
628     napi_env env = (napi_env)engine_;
629     napi_value lhs = nullptr;
630     std::string lstr = "test";
631     napi_create_string_utf8(env, lstr.c_str(), NAPI_AUTO_LENGTH, &lhs);
632 
633     napi_value rhs = nullptr;
634     std::string rstr = "test";
635     napi_create_string_utf8(env, rstr.c_str(), NAPI_AUTO_LENGTH, &rhs);
636 
637     bool res = NapiHelper::IsStrictEqual(env, lhs, rhs);
638 
639     ASSERT_TRUE(res);
640 }
641 
642 HWTEST_F(NativeEngineTest, IsStrictEqualTest002, testing::ext::TestSize.Level0)
643 {
644     napi_env env = (napi_env)engine_;
645     napi_value lhs = nullptr;
646     std::string lstr = "test";
647     napi_create_string_utf8(env, lstr.c_str(), NAPI_AUTO_LENGTH, &lhs);
648 
649     napi_value rhs = nullptr;
650     std::string rstr = "test2";
651     napi_create_string_utf8(env, rstr.c_str(), NAPI_AUTO_LENGTH, &rhs);
652 
653     bool res = NapiHelper::IsStrictEqual(env, lhs, rhs);
654     ASSERT_FALSE(res);
655 }
656 
657 HWTEST_F(NativeEngineTest, IsSendableTest001, testing::ext::TestSize.Level0)
658 {
659     napi_env env = (napi_env)engine_;
660     napi_value value = nullptr;
661     ASSERT_CHECK_CALL(napi_create_sendable_map(env, &value));
662 
663     bool res = NapiHelper::IsSendable(env, value);
664     ASSERT_TRUE(res);
665 }
666 
667 HWTEST_F(NativeEngineTest, IsSendableTest002, testing::ext::TestSize.Level0)
668 {
669     napi_env env = (napi_env)engine_;
670     napi_value value = nullptr;
671 
672     bool res = NapiHelper::IsSendable(env, value);
673     ASSERT_FALSE(res);
674 }
675 
676 HWTEST_F(NativeEngineTest, HasNamePropertyTest001, testing::ext::TestSize.Level0)
677 {
678     napi_env env = (napi_env)engine_;
679     napi_value result = nullptr;
680     ASSERT_CHECK_CALL(napi_create_object(env, &result));
681 
682     const char testStr[] = "1234567";
683     napi_value strAttribute = nullptr;
684     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
685     const char* name = "strAttribute";
686     ASSERT_CHECK_CALL(napi_set_named_property(env, result, name, strAttribute));
687 
688     bool res = NapiHelper::HasNameProperty(env, result, name);
689     ASSERT_TRUE(res);
690 }
691 
692 HWTEST_F(NativeEngineTest, HasNamePropertyTest002, testing::ext::TestSize.Level0)
693 {
694     napi_env env = (napi_env)engine_;
695     napi_value result = nullptr;
696     ASSERT_CHECK_CALL(napi_create_object(env, &result));
697     const char* name = "test";
698 
699     bool res = NapiHelper::HasNameProperty(env, result, name);
700     ASSERT_FALSE(res);
701 }
702 
703 HWTEST_F(NativeEngineTest, CreatePromiseTest001, testing::ext::TestSize.Level0)
704 {
705     napi_env env = (napi_env)engine_;
706     napi_deferred deferred = nullptr;
707 
708     napi_value promise = NapiHelper::CreatePromise(env, &deferred);
709     ASSERT_NE(promise, nullptr);
710 }
711 
712 HWTEST_F(NativeEngineTest, GetArrayLengthTest001, testing::ext::TestSize.Level0)
713 {
714     napi_env env = (napi_env)engine_;
715 
716     napi_value result = NapiHelper::CreateObject(env);
__anon35c8744e0702(napi_env env, napi_callback_info info) 717     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
718         return nullptr;
719     };
720     napi_value funcAttribute = nullptr;
721     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcAttribute);
722 
723     napi_value funcKey = nullptr;
724     const char* funcKeyStr = "func";
725     napi_create_string_latin1(env, funcKeyStr, strlen(funcKeyStr), &funcKey);
726     napi_set_property(env, result, funcKey, funcAttribute);
727 
728     napi_value propFuncValue = nullptr;
729     napi_get_property_names(env, result, &propFuncValue);
730 
731     uint32_t arrayLength = NapiHelper::GetArrayLength(env, propFuncValue);
732     ASSERT_EQ(arrayLength, static_cast<uint32_t>(1));
733 }
734 
735 HWTEST_F(NativeEngineTest, GetUint32ValueTest001, testing::ext::TestSize.Level0)
736 {
737     napi_env env = (napi_env)engine_;
738 
739     uint32_t testValue = UINT32_MAX;
740     napi_value result = nullptr;
741     ASSERT_CHECK_CALL(napi_create_uint32(env, testValue, &result));
742     ASSERT_CHECK_VALUE_TYPE(env, result, napi_number);
743 
744     uint32_t resultValue = NapiHelper::GetUint32Value(env, result);
745     ASSERT_EQ(resultValue, UINT32_MAX);
746 }
747 
748 HWTEST_F(NativeEngineTest, GetInt32ValueTest001, testing::ext::TestSize.Level0)
749 {
750     napi_env env = (napi_env)engine_;
751 
752     int32_t testValue = INT32_MAX;
753     napi_value result = nullptr;
754     ASSERT_CHECK_CALL(napi_create_int32(env, testValue, &result));
755 
756     int32_t resultValue = NapiHelper::GetInt32Value(env, result);
757     ASSERT_EQ(resultValue, INT32_MAX);
758 }
759 
760 HWTEST_F(NativeEngineTest, IsExceptionPendingTest001, testing::ext::TestSize.Level0)
761 {
762     napi_env env = (napi_env)engine_;
763 
764     napi_value funcValue = nullptr;
765     napi_value exception = nullptr;
766     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH,
__anon35c8744e0802(napi_env env, napi_callback_info info) 767         [](napi_env env, napi_callback_info info) -> napi_value {
768             napi_value error = nullptr;
769             napi_throw_error(env, "500", "Common error");
770             return error;
771         },
772         nullptr, &funcValue);
773     ASSERT_NE(funcValue, nullptr);
774 
775     napi_value recv = nullptr;
776     napi_get_undefined(env, &recv);
777     ASSERT_NE(recv, nullptr);
778     napi_value funcResultValue = nullptr;
779     napi_call_function(env, recv, funcValue, 0, nullptr, &funcResultValue);
780     bool isExceptionPending = NapiHelper::IsExceptionPending(env);
781     napi_is_exception_pending(env, &isExceptionPending);
782     ASSERT_TRUE(isExceptionPending);
783 
784     napi_get_and_clear_last_exception(env, &exception);
785 }
786 
787 HWTEST_F(NativeEngineTest, GetPrintStringTest001, testing::ext::TestSize.Level0)
788 {
789     napi_env env = (napi_env)engine_;
790 
791     napi_value result = nullptr;
792 
793     std::string str = NapiHelper::GetPrintString(env, result);
794     ASSERT_EQ(str, "");
795 }
796 
797 HWTEST_F(NativeEngineTest, GetUint64ValueTest001, testing::ext::TestSize.Level0)
798 {
799     napi_env env = (napi_env)engine_;
800 
801     uint64_t testValue = UINT64_MAX;
802     napi_value result = nullptr;
803     ASSERT_CHECK_CALL(napi_create_bigint_uint64(env, testValue, &result));
804 
805     int32_t resultValue = NapiHelper::GetUint64Value(env, result);
806     ASSERT_EQ(resultValue, UINT64_MAX);
807 }
808 
809 HWTEST_F(NativeEngineTest, GetElementTest001, testing::ext::TestSize.Level0)
810 {
811     napi_env env = (napi_env)engine_;
812 
813     napi_value result = NapiHelper::CreateObject(env);
814 
815     const char testStr[] = "1234567";
816     napi_value strAttribute = nullptr;
817     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
818     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
819     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "strAttribute", strAttribute));
820 
821     napi_value retStrAttribute = nullptr;
822     ASSERT_CHECK_CALL(napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
823     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
824 
825     int32_t testNumber = 12345;
826     napi_value numberAttribute = nullptr;
827     ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
828     ASSERT_CHECK_VALUE_TYPE(env, numberAttribute, napi_number);
829     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "numberAttribute", numberAttribute));
830 
831     napi_value propNames = nullptr;
832     ASSERT_CHECK_CALL(napi_get_property_names(env, result, &propNames));
833     ASSERT_CHECK_VALUE_TYPE(env, propNames, napi_object);
834     bool isArray = NapiHelper::IsArray(env, propNames);
835     ASSERT_TRUE(isArray);
836 
837     uint32_t arrayLength = NapiHelper::GetArrayLength(env, propNames);
838     ASSERT_EQ(arrayLength, static_cast<uint32_t>(2));
839 
840     for (uint32_t i = 0; i < arrayLength; i++) {
841         napi_value propName = NapiHelper::GetElement(env, propNames, i);
842         ASSERT_CHECK_VALUE_TYPE(env, propName, napi_string);
843     }
844 }