1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <ctime>
17 #include "test.h"
18
19 #include "napi/native_api.h"
20 #include "napi/native_node_api.h"
21
22 #include "securec.h"
23 #include "js_childprocess.h"
24 #include "js_process.h"
25 #include "tools/log.h"
26
27 #define ASSERT_CHECK_CALL(call) \
28 { \
29 ASSERT_EQ(call, napi_ok); \
30 }
31
32 #define ASSERT_CHECK_VALUE_TYPE(env, value, type) \
33 { \
34 napi_valuetype valueType = napi_undefined; \
35 ASSERT_TRUE(value != nullptr); \
36 ASSERT_CHECK_CALL(napi_typeof(env, value, &valueType)); \
37 ASSERT_EQ(valueType, type); \
38 }
RunCommand(napi_env env,napi_value command,napi_value options)39 static OHOS::JsSysModule::Process::ChildProcess RunCommand(napi_env env, napi_value command, napi_value options)
40 {
41 OHOS::JsSysModule::Process::ChildProcess objectInfo;
42
43 objectInfo.InitOptionsInfo(env, options);
44
45 objectInfo.Spawn(env, command);
46
47 return objectInfo;
48 }
49 static std::string testStr = "";
Method(napi_env env,napi_callback_info info)50 napi_value Method(napi_env env, napi_callback_info info)
51 {
52 napi_value thisVar = nullptr;
53 size_t argc = 0;
54 napi_value args[6] = { 0 }; // 6:six args
55 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr));
56 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &thisVar, nullptr));
57
58 napi_value name = args[0];
59 napi_value value = args[1];
60
61 std::string buffer1 = "";
62 size_t bufferSize1 = 0;
63 napi_get_value_string_utf8(env, name, nullptr, 0, &bufferSize1);
64 buffer1.reserve(bufferSize1 + 1);
65 buffer1.resize(bufferSize1);
66 napi_get_value_string_utf8(env, name, buffer1.data(), bufferSize1 + 1, &bufferSize1);
67
68 std::string buffer2 = "";
69 size_t bufferSize2 = 0;
70 napi_get_value_string_utf8(env, value, nullptr, 0, &bufferSize2);
71 buffer2.reserve(bufferSize2 + 1);
72 buffer2.resize(bufferSize2);
73 napi_get_value_string_utf8(env, value, buffer2.data(), bufferSize2 + 1, &bufferSize2);
74 testStr += buffer1 + buffer2;
75 napi_value result = nullptr;
76 napi_get_boolean(env, true, &result);
77 return result;
78 }
79 /**
80 * @tc.name: ProcessUptimeTest001
81 * @tc.desc: Test process Uptime.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(NativeEngineTest, ProcessUptimeTest001, testing::ext::TestSize.Level0)
85 {
86 napi_env env = (napi_env)engine_;
87 OHOS::JsSysModule::Process::Process process;
88 napi_value timeStart = process.Uptime(env);
89 sleep(1);
90 napi_value timeEnd = process.Uptime(env);
91 double start = 0;
92 double end = 0;
93 napi_get_value_double(env, timeStart, &start);
94 napi_get_value_double(env, timeEnd, &end);
95 ASSERT_EQ(end - start, 1);
96 }
97
98 /**
99 * @tc.name: ProcessKillTest001
100 * @tc.desc: Test process kill signal.
101 * @tc.type: FUNC
102 */
103 HWTEST_F(NativeEngineTest, ProcessKillTest001, testing::ext::TestSize.Level0)
104 {
105 napi_env env = (napi_env)engine_;
106 OHOS::JsSysModule::Process::Process process;
107
108 std::string command("ls; sleep 1");
109 napi_value temp = nullptr;
110 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
111
112 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
113
114 napi_value pid = childprocess.Getpid(env);
115 napi_value signal = nullptr;
116 napi_create_int32(env, 9, &signal);
117 napi_value result = process.Kill(env, pid, signal);
118 bool res = false;
119 napi_get_value_bool(env, result, &res);
120 ASSERT_FALSE(res);
121 }
122
123 /**
124 * @tc.name: ProcessKillTest002
125 * @tc.desc: Test process kill signal.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(NativeEngineTest, ProcessKillTest002, testing::ext::TestSize.Level0)
129 {
130 napi_env env = (napi_env)engine_;
131 OHOS::JsSysModule::Process::Process process;
132
133 std::string command("ls; sleep 1");
134 napi_value temp = nullptr;
135 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
136
137 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
138
139 napi_value pid = childprocess.Getpid(env);
140 napi_value signal = nullptr;
141 napi_create_int32(env, 999, &signal);
142 napi_value result = process.Kill(env, pid, signal);
143 bool res = false;
144 napi_get_value_bool(env, result, &res);
145 ASSERT_FALSE(res);
146 }
147
148 /**
149 * @tc.name: ProcessRunCmdTest001
150 * @tc.desc: Test process RunCmd fork process.
151 * @tc.type: FUNC
152 */
153 HWTEST_F(NativeEngineTest, ProcessRunCmdTest001, testing::ext::TestSize.Level0)
154 {
155 napi_env env = (napi_env)engine_;
156 OHOS::JsSysModule::Process::Process process;
157
158 std::string command("each abc");
159 napi_value temp = nullptr;
160 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
161
162 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
163
164 napi_value output = childprocess.GetOutput(env);
165 bool res = false;
166 napi_is_promise(env, output, &res);
167 ASSERT_TRUE(res);
168 }
169
170 /**
171 * @tc.name: ProcessRunCmdTest002
172 * @tc.desc: Test process RunCmd fork process.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(NativeEngineTest, ProcessRunCmdTest002, testing::ext::TestSize.Level0)
176 {
177 napi_env env = (napi_env)engine_;
178 OHOS::JsSysModule::Process::Process process;
179
180 std::string command("mkdir test.txt");
181 napi_value temp = nullptr;
182 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
183
184 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
185
186 napi_value errorOutput = childprocess.GetErrorOutput(env);
187 bool res = false;
188 napi_is_promise(env, errorOutput, &res);
189 ASSERT_TRUE(res);
190 }
191
192 /**
193 * @tc.name: ProcessGetUidTest001
194 * @tc.desc: Test process uid.
195 * @tc.type: FUNC
196 */
197 HWTEST_F(NativeEngineTest, ProcessGetUidTest001, testing::ext::TestSize.Level0)
198 {
199 napi_env env = (napi_env)engine_;
200 OHOS::JsSysModule::Process::Process process;
201 napi_value napiUid = process.GetUid(env);
202 int32_t uid = 0;
203 napi_get_value_int32(env, napiUid, &uid);
204 bool res = false;
205 if (uid >= 0) {
206 res = true;
207 }
208 ASSERT_TRUE(res);
209 }
210
211 /**
212 * @tc.name: ProcessGetGidTest001
213 * @tc.desc: Test process gid.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(NativeEngineTest, ProcessGetGidTest001, testing::ext::TestSize.Level0)
217 {
218 napi_env env = (napi_env)engine_;
219 OHOS::JsSysModule::Process::Process process;
220 napi_value napiGid = process.GetGid(env);
221 int32_t gid = 0;
222 napi_get_value_int32(env, napiGid, &gid);
223 bool res = false;
224 if (gid >= 0) {
225 res = true;
226 }
227 ASSERT_TRUE(res);
228 }
229
230 /**
231 * @tc.name: ProcessGetEUidTest001
232 * @tc.desc: Test process euid.
233 * @tc.type: FUNC
234 */
235 HWTEST_F(NativeEngineTest, ProcessGetEUidTest001, testing::ext::TestSize.Level0)
236 {
237 napi_env env = (napi_env)engine_;
238 OHOS::JsSysModule::Process::Process process;
239 napi_value napiEuid = process.GetEUid(env);
240 int32_t euid = 0;
241 napi_get_value_int32(env, napiEuid, &euid);
242 bool res = false;
243 if (euid >= 0) {
244 res = true;
245 }
246 ASSERT_TRUE(res);
247 }
248
249 /**
250 * @tc.name: ProcessGetEGidTest001
251 * @tc.desc: Test process egid.
252 * @tc.type: FUNC
253 */
254 HWTEST_F(NativeEngineTest, ProcessGetEGidTest001, testing::ext::TestSize.Level0)
255 {
256 napi_env env = (napi_env)engine_;
257 OHOS::JsSysModule::Process::Process process;
258 napi_value napiEgid = process.GetEGid(env);
259 int32_t egid = 0;
260 napi_get_value_int32(env, napiEgid, &egid);
261 bool res = false;
262 if (egid >= 0) {
263 res = true;
264 }
265 ASSERT_TRUE(res);
266 }
267
268 /**
269 * @tc.name: ProcessGetPidTest001
270 * @tc.desc: Test process pid.
271 * @tc.type: FUNC
272 */
273 HWTEST_F(NativeEngineTest, ProcessGetPidTest001, testing::ext::TestSize.Level0)
274 {
275 napi_env env = (napi_env)engine_;
276 OHOS::JsSysModule::Process::Process process;
277 napi_value napiPid = process.GetPid(env);
278 int32_t pid = 0;
279 napi_get_value_int32(env, napiPid, &pid);
280 bool res = false;
281 if (pid > 0) {
282 res = true;
283 }
284 ASSERT_TRUE(res);
285 }
286
287 /**
288 * @tc.name: ProcessGetPidTest001
289 * @tc.desc: Test process ppid.
290 * @tc.type: FUNC
291 */
292 HWTEST_F(NativeEngineTest, ProcessGetPpidTest001, testing::ext::TestSize.Level0)
293 {
294 napi_env env = (napi_env)engine_;
295 OHOS::JsSysModule::Process::Process process;
296 napi_value napiPpid = process.GetPpid(env);
297 int32_t ppid = 0;
298 napi_get_value_int32(env, napiPpid, &ppid);
299 bool res = false;
300 if (ppid > 0) {
301 res = true;
302 }
303 ASSERT_TRUE(res);
304 }
305
306 /**
307 * @tc.name:childProcessPpidTest001
308 * @tc.desc: test get the parent process ID.
309 * @tc.type: FUNC
310 */
311 HWTEST_F(NativeEngineTest, childProcessPpidTest001, testing::ext::TestSize.Level0)
312 {
313 napi_env env = (napi_env)engine_;
314 OHOS::JsSysModule::Process::Process process;
315
316 std::string command("ls; sleep 1s;");
317 napi_value temp = nullptr;
318 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
319
320 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
321 napi_value result = childprocess.Getppid(env);
322 int32_t ppid = 0;
323 napi_get_value_int32(env, result, &ppid);
324 bool res = false;
325 if (ppid >= 0) {
326 res = true;
327 }
328 ASSERT_TRUE(res);
329 }
330
331 /**
332 * @tc.name:childProcesspidTest001
333 * @tc.desc: test get the specific pid value.
334 * @tc.type: FUNC
335 */
336 HWTEST_F(NativeEngineTest, childProcesspidTest001, testing::ext::TestSize.Level0)
337 {
338 napi_env env = (napi_env)engine_;
339 OHOS::JsSysModule::Process::Process process;
340
341 std::string command("ls; sleep 1s;");
342 napi_value temp = nullptr;
343 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
344
345 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
346 napi_value result = childprocess.Getpid(env);
347 int32_t pid = 0;
348 napi_get_value_int32(env, result, &pid);
349 bool res = false;
350 if (pid >= 0) {
351 res = true;
352 }
353 ASSERT_TRUE(res);
354 }
355
356 /**
357 * @tc.name: ProcessGetGroupsTest001
358 * @tc.desc: Test process groups.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(NativeEngineTest, ProcessGetGroupsTest001, testing::ext::TestSize.Level0)
362 {
363 napi_env env = (napi_env)engine_;
364 OHOS::JsSysModule::Process::Process process;
365 napi_value element = nullptr;
366 napi_value groups = process.GetGroups(env);
367 napi_get_element(env, groups, 1, &element);
368 int32_t indexOne = 0;
369 napi_get_value_int32(env, element, &indexOne);
370 bool res = false;
371 if (indexOne >= 0) {
372 res = true;
373 }
374 ASSERT_TRUE(res);
375 }
376
377 /**
378 * @tc.name: ProcessChdirTest001
379 * @tc.desc: Test process gid.
380 * @tc.type: FUNC
381 */
382 HWTEST_F(NativeEngineTest, ProcessChdirTest001, testing::ext::TestSize.Level0)
383 {
384 napi_env env = (napi_env)engine_;
385 OHOS::JsSysModule::Process::Process process;
386 std::string catalogue = "/system/lib";
387 napi_value temp = nullptr;
388 napi_create_string_utf8(env, catalogue.c_str(), catalogue.length(), &temp);
389 process.Chdir(env, temp);
390 napi_value cwd = process.Cwd(env);
391 size_t bufferSize = 0;
392 if (napi_get_value_string_utf8(env, cwd, nullptr, 0, &bufferSize) != napi_ok) {
393 HILOG_ERROR("can not get str size");
394 }
395 std::string result = "";
396 result.reserve(bufferSize + 1);
397 result.resize(bufferSize);
398 if (napi_get_value_string_utf8(env, cwd, result.data(), bufferSize + 1, &bufferSize) != napi_ok) {
399 HILOG_ERROR("can not get str value");
400 }
401 std::string tag = "";
402 tag = result;
403 bool res = false;
404 if (tag == catalogue) {
405 res = true;
406 }
407 ASSERT_TRUE(res);
408 }
409
410 /**
411 * @tc.name: ProcessOn001
412 * @tc.desc: Test process gid.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(NativeEngineTest, ProcessOn001, testing::ext::TestSize.Level0)
416 {
417 napi_env env = (napi_env)engine_;
418 OHOS::JsSysModule::Process::Process process;
419 napi_value temp = nullptr;
420 std::string cbNameEvent = "add";
421 napi_create_string_utf8(env, cbNameEvent.c_str(), cbNameEvent.length(), &temp);
422 std::string cbName = "cbMethod";
423 napi_value cb = nullptr;
424 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &cb);
425 process.On(env, temp, cb);
426 napi_value convertResult = nullptr;
427 convertResult = process.Off(env, temp);
428 bool res = false;
429 napi_get_value_bool(env, convertResult, &res);
430 ASSERT_FALSE(res);
431 }
432
433 /**
434 * @tc.name: ProcessOn002
435 * @tc.desc: Test process gid.
436 * @tc.type: FUNC
437 */
438 HWTEST_F(NativeEngineTest, ProcessOn002, testing::ext::TestSize.Level0)
439 {
440 napi_env env = (napi_env)engine_;
441 OHOS::JsSysModule::Process::Process process;
442 napi_value temp = nullptr;
443 std::string cbNameEvent = "UnHandleRejection";
444 napi_create_string_utf8(env, cbNameEvent.c_str(), cbNameEvent.length(), &temp);
445 std::string cbName = "cbMethod";
446 napi_value cb = nullptr;
447 napi_create_function(env, cbName.c_str(), cbName.size(), Method, nullptr, &cb);
448 process.On(env, temp, cb);
449 napi_value convertResult = nullptr;
450 convertResult = process.Off(env, temp);
451 bool res = false;
452 napi_get_value_bool(env, convertResult, &res);
453 ASSERT_TRUE(res);
454 }
455
456 /**
457 * @tc.name: ProcessGetTid001
458 * @tc.desc: Test process gid.
459 * @tc.type: FUNC
460 */
461 HWTEST_F(NativeEngineTest, ProcessGetTid001, testing::ext::TestSize.Level0)
462 {
463 napi_env env = (napi_env)engine_;
464 OHOS::JsSysModule::Process::Process process;
465 napi_value napiTid = process.GetTid(env);
466 int32_t tid = 0;
467 napi_get_value_int32(env, napiTid, &tid);
468 bool res = false;
469 if (tid != 0) {
470 res = true;
471 }
472 ASSERT_TRUE(res);
473 }
474
475 /**
476 * @tc.name: ProcessIsIsolatedProcess001
477 * @tc.desc: test whether the process is isolated.
478 * @tc.type: FUNC
479 */
480 HWTEST_F(NativeEngineTest, ProcessIsolatedProcess001, testing::ext::TestSize.Level0)
481 {
482 napi_env env = (napi_env)engine_;
483 OHOS::JsSysModule::Process::Process process;
484 napi_value result = process.IsIsolatedProcess(env);
485 bool res = false;
486 napi_get_value_bool(env, result, &res);
487 if (res) {
488 ASSERT_TRUE(res);
489 } else {
490 ASSERT_FALSE(res);
491 }
492 }
493
494 /**
495 * @tc.name: ProcessIsAppUid001
496 * @tc.desc: test whether the process is AppUid.
497 * @tc.type: FUNC
498 */
499 HWTEST_F(NativeEngineTest, ProcessIsAppUid001, testing::ext::TestSize.Level0)
500 {
501 napi_env env = (napi_env)engine_;
502 OHOS::JsSysModule::Process::Process process;
503 napi_value uid = nullptr;
504 napi_create_int32(env, 9, &uid);
505 napi_value result = process.IsAppUid(env, uid);
506 bool res = false;
507 napi_get_value_bool(env, result, &res);
508 ASSERT_FALSE(res);
509 }
510
511 /**
512 * @tc.name: ProcessIs64Bit001
513 * @tc.desc: test the operating environment is 64-bit.
514 * @tc.type: FUNC
515 */
516 HWTEST_F(NativeEngineTest, ProcessIs64Bit001, testing::ext::TestSize.Level0)
517 {
518 napi_env env = (napi_env)engine_;
519 OHOS::JsSysModule::Process::Process process;
520 napi_value result = process.Is64Bit(env);
521 bool res = false;
522 napi_get_value_bool(env, result, &res);
523 if (res) {
524 ASSERT_TRUE(res);
525 } else {
526 ASSERT_FALSE(res);
527 }
528 }
529
530 /**
531 * @tc.name: ProcessGetEnvironmentVar001
532 * @tc.desc: test get the value corresponding to the environment variable.
533 * @tc.type: FUNC
534 */
535 HWTEST_F(NativeEngineTest, ProcessGetEnvironmentVar001, testing::ext::TestSize.Level0)
536 {
537 napi_env env = (napi_env)engine_;
538 OHOS::JsSysModule::Process::Process process;
539 napi_value temp = nullptr;
540 std::string envVar = "PATH";
541 napi_create_string_utf8(env, envVar.c_str(), envVar.length(), &temp);
542 napi_value result = process.GetEnvironmentVar(env, temp);
543 napi_valuetype valuetype;
544 napi_typeof(env, result, &valuetype);
545 bool res = false;
546 if (valuetype == napi_string) {
547 res = true;
548 }
549 napi_get_value_bool(env, result, &res);
550 ASSERT_TRUE(res);
551 }
552
553 /**
554 * @tc.name: ProcesGetUidForName001
555 * @tc.desc: test Get process uid by process name.
556 * @tc.type: FUNC
557 */
558 HWTEST_F(NativeEngineTest, ProcesGetUidForName001, testing::ext::TestSize.Level0)
559 {
560 napi_env env = (napi_env)engine_;
561 OHOS::JsSysModule::Process::Process process;
562 napi_value temp = nullptr;
563 std::string user = "root";
564 napi_create_string_utf8(env, user.c_str(), user.length(), &temp);
565 napi_value result = process.GetUidForName(env, temp);
566 int32_t num = 0;
567 napi_get_value_int32(env, result, &num);
568 bool res = false;
569 if (num >= 0) {
570 res = true;
571 }
572 napi_get_value_bool(env, result, &res);
573 ASSERT_TRUE(res);
574 }
575
576 /**
577 * @tc.name: ProcesGetUidForName002
578 * @tc.desc: test Get process uid by process name.
579 * @tc.type: FUNC
580 */
581 HWTEST_F(NativeEngineTest, ProcesGetUidForName002, testing::ext::TestSize.Level0)
582 {
583 napi_env env = (napi_env)engine_;
584 OHOS::JsSysModule::Process::Process process;
585 napi_value temp = nullptr;
586 std::string user = "1234";
587 napi_create_string_utf8(env, user.c_str(), user.length(), &temp);
588 napi_value result = process.GetUidForName(env, temp);
589 int32_t num = 0;
590 napi_get_value_int32(env, result, &num);
591 bool res = false;
592 if (num == -1) {
593 res = true;
594 }
595 napi_get_value_bool(env, result, &res);
596 ASSERT_TRUE(res);
597 }
598
599 /**
600 * @tc.name: ProcesGetThreadPriority001
601 * @tc.desc: test Get thread priority based on specified tid.
602 * @tc.type: FUNC
603 */
604 HWTEST_F(NativeEngineTest, ProcesGetThreadPriority001, testing::ext::TestSize.Level0)
605 {
606 napi_env env = (napi_env)engine_;
607 OHOS::JsSysModule::Process::Process process;
608 napi_value napiTid = process.GetTid(env);
609 napi_value result = process.GetThreadPriority(env, napiTid);
610 napi_valuetype valuetype;
611 napi_typeof(env, result, &valuetype);
612 bool res = false;
613 if (valuetype == napi_number) {
614 res = true;
615 }
616 ASSERT_TRUE(res);
617 }
618
619 /**
620 * @tc.name: ProcesGetGetStartRealtime001
621 * @tc.desc: test Get the real-time elapsed time from system startup to process startup.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(NativeEngineTest, ProcesGetGetStartRealtime001, testing::ext::TestSize.Level0)
625 {
626 napi_env env = (napi_env)engine_;
627 OHOS::JsSysModule::Process::Process process;
628 napi_value result = process.GetStartRealtime(env);
629 double num = 0;
630 napi_get_value_double(env, result, &num);
631 bool res = false;
632 if (num == 0) {
633 res = true;
634 }
635 ASSERT_TRUE(res);
636 }
637
638 /**
639 * @tc.name: ProcesGetPastCputime001
640 * @tc.desc: test Get the CPU time from the process startup to the current time.
641 * @tc.type: FUNC
642 */
643 HWTEST_F(NativeEngineTest, ProcesGetPastCputime001, testing::ext::TestSize.Level0)
644 {
645 napi_env env = (napi_env)engine_;
646 OHOS::JsSysModule::Process::Process process;
647 napi_value result = process.GetPastCputime(env);
648 int32_t num = 0;
649 napi_get_value_int32(env, result, &num);
650 bool res = false;
651 if (num != 0) {
652 res = true;
653 }
654 napi_get_value_bool(env, result, &res);
655 ASSERT_TRUE(res);
656 }
657
658 /**
659 * @tc.name: ProcesGetSystemConfig001
660 * @tc.desc: test Get system configuration information.
661 * @tc.type: FUNC
662 */
663 HWTEST_F(NativeEngineTest, ProcesGetSystemConfig001, testing::ext::TestSize.Level0)
664 {
665 napi_env env = (napi_env)engine_;
666 OHOS::JsSysModule::Process::Process process;
667 napi_value config = nullptr;
668 napi_create_int32(env, _SC_NPROCESSORS_CONF, &config);
669 napi_value result = process.GetSystemConfig(env, config);
670 int32_t num = 0;
671 napi_get_value_int32(env, result, &num);
672 bool res = false;
673 if (num != 0) {
674 res = true;
675 }
676 napi_get_value_bool(env, result, &res);
677 ASSERT_TRUE(res);
678 }
679
680 /**
681 * @tc.name: ProcessCloseTest001
682 * @tc.desc: Close the target process.
683 * @tc.type: FUNC
684 */
685 HWTEST_F(NativeEngineTest, ProcessCloseTest001, testing::ext::TestSize.Level0)
686 {
687 napi_env env = (napi_env)engine_;
688 OHOS::JsSysModule::Process::Process process;
689
690 std::string command("ls; sleep 1");
691 napi_value temp = nullptr;
692 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
693
694 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
695 childprocess.Wait(env);
696 childprocess.Close();
697 napi_value exitCode = childprocess.GetExitCode(env);
698 int32_t num = 0;
699 napi_value result = nullptr;
700 napi_get_value_int32(env, exitCode, &num);
701 bool res = false;
702 if (num == 0) {
703 res = true;
704 }
705 napi_get_value_bool(env, result, &res);
706 ASSERT_TRUE(res);
707 }
708
709 /**
710 * @tc.name:childProcessKillTest001
711 * @tc.desc: Send a signal to process.
712 * @tc.type: FUNC
713 */
714 HWTEST_F(NativeEngineTest, childProcessKillTest001, testing::ext::TestSize.Level0)
715 {
716 napi_env env = (napi_env)engine_;
717 OHOS::JsSysModule::Process::Process process;
718
719 std::string command("ls; sleep 1s;");
720 napi_value temp = nullptr;
721 napi_create_string_utf8(env, command.c_str(), command.length(), &temp);
722
723 OHOS::JsSysModule::Process::ChildProcess childprocess = RunCommand(env, temp, nullptr);
724 childprocess.Wait(env);
725 napi_value signo = nullptr;
726 napi_create_int32(env, 9, &signo);
727 childprocess.Kill(env, signo);
728 napi_value result = childprocess.GetKilled(env);
729 bool res = false;
730 napi_get_value_bool(env, result, &res);
731 ASSERT_FALSE(res);
732 }