• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "utils/log.h"
21 
22 #define ASSERT_CHECK_CALL(call)   \
23     {                             \
24         ASSERT_EQ(call, napi_ok); \
25     }
26 
27 #define ASSERT_CHECK_VALUE_TYPE(env, value, type)               \
28     {                                                           \
29         napi_valuetype valueType = napi_undefined;              \
30         ASSERT_TRUE(value != nullptr);                          \
31         ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
32         ASSERT_EQ(valueType, type);                             \
33     }
34 
35 using namespace Commonlibrary::Concurrent::Common::Helper;
36 
37 HWTEST_F(NativeEngineTest, IsStringTest001, testing::ext::TestSize.Level0)
38 {
39     napi_env env = (napi_env)engine_;
40     napi_value value = nullptr;
41     std::string str = "test";
42     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value);
43     bool res;
44     res = NapiHelper::IsString(env, value);
45     ASSERT_TRUE(res);
46 }
47 
48 HWTEST_F(NativeEngineTest, IsNotUndefinedTest001, testing::ext::TestSize.Level0)
49 {
50     napi_env env = (napi_env)engine_;
51     napi_value value = nullptr;
52     ASSERT_CHECK_CALL(napi_get_undefined(env, &value));
53     bool res;
54     res = NapiHelper::IsNotUndefined(env, value) ? false : true;
55     ASSERT_TRUE(res);
56 }
57 
58 HWTEST_F(NativeEngineTest, IsArrayTest001, testing::ext::TestSize.Level0)
59 {
60     napi_env env = (napi_env)engine_;
61 
62     napi_value result = nullptr;
63     ASSERT_CHECK_CALL(napi_create_object(env, &result));
64     ASSERT_CHECK_VALUE_TYPE(env, result, napi_object);
65 
66     const char testStr[] = "1234567";
67     napi_value strAttribute = nullptr;
68     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
69     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
70     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "strAttribute", strAttribute));
71 
72     napi_value retStrAttribute = nullptr;
73     ASSERT_CHECK_CALL(napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
74     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
75 
76     int32_t testNumber = 12345; // 12345 : indicates any number
77     napi_value numberAttribute = nullptr;
78     ASSERT_CHECK_CALL(napi_create_int32(env, testNumber, &numberAttribute));
79     ASSERT_CHECK_VALUE_TYPE(env, numberAttribute, napi_number);
80     ASSERT_CHECK_CALL(napi_set_named_property(env, result, "numberAttribute", numberAttribute));
81 
82     napi_value propNames = nullptr;
83     ASSERT_CHECK_CALL(napi_get_property_names(env, result, &propNames));
84     ASSERT_CHECK_VALUE_TYPE(env, propNames, napi_object);
85     bool isArray = false;
86     isArray = NapiHelper::IsArray(env, propNames);
87 
88     ASSERT_TRUE(isArray);
89 }
90 
91 HWTEST_F(NativeEngineTest, IsFunctionTest001, testing::ext::TestSize.Level0)
92 {
93     napi_env env = (napi_env)engine_;
94 
__anon7113b5370102(napi_env env, napi_callback_info info) 95     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
96         return nullptr;
97     };
98 
99     napi_value value = nullptr;
100     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &value);
101     ASSERT_NE(value, nullptr);
102     bool res;
103     res = NapiHelper::IsFunction(env, value);
104     ASSERT_TRUE(res);
105 }
106 
107 HWTEST_F(NativeEngineTest, GetCallbackInfoArgc001, testing::ext::TestSize.Level0)
108 {
109     napi_env env = (napi_env)engine_;
110 
__anon7113b5370202(napi_env env, napi_callback_info info) 111     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
112         napi_value thisVar;
113         napi_value* argv = nullptr;
114         size_t argc = 0;
115         void* data = nullptr;
116 
117         argc = NapiHelper::GetCallbackInfoArgc(env, info);
118         if (argc > 0) {
119             argv = new napi_value[argc];
120         }
121         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
122 
123         napi_value result = nullptr;
124         napi_create_object(env, &result);
125 
126         napi_value messageKey = nullptr;
127         const char* messageKeyStr = "message";
128         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
129         napi_value messageValue = nullptr;
130         const char* messageValueStr = "OK";
131         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
132         napi_set_property(env, result, messageKey, messageValue);
133 
134         if (argv != nullptr) {
135             delete []argv;
136         }
137         return result;
138     };
139 
140     napi_value funcValue = nullptr;
141     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
142     ASSERT_NE(funcValue, nullptr);
143 
144     bool result = false;
145     napi_is_callable(env, funcValue, &result);
146     ASSERT_TRUE(result);
147 }
148 
149 HWTEST_F(NativeEngineTest, GetNamePropertyInParentPort001, testing::ext::TestSize.Level0)
150 {
151     napi_env env = (napi_env)engine_;
152 
153     napi_value result = nullptr;
154     napi_ref resultRef = nullptr;
155 
156     napi_create_object(env, &result);
157     resultRef = NapiHelper::CreateReference(env, result, 1);
158 
159     napi_value value = nullptr;
160 
161     value = NapiHelper::GetNamePropertyInParentPort(env, resultRef, "test");
162     ASSERT_TRUE(value != nullptr);
163 }
164 
165 HWTEST_F(NativeEngineTest, GetUndefinedValue001, testing::ext::TestSize.Level0)
166 {
167     napi_env env = (napi_env)engine_;
168     napi_value value = nullptr;
169 
170     value = NapiHelper::GetUndefinedValue(env);
171     bool res = false;
172     res = NapiHelper::IsNotUndefined(env, value) ? false : true;
173     ASSERT_TRUE(res);
174 }
175 
176 HWTEST_F(NativeEngineTest, IsCallable001, testing::ext::TestSize.Level0)
177 {
178     napi_env env = (napi_env)engine_;
179 
__anon7113b5370302(napi_env env, napi_callback_info info) 180     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
181         napi_value thisVar;
182         napi_value* argv = nullptr;
183         size_t argc = 0;
184         void* data = nullptr;
185 
186         napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
187         if (argc > 0) {
188             argv = new napi_value[argc];
189         }
190         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
191 
192         napi_value result = nullptr;
193         napi_create_object(env, &result);
194 
195         napi_value messageKey = nullptr;
196         const char* messageKeyStr = "message";
197         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
198         napi_value messageValue = nullptr;
199         const char* messageValueStr = "OK";
200         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
201         napi_set_property(env, result, messageKey, messageValue);
202 
203         if (argv != nullptr) {
204             delete []argv;
205         }
206         return result;
207     };
208 
209     napi_value funcValue = nullptr;
210     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
211     ASSERT_NE(funcValue, nullptr);
212 
213     bool result = false;
214     result = NapiHelper::IsCallable(env, funcValue);
215     ASSERT_TRUE(result);
216 }
217 
218 HWTEST_F(NativeEngineTest, IsCallable002, testing::ext::TestSize.Level0)
219 {
220     napi_env env = (napi_env)engine_;
221 
__anon7113b5370402(napi_env env, napi_callback_info info) 222     auto func = [](napi_env env, napi_callback_info info) -> napi_value {
223         napi_value thisVar;
224         napi_value* argv = nullptr;
225         size_t argc = 0;
226         void* data = nullptr;
227 
228         napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
229         if (argc > 0) {
230             argv = new napi_value[argc];
231         }
232         napi_get_cb_info(env, info, &argc, argv, &thisVar, &data);
233 
234         napi_value result = nullptr;
235         napi_create_object(env, &result);
236 
237         napi_value messageKey = nullptr;
238         const char* messageKeyStr = "message";
239         napi_create_string_latin1(env, messageKeyStr, strlen(messageKeyStr), &messageKey);
240         napi_value messageValue = nullptr;
241         const char* messageValueStr = "OK";
242         napi_create_string_latin1(env, messageValueStr, strlen(messageValueStr), &messageValue);
243         napi_set_property(env, result, messageKey, messageValue);
244 
245         if (argv != nullptr) {
246             delete []argv;
247         }
248         return result;
249     };
250 
251     napi_value funcValue = nullptr;
252     napi_create_function(env, "testFunc", NAPI_AUTO_LENGTH, func, nullptr, &funcValue);
253     ASSERT_NE(funcValue, nullptr);
254 
255     napi_ref resultRef = nullptr;
256     resultRef = NapiHelper::CreateReference(env, funcValue, 1);
257 
258     bool result = false;
259     result = NapiHelper::IsCallable(env, resultRef);
260     ASSERT_TRUE(result);
261 }
262 
263 HWTEST_F(NativeEngineTest, SetNamePropertyInGlobal001, testing::ext::TestSize.Level0)
264 {
265     napi_env env = (napi_env)engine_;
266 
267     const char testStr[] = "1234567";
268     napi_value strAttribute = nullptr;
269     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
270     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
271 
272 
273     NapiHelper::SetNamePropertyInGlobal(env, "strAttribute", strAttribute);
274     napi_value result = nullptr;
275     result = NapiHelper::GetGlobalObject(env);
276 
277     napi_value retStrAttribute = nullptr;
278     ASSERT_CHECK_CALL(napi_get_named_property(env, result, "strAttribute", &retStrAttribute));
279     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
280 }
281 
282 HWTEST_F(NativeEngineTest, IsObject001, testing::ext::TestSize.Level0)
283 {
284     napi_env env = (napi_env)engine_;
285     napi_value value = nullptr;
286 
287     napi_create_object(env, &value);
288     bool res = false;
289     res = NapiHelper::IsObject(env, value);
290     ASSERT_TRUE(res);
291 }
292 
293 HWTEST_F(NativeEngineTest, GetString001, testing::ext::TestSize.Level0)
294 {
295     napi_env env = (napi_env)engine_;
296     napi_value value = nullptr;
297 
298     std::string str = "test";
299     napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value);
300     bool res = false;
301     res = NapiHelper::IsString(env, value);
302     ASSERT_TRUE(res);
303 
304     char* script = NapiHelper::GetString(env, value);
305     std::string s(script);
306     ASSERT_EQ(str, s);
307 }
308 
309 HWTEST_F(NativeEngineTest, CreateBooleanValue001, testing::ext::TestSize.Level0)
310 {
311     napi_env env = (napi_env)engine_;
312     napi_value value = nullptr;
313 
314     value = NapiHelper::CreateBooleanValue(env, true);
315     ASSERT_CHECK_VALUE_TYPE(env, value, napi_boolean);
316 }
317 
318 HWTEST_F(NativeEngineTest, GetGlobalObject001, testing::ext::TestSize.Level0)
319 {
320     napi_env env = (napi_env)engine_;
321     napi_value value = nullptr;
322 
323     value = NapiHelper::GetGlobalObject(env);
324     ASSERT_CHECK_VALUE_TYPE(env, value, napi_object);
325 }
326 
327 HWTEST_F(NativeEngineTest, CreateReference001, testing::ext::TestSize.Level0)
328 {
329     napi_env env = (napi_env)engine_;
330 
331     napi_value result = nullptr;
332     napi_ref resultRef = nullptr;
333 
334     napi_create_object(env, &result);
335     resultRef = NapiHelper::CreateReference(env, result, 1);
336 
337     uint32_t resultRefCount = 0;
338 
339     napi_reference_ref(env, resultRef, &resultRefCount);
340     ASSERT_EQ(resultRefCount, (uint32_t)2); // 2 : means count of resultRef
341 
342     napi_reference_unref(env, resultRef, &resultRefCount);
343     ASSERT_EQ(resultRefCount, (uint32_t)1);
344 
345     NapiHelper::DeleteReference(env, resultRef);
346 }
347 
348 HWTEST_F(NativeEngineTest, CreateUint32001, testing::ext::TestSize.Level0)
349 {
350     napi_env env = (napi_env)engine_;
351     uint32_t testValue = UINT32_MAX;
352     napi_value result = nullptr;
353     result = NapiHelper::CreateUint32(env, testValue);
354     ASSERT_CHECK_VALUE_TYPE(env, result, napi_number);
355 }
356 
357 HWTEST_F(NativeEngineTest, GetLibUV001, testing::ext::TestSize.Level0)
358 {
359     napi_env env = (napi_env)engine_;
360     uv_loop_t* loop;
361     loop = NapiHelper::GetLibUV(env);
362 
363     ASSERT_NE(loop, nullptr);
364 }
365 
366 HWTEST_F(NativeEngineTest, GetReferenceValue001, testing::ext::TestSize.Level0)
367 {
368     napi_env env = (napi_env)engine_;
369 
370     napi_value result = nullptr;
371     napi_ref resultRef = nullptr;
372 
373     napi_create_object(env, &result);
374     napi_create_reference(env, result, 1, &resultRef);
375 
376     napi_value refValue = nullptr;
377 
378     refValue = NapiHelper::GetReferenceValue(env, resultRef);
379 
380     ASSERT_NE(refValue, nullptr);
381 
382     NapiHelper::DeleteReference(env, resultRef);
383 }
384 
385 HWTEST_F(NativeEngineTest, DeleteReference001, testing::ext::TestSize.Level0)
386 {
387     napi_env env = (napi_env)engine_;
388 
389     napi_value result = nullptr;
390     napi_ref resultRef = nullptr;
391 
392     napi_create_object(env, &result);
393     napi_create_reference(env, result, 1, &resultRef);
394     ASSERT_NE(resultRef, nullptr);
395 
396     NapiHelper::DeleteReference(env, resultRef);
397 }
398 
399 HWTEST_F(NativeEngineTest, GetNameProperty001, testing::ext::TestSize.Level0)
400 {
401     napi_env env = (napi_env)engine_;
402 
403     const char testStr[] = "1234567";
404     napi_value strAttribute = nullptr;
405     ASSERT_CHECK_CALL(napi_create_string_utf8(env, testStr, strlen(testStr), &strAttribute));
406     ASSERT_CHECK_VALUE_TYPE(env, strAttribute, napi_string);
407 
408 
409     NapiHelper::SetNamePropertyInGlobal(env, "strAttribute", strAttribute);
410     napi_value result = nullptr;
411     result = NapiHelper::GetGlobalObject(env);
412 
413     napi_value retStrAttribute = nullptr;
414     retStrAttribute = NapiHelper::GetNameProperty(env, result, "strAttribute");
415     ASSERT_CHECK_VALUE_TYPE(env, retStrAttribute, napi_string);
416 }
417 
418 HWTEST_F(NativeEngineTest, GetBooleanValue001, testing::ext::TestSize.Level0)
419 {
420     napi_env env = (napi_env)engine_;
421     napi_value result = nullptr;
422     result = NapiHelper::CreateBooleanValue(env, true);
423     ASSERT_CHECK_VALUE_TYPE(env, result, napi_boolean);
424 
425     bool resultValue = false;
426     resultValue = NapiHelper::GetBooleanValue(env, result);
427     ASSERT_TRUE(resultValue);
428 }
429 
430 HWTEST_F(NativeEngineTest, StrictEqual001, testing::ext::TestSize.Level0)
431 {
432     napi_env env = (napi_env)engine_;
433 
434     const char* testStringStr = "test";
435     napi_value testString = nullptr;
436     napi_create_string_utf8(env, testStringStr, strlen(testStringStr), &testString);
437     bool isStrictEquals = false;
438 
439     isStrictEquals = NapiHelper::StrictEqual(env, testString, testString);
440     ASSERT_TRUE(isStrictEquals);
441 }
442 
443 HWTEST_F(NativeEngineTest, GetConstructorName001, testing::ext::TestSize.Level0)
444 {
445     napi_env env = (napi_env)engine_;
446 
447     napi_value testClass = nullptr;
448     napi_define_class(
449         env, "TestClass", NAPI_AUTO_LENGTH,
__anon7113b5370502(napi_env env, napi_callback_info info) 450         [](napi_env env, napi_callback_info info) -> napi_value {
451             napi_value thisVar = nullptr;
452             napi_get_cb_info(env, info, nullptr, nullptr, &thisVar, nullptr);
453 
454             return thisVar;
455         }, nullptr, 0, nullptr, &testClass);
456 
457     napi_value testInstance = nullptr;
458     ASSERT_CHECK_CALL(napi_new_instance(env, testClass, 0, nullptr, &testInstance));
459 
460     std::string resVal = NapiHelper::GetConstructorName(env, testInstance);
461     ASSERT_EQ(resVal, "TestClass");
462 }
463