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
36using namespace Commonlibrary::Concurrent::Common::Helper;
37
38HWTEST_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
49HWTEST_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
59HWTEST_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
70HWTEST_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
103HWTEST_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
112HWTEST_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
129HWTEST_F(NativeEngineTest, IsFunctionTest001, testing::ext::TestSize.Level0)
130{
131    napi_env env = (napi_env)engine_;
132
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
145HWTEST_F(NativeEngineTest, GetCallbackInfoArgc001, testing::ext::TestSize.Level0)
146{
147    napi_env env = (napi_env)engine_;
148
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
187HWTEST_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
203HWTEST_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
214HWTEST_F(NativeEngineTest, IsCallable001, testing::ext::TestSize.Level0)
215{
216    napi_env env = (napi_env)engine_;
217
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
256HWTEST_F(NativeEngineTest, IsCallable002, testing::ext::TestSize.Level0)
257{
258    napi_env env = (napi_env)engine_;
259
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
301HWTEST_F(NativeEngineTest, IsCallable003, testing::ext::TestSize.Level0)
302{
303    napi_env env = (napi_env)engine_;
304
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
320HWTEST_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
339HWTEST_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
350HWTEST_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
365HWTEST_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
382HWTEST_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
391HWTEST_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
400HWTEST_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
421HWTEST_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
430HWTEST_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
439HWTEST_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
458HWTEST_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
472HWTEST_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
491HWTEST_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
503HWTEST_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
516HWTEST_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,
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
537HWTEST_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
544HWTEST_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
554HWTEST_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
565HWTEST_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
579HWTEST_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
588HWTEST_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
599HWTEST_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
608HWTEST_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
617HWTEST_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
626HWTEST_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
642HWTEST_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
657HWTEST_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
667HWTEST_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
676HWTEST_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
692HWTEST_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
703HWTEST_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
712HWTEST_F(NativeEngineTest, GetArrayLengthTest001, testing::ext::TestSize.Level0)
713{
714    napi_env env = (napi_env)engine_;
715
716    napi_value result = NapiHelper::CreateObject(env);
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
735HWTEST_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
748HWTEST_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
760HWTEST_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,
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
787HWTEST_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
797HWTEST_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
809HWTEST_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}