1/* 2 * Copyright (C) 2021-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 vibrator from '@ohos.vibrator' 16import systemVibrator from '@system.vibrator' 17 18import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index' 19 20describe("VibratorJsTest", function () { 21 beforeAll(function () { 22 /* 23 * @tc.setup: setup invoked before all testcases 24 */ 25 console.info('beforeAll called') 26 }) 27 28 afterAll(function () { 29 /* 30 * @tc.teardown: teardown invoked after all testcases 31 */ 32 console.info('afterAll called') 33 }) 34 35 beforeEach(function () { 36 /* 37 * @tc.setup: setup invoked before each testcases 38 */ 39 console.info('beforeEach called') 40 }) 41 42 afterEach(function () { 43 /* 44 * @tc.teardown: teardown invoked after each testcases 45 */ 46 vibrator.stop("preset"); 47 vibrator.stop("time"); 48 console.info('afterEach called') 49 }) 50 51 const OPERATION_FAIL_CODE = 14600101; 52 const PERMISSION_ERROR_CODE = 201; 53 const PARAMETER_ERROR_CODE = 401; 54 55 const OPERATION_FAIL_MSG = 'Device operation failed.' 56 const PERMISSION_ERROR_MSG = 'Permission denied.' 57 const PARAMETER_ERROR_MSG = 'The parameter invalid.' 58 59 /* 60 * @tc.name:VibratorJsTest001 61 * @tc.desc:verify app info is not null 62 * @tc.type: FUNC 63 * @tc.require: Issue Number 64 */ 65 it("VibratorJsTest001", 0, async function (done) { 66 function vibrateCallback(error) { 67 if (error) { 68 console.info('VibratorJsTest001 vibrator error'); 69 expect(false).assertTrue(); 70 } else { 71 console.info('VibratorJsTest001 vibrator success'); 72 expect(true).assertTrue(); 73 } 74 setTimeout(() => { 75 done(); 76 }, 500); 77 } 78 vibrator.vibrate(10, vibrateCallback); 79 }) 80 81 /* 82 * @tc.name:VibratorJsTest002 83 * @tc.desc:verify app info is not null 84 * @tc.type: FUNC 85 * @tc.require: Issue Number 86 */ 87 it("VibratorJsTest002", 0, async function (done) { 88 function vibrateCallback(error) { 89 if (error) { 90 console.info('VibratorJsTest002 vibrator success'); 91 expect(true).assertTrue(); 92 } else { 93 console.info('VibratorJsTest002 vibrator error'); 94 expect(false).assertTrue(); 95 } 96 setTimeout(() => { 97 done(); 98 }, 500); 99 } 100 vibrator.vibrate(-1, vibrateCallback); 101 }) 102 103 /* 104 * @tc.name:VibratorJsTest003 105 * @tc.desc:verify app info is not null 106 * @tc.type: FUNC 107 * @tc.require: Issue Number 108 */ 109 it("VibratorJsTest003", 0, async function (done) { 110 function vibrateCallback(error) { 111 if (error) { 112 console.info('VibratorJsTest003 vibrator success'); 113 expect(true).assertTrue(); 114 } else { 115 console.info('VibratorJsTest003 vibrator error'); 116 expect(false).assertTrue(); 117 } 118 setTimeout(() => { 119 done(); 120 }, 500); 121 } 122 vibrator.vibrate(1800000 + 1, vibrateCallback); 123 }) 124 125 /* 126 * @tc.name:VibratorJsTest004 127 * @tc.desc:verify app info is not null 128 * @tc.type: FUNC 129 * @tc.require: Issue Number 130 */ 131 it("VibratorJsTest004", 0, async function (done) { 132 function vibrateCallback(error) { 133 if (error) { 134 console.info('VibratorJsTest004 vibrator error'); 135 expect(false).assertTrue(); 136 } else { 137 console.info('VibratorJsTest004 vibrator success'); 138 expect(true).assertTrue(); 139 } 140 setTimeout(() => { 141 done(); 142 }, 500); 143 } 144 vibrator.vibrate(1800000, vibrateCallback); 145 }) 146 147 /* 148 * @tc.name:VibratorJsTest005 149 * @tc.desc:verify app info is not null 150 * @tc.type: FUNC 151 * @tc.require: Issue Number 152 */ 153 it("VibratorJsTest005", 0, async function (done) { 154 function vibrateCallback(error) { 155 if (error) { 156 console.info('VibratorJsTest005 vibrator success'); 157 expect(true).assertTrue(); 158 } else { 159 console.info('VibratorJsTest005 vibrator error'); 160 expect(false).assertTrue(); 161 } 162 setTimeout(() => { 163 done(); 164 }, 500); 165 } 166 vibrator.vibrate("", vibrateCallback); 167 }) 168 169 /* 170 * @tc.name:VibratorJsTest006 171 * @tc.desc:verify app info is not null 172 * @tc.type: FUNC 173 * @tc.require: Issue Number 174 */ 175 it("VibratorJsTest006", 0, async function (done) { 176 function vibrateCallback(error) { 177 if (error) { 178 console.info('VibratorJsTest006 vibrator success'); 179 expect(true).assertTrue(); 180 } else { 181 console.info('VibratorJsTest006 vibrator error'); 182 expect(false).assertTrue(); 183 } 184 setTimeout(() => { 185 done(); 186 }, 500); 187 } 188 vibrator.vibrate("xxx", vibrateCallback); 189 }) 190 191 /* 192 * @tc.name:VibratorJsTest007 193 * @tc.desc:verify app info is not null 194 * @tc.type: FUNC 195 * @tc.require: Issue Number 196 */ 197 it("VibratorJsTest007", 0, async function (done) { 198 function vibrateCallback(error) { 199 if (error) { 200 console.info('VibratorJsTest007 vibrator error'); 201 expect(false).assertTrue(); 202 } else { 203 console.info('VibratorJsTest007 vibrator success'); 204 expect(true).assertTrue(); 205 } 206 setTimeout(() => { 207 done(); 208 }, 500); 209 } 210 vibrator.vibrate("haptic.clock.timer", vibrateCallback); 211 }) 212 213 /* 214 * @tc.name:VibratorJsTest008 215 * @tc.desc:verify app info is not null 216 * @tc.type: FUNC 217 * @tc.require: Issue Number 218 */ 219 it("VibratorJsTest008", 0, async function (done) { 220 function stopPromise() { 221 return new Promise((resolve, reject) => { 222 vibrator.stop("time", (error) => { 223 if (error) { 224 console.info('VibratorJsTest008 stop error'); 225 expect(false).assertTrue(); 226 setTimeout(() => { 227 reject(); 228 }, 500); 229 } else { 230 console.info('VibratorJsTest008 stop success'); 231 expect(true).assertTrue(); 232 setTimeout(() => { 233 resolve(); 234 }, 500); 235 } 236 }); 237 }) 238 } 239 240 let promise = new Promise((resolve, reject) => { 241 vibrator.vibrate(180000, (error) => { 242 if (error) { 243 console.info('VibratorJsTest008 vibrate error'); 244 expect(false).assertTrue(); 245 setTimeout(() => { 246 reject(); 247 }, 500); 248 } else { 249 console.info('VibratorJsTest008 vibrate success'); 250 expect(true).assertTrue(); 251 setTimeout(() => { 252 resolve(); 253 }, 500); 254 } 255 }); 256 }) 257 258 await promise.then(() => { 259 return stopPromise(); 260 }, () => { 261 console.info("VibratorJsTest008 reject"); 262 }) 263 done(); 264 }) 265 266 /* 267 * @tc.name:VibratorJsTest009 268 * @tc.desc:verify app info is not null 269 * @tc.type: FUNC 270 * @tc.require: Issue Number 271 */ 272 it("VibratorJsTest009", 0, async function (done) { 273 try { 274 function vibrateCallback(error) { 275 if (error) { 276 console.info('VibratorJsTest009 stop success'); 277 expect(true).assertTrue(); 278 } else { 279 console.info('VibratorJsTest009 stop off'); 280 expect(false).assertTrue(); 281 } 282 setTimeout(() => { 283 done(); 284 }, 500); 285 } 286 vibrator.stop("", vibrateCallback); 287 } catch (error) { 288 console.info(error); 289 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 290 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 291 done(); 292 } 293 }) 294 295 /* 296 * @tc.name:VibratorJsTest010 297 * @tc.desc:verify app info is not null 298 * @tc.type: FUNC 299 * @tc.require: Issue Number 300 */ 301 it("VibratorJsTest010", 0, async function (done) { 302 vibrator.vibrate(1000).then(() => { 303 console.log("VibratorJsTest010 vibrate success"); 304 expect(true).assertTrue(); 305 setTimeout(() => { 306 done(); 307 }, 500); 308 }, (error) => { 309 expect(false).assertTrue(); 310 console.log("VibratorJsTest010 vibrate error"); 311 setTimeout(() => { 312 done(); 313 }, 500); 314 }); 315 }) 316 317 /* 318 * @tc.name:VibratorJsTest011 319 * @tc.desc:verify app info is not null 320 * @tc.type: FUNC 321 * @tc.require: Issue Number 322 */ 323 it("VibratorJsTest011", 0, async function (done) { 324 vibrator.vibrate(-1).then(() => { 325 console.log("VibratorJsTest011 vibrate error"); 326 expect(false).assertTrue(); 327 setTimeout(() => { 328 done(); 329 }, 500); 330 }, (error) => { 331 expect(true).assertTrue(); 332 console.log("VibratorJsTest011 vibrate success"); 333 setTimeout(() => { 334 done(); 335 }, 500); 336 }); 337 }) 338 339 /* 340 * @tc.name:VibratorJsTest012 341 * @tc.desc:verify app info is not null 342 * @tc.type: FUNC 343 * @tc.require: Issue Number 344 */ 345 it("VibratorJsTest012", 0, async function (done) { 346 vibrator.vibrate(1800000 + 1).then(() => { 347 console.log("VibratorJsTest012 vibrate error"); 348 expect(false).assertTrue(); 349 setTimeout(() => { 350 done(); 351 }, 500); 352 }, (error) => { 353 expect(true).assertTrue(); 354 console.log("VibratorJsTest012 vibrate success"); 355 setTimeout(() => { 356 done(); 357 }, 500); 358 }); 359 }) 360 361 /* 362 * @tc.name:VibratorJsTest013 363 * @tc.desc:verify app info is not null 364 * @tc.type: FUNC 365 * @tc.require: Issue Number 366 */ 367 it("VibratorJsTest013", 0, async function (done) { 368 vibrator.vibrate("haptic.clock.timer").then(() => { 369 console.log("VibratorJsTest013 vibrate success"); 370 expect(true).assertTrue(); 371 setTimeout(() => { 372 done(); 373 }, 500); 374 }, (error) => { 375 expect(false).assertTrue(); 376 console.log("VibratorJsTest013 vibrate error"); 377 setTimeout(() => { 378 done(); 379 }, 500); 380 }); 381 }) 382 383 /* 384 * @tc.name:VibratorJsTest014 385 * @tc.desc:verify app info is not null 386 * @tc.type: FUNC 387 * @tc.require: Issue Number 388 */ 389 it("VibratorJsTest014", 0, async function (done) { 390 vibrator.vibrate("").then(() => { 391 console.log("VibratorJsTest014 vibrate error"); 392 expect(false).assertTrue(); 393 setTimeout(() => { 394 done(); 395 }, 500); 396 }, (error) => { 397 expect(true).assertTrue(); 398 console.log("VibratorJsTest014 vibrate success"); 399 setTimeout(() => { 400 done(); 401 }, 500); 402 }); 403 }) 404 405 /* 406 * @tc.name:VibratorJsTest015 407 * @tc.desc:verify app info is not null 408 * @tc.type: FUNC 409 * @tc.require: Issue Number 410 */ 411 it("VibratorJsTest015", 0, async function (done) { 412 try { 413 vibrator.stop("").then(() => { 414 console.log("VibratorJsTest015 stop error"); 415 expect(false).assertTrue(); 416 setTimeout(() => { 417 done(); 418 }, 500); 419 }, (error) => { 420 expect(true).assertTrue(); 421 console.log("VibratorJsTest015 stop success"); 422 setTimeout(() => { 423 done(); 424 }, 500); 425 }); 426 } catch (error) { 427 console.info(error); 428 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 429 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 430 done(); 431 } 432 }) 433 434 /* 435 * @tc.name:VibratorJsTest016 436 * @tc.desc:verify app info is not null 437 * @tc.type: FUNC 438 * @tc.require: Issue Number 439 */ 440 it("VibratorJsTest016", 0, async function (done) { 441 function stopPromise() { 442 return new Promise((resolve, reject) => { 443 vibrator.stop("time").then(() => { 444 console.log("VibratorJsTest016 stop success"); 445 expect(true).assertTrue(); 446 setTimeout(() => { 447 resolve(); 448 }, 500); 449 }, (error) => { 450 expect(false).assertTrue(); 451 console.log("VibratorJsTest016 stop error"); 452 setTimeout(() => { 453 reject(); 454 }, 500); 455 }); 456 }) 457 } 458 459 let promise = new Promise((resolve, reject) => { 460 vibrator.vibrate(180000).then(() => { 461 console.log("VibratorJsTest016 vibrate success"); 462 expect(true).assertTrue(); 463 setTimeout(() => { 464 resolve(); 465 }, 500); 466 }, (error) => { 467 expect(false).assertTrue(); 468 console.log("VibratorJsTest016 vibrate error"); 469 setTimeout(() => { 470 reject(); 471 }, 500); 472 }); 473 }) 474 475 await promise.then(() => { 476 return stopPromise(); 477 }, () => { 478 console.info("VibratorJsTest016 reject"); 479 }) 480 done(); 481 }) 482 483 /* 484 * @tc.name:VibratorJsTest017 485 * @tc.desc:verify app info is not null 486 * @tc.type: FUNC 487 * @tc.require: I5SWJI 488 */ 489 it("VibratorJsTest017", 0, async function (done) { 490 systemVibrator.vibrate({ 491 mode: 'short', 492 success: function () { 493 expect(true).assertTrue(); 494 console.log('vibrate is successful'); 495 done(); 496 }, 497 fail: function (data, code) { 498 expect(false).assertTrue(); 499 console.log('vibrate is failed, data: ' + data + "code: " + code); 500 done(); 501 }, 502 complete: function () { 503 console.log('vibrate is completed'); 504 done(); 505 } 506 }); 507 }) 508 509 /* 510 * @tc.name:VibratorJsTest018 511 * @tc.desc:verify app info is not null 512 * @tc.type: FUNC 513 * @tc.require: I53SGE 514 */ 515 it("VibratorJsTest018", 0, async function (done) { 516 systemVibrator.vibrate({ 517 mode: 'long', 518 success: function () { 519 expect(true).assertTrue(); 520 console.log('vibrate is successful'); 521 done(); 522 }, 523 fail: function (data, code) { 524 expect(false).assertTrue(); 525 console.log('vibrate is failed, data: ' + data + "code: " + code); 526 done(); 527 }, 528 complete: function () { 529 console.log('vibrate is completed'); 530 done(); 531 } 532 }); 533 }) 534 535 /* 536 * @tc.name:VibratorJsTest019 537 * @tc.desc:verify app info is not null 538 * @tc.type: FUNC 539 * @tc.require: I53SGE 540 */ 541 it("VibratorJsTest019", 0, async function (done) { 542 systemVibrator.vibrate({ 543 success: function () { 544 expect(true).assertTrue(); 545 console.log('vibrate is successful'); 546 done(); 547 }, 548 fail: function (data, code) { 549 expect(false).assertTrue(); 550 console.log('vibrate is failed, data: ' + data + "code: " + code); 551 done(); 552 }, 553 complete: function () { 554 console.log('vibrate is completed'); 555 done(); 556 } 557 }); 558 }) 559 560 /* 561 * @tc.name:VibratorJsTest020 562 * @tc.desc:verify app info is not null 563 * @tc.type: FUNC 564 * @tc.require: I53SGE 565 */ 566 it("VibratorJsTest020", 0, async function (done) { 567 systemVibrator.vibrate({ 568 success: function () { 569 expect(true).assertTrue(); 570 console.log('vibrate is successful'); 571 done(); 572 }, 573 }); 574 }) 575 576 /* 577 * @tc.name:VibrateTest001 578 * @tc.desc:verify app info is not null 579 * @tc.type: FUNC 580 * @tc.require: I53SGE 581 */ 582 it("VibrateTest001", 0, async function (done) { 583 vibrator.startVibration({ 584 type: "time", 585 duration: 1000 586 }, { 587 usage: "unknown" 588 }, (error) => { 589 if (error) { 590 console.info('VibrateTest001 startVibration error'); 591 expect(false).assertTrue(); 592 } else { 593 console.info('VibrateTest001 startVibration success'); 594 expect(true).assertTrue(); 595 } 596 setTimeout(() => { 597 done(); 598 }, 500); 599 }); 600 }) 601 602 /* 603 * @tc.name:VibrateTest002 604 * @tc.desc:verify app info is not null 605 * @tc.type: FUNC 606 * @tc.require: I53SGE 607 */ 608 it("VibrateTest002", 0, async function (done) { 609 try { 610 vibrator.startVibration({ 611 type: "", 612 duration: 1000 613 }, { 614 usage: "unknown" 615 }, (error) => { 616 if (error) { 617 expect(true).assertTrue(); 618 } else { 619 expect(false).assertTrue(); 620 } 621 setTimeout(() => { 622 done(); 623 }, 500); 624 }); 625 } catch (error) { 626 console.info(error); 627 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 628 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 629 done(); 630 } 631 }) 632 633 /* 634 * @tc.name:VibrateTest003 635 * @tc.desc:verify app info is not null 636 * @tc.type: FUNC 637 * @tc.require: I53SGE 638 */ 639 it("VibrateTest003", 0, async function (done) { 640 vibrator.startVibration({ 641 type: "preset", 642 effectId: "haptic.clock.timer", 643 count: 1, 644 }, { 645 usage: "unknown" 646 }, (error) => { 647 if (error) { 648 console.info('VibrateTest003 vibrator error'); 649 expect(false).assertTrue(); 650 } else { 651 console.info('VibrateTest003 vibrator success'); 652 expect(true).assertTrue(); 653 } 654 setTimeout(() => { 655 done(); 656 }, 500); 657 }); 658 }) 659 660 /* 661 * @tc.name:VibrateTest004 662 * @tc.desc:verify app info is not null 663 * @tc.type: FUNC 664 * @tc.require: I53SGE 665 */ 666 it("VibrateTest004", 0, async function (done) { 667 try { 668 vibrator.startVibration({ 669 type: "preset", 670 effectId: "", 671 count: 3, 672 }, { 673 usage: "unknown" 674 }, (error) => { 675 if (error) { 676 expect(true).assertTrue(); 677 } else { 678 expect(false).assertTrue(); 679 } 680 setTimeout(() => { 681 done(); 682 }, 500); 683 }); 684 } catch (error) { 685 console.info(error); 686 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 687 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 688 done(); 689 } 690 }) 691 692 /* 693 * @tc.name:VibrateTest005 694 * @tc.desc:verify app info is not null 695 * @tc.type: FUNC 696 * @tc.require: I53SGE 697 */ 698 it("VibrateTest005", 0, async function (done) { 699 try { 700 vibrator.startVibration({ 701 type: "preset", 702 effectId: "haptic.clock.timer", 703 count: 3, 704 }, { 705 usage: "" 706 }, (error) => { 707 expect(false).assertTrue(); 708 setTimeout(() => { 709 done(); 710 }, 500); 711 }); 712 } catch (error) { 713 console.info(error); 714 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 715 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 716 done(); 717 } 718 }) 719 720 /* 721 * @tc.name:VibrateTest006 722 * @tc.desc:verify app info is not null 723 * @tc.type: FUNC 724 * @tc.require: I53SGE 725 */ 726 it("VibrateTest006", 0, async function (done) { 727 try { 728 vibrator.startVibration(null, null); 729 } catch (error) { 730 console.info(error); 731 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 732 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 733 done(); 734 } 735 }) 736 737 /* 738 * @tc.name:VibrateTest007 739 * @tc.desc:verify app info is not null 740 * @tc.type: FUNC 741 * @tc.require: I53SGE 742 */ 743 it("VibrateTest007", 0, async function (done) { 744 await vibrator.startVibration({ 745 type: "time", 746 duration: 1000, 747 }, { 748 usage: "unknown" 749 }).then(() => { 750 expect(true).assertTrue(); 751 }).catch((error) => { 752 expect(false).assertTrue(); 753 }); 754 done(); 755 }) 756 757 /* 758 * @tc.name:VibrateTest008 759 * @tc.desc:verify app info is not null 760 * @tc.type: FUNC 761 * @tc.require: I53SGE 762 */ 763 it("VibrateTest008", 0, async function (done) { 764 try { 765 await vibrator.startVibration({ 766 type: "", 767 duration: 1000 768 }, { 769 usage: "unknown" 770 }).then(() => { 771 expect(false).assertTrue(); 772 }).catch((error) => { 773 expect(true).assertTrue(); 774 }); 775 done(); 776 } catch (error) { 777 console.info(error); 778 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 779 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 780 done(); 781 } 782 }) 783 784 /* 785 * @tc.name:VibrateTest009 786 * @tc.desc:verify app info is not null 787 * @tc.type: FUNC 788 * @tc.require: I53SGE 789 */ 790 it("VibrateTest009", 0, async function (done) { 791 await vibrator.startVibration({ 792 type: "preset", 793 effectId: "haptic.clock.timer", 794 count: 1, 795 }, { 796 usage: "unknown" 797 }).then(() => { 798 expect(true).assertTrue(); 799 }).catch((error) => { 800 expect(false).assertTrue(); 801 }); 802 done(); 803 }) 804 805 /* 806 * @tc.name:VibrateTest010 807 * @tc.desc:verify app info is not null 808 * @tc.type: FUNC 809 * @tc.require: I53SGE 810 */ 811 it("VibrateTest010", 0, async function (done) { 812 try { 813 vibrator.startVibration({ 814 type: "preset", 815 effectId: "", 816 count: 3, 817 }, { 818 usage: "unknown" 819 }).then(() => { 820 expect(false).assertTrue(); 821 done(); 822 }).catch((error) => { 823 expect(true).assertTrue(); 824 done(); 825 }); 826 } catch (error) { 827 console.info(error); 828 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 829 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 830 done(); 831 } 832 }) 833 834 /* 835 * @tc.name:VibrateTest011 836 * @tc.desc:verify app info is not null 837 * @tc.type: FUNC 838 * @tc.require: I53SGE 839 */ 840 it("VibrateTest011", 0, async function (done) { 841 try { 842 vibrator.startVibration({ 843 type: "preset", 844 effectId: "haptic.clock.timer", 845 count: 3, 846 }, { 847 usage: "" 848 }).then(() => { 849 expect(false).assertTrue(); 850 done(); 851 }).catch((error) => { 852 expect(true).assertTrue(); 853 done(); 854 }); 855 } catch (error) { 856 console.info(error); 857 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 858 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 859 done(); 860 } 861 }) 862 863 /* 864 * @tc.name:VibrateTest012 865 * @tc.desc:verify app info is not null 866 * @tc.type: FUNC 867 * @tc.require: I53SGE 868 */ 869 it("VibrateTest012", 0, async function (done) { 870 try { 871 vibrator.startVibration({ 872 type: 1, 873 count: 3, 874 }, { 875 usage: "" 876 }) 877 } catch (error) { 878 console.info(error); 879 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 880 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 881 done(); 882 } 883 }) 884 885 /* 886 * @tc.name:VibrateTest013 887 * @tc.desc:verify app info is not null 888 * @tc.type: FUNC 889 * @tc.require: I53SGE 890 */ 891 it("VibrateTest013", 0, async function (done) { 892 function vibratePromise() { 893 return new Promise((resolve, reject) => { 894 vibrator.startVibration({ 895 type: "time", 896 duration: 100 897 }, { 898 usage: "unknown" 899 }, (error) => { 900 if (error) { 901 expect(false).assertTrue(); 902 } else { 903 expect(true).assertTrue(); 904 } 905 setTimeout(() => { 906 done(); 907 }, 500); 908 }); 909 }) 910 } 911 912 let promise = new Promise((resolve, reject) => { 913 vibrator.startVibration({ 914 type: "time", 915 duration: 100 916 }, { 917 usage: "unknown" 918 }, (error) => { 919 if (error) { 920 expect(false).assertTrue(); 921 reject(); 922 } else { 923 expect(true).assertTrue(); 924 resolve(); 925 } 926 }); 927 }) 928 929 await promise.then(() => { 930 return vibratePromise(); 931 }, () => { 932 console.info("StartVibrationTest013 reject"); 933 }) 934 done(); 935 }) 936 937 /* 938 * @tc.name:VibrateTest014 939 * @tc.desc:verify app info is not null 940 * @tc.type: FUNC 941 * @tc.require: I53SGE 942 */ 943 it("VibrateTest014", 0, async function (done) { 944 function vibratePromise() { 945 return new Promise((resolve, reject) => { 946 vibrator.startVibration({ 947 type: "preset", 948 effectId: "haptic.clock.timer", 949 count: 1, 950 }, { 951 usage: "unknown" 952 }, (error) => { 953 if (error) { 954 expect(error.code).assertEqual(OPERATION_FAIL_CODE); 955 expect(error.message).assertEqual(OPERATION_FAIL_MSG); 956 } else { 957 expect(false).assertTrue(); 958 } 959 setTimeout(() => { 960 done(); 961 }, 500); 962 }); 963 }) 964 } 965 966 let promise = new Promise((resolve, reject) => { 967 vibrator.startVibration({ 968 type: "time", 969 duration: 100 970 }, { 971 usage: "alarm" 972 }, (error) => { 973 if (error) { 974 expect(false).assertTrue(); 975 reject(); 976 } else { 977 expect(true).assertTrue(); 978 resolve(); 979 } 980 }); 981 }) 982 983 await promise.then(() => { 984 return vibratePromise(); 985 }, () => { 986 console.info("VibrateTest014 reject"); 987 }) 988 done(); 989 }) 990 991 /* 992 * @tc.name:VibrateTest015 993 * @tc.desc:verify app info is not null 994 * @tc.type: FUNC 995 * @tc.require: I6HKTI 996 */ 997 it("VibrateTest015", 0, async function (done) { 998 function vibratePromise() { 999 return new Promise((resolve, reject) => { 1000 vibrator.startVibration({ 1001 type: "preset", 1002 effectId: "haptic.clock.timer", 1003 count: 3, 1004 }, { 1005 usage: "unknown", 1006 }, (error) => { 1007 if (error) { 1008 expect(false).assertTrue(); 1009 } else { 1010 expect(true).assertTrue(); 1011 } 1012 setTimeout(() => { 1013 done(); 1014 }, 500); 1015 }); 1016 }) 1017 } 1018 1019 let promise = new Promise((resolve, reject) => { 1020 vibrator.startVibration({ 1021 type: "time", 1022 duration: 10000 1023 }, { 1024 usage: "alarm" 1025 }, (error) => { 1026 if (error) { 1027 expect(false).assertTrue(); 1028 reject(); 1029 } else { 1030 expect(true).assertTrue(); 1031 resolve(); 1032 } 1033 }); 1034 }) 1035 await promise.then(() => { 1036 return vibratePromise(); 1037 }, () => { 1038 console.info("VibrateTest015 reject"); 1039 }) 1040 done(); 1041 }) 1042 1043 /* 1044 * @tc.name:VibrateTest016 1045 * @tc.desc:verify app info is not null 1046 * @tc.type: FUNC 1047 * @tc.require: I6HKTI 1048 */ 1049 it("VibrateTest016", 0, async function (done) { 1050 function vibratePromise() { 1051 return new Promise((resolve, reject) => { 1052 vibrator.startVibration({ 1053 type: "time", 1054 duration: 3000, 1055 }, { 1056 usage: "alarm" 1057 }, (error) => { 1058 if (error) { 1059 expect(false).assertTrue(); 1060 } else { 1061 expect(true).assertTrue(); 1062 } 1063 setTimeout(() => { 1064 done(); 1065 }, 500); 1066 }); 1067 }) 1068 } 1069 1070 let promise = new Promise((resolve, reject) => { 1071 vibrator.startVibration({ 1072 type: "preset", 1073 effectId: "haptic.clock.timer", 1074 count: 1, 1075 }, { 1076 usage: "unknown" 1077 }, (error) => { 1078 if (error) { 1079 expect(false).assertTrue(); 1080 reject(); 1081 } else { 1082 expect(true).assertTrue(); 1083 resolve(); 1084 } 1085 }); 1086 }) 1087 1088 await promise.then(() => { 1089 return vibratePromise(); 1090 }, () => { 1091 console.info("VibrateTest016 reject"); 1092 }) 1093 done(); 1094 }) 1095 1096 /* 1097 * @tc.name:VibrateTest017 1098 * @tc.desc:verify app info is not null 1099 * @tc.type: FUNC 1100 * @tc.require: I6HKTI 1101 */ 1102 it("VibrateTest017", 0, async function (done) { 1103 function vibratePromise() { 1104 return new Promise((resolve, reject) => { 1105 vibrator.startVibration({ 1106 type: "preset", 1107 effectId: "haptic.clock.timer", 1108 count: 3, 1109 }, { 1110 usage: "unknown" 1111 }, (error) => { 1112 if (error) { 1113 expect(false).assertTrue(); 1114 } else { 1115 expect(true).assertTrue(); 1116 } 1117 setTimeout(() => { 1118 done(); 1119 }, 500); 1120 }); 1121 }) 1122 } 1123 1124 let promise = new Promise((resolve, reject) => { 1125 vibrator.startVibration({ 1126 type: "preset", 1127 effectId: "haptic.clock.timer", 1128 count: 3, 1129 }, { 1130 usage: "unknown" 1131 }, (error) => { 1132 if (error) { 1133 expect(false).assertTrue(); 1134 reject(); 1135 } else { 1136 expect(true).assertTrue(); 1137 resolve(); 1138 } 1139 }); 1140 }) 1141 1142 await promise.then(() => { 1143 return vibratePromise(); 1144 }, () => { 1145 console.info("VibrateTest017 reject"); 1146 }) 1147 done(); 1148 }) 1149 1150 /* 1151 * @tc.name:VibrateTest018 1152 * @tc.desc:verify app info is not null 1153 * @tc.type: FUNC 1154 * @tc.require: I6HKTI 1155 */ 1156 it("VibrateTest018", 0, async function (done) { 1157 function vibratePromise() { 1158 return new Promise((resolve, reject) => { 1159 vibrator.startVibration({ 1160 type: "preset", 1161 effectId: "haptic.clock.timer", 1162 count: 1, 1163 }, { 1164 usage: "ring" 1165 }, (error) => { 1166 if (error) { 1167 expect(false).assertTrue(); 1168 } else { 1169 expect(true).assertTrue(); 1170 } 1171 setTimeout(() => { 1172 done(); 1173 }, 500); 1174 }); 1175 }) 1176 } 1177 1178 let promise = new Promise((resolve, reject) => { 1179 vibrator.startVibration({ 1180 type: "preset", 1181 effectId: "haptic.clock.timer", 1182 count: 1, 1183 }, { 1184 usage: "notification" 1185 }, (error) => { 1186 if (error) { 1187 expect(false).assertTrue(); 1188 reject(); 1189 } else { 1190 expect(true).assertTrue(); 1191 resolve(); 1192 } 1193 }); 1194 }) 1195 1196 await promise.then(() => { 1197 return vibratePromise(); 1198 }, () => { 1199 console.info("VibrateTest018 reject"); 1200 }) 1201 done(); 1202 }) 1203 1204 /* 1205 * @tc.name:VibratorJsTest019 1206 * @tc.desc:verify app info is not null 1207 * @tc.type: FUNC 1208 * @tc.require: I5SWJI 1209 */ 1210 it("VibratorJsTest019", 0, async function (done) { 1211 function vibrateCallback(error) { 1212 if (error) { 1213 console.info('VibratorJsTest019 stop fail'); 1214 expect(false).assertTrue(); 1215 } else { 1216 console.info('VibratorJsTest019 stop off'); 1217 expect(false).assertTrue(); 1218 } 1219 setTimeout(() => { 1220 done(); 1221 }, 500); 1222 } 1223 try { 1224 vibrator.stopVibration("", vibrateCallback); 1225 } catch (error) { 1226 console.info(error); 1227 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1228 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 1229 done(); 1230 } 1231 }) 1232 1233 /* 1234 * @tc.name:VibrateTest020 1235 * @tc.desc:verify app info is not null 1236 * @tc.type: FUNC 1237 * @tc.require: I5SWJI 1238 */ 1239 it("VibrateTest020", 0, async function (done) { 1240 try { 1241 vibrator.stopVibration("").then(() => { 1242 console.log("VibrateTest020 stop error"); 1243 expect(false).assertTrue(); 1244 setTimeout(() => { 1245 done(); 1246 }, 500); 1247 }, (error) => { 1248 expect(false).assertTrue(); 1249 console.log("VibrateTest020 stop error"); 1250 setTimeout(() => { 1251 done(); 1252 }, 500); 1253 }); 1254 } catch (error) { 1255 console.info(error); 1256 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1257 expect(error.message).assertEqual(PARAMETER_ERROR_MSG); 1258 done(); 1259 } 1260 }) 1261 1262 /* 1263 * @tc.name:VibrateTest021 1264 * @tc.desc:verify app info is not null 1265 * @tc.type: FUNC 1266 * @tc.require: I5SWJI 1267 */ 1268 it("VibrateTest021", 0, async function (done) { 1269 function stopPromise() { 1270 return new Promise((resolve, reject) => { 1271 vibrator.stopVibration("time").then(() => { 1272 console.log("VibrateTest021 stop success"); 1273 expect(true).assertTrue(); 1274 setTimeout(() => { 1275 resolve(); 1276 }, 500); 1277 }, (error) => { 1278 expect(false).assertTrue(); 1279 console.log("VibrateTest021 stop error"); 1280 setTimeout(() => { 1281 reject(); 1282 }, 500); 1283 }); 1284 }) 1285 } 1286 1287 let promise = new Promise((resolve, reject) => { 1288 vibrator.vibrate(180000).then(() => { 1289 console.log("VibrateTest021 vibrate success"); 1290 expect(true).assertTrue(); 1291 setTimeout(() => { 1292 resolve(); 1293 }, 500); 1294 }, (error) => { 1295 expect(false).assertTrue(); 1296 console.log("VibrateTest021 vibrate error"); 1297 setTimeout(() => { 1298 reject(); 1299 }, 500); 1300 }); 1301 }) 1302 1303 await promise.then(() => { 1304 return stopPromise(); 1305 }, () => { 1306 console.info("VibrateTest021 reject"); 1307 }) 1308 done(); 1309 }) 1310}) 1311