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 */ 15import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from '@ohos/hypium' 16import process from '@ohos.process' 17export default function ProcessTest() { 18describe('ProcessTest', function () { 19 20 /** 21 * @tc.name: testGetUid001 22 * @tc.desc: returns the digital user id of the process. 23 */ 24 it('testGetUid001', 0, function () { 25 let result = process.uid 26 if (result > 0) { 27 var flag = true 28 } 29 expect(flag).assertEqual(true) 30 }) 31 32 /** 33 * @tc.name: testGetUid002 34 * @tc.desc: returns the digital user id of the process. 35 */ 36 it('testGetUid002', 0, function () { 37 for (let i = 0; i < 3; i++) { 38 let result = process.uid 39 if (result != null) { 40 if (result > 0) { 41 var flag = true 42 } 43 expect(flag).assertEqual(true) 44 } 45 } 46 }) 47 48 /** 49 * @tc.name: testGetUid003 50 * @tc.desc: returns the digital user id of the process. 51 */ 52 it('testGetUid003', 0, function () { 53 for (let i = 0; i < 6; i++) { 54 let result = process.uid 55 if (result != null) { 56 if (result > 0) { 57 var flag = true 58 } 59 expect(flag).assertEqual(true) 60 } 61 } 62 }) 63 64 /** 65 * @tc.name: testGetUid004 66 * @tc.desc: returns the digital user id of the process. 67 */ 68 it('testGetUid004', 0, function () { 69 for (let i = 0; i < 8; i++) { 70 let result = process.uid 71 if (result != null) { 72 if (result > 0) { 73 var flag = true 74 } 75 expect(flag).assertEqual(true) 76 } 77 } 78 }) 79 80 /** 81 * @tc.name: testGetUid005 82 * @tc.desc: returns the digital user id of the process. 83 */ 84 it('testGetUid005', 0, function () { 85 for (let i = 0; i < 5; i++){ 86 let result = process.uid 87 if (result != null) { 88 if (result > 0) { 89 var flag = true 90 } 91 expect(flag).assertEqual(true) 92 } 93 } 94 }) 95 96 /** 97 * @tc.name: testKill001 98 * @tc.desc: Return whether the signal was sent successfully. 99 */ 100 it('testKill001', 0, function () { 101 let result = process.kill(3, 123) 102 expect(result).assertEqual(false) 103 }) 104 105 /** 106 * @tc.name: testKill002 107 * @tc.desc: Return whether the signal was sent successfully. 108 */ 109 it('testKill002', 0, function () { 110 let pres = process.pid 111 let result = process.kill(23, pres) 112 expect(result).assertEqual(true) 113 }) 114 115 /** 116 * @tc.name: testKill003 117 * @tc.desc: Return whether the signal was sent successfully. 118 */ 119 it('testKill003', 0, function () { 120 let pres = process.pid 121 let result = process.kill(28, pres) 122 expect(result).assertEqual(true) 123 }) 124 125 /** 126 * @tc.name: testKill004 127 * @tc.desc: Return whether the signal was sent successfully. 128 */ 129 it('testKill004', 0, function () { 130 let pres = process.pid 131 let result = process.kill(17, pres) 132 expect(result).assertEqual(true) 133 }) 134 135 /** 136 * @tc.name: testKill005 137 * @tc.desc: Return whether the signal was sent successfully. 138 */ 139 it('testKill005', 0, function () { 140 let result = process.kill(3, 113) 141 expect(result).assertEqual(false) 142 }) 143 144 /** 145 * @tc.name: testKill006 146 * @tc.desc: Return whether the signal was sent successfully. 147 */ 148 it('testKill006', 0, function () { 149 let pres = process.pid 150 let result = process.kill('17', pres) 151 expect(result).assertEqual(true) 152 }) 153 154 /** 155 * @tc.name: testUptime001 156 * @tc.desc: Returns the running time of the system. 157 */ 158 it('testUptime001', 0, function () { 159 let result1 = process.uptime() 160 function sleep(d){ 161 while(process.uptime() - result1 <= d); 162 } 163 sleep(6); 164 let result2 = process.uptime() 165 var flag = false 166 if ((result2 - result1) >= 6) { 167 flag = true 168 } 169 expect(flag).assertEqual(true) 170 }) 171 172 /** 173 * @tc.name: testUptime002 174 * @tc.desc: Returns the running time of the system. 175 */ 176 it('testUptime002', 0, function () { 177 let result1 = process.uptime() 178 function sleep(d){ 179 while (process.uptime() - result1 <= d); 180 } 181 sleep(8); 182 let result2 = process.uptime() 183 var flag = false 184 if ((result2 - result1) >= 8) { 185 flag = true 186 } 187 expect(flag).assertEqual(true) 188 }) 189 190 /** 191 * @tc.name: testUptime003 192 * @tc.desc: Returns the running time of the system. 193 */ 194 it('testUptime003', 0, function () { 195 let result1 = process.uptime() 196 function sleep(d){ 197 while (process.uptime() - result1 <= d); 198 } 199 sleep(10); 200 let result2 = process.uptime() 201 var flag = false 202 if ((result2 - result1) >= 10) { 203 flag = true 204 } 205 expect(flag).assertEqual(true) 206 }) 207 208 /** 209 * @tc.name: testUptime004 210 * @tc.desc: Returns the running time of the system. 211 */ 212 it('testUptime004', 0, function () { 213 let result1 = process.uptime() 214 function sleep(d){ 215 while (process.uptime() - result1 <= d); 216 } 217 sleep(7); 218 let result2 = process.uptime() 219 var flag = false 220 if ((result2 - result1) >= 7) { 221 flag = true 222 } 223 expect(flag).assertEqual(true) 224 }) 225 226 /** 227 * @tc.name: testUptime005 228 * @tc.desc: Returns the running time of the system. 229 */ 230 it('testUptime005', 0, function () { 231 let result1 = process.uptime() 232 function sleep(d){ 233 while (process.uptime() - result1 <= d); 234 } 235 sleep(11); 236 let result2 = process.uptime() 237 var flag = false 238 if ((result2 - result1) >= 11) { 239 flag = true 240 } 241 expect(flag).assertEqual(true) 242 }) 243 244 /** 245 * @tc.name: testPid001 246 * @tc.desc: Return pid is the pid of the current process. 247 */ 248 it('testPid001', 0, function () { 249 let result = process.pid 250 if (result > 0) { 251 var flag = true 252 } 253 expect(flag).assertEqual(true) 254 }) 255 256 /** 257 * @tc.name: testPid002 258 * @tc.desc: Return pid is the pid of the current process. 259 */ 260 it('testPid002', 0, function () { 261 for (let i = 0; i < 3; i++) { 262 let result = process.pid 263 if (result > 0) { 264 var flag = true 265 } 266 expect(flag).assertEqual(true) 267 } 268 }) 269 270 /** 271 * @tc.name: testPid003 272 * @tc.desc: Return pid is the pid of the current process. 273 */ 274 it('testPid003', 0, function () { 275 for (let i = 0; i < 5; i++) { 276 let result = process.pid 277 if (result > 0) { 278 var flag = true 279 } 280 expect(flag).assertEqual(true) 281 } 282 }) 283 284 /** 285 * @tc.name: testPid004 286 * @tc.desc: Return pid is the pid of the current process. 287 */ 288 it('testPid004', 0, function () { 289 for (let i = 0; i < 6; i++) { 290 let result = process.pid 291 if (result > 0) { 292 var flag = true 293 } 294 expect(flag).assertEqual(true) 295 } 296 }) 297 298 /** 299 * @tc.name: testPid005 300 * @tc.desc: Return pid is the pid of the current process. 301 */ 302 it('testPid005', 0, function () { 303 for (let i = 0; i < 8; i++) { 304 let result = process.pid 305 if (result > 0) { 306 var flag = true 307 } 308 expect(flag).assertEqual(true) 309 } 310 }) 311 312 /** 313 * @tc.name: testTid001 314 * @tc.desc: Returns the tid of the current thread. 315 */ 316 it('testTid001', 0, function () { 317 let pres = process.tid 318 if (pres > 0) { 319 var flag = new Boolean(true) 320 } 321 expect(Boolean(flag)).assertEqual(true) 322 }) 323 324 /** 325 * @tc.name: testTid002 326 * @tc.desc: Returns the tid of the current thread. 327 */ 328 it('testTid002', 0, function () { 329 for (let i=0; i < 5; i++) { 330 let pres = process.tid 331 if (pres > 0) { 332 var flag = new Boolean(true) 333 } 334 expect(Boolean(flag)).assertEqual(true) 335 } 336 }) 337 338 /** 339 * @tc.name: testTid003 340 * @tc.desc: Returns the tid of the current thread. 341 */ 342 it('testTid003', 0, function () { 343 for (let i=0; i < 3; i++) { 344 let pres = process.tid 345 if (pres > 0) { 346 var flag = new Boolean(true) 347 } 348 expect(Boolean(flag)).assertEqual(true) 349 } 350 }) 351 352 353 /** 354 * @tc.name: testisIsolatedProcess001 355 * @tc.desc: Returns a boolean whether the process is isolated. 356 */ 357 it('testisIsolatedProcess001', 0, function () { 358 let pres = process.isIsolatedProcess() 359 expect(pres).assertEqual(true) 360 }) 361 362 /** 363 * @tc.name: testisIsolatedProcess002 364 * @tc.desc: Returns a boolean whether the process is isolated. 365 */ 366 it('testisIsolatedProcess002', 0, function () { 367 for (let i=0; i < 3; i++) { 368 let pres = process.isIsolatedProcess() 369 expect(pres).assertEqual(true) 370 } 371 }) 372 373 /** 374 * @tc.name: testisIsolatedProcess003 375 * @tc.desc: Returns a boolean whether the process is isolated. 376 */ 377 it('testisIsolatedProcess003', 0, function () { 378 for (let i=0; i < 5; i++) { 379 let pres = process.isIsolatedProcess() 380 expect(pres).assertEqual(true) 381 } 382 }) 383 384 385 /** 386 * @tc.name: testIsappuid001 387 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 388 */ 389 it('testIsappuid001', 0, function () { 390 let isorno = process.isAppUid(167) 391 expect(isorno).assertEqual(false) 392 }) 393 394 /** 395 * @tc.name: testIsappuid002 396 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 397 */ 398 it('testIsappuid002', 0, function () { 399 let isorno = process.isAppUid(123) 400 expect(isorno).assertEqual(false) 401 }) 402 403 /** 404 * @tc.name: testIsappuid003 405 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 406 */ 407 it('testIsappuid003', 0, function () { 408 let isorno = process.isAppUid(80000) 409 expect(isorno).assertEqual(false) 410 }) 411 412 /** 413 * @tc.name: testIsappuid004 414 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 415 */ 416 it('testIsappuid004', 0, function () { 417 let isorno = process.isAppUid(789) 418 expect(isorno).assertEqual(false) 419 }) 420 421 /** 422 * @tc.name: testIsappuid005 423 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 424 */ 425 it('testIsappuid005', 0, function () { 426 let isorno = process.isAppUid(8569) 427 expect(isorno).assertEqual(false) 428 }) 429 430 /** 431 * @tc.name: testIs64Bit001 432 * @tc.desc: Returns a boolean whether the process is running in a 64-bit environment. 433 */ 434 it('testIs64Bit001', 0, function () { 435 let isorno = process.is64Bit() 436 if (isorno) { 437 expect(isorno).assertEqual(true) 438 } else { 439 expect(isorno).assertEqual(false) 440 } 441 }) 442 443 /** 444 * @tc.name: testIs64Bit002 445 * @tc.desc: Returns a boolean whether the process is running in a 64-bit environment. 446 */ 447 it('testIs64Bit002', 0, function () { 448 for (let i=0; i<3; i++) { 449 let isorno = process.is64Bit() 450 if (isorno) { 451 expect(isorno).assertEqual(true) 452 } else { 453 expect(isorno).assertEqual(false) 454 } 455 } 456 }) 457 458 /** 459 * @tc.name: testIs64Bit003 460 * @tc.desc: Returns a boolean whether the process is running in a 64-bit environment. 461 */ 462 it('testIs64Bit004', 0, function () { 463 for (let i=0; i<5; i++) { 464 let isorno = process.is64Bit() 465 if (isorno) { 466 expect(isorno).assertEqual(true) 467 } else { 468 expect(isorno).assertEqual(false) 469 } 470 } 471 }) 472 473 474 /** 475 * @tc.name: testGetUidForName001 476 * @tc.desc: Returns the uid based on the specified user name. 477 */ 478 it('testGetUidForName001',0, function () { 479 let pres = process.getUidForName("root") 480 if (pres != -1) { 481 let flag = new Boolean(true) 482 expect(Boolean(flag)).assertEqual(true) 483 } 484 }) 485 486 /** 487 * @tc.name: testGetUidForName002 488 * @tc.desc: Returns the uid based on the specified user name. 489 */ 490 it('testGetUidForName002', 0, function () { 491 for (let i=0; i<3; i++) { 492 let pres = process.getUidForName("12356") 493 expect(pres).assertEqual(-1) 494 } 495 }) 496 497 /** 498 * @tc.name: testGetUidForName003 499 * @tc.desc: Returns the uid based on the specified user name. 500 */ 501 it('testGetUidForName003', 0, function () { 502 for (let i=0; i<5; i++) { 503 let pres = process.getUidForName("12356") 504 expect(pres).assertEqual(-1) 505 } 506 }) 507 508 509 /** 510 * @tc.name: testGetThreadPriority001 511 * @tc.desc: Returns the thread priority based on the specified tid. 512 */ 513 it('testGetThreadPriority001', 0, function () { 514 let pres = process.tid 515 let pri = process.getThreadPriority(pres) 516 if (pri) { 517 let flag = new Boolean(true) 518 expect(Boolean(flag)).assertEqual(true) 519 } 520 }) 521 522 /** 523 * @tc.name: testGetThreadPriority002 524 * @tc.desc: Returns the thread priority based on the specified tid. 525 */ 526 it('testGetThreadPriority002', 0, function () { 527 let pres = process.tid 528 for (let i=0; i<3; i++) { 529 let pri = process.getThreadPriority(pres) 530 if (pri > 0) { 531 let flag = new Boolean(true) 532 expect(Boolean(flag)).assertEqual(true) 533 } 534 } 535 }) 536 537 /** 538 * @tc.name: testGetThreadPriority003 539 * @tc.desc: Returns the thread priority based on the specified tid. 540 */ 541 it('testGetThreadPriority003', 0, function () { 542 let pres = process.tid 543 for (let i=0; i<5; i++) { 544 let pri = process.getThreadPriority(pres) 545 if (pri > 0) { 546 let flag = new Boolean(true) 547 expect(Boolean(flag)).assertEqual(true) 548 } 549 } 550 }) 551 552 /** 553 * @tc.name: testGetStartRealtime001 554 * @tc.desc: Returns the elapsed real time (in milliseconds) taken from the start of 555 * @the system to the start of the process. 556 */ 557 it('testGetStartRealtime001', 0, function () { 558 for (let i=0; i<3; i++) { 559 let pri = process.getStartRealtime() 560 if (pri !== null) { 561 var flag = new Boolean(true) 562 } 563 expect(Boolean(flag)).assertEqual(true) 564 } 565 }) 566 567 /** 568 * @tc.name: testGetStartRealtime002 569 * @tc.desc: Returns the elapsed real time (in milliseconds) taken from the start of 570 * @the system to the start of the process. 571 */ 572 it('testGetStartRealtime002', 0, function () { 573 let pri = process.getStartRealtime() 574 if (pri !== null) { 575 var flag = new Boolean(true) 576 } 577 expect(Boolean(flag)).assertEqual(true) 578 }) 579 580 /** 581 * @tc.name: testGetStartRealtime003 582 * @tc.desc: Returns the elapsed real time (in milliseconds) taken from the start of 583 * @the system to the start of the process. 584 */ 585 it('testGetStartRealtime003', 0, function () { 586 for (let i=0; i<5; i++) { 587 let pri = process.getStartRealtime() 588 if (pri !== null) { 589 var flag = new Boolean(true) 590 } 591 expect(Boolean(flag)).assertEqual(true) 592 } 593 }) 594 595 /** 596 * @tc.name: testGetStartRealtime004 597 * @tc.desc: Returns the elapsed real time (in milliseconds) 598 * @taken from the start of the system to the start of the process. 599 */ 600 it('testGetStartRealtime004', 0, function () { 601 for (let i=0; i<8; i++) { 602 let pri = process.getStartRealtime() 603 if (pri !== null) { 604 var flag = new Boolean(true) 605 } 606 expect(Boolean(flag)).assertEqual(true) 607 } 608 }) 609 610 /** 611 * @tc.name: testGetStartRealtime005 612 * @tc.desc: Returns the elapsed real time (in milliseconds) taken from the start of 613 * @the system to the start of the process. 614 */ 615 it('testGetStartRealtime005', 0, function () { 616 for (let i=0; i<6; i++) { 617 let pri = process.getStartRealtime() 618 if (pri !== null) { 619 var flag = new Boolean(true) 620 } 621 expect(Boolean(flag)).assertEqual(true) 622 } 623 }) 624 625 /** 626 * @tc.name: testGetpastCpuTime001 627 * @tc.desc: Returns the cpu time (in milliseconds) from the time when the process starts to the current time. 628 */ 629 it('testGetpastCpuTime001', 0, function () { 630 for (let i=0; i<3; i++) { 631 let pri = process.getPastCpuTime() 632 if (pri > 0) { 633 var flag = new Boolean(true) 634 } 635 expect(Boolean(flag)).assertEqual(true) 636 } 637 }) 638 639 /** 640 * @tc.name: testGetpastCpuTime002 641 * @tc.desc: Returns the cpu time (in milliseconds) from the time when the process starts to the current time. 642 */ 643 it('testGetpastCpuTime002', 0, function () { 644 let pri = process.getPastCpuTime() 645 if (pri > 0) { 646 var flag = new Boolean(true) 647 } 648 expect(Boolean(flag)).assertEqual(true) 649 }) 650 651 /** 652 * @tc.name: testGetpastCpuTime003 653 * @tc.desc: Returns the cpu time (in milliseconds) from the time when the process starts to the current time. 654 */ 655 it('testGetpastCpuTime003', 0, function () { 656 for (let i=0; i<5; i++) { 657 let pri = process.getPastCpuTime() 658 if (pri > 0) { 659 var flag = new Boolean(true) 660 } 661 expect(Boolean(flag)).assertEqual(true) 662 } 663 }) 664 665 /** 666 * @tc.name: testGetpastCpuTime004 667 * @tc.desc: Returns the cpu time (in milliseconds) from the time when the process starts to the current time. 668 */ 669 it('testGetpastCpuTime004', 0, function () { 670 for (let i=0; i<8; i++) { 671 let pri = process.getPastCpuTime() 672 if (pri > 0) { 673 var flag = new Boolean(true) 674 } 675 expect(Boolean(flag)).assertEqual(true) 676 } 677 }) 678 679 /** 680 * @tc.name: testGetSystemConfig001 681 * @tc.desc: Returns the system configuration at runtime. 682 */ 683 it('testGetSystemConfig001', 0, function () { 684 let _SC_ARG_MAX = 0 685 let pri = process.getSystemConfig(_SC_ARG_MAX) 686 if (pri > 0) { 687 var flag = new Boolean(true) 688 } 689 expect(Boolean(flag)).assertEqual(true) 690 }) 691 692 /** 693 * @tc.name: testGetSystemConfig002 694 * @tc.desc: Returns the system configuration at runtime. 695 */ 696 it('testGetSystemConfig002', 0, function () { 697 let _SC_ARG_MAX = 0 698 for (let i=0; i<3; i++) { 699 let pri = process.getSystemConfig(_SC_ARG_MAX) 700 if (pri > 0) { 701 var flag = new Boolean(true) 702 } 703 expect(Boolean(flag)).assertEqual(true) 704 } 705 }) 706 707 /** 708 * @tc.name: testGetSystemConfig003 709 * @tc.desc: Returns the system configuration at runtime. 710 */ 711 it('testGetSystemConfig003', 0, function () { 712 let _SC_ARG_MAX = 0 713 for (let i=0; i<5; i++) { 714 let pri = process.getSystemConfig(_SC_ARG_MAX) 715 if (pri > 0) { 716 var flag = new Boolean(true) 717 } 718 expect(Boolean(flag)).assertEqual(true) 719 } 720 }) 721 722 /** 723 * @tc.name: testGetSystemConfig004 724 * @tc.desc: Returns the system configuration at runtime. 725 */ 726 it('testGetSystemConfig004', 0, function () { 727 let _SC_OPEN_MAX = 4 728 let pri = process.getSystemConfig(_SC_OPEN_MAX) 729 if (pri > 0) { 730 var flag = new Boolean(true) 731 } 732 expect(Boolean(flag)).assertEqual(true) 733 }) 734 735 /** 736 * @tc.name: testGetSystemConfig005 737 * @tc.desc: Returns the system configuration at runtime. 738 */ 739 it('testGetSystemConfig005', 0, function () { 740 let _SC_PAGESIZE = 8 741 let pri = process.getSystemConfig(_SC_PAGESIZE) 742 if (pri > 0) { 743 var flag = new Boolean(true) 744 } 745 expect(Boolean(flag)).assertEqual(true) 746 }) 747 748 /** 749 * @tc.name: testGetEnvironmentVar001 750 * @tc.desc: Returns the system value for environment variables. 751 */ 752 it('testGetEnvironmentVar001', 0, function () { 753 let pri = process.getEnvironmentVar("USER") 754 if (pri != null) { 755 var flag = new Boolean(true) 756 expect(Boolean(flag)).assertEqual(true) 757 } 758 }) 759 760 /** 761 * @tc.name: testGetEnvironmentVar002 762 * @tc.desc: Returns the system value for environment variables. 763 */ 764 it('testGetEnvironmentVar002', 0, function () { 765 for (let i=0; i<3; i++) { 766 let pri = process.getEnvironmentVar("PATH") 767 if (pri != null) { 768 var flag = new Boolean(true) 769 expect(Boolean(flag)).assertEqual(true) 770 } 771 } 772 }) 773 774 /** 775 * @tc.name: testGetEnvironmentVar003 776 * @tc.desc: Returns the system value for environment variables. 777 */ 778 it('testGetEnvironmentVar003', 0, function () { 779 for (let i=0; i<5; i++) { 780 let pri = process.getEnvironmentVar("PATH") 781 if (pri != null) { 782 var flag = new Boolean(true) 783 expect(Boolean(flag)).assertEqual(true) 784 } 785 } 786 }) 787 788 /** 789 * @tc.name: testGetEnvironmentVar004 790 * @tc.desc: Returns the system value for environment variables. 791 */ 792 it('testGetEnvironmentVar004', 0, function () { 793 for (let i=0; i<6; i++) { 794 let pri = process.getEnvironmentVar("USER") 795 if (pri != null) { 796 var flag = new Boolean(true) 797 expect(Boolean(flag)).assertEqual(true) 798 } 799 } 800 }) 801 802 /** 803 * @tc.name: testGetEnvironmentVar005 804 * @tc.desc: Returns the system value for environment variables. 805 */ 806 it('testGetEnvironmentVar005', 0, function () { 807 for (let i=0; i<8; i++) { 808 let pri = process.getEnvironmentVar("USER") 809 if (pri != null) { 810 var flag = new Boolean(true) 811 expect(Boolean(flag)).assertEqual(true) 812 } 813 } 814 }) 815 816 /** 817 * @tc.name: testGetEnvironmentVar006 818 * @tc.desc: Returns the system value for environment variables. 819 */ 820 it('testGetEnvironmentVar006', 0, function () { 821 for (let i=0; i<100; i++) { 822 let pri = process.getEnvironmentVar("i123") 823 if (pri == null) { 824 var flag = new Boolean(true) 825 expect(Boolean(flag)).assertEqual(true) 826 } 827 } 828 }) 829}) 830describe('ProcessManager', function () { 831 /** 832 * @tc.name: testIsappuid001 833 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 834 */ 835 it('testProcessManagerIsappuid001', 0, function () { 836 let pro = new process.ProcessManager() 837 let isorno = pro.isAppUid(167) 838 expect(isorno).assertEqual(false) 839 }) 840 841 /** 842 * @tc.name: testIsappuid002 843 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 844 */ 845 it('testProcessManagerIsappuid002', 0, function () { 846 let pro = new process.ProcessManager() 847 let isorno = pro.isAppUid(123) 848 expect(isorno).assertEqual(false) 849 }) 850 851 /** 852 * @tc.name: testIsappuid003 853 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 854 */ 855 it('testProcessManagerIsappuid003', 0, function () { 856 let pro = new process.ProcessManager() 857 let isorno = pro.isAppUid(80000) 858 expect(isorno).assertEqual(false) 859 }) 860 861 /** 862 * @tc.name: testIsappuid004 863 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 864 */ 865 it('testProcessManagerIsappuid004', 0, function () { 866 let pro = new process.ProcessManager() 867 let isorno = pro.isAppUid(789) 868 expect(isorno).assertEqual(false) 869 }) 870 871 /** 872 * @tc.name: testIsappuid005 873 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 874 */ 875 it('testProcessManagerIsappuid005', 0, function () { 876 let pro = new process.ProcessManager() 877 let isorno = pro.isAppUid(8569) 878 expect(isorno).assertEqual(false) 879 }) 880 881 /** 882 * @tc.name: testIsappuid006 883 * @tc.desc: Returns a boolean whether the specified uid belongs to a particular application. 884 */ 885 it('testProcessManagerIsappuid006', 0, function () { 886 try { 887 let pro = new process.ProcessManager() 888 let mag = pro.isAppUid("asdad") 889 } catch (e) { 890 expect(e.toString()).assertEqual("BuisnessError: The type of v must be number.") 891 } 892 }) 893 /** 894 * @tc.name: testKill001 895 * @tc.desc: Return whether the signal was sent successfully. 896 */ 897 it('testProcessManagerKill001', 0, function () { 898 let pro = new process.ProcessManager() 899 let result = pro.kill(3, 123) 900 expect(result).assertEqual(false) 901 }) 902 903 /** 904 * @tc.name: testKill002 905 * @tc.desc: Return whether the signal was sent successfully. 906 */ 907 it('testProcessManagerKill002', 0, function () { 908 let pro = new process.ProcessManager() 909 let pres = process.pid 910 let result = pro.kill(23, pres) 911 expect(result).assertEqual(true) 912 }) 913 914 /** 915 * @tc.name: testKill003 916 * @tc.desc: Return whether the signal was sent successfully. 917 */ 918 it('testProcessManagerKill003', 0, function () { 919 let pro = new process.ProcessManager() 920 let pres = process.pid 921 let result = pro.kill(28, pres) 922 expect(result).assertEqual(true) 923 }) 924 925 /** 926 * @tc.name: testKill004 927 * @tc.desc: Return whether the signal was sent successfully. 928 */ 929 it('testProcessManagerKill004', 0, function () { 930 let pro = new process.ProcessManager() 931 let pres = process.pid 932 let result = pro.kill(17, pres) 933 expect(result).assertEqual(true) 934 }) 935 936 /** 937 * @tc.name: testKill005 938 * @tc.desc: Return whether the signal was sent successfully. 939 */ 940 it('testProcessManagerKill005', 0, function () { 941 let pro = new process.ProcessManager() 942 let result = pro.kill(3, 113) 943 expect(result).assertEqual(false) 944 }) 945 946 /** 947 * @tc.name: testKill006 948 * @tc.desc: Return whether the signal was sent successfully. 949 */ 950 it('testProcessManagerKill006', 0, function () { 951 try { 952 let pro = new process.ProcessManager() 953 let result = pro.kill("asd", 123) 954 } catch (e) { 955 expect(e.toString()).assertEqual("BuisnessError: The type of v must be number.") 956 } 957 }) 958 959 /** 960 * @tc.name: testGetUidForName001 961 * @tc.desc: Returns the uid based on the specified user name. 962 */ 963 it('testProcessManagerGetUidForName001',0, function () { 964 let pro = new process.ProcessManager() 965 let pres = pro.getUidForName("root") 966 if (pres != -1) { 967 let flag = new Boolean(true) 968 expect(Boolean(flag)).assertEqual(true) 969 } 970 }) 971 972 /** 973 * @tc.name: testGetUidForName002 974 * @tc.desc: Returns the uid based on the specified user name. 975 */ 976 it('testProcessManagerGetUidForName002', 0, function () { 977 let pro = new process.ProcessManager() 978 for (let i=0; i<3; i++) { 979 let pres = pro.getUidForName("12356") 980 expect(pres).assertEqual(-1) 981 } 982 }) 983 984 /** 985 * @tc.name: testGetUidForName003 986 * @tc.desc: Returns the uid based on the specified user name. 987 */ 988 it('testProcessManagerGetUidForName003', 0, function () { 989 let pro = new process.ProcessManager() 990 for (let i=0; i<5; i++) { 991 let pres = pro.getUidForName("as123") 992 expect(pres).assertEqual(-1) 993 } 994 }) 995 /** 996 * @tc.name: testGetUidForName004 997 * @tc.desc: Returns the uid based on the specified user name. 998 */ 999 it('testProcessManagerGetUidForName004',0, function () { 1000 try { 1001 let pro = new process.ProcessManager() 1002 let pres = pro.getUidForName(12) 1003 } catch (e) { 1004 expect(e.toString()).assertEqual("BuisnessError: The type of v must be string.") 1005 } 1006 }) 1007 1008 /** 1009 * @tc.name: testGetThreadPriority001 1010 * @tc.desc: Returns the thread priority based on the specified tid. 1011 */ 1012 it('testProcessManagerGetThreadPriority001', 0, function () { 1013 let pro = new process.ProcessManager() 1014 let pres = process.tid 1015 let pri = pro.getThreadPriority(pres) 1016 if (pri) { 1017 let flag = new Boolean(true) 1018 expect(Boolean(flag)).assertEqual(true) 1019 } 1020 }) 1021 1022 /** 1023 * @tc.name: testGetThreadPriority002 1024 * @tc.desc: Returns the thread priority based on the specified tid. 1025 */ 1026 it('testProcessManagerGetThreadPriority002', 0, function () { 1027 let pro = new process.ProcessManager() 1028 let pres = process.tid 1029 for (let i=0; i<3; i++) { 1030 let pri = pro.getThreadPriority(pres) 1031 if (pri > 0) { 1032 let flag = new Boolean(true) 1033 expect(Boolean(flag)).assertEqual(true) 1034 } 1035 } 1036 }) 1037 1038 /** 1039 * @tc.name: testGetThreadPriority003 1040 * @tc.desc: Returns the thread priority based on the specified tid. 1041 */ 1042 it('testProcessManagerGetThreadPriority003', 0, function () { 1043 let pro = new process.ProcessManager() 1044 let pres = process.tid 1045 for (let i=0; i<5; i++) { 1046 let pri = pro.getThreadPriority(pres) 1047 if (pri > 0) { 1048 let flag = new Boolean(true) 1049 expect(Boolean(flag)).assertEqual(true) 1050 } 1051 } 1052 }) 1053 1054 /** 1055 * @tc.name: testGetThreadPriority001 1056 * @tc.desc: Returns the thread priority based on the specified tid. 1057 */ 1058 it('testProcessManagerGetThreadPriority004', 0, function () { 1059 try { 1060 let pro = new process.ProcessManager() 1061 let pri = pro.getThreadPriority("asdad") 1062 } catch (e) { 1063 expect(e.toString()).assertEqual("BuisnessError: The type of v must be number.") 1064 } 1065 }) 1066 1067 /** 1068 * @tc.name: testGetSystemConfig001 1069 * @tc.desc: Returns the system configuration at runtime. 1070 */ 1071 it('testProcessManagerGetSystemConfig001', 0, function () { 1072 let pro = new process.ProcessManager() 1073 let _SC_ARG_MAX = 0 1074 let pri = pro.getSystemConfig(_SC_ARG_MAX) 1075 if (pri > 0) { 1076 var flag = new Boolean(true) 1077 } 1078 expect(Boolean(flag)).assertEqual(true) 1079 }) 1080 1081 /** 1082 * @tc.name: testGetSystemConfig002 1083 * @tc.desc: Returns the system configuration at runtime. 1084 */ 1085 it('testProcessManagerGetSystemConfig002', 0, function () { 1086 let pro = new process.ProcessManager() 1087 let _SC_ARG_MAX = 0 1088 for (let i=0; i<3; i++) { 1089 let pri = pro.getSystemConfig(_SC_ARG_MAX) 1090 if (pri > 0) { 1091 var flag = new Boolean(true) 1092 } 1093 expect(Boolean(flag)).assertEqual(true) 1094 } 1095 }) 1096 1097 /** 1098 * @tc.name: testGetSystemConfig003 1099 * @tc.desc: Returns the system configuration at runtime. 1100 */ 1101 it('testProcessManagerGetSystemConfig003', 0, function () { 1102 let pro = new process.ProcessManager() 1103 let _SC_ARG_MAX = 0 1104 for (let i=0; i<5; i++) { 1105 let pri = pro.getSystemConfig(_SC_ARG_MAX) 1106 if (pri > 0) { 1107 var flag = new Boolean(true) 1108 } 1109 expect(Boolean(flag)).assertEqual(true) 1110 } 1111 }) 1112 1113 /** 1114 * @tc.name: testGetSystemConfig004 1115 * @tc.desc: Returns the system configuration at runtime. 1116 */ 1117 it('testProcessManagerGetSystemConfig004', 0, function () { 1118 let pro = new process.ProcessManager() 1119 let _SC_OPEN_MAX = 4 1120 let pri = pro.getSystemConfig(_SC_OPEN_MAX) 1121 if (pri > 0) { 1122 var flag = new Boolean(true) 1123 } 1124 expect(Boolean(flag)).assertEqual(true) 1125 }) 1126 1127 /** 1128 * @tc.name: testGetSystemConfig005 1129 * @tc.desc: Returns the system configuration at runtime. 1130 */ 1131 it('testProcessManagerGetSystemConfig005', 0, function () { 1132 let pro = new process.ProcessManager() 1133 let _SC_PAGESIZE = 8 1134 let pri = pro.getSystemConfig(_SC_PAGESIZE) 1135 if (pri > 0) { 1136 var flag = new Boolean(true) 1137 } 1138 expect(Boolean(flag)).assertEqual(true) 1139 }) 1140 1141 /** 1142 * @tc.name: testGetSystemConfig001 1143 * @tc.desc: Returns the system configuration at runtime. 1144 */ 1145 it('testProcessManagerGetSystemConfig006', 0, function () { 1146 try { 1147 let pro = new process.ProcessManager() 1148 let pri = pro.getSystemConfig("asdad") 1149 } catch (e) { 1150 expect(e.toString()).assertEqual("BuisnessError: The type of v must be number.") 1151 } 1152 }) 1153 1154 /** 1155 * @tc.name: testGetEnvironmentVar001 1156 * @tc.desc: Returns the system value for environment variables. 1157 */ 1158 it('testProcessManagerGetEnvironmentVar001', 0, function () { 1159 let pro = new process.ProcessManager() 1160 let pri = pro.getEnvironmentVar("USER") 1161 if (pri != null) { 1162 var flag = new Boolean(true) 1163 expect(Boolean(flag)).assertEqual(true) 1164 } 1165 }) 1166 1167 /** 1168 * @tc.name: testGetEnvironmentVar002 1169 * @tc.desc: Returns the system value for environment variables. 1170 */ 1171 it('testProcessManagerGetEnvironmentVar002', 0, function () { 1172 let pro = new process.ProcessManager() 1173 for (let i=0; i<3; i++) { 1174 let pri = pro.getEnvironmentVar("PATH") 1175 if (pri != null) { 1176 var flag = new Boolean(true) 1177 expect(Boolean(flag)).assertEqual(true) 1178 } 1179 } 1180 }) 1181 1182 /** 1183 * @tc.name: testGetEnvironmentVar006 1184 * @tc.desc: Returns the system value for environment variables. 1185 */ 1186 it('testProcessManagerGetEnvironmentVar003', 0, function () { 1187 let pro = new process.ProcessManager() 1188 for (let i=0; i<100; i++) { 1189 let pri = pro.getEnvironmentVar("i123") 1190 if (pri == null) { 1191 var flag = new Boolean(true) 1192 expect(Boolean(flag)).assertEqual(true) 1193 } 1194 } 1195 }) 1196 1197 /** 1198 * @tc.name: testGetEnvironmentVar001 1199 * @tc.desc: Returns the system value for environment variables. 1200 */ 1201 it('testProcessManagerGetEnvironmentVar004', 0, function () { 1202 try { 1203 let pro = new process.ProcessManager() 1204 let pri = pro.getEnvironmentVar(123) 1205 } catch (e) { 1206 expect(e.toString()).assertEqual("BuisnessError: The type of v must be string.") 1207 } 1208 }) 1209}) 1210}