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:VibrateTest001
1277     * @tc.desc:verify app info is not null
1278     * @tc.type: FUNC
1279     * @tc.require: I53SGE
1280     * @tc.number: VibrateTest001
1281     */
1282    it("VibrateTest001", 0, async function (done) {
1283        vibrator.startVibration({
1284            type: "time",
1285            duration: 1000
1286        }, {
1287            usage: "unknown"
1288        }, (error) => {
1289            if (error) {
1290                console.info('VibrateTest001 startVibration error');
1291                expect(false).assertTrue();
1292            } else {
1293                console.info('VibrateTest001 startVibration success');
1294                expect(true).assertTrue();
1295            }
1296            setTimeout(() => {
1297                done();
1298            }, 500);
1299        });
1300    })
1301
1302    /*
1303     * @tc.name:VibrateTest002
1304     * @tc.desc:verify app info is not null
1305     * @tc.type: FUNC
1306     * @tc.require: I53SGE
1307     * @tc.number: VibrateTest002
1308     */
1309    it("VibrateTest002", 0, async function (done) {
1310        try {
1311            vibrator.startVibration({
1312                type: "",
1313                duration: 1000
1314            }, {
1315                usage: "unknown"
1316            }, (error) => {
1317                if (error) {
1318                    expect(true).assertTrue();
1319                } else {
1320                    expect(false).assertTrue();
1321                }
1322                setTimeout(() => {
1323                    done();
1324                }, 500);
1325            });
1326        } catch (error) {
1327            console.info(error);
1328            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1329            done();
1330        }
1331    })
1332
1333    /*
1334     * @tc.name:VibrateTest003
1335     * @tc.desc:verify app info is not null
1336     * @tc.type: FUNC
1337     * @tc.require: I53SGE
1338     * @tc.number: VibrateTest003
1339     */
1340    it("VibrateTest003", 0, async function (done) {
1341        if (g_execute) {
1342            vibrator.startVibration({
1343                type: "preset",
1344                effectId: "haptic.clock.timer",
1345                count: 1,
1346            }, {
1347                usage: "unknown"
1348            }, (error) => {
1349                if (error) {
1350                    console.info('VibrateTest003 vibrator error');
1351                    expect(false).assertTrue();
1352                } else {
1353                    console.info('VibrateTest003 vibrator success');
1354                    expect(true).assertTrue();
1355                }
1356                setTimeout(() => {
1357                    done();
1358                }, 500);
1359            });
1360        } else {
1361            console.info('VibrateTest003 vibrator success');
1362            expect(true).assertTrue();
1363            done();
1364        }
1365    })
1366
1367    /*
1368     * @tc.name:VibrateTest004
1369     * @tc.desc:verify app info is not null
1370     * @tc.type: FUNC
1371     * @tc.require: I53SGE
1372     * @tc.number: VibrateTest004
1373     */
1374    it("VibrateTest004", 0, async function (done) {
1375        try {
1376            vibrator.startVibration({
1377                type: "preset",
1378                effectId: "",
1379                count: 3,
1380            }, {
1381                usage: "unknown"
1382            }, (error) => {
1383                if (error) {
1384                    expect(true).assertTrue();
1385                } else {
1386                    expect(false).assertTrue();
1387                }
1388                setTimeout(() => {
1389                    done();
1390                }, 500);
1391            });
1392        } catch (error) {
1393            console.info(error);
1394            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1395            done();
1396        }
1397    })
1398
1399    /*
1400     * @tc.name:VibrateTest005
1401     * @tc.desc:verify app info is not null
1402     * @tc.type: FUNC
1403     * @tc.require: I53SGE
1404     * @tc.number: VibrateTest005
1405     */
1406    it("VibrateTest005", 0, async function (done) {
1407        if (g_execute) {
1408            try {
1409                vibrator.startVibration({
1410                    type: "preset",
1411                    effectId: "haptic.clock.timer",
1412                    count: 3,
1413                }, {
1414                    usage: ""
1415                }, (error) => {
1416                    expect(false).assertTrue();
1417                    setTimeout(() => {
1418                        done();
1419                    }, 500);
1420                });
1421            } catch (error) {
1422                console.info(error);
1423                expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1424                done();
1425            }
1426        } else {
1427            console.info('VibrateTest005 vibrator success');
1428            expect(true).assertTrue();
1429            done();
1430        }
1431    })
1432
1433    /*
1434     * @tc.name:VibrateTest006
1435     * @tc.desc:verify app info is not null
1436     * @tc.type: FUNC
1437     * @tc.require: I53SGE
1438     * @tc.number: VibrateTest006
1439     */
1440    it("VibrateTest006", 0, async function (done) {
1441        try {
1442            vibrator.startVibration(null, null);
1443        } catch (error) {
1444            console.info(error);
1445            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1446            done();
1447        }
1448    })
1449
1450    /*
1451     * @tc.name:VibrateTest007
1452     * @tc.desc:verify app info is not null
1453     * @tc.type: FUNC
1454     * @tc.require: I53SGE
1455     * @tc.number: VibrateTest007
1456     */
1457    it("VibrateTest007", 0, async function (done) {
1458        await vibrator.startVibration({
1459            type: "time",
1460            duration: 1000,
1461        }, {
1462            usage: "unknown"
1463        }).then(() => {
1464            expect(true).assertTrue();
1465        }).catch((error) => {
1466            expect(false).assertTrue();
1467        });
1468        done();
1469    })
1470
1471    /*
1472     * @tc.name:VibrateTest008
1473     * @tc.desc:verify app info is not null
1474     * @tc.type: FUNC
1475     * @tc.require: I53SGE
1476     * @tc.number: VibrateTest008
1477     */
1478    it("VibrateTest008", 0, async function (done) {
1479        try {
1480            await vibrator.startVibration({
1481                type: "",
1482                duration: 1000
1483            }, {
1484                usage: "unknown"
1485            }).then(() => {
1486                expect(false).assertTrue();
1487            }).catch((error) => {
1488                expect(true).assertTrue();
1489            });
1490            done();
1491        } catch (error) {
1492            console.info(error);
1493            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1494            done();
1495        }
1496    })
1497
1498    /*
1499     * @tc.name:VibrateTest009
1500     * @tc.desc:verify app info is not null
1501     * @tc.type: FUNC
1502     * @tc.require: I53SGE
1503     * @tc.number: VibrateTest009
1504     */
1505    it("VibrateTest009", 0, async function (done) {
1506        if (g_execute) {
1507            await vibrator.startVibration({
1508                type: "preset",
1509                effectId: "haptic.clock.timer",
1510                count: 1,
1511            }, {
1512                usage: "unknown"
1513            }).then(() => {
1514                expect(true).assertTrue();
1515            }).catch((error) => {
1516                expect(false).assertTrue();
1517            });
1518            done();
1519        } else {
1520            console.info('VibrateTest009 vibrator success');
1521            expect(true).assertTrue();
1522            done();
1523        }
1524    })
1525
1526    /*
1527     * @tc.name:VibrateTest010
1528     * @tc.desc:verify app info is not null
1529     * @tc.type: FUNC
1530     * @tc.require: I53SGE
1531     * @tc.number: VibrateTest010
1532     */
1533    it("VibrateTest010", 0, async function (done) {
1534        try {
1535            vibrator.startVibration({
1536                type: "preset",
1537                effectId: "",
1538                count: 3,
1539            }, {
1540                usage: "unknown"
1541            }).then(() => {
1542                expect(false).assertTrue();
1543                done();
1544            }).catch((error) => {
1545                expect(true).assertTrue();
1546                done();
1547            });
1548        } catch (error) {
1549            console.info(error);
1550            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1551            done();
1552        }
1553    })
1554
1555    /*
1556     * @tc.name:VibrateTest011
1557     * @tc.desc:verify app info is not null
1558     * @tc.type: FUNC
1559     * @tc.require: I53SGE
1560     * @tc.number: VibrateTest011
1561     */
1562    it("VibrateTest011", 0, async function (done) {
1563        if (g_execute) {
1564            try {
1565                vibrator.startVibration({
1566                    type: "preset",
1567                    effectId: "haptic.clock.timer",
1568                    count: 3,
1569                }, {
1570                    usage: ""
1571                }).then(() => {
1572                    expect(false).assertTrue();
1573                    done();
1574                }).catch((error) => {
1575                    expect(true).assertTrue();
1576                    done();
1577                });
1578            } catch (error) {
1579                console.info(error);
1580                expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1581                done();
1582            }
1583        } else {
1584            console.info('VibrateTest011 vibrator success');
1585            expect(true).assertTrue();
1586            done();
1587        }
1588    })
1589
1590    /*
1591     * @tc.name:VibrateTest012
1592     * @tc.desc:verify app info is not null
1593     * @tc.type: FUNC
1594     * @tc.require: I53SGE
1595     * @tc.number: VibrateTest012
1596     */
1597    it("VibrateTest012", 0, async function (done) {
1598        try {
1599            vibrator.startVibration({
1600                type: 1,
1601                count: 3,
1602            }, {
1603                usage: ""
1604            })
1605        } catch (error) {
1606            console.info(error);
1607            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
1608            done();
1609        }
1610    })
1611
1612    /*
1613     * @tc.name:VibrateTest013
1614     * @tc.desc:verify app info is not null
1615     * @tc.type: FUNC
1616     * @tc.require: I53SGE
1617     * @tc.number: VibrateTest013
1618     */
1619    it("VibrateTest013", 0, async function (done) {
1620        function vibratePromise() {
1621            return new Promise((resolve, reject) => {
1622                vibrator.startVibration({
1623                    type: "time",
1624                    duration: 100
1625                }, {
1626                    usage: "unknown"
1627                }, (error) => {
1628                    if (error) {
1629                        expect(false).assertTrue();
1630                    } else {
1631                        expect(true).assertTrue();
1632                    }
1633                    setTimeout(() => {
1634                        done();
1635                    }, 500);
1636                });
1637            })
1638        }
1639
1640        let promise = new Promise((resolve, reject) => {
1641            vibrator.startVibration({
1642                type: "time",
1643                duration: 100
1644            }, {
1645                usage: "unknown"
1646            }, (error) => {
1647                if (error) {
1648                    expect(false).assertTrue();
1649                    reject();
1650                } else {
1651                    expect(true).assertTrue();
1652                    resolve();
1653                }
1654            });
1655        })
1656
1657        await promise.then(() => {
1658            return vibratePromise();
1659        }, () => {
1660            console.info("StartVibrationTest013 reject");
1661        })
1662        done();
1663    })
1664
1665    /*
1666     * @tc.name:VibrateTest014
1667     * @tc.desc:verify app info is not null
1668     * @tc.type: FUNC
1669     * @tc.require: I53SGE
1670     * @tc.number: VibrateTest014
1671     */
1672    it("VibrateTest014", 0, async function (done) {
1673        if (g_execute) {
1674            function vibratePromise() {
1675                return new Promise((resolve, reject) => {
1676                    vibrator.startVibration({
1677                        type: "preset",
1678                        effectId: "haptic.clock.timer",
1679                        count: 1,
1680                    }, {
1681                        usage: "unknown"
1682                    }, (error) => {
1683                        if (error) {
1684                            expect(error.code).assertEqual(OPERATION_FAIL_CODE);
1685                            expect(error.message).assertEqual(OPERATION_FAIL_MSG);
1686                        } else {
1687                            expect(false).assertTrue();
1688                        }
1689                        setTimeout(() => {
1690                            done();
1691                        }, 500);
1692                    });
1693                })
1694            }
1695
1696            let promise = new Promise((resolve, reject) => {
1697                vibrator.startVibration({
1698                    type: "time",
1699                    duration: 100
1700                }, {
1701                    usage: "alarm"
1702                }, (error) => {
1703                    if (error) {
1704                        expect(false).assertTrue();
1705                        reject();
1706                    } else {
1707                        expect(true).assertTrue();
1708                        resolve();
1709                    }
1710                });
1711            })
1712
1713            await promise.then(() => {
1714                return vibratePromise();
1715            }, () => {
1716                console.info("VibrateTest014 reject");
1717            })
1718            done();
1719        } else {
1720            console.info('VibrateTest014 vibrator success');
1721            expect(true).assertTrue();
1722            done();
1723        }
1724    })
1725
1726    /*
1727     * @tc.name:VibrateTest015
1728     * @tc.desc:verify app info is not null
1729     * @tc.type: FUNC
1730     * @tc.require: I6HKTI
1731     * @tc.number: VibrateTest015
1732     */
1733    it("VibrateTest015", 0, async function (done) {
1734        if (g_execute) {
1735            function vibratePromise() {
1736                return new Promise((resolve, reject) => {
1737                    vibrator.startVibration({
1738                        type: "preset",
1739                        effectId: "haptic.clock.timer",
1740                        count: 3,
1741                    }, {
1742                        usage: "unknown",
1743                    }, (error) => {
1744                        if (error) {
1745                            expect(false).assertTrue();
1746                        } else {
1747                            expect(true).assertTrue();
1748                        }
1749                        setTimeout(() => {
1750                            done();
1751                        }, 500);
1752                    });
1753                })
1754            }
1755
1756            let promise = new Promise((resolve, reject) => {
1757                vibrator.startVibration({
1758                    type: "time",
1759                    duration: 10000
1760                }, {
1761                    usage: "alarm"
1762                }, (error) => {
1763                    if (error) {
1764                        expect(false).assertTrue();
1765                        reject();
1766                    } else {
1767                        expect(true).assertTrue();
1768                        resolve();
1769                    }
1770                });
1771            })
1772            await promise.then(() => {
1773                return vibratePromise();
1774            }, () => {
1775                console.info("VibrateTest015 reject");
1776            })
1777            done();
1778        } else {
1779            console.info('VibrateTest015 vibrator success');
1780            expect(true).assertTrue();
1781            done();
1782        }
1783    })
1784
1785    /*
1786     * @tc.name:VibrateTest016
1787     * @tc.desc:verify app info is not null
1788     * @tc.type: FUNC
1789     * @tc.require: I6HKTI
1790     * @tc.number: VibrateTest016
1791     */
1792    it("VibrateTest016", 0, async function (done) {
1793        if (g_execute) {
1794            function vibratePromise() {
1795                return new Promise((resolve, reject) => {
1796                    vibrator.startVibration({
1797                        type: "preset",
1798                        effectId: "haptic.clock.timer",
1799                        count: 1,
1800                    }, {
1801                        usage: "unknown",
1802                    }, (error) => {
1803                        if (error) {
1804                            expect(error.code).assertEqual(OPERATION_FAIL_CODE);
1805                            expect(error.message).assertEqual(OPERATION_FAIL_MSG);
1806                        } else {
1807                            expect(false).assertTrue();
1808                        }
1809                        setTimeout(() => {
1810                            done();
1811                        }, 500);
1812                    });
1813                })
1814            }
1815
1816            let promise = new Promise((resolve, reject) => {
1817                vibrator.startVibration({
1818                    type: "preset",
1819                    effectId: "haptic.clock.timer",
1820                    count: 3,
1821                }, {
1822                    usage: "unknown",
1823                }, (error) => {
1824                    if (error) {
1825                        expect(false).assertTrue();
1826                        reject();
1827                    } else {
1828                        expect(true).assertTrue();
1829                        resolve();
1830                    }
1831                });
1832            })
1833
1834            await promise.then(() => {
1835                return vibratePromise();
1836            }, () => {
1837                console.info("VibrateTest016 reject");
1838            })
1839            done();
1840        } else {
1841            console.info('VibrateTest016 vibrator success');
1842            expect(true).assertTrue();
1843            done();
1844        }
1845    })
1846
1847    /*
1848     * @tc.name:VibrateTest017
1849     * @tc.desc:verify app info is not null
1850     * @tc.type: FUNC
1851     * @tc.require: I6HKTI
1852     * @tc.number: VibrateTest017
1853     */
1854    it("VibrateTest017", 0, async function (done) {
1855        if (g_execute) {
1856            function vibratePromise() {
1857                return new Promise((resolve, reject) => {
1858                    vibrator.startVibration({
1859                        type: "time",
1860                        duration: 3000,
1861                    }, {
1862                        usage: "alarm"
1863                    }, (error) => {
1864                        if (error) {
1865                            expect(error.code).assertEqual(OPERATION_FAIL_CODE);
1866                            expect(error.message).assertEqual(OPERATION_FAIL_MSG);
1867                        } else {
1868                            expect(false).assertTrue();
1869                        }
1870                        setTimeout(() => {
1871                            done();
1872                        }, 500);
1873                    });
1874                })
1875            }
1876
1877            let promise = new Promise((resolve, reject) => {
1878                vibrator.startVibration({
1879                    type: "preset",
1880                    effectId: "haptic.clock.timer",
1881                    count: 3,
1882                }, {
1883                    usage: "unknown"
1884                }, (error) => {
1885                    if (error) {
1886                        expect(false).assertTrue();
1887                        reject();
1888                    } else {
1889                        expect(true).assertTrue();
1890                        resolve();
1891                    }
1892                });
1893            })
1894
1895            await promise.then(() => {
1896                return vibratePromise();
1897            }, () => {
1898                console.info("VibrateTest017 reject");
1899            })
1900            done();
1901        } else {
1902            console.info('VibrateTest017 vibrator success');
1903            expect(true).assertTrue();
1904            done();
1905        }
1906    })
1907
1908    /*
1909     * @tc.name:VibrateTest018
1910     * @tc.desc:verify app info is not null
1911     * @tc.type: FUNC
1912     * @tc.require: I6HKTI
1913     * @tc.number: VibrateTest018
1914     */
1915    it("VibrateTest018", 0, async function (done) {
1916        if (g_execute) {
1917            function vibratePromise() {
1918                return new Promise((resolve, reject) => {
1919                    vibrator.startVibration({
1920                        type: "time",
1921                        duration: 3000,
1922                    }, {
1923                        usage: "alarm"
1924                    }, (error) => {
1925                        if (error) {
1926                            expect(false).assertTrue();
1927                        } else {
1928                            expect(true).assertTrue();
1929                        }
1930                        setTimeout(() => {
1931                            done();
1932                        }, 500);
1933                    });
1934                })
1935            }
1936
1937            let promise = new Promise((resolve, reject) => {
1938                vibrator.startVibration({
1939                    type: "preset",
1940                    effectId: "haptic.clock.timer",
1941                    count: 1,
1942                }, {
1943                    usage: "unknown"
1944                }, (error) => {
1945                    if (error) {
1946                        expect(false).assertTrue();
1947                        reject();
1948                    } else {
1949                        expect(true).assertTrue();
1950                        resolve();
1951                    }
1952                });
1953            })
1954
1955            await promise.then(() => {
1956                return vibratePromise();
1957            }, () => {
1958                console.info("VibrateTest018 reject");
1959            })
1960            done();
1961        } else {
1962            console.info('VibrateTest018 vibrator success');
1963            expect(true).assertTrue();
1964            done();
1965        }
1966    })
1967
1968    /*
1969     * @tc.name:VibrateTest019
1970     * @tc.desc:verify app info is not null
1971     * @tc.type: FUNC
1972     * @tc.require: I53SGE
1973     * @tc.number: VibrateTest019
1974     */
1975    it("VibrateTest019", 0, async function (done) {
1976        if (g_execute) {
1977            function vibratePromise() {
1978                return new Promise((resolve, reject) => {
1979                    vibrator.startVibration({
1980                        type: "preset",
1981                        effectId: "haptic.clock.timer",
1982                        count: 3,
1983                    }, {
1984                        usage: "unknown"
1985                    }, (error) => {
1986                        if (error) {
1987                            expect(false).assertTrue();
1988                        } else {
1989                            expect(true).assertTrue();
1990                        }
1991                        setTimeout(() => {
1992                            done();
1993                        }, 500);
1994                    });
1995                })
1996            }
1997
1998            let promise = new Promise((resolve, reject) => {
1999                vibrator.startVibration({
2000                    type: "preset",
2001                    effectId: "haptic.clock.timer",
2002                    count: 3,
2003                }, {
2004                    usage: "unknown"
2005                }, (error) => {
2006                    if (error) {
2007                        expect(false).assertTrue();
2008                        reject();
2009                    } else {
2010                        expect(true).assertTrue();
2011                        resolve();
2012                    }
2013                });
2014            })
2015
2016            await promise.then(() => {
2017                return vibratePromise();
2018            }, () => {
2019                console.info("VibrateTest019 reject");
2020            })
2021            done();
2022        } else {
2023            console.info('VibrateTest019 vibrator success');
2024            expect(true).assertTrue();
2025            done();
2026        }
2027    })
2028
2029    /*
2030     * @tc.name:VibrateTest020
2031     * @tc.desc:verify app info is not null
2032     * @tc.type: FUNC
2033     * @tc.require: I53SGE
2034     * @tc.number: VibrateTest020
2035     */
2036    it("VibrateTest020", 0, async function (done) {
2037        if (g_execute) {
2038            function vibratePromise() {
2039                return new Promise((resolve, reject) => {
2040                    vibrator.startVibration({
2041                        type: "preset",
2042                        effectId: "haptic.clock.timer",
2043                        count: 1,
2044                    }, {
2045                        usage: "ring"
2046                    }, (error) => {
2047                        if (error) {
2048                            expect(false).assertTrue();
2049                        } else {
2050                            expect(true).assertTrue();
2051                        }
2052                        setTimeout(() => {
2053                            done();
2054                        }, 500);
2055                    });
2056                })
2057            }
2058
2059            let promise = new Promise((resolve, reject) => {
2060                vibrator.startVibration({
2061                    type: "preset",
2062                    effectId: "haptic.clock.timer",
2063                    count: 1,
2064                }, {
2065                    usage: "notification"
2066                }, (error) => {
2067                    if (error) {
2068                        expect(false).assertTrue();
2069                        reject();
2070                    } else {
2071                        expect(true).assertTrue();
2072                        resolve();
2073                    }
2074                });
2075            })
2076
2077            await promise.then(() => {
2078                return vibratePromise();
2079            }, () => {
2080                console.info("VibrateTest020 reject");
2081            })
2082            done();
2083        } else {
2084            console.info('VibrateTest020 vibrator success');
2085            expect(true).assertTrue();
2086            done();
2087        }
2088    })
2089
2090    /*
2091     * @tc.name:VibrateTest021
2092     * @tc.desc:verify app info is not null
2093     * @tc.type: FUNC
2094     * @tc.require: I53SGE
2095     * @tc.number: VibrateTest021
2096     */
2097    it("VibrateTest021", 0, async function (done) {
2098        if (g_execute) {
2099            function vibratePromise() {
2100                return new Promise((resolve, reject) => {
2101                    vibrator.startVibration({
2102                        type: "preset",
2103                        effectId: "haptic.clock.timer",
2104                        count: 1,
2105                    }, {
2106                        usage: "unknown"
2107                    }, (error) => {
2108                        if (error) {
2109                            expect(error.code).assertEqual(OPERATION_FAIL_CODE);
2110                            expect(error.message).assertEqual(OPERATION_FAIL_MSG);
2111                        } else {
2112                            expect(false).assertTrue();
2113                        }
2114                        setTimeout(() => {
2115                            done();
2116                        }, 500);
2117                    });
2118                })
2119            }
2120
2121            let promise = new Promise((resolve, reject) => {
2122                vibrator.startVibration({
2123                    type: "preset",
2124                    effectId: "haptic.clock.timer",
2125                    count: 3,
2126                }, {
2127                    usage: "notification"
2128                }, (error) => {
2129                    if (error) {
2130                        expect(false).assertTrue();
2131                        reject();
2132                    } else {
2133                        expect(true).assertTrue();
2134                        resolve();
2135                    }
2136                });
2137            })
2138
2139            await promise.then(() => {
2140                return vibratePromise();
2141            }, () => {
2142                console.info("VibrateTest021 reject");
2143            })
2144            done();
2145        } else {
2146            console.info('VibrateTest021 vibrator success');
2147            expect(true).assertTrue();
2148            done();
2149        }
2150    })
2151
2152     /*
2153     * @tc.name:VibratorJsTest022
2154     * @tc.desc:verify app info is not null
2155     * @tc.type: FUNC
2156     * @tc.require: I5SWJI
2157     * @tc.number: VibrateTest022
2158     */
2159     it("VibrateTest022", 0, async function (done) {
2160        function vibrateCallback(error) {
2161            if (error) {
2162                console.info('VibrateTest022 stop fail');
2163                expect(false).assertTrue();
2164            } else {
2165                console.info('VibrateTest022 stop off');
2166                expect(false).assertTrue();
2167            }
2168            setTimeout(() => {
2169                done();
2170            }, 500);
2171        }
2172        try {
2173            vibrator.stopVibration("", vibrateCallback);
2174        } catch (error) {
2175            console.info(error);
2176            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2177            done();
2178        }
2179    })
2180
2181    /*
2182     * @tc.name:VibrateTest023
2183     * @tc.desc:verify app info is not null
2184     * @tc.type: FUNC
2185     * @tc.require: I5SWJI
2186     * @tc.number: VibrateTest023
2187     */
2188    it("VibrateTest023", 0, async function (done) {
2189        if (g_execute) {
2190            function stopPromise() {
2191                return new Promise((resolve, reject) => {
2192                    vibrator.stopVibration("preset").then(() => {
2193                        console.log("VibrateTest023 off success");
2194                        expect(true).assertTrue();
2195                        setTimeout(() => {
2196                            resolve();
2197                        }, 500);
2198                    }, (error) => {
2199                        expect(false).assertTrue();
2200                        console.log("VibrateTest023 off error");
2201                        setTimeout(() => {
2202                            reject();
2203                        }, 500);
2204                    });
2205                })
2206            }
2207
2208            let promise = new Promise((resolve, reject) => {
2209                vibrator.startVibration("haptic.clock.timer").then(() => {
2210                    console.log("VibrateTest023 vibrate success");
2211                    expect(true).assertTrue();
2212                    resolve();
2213                }, (error) => {
2214                    expect(false).assertTrue();
2215                    console.log("VibrateTest023 vibrate error");
2216                    reject();
2217                });
2218            })
2219
2220            await promise.then(() => {
2221                return stopPromise();
2222            }, () => {
2223                console.info("VibrateTest023 reject");
2224            })
2225            done();
2226        } else {
2227            console.info('VibrateTest023 vibrator success');
2228            expect(true).assertTrue();
2229            done();
2230        }
2231    })
2232
2233    /*
2234     * @tc.name:VibrateTest024
2235     * @tc.desc:verify app info is not null
2236     * @tc.type: FUNC
2237     * @tc.require: I5SWJI
2238     * @tc.number: VibrateTest024
2239     */
2240    it("VibrateTest024", 0, async function (done) {
2241        try {
2242            vibrator.stopVibration("").then(() => {
2243                console.log("VibrateTest024 stop error");
2244                expect(false).assertTrue();
2245                setTimeout(() => {
2246                    done();
2247                }, 500);
2248            }, (error) => {
2249                expect(false).assertTrue();
2250                console.log("VibrateTest024 stop error");
2251                setTimeout(() => {
2252                    done();
2253                }, 500);
2254            });
2255        } catch (error) {
2256            console.info(error);
2257            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2258            done();
2259        }
2260    })
2261
2262    /*
2263     * @tc.name:VibrateTest025
2264     * @tc.desc:verify app info is not null
2265     * @tc.type: FUNC
2266     * @tc.require: I5SWJI
2267     * @tc.number: VibrateTest025
2268     */
2269    it("VibrateTest025", 0, async function (done) {
2270        function stopPromise() {
2271            return new Promise((resolve, reject) => {
2272                vibrator.stopVibration("time").then(() => {
2273                    console.log("VibrateTest025 stop success");
2274                    expect(true).assertTrue();
2275                    setTimeout(() => {
2276                        resolve();
2277                    }, 500);
2278                }, (error) => {
2279                    expect(false).assertTrue();
2280                    console.log("VibrateTest025 stop error");
2281                    setTimeout(() => {
2282                        reject();
2283                    }, 500);
2284                });
2285            })
2286        }
2287
2288        let promise = new Promise((resolve, reject) => {
2289            vibrator.vibrate(180000).then(() => {
2290                console.log("VibrateTest025 vibrate success");
2291                expect(true).assertTrue();
2292                setTimeout(() => {
2293                    resolve();
2294                }, 500);
2295            }, (error) => {
2296                expect(false).assertTrue();
2297                console.log("VibrateTest025 vibrate error");
2298                setTimeout(() => {
2299                    reject();
2300                }, 500);
2301            });
2302        })
2303
2304        await promise.then(() => {
2305            return stopPromise();
2306        }, () => {
2307            console.info("VibrateTest025 reject");
2308        })
2309        done();
2310    })
2311
2312    /*
2313     * @tc.name:VibrateTest026
2314     * @tc.desc:verify the isSupportEffect and stopVibration interface
2315     * @tc.type: FUNC
2316     * @tc.require: I6HLLL
2317     * @tc.number: VibrateTest026
2318     */
2319    it("VibrateTest026", 0, async function (done) {
2320        vibrator.isSupportEffect(INVALID_EFFECT_ID, (error, state) => {
2321            if (error) {
2322                console.info('VibrateTest026 error');
2323                expect(false).assertTrue();
2324            } else {
2325                console.info('VibrateTest026 success');
2326                expect(!state).assertTrue();
2327            }
2328            done();
2329        });
2330    })
2331
2332    /*
2333     * @tc.name:VibrateTest027
2334     * @tc.desc:verify the isSupportEffect and stopVibration interface
2335     * @tc.type: FUNC
2336     * @tc.require: I6HLLL
2337     * @tc.number: VibrateTest027
2338     */
2339    it("VibrateTest027", 0, async function (done) {
2340        let isSupport = false;
2341
2342        function vibratePromise() {
2343            return new Promise((resolve, reject) => {
2344                if (isSupport) {
2345                    vibrator.startVibration({
2346                        type: "preset",
2347                        effectId: EFFECT_ID,
2348                        count: 1,
2349                    }, {
2350                        usage: "unknown"
2351                    }, (error) => {
2352                        if (error) {
2353                            expect(false).assertTrue();
2354                            reject(error);
2355                        } else {
2356                            expect(true).assertTrue();
2357                            resolve();
2358                        }
2359                    });
2360                } else {
2361                    resolve();
2362                }
2363            })
2364        }
2365
2366        function stopPromise() {
2367            return new Promise((resolve, reject) => {
2368                if (isSupport) {
2369                    vibrator.stopVibration((error) => {
2370                        if (error) {
2371                            expect(false).assertTrue();
2372                            reject(error);
2373                        } else {
2374                            expect(true).assertTrue();
2375                            resolve();
2376                        }
2377                    });
2378                } else {
2379                    resolve();
2380                }
2381            })
2382        }
2383
2384        let isSupportPromise = new Promise((resolve, reject) => {
2385            vibrator.isSupportEffect(EFFECT_ID, (error, state) => {
2386                if (error) {
2387                    expect(false).assertTrue();
2388                    reject(error);
2389                } else {
2390                    expect(true).assertTrue();
2391                    isSupport = state;
2392                    resolve();
2393                }
2394            });
2395        })
2396
2397        await isSupportPromise.then(() => {
2398            return vibratePromise();
2399        }).then(() => {
2400            return stopPromise();
2401        }).catch((error) => {
2402            expect(false).assertTrue();
2403        })
2404        done();
2405    })
2406
2407    /*
2408     * @tc.name:VibrateTest028
2409     * @tc.desc:verify the isSupportEffect and stopVibration interface
2410     * @tc.type: FUNC
2411     * @tc.require: I6HLLL
2412     * @tc.number: VibrateTest028
2413     */
2414    it("VibrateTest028", 0, async function (done) {
2415        try {
2416            vibrator.isSupportEffect(123, (error, state) => {
2417                console.info("VibrateTest028 should not in this method");
2418                expect(false).assertTrue();
2419                done();
2420            });
2421        } catch (error) {
2422            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2423            done();
2424        }
2425    })
2426
2427    /*
2428     * @tc.name:VibrateTest029
2429     * @tc.desc:verify the isSupportEffect and stopVibration interface
2430     * @tc.type: FUNC
2431     * @tc.require: I6HLLL
2432     * @tc.number: VibrateTest029
2433     */
2434    it("VibrateTest029", 0, async function (done) {
2435        try {
2436            vibrator.isSupportEffect();
2437        } catch (error) {
2438            console.info("VibrateTest029 exception in");
2439            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2440            done();
2441        }
2442    })
2443
2444    /*
2445     * @tc.name:VibrateTest030
2446     * @tc.desc:verify the isSupportEffect and stopVibration interface
2447     * @tc.type: FUNC
2448     * @tc.require: I6HLLL
2449     * @tc.number: VibrateTest030
2450     */
2451    it("VibrateTest030", 0, async function (done) {
2452        await vibrator.isSupportEffect(INVALID_EFFECT_ID).then((state) => {
2453            expect(!state).assertTrue();
2454        }, (error) => {
2455            expect(false).assertTrue();
2456        });
2457        done();
2458    })
2459
2460    /*
2461     * @tc.name:VibrateTest031
2462     * @tc.desc:verify the isSupportEffect and stopVibration interface
2463     * @tc.type: FUNC
2464     * @tc.require: I6HLLL
2465     * @tc.number: VibrateTest031
2466     */
2467    it("VibrateTest031", 0, async function (done) {
2468        let isSupport = false;
2469
2470        function vibratePromise() {
2471            return new Promise((resolve, reject) => {
2472                if (isSupport) {
2473                    vibrator.startVibration({
2474                        type: "preset",
2475                        effectId: EFFECT_ID,
2476                        count: 1,
2477                    }, {
2478                        usage: "unknown"
2479                    }, (error) => {
2480                        if (error) {
2481                            expect(false).assertTrue();
2482                            reject(error);
2483                        } else {
2484                            expect(true).assertTrue();
2485                            resolve();
2486                        }
2487                    });
2488                } else {
2489                    resolve();
2490                }
2491            })
2492        }
2493
2494        function stopPromise() {
2495            return new Promise((resolve, reject) => {
2496                if (isSupport) {
2497                    vibrator.stopVibration((error) => {
2498                        if (error) {
2499                            expect(false).assertTrue();
2500                            reject(error);
2501                        } else {
2502                            expect(true).assertTrue();
2503                            resolve();
2504                        }
2505                    });
2506                } else {
2507                    resolve();
2508                }
2509            })
2510        }
2511
2512        let isSupportPromise = new Promise((resolve, reject) => {
2513            vibrator.isSupportEffect(EFFECT_ID).then((state) => {
2514                expect(true).assertTrue();
2515                isSupport = state;
2516                resolve();
2517            }, (error) => {
2518                expect(false).assertTrue();
2519                reject(error);
2520            });
2521        })
2522
2523        await isSupportPromise.then(() => {
2524            return vibratePromise();
2525        }).then(() => {
2526            return stopPromise();
2527        }).catch((error) => {
2528            expect(false).assertTrue();
2529        })
2530        done();
2531    })
2532
2533    /*
2534     * @tc.name:VibrateTest032
2535     * @tc.desc:verify the isSupportEffect and stopVibration interface
2536     * @tc.type: FUNC
2537     * @tc.require: I6HLLL
2538     * @tc.number: VibrateTest032
2539     */
2540    it("VibrateTest032", 0, async function (done) {
2541        try {
2542            vibrator.isSupportEffect(123).then((state) => {
2543                expect(false).assertTrue();
2544                done();
2545            }, (error) => {
2546                expect(false).assertTrue();
2547                done();
2548            });
2549        } catch (error) {
2550            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2551            done();
2552        }
2553    })
2554
2555    /*
2556     * @tc.name:VibrateTest033
2557     * @tc.desc:verify the isSupportEffect and stopVibration interface
2558     * @tc.type: FUNC
2559     * @tc.require: I6HLLL
2560     * @tc.number: VibrateTest033
2561     */
2562    it("VibrateTest033", 0, async function (done) {
2563        try {
2564            vibrator.isSupportEffect().then((state) => {
2565                expect(false).assertTrue();
2566                done();
2567            }, (error) => {
2568                expect(false).assertTrue();
2569                done();
2570            });
2571        } catch (error) {
2572            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
2573            done();
2574        }
2575    })
2576
2577    /*
2578     * @tc.name:VibrateTest034
2579     * @tc.desc:verify the isSupportEffect and stopVibration interface
2580     * @tc.type: FUNC
2581     * @tc.require: I6HLLL
2582     * @tc.number: VibrateTest034
2583     */
2584    it("VibrateTest034", 0, async function (done) {
2585        function stopPromise() {
2586            return new Promise((resolve, reject) => {
2587                vibrator.stopVibration((error) => {
2588                    if (error) {
2589                        expect(false).assertTrue();
2590                        reject(error);
2591                    } else {
2592                        expect(true).assertTrue();
2593                        resolve();
2594                    }
2595                });
2596            })
2597        }
2598
2599        let promise = new Promise((resolve, reject) => {
2600            vibrator.vibrate(2000, (error) => {
2601                if (error) {
2602                    expect(false).assertTrue();
2603                    reject(error);
2604                } else {
2605                    expect(true).assertTrue();
2606                    resolve();
2607                }
2608            });
2609        })
2610
2611        await promise.then(() => {
2612            return stopPromise();
2613        }).catch((error) => {
2614            expect(false).assertTrue();
2615        })
2616        done();
2617    })
2618
2619    /*
2620     * @tc.name:VibrateTest035
2621     * @tc.desc:verify the isSupportEffect and stopVibration interface
2622     * @tc.type: FUNC
2623     * @tc.require: I6HLLL
2624     * @tc.number: VibrateTest035
2625     */
2626    it("VibrateTest035", 0, async function (done) {
2627        function stopPromise() {
2628            return new Promise((resolve, reject) => {
2629                vibrator.stopVibration().then(() => {
2630                    expect(true).assertTrue();
2631                    resolve();
2632                }, (error) => {
2633                    expect(false).assertTrue();
2634                    reject(error);
2635                });
2636            })
2637        }
2638
2639        let promise = new Promise((resolve, reject) => {
2640            vibrator.vibrate(2000, (error) => {
2641                if (error) {
2642                    expect(false).assertTrue();
2643                    reject(error);
2644                } else {
2645                    expect(true).assertTrue();
2646                    resolve();
2647                }
2648            });
2649        })
2650
2651        await promise.then(() => {
2652            return stopPromise();
2653        }).catch((error) => {
2654            expect(false).assertTrue();
2655        })
2656        done();
2657    })
2658
2659    /*
2660     * @tc.name:VibrateTest036
2661     * @tc.desc:verify app info is not null
2662     * @tc.type: FUNC
2663     * @tc.require: I5SWJI
2664     * @tc.number: VibrateTest036
2665     */
2666    it("VibrateTest036", 0, async function (done) {
2667        if (g_execute) {
2668            function stopPromise() {
2669                return new Promise((resolve, reject) => {
2670                    vibrator.stopVibration("preset", undefined).then(() => {
2671                        console.log("VibrateTest036 off success");
2672                        expect(true).assertTrue();
2673                        setTimeout(() => {
2674                            resolve();
2675                        }, 500);
2676                    }, (error) => {
2677                        expect(false).assertTrue();
2678                        console.log("VibrateTest036 off error");
2679                        setTimeout(() => {
2680                            reject();
2681                        }, 500);
2682                    });
2683                })
2684            }
2685
2686            let promise = new Promise((resolve, reject) => {
2687                vibrator.startVibration("haptic.clock.timer").then(() => {
2688                    console.log("VibrateTest036 vibrate success");
2689                    expect(true).assertTrue();
2690                    resolve();
2691                }, (error) => {
2692                    expect(false).assertTrue();
2693                    console.log("VibrateTest036 vibrate error");
2694                    reject();
2695                });
2696            })
2697
2698            await promise.then(() => {
2699                return stopPromise();
2700            }, () => {
2701                console.info("VibrateTest036 reject");
2702            })
2703            done();
2704        } else {
2705            console.info('VibrateTest036 vibrator success');
2706            expect(true).assertTrue();
2707            done();
2708        }
2709    })
2710
2711    /*
2712     * @tc.name:VibrateTest037
2713     * @tc.desc:verify app info is not null
2714     * @tc.type: FUNC
2715     * @tc.require: I5SWJI
2716     * @tc.number: VibrateTest037
2717     */
2718    it("VibrateTest037", 0, async function (done) {
2719        if (g_execute) {
2720            function stopPromise() {
2721                return new Promise((resolve, reject) => {
2722                    vibrator.stopVibration("preset", null).then(() => {
2723                        console.log("VibrateTest037 off success");
2724                        expect(true).assertTrue();
2725                        setTimeout(() => {
2726                            resolve();
2727                        }, 500);
2728                    }, (error) => {
2729                        expect(false).assertTrue();
2730                        console.log("VibrateTest037 off error");
2731                        setTimeout(() => {
2732                            reject();
2733                        }, 500);
2734                    });
2735                })
2736            }
2737
2738            let promise = new Promise((resolve, reject) => {
2739                vibrator.startVibration("haptic.clock.timer").then(() => {
2740                    console.log("VibrateTest037 vibrate success");
2741                    expect(true).assertTrue();
2742                    resolve();
2743                }, (error) => {
2744                    expect(false).assertTrue();
2745                    console.log("VibrateTest037 vibrate error");
2746                    reject();
2747                });
2748            })
2749
2750            await promise.then(() => {
2751                return stopPromise();
2752            }, () => {
2753                console.info("VibrateTest037 reject");
2754            })
2755            done();
2756        } else {
2757            console.info('VibrateTest037 vibrator success');
2758            expect(true).assertTrue();
2759            done();
2760        }
2761    })
2762
2763    /*
2764     * @tc.name:VibrateTest038
2765     * @tc.desc:verify app info is not null
2766     * @tc.type: FUNC
2767     * @tc.require: I5SWJI
2768     * @tc.number: VibrateTest038
2769     */
2770    it("VibrateTest038", 0, async function (done) {
2771        if (g_execute) {
2772            function stopPromise() {
2773                return new Promise((resolve, reject) => {
2774                    vibrator.stopVibration("preset", "abc").then(() => {
2775                        console.log("VibrateTest038 off success");
2776                        expect(true).assertTrue();
2777                        setTimeout(() => {
2778                            resolve();
2779                        }, 500);
2780                    }, (error) => {
2781                        expect(false).assertTrue();
2782                        console.log("VibrateTest038 off error");
2783                        setTimeout(() => {
2784                            reject();
2785                        }, 500);
2786                    });
2787                })
2788            }
2789
2790            let promise = new Promise((resolve, reject) => {
2791                vibrator.startVibration("haptic.clock.timer").then(() => {
2792                    console.log("VibrateTest038 vibrate success");
2793                    expect(true).assertTrue();
2794                    resolve();
2795                }, (error) => {
2796                    expect(false).assertTrue();
2797                    console.log("VibrateTest038 vibrate error");
2798                    reject();
2799                });
2800            })
2801
2802            await promise.then(() => {
2803                return stopPromise();
2804            }, () => {
2805                console.info("VibrateTest038 reject");
2806            })
2807            done();
2808        } else {
2809            console.info('VibrateTest038 vibrator success');
2810            expect(true).assertTrue();
2811            done();
2812        }
2813    })
2814
2815    /*
2816     * @tc.name:VibrateTest039
2817     * @tc.desc:verify app info is not null
2818     * @tc.type: FUNC
2819     * @tc.require: I53SGE
2820     * @tc.number: VibrateTest039
2821     */
2822    it("VibrateTest039", 0, async function (done) {
2823        await vibrator.startVibration({
2824            type: "time",
2825            duration: 1000,
2826        }, {
2827            usage: "unknown"
2828        }, undefined).then(() => {
2829            expect(true).assertTrue();
2830        }).catch((error) => {
2831            expect(false).assertTrue();
2832        });
2833        done();
2834    })
2835
2836    /*
2837     * @tc.name:VibrateTest040
2838     * @tc.desc:verify app info is not null
2839     * @tc.type: FUNC
2840     * @tc.require: I53SGE
2841     * @tc.number: VibrateTest040
2842     */
2843    it("VibrateTest040", 0, async function (done) {
2844        await vibrator.startVibration({
2845            type: "time",
2846            duration: 1000,
2847        }, {
2848            usage: "unknown"
2849        }, null).then(() => {
2850            expect(true).assertTrue();
2851        }).catch((error) => {
2852            expect(false).assertTrue();
2853        });
2854        done();
2855    })
2856
2857    /*
2858     * @tc.name:VibrateTest041
2859     * @tc.desc:verify app info is not null
2860     * @tc.type: FUNC
2861     * @tc.require: I53SGE
2862     * @tc.number: VibrateTest041
2863     */
2864    it("VibrateTest041", 0, async function (done) {
2865        await vibrator.startVibration({
2866            type: "time",
2867            duration: 1000,
2868        }, {
2869            usage: "unknown"
2870        }, "abc").then(() => {
2871            expect(true).assertTrue();
2872        }).catch((error) => {
2873            expect(false).assertTrue();
2874        });
2875        done();
2876    })
2877
2878    /*
2879     * @tc.name:VibrateTest042
2880     * @tc.desc:verify app info is not null
2881     * @tc.type: FUNC
2882     * @tc.require: I5SWJI
2883     * @tc.number: VibrateTest042
2884     */
2885    it("VibrateTest042", 0, async function (done) {
2886        function stopPromise() {
2887            return new Promise((resolve, reject) => {
2888                vibrator.stopVibration(undefined).then(() => {
2889                    expect(true).assertTrue();
2890                    resolve();
2891                }, (error) => {
2892                    expect(false).assertTrue();
2893                    reject(error);
2894                });
2895            })
2896        }
2897
2898        let promise = new Promise((resolve, reject) => {
2899            vibrator.vibrate(2000, (error) => {
2900                if (error) {
2901                    expect(false).assertTrue();
2902                    reject(error);
2903                } else {
2904                    expect(true).assertTrue();
2905                    resolve();
2906                }
2907            });
2908        })
2909
2910        await promise.then(() => {
2911            return stopPromise();
2912        }).catch((error) => {
2913            expect(false).assertTrue();
2914        })
2915        done();
2916    })
2917
2918    /*
2919     * @tc.name:VibrateTest043
2920     * @tc.desc:verify app info is not null
2921     * @tc.type: FUNC
2922     * @tc.require: I5SWJI
2923     * @tc.number: VibrateTest043
2924     */
2925    it("VibrateTest043", 0, async function (done) {
2926        function stopPromise() {
2927            return new Promise((resolve, reject) => {
2928                vibrator.stopVibration(null).then(() => {
2929                    expect(true).assertTrue();
2930                    resolve();
2931                }, (error) => {
2932                    expect(false).assertTrue();
2933                    reject(error);
2934                });
2935            })
2936        }
2937
2938        let promise = new Promise((resolve, reject) => {
2939            vibrator.vibrate(2000, (error) => {
2940                if (error) {
2941                    expect(false).assertTrue();
2942                    reject(error);
2943                } else {
2944                    expect(true).assertTrue();
2945                    resolve();
2946                }
2947            });
2948        })
2949
2950        await promise.then(() => {
2951            return stopPromise();
2952        }).catch((error) => {
2953            expect(false).assertTrue();
2954        })
2955        done();
2956    })
2957
2958    /*
2959     * @tc.name:VibrateTest044
2960     * @tc.desc:verify app info is not null
2961     * @tc.type: FUNC
2962     * @tc.require: I5SWJI
2963     * @tc.number: VibrateTest044
2964     */
2965    it("VibrateTest044", 0, async function (done) {
2966        function stopPromise() {
2967            return new Promise((resolve, reject) => {
2968                vibrator.stopVibration(123).then(() => {
2969                    expect(true).assertTrue();
2970                    resolve();
2971                }, (error) => {
2972                    expect(false).assertTrue();
2973                    reject(error);
2974                });
2975            })
2976        }
2977
2978        let promise = new Promise((resolve, reject) => {
2979            vibrator.vibrate(2000, (error) => {
2980                if (error) {
2981                    expect(false).assertTrue();
2982                    reject(error);
2983                } else {
2984                    expect(true).assertTrue();
2985                    resolve();
2986                }
2987            });
2988        })
2989
2990        await promise.then(() => {
2991            return stopPromise();
2992        }).catch((error) => {
2993            expect(false).assertTrue();
2994        })
2995        done();
2996    })
2997
2998    /*
2999     * @tc.name:VibrateTest045
3000     * @tc.desc:verify the isSupportEffect and stopVibration interface
3001     * @tc.type: FUNC
3002     * @tc.require: I6HLLL
3003     * @tc.number: VibrateTest045
3004     */
3005    it("VibrateTest045", 0, async function (done) {
3006        let isSupport = false;
3007
3008        function vibratePromise() {
3009            return new Promise((resolve, reject) => {
3010                if (isSupport) {
3011                    vibrator.startVibration({
3012                        type: "preset",
3013                        effectId: EFFECT_ID,
3014                        count: 1,
3015                    }, {
3016                        usage: "unknown"
3017                    }, (error) => {
3018                        if (error) {
3019                            expect(false).assertTrue();
3020                            reject(error);
3021                        } else {
3022                            expect(true).assertTrue();
3023                            resolve();
3024                        }
3025                    });
3026                } else {
3027                    resolve();
3028                }
3029            })
3030        }
3031
3032        function stopPromise() {
3033            return new Promise((resolve, reject) => {
3034                if (isSupport) {
3035                    vibrator.stopVibration((error) => {
3036                        if (error) {
3037                            expect(false).assertTrue();
3038                            reject(error);
3039                        } else {
3040                            expect(true).assertTrue();
3041                            resolve();
3042                        }
3043                    });
3044                } else {
3045                    resolve();
3046                }
3047            })
3048        }
3049
3050        let isSupportPromise = new Promise((resolve, reject) => {
3051            vibrator.isSupportEffect(EFFECT_ID, undefined).then((state) => {
3052                expect(true).assertTrue();
3053                isSupport = state;
3054                resolve();
3055            }, (error) => {
3056                expect(false).assertTrue();
3057                reject(error);
3058            });
3059        })
3060
3061        await isSupportPromise.then(() => {
3062            return vibratePromise();
3063        }).then(() => {
3064            return stopPromise();
3065        }).catch((error) => {
3066            expect(false).assertTrue();
3067        })
3068        done();
3069    })
3070
3071    /*
3072     * @tc.name:VibrateTest046
3073     * @tc.desc:verify the isSupportEffect and stopVibration interface
3074     * @tc.type: FUNC
3075     * @tc.require: I6HLLL
3076     * @tc.number: VibrateTest046
3077     */
3078    it("VibrateTest046", 0, async function (done) {
3079        let isSupport = false;
3080
3081        function vibratePromise() {
3082            return new Promise((resolve, reject) => {
3083                if (isSupport) {
3084                    vibrator.startVibration({
3085                        type: "preset",
3086                        effectId: EFFECT_ID,
3087                        count: 1,
3088                    }, {
3089                        usage: "unknown"
3090                    }, (error) => {
3091                        if (error) {
3092                            expect(false).assertTrue();
3093                            reject(error);
3094                        } else {
3095                            expect(true).assertTrue();
3096                            resolve();
3097                        }
3098                    });
3099                } else {
3100                    resolve();
3101                }
3102            })
3103        }
3104
3105        function stopPromise() {
3106            return new Promise((resolve, reject) => {
3107                if (isSupport) {
3108                    vibrator.stopVibration((error) => {
3109                        if (error) {
3110                            expect(false).assertTrue();
3111                            reject(error);
3112                        } else {
3113                            expect(true).assertTrue();
3114                            resolve();
3115                        }
3116                    });
3117                } else {
3118                    resolve();
3119                }
3120            })
3121        }
3122
3123        let isSupportPromise = new Promise((resolve, reject) => {
3124            vibrator.isSupportEffect(EFFECT_ID, null).then((state) => {
3125                expect(true).assertTrue();
3126                isSupport = state;
3127                resolve();
3128            }, (error) => {
3129                expect(false).assertTrue();
3130                reject(error);
3131            });
3132        })
3133
3134        await isSupportPromise.then(() => {
3135            return vibratePromise();
3136        }).then(() => {
3137            return stopPromise();
3138        }).catch((error) => {
3139            expect(false).assertTrue();
3140        })
3141        done();
3142    })
3143
3144    /*
3145     * @tc.name:VibrateTest047
3146     * @tc.desc:verify the isSupportEffect and stopVibration interface
3147     * @tc.type: FUNC
3148     * @tc.require: I6HLLL
3149     * @tc.number: VibrateTest047
3150     */
3151    it("VibrateTest047", 0, async function (done) {
3152        let isSupport = false;
3153
3154        function vibratePromise() {
3155            return new Promise((resolve, reject) => {
3156                if (isSupport) {
3157                    vibrator.startVibration({
3158                        type: "preset",
3159                        effectId: EFFECT_ID,
3160                        count: 1,
3161                    }, {
3162                        usage: "unknown"
3163                    }, (error) => {
3164                        if (error) {
3165                            expect(false).assertTrue();
3166                            reject(error);
3167                        } else {
3168                            expect(true).assertTrue();
3169                            resolve();
3170                        }
3171                    });
3172                } else {
3173                    resolve();
3174                }
3175            })
3176        }
3177
3178        function stopPromise() {
3179            return new Promise((resolve, reject) => {
3180                if (isSupport) {
3181                    vibrator.stopVibration((error) => {
3182                        if (error) {
3183                            expect(false).assertTrue();
3184                            reject(error);
3185                        } else {
3186                            expect(true).assertTrue();
3187                            resolve();
3188                        }
3189                    });
3190                } else {
3191                    resolve();
3192                }
3193            })
3194        }
3195
3196        let isSupportPromise = new Promise((resolve, reject) => {
3197            vibrator.isSupportEffect(EFFECT_ID, "abc").then((state) => {
3198                expect(true).assertTrue();
3199                isSupport = state;
3200                resolve();
3201            }, (error) => {
3202                expect(false).assertTrue();
3203                reject(error);
3204            });
3205        })
3206
3207        await isSupportPromise.then(() => {
3208            return vibratePromise();
3209        }).then(() => {
3210            return stopPromise();
3211        }).catch((error) => {
3212            expect(false).assertTrue();
3213        })
3214        done();
3215    })
3216
3217    /*
3218     * @tc.name:VibrateTest048
3219     * @tc.desc:verify the startVibration interface
3220     * @tc.type: FUNC
3221     * @tc.require: I6HLLL
3222     * @tc.number: VibrateTest048
3223     */
3224    it("VibrateTest048", 0, async function (done) {
3225        try {
3226            vibrator.startVibration({
3227                type: "file",
3228                hapticFd: { fd: "" }
3229            }, {
3230                usage: "unknown"
3231            }, (error)=>{
3232                console.info("VibrateTest036 should not in this method");
3233                expect(false).assertTrue();
3234                done();
3235            });
3236        } catch (error) {
3237            expect(error.code).assertEqual(PARAMETER_ERROR_CODE);
3238            done();
3239        }
3240    })
3241
3242    /*
3243     * @tc.name:VibrateTest049
3244     * @tc.desc:verify the isHdHapticSupported interface
3245     * @tc.type: FUNC
3246     * @tc.require: I6HLLL
3247     * @tc.number: VibrateTest049
3248     */
3249    it("VibrateTest049", 0, function () {
3250        try {
3251            expect(typeof(vibrator.isHdHapticSupported())).assertEqual("boolean");
3252        } catch (error) {
3253            console.info("VibrateTest037 exception in, err:" + error);
3254            expect(true).assertEqual(false);
3255        }
3256    })
3257
3258    /*
3259     * @tc.name:VibrateTest050
3260     * @tc.desc:verify the synchronous interface
3261     * @tc.type: FUNC
3262     * @tc.require: I6HLLL
3263     * @tc.number: VibrateTest050
3264     */
3265    it("VibrateTest050", 0, async function () {
3266        console.info("VibrateTest050 in");
3267        await vibrator.startVibration({
3268            type: "time",
3269            duration: 500
3270        }, {
3271            usage: "alarm"
3272        }, (error) => {
3273            if (error) {
3274                console.info("startVibration error: " + JSON.stringify(error));
3275                expect(false).assertTrue();
3276            } else {
3277                console.info("startVibration success");
3278                expect(true).assertTrue();
3279            }
3280            done();
3281        });
3282        try {
3283            vibrator.stopVibrationSync();
3284            console.info("stopVibrationSync success");
3285            expect(true).assertTrue();
3286        } catch (error) {
3287            console.info("stopVibrationSync error: " + JSON.stringify(error));
3288            expect(false).assertTrue();
3289        }
3290        console.info("VibrateTest050 end");
3291    })
3292
3293    /*
3294     * @tc.name:VibrateTest051
3295     * @tc.desc:verify the synchronous interface
3296     * @tc.type: FUNC
3297     * @tc.require: I6HLLL
3298     * @tc.number: VibrateTest051
3299     */
3300    it("VibrateTest051", 0, async function () {
3301        console.info("VibrateTest051 in");
3302        try {
3303            let ret = vibrator.isSupportEffectSync(INVALID_EFFECT_ID);
3304            expect(ret).assertEqual(false);
3305        } catch (error) {
3306            console.info("isSupportEffectSync error: " + JSON.stringify(error));
3307            expect(false).assertTrue();
3308        }
3309        console.info("VibrateTest051 end");
3310    })
3311})
3312