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' 17import deviceInfo from '@ohos.deviceInfo' 18 19import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 20 21describe("VibratorJsTest", function () { 22 var g_execute = true; 23 let EFFECT_ID = "haptic.clock.timer"; 24 let EFFECT_SOFT = "haptic.effect.soft"; 25 let EFFECT_HARD = "haptic.effect.hard"; 26 let EFFECT_SHARP = "haptic.effect.sharp"; 27 let INVALID_EFFECT_ID = "haptic.xxx.yyy"; 28 beforeAll(function() { 29 /* 30 * @tc.setup: setup invoked before all testcases 31 */ 32 console.info('beforeAll called') 33 vibrator.isSupportEffect(EFFECT_ID).then((state) => { 34 expect(true).assertTrue(); 35 g_execute = state; 36 if (g_execute) { 37 console.info('this device is supportEffect') 38 } else { 39 console.info('this device is not supportEffect') 40 } 41 resolve(); 42 }, (error) => { 43 expect(false).assertTrue(); 44 reject(error); 45 }); 46 }) 47 48 afterAll(function() { 49 /* 50 * @tc.teardown: teardown invoked after all testcases 51 */ 52 console.info('afterAll called') 53 }) 54 55 beforeEach(function() { 56 /* 57 * @tc.setup: setup invoked before each testcases 58 */ 59 60 console.info('beforeEach called') 61 }) 62 63 afterEach(function() { 64 /* 65 * @tc.teardown: teardown invoked after each testcases 66 */ 67 vibrator.stop("preset"); 68 vibrator.stop("time"); 69 console.info('afterEach called') 70 }) 71 72 const OPERATION_FAIL_CODE = 14600101; 73 const PERMISSION_ERROR_CODE = 201; 74 const PARAMETER_ERROR_CODE = 401; 75 76 const OPERATION_FAIL_MSG = 'Device operation failed.' 77 const PERMISSION_ERROR_MSG = 'Permission denied.' 78 const PARAMETER_ERROR_MSG = 'The parameter invalid.' 79 80 /* 81 * @tc.name:VibratorJsTest001 82 * @tc.desc:verify app info is not null 83 * @tc.type: FUNC 84 * @tc.require: Issue Number 85 * @tc.number: VibratorJsTest001 86 */ 87 it("VibratorJsTest001", 0, async function (done) { 88 function vibrateCallback(error) { 89 if (error) { 90 console.info('VibratorJsTest001 vibrator error'); 91 expect(false).assertTrue(); 92 } else { 93 console.info('VibratorJsTest001 vibrator success'); 94 expect(true).assertTrue(); 95 } 96 setTimeout(() => { 97 done(); 98 }, 500); 99 } 100 vibrator.vibrate(10, vibrateCallback); 101 }) 102 103 /* 104 * @tc.name:VibratorJsTest002 105 * @tc.desc:verify app info is not null 106 * @tc.type: FUNC 107 * @tc.require: Issue Number 108 * @tc.number: VibratorJsTest002 109 */ 110 it("VibratorJsTest002", 0, async function (done) { 111 function vibrateCallback(error) { 112 if (error) { 113 console.info('VibratorJsTest002 vibrator success'); 114 expect(true).assertTrue(); 115 } else { 116 console.info('VibratorJsTest002 vibrator error'); 117 expect(false).assertTrue(); 118 } 119 setTimeout(() => { 120 done(); 121 }, 500); 122 } 123 vibrator.vibrate(-1, vibrateCallback); 124 }) 125 126 /* 127 * @tc.name:VibratorJsTest003 128 * @tc.desc:verify app info is not null 129 * @tc.type: FUNC 130 * @tc.require: Issue Number 131 * @tc.number: VibratorJsTest003 132 */ 133 it("VibratorJsTest003", 0, async function (done) { 134 function vibrateCallback(error) { 135 if (error) { 136 console.info('VibratorJsTest003 vibrator success'); 137 expect(true).assertTrue(); 138 } else { 139 console.info('VibratorJsTest003 vibrator error'); 140 expect(false).assertTrue(); 141 } 142 setTimeout(() => { 143 done(); 144 }, 500); 145 } 146 vibrator.vibrate(1800000 + 1, vibrateCallback); 147 }) 148 149 /* 150 * @tc.name:VibratorJsTest004 151 * @tc.desc:verify app info is not null 152 * @tc.type: FUNC 153 * @tc.require: Issue Number 154 * @tc.number: VibratorJsTest004 155 */ 156 it("VibratorJsTest004", 0, async function (done) { 157 function vibrateCallback(error) { 158 if (error) { 159 console.info('VibratorJsTest004 vibrator error'); 160 expect(false).assertTrue(); 161 } else { 162 console.info('VibratorJsTest004 vibrator success'); 163 expect(true).assertTrue(); 164 } 165 setTimeout(() => { 166 done(); 167 }, 500); 168 } 169 vibrator.vibrate(1800000, vibrateCallback); 170 }) 171 172 /* 173 * @tc.name:VibratorJsTest005 174 * @tc.desc:verify app info is not null 175 * @tc.type: FUNC 176 * @tc.require: Issue Number 177 * @tc.number: VibratorJsTest005 178 */ 179 it("VibratorJsTest005", 0, async function (done) { 180 function vibrateCallback(error) { 181 if (error) { 182 console.info('VibratorJsTest005 vibrator success'); 183 expect(true).assertTrue(); 184 } else { 185 console.info('VibratorJsTest005 vibrator error'); 186 expect(false).assertTrue(); 187 } 188 setTimeout(() => { 189 done(); 190 }, 500); 191 } 192 vibrator.vibrate("", vibrateCallback); 193 }) 194 195 /* 196 * @tc.name:VibratorJsTest006 197 * @tc.desc:verify app info is not null 198 * @tc.type: FUNC 199 * @tc.require: Issue Number 200 * @tc.number: VibratorJsTest006 201 */ 202 it("VibratorJsTest006", 0, async function (done) { 203 function vibrateCallback(error) { 204 if (error) { 205 console.info('VibratorJsTest006 vibrator success'); 206 expect(true).assertTrue(); 207 } else { 208 console.info('VibratorJsTest006 vibrator error'); 209 expect(false).assertTrue(); 210 } 211 setTimeout(() => { 212 done(); 213 }, 500); 214 } 215 vibrator.vibrate("xxx", vibrateCallback); 216 }) 217 218 /* 219 * @tc.name:VibratorJsTest007 220 * @tc.desc:verify app info is not null 221 * @tc.type: FUNC 222 * @tc.require: Issue Number 223 * @tc.number: VibratorJsTest007 224 */ 225 it("VibratorJsTest007", 0, async function (done) { 226 if (g_execute) { 227 function vibrateCallback(error) { 228 if (error) { 229 console.info('VibratorJsTest007 vibrator error'); 230 expect(false).assertTrue(); 231 } else { 232 console.info('VibratorJsTest007 vibrator success'); 233 expect(true).assertTrue(); 234 } 235 setTimeout(() => { 236 done(); 237 }, 500); 238 } 239 vibrator.vibrate("haptic.clock.timer", vibrateCallback); 240 } else { 241 console.info('VibratorJsTest007 vibrator success'); 242 expect(true).assertTrue(); 243 done(); 244 } 245 }) 246 247 /* 248 * @tc.name:VibratorJsTest008 249 * @tc.desc:verify app info is not null 250 * @tc.type: FUNC 251 * @tc.require: Issue Number 252 * @tc.number: VibratorJsTest008 253 */ 254 it("VibratorJsTest008", 0, async function (done) { 255 if (g_execute) { 256 function stopPromise() { 257 return new Promise((resolve, reject) => { 258 vibrator.stop("preset", (error) => { 259 if (error) { 260 console.info('VibratorJsTest008 stop error'); 261 expect(false).assertTrue(); 262 setTimeout(() => { 263 reject(); 264 }, 500); 265 } else { 266 console.info('VibratorJsTest008 stop success'); 267 expect(true).assertTrue(); 268 setTimeout(() => { 269 resolve(); 270 }, 500); 271 } 272 }); 273 }) 274 } 275 276 let promise = new Promise((resolve, reject) => { 277 vibrator.vibrate("haptic.clock.timer", (error) => { 278 if (error) { 279 console.info('VibratorJsTest008 vibrate error'); 280 expect(false).assertTrue(); 281 reject(); 282 } else { 283 console.info('VibratorJsTest008 vibrate success'); 284 expect(true).assertTrue(); 285 resolve(); 286 } 287 }); 288 }) 289 290 await promise.then(() => { 291 return stopPromise(); 292 }, () => { 293 console.info("VibratorJsTest008 reject"); 294 }) 295 done(); 296 } else { 297 console.info('VibratorJsTest008 vibrator success'); 298 expect(true).assertTrue(); 299 done(); 300 } 301 }) 302 303 /* 304 * @tc.name:VibratorJsTest009 305 * @tc.desc:verify app info is not null 306 * @tc.type: FUNC 307 * @tc.require: Issue Number 308 * @tc.number: VibratorJsTest009 309 */ 310 it("VibratorJsTest009", 0, async function (done) { 311 function stopPromise() { 312 return new Promise((resolve, reject) => { 313 vibrator.stop("time", (error) => { 314 if (error) { 315 console.info('VibratorJsTest009 stop error'); 316 expect(false).assertTrue(); 317 setTimeout(() => { 318 reject(); 319 }, 500); 320 } else { 321 console.info('VibratorJsTest009 stop success'); 322 expect(true).assertTrue(); 323 setTimeout(() => { 324 resolve(); 325 }, 500); 326 } 327 }); 328 }) 329 } 330 331 let promise = new Promise((resolve, reject) => { 332 vibrator.vibrate(180000, (error) => { 333 if (error) { 334 console.info('VibratorJsTest009 vibrate error'); 335 expect(false).assertTrue(); 336 setTimeout(() => { 337 reject(); 338 }, 500); 339 } else { 340 console.info('VibratorJsTest009 vibrate success'); 341 expect(true).assertTrue(); 342 setTimeout(() => { 343 resolve(); 344 }, 500); 345 } 346 }); 347 }) 348 349 await promise.then(() => { 350 return stopPromise(); 351 }, () => { 352 console.info("VibratorJsTest009 reject"); 353 }) 354 done(); 355 }) 356 357 /* 358 * @tc.name:VibratorJsTest010 359 * @tc.desc:verify app info is not null 360 * @tc.type: FUNC 361 * @tc.require: Issue Number 362 * @tc.number: VibratorJsTest010 363 */ 364 it("VibratorJsTest010", 0, async function (done) { 365 try { 366 function vibrateCallback(error) { 367 if (error) { 368 console.info('VibratorJsTest010 stop success'); 369 expect(true).assertTrue(); 370 } else { 371 console.info('VibratorJsTest010 stop off'); 372 expect(false).assertTrue(); 373 } 374 setTimeout(() => { 375 done(); 376 }, 500); 377 } 378 vibrator.stop("", vibrateCallback); 379 } catch (error) { 380 console.info(error); 381 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 382 done(); 383 } 384 }) 385 386 /* 387 * @tc.name:VibratorJsTest011 388 * @tc.desc:verify app info is not null 389 * @tc.type: FUNC 390 * @tc.require: Issue Number 391 * @tc.number: VibratorJsTest011 392 */ 393 it("VibratorJsTest011", 0, async function (done) { 394 vibrator.vibrate(1000).then(() => { 395 console.log("VibratorJsTest011 vibrate success"); 396 expect(true).assertTrue(); 397 setTimeout(() => { 398 done(); 399 }, 500); 400 }, (error) => { 401 expect(false).assertTrue(); 402 console.log("VibratorJsTest011 vibrate error"); 403 setTimeout(() => { 404 done(); 405 }, 500); 406 }); 407 }) 408 409 /* 410 * @tc.name:VibratorJsTest012 411 * @tc.desc:verify app info is not null 412 * @tc.type: FUNC 413 * @tc.require: Issue Number 414 * @tc.number: VibratorJsTest012 415 */ 416 it("VibratorJsTest012", 0, async function (done) { 417 vibrator.vibrate(-1).then(() => { 418 console.log("VibratorJsTest012 vibrate error"); 419 expect(false).assertTrue(); 420 setTimeout(() => { 421 done(); 422 }, 500); 423 }, (error) => { 424 expect(true).assertTrue(); 425 console.log("VibratorJsTest012 vibrate success"); 426 setTimeout(() => { 427 done(); 428 }, 500); 429 }); 430 }) 431 432 /* 433 * @tc.name:VibratorJsTest013 434 * @tc.desc:verify app info is not null 435 * @tc.type: FUNC 436 * @tc.require: Issue Number 437 * @tc.number: VibratorJsTest013 438 */ 439 it("VibratorJsTest013", 0, async function (done) { 440 vibrator.vibrate(1800000 + 1).then(() => { 441 console.log("VibratorJsTest013 vibrate error"); 442 expect(false).assertTrue(); 443 setTimeout(() => { 444 done(); 445 }, 500); 446 }, (error) => { 447 expect(true).assertTrue(); 448 console.log("VibratorJsTest013 vibrate success"); 449 setTimeout(() => { 450 done(); 451 }, 500); 452 }); 453 }) 454 455 /* 456 * @tc.name:VibratorJsTest014 457 * @tc.desc:verify app info is not null 458 * @tc.type: FUNC 459 * @tc.require: Issue Number 460 * @tc.number: VibratorJsTest014 461 */ 462 it("VibratorJsTest014", 0, async function (done) { 463 if (g_execute) { 464 vibrator.vibrate("haptic.clock.timer").then(() => { 465 console.log("VibratorJsTest014 vibrate success"); 466 expect(true).assertTrue(); 467 setTimeout(() => { 468 done(); 469 }, 500); 470 }, (error) => { 471 expect(false).assertTrue(); 472 console.log("VibratorJsTest014 vibrate error"); 473 setTimeout(() => { 474 done(); 475 }, 500); 476 }); 477 } else { 478 console.info('VibratorJsTest014 vibrator success'); 479 expect(true).assertTrue(); 480 done(); 481 } 482 }) 483 484 /* 485 * @tc.name:VibratorJsTest015 486 * @tc.desc:verify app info is not null 487 * @tc.type: FUNC 488 * @tc.require: Issue Number 489 * @tc.number: VibratorJsTest015 490 */ 491 it("VibratorJsTest015", 0, async function (done) { 492 if (g_execute) { 493 function stopPromise() { 494 return new Promise((resolve, reject) => { 495 vibrator.stop("preset").then(() => { 496 console.log("VibratorJsTest015 off success"); 497 expect(true).assertTrue(); 498 setTimeout(() => { 499 resolve(); 500 }, 500); 501 }, (error) => { 502 expect(false).assertTrue(); 503 console.log("VibratorJsTest015 off error"); 504 setTimeout(() => { 505 reject(); 506 }, 500); 507 }); 508 }) 509 } 510 511 let promise = new Promise((resolve, reject) => { 512 vibrator.vibrate("haptic.clock.timer").then(() => { 513 console.log("VibratorJsTest015 vibrate success"); 514 expect(true).assertTrue(); 515 resolve(); 516 }, (error) => { 517 expect(false).assertTrue(); 518 console.log("VibratorJsTest015 vibrate error"); 519 reject(); 520 }); 521 }) 522 523 await promise.then(() => { 524 return stopPromise(); 525 }, () => { 526 console.info("VibratorJsTest015 reject"); 527 }) 528 done(); 529 } else { 530 console.info('VibratorJsTest015 vibrator success'); 531 expect(true).assertTrue(); 532 done(); 533 } 534 }) 535 536 /* 537 * @tc.name:VibratorJsTest016 538 * @tc.desc:verify app info is not null 539 * @tc.type: FUNC 540 * @tc.require: Issue Number 541 * @tc.number: VibratorJsTest016 542 */ 543 it("VibratorJsTest016", 0, async function (done) { 544 vibrator.vibrate("").then(() => { 545 console.log("VibratorJsTest016 vibrate error"); 546 expect(false).assertTrue(); 547 setTimeout(() => { 548 done(); 549 }, 500); 550 }, (error) => { 551 expect(true).assertTrue(); 552 console.log("VibratorJsTest016 vibrate success"); 553 setTimeout(() => { 554 done(); 555 }, 500); 556 }); 557 }) 558 559 /* 560 * @tc.name:VibratorJsTest017 561 * @tc.desc:verify app info is not null 562 * @tc.type: FUNC 563 * @tc.require: Issue Number 564 * @tc.number: VibratorJsTest017 565 */ 566 it("VibratorJsTest017", 0, async function (done) { 567 try { 568 vibrator.stop("").then(() => { 569 console.log("VibratorJsTest017 stop error"); 570 expect(false).assertTrue(); 571 setTimeout(() => { 572 done(); 573 }, 500); 574 }, (error) => { 575 expect(true).assertTrue(); 576 console.log("VibratorJsTest017 stop success"); 577 setTimeout(() => { 578 done(); 579 }, 500); 580 }); 581 } catch (error) { 582 console.info(error); 583 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 584 done(); 585 } 586 }) 587 588 /* 589 * @tc.name:VibratorJsTest018 590 * @tc.desc:verify app info is not null 591 * @tc.type: FUNC 592 * @tc.require: Issue Number 593 * @tc.number: VibratorJsTest018 594 */ 595 it("VibratorJsTest018", 0, async function (done) { 596 function stopPromise() { 597 return new Promise((resolve, reject) => { 598 vibrator.stop("time").then(() => { 599 console.log("VibratorJsTest018 stop success"); 600 expect(true).assertTrue(); 601 setTimeout(() => { 602 resolve(); 603 }, 500); 604 }, (error) => { 605 expect(false).assertTrue(); 606 console.log("VibratorJsTest018 stop error"); 607 setTimeout(() => { 608 reject(); 609 }, 500); 610 }); 611 }) 612 } 613 614 let promise = new Promise((resolve, reject) => { 615 vibrator.vibrate(180000).then(() => { 616 console.log("VibratorJsTest018 vibrate success"); 617 expect(true).assertTrue(); 618 setTimeout(() => { 619 resolve(); 620 }, 500); 621 }, (error) => { 622 expect(false).assertTrue(); 623 console.log("VibratorJsTest018 vibrate error"); 624 setTimeout(() => { 625 reject(); 626 }, 500); 627 }); 628 }) 629 630 await promise.then(() => { 631 return stopPromise(); 632 }, () => { 633 console.info("VibratorJsTest018 reject"); 634 }) 635 done(); 636 }) 637 638 /* 639 * @tc.name:VibratorJsTest019 640 * @tc.desc:verify app info is not null 641 * @tc.type: FUNC 642 * @tc.require: Issue Number 643 * @tc.number: VibratorJsTest019 644 */ 645 it("VibratorJsTest019", 0, async function (done) { 646 systemVibrator.vibrate({ 647 mode: 'short', 648 success: function() { 649 expect(true).assertTrue(); 650 console.log('vibrate is successful'); 651 done(); 652 }, 653 fail: function(data, code) { 654 expect(false).assertTrue(); 655 console.log('vibrate is failed, data: ' + data + "code: " + code); 656 done(); 657 }, 658 complete: function() { 659 console.log('vibrate is completed'); 660 done(); 661 } 662 }); 663 }) 664 665 /* 666 * @tc.name:VibratorJsTest020 667 * @tc.desc:verify app info is not null 668 * @tc.type: FUNC 669 * @tc.require: Issue Number 670 * @tc.number: VibratorJsTest020 671 */ 672 it("VibratorJsTest020", 0, async function (done) { 673 systemVibrator.vibrate({ 674 mode: 'long', 675 success: function() { 676 expect(true).assertTrue(); 677 console.log('vibrate is successful'); 678 done(); 679 }, 680 fail: function(data, code) { 681 expect(false).assertTrue(); 682 console.log('vibrate is failed, data: ' + data + "code: " + code); 683 done(); 684 }, 685 complete: function() { 686 console.log('vibrate is completed'); 687 done(); 688 } 689 }); 690 }) 691 692 /* 693 * @tc.name:VibratorJsTest021 694 * @tc.desc:verify app info is not null 695 * @tc.type: FUNC 696 * @tc.require: Issue Number 697 * @tc.number: VibratorJsTest021 698 */ 699 it("VibratorJsTest021", 0, async function (done) { 700 systemVibrator.vibrate({ 701 success: function() { 702 expect(true).assertTrue(); 703 console.log('vibrate is successful'); 704 done(); 705 }, 706 fail: function(data, code) { 707 expect(false).assertTrue(); 708 console.log('vibrate is failed, data: ' + data + "code: " + code); 709 done(); 710 }, 711 complete: function() { 712 console.log('vibrate is completed'); 713 done(); 714 } 715 }); 716 }) 717 718 /* 719 * @tc.name:VibratorJsTest022 720 * @tc.desc:verify app info is not null 721 * @tc.type: FUNC 722 * @tc.require: Issue Number 723 * @tc.number: VibratorJsTest022 724 */ 725 it("VibratorJsTest022", 0, async function (done) { 726 systemVibrator.vibrate({ 727 success: function() { 728 expect(true).assertTrue(); 729 console.log('vibrate is successful'); 730 done(); 731 }, 732 }); 733 }) 734 735 /* 736 * @tc.name:VibratorJsTest023 737 * @tc.desc:verify app info is not null 738 * @tc.type: FUNC 739 * @tc.require: Issue Number 740 * @tc.number: VibratorJsTest023 741 */ 742 it("VibratorJsTest023", 0, async function (done) { 743 vibrator.vibrate(1000, undefined).then(() => { 744 console.log("VibratorJsTest023 vibrate success"); 745 expect(true).assertTrue(); 746 setTimeout(() => { 747 done(); 748 }, 500); 749 }, (error) => { 750 expect(false).assertTrue(); 751 console.log("VibratorJsTest023 vibrate error"); 752 setTimeout(() => { 753 done(); 754 }, 500); 755 }); 756 }) 757 758 /* 759 * @tc.name:VibratorJsTest024 760 * @tc.desc:verify app info is not null 761 * @tc.type: FUNC 762 * @tc.require: Issue Number 763 * @tc.number: VibratorJsTest024 764 */ 765 it("VibratorJsTest024", 0, async function (done) { 766 vibrator.vibrate(1000, null).then(() => { 767 console.log("VibratorJsTest024 vibrate success"); 768 expect(true).assertTrue(); 769 setTimeout(() => { 770 done(); 771 }, 500); 772 }, (error) => { 773 expect(false).assertTrue(); 774 console.log("VibratorJsTest024 vibrate error"); 775 setTimeout(() => { 776 done(); 777 }, 500); 778 }); 779 }) 780 781 /* 782 * @tc.name:VibratorJsTest025 783 * @tc.desc:verify app info is not null 784 * @tc.type: FUNC 785 * @tc.require: Issue Number 786 * @tc.number: VibratorJsTest025 787 */ 788 it("VibratorJsTest025", 0, async function (done) { 789 vibrator.vibrate(1000, "abc").then(() => { 790 console.log("VibratorJsTest025 vibrate success"); 791 expect(true).assertTrue(); 792 setTimeout(() => { 793 done(); 794 }, 500); 795 }, (error) => { 796 expect(false).assertTrue(); 797 console.log("VibratorJsTest025 vibrate error"); 798 setTimeout(() => { 799 done(); 800 }, 500); 801 }); 802 }) 803 804 /* 805 * @tc.name:VibratorJsTest026 806 * @tc.desc:verify app info is not null 807 * @tc.type: FUNC 808 * @tc.require: Issue Number 809 * @tc.number: VibratorJsTest026 810 */ 811 it("VibratorJsTest026", 0, async function (done) { 812 if (g_execute) { 813 vibrator.vibrate("haptic.clock.timer", undefined).then(() => { 814 console.log("VibratorJsTest026 vibrate success"); 815 expect(true).assertTrue(); 816 setTimeout(() => { 817 done(); 818 }, 500); 819 }, (error) => { 820 expect(false).assertTrue(); 821 console.log("VibratorJsTest026 vibrate error"); 822 setTimeout(() => { 823 done(); 824 }, 500); 825 }); 826 } else { 827 console.info('VibratorJsTest026 vibrator success'); 828 expect(true).assertTrue(); 829 done(); 830 } 831 }) 832 833 /* 834 * @tc.name:VibratorJsTest027 835 * @tc.desc:verify app info is not null 836 * @tc.type: FUNC 837 * @tc.require: Issue Number 838 * @tc.number: VibratorJsTest027 839 */ 840 it("VibratorJsTest027", 0, async function (done) { 841 if (g_execute) { 842 vibrator.vibrate("haptic.clock.timer", null).then(() => { 843 console.log("VibratorJsTest027 vibrate success"); 844 expect(true).assertTrue(); 845 setTimeout(() => { 846 done(); 847 }, 500); 848 }, (error) => { 849 expect(false).assertTrue(); 850 console.log("VibratorJsTest027 vibrate error"); 851 setTimeout(() => { 852 done(); 853 }, 500); 854 }); 855 } else { 856 console.info('VibratorJsTest027 vibrator success'); 857 expect(true).assertTrue(); 858 done(); 859 } 860 }) 861 862 /* 863 * @tc.name:VibratorJsTest028 864 * @tc.desc:verify app info is not null 865 * @tc.type: FUNC 866 * @tc.require: Issue Number 867 * @tc.number: VibratorJsTest028 868 */ 869 it("VibratorJsTest028", 0, async function (done) { 870 if (g_execute) { 871 vibrator.vibrate("haptic.clock.timer", "abc").then(() => { 872 console.log("VibratorJsTest028 vibrate success"); 873 expect(true).assertTrue(); 874 setTimeout(() => { 875 done(); 876 }, 500); 877 }, (error) => { 878 expect(false).assertTrue(); 879 console.log("VibratorJsTest028 vibrate error"); 880 setTimeout(() => { 881 done(); 882 }, 500); 883 }); 884 } else { 885 console.info('VibratorJsTest028 vibrator success'); 886 expect(true).assertTrue(); 887 done(); 888 } 889 }) 890 891 /* 892 * @tc.name:VibratorJsTest029 893 * @tc.desc:verify app info is not null 894 * @tc.type: FUNC 895 * @tc.require: Issue Number 896 * @tc.number: VibratorJsTest029 897 */ 898 it("VibratorJsTest029", 0, async function (done) { 899 systemVibrator.vibrate(); 900 setTimeout(() => { 901 expect(true).assertTrue(); 902 done(); 903 }, 500); 904 }) 905 906 /* 907 * @tc.name:VibratorJsTest030 908 * @tc.desc:verify app info is not null 909 * @tc.type: FUNC 910 * @tc.require: Issue Number 911 * @tc.number: VibratorJsTest030 912 */ 913 it("VibratorJsTest030", 0, async function (done) { 914 systemVibrator.vibrate(undefined); 915 setTimeout(() => { 916 expect(true).assertTrue(); 917 done(); 918 }, 500); 919 }) 920 921 /* 922 * @tc.name:VibratorJsTest031 923 * @tc.desc:verify app info is not null 924 * @tc.type: FUNC 925 * @tc.require: Issue Number 926 * @tc.number: VibratorJsTest031 927 */ 928 it("VibratorJsTest031", 0, async function (done) { 929 systemVibrator.vibrate(null); 930 setTimeout(() => { 931 expect(true).assertTrue(); 932 done(); 933 }, 500); 934 }) 935 936 /* 937 * @tc.name:VibratorJsTest032 938 * @tc.desc:verify app info is not null 939 * @tc.type: FUNC 940 * @tc.require: Issue Number 941 * @tc.number: VibratorJsTest032 942 */ 943 it("VibratorJsTest032", 0, async function (done) { 944 systemVibrator.vibrate("abc"); 945 setTimeout(() => { 946 expect(true).assertTrue(); 947 done(); 948 }, 500); 949 }) 950 951 /* 952 * @tc.name:VibratorJsTest033 953 * @tc.desc:verify app info is not null 954 * @tc.type: FUNC 955 * @tc.require: Issue Number 956 * @tc.number: VibratorJsTest033 957 */ 958 it("VibratorJsTest033", 0, async function (done) { 959 systemVibrator.vibrate({ 960 mode: undefined, 961 success: function() { 962 expect(true).assertTrue(); 963 console.log('vibrate is successful'); 964 done(); 965 }, 966 fail: undefined, 967 complete: undefined 968 }); 969 }) 970 971 /* 972 * @tc.name:VibratorJsTest034 973 * @tc.desc:verify app info is not null 974 * @tc.type: FUNC 975 * @tc.require: Issue Number 976 * @tc.number: VibratorJsTest034 977 */ 978 it("VibratorJsTest034", 0, async function (done) { 979 systemVibrator.vibrate({ 980 mode: null, 981 success: function() { 982 expect(true).assertTrue(); 983 console.log('vibrate is successful'); 984 done(); 985 }, 986 fail: null, 987 complete: null 988 }); 989 }) 990 991 /* 992 * @tc.name:VibratorJsTest035 993 * @tc.desc:verify app info is not null 994 * @tc.type: FUNC 995 * @tc.require: Issue Number 996 * @tc.number: VibratorJsTest035 997 */ 998 it("VibratorJsTest035", 0, async function (done) { 999 systemVibrator.vibrate({ 1000 mode: 123, 1001 success: function() { 1002 expect(true).assertTrue(); 1003 console.log('vibrate is successful'); 1004 done(); 1005 }, 1006 fail: 123, 1007 complete: 123 1008 }); 1009 }) 1010 1011 /* 1012 * @tc.name:VibratorJsTest036 1013 * @tc.desc:verify app info is not null 1014 * @tc.type: FUNC 1015 * @tc.require: Issue Number 1016 * @tc.number: VibratorJsTest036 1017 */ 1018 it("VibratorJsTest036", 0, async function (done) { 1019 if (g_execute) { 1020 function stopPromise() { 1021 return new Promise((resolve, reject) => { 1022 vibrator.stop("preset", undefined).then(() => { 1023 console.log("VibratorJsTest036 off success"); 1024 expect(true).assertTrue(); 1025 setTimeout(() => { 1026 resolve(); 1027 }, 500); 1028 }, (error) => { 1029 expect(false).assertTrue(); 1030 console.log("VibratorJsTest036 off error"); 1031 setTimeout(() => { 1032 reject(); 1033 }, 500); 1034 }); 1035 }) 1036 } 1037 1038 let promise = new Promise((resolve, reject) => { 1039 vibrator.vibrate("haptic.clock.timer").then(() => { 1040 console.log("VibratorJsTest036 vibrate success"); 1041 expect(true).assertTrue(); 1042 resolve(); 1043 }, (error) => { 1044 expect(false).assertTrue(); 1045 console.log("VibratorJsTest036 vibrate error"); 1046 reject(); 1047 }); 1048 }) 1049 1050 await promise.then(() => { 1051 return stopPromise(); 1052 }, () => { 1053 console.info("VibratorJsTest036 reject"); 1054 }) 1055 done(); 1056 } else { 1057 console.info('VibratorJsTest036 vibrator success'); 1058 expect(true).assertTrue(); 1059 done(); 1060 } 1061 }) 1062 1063 /* 1064 * @tc.name:VibratorJsTest037 1065 * @tc.desc:verify app info is not null 1066 * @tc.type: FUNC 1067 * @tc.require: Issue Number 1068 * @tc.number: VibratorJsTest037 1069 */ 1070 it("VibratorJsTest037", 0, async function (done) { 1071 if (g_execute) { 1072 function stopPromise() { 1073 return new Promise((resolve, reject) => { 1074 vibrator.stop("preset", null).then(() => { 1075 console.log("VibratorJsTest037 off success"); 1076 expect(true).assertTrue(); 1077 setTimeout(() => { 1078 resolve(); 1079 }, 500); 1080 }, (error) => { 1081 expect(false).assertTrue(); 1082 console.log("VibratorJsTest037 off error"); 1083 setTimeout(() => { 1084 reject(); 1085 }, 500); 1086 }); 1087 }) 1088 } 1089 1090 let promise = new Promise((resolve, reject) => { 1091 vibrator.vibrate("haptic.clock.timer").then(() => { 1092 console.log("VibratorJsTest037 vibrate success"); 1093 expect(true).assertTrue(); 1094 resolve(); 1095 }, (error) => { 1096 expect(false).assertTrue(); 1097 console.log("VibratorJsTest037 vibrate error"); 1098 reject(); 1099 }); 1100 }) 1101 1102 await promise.then(() => { 1103 return stopPromise(); 1104 }, () => { 1105 console.info("VibratorJsTest037 reject"); 1106 }) 1107 done(); 1108 } else { 1109 console.info('VibratorJsTest037 vibrator success'); 1110 expect(true).assertTrue(); 1111 done(); 1112 } 1113 }) 1114 1115 /* 1116 * @tc.name:VibratorJsTest038 1117 * @tc.desc:verify app info is not null 1118 * @tc.type: FUNC 1119 * @tc.require: Issue Number 1120 * @tc.number: VibratorJsTest038 1121 */ 1122 it("VibratorJsTest038", 0, async function (done) { 1123 if (g_execute) { 1124 function stopPromise() { 1125 return new Promise((resolve, reject) => { 1126 vibrator.stop("preset", "abc").then(() => { 1127 console.log("VibratorJsTest038 off success"); 1128 expect(true).assertTrue(); 1129 setTimeout(() => { 1130 resolve(); 1131 }, 500); 1132 }, (error) => { 1133 expect(false).assertTrue(); 1134 console.log("VibratorJsTest038 off error"); 1135 setTimeout(() => { 1136 reject(); 1137 }, 500); 1138 }); 1139 }) 1140 } 1141 1142 let promise = new Promise((resolve, reject) => { 1143 vibrator.vibrate("haptic.clock.timer").then(() => { 1144 console.log("VibratorJsTest038 vibrate success"); 1145 expect(true).assertTrue(); 1146 resolve(); 1147 }, (error) => { 1148 expect(false).assertTrue(); 1149 console.log("VibratorJsTest038 vibrate error"); 1150 reject(); 1151 }); 1152 }) 1153 1154 await promise.then(() => { 1155 return stopPromise(); 1156 }, () => { 1157 console.info("VibratorJsTest038 reject"); 1158 }) 1159 done(); 1160 } else { 1161 console.info('VibratorJsTest038 vibrator success'); 1162 expect(true).assertTrue(); 1163 done(); 1164 } 1165 }) 1166 1167 /* 1168 * @tc.name:VibratorJsTest039 1169 * @tc.desc:verify app info is not null 1170 * @tc.type: FUNC 1171 * @tc.require: I53SGE 1172 * @tc.number: VibratorJsTest039 1173 */ 1174 it("VibratorJsTest039", 0, async function (done) { 1175 let ret = vibrator.isSupportEffectSync("haptic.effect.soft"); 1176 if (ret) { 1177 vibrator.startVibration({ 1178 type: "preset", 1179 effectId: "haptic.effect.soft", 1180 count: 1, 1181 intensity: 50, 1182 }, { 1183 usage: "unknown" 1184 }, (error) => { 1185 if (error) { 1186 console.info('VibratorJsTest039 vibrator error'); 1187 expect(false).assertTrue(); 1188 } else { 1189 console.info('VibratorJsTest039 vibrator success'); 1190 expect(true).assertTrue(); 1191 } 1192 setTimeout(() => { 1193 done(); 1194 }, 500); 1195 }); 1196 } else { 1197 console.info('This device is not supportEffect'); 1198 expect(true).assertTrue(); 1199 done(); 1200 } 1201 }) 1202 1203 /* 1204 * @tc.name:VibratorJsTest040 1205 * @tc.desc:verify app info is not null 1206 * @tc.type: FUNC 1207 * @tc.require: I53SGE 1208 * @tc.number: VibratorJsTest040 1209 */ 1210 it("VibratorJsTest040", 0, async function (done) { 1211 let ret = vibrator.isSupportEffectSync("haptic.effect.hard"); 1212 if (ret) { 1213 vibrator.startVibration({ 1214 type: "preset", 1215 effectId: "haptic.effect.hard", 1216 count: 1, 1217 intensity: 50, 1218 }, { 1219 usage: "unknown" 1220 }, (error) => { 1221 if (error) { 1222 console.info('VibratorJsTest040 vibrator error'); 1223 expect(false).assertTrue(); 1224 } else { 1225 console.info('VibratorJsTest040 vibrator success'); 1226 expect(true).assertTrue(); 1227 } 1228 setTimeout(() => { 1229 done(); 1230 }, 500); 1231 }); 1232 } else { 1233 console.info('This device is not supportEffect'); 1234 expect(true).assertTrue(); 1235 done(); 1236 } 1237 }) 1238 1239 /* 1240 * @tc.name:VibratorJsTest041 1241 * @tc.desc:verify app info is not null 1242 * @tc.type: FUNC 1243 * @tc.require: I53SGE 1244 * @tc.number: VibratorJsTest041 1245 */ 1246 it("VibratorJsTest041", 0, async function (done) { 1247 let ret = vibrator.isSupportEffectSync("haptic.effect.sharp"); 1248 if (ret) { 1249 vibrator.startVibration({ 1250 type: "preset", 1251 effectId: "haptic.effect.sharp", 1252 count: 1, 1253 intensity: 50, 1254 }, { 1255 usage: "unknown" 1256 }, (error) => { 1257 if (error) { 1258 console.info('VibratorJsTest041 vibrator error'); 1259 expect(false).assertTrue(); 1260 } else { 1261 console.info('VibratorJsTest041 vibrator success'); 1262 expect(true).assertTrue(); 1263 } 1264 setTimeout(() => { 1265 done(); 1266 }, 500); 1267 }); 1268 } else { 1269 console.info('This device is not supportEffect'); 1270 expect(true).assertTrue(); 1271 done(); 1272 } 1273 }) 1274 1275 /* 1276 * @tc.name: VibratorJsTest042 1277 * @tc.desc: Test for getting the vibrator list. 1278 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0420 1279 */ 1280 it("VibratorJsTest042", 0, async function (done) { 1281 try { 1282 const vibratorsList = vibrator.getVibratorInfoSync(); 1283 if (vibratorsList.length === 0) { 1284 console.warn('vibratorsList is null, ending test case.'); 1285 done(); 1286 } 1287 expect(Array.isArray(vibratorsList)).assertEqual(true); 1288 done(); 1289 } catch (error) { 1290 console.error('VibratorJsTest042 failed with error:', error); 1291 done(); 1292 } 1293 }) 1294 1295 /* 1296 * @tc.name: VibratorJsTest043 1297 * @tc.desc: Test to get a vibrator information. 1298 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0430 1299 */ 1300 it("VibratorJsTest043", 0, async function (done) { 1301 try { 1302 const vibratorInfoParam = { 1303 deviceId: -1, 1304 vibratorId: -1 1305 }; 1306 const vibratorsList = vibrator.getVibratorInfoSync(vibratorInfoParam); 1307 if (vibratorsList.length === 0) { 1308 console.warn('vibratorsList is null, ending test case.'); 1309 done(); 1310 } 1311 expect(Array.isArray(vibratorsList)).assertEqual(true); 1312 done(); 1313 } catch (error) { 1314 console.error('VibratorJsTest043 failed with error:', error); 1315 done(); 1316 } 1317 }) 1318 1319 /* 1320 * @tc.name: VibratorJsTest044 1321 * @tc.desc: Test the on function for VIBRATOR_DEVICE_STATE_CHANGE with valid and invalid parameters. 1322 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0440 1323 */ 1324 it("VibratorJsTest044", 0, function (done) { 1325 try { 1326 const vibratorsList = vibrator.getVibratorInfoSync(); 1327 if (vibratorsList.length === 0) { 1328 console.warn('vibratorsList is null, ending test case.'); 1329 done(); 1330 } 1331 const validCallback = function (statusEvent) { 1332 console.info(' timestamp:', statusEvent.timestamp); 1333 console.info(' deviceId:', statusEvent.deviceId); 1334 console.info(' vibratorCount:', statusEvent.vibratorCount); 1335 console.info(' isVibratorOnline:', statusEvent.isVibratorOnline); 1336 expect(statusEvent).toBeDefined(); 1337 expect(typeof statusEvent).toBe('object'); 1338 }; 1339 vibrator.on("vibratorStateChange", validCallback); 1340 setTimeout(() => { 1341 vibrator.off("vibratorStateChange", validCallback); 1342 }, 500); 1343 done(); 1344 } catch (error) { 1345 console.error('VibratorJsTest044 failed with error:', error); 1346 done(); 1347 } 1348 }) 1349 1350 /* 1351 * @tc.name: VibratorJsTest045 1352 * @tc.desc: Test stop the motor vibration in all modes. 1353 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0450 1354 */ 1355 it("VibratorJsTest045", 0, async function (done) { 1356 try { 1357 const vibratorsList = vibrator.getVibratorInfoSync(); 1358 if (vibratorsList.length === 0) { 1359 console.warn('vibratorsList is null, ending test case.'); 1360 done(); 1361 } 1362 await vibrator.startVibration({ 1363 type: "time", 1364 duration: 500 1365 }, { 1366 id: vibratorsList[0].vibratorId, 1367 deviceId: vibratorsList[0].deviceId, 1368 usage: "alarm" 1369 }, (error) => { 1370 if (error) { 1371 console.info("startVibration error: " + JSON.stringify(error)); 1372 expect(false).assertTrue(); 1373 } else { 1374 console.info("startVibration success"); 1375 } 1376 done(); 1377 }); 1378 await vibrator.stopVibration(); 1379 console.info("stopVibration success"); 1380 done(); 1381 } catch (error) { 1382 console.info("stopVibration error: " + JSON.stringify(error)); 1383 done(); 1384 } 1385 }) 1386 1387 /* 1388 * @tc.name: VibratorJsTest046 1389 * @tc.desc: Test single motor stop vibration. 1390 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0460 1391 */ 1392 it("VibratorJsTest046", 0, async function (done) { 1393 try { 1394 const vibratorsList = vibrator.getVibratorInfoSync(); 1395 if (vibratorsList.length === 0) { 1396 console.warn('vibratorsList is null, ending test case.'); 1397 done(); 1398 } 1399 await vibrator.startVibration({ 1400 type: "time", 1401 duration: 500 1402 }, { 1403 id: vibratorsList[0].vibratorId, 1404 deviceId: vibratorsList[0].deviceId, 1405 usage: "alarm" 1406 }, (error) => { 1407 if (error) { 1408 console.info("startVibration error: " + JSON.stringify(error)); 1409 expect(false).assertTrue(); 1410 } else { 1411 console.info("startVibration success"); 1412 } 1413 done(); 1414 }); 1415 const vibratorInfoParam = { 1416 deviceId: vibratorsList[0].deviceId, 1417 vibratorId: vibratorsList[0].vibratorId 1418 }; 1419 await vibrator.stopVibration(vibratorInfoParam); 1420 console.info("stopVibration success"); 1421 done(); 1422 } catch (error) { 1423 console.info("stopVibration error: " + JSON.stringify(error)); 1424 done(); 1425 } 1426 }) 1427 1428 /* 1429 * @tc.name: VibratorJsTest047 1430 * @tc.desc: Test the function of obtaining the effect information through the device ID and vibratorId. 1431 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0470 1432 */ 1433 it("VibratorJsTest047", 0, async function (done) { 1434 try { 1435 const effectId = "haptic.clock.timer"; 1436 const vibratorsList = vibrator.getVibratorInfoSync(); 1437 if (vibratorsList.length === 0) { 1438 console.warn('vibratorsList is null, ending test case.'); 1439 done(); 1440 } 1441 const vibratorInfoParam = { 1442 deviceId: vibratorsList[0].deviceId, 1443 vibratorId: vibratorsList[0].vibratorId 1444 }; 1445 const jsEffectInfo = vibrator.getEffectInfoSync(effectId, vibratorInfoParam); 1446 if (!jsEffectInfo.isEffectSupported) { 1447 console.info('VibratorJsTest047 is not supported on this device.'); 1448 done(); 1449 return; 1450 } 1451 expect(jsEffectInfo.isEffectSupported).assertTrue(); 1452 done(); 1453 } catch (error) { 1454 console.error('VibratorJsTest047 failed with error:', error); 1455 done(); 1456 } 1457 }) 1458 1459 /* 1460 * @tc.name: VibratorJsTest048 1461 * @tc.desc: Test the function of obtaining the effect information through the vibratorId. 1462 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0480 1463 */ 1464 it("VibratorJsTest048", 0, async function (done) { 1465 try { 1466 const vibratorsList = vibrator.getVibratorInfoSync(); 1467 if (vibratorsList.length === 0) { 1468 console.warn('vibratorsList is null, ending test case.'); 1469 done(); 1470 } 1471 const effectId = "haptic.clock.timer"; 1472 const jsEffectInfo = vibrator.getEffectInfoSync(effectId); 1473 if (!jsEffectInfo.isEffectSupported) { 1474 console.info('VibratorJsTest048 is not supported on this device.'); 1475 done(); 1476 return; 1477 } 1478 expect(jsEffectInfo.isEffectSupported).assertTrue(); 1479 done(); 1480 } catch (error) { 1481 console.error('VibratorJsTest048 failed with error:', error); 1482 done(); 1483 } 1484 }) 1485 1486 /* 1487 * @tc.name: VibratorJsTest049 1488 * @tc.desc: Test the function of obtaining the effect information through the device ID. 1489 * @tc.number: SUB_SensorSystem_Vibrator_JsTest_0490 1490 */ 1491 it("VibratorJsTest049", 0, async function (done) { 1492 try { 1493 const vibratorsList = vibrator.getVibratorInfoSync(); 1494 if (vibratorsList.length === 0) { 1495 console.warn('vibratorsList is null, ending test case.'); 1496 done(); 1497 } 1498 const effectId = "haptic.clock.timer"; 1499 const vibratorInfoParam = { 1500 deviceId: vibratorsList[0].deviceId, 1501 }; 1502 const jsEffectInfo = vibrator.getEffectInfoSync(effectId, vibratorInfoParam); 1503 if (!jsEffectInfo.isEffectSupported) { 1504 console.info('VibratorJsTest049 is not supported on this device.'); 1505 done(); 1506 return; 1507 } 1508 expect(jsEffectInfo.isEffectSupported).assertTrue(); 1509 done(); 1510 } catch (error) { 1511 console.error('VibratorJsTest049 failed with error:', error); 1512 done(); 1513 } 1514 }) 1515 1516 /* 1517 * @tc.name:VibrateTest001 1518 * @tc.desc:verify app info is not null 1519 * @tc.type: FUNC 1520 * @tc.require: I53SGE 1521 * @tc.number: VibrateTest001 1522 */ 1523 it("VibrateTest001", 0, async function (done) { 1524 vibrator.startVibration({ 1525 type: "time", 1526 duration: 1000 1527 }, { 1528 usage: "unknown" 1529 }, (error) => { 1530 if (error) { 1531 console.info('VibrateTest001 startVibration error'); 1532 expect(false).assertTrue(); 1533 } else { 1534 console.info('VibrateTest001 startVibration success'); 1535 expect(true).assertTrue(); 1536 } 1537 setTimeout(() => { 1538 done(); 1539 }, 500); 1540 }); 1541 }) 1542 1543 /* 1544 * @tc.name:VibrateTest002 1545 * @tc.desc:verify app info is not null 1546 * @tc.type: FUNC 1547 * @tc.require: I53SGE 1548 * @tc.number: VibrateTest002 1549 */ 1550 it("VibrateTest002", 0, async function (done) { 1551 try { 1552 vibrator.startVibration({ 1553 type: "", 1554 duration: 1000 1555 }, { 1556 usage: "unknown" 1557 }, (error) => { 1558 if (error) { 1559 expect(true).assertTrue(); 1560 } else { 1561 expect(false).assertTrue(); 1562 } 1563 setTimeout(() => { 1564 done(); 1565 }, 500); 1566 }); 1567 } catch (error) { 1568 console.info(error); 1569 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1570 done(); 1571 } 1572 }) 1573 1574 /* 1575 * @tc.name:VibrateTest003 1576 * @tc.desc:verify app info is not null 1577 * @tc.type: FUNC 1578 * @tc.require: I53SGE 1579 * @tc.number: VibrateTest003 1580 */ 1581 it("VibrateTest003", 0, async function (done) { 1582 if (g_execute) { 1583 vibrator.startVibration({ 1584 type: "preset", 1585 effectId: "haptic.clock.timer", 1586 count: 1, 1587 }, { 1588 usage: "unknown" 1589 }, (error) => { 1590 if (error) { 1591 console.info('VibrateTest003 vibrator error'); 1592 expect(false).assertTrue(); 1593 } else { 1594 console.info('VibrateTest003 vibrator success'); 1595 expect(true).assertTrue(); 1596 } 1597 setTimeout(() => { 1598 done(); 1599 }, 500); 1600 }); 1601 } else { 1602 console.info('VibrateTest003 vibrator success'); 1603 expect(true).assertTrue(); 1604 done(); 1605 } 1606 }) 1607 1608 /* 1609 * @tc.name:VibrateTest004 1610 * @tc.desc:verify app info is not null 1611 * @tc.type: FUNC 1612 * @tc.require: I53SGE 1613 * @tc.number: VibrateTest004 1614 */ 1615 it("VibrateTest004", 0, async function (done) { 1616 try { 1617 vibrator.startVibration({ 1618 type: "preset", 1619 effectId: "", 1620 count: 3, 1621 }, { 1622 usage: "unknown" 1623 }, (error) => { 1624 if (error) { 1625 expect(true).assertTrue(); 1626 } else { 1627 expect(false).assertTrue(); 1628 } 1629 setTimeout(() => { 1630 done(); 1631 }, 500); 1632 }); 1633 } catch (error) { 1634 console.info(error); 1635 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1636 done(); 1637 } 1638 }) 1639 1640 /* 1641 * @tc.name:VibrateTest005 1642 * @tc.desc:verify app info is not null 1643 * @tc.type: FUNC 1644 * @tc.require: I53SGE 1645 * @tc.number: VibrateTest005 1646 */ 1647 it("VibrateTest005", 0, async function (done) { 1648 if (g_execute) { 1649 try { 1650 vibrator.startVibration({ 1651 type: "preset", 1652 effectId: "haptic.clock.timer", 1653 count: 3, 1654 }, { 1655 usage: "" 1656 }, (error) => { 1657 expect(false).assertTrue(); 1658 setTimeout(() => { 1659 done(); 1660 }, 500); 1661 }); 1662 } catch (error) { 1663 console.info(error); 1664 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1665 done(); 1666 } 1667 } else { 1668 console.info('VibrateTest005 vibrator success'); 1669 expect(true).assertTrue(); 1670 done(); 1671 } 1672 }) 1673 1674 /* 1675 * @tc.name:VibrateTest006 1676 * @tc.desc:verify app info is not null 1677 * @tc.type: FUNC 1678 * @tc.require: I53SGE 1679 * @tc.number: VibrateTest006 1680 */ 1681 it("VibrateTest006", 0, async function (done) { 1682 try { 1683 vibrator.startVibration(null, null); 1684 } catch (error) { 1685 console.info(error); 1686 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1687 done(); 1688 } 1689 }) 1690 1691 /* 1692 * @tc.name:VibrateTest007 1693 * @tc.desc:verify app info is not null 1694 * @tc.type: FUNC 1695 * @tc.require: I53SGE 1696 * @tc.number: VibrateTest007 1697 */ 1698 it("VibrateTest007", 0, async function (done) { 1699 await vibrator.startVibration({ 1700 type: "time", 1701 duration: 1000, 1702 }, { 1703 usage: "unknown" 1704 }).then(() => { 1705 expect(true).assertTrue(); 1706 }).catch((error) => { 1707 expect(false).assertTrue(); 1708 }); 1709 done(); 1710 }) 1711 1712 /* 1713 * @tc.name:VibrateTest008 1714 * @tc.desc:verify app info is not null 1715 * @tc.type: FUNC 1716 * @tc.require: I53SGE 1717 * @tc.number: VibrateTest008 1718 */ 1719 it("VibrateTest008", 0, async function (done) { 1720 try { 1721 await vibrator.startVibration({ 1722 type: "", 1723 duration: 1000 1724 }, { 1725 usage: "unknown" 1726 }).then(() => { 1727 expect(false).assertTrue(); 1728 }).catch((error) => { 1729 expect(true).assertTrue(); 1730 }); 1731 done(); 1732 } catch (error) { 1733 console.info(error); 1734 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1735 done(); 1736 } 1737 }) 1738 1739 /* 1740 * @tc.name:VibrateTest009 1741 * @tc.desc:verify app info is not null 1742 * @tc.type: FUNC 1743 * @tc.require: I53SGE 1744 * @tc.number: VibrateTest009 1745 */ 1746 it("VibrateTest009", 0, async function (done) { 1747 if (g_execute) { 1748 await vibrator.startVibration({ 1749 type: "preset", 1750 effectId: "haptic.clock.timer", 1751 count: 1, 1752 }, { 1753 usage: "unknown" 1754 }).then(() => { 1755 expect(true).assertTrue(); 1756 }).catch((error) => { 1757 expect(false).assertTrue(); 1758 }); 1759 done(); 1760 } else { 1761 console.info('VibrateTest009 vibrator success'); 1762 expect(true).assertTrue(); 1763 done(); 1764 } 1765 }) 1766 1767 /* 1768 * @tc.name:VibrateTest010 1769 * @tc.desc:verify app info is not null 1770 * @tc.type: FUNC 1771 * @tc.require: I53SGE 1772 * @tc.number: VibrateTest010 1773 */ 1774 it("VibrateTest010", 0, async function (done) { 1775 try { 1776 vibrator.startVibration({ 1777 type: "preset", 1778 effectId: "", 1779 count: 3, 1780 }, { 1781 usage: "unknown" 1782 }).then(() => { 1783 expect(false).assertTrue(); 1784 done(); 1785 }).catch((error) => { 1786 expect(true).assertTrue(); 1787 done(); 1788 }); 1789 } catch (error) { 1790 console.info(error); 1791 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1792 done(); 1793 } 1794 }) 1795 1796 /* 1797 * @tc.name:VibrateTest011 1798 * @tc.desc:verify app info is not null 1799 * @tc.type: FUNC 1800 * @tc.require: I53SGE 1801 * @tc.number: VibrateTest011 1802 */ 1803 it("VibrateTest011", 0, async function (done) { 1804 if (g_execute) { 1805 try { 1806 vibrator.startVibration({ 1807 type: "preset", 1808 effectId: "haptic.clock.timer", 1809 count: 3, 1810 }, { 1811 usage: "" 1812 }).then(() => { 1813 expect(false).assertTrue(); 1814 done(); 1815 }).catch((error) => { 1816 expect(true).assertTrue(); 1817 done(); 1818 }); 1819 } catch (error) { 1820 console.info(error); 1821 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1822 done(); 1823 } 1824 } else { 1825 console.info('VibrateTest011 vibrator success'); 1826 expect(true).assertTrue(); 1827 done(); 1828 } 1829 }) 1830 1831 /* 1832 * @tc.name:VibrateTest012 1833 * @tc.desc:verify app info is not null 1834 * @tc.type: FUNC 1835 * @tc.require: I53SGE 1836 * @tc.number: VibrateTest012 1837 */ 1838 it("VibrateTest012", 0, async function (done) { 1839 try { 1840 vibrator.startVibration({ 1841 type: 1, 1842 count: 3, 1843 }, { 1844 usage: "" 1845 }) 1846 } catch (error) { 1847 console.info(error); 1848 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 1849 done(); 1850 } 1851 }) 1852 1853 /* 1854 * @tc.name:VibrateTest013 1855 * @tc.desc:verify app info is not null 1856 * @tc.type: FUNC 1857 * @tc.require: I53SGE 1858 * @tc.number: VibrateTest013 1859 */ 1860 it("VibrateTest013", 0, async function (done) { 1861 function vibratePromise() { 1862 return new Promise((resolve, reject) => { 1863 vibrator.startVibration({ 1864 type: "time", 1865 duration: 100 1866 }, { 1867 usage: "unknown" 1868 }, (error) => { 1869 if (error) { 1870 expect(false).assertTrue(); 1871 } else { 1872 expect(true).assertTrue(); 1873 } 1874 setTimeout(() => { 1875 done(); 1876 }, 500); 1877 }); 1878 }) 1879 } 1880 1881 let promise = new Promise((resolve, reject) => { 1882 vibrator.startVibration({ 1883 type: "time", 1884 duration: 100 1885 }, { 1886 usage: "unknown" 1887 }, (error) => { 1888 if (error) { 1889 expect(false).assertTrue(); 1890 reject(); 1891 } else { 1892 expect(true).assertTrue(); 1893 resolve(); 1894 } 1895 }); 1896 }) 1897 1898 await promise.then(() => { 1899 return vibratePromise(); 1900 }, () => { 1901 console.info("StartVibrationTest013 reject"); 1902 }) 1903 done(); 1904 }) 1905 1906 /* 1907 * @tc.name:VibrateTest014 1908 * @tc.desc:verify app info is not null 1909 * @tc.type: FUNC 1910 * @tc.require: I53SGE 1911 * @tc.number: VibrateTest014 1912 */ 1913 it("VibrateTest014", 0, async function (done) { 1914 if (g_execute) { 1915 function vibratePromise() { 1916 return new Promise((resolve, reject) => { 1917 vibrator.startVibration({ 1918 type: "preset", 1919 effectId: "haptic.clock.timer", 1920 count: 1, 1921 }, { 1922 usage: "unknown" 1923 }, (error) => { 1924 if (error) { 1925 expect(error.code).assertEqual(OPERATION_FAIL_CODE); 1926 expect(error.message).assertEqual(OPERATION_FAIL_MSG); 1927 } else { 1928 expect(false).assertTrue(); 1929 } 1930 setTimeout(() => { 1931 done(); 1932 }, 500); 1933 }); 1934 }) 1935 } 1936 1937 let promise = new Promise((resolve, reject) => { 1938 vibrator.startVibration({ 1939 type: "time", 1940 duration: 100 1941 }, { 1942 usage: "alarm" 1943 }, (error) => { 1944 if (error) { 1945 expect(false).assertTrue(); 1946 reject(); 1947 } else { 1948 expect(true).assertTrue(); 1949 resolve(); 1950 } 1951 }); 1952 }) 1953 1954 await promise.then(() => { 1955 return vibratePromise(); 1956 }, () => { 1957 console.info("VibrateTest014 reject"); 1958 }) 1959 done(); 1960 } else { 1961 console.info('VibrateTest014 vibrator success'); 1962 expect(true).assertTrue(); 1963 done(); 1964 } 1965 }) 1966 1967 /* 1968 * @tc.name:VibrateTest015 1969 * @tc.desc:verify app info is not null 1970 * @tc.type: FUNC 1971 * @tc.require: I6HKTI 1972 * @tc.number: VibrateTest015 1973 */ 1974 it("VibrateTest015", 0, async function (done) { 1975 if (g_execute) { 1976 function vibratePromise() { 1977 return new Promise((resolve, reject) => { 1978 vibrator.startVibration({ 1979 type: "preset", 1980 effectId: "haptic.clock.timer", 1981 count: 3, 1982 }, { 1983 usage: "unknown", 1984 }, (error) => { 1985 if (error) { 1986 expect(false).assertTrue(); 1987 } else { 1988 expect(true).assertTrue(); 1989 } 1990 setTimeout(() => { 1991 done(); 1992 }, 500); 1993 }); 1994 }) 1995 } 1996 1997 let promise = new Promise((resolve, reject) => { 1998 vibrator.startVibration({ 1999 type: "time", 2000 duration: 10000 2001 }, { 2002 usage: "alarm" 2003 }, (error) => { 2004 if (error) { 2005 expect(false).assertTrue(); 2006 reject(); 2007 } else { 2008 expect(true).assertTrue(); 2009 resolve(); 2010 } 2011 }); 2012 }) 2013 await promise.then(() => { 2014 return vibratePromise(); 2015 }, () => { 2016 console.info("VibrateTest015 reject"); 2017 }) 2018 done(); 2019 } else { 2020 console.info('VibrateTest015 vibrator success'); 2021 expect(true).assertTrue(); 2022 done(); 2023 } 2024 }) 2025 2026 /* 2027 * @tc.name:VibrateTest016 2028 * @tc.desc:verify app info is not null 2029 * @tc.type: FUNC 2030 * @tc.require: I6HKTI 2031 * @tc.number: VibrateTest016 2032 */ 2033 it("VibrateTest016", 0, async function (done) { 2034 if (g_execute) { 2035 function vibratePromise() { 2036 return new Promise((resolve, reject) => { 2037 vibrator.startVibration({ 2038 type: "preset", 2039 effectId: "haptic.clock.timer", 2040 count: 1, 2041 }, { 2042 usage: "unknown", 2043 }, (error) => { 2044 if (error) { 2045 expect(error.code).assertEqual(OPERATION_FAIL_CODE); 2046 expect(error.message).assertEqual(OPERATION_FAIL_MSG); 2047 } else { 2048 expect(false).assertTrue(); 2049 } 2050 setTimeout(() => { 2051 done(); 2052 }, 500); 2053 }); 2054 }) 2055 } 2056 2057 let promise = new Promise((resolve, reject) => { 2058 vibrator.startVibration({ 2059 type: "preset", 2060 effectId: "haptic.clock.timer", 2061 count: 3, 2062 }, { 2063 usage: "unknown", 2064 }, (error) => { 2065 if (error) { 2066 expect(false).assertTrue(); 2067 reject(); 2068 } else { 2069 expect(true).assertTrue(); 2070 resolve(); 2071 } 2072 }); 2073 }) 2074 2075 await promise.then(() => { 2076 return vibratePromise(); 2077 }, () => { 2078 console.info("VibrateTest016 reject"); 2079 }) 2080 done(); 2081 } else { 2082 console.info('VibrateTest016 vibrator success'); 2083 expect(true).assertTrue(); 2084 done(); 2085 } 2086 }) 2087 2088 /* 2089 * @tc.name:VibrateTest017 2090 * @tc.desc:verify app info is not null 2091 * @tc.type: FUNC 2092 * @tc.require: I6HKTI 2093 * @tc.number: VibrateTest017 2094 */ 2095 it("VibrateTest017", 0, async function (done) { 2096 if (g_execute) { 2097 function vibratePromise() { 2098 return new Promise((resolve, reject) => { 2099 vibrator.startVibration({ 2100 type: "time", 2101 duration: 3000, 2102 }, { 2103 usage: "alarm" 2104 }, (error) => { 2105 if (error) { 2106 expect(error.code).assertEqual(OPERATION_FAIL_CODE); 2107 expect(error.message).assertEqual(OPERATION_FAIL_MSG); 2108 } else { 2109 expect(false).assertTrue(); 2110 } 2111 setTimeout(() => { 2112 done(); 2113 }, 500); 2114 }); 2115 }) 2116 } 2117 2118 let promise = new Promise((resolve, reject) => { 2119 vibrator.startVibration({ 2120 type: "preset", 2121 effectId: "haptic.clock.timer", 2122 count: 3, 2123 }, { 2124 usage: "unknown" 2125 }, (error) => { 2126 if (error) { 2127 expect(false).assertTrue(); 2128 reject(); 2129 } else { 2130 expect(true).assertTrue(); 2131 resolve(); 2132 } 2133 }); 2134 }) 2135 2136 await promise.then(() => { 2137 return vibratePromise(); 2138 }, () => { 2139 console.info("VibrateTest017 reject"); 2140 }) 2141 done(); 2142 } else { 2143 console.info('VibrateTest017 vibrator success'); 2144 expect(true).assertTrue(); 2145 done(); 2146 } 2147 }) 2148 2149 /* 2150 * @tc.name:VibrateTest018 2151 * @tc.desc:verify app info is not null 2152 * @tc.type: FUNC 2153 * @tc.require: I6HKTI 2154 * @tc.number: VibrateTest018 2155 */ 2156 it("VibrateTest018", 0, async function (done) { 2157 if (g_execute) { 2158 function vibratePromise() { 2159 return new Promise((resolve, reject) => { 2160 vibrator.startVibration({ 2161 type: "time", 2162 duration: 3000, 2163 }, { 2164 usage: "alarm" 2165 }, (error) => { 2166 if (error) { 2167 expect(false).assertTrue(); 2168 } else { 2169 expect(true).assertTrue(); 2170 } 2171 setTimeout(() => { 2172 done(); 2173 }, 500); 2174 }); 2175 }) 2176 } 2177 2178 let promise = new Promise((resolve, reject) => { 2179 vibrator.startVibration({ 2180 type: "preset", 2181 effectId: "haptic.clock.timer", 2182 count: 1, 2183 }, { 2184 usage: "unknown" 2185 }, (error) => { 2186 if (error) { 2187 expect(false).assertTrue(); 2188 reject(); 2189 } else { 2190 expect(true).assertTrue(); 2191 resolve(); 2192 } 2193 }); 2194 }) 2195 2196 await promise.then(() => { 2197 return vibratePromise(); 2198 }, () => { 2199 console.info("VibrateTest018 reject"); 2200 }) 2201 done(); 2202 } else { 2203 console.info('VibrateTest018 vibrator success'); 2204 expect(true).assertTrue(); 2205 done(); 2206 } 2207 }) 2208 2209 /* 2210 * @tc.name:VibrateTest019 2211 * @tc.desc:verify app info is not null 2212 * @tc.type: FUNC 2213 * @tc.require: I53SGE 2214 * @tc.number: VibrateTest019 2215 */ 2216 it("VibrateTest019", 0, async function (done) { 2217 if (g_execute) { 2218 function vibratePromise() { 2219 return new Promise((resolve, reject) => { 2220 vibrator.startVibration({ 2221 type: "preset", 2222 effectId: "haptic.clock.timer", 2223 count: 3, 2224 }, { 2225 usage: "unknown" 2226 }, (error) => { 2227 if (error) { 2228 expect(false).assertTrue(); 2229 } else { 2230 expect(true).assertTrue(); 2231 } 2232 setTimeout(() => { 2233 done(); 2234 }, 500); 2235 }); 2236 }) 2237 } 2238 2239 let promise = new Promise((resolve, reject) => { 2240 vibrator.startVibration({ 2241 type: "preset", 2242 effectId: "haptic.clock.timer", 2243 count: 3, 2244 }, { 2245 usage: "unknown" 2246 }, (error) => { 2247 if (error) { 2248 expect(false).assertTrue(); 2249 reject(); 2250 } else { 2251 expect(true).assertTrue(); 2252 resolve(); 2253 } 2254 }); 2255 }) 2256 2257 await promise.then(() => { 2258 return vibratePromise(); 2259 }, () => { 2260 console.info("VibrateTest019 reject"); 2261 }) 2262 done(); 2263 } else { 2264 console.info('VibrateTest019 vibrator success'); 2265 expect(true).assertTrue(); 2266 done(); 2267 } 2268 }) 2269 2270 /* 2271 * @tc.name:VibrateTest020 2272 * @tc.desc:verify app info is not null 2273 * @tc.type: FUNC 2274 * @tc.require: I53SGE 2275 * @tc.number: VibrateTest020 2276 */ 2277 it("VibrateTest020", 0, async function (done) { 2278 if (g_execute) { 2279 function vibratePromise() { 2280 return new Promise((resolve, reject) => { 2281 vibrator.startVibration({ 2282 type: "preset", 2283 effectId: "haptic.clock.timer", 2284 count: 1, 2285 }, { 2286 usage: "ring" 2287 }, (error) => { 2288 if (error) { 2289 expect(false).assertTrue(); 2290 } else { 2291 expect(true).assertTrue(); 2292 } 2293 setTimeout(() => { 2294 done(); 2295 }, 500); 2296 }); 2297 }) 2298 } 2299 2300 let promise = new Promise((resolve, reject) => { 2301 vibrator.startVibration({ 2302 type: "preset", 2303 effectId: "haptic.clock.timer", 2304 count: 1, 2305 }, { 2306 usage: "notification" 2307 }, (error) => { 2308 if (error) { 2309 expect(false).assertTrue(); 2310 reject(); 2311 } else { 2312 expect(true).assertTrue(); 2313 resolve(); 2314 } 2315 }); 2316 }) 2317 2318 await promise.then(() => { 2319 return vibratePromise(); 2320 }, () => { 2321 console.info("VibrateTest020 reject"); 2322 }) 2323 done(); 2324 } else { 2325 console.info('VibrateTest020 vibrator success'); 2326 expect(true).assertTrue(); 2327 done(); 2328 } 2329 }) 2330 2331 /* 2332 * @tc.name:VibrateTest021 2333 * @tc.desc:verify app info is not null 2334 * @tc.type: FUNC 2335 * @tc.require: I53SGE 2336 * @tc.number: VibrateTest021 2337 */ 2338 it("VibrateTest021", 0, async function (done) { 2339 if (g_execute) { 2340 function vibratePromise() { 2341 return new Promise((resolve, reject) => { 2342 vibrator.startVibration({ 2343 type: "preset", 2344 effectId: "haptic.clock.timer", 2345 count: 1, 2346 }, { 2347 usage: "unknown" 2348 }, (error) => { 2349 if (error) { 2350 expect(error.code).assertEqual(OPERATION_FAIL_CODE); 2351 expect(error.message).assertEqual(OPERATION_FAIL_MSG); 2352 } else { 2353 expect(false).assertTrue(); 2354 } 2355 setTimeout(() => { 2356 done(); 2357 }, 500); 2358 }); 2359 }) 2360 } 2361 2362 let promise = new Promise((resolve, reject) => { 2363 vibrator.startVibration({ 2364 type: "preset", 2365 effectId: "haptic.clock.timer", 2366 count: 3, 2367 }, { 2368 usage: "notification" 2369 }, (error) => { 2370 if (error) { 2371 expect(false).assertTrue(); 2372 reject(); 2373 } else { 2374 expect(true).assertTrue(); 2375 resolve(); 2376 } 2377 }); 2378 }) 2379 2380 await promise.then(() => { 2381 return vibratePromise(); 2382 }, () => { 2383 console.info("VibrateTest021 reject"); 2384 }) 2385 done(); 2386 } else { 2387 console.info('VibrateTest021 vibrator success'); 2388 expect(true).assertTrue(); 2389 done(); 2390 } 2391 }) 2392 2393 /* 2394 * @tc.name:VibratorJsTest022 2395 * @tc.desc:verify app info is not null 2396 * @tc.type: FUNC 2397 * @tc.require: I5SWJI 2398 * @tc.number: VibrateTest022 2399 */ 2400 it("VibrateTest022", 0, async function (done) { 2401 function vibrateCallback(error) { 2402 if (error) { 2403 console.info('VibrateTest022 stop fail'); 2404 expect(false).assertTrue(); 2405 } else { 2406 console.info('VibrateTest022 stop off'); 2407 expect(false).assertTrue(); 2408 } 2409 setTimeout(() => { 2410 done(); 2411 }, 500); 2412 } 2413 try { 2414 vibrator.stopVibration("", vibrateCallback); 2415 } catch (error) { 2416 console.info(error); 2417 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2418 done(); 2419 } 2420 }) 2421 2422 /* 2423 * @tc.name:VibrateTest023 2424 * @tc.desc:verify app info is not null 2425 * @tc.type: FUNC 2426 * @tc.require: I5SWJI 2427 * @tc.number: VibrateTest023 2428 */ 2429 it("VibrateTest023", 0, async function (done) { 2430 if (g_execute) { 2431 function stopPromise() { 2432 return new Promise((resolve, reject) => { 2433 vibrator.stopVibration("preset").then(() => { 2434 console.log("VibrateTest023 off success"); 2435 expect(true).assertTrue(); 2436 setTimeout(() => { 2437 resolve(); 2438 }, 500); 2439 }, (error) => { 2440 expect(false).assertTrue(); 2441 console.log("VibrateTest023 off error"); 2442 setTimeout(() => { 2443 reject(); 2444 }, 500); 2445 }); 2446 }) 2447 } 2448 2449 let promise = new Promise((resolve, reject) => { 2450 vibrator.startVibration("haptic.clock.timer").then(() => { 2451 console.log("VibrateTest023 vibrate success"); 2452 expect(true).assertTrue(); 2453 resolve(); 2454 }, (error) => { 2455 expect(false).assertTrue(); 2456 console.log("VibrateTest023 vibrate error"); 2457 reject(); 2458 }); 2459 }) 2460 2461 await promise.then(() => { 2462 return stopPromise(); 2463 }, () => { 2464 console.info("VibrateTest023 reject"); 2465 }) 2466 done(); 2467 } else { 2468 console.info('VibrateTest023 vibrator success'); 2469 expect(true).assertTrue(); 2470 done(); 2471 } 2472 }) 2473 2474 /* 2475 * @tc.name:VibrateTest024 2476 * @tc.desc:verify app info is not null 2477 * @tc.type: FUNC 2478 * @tc.require: I5SWJI 2479 * @tc.number: VibrateTest024 2480 */ 2481 it("VibrateTest024", 0, async function (done) { 2482 try { 2483 vibrator.stopVibration("").then(() => { 2484 console.log("VibrateTest024 stop error"); 2485 expect(false).assertTrue(); 2486 setTimeout(() => { 2487 done(); 2488 }, 500); 2489 }, (error) => { 2490 expect(false).assertTrue(); 2491 console.log("VibrateTest024 stop error"); 2492 setTimeout(() => { 2493 done(); 2494 }, 500); 2495 }); 2496 } catch (error) { 2497 console.info(error); 2498 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2499 done(); 2500 } 2501 }) 2502 2503 /* 2504 * @tc.name:VibrateTest025 2505 * @tc.desc:verify app info is not null 2506 * @tc.type: FUNC 2507 * @tc.require: I5SWJI 2508 * @tc.number: VibrateTest025 2509 */ 2510 it("VibrateTest025", 0, async function (done) { 2511 function stopPromise() { 2512 return new Promise((resolve, reject) => { 2513 vibrator.stopVibration("time").then(() => { 2514 console.log("VibrateTest025 stop success"); 2515 expect(true).assertTrue(); 2516 setTimeout(() => { 2517 resolve(); 2518 }, 500); 2519 }, (error) => { 2520 expect(false).assertTrue(); 2521 console.log("VibrateTest025 stop error"); 2522 setTimeout(() => { 2523 reject(); 2524 }, 500); 2525 }); 2526 }) 2527 } 2528 2529 let promise = new Promise((resolve, reject) => { 2530 vibrator.vibrate(180000).then(() => { 2531 console.log("VibrateTest025 vibrate success"); 2532 expect(true).assertTrue(); 2533 setTimeout(() => { 2534 resolve(); 2535 }, 500); 2536 }, (error) => { 2537 expect(false).assertTrue(); 2538 console.log("VibrateTest025 vibrate error"); 2539 setTimeout(() => { 2540 reject(); 2541 }, 500); 2542 }); 2543 }) 2544 2545 await promise.then(() => { 2546 return stopPromise(); 2547 }, () => { 2548 console.info("VibrateTest025 reject"); 2549 }) 2550 done(); 2551 }) 2552 2553 /* 2554 * @tc.name:VibrateTest026 2555 * @tc.desc:verify the isSupportEffect and stopVibration interface 2556 * @tc.type: FUNC 2557 * @tc.require: I6HLLL 2558 * @tc.number: VibrateTest026 2559 */ 2560 it("VibrateTest026", 0, async function (done) { 2561 vibrator.isSupportEffect(INVALID_EFFECT_ID, (error, state) => { 2562 if (error) { 2563 console.info('VibrateTest026 error'); 2564 expect(false).assertTrue(); 2565 } else { 2566 console.info('VibrateTest026 success'); 2567 expect(!state).assertTrue(); 2568 } 2569 done(); 2570 }); 2571 }) 2572 2573 /* 2574 * @tc.name:VibrateTest027 2575 * @tc.desc:verify the isSupportEffect and stopVibration interface 2576 * @tc.type: FUNC 2577 * @tc.require: I6HLLL 2578 * @tc.number: VibrateTest027 2579 */ 2580 it("VibrateTest027", 0, async function (done) { 2581 let isSupport = false; 2582 2583 function vibratePromise() { 2584 return new Promise((resolve, reject) => { 2585 if (isSupport) { 2586 vibrator.startVibration({ 2587 type: "preset", 2588 effectId: EFFECT_ID, 2589 count: 1, 2590 }, { 2591 usage: "unknown" 2592 }, (error) => { 2593 if (error) { 2594 expect(false).assertTrue(); 2595 reject(error); 2596 } else { 2597 expect(true).assertTrue(); 2598 resolve(); 2599 } 2600 }); 2601 } else { 2602 resolve(); 2603 } 2604 }) 2605 } 2606 2607 function stopPromise() { 2608 return new Promise((resolve, reject) => { 2609 if (isSupport) { 2610 vibrator.stopVibration((error) => { 2611 if (error) { 2612 expect(false).assertTrue(); 2613 reject(error); 2614 } else { 2615 expect(true).assertTrue(); 2616 resolve(); 2617 } 2618 }); 2619 } else { 2620 resolve(); 2621 } 2622 }) 2623 } 2624 2625 let isSupportPromise = new Promise((resolve, reject) => { 2626 vibrator.isSupportEffect(EFFECT_ID, (error, state) => { 2627 if (error) { 2628 expect(false).assertTrue(); 2629 reject(error); 2630 } else { 2631 expect(true).assertTrue(); 2632 isSupport = state; 2633 resolve(); 2634 } 2635 }); 2636 }) 2637 2638 await isSupportPromise.then(() => { 2639 return vibratePromise(); 2640 }).then(() => { 2641 return stopPromise(); 2642 }).catch((error) => { 2643 expect(false).assertTrue(); 2644 }) 2645 done(); 2646 }) 2647 2648 /* 2649 * @tc.name:VibrateTest028 2650 * @tc.desc:verify the isSupportEffect and stopVibration interface 2651 * @tc.type: FUNC 2652 * @tc.require: I6HLLL 2653 * @tc.number: VibrateTest028 2654 */ 2655 it("VibrateTest028", 0, async function (done) { 2656 try { 2657 vibrator.isSupportEffect(123, (error, state) => { 2658 console.info("VibrateTest028 should not in this method"); 2659 expect(false).assertTrue(); 2660 done(); 2661 }); 2662 } catch (error) { 2663 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2664 done(); 2665 } 2666 }) 2667 2668 /* 2669 * @tc.name:VibrateTest029 2670 * @tc.desc:verify the isSupportEffect and stopVibration interface 2671 * @tc.type: FUNC 2672 * @tc.require: I6HLLL 2673 * @tc.number: VibrateTest029 2674 */ 2675 it("VibrateTest029", 0, async function (done) { 2676 try { 2677 vibrator.isSupportEffect(); 2678 } catch (error) { 2679 console.info("VibrateTest029 exception in"); 2680 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2681 done(); 2682 } 2683 }) 2684 2685 /* 2686 * @tc.name:VibrateTest030 2687 * @tc.desc:verify the isSupportEffect and stopVibration interface 2688 * @tc.type: FUNC 2689 * @tc.require: I6HLLL 2690 * @tc.number: VibrateTest030 2691 */ 2692 it("VibrateTest030", 0, async function (done) { 2693 await vibrator.isSupportEffect(INVALID_EFFECT_ID).then((state) => { 2694 expect(!state).assertTrue(); 2695 }, (error) => { 2696 expect(false).assertTrue(); 2697 }); 2698 done(); 2699 }) 2700 2701 /* 2702 * @tc.name:VibrateTest031 2703 * @tc.desc:verify the isSupportEffect and stopVibration interface 2704 * @tc.type: FUNC 2705 * @tc.require: I6HLLL 2706 * @tc.number: VibrateTest031 2707 */ 2708 it("VibrateTest031", 0, async function (done) { 2709 let isSupport = false; 2710 2711 function vibratePromise() { 2712 return new Promise((resolve, reject) => { 2713 if (isSupport) { 2714 vibrator.startVibration({ 2715 type: "preset", 2716 effectId: EFFECT_ID, 2717 count: 1, 2718 }, { 2719 usage: "unknown" 2720 }, (error) => { 2721 if (error) { 2722 expect(false).assertTrue(); 2723 reject(error); 2724 } else { 2725 expect(true).assertTrue(); 2726 resolve(); 2727 } 2728 }); 2729 } else { 2730 resolve(); 2731 } 2732 }) 2733 } 2734 2735 function stopPromise() { 2736 return new Promise((resolve, reject) => { 2737 if (isSupport) { 2738 vibrator.stopVibration((error) => { 2739 if (error) { 2740 expect(false).assertTrue(); 2741 reject(error); 2742 } else { 2743 expect(true).assertTrue(); 2744 resolve(); 2745 } 2746 }); 2747 } else { 2748 resolve(); 2749 } 2750 }) 2751 } 2752 2753 let isSupportPromise = new Promise((resolve, reject) => { 2754 vibrator.isSupportEffect(EFFECT_ID).then((state) => { 2755 expect(true).assertTrue(); 2756 isSupport = state; 2757 resolve(); 2758 }, (error) => { 2759 expect(false).assertTrue(); 2760 reject(error); 2761 }); 2762 }) 2763 2764 await isSupportPromise.then(() => { 2765 return vibratePromise(); 2766 }).then(() => { 2767 return stopPromise(); 2768 }).catch((error) => { 2769 expect(false).assertTrue(); 2770 }) 2771 done(); 2772 }) 2773 2774 /* 2775 * @tc.name:VibrateTest032 2776 * @tc.desc:verify the isSupportEffect and stopVibration interface 2777 * @tc.type: FUNC 2778 * @tc.require: I6HLLL 2779 * @tc.number: VibrateTest032 2780 */ 2781 it("VibrateTest032", 0, async function (done) { 2782 try { 2783 vibrator.isSupportEffect(123).then((state) => { 2784 expect(false).assertTrue(); 2785 done(); 2786 }, (error) => { 2787 expect(false).assertTrue(); 2788 done(); 2789 }); 2790 } catch (error) { 2791 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2792 done(); 2793 } 2794 }) 2795 2796 /* 2797 * @tc.name:VibrateTest033 2798 * @tc.desc:verify the isSupportEffect and stopVibration interface 2799 * @tc.type: FUNC 2800 * @tc.require: I6HLLL 2801 * @tc.number: VibrateTest033 2802 */ 2803 it("VibrateTest033", 0, async function (done) { 2804 try { 2805 vibrator.isSupportEffect().then((state) => { 2806 expect(false).assertTrue(); 2807 done(); 2808 }, (error) => { 2809 expect(false).assertTrue(); 2810 done(); 2811 }); 2812 } catch (error) { 2813 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 2814 done(); 2815 } 2816 }) 2817 2818 /* 2819 * @tc.name:VibrateTest034 2820 * @tc.desc:verify the isSupportEffect and stopVibration interface 2821 * @tc.type: FUNC 2822 * @tc.require: I6HLLL 2823 * @tc.number: VibrateTest034 2824 */ 2825 it("VibrateTest034", 0, async function (done) { 2826 function stopPromise() { 2827 return new Promise((resolve, reject) => { 2828 vibrator.stopVibration((error) => { 2829 if (error) { 2830 expect(false).assertTrue(); 2831 reject(error); 2832 } else { 2833 expect(true).assertTrue(); 2834 resolve(); 2835 } 2836 }); 2837 }) 2838 } 2839 2840 let promise = new Promise((resolve, reject) => { 2841 vibrator.vibrate(2000, (error) => { 2842 if (error) { 2843 expect(false).assertTrue(); 2844 reject(error); 2845 } else { 2846 expect(true).assertTrue(); 2847 resolve(); 2848 } 2849 }); 2850 }) 2851 2852 await promise.then(() => { 2853 return stopPromise(); 2854 }).catch((error) => { 2855 expect(false).assertTrue(); 2856 }) 2857 done(); 2858 }) 2859 2860 /* 2861 * @tc.name:VibrateTest035 2862 * @tc.desc:verify the isSupportEffect and stopVibration interface 2863 * @tc.type: FUNC 2864 * @tc.require: I6HLLL 2865 * @tc.number: VibrateTest035 2866 */ 2867 it("VibrateTest035", 0, async function (done) { 2868 function stopPromise() { 2869 return new Promise((resolve, reject) => { 2870 vibrator.stopVibration().then(() => { 2871 expect(true).assertTrue(); 2872 resolve(); 2873 }, (error) => { 2874 expect(false).assertTrue(); 2875 reject(error); 2876 }); 2877 }) 2878 } 2879 2880 let promise = new Promise((resolve, reject) => { 2881 vibrator.vibrate(2000, (error) => { 2882 if (error) { 2883 expect(false).assertTrue(); 2884 reject(error); 2885 } else { 2886 expect(true).assertTrue(); 2887 resolve(); 2888 } 2889 }); 2890 }) 2891 2892 await promise.then(() => { 2893 return stopPromise(); 2894 }).catch((error) => { 2895 expect(false).assertTrue(); 2896 }) 2897 done(); 2898 }) 2899 2900 /* 2901 * @tc.name:VibrateTest036 2902 * @tc.desc:verify app info is not null 2903 * @tc.type: FUNC 2904 * @tc.require: I5SWJI 2905 * @tc.number: VibrateTest036 2906 */ 2907 it("VibrateTest036", 0, async function (done) { 2908 if (g_execute) { 2909 function stopPromise() { 2910 return new Promise((resolve, reject) => { 2911 vibrator.stopVibration("preset", undefined).then(() => { 2912 console.log("VibrateTest036 off success"); 2913 expect(true).assertTrue(); 2914 setTimeout(() => { 2915 resolve(); 2916 }, 500); 2917 }, (error) => { 2918 expect(false).assertTrue(); 2919 console.log("VibrateTest036 off error"); 2920 setTimeout(() => { 2921 reject(); 2922 }, 500); 2923 }); 2924 }) 2925 } 2926 2927 let promise = new Promise((resolve, reject) => { 2928 vibrator.startVibration("haptic.clock.timer").then(() => { 2929 console.log("VibrateTest036 vibrate success"); 2930 expect(true).assertTrue(); 2931 resolve(); 2932 }, (error) => { 2933 expect(false).assertTrue(); 2934 console.log("VibrateTest036 vibrate error"); 2935 reject(); 2936 }); 2937 }) 2938 2939 await promise.then(() => { 2940 return stopPromise(); 2941 }, () => { 2942 console.info("VibrateTest036 reject"); 2943 }) 2944 done(); 2945 } else { 2946 console.info('VibrateTest036 vibrator success'); 2947 expect(true).assertTrue(); 2948 done(); 2949 } 2950 }) 2951 2952 /* 2953 * @tc.name:VibrateTest037 2954 * @tc.desc:verify app info is not null 2955 * @tc.type: FUNC 2956 * @tc.require: I5SWJI 2957 * @tc.number: VibrateTest037 2958 */ 2959 it("VibrateTest037", 0, async function (done) { 2960 if (g_execute) { 2961 function stopPromise() { 2962 return new Promise((resolve, reject) => { 2963 vibrator.stopVibration("preset", null).then(() => { 2964 console.log("VibrateTest037 off success"); 2965 expect(true).assertTrue(); 2966 setTimeout(() => { 2967 resolve(); 2968 }, 500); 2969 }, (error) => { 2970 expect(false).assertTrue(); 2971 console.log("VibrateTest037 off error"); 2972 setTimeout(() => { 2973 reject(); 2974 }, 500); 2975 }); 2976 }) 2977 } 2978 2979 let promise = new Promise((resolve, reject) => { 2980 vibrator.startVibration("haptic.clock.timer").then(() => { 2981 console.log("VibrateTest037 vibrate success"); 2982 expect(true).assertTrue(); 2983 resolve(); 2984 }, (error) => { 2985 expect(false).assertTrue(); 2986 console.log("VibrateTest037 vibrate error"); 2987 reject(); 2988 }); 2989 }) 2990 2991 await promise.then(() => { 2992 return stopPromise(); 2993 }, () => { 2994 console.info("VibrateTest037 reject"); 2995 }) 2996 done(); 2997 } else { 2998 console.info('VibrateTest037 vibrator success'); 2999 expect(true).assertTrue(); 3000 done(); 3001 } 3002 }) 3003 3004 /* 3005 * @tc.name:VibrateTest038 3006 * @tc.desc:verify app info is not null 3007 * @tc.type: FUNC 3008 * @tc.require: I5SWJI 3009 * @tc.number: VibrateTest038 3010 */ 3011 it("VibrateTest038", 0, async function (done) { 3012 if (g_execute) { 3013 function stopPromise() { 3014 return new Promise((resolve, reject) => { 3015 vibrator.stopVibration("preset", "abc").then(() => { 3016 console.log("VibrateTest038 off success"); 3017 expect(true).assertTrue(); 3018 setTimeout(() => { 3019 resolve(); 3020 }, 500); 3021 }, (error) => { 3022 expect(false).assertTrue(); 3023 console.log("VibrateTest038 off error"); 3024 setTimeout(() => { 3025 reject(); 3026 }, 500); 3027 }); 3028 }) 3029 } 3030 3031 let promise = new Promise((resolve, reject) => { 3032 vibrator.startVibration("haptic.clock.timer").then(() => { 3033 console.log("VibrateTest038 vibrate success"); 3034 expect(true).assertTrue(); 3035 resolve(); 3036 }, (error) => { 3037 expect(false).assertTrue(); 3038 console.log("VibrateTest038 vibrate error"); 3039 reject(); 3040 }); 3041 }) 3042 3043 await promise.then(() => { 3044 return stopPromise(); 3045 }, () => { 3046 console.info("VibrateTest038 reject"); 3047 }) 3048 done(); 3049 } else { 3050 console.info('VibrateTest038 vibrator success'); 3051 expect(true).assertTrue(); 3052 done(); 3053 } 3054 }) 3055 3056 /* 3057 * @tc.name:VibrateTest039 3058 * @tc.desc:verify app info is not null 3059 * @tc.type: FUNC 3060 * @tc.require: I53SGE 3061 * @tc.number: VibrateTest039 3062 */ 3063 it("VibrateTest039", 0, async function (done) { 3064 await vibrator.startVibration({ 3065 type: "time", 3066 duration: 1000, 3067 }, { 3068 usage: "unknown" 3069 }, undefined).then(() => { 3070 expect(true).assertTrue(); 3071 }).catch((error) => { 3072 expect(false).assertTrue(); 3073 }); 3074 done(); 3075 }) 3076 3077 /* 3078 * @tc.name:VibrateTest040 3079 * @tc.desc:verify app info is not null 3080 * @tc.type: FUNC 3081 * @tc.require: I53SGE 3082 * @tc.number: VibrateTest040 3083 */ 3084 it("VibrateTest040", 0, async function (done) { 3085 await vibrator.startVibration({ 3086 type: "time", 3087 duration: 1000, 3088 }, { 3089 usage: "unknown" 3090 }, null).then(() => { 3091 expect(true).assertTrue(); 3092 }).catch((error) => { 3093 expect(false).assertTrue(); 3094 }); 3095 done(); 3096 }) 3097 3098 /* 3099 * @tc.name:VibrateTest041 3100 * @tc.desc:verify app info is not null 3101 * @tc.type: FUNC 3102 * @tc.require: I53SGE 3103 * @tc.number: VibrateTest041 3104 */ 3105 it("VibrateTest041", 0, async function (done) { 3106 await vibrator.startVibration({ 3107 type: "time", 3108 duration: 1000, 3109 }, { 3110 usage: "unknown" 3111 }, "abc").then(() => { 3112 expect(true).assertTrue(); 3113 }).catch((error) => { 3114 expect(false).assertTrue(); 3115 }); 3116 done(); 3117 }) 3118 3119 /* 3120 * @tc.name:VibrateTest042 3121 * @tc.desc:verify app info is not null 3122 * @tc.type: FUNC 3123 * @tc.require: I5SWJI 3124 * @tc.number: VibrateTest042 3125 */ 3126 it("VibrateTest042", 0, async function (done) { 3127 function stopPromise() { 3128 return new Promise((resolve, reject) => { 3129 vibrator.stopVibration(undefined).then(() => { 3130 expect(true).assertTrue(); 3131 resolve(); 3132 }, (error) => { 3133 expect(false).assertTrue(); 3134 reject(error); 3135 }); 3136 }) 3137 } 3138 3139 let promise = new Promise((resolve, reject) => { 3140 vibrator.vibrate(2000, (error) => { 3141 if (error) { 3142 expect(false).assertTrue(); 3143 reject(error); 3144 } else { 3145 expect(true).assertTrue(); 3146 resolve(); 3147 } 3148 }); 3149 }) 3150 3151 await promise.then(() => { 3152 return stopPromise(); 3153 }).catch((error) => { 3154 expect(false).assertTrue(); 3155 }) 3156 done(); 3157 }) 3158 3159 /* 3160 * @tc.name:VibrateTest043 3161 * @tc.desc:verify app info is not null 3162 * @tc.type: FUNC 3163 * @tc.require: I5SWJI 3164 * @tc.number: VibrateTest043 3165 */ 3166 it("VibrateTest043", 0, async function (done) { 3167 function stopPromise() { 3168 return new Promise((resolve, reject) => { 3169 vibrator.stopVibration(null).then(() => { 3170 expect(true).assertTrue(); 3171 resolve(); 3172 }, (error) => { 3173 expect(false).assertTrue(); 3174 reject(error); 3175 }); 3176 }) 3177 } 3178 3179 let promise = new Promise((resolve, reject) => { 3180 vibrator.vibrate(2000, (error) => { 3181 if (error) { 3182 expect(false).assertTrue(); 3183 reject(error); 3184 } else { 3185 expect(true).assertTrue(); 3186 resolve(); 3187 } 3188 }); 3189 }) 3190 3191 await promise.then(() => { 3192 return stopPromise(); 3193 }).catch((error) => { 3194 expect(false).assertTrue(); 3195 }) 3196 done(); 3197 }) 3198 3199 /* 3200 * @tc.name:VibrateTest044 3201 * @tc.desc:verify app info is not null 3202 * @tc.type: FUNC 3203 * @tc.require: I5SWJI 3204 * @tc.number: VibrateTest044 3205 */ 3206 it("VibrateTest044", 0, async function (done) { 3207 function stopPromise() { 3208 return new Promise((resolve, reject) => { 3209 vibrator.stopVibration(123).then(() => { 3210 expect(true).assertTrue(); 3211 resolve(); 3212 }, (error) => { 3213 expect(false).assertTrue(); 3214 reject(error); 3215 }); 3216 }) 3217 } 3218 3219 let promise = new Promise((resolve, reject) => { 3220 vibrator.vibrate(2000, (error) => { 3221 if (error) { 3222 expect(false).assertTrue(); 3223 reject(error); 3224 } else { 3225 expect(true).assertTrue(); 3226 resolve(); 3227 } 3228 }); 3229 }) 3230 3231 await promise.then(() => { 3232 return stopPromise(); 3233 }).catch((error) => { 3234 expect(false).assertTrue(); 3235 }) 3236 done(); 3237 }) 3238 3239 /* 3240 * @tc.name:VibrateTest045 3241 * @tc.desc:verify the isSupportEffect and stopVibration interface 3242 * @tc.type: FUNC 3243 * @tc.require: I6HLLL 3244 * @tc.number: VibrateTest045 3245 */ 3246 it("VibrateTest045", 0, async function (done) { 3247 let isSupport = false; 3248 3249 function vibratePromise() { 3250 return new Promise((resolve, reject) => { 3251 if (isSupport) { 3252 vibrator.startVibration({ 3253 type: "preset", 3254 effectId: EFFECT_ID, 3255 count: 1, 3256 }, { 3257 usage: "unknown" 3258 }, (error) => { 3259 if (error) { 3260 expect(false).assertTrue(); 3261 reject(error); 3262 } else { 3263 expect(true).assertTrue(); 3264 resolve(); 3265 } 3266 }); 3267 } else { 3268 resolve(); 3269 } 3270 }) 3271 } 3272 3273 function stopPromise() { 3274 return new Promise((resolve, reject) => { 3275 if (isSupport) { 3276 vibrator.stopVibration((error) => { 3277 if (error) { 3278 expect(false).assertTrue(); 3279 reject(error); 3280 } else { 3281 expect(true).assertTrue(); 3282 resolve(); 3283 } 3284 }); 3285 } else { 3286 resolve(); 3287 } 3288 }) 3289 } 3290 3291 let isSupportPromise = new Promise((resolve, reject) => { 3292 vibrator.isSupportEffect(EFFECT_ID, undefined).then((state) => { 3293 expect(true).assertTrue(); 3294 isSupport = state; 3295 resolve(); 3296 }, (error) => { 3297 expect(false).assertTrue(); 3298 reject(error); 3299 }); 3300 }) 3301 3302 await isSupportPromise.then(() => { 3303 return vibratePromise(); 3304 }).then(() => { 3305 return stopPromise(); 3306 }).catch((error) => { 3307 expect(false).assertTrue(); 3308 }) 3309 done(); 3310 }) 3311 3312 /* 3313 * @tc.name:VibrateTest046 3314 * @tc.desc:verify the isSupportEffect and stopVibration interface 3315 * @tc.type: FUNC 3316 * @tc.require: I6HLLL 3317 * @tc.number: VibrateTest046 3318 */ 3319 it("VibrateTest046", 0, async function (done) { 3320 let isSupport = false; 3321 3322 function vibratePromise() { 3323 return new Promise((resolve, reject) => { 3324 if (isSupport) { 3325 vibrator.startVibration({ 3326 type: "preset", 3327 effectId: EFFECT_ID, 3328 count: 1, 3329 }, { 3330 usage: "unknown" 3331 }, (error) => { 3332 if (error) { 3333 expect(false).assertTrue(); 3334 reject(error); 3335 } else { 3336 expect(true).assertTrue(); 3337 resolve(); 3338 } 3339 }); 3340 } else { 3341 resolve(); 3342 } 3343 }) 3344 } 3345 3346 function stopPromise() { 3347 return new Promise((resolve, reject) => { 3348 if (isSupport) { 3349 vibrator.stopVibration((error) => { 3350 if (error) { 3351 expect(false).assertTrue(); 3352 reject(error); 3353 } else { 3354 expect(true).assertTrue(); 3355 resolve(); 3356 } 3357 }); 3358 } else { 3359 resolve(); 3360 } 3361 }) 3362 } 3363 3364 let isSupportPromise = new Promise((resolve, reject) => { 3365 vibrator.isSupportEffect(EFFECT_ID, null).then((state) => { 3366 expect(true).assertTrue(); 3367 isSupport = state; 3368 resolve(); 3369 }, (error) => { 3370 expect(false).assertTrue(); 3371 reject(error); 3372 }); 3373 }) 3374 3375 await isSupportPromise.then(() => { 3376 return vibratePromise(); 3377 }).then(() => { 3378 return stopPromise(); 3379 }).catch((error) => { 3380 expect(false).assertTrue(); 3381 }) 3382 done(); 3383 }) 3384 3385 /* 3386 * @tc.name:VibrateTest047 3387 * @tc.desc:verify the isSupportEffect and stopVibration interface 3388 * @tc.type: FUNC 3389 * @tc.require: I6HLLL 3390 * @tc.number: VibrateTest047 3391 */ 3392 it("VibrateTest047", 0, async function (done) { 3393 let isSupport = false; 3394 3395 function vibratePromise() { 3396 return new Promise((resolve, reject) => { 3397 if (isSupport) { 3398 vibrator.startVibration({ 3399 type: "preset", 3400 effectId: EFFECT_ID, 3401 count: 1, 3402 }, { 3403 usage: "unknown" 3404 }, (error) => { 3405 if (error) { 3406 expect(false).assertTrue(); 3407 reject(error); 3408 } else { 3409 expect(true).assertTrue(); 3410 resolve(); 3411 } 3412 }); 3413 } else { 3414 resolve(); 3415 } 3416 }) 3417 } 3418 3419 function stopPromise() { 3420 return new Promise((resolve, reject) => { 3421 if (isSupport) { 3422 vibrator.stopVibration((error) => { 3423 if (error) { 3424 expect(false).assertTrue(); 3425 reject(error); 3426 } else { 3427 expect(true).assertTrue(); 3428 resolve(); 3429 } 3430 }); 3431 } else { 3432 resolve(); 3433 } 3434 }) 3435 } 3436 3437 let isSupportPromise = new Promise((resolve, reject) => { 3438 vibrator.isSupportEffect(EFFECT_ID, "abc").then((state) => { 3439 expect(true).assertTrue(); 3440 isSupport = state; 3441 resolve(); 3442 }, (error) => { 3443 expect(false).assertTrue(); 3444 reject(error); 3445 }); 3446 }) 3447 3448 await isSupportPromise.then(() => { 3449 return vibratePromise(); 3450 }).then(() => { 3451 return stopPromise(); 3452 }).catch((error) => { 3453 expect(false).assertTrue(); 3454 }) 3455 done(); 3456 }) 3457 3458 /* 3459 * @tc.name:VibrateTest048 3460 * @tc.desc:verify the startVibration interface 3461 * @tc.type: FUNC 3462 * @tc.require: I6HLLL 3463 * @tc.number: VibrateTest048 3464 */ 3465 it("VibrateTest048", 0, async function (done) { 3466 try { 3467 vibrator.startVibration({ 3468 type: "file", 3469 hapticFd: { fd: "" } 3470 }, { 3471 usage: "unknown" 3472 }, (error)=>{ 3473 console.info("VibrateTest036 should not in this method"); 3474 expect(false).assertTrue(); 3475 done(); 3476 }); 3477 } catch (error) { 3478 expect(error.code).assertEqual(PARAMETER_ERROR_CODE); 3479 done(); 3480 } 3481 }) 3482 3483 /* 3484 * @tc.name:VibrateTest049 3485 * @tc.desc:verify the isHdHapticSupported interface 3486 * @tc.type: FUNC 3487 * @tc.require: I6HLLL 3488 * @tc.number: VibrateTest049 3489 */ 3490 it("VibrateTest049", 0, function () { 3491 try { 3492 expect(typeof(vibrator.isHdHapticSupported())).assertEqual("boolean"); 3493 } catch (error) { 3494 console.info("VibrateTest037 exception in, err:" + error); 3495 expect(true).assertEqual(false); 3496 } 3497 }) 3498 3499 /* 3500 * @tc.name:VibrateTest050 3501 * @tc.desc:verify the synchronous interface 3502 * @tc.type: FUNC 3503 * @tc.require: I6HLLL 3504 * @tc.number: VibrateTest050 3505 */ 3506 it("VibrateTest050", 0, async function () { 3507 console.info("VibrateTest050 in"); 3508 await vibrator.startVibration({ 3509 type: "time", 3510 duration: 500 3511 }, { 3512 usage: "alarm" 3513 }, (error) => { 3514 if (error) { 3515 console.info("startVibration error: " + JSON.stringify(error)); 3516 expect(false).assertTrue(); 3517 } else { 3518 console.info("startVibration success"); 3519 expect(true).assertTrue(); 3520 } 3521 done(); 3522 }); 3523 try { 3524 vibrator.stopVibrationSync(); 3525 console.info("stopVibrationSync success"); 3526 expect(true).assertTrue(); 3527 } catch (error) { 3528 console.info("stopVibrationSync error: " + JSON.stringify(error)); 3529 expect(false).assertTrue(); 3530 } 3531 console.info("VibrateTest050 end"); 3532 }) 3533 3534 /* 3535 * @tc.name:VibrateTest051 3536 * @tc.desc:verify the synchronous interface 3537 * @tc.type: FUNC 3538 * @tc.require: I6HLLL 3539 * @tc.number: VibrateTest051 3540 */ 3541 it("VibrateTest051", 0, async function () { 3542 console.info("VibrateTest051 in"); 3543 try { 3544 let ret = vibrator.isSupportEffectSync(INVALID_EFFECT_ID); 3545 expect(ret).assertEqual(false); 3546 } catch (error) { 3547 console.info("isSupportEffectSync error: " + JSON.stringify(error)); 3548 expect(false).assertTrue(); 3549 } 3550 console.info("VibrateTest051 end"); 3551 }) 3552 3553 /* 3554 * @tc.name:VibrateJsTest052 3555 * @tc.desc:verify app info is not null 3556 * @tc.type: FUNC 3557 * @tc.require: I53SGE 3558 * @tc.number: VibrateJsTest052 3559 */ 3560 it("VibrateJsTest052", 0, async function () { 3561 let ret = vibrator.isSupportEffectSync("haptic.notice.success"); 3562 if (ret) { 3563 vibrator.startVibration({ 3564 type: "preset", 3565 effectId: "haptic.notice.success", 3566 count: 1, 3567 intensity: 50, 3568 }, { 3569 usage: "unknown" 3570 }, (error) => { 3571 if (error) { 3572 console.info('VibrateJsTest052 vibrator error'); 3573 expect(false).assertTrue(); 3574 } else { 3575 console.info('VibrateJsTest052 vibrator success'); 3576 expect(true).assertTrue(); 3577 } 3578 setTimeout(() => { 3579 done(); 3580 }, 139); 3581 }); 3582 } else { 3583 console.info('This device is not supportEffect'); 3584 expect(true).assertTrue(); 3585 done(); 3586 } 3587 }) 3588 3589 /* 3590 * @tc.name:VibrateJsTest053 3591 * @tc.desc:verify app info is not null 3592 * @tc.type: FUNC 3593 * @tc.require: I53SGE 3594 * @tc.number: VibrateJsTest053 3595 */ 3596 it("VibrateJsTest053", 0, async function () { 3597 let ret = vibrator.isSupportEffectSync("haptic.notice.fail"); 3598 if (ret) { 3599 vibrator.startVibration({ 3600 type: "preset", 3601 effectId: "haptic.notice.fail", 3602 count: 1, 3603 intensity: 50, 3604 }, { 3605 usage: "unknown" 3606 }, (error) => { 3607 if (error) { 3608 console.info('VibrateJsTest053 vibrator error'); 3609 expect(false).assertTrue(); 3610 } else { 3611 console.info('VibrateJsTest053 vibrator success'); 3612 expect(true).assertTrue(); 3613 } 3614 setTimeout(() => { 3615 done(); 3616 }, 277); 3617 }); 3618 } else { 3619 console.info('This device is not supportEffect'); 3620 expect(true).assertTrue(); 3621 done(); 3622 } 3623 }) 3624 3625 /* 3626 * @tc.name:VibrateJsTest054 3627 * @tc.desc:verify app info is not null 3628 * @tc.type: FUNC 3629 * @tc.require: I53SGE 3630 * @tc.number: VibrateJsTest054 3631 */ 3632 it("VibrateJsTest054", 0, async function () { 3633 let ret = vibrator.isSupportEffectSync("haptic.notice.warning"); 3634 if (ret) { 3635 vibrator.startVibration({ 3636 type: "preset", 3637 effectId: "haptic.notice.warning", 3638 count: 1, 3639 intensity: 50, 3640 }, { 3641 usage: "unknown" 3642 }, (error) => { 3643 if (error) { 3644 console.info('VibrateJsTest054 vibrator error'); 3645 expect(false).assertTrue(); 3646 } else { 3647 console.info('VibrateJsTest054 vibrator success'); 3648 expect(true).assertTrue(); 3649 } 3650 setTimeout(() => { 3651 done(); 3652 }, 2200); 3653 }); 3654 } else { 3655 console.info('This device is not supportEffect'); 3656 expect(true).assertTrue(); 3657 done(); 3658 } 3659 }) 3660}) 3661