1 /*
2 * Copyright (c) 2022 Chipsea Technologies (Shenzhen) Corp., 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 <gtest/gtest.h>
17 #include <thread>
18 #include "napi/native_api.h"
19 #include "napi/native_node_api.h"
20 #include "medical_napi_utils.h"
21 #include "medical_native_impl.h"
22 #include "native_engine.h"
23 #include "ark_native_engine.h"
24 #include "hilog/log.h"
25
26 namespace OHOS {
27 namespace Sensors {
28 using namespace testing::ext;
29 using namespace OHOS::HiviewDFX;
30 static NativeEngine* g_nativeEngine = nullptr;
31 namespace {
32 using namespace OHOS::HiviewDFX;
33 static constexpr HiLogLabel LABEL = {LOG_CORE, 0xD002784, "MedicalJsTest"};
34 }
35
36 class MedicalJsTest : public testing::Test {
37 public:
38 void SetUp();
39 void TearDown();
40 MedicalJsTest();
41 virtual ~MedicalJsTest();
42 protected:
43 NativeEngine* engine_;
44 };
45
SetUp()46 void MedicalJsTest::SetUp()
47 {
48 HiLog::Info(LABEL, "%{public}s begin", __func__);
49 }
50
TearDown()51 void MedicalJsTest::TearDown()
52 {
53 HiLog::Info(LABEL, "%{public}s end", __func__);
54 }
55
MedicalJsTest()56 MedicalJsTest::MedicalJsTest()
57 {
58 panda::RuntimeOption option;
59 option.SetGcType(panda::RuntimeOption::GC_TYPE::GEN_GC);
60
61 const int64_t poolSize = 0x1000000; // 16M
62 option.SetGcPoolSize(poolSize);
63
64 option.SetLogLevel(panda::RuntimeOption::LOG_LEVEL::ERROR);
65 option.SetDebuggerLibraryPath("");
66 EcmaVM *vm = panda::JSNApi::CreateJSVM(option);
67 if (vm == nullptr) {
68 return;
69 }
70
71 g_nativeEngine = new ArkNativeEngine(vm, nullptr);
72 engine_ = g_nativeEngine;
73 }
74
~MedicalJsTest()75 MedicalJsTest::~MedicalJsTest()
76 {
77 delete g_nativeEngine;
78 g_nativeEngine = nullptr;
79 }
80
81 /*
82 * @tc.name: IsMatchType_001
83 * @tc.desc: Match napi_number
84 * @tc.type: FUNC
85 * @tc.require:SR000G54IU
86 */
87 HWTEST_F(MedicalJsTest, IsMatchType_001, TestSize.Level1)
88 {
89 napi_env env = (napi_env)engine_;
90 uint32_t cppValue = UINT32_MAX;
91 napi_value napiValue = nullptr;
92 napi_create_uint32(env, cppValue, &napiValue);
93
94 bool ret = IsMatchType(napiValue, napi_number, env);
95 ASSERT_EQ(ret, true);
96 }
97
98 /*
99 * @tc.name: IsMatchType_002
100 * @tc.desc: Match napi_string
101 * @tc.type: FUNC
102 * @tc.require:AR000G54IV
103 */
104 HWTEST_F(MedicalJsTest, IsMatchType_002, TestSize.Level1)
105 {
106 // Construction parameters
107 napi_env env = (napi_env)engine_;
108 const char cppValue[] = "中文,English,123456,!@#";
109 size_t cppValueStrLength = strlen(cppValue);
110 napi_value napiValue = nullptr;
111 napi_create_string_utf8(env, cppValue, cppValueStrLength, &napiValue);
112
113 // call function
114 bool ret = IsMatchType(napiValue, napi_string, env);
115 ASSERT_EQ(ret, true);
116 }
117
118 /*
119 * @tc.name: IsMatchType_003
120 * @tc.desc: Match napi_symbol
121 * @tc.type: FUNC
122 * @tc.require: AR000G54IV
123 */
124 HWTEST_F(MedicalJsTest, IsMatchType_003, TestSize.Level1)
125 {
126 // Construction parameters
127 napi_env env = (napi_env)engine_;
128 const char testStr[] = "testSymbol";
129 napi_value result = nullptr;
130 napi_create_string_latin1(env, testStr, strlen(testStr), &result);
131 napi_value symbolVal = nullptr;
132 napi_create_symbol(env, result, &symbolVal);
133
134 // call function
135 bool ret = IsMatchType(symbolVal, napi_symbol, env);
136 ASSERT_EQ(ret, true);
137 }
138
139 /*
140 * @tc.name: IsMatchType_004
141 * @tc.desc: Match napi_function
142 * @tc.type: FUNC
143 * @tc.require: AR000G54IV
144 */
145 HWTEST_F(MedicalJsTest, IsMatchType_004, TestSize.Level1)
146 {
147 // Construction parameters
148 napi_env env = (napi_env)engine_;
149 const char* tetScriptStr = "new Date();";
150 napi_value testScript = nullptr;
151 napi_create_string_utf8(env, tetScriptStr, strlen(tetScriptStr), &testScript);
152 napi_value date = nullptr;
153 napi_run_script(env, testScript, &date);
154 napi_value getTimeFunc = nullptr;
155 napi_get_named_property(env, date, "getTime", &getTimeFunc);
156
157 // call function
158 bool ret = IsMatchType(getTimeFunc, napi_function, env);
159 ASSERT_EQ(ret, true);
160 }
161
162 /*
163 * @tc.name: IsMatchType_005
164 * @tc.desc: Match napi_boolean
165 * @tc.type: FUNC
166 * @tc.require: AR000G54IV
167 */
168 HWTEST_F(MedicalJsTest, IsMatchType_005, TestSize.Level1)
169 {
170 // Construction parameters
171 napi_env env = (napi_env)engine_;
172 napi_value result = nullptr;
173 napi_get_boolean(env, true, &result);
174
175 // call function
176 bool ret = IsMatchType(result, napi_boolean, env);
177 ASSERT_EQ(ret, true);
178 }
179
180 /*
181 * @tc.name: GetNapiInt32_001
182 * @tc.desc: change int32_t[INT32_MAX] to napi_value
183 * @tc.type: FUNC
184 * @tc.require: SR000FU58Q
185 */
186 HWTEST_F(MedicalJsTest, GetNapiInt32_001, TestSize.Level1)
187 {
188 // Construction parameters
189 napi_env env = (napi_env)engine_;
190 int32_t number = INT32_MAX;
191
192 // call function
193 napi_value value = GetNapiInt32(number, env);
194 napi_valuetype ret;
195 napi_typeof(env, value, &ret);
196 ASSERT_EQ(ret, number);
197 }
198
199 /*
200 * @tc.name: GetNapiInt32_002
201 * @tc.desc: change int32_t[INT32_MIN] to napi_value
202 * @tc.type: FUNC
203 * @tc.require: AR000FU73V
204 */
205 HWTEST_F(MedicalJsTest, GetNapiInt32_002, TestSize.Level1)
206 {
207 // Construction parameters
208 napi_env env = (napi_env)engine_;
209 int32_t number = INT32_MIN;
210
211 // call function
212 napi_value value = GetNapiInt32(number, env);
213 napi_valuetype ret;
214 napi_typeof(env, value, &ret);
215 ASSERT_EQ(ret, number);
216 }
217
218 /*
219 * @tc.name: GetNapiInt32_003
220 * @tc.desc: change int32_t[true] to napi_value
221 * @tc.type: FUNC
222 * @tc.require: AR000FU73V
223 */
224 HWTEST_F(MedicalJsTest, GetNapiInt32_003, TestSize.Level1)
225 {
226 // Construction parameters
227 napi_env env = (napi_env)engine_;
228 int32_t number = static_cast<int32_t>(true);
229
230 // call function
231 napi_value value = GetNapiInt32(number, env);
232 napi_valuetype ret;
233 napi_typeof(env, value, &ret);
234 ASSERT_EQ(ret, number);
235 }
236
237 /*
238 * @tc.name: GetNapiInt32_004
239 * @tc.desc: change int32_t[true] to napi_value
240 * @tc.type: FUNC
241 * @tc.require: AR000FU73V
242 */
243 HWTEST_F(MedicalJsTest, GetNapiInt32_004, TestSize.Level1)
244 {
245 // Construction parameters
246 napi_env env = (napi_env)engine_;
247 int32_t number = static_cast<int32_t>(false);
248
249 // call function
250 napi_value value = GetNapiInt32(number, env);
251 napi_valuetype ret;
252 napi_typeof(env, value, &ret);
253 ASSERT_EQ(ret, number);
254 }
255
256 /*
257 * @tc.name: GetNapiInt32_005
258 * @tc.desc: change int32_t[char] to napi_value
259 * @tc.type: FUNC
260 * @tc.require: AR000FU73V
261 */
262 HWTEST_F(MedicalJsTest, GetNapiInt32_005, TestSize.Level1)
263 {
264 // Construction parameters
265 napi_env env = (napi_env)engine_;
266 int32_t number = static_cast<int32_t>('a');
267
268 // call function
269 napi_value value = GetNapiInt32(number, env);
270 napi_valuetype ret;
271 napi_typeof(env, value, &ret);
272 ASSERT_EQ(ret, number);
273 }
274
275 /*
276 * @tc.name: NapiGetNamedProperty_001
277 * @tc.desc: Parse function in Json
278 * @tc.type: FUNC
279 * @tc.require: AR000FU73V
280 */
281 HWTEST_F(MedicalJsTest, NapiGetNamedProperty_001, TestSize.Level1)
282 {
283 // Construction parameters
284 napi_env env = (napi_env)engine_;
285 const char* tetScriptStr = "new Date();";
286 napi_value testScript = nullptr;
287 napi_create_string_utf8(env, tetScriptStr, strlen(tetScriptStr), &testScript);
288 napi_value date = nullptr;
289 napi_run_script(env, testScript, &date);
290
291 // call function
292 napi_value value = NapiGetNamedProperty(date, "getTime", env);
293 napi_valuetype ret;
294 napi_typeof(env, value, &ret);
295 ASSERT_EQ(ret, napi_function);
296 }
297
298 /*
299 * @tc.name: NapiGetNamedProperty_002
300 * @tc.desc: Parse function in Json
301 * @tc.type: FUNC
302 * @tc.require: AR000FU73V
303 */
304 HWTEST_F(MedicalJsTest, NapiGetNamedProperty_002, TestSize.Level1)
305 {
306 // 定义变量 赋值
307 napi_env env = (napi_env)engine_;
308 int32_t status=101;
309 napi_value message;
310 napi_create_int32(env, status, &message);
311
312 // 定义变量为对象
313 napi_value result;
314 napi_create_object(env, &result);
315
316 // 赋值给object
317 napi_set_named_property(env, result, "code", message);
318
319 napi_value value = NapiGetNamedProperty(result, "code", env);
320 napi_valuetype ret;
321 napi_typeof(env, value, &ret);
322 ASSERT_EQ(ret, napi_number);
323 }
324
325 /*
326 * @tc.name: NapiGetNamedProperty_003
327 * @tc.desc: Parse function in Json
328 * @tc.type: FUNC
329 * @tc.require: AR000FU73V
330 */
331 HWTEST_F(MedicalJsTest, NapiGetNamedProperty_003, TestSize.Level1)
332 {
333 // 定义变量 赋值
334 napi_env env = (napi_env)engine_;
335 const char status[] = "type001";
336 napi_value message;
337 napi_create_string_utf8(env, status, strlen(status), &message);
338
339 // 定义变量为对象
340 napi_value result;
341 napi_create_object(env, &result);
342
343 // 赋值给object
344 napi_set_named_property(env, result, "code", message);
345
346 napi_value value = NapiGetNamedProperty(result, "code", env);
347 napi_valuetype ret;
348 napi_typeof(env, value, &ret);
349 ASSERT_EQ(ret, napi_string);
350 }
351
352 /*
353 * @tc.name: NapiGetNamedProperty_004
354 * @tc.desc: Parse function in Json
355 * @tc.type: FUNC
356 * @tc.require: AR000G54IV
357 */
358 HWTEST_F(MedicalJsTest, NapiGetNamedProperty_004, TestSize.Level1)
359 {
360 // 定义变量 赋值
361 napi_env env = (napi_env)engine_;
362 napi_value message;
363 napi_get_boolean(env, true, &message);
364
365 // 定义变量为对象
366 napi_value result;
367 napi_create_object(env, &result);
368
369 // 赋值给object
370 napi_set_named_property(env, result, "code", message);
371
372
373 napi_value value = NapiGetNamedProperty(result, "code", env);
374 napi_valuetype ret;
375 napi_typeof(env, value, &ret);
376 ASSERT_EQ(ret, napi_boolean);
377 }
378
379 /*
380 * @tc.name: NapiGetNamedProperty_005
381 * @tc.desc: Parse function in Json
382 * @tc.type: FUNC
383 * @tc.require: AR000G54IV
384 */
385 HWTEST_F(MedicalJsTest, NapiGetNamedProperty_005, TestSize.Level1)
386 {
387 // 定义变量 赋值
388 napi_env env = (napi_env)engine_;
389 const char testStr[] = "testSymbol";
390 napi_value resultSymbol = nullptr;
391 napi_create_string_latin1(env, testStr, strlen(testStr), &resultSymbol);
392 napi_value message = nullptr;
393 napi_create_symbol(env, resultSymbol, &message);
394
395 // 定义变量为对象
396 napi_value result;
397 napi_create_object(env, &result);
398
399 // 赋值给object
400 napi_set_named_property(env, result, "code", message);
401
402 napi_value value = NapiGetNamedProperty(result, "code", env);
403 napi_valuetype ret;
404 napi_typeof(env, value, &ret);
405 ASSERT_EQ(ret, napi_symbol);
406 }
407 /*
408 * @tc.name: GetCppInt32_001
409 * @tc.desc: Parse function in Json
410 * @tc.type: FUNC
411 * @tc.require: AR000G54IV
412 */
413 HWTEST_F(MedicalJsTest, GetCppInt32_001, TestSize.Level1)
414 {
415 // Construction parameters
416 napi_env env = (napi_env)engine_;
417 int32_t number = INT32_MAX;
418 napi_value value;
419 napi_create_int32(env, number, &value);
420
421 // call function
422 int32_t ret = GetCppInt32(value, env);
423 ASSERT_EQ(ret, number);
424 }
425
426 /*
427 * @tc.name: GetCppInt32_002
428 * @tc.desc: Parse function in Json
429 * @tc.type: FUNC
430 * @tc.require: AR000G54IV
431 */
432 HWTEST_F(MedicalJsTest, GetCppInt32_002, TestSize.Level1)
433 {
434 // Construction parameters
435 napi_env env = (napi_env)engine_;
436 int32_t number = INT32_MIN;
437 napi_value value;
438 napi_create_int32(env, number, &value);
439
440 // call function
441 int32_t ret = GetCppInt32(value, env);
442 ASSERT_EQ(ret, number);
443 }
444
445 /*
446 * @tc.name: GetCppInt32_003
447 * @tc.desc: Parse function in Json
448 * @tc.type: FUNC
449 * @tc.require: AR000G54IV
450 */
451 HWTEST_F(MedicalJsTest, GetCppInt32_003, TestSize.Level1)
452 {
453 // Construction parameters
454 napi_env env = (napi_env)engine_;
455 int32_t number = static_cast<int32_t>(true);
456 napi_value value;
457 napi_create_int32(env, number, &value);
458
459 // call function
460 int32_t ret = GetCppInt32(value, env);
461 ASSERT_EQ(ret, number);
462 }
463
464 /*
465 * @tc.name: GetCppInt32_004
466 * @tc.desc: Parse function in Json
467 * @tc.type: FUNC
468 * @tc.require: AR000G54IV
469 */
470 HWTEST_F(MedicalJsTest, GetCppInt32_004, TestSize.Level1)
471 {
472 // Construction parameters
473 napi_env env = (napi_env)engine_;
474 int32_t number = static_cast<int32_t>(false);
475 napi_value value;
476 napi_create_int32(env, number, &value);
477
478 // call function
479 int32_t ret = GetCppInt32(value, env);
480 ASSERT_EQ(ret, number);
481 }
482 /*
483 * @tc.name: GetCppInt32_005
484 * @tc.desc: Parse function in Json
485 * @tc.type: FUNC
486 * @tc.require: AR000G54IV
487 */
488 HWTEST_F(MedicalJsTest, GetCppInt32_005, TestSize.Level1)
489 {
490 // Construction parameters
491 napi_env env = (napi_env)engine_;
492 int32_t number = static_cast<int32_t>('b');
493 napi_value value;
494 napi_create_int32(env, number, &value);
495
496 // call function
497 int32_t ret = GetCppInt32(value, env);
498 ASSERT_EQ(ret, number);
499 }
500
501 /*
502 * @tc.name: GetCppInt64_001
503 * @tc.desc: Parse function in Json
504 * @tc.type: FUNC
505 * @tc.require: AR000G54IV
506 */
507 HWTEST_F(MedicalJsTest, GetCppInt64_001, TestSize.Level1)
508 {
509 // Construction parameters
510 int64_t tmpInt64Max = 9007199254740991;
511 napi_env env = (napi_env)engine_;
512 int64_t number = tmpInt64Max;
513 napi_value value;
514 napi_create_int64(env, number, &value);
515
516 // call function
517 int64_t ret = GetCppInt64(value, env);
518 ASSERT_EQ(ret, tmpInt64Max);
519 }
520
521 /*
522 * @tc.name: GetCppInt64_002
523 * @tc.desc: Parse function in Json
524 * @tc.type: FUNC
525 * @tc.require: AR000G54IV
526 */
527 HWTEST_F(MedicalJsTest, GetCppInt64_002, TestSize.Level1)
528 {
529 // Construction parameters
530 napi_env env = (napi_env)engine_;
531 int64_t number = static_cast<int32_t>(INT64_MIN);
532 napi_value value;
533 napi_create_int64(env, number, &value);
534
535 // call function
536 int64_t ret = GetCppInt64(value, env);
537 ASSERT_EQ(ret, number);
538 }
539
540 /*
541 * @tc.name: GetCppInt64_003
542 * @tc.desc: Parse function in Json
543 * @tc.type: FUNC
544 * @tc.require: AR000G54IV
545 */
546 HWTEST_F(MedicalJsTest, GetCppInt64_003, TestSize.Level1)
547 {
548 // Construction parameters
549 napi_env env = (napi_env)engine_;
550 int64_t number = static_cast<int32_t>(true);
551 napi_value value;
552 napi_create_int64(env, number, &value);
553
554
555 // call function
556 int64_t ret = GetCppInt64(value, env);
557 ASSERT_EQ(ret, number);
558 }
559
560 /*
561 * @tc.name: GetCppInt64_004
562 * @tc.desc: Parse function in Json
563 * @tc.type: FUNC
564 * @tc.require: AR000G54IV
565 */
566 HWTEST_F(MedicalJsTest, GetCppInt64_004, TestSize.Level1)
567 {
568 // Construction parameters
569 napi_env env = (napi_env)engine_;
570 int64_t number = static_cast<int32_t>(false);
571 napi_value value;
572 napi_create_int64(env, number, &value);
573
574 // call function
575 int64_t ret = GetCppInt64(value, env);
576 ASSERT_EQ(ret, number);
577 }
578 /*
579 * @tc.name: GetCppInt64_005
580 * @tc.desc: Parse function in Json
581 * @tc.type: FUNC
582 * @tc.require: AR000G54IV
583 */
584 HWTEST_F(MedicalJsTest, GetCppInt64_005, TestSize.Level1)
585 {
586 // Construction parameters
587 napi_env env = (napi_env)engine_;
588 int64_t number = static_cast<int32_t>('c');
589 napi_value value;
590 napi_create_int64(env, number, &value);
591
592 // call function
593 int64_t ret = GetCppInt64(value, env);
594 ASSERT_EQ(ret, number);
595 }
596 } // namespace Sensors
597 } // namespace OHOS