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 */
15
16import reminderAgent from '@ohos.reminderAgentManager';
17
18
19import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index'
20
21describe("ReminderHelperTest", function () {
22    beforeAll(function() {
23
24        /*
25         * @tc.setup: setup invoked before all testcases
26         */
27        console.info('beforeAll caled')
28    })
29
30    afterAll(function() {
31
32        /*
33         * @tc.teardown: teardown invoked after all testcases
34         */
35        console.info('afterAll caled')
36    })
37
38    beforeEach(function() {
39
40        /*
41         * @tc.setup: setup invoked before each testcases
42         */
43        console.info('beforeEach caled')
44    })
45
46    afterEach(function() {
47
48        /*
49         * @tc.teardown: teardown invoked after each testcases
50         */
51        console.info('afterEach caled')
52        reminderAgent.cancelAllReminders();
53    })
54
55    /*
56     * @tc.name: testReminderHelper001
57     * @tc.desc: test spent time by publishReminder with timer (callback)
58     * @tc.type: FUNC
59     * @tc.require:
60     */
61    it("testReminderHelper001", 0, async function (done) {
62        let timer = {
63            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
64            triggerTimeInSeconds: 3
65        }
66        function reminderCallback(err, reminderId){
67            let end = getTime();
68            let times = end - begin;
69            if (times < 500) {
70                expect(true).assertTrue();
71            } else {
72                expect(false).assertTrue();
73            }
74            setTimeout(() => {
75                done();
76            }, 500);
77        }
78        function getTime(){
79            var time = new Date();
80            var Milliseconds = time.getTime();
81            return Milliseconds;
82        }
83        let begin = getTime();
84        try {
85            reminderAgent.publishReminder(timer, reminderCallback)
86        } catch (e) {
87            expect(false).assertTrue();
88        };
89    })
90
91    /*
92    * @tc.name: testReminderHelper002
93    * @tc.desc: test spent time by publishReminder with timer (promise)
94    * @tc.type: FUNC
95    * @tc.require:
96    */
97    it("testReminderHelper002", 0, async function (done) {
98        let timer = {
99            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
100            triggerTimeInSeconds: 3
101        }
102        function getTime(){
103            var time = new Date();
104            var Milliseconds = time.getTime();
105            return Milliseconds;
106        }
107        let begin = getTime();
108        try {
109            reminderAgent.publishReminder(timer).then((reminderId) => {
110                let end = getTime();
111                let times = end - begin;
112                if (times < 50) {
113                    expect(true).assertTrue();
114                } else {
115                    expect(false).assertTrue();
116                }
117            });
118        } catch (e) {
119            expect(false).assertTrue();
120        };
121        setTimeout(() => {
122            done();
123        }, 500);
124    })
125
126    /*
127     * @tc.name: testReminderHelper003
128     * @tc.desc: test spent time by publishReminder with alarm (callback)
129     * @tc.type: FUNC
130     * @tc.require:
131     */
132    it("testReminderHelper003", 0, async function (done) {
133        let alarm = {
134            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
135            hour: 21,
136            minute: 14,
137            title: "this is title",
138            content: "this is content"
139        }
140        function reminderCallback(err, reminderId){
141            let end = getTime();
142            times = end - begin;
143            if (times < 50) {
144                expect(true).assertTrue();
145            } else {
146                expect(false).assertTrue();
147            }
148            setTimeout(() => {
149                done();
150            }, 500);
151        }
152        function getTime(){
153            var time = new Date();
154            var Milliseconds = time.getTime();
155            return Milliseconds;
156        }
157        let times = 0;
158        let begin = getTime();
159        try {
160            reminderAgent.publishReminder(alarm, reminderCallback)
161        } catch (e) {
162            expect(false).assertTrue();
163        };
164    })
165
166    /*
167    * @tc.name: testReminderHelper004
168    * @tc.desc: test spent time by publishReminder with alarm (promise)
169    * @tc.type: FUNC
170    * @tc.require:
171    */
172
173    it("testReminderHelper004", 0, async function (done) {
174        let alarm = {
175            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
176            hour: 21,
177            minute: 14,
178            title: "this is title",
179            content: "this is content"
180        }
181        function getTime(){
182            var time = new Date();
183            var Milliseconds = time.getTime();
184            return Milliseconds;
185        }
186        let begin = getTime();
187        try {
188            reminderAgent.publishReminder(alarm).then((reminderId) => {
189                let end = getTime();
190                let times = end - begin;
191                if (times < 50) {
192                    expect(true).assertTrue();
193                } else {
194                    expect(false).assertTrue();
195                }
196            });
197        } catch (e) {
198            expect(false).assertTrue();
199        };
200        setTimeout(() => {
201            done();
202        }, 500);
203    })
204
205    /*
206     * @tc.name: testReminderHelper005
207     * @tc.desc: test spent time by publishReminder with calendar (callback)
208     * @tc.type: FUNC
209     * @tc.require:
210     */
211    it("testReminderHelper005", 0, async function (done) {
212        let calendar = {
213            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
214            dateTime : {
215                year: 2025,
216                month: 10,
217                day: 10,
218                hour: 23,
219                minute: 30
220            }
221        }
222        function reminderCallback(err, reminderId){
223            let end = getTime();
224            times = end - begin;
225            if (times < 50) {
226                expect(true).assertTrue();
227            } else {
228                expect(false).assertTrue();
229            }
230            setTimeout(() => {
231                done();
232            }, 500);
233        }
234        function getTime(){
235            var time = new Date();
236            var Milliseconds = time.getTime();
237            return Milliseconds;
238        }
239        let begin = getTime();
240        let times = 0;
241        try {
242            reminderAgent.publishReminder(calendar, reminderCallback)
243        } catch (e) {
244            expect(false).assertTrue();
245        };
246    })
247
248    /*
249     * @tc.name: testReminderHelper006
250     * @tc.desc: test spent time by publishReminder with calendar (promise)
251     * @tc.type: FUNC
252     * @tc.require:
253     */
254    it("testReminderHelper006", 0, async function (done) {
255        let calendar = {
256            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
257            dateTime : {
258                year: 2025,
259                month: 10,
260                day: 10,
261                hour: 23,
262                minute: 30
263            }
264        }
265        function getTime(){
266            var time = new Date();
267            var Milliseconds = time.getTime();
268            return Milliseconds;
269        }
270        let begin = getTime();
271        try {
272            reminderAgent.publishReminder(calendar).then((reminderId) => {
273                let end = getTime();
274                let times = end - begin;
275                if (times < 50) {
276                    expect(true).assertTrue();
277                } else {
278                    expect(false).assertTrue();
279                }
280            })
281        } catch (e) {
282            expect(false).assertTrue();
283        };
284        setTimeout(() => {
285            done();
286        }, 500);
287    })
288
289    /*
290     * @tc.name: testReminderHelper007
291     * @tc.desc: test spent time by cancelReminder with not reminderId (callback)
292     * @tc.type: FUNC
293     * @tc.require:
294     */
295    it("testReminderHelper007", 0, async function (done) {
296        function reminderCallback(err, data){
297            let end = getTime();
298            times = end - begin;
299            if (times < 50) {
300                expect(true).assertTrue();
301            } else {
302                expect(false).assertTrue();
303            }
304            setTimeout(() => {
305                done();
306            }, 500);
307        }
308        function getTime(){
309            var time = new Date();
310            var Milliseconds = time.getTime();
311            return Milliseconds;
312        }
313        let begin = getTime();
314        let times = 0;
315        try {
316            reminderAgent.cancelReminder(1, reminderCallback)
317        } catch (e) {
318            expect(false).assertTrue();
319        };
320    })
321
322    /*
323     * @tc.name: testReminderHelper008
324     * @tc.desc: test spent time by cancelReminder with not reminderId (promise)
325     * @tc.type: FUNC
326     * @tc.require:
327     */
328    it("testReminderHelper008", 0, async function (done) {
329        function getTime(){
330            var time = new Date();
331            var Milliseconds = time.getTime();
332            return Milliseconds;
333        }
334        let begin = getTime();
335        try {
336            reminderAgent.cancelReminder(1).then(() => {
337                let end = getTime();
338                let times = end - begin;
339                if (times < 50) {
340                    expect(true).assertTrue();
341                } else {
342                    expect(false).assertTrue();
343                }
344            })
345        } catch (e) {
346            expect(false).assertTrue();
347        };
348        setTimeout(() => {
349            done();
350        }, 500);
351    })
352
353    /*
354     * @tc.name: testReminderHelper009
355     * @tc.desc: test spent time by cancelReminder with timer (callback)
356     * @tc.type: FUNC
357     * @tc.require:
358     */
359    it("testReminderHelper009", 0, async function (done) {
360        let timer = {
361            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
362            triggerTimeInSeconds: 3
363        }
364        function reminderCallback(err, data){
365            let end = getTime();
366            times = end - begin;
367            if (times < 50) {
368                expect(true).assertTrue();
369            } else {
370                expect(false).assertTrue();
371            }
372            setTimeout(() => {
373                done();
374            }, 500);
375        }
376        function getTime(){
377            var time = new Date();
378            var Milliseconds = time.getTime();
379            return Milliseconds;
380        }
381        let begin = 0;
382        let times = 0;
383        try {
384            reminderAgent.publishReminder(timer, (err, reminderId) => {
385                begin = getTime();
386                try {
387                    reminderAgent.cancelReminder(reminderId, reminderCallback);
388                } catch (e) {
389                    expect(false).assertTrue();
390                };
391            })
392        } catch (e) {
393            expect(false).assertTrue();
394        };
395    })
396
397    /*
398     * @tc.name: testReminderHelper010
399     * @tc.desc: test spent time by cancelReminder with calendar (promise)
400     * @tc.type: FUNC
401     * @tc.require:
402     */
403    it("testReminderHelper010", 0, async function (done) {
404        let calendar = {
405            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
406            dateTime : {
407                year: 2025,
408                month: 10,
409                day: 10,
410                hour: 23,
411                minute: 30
412            }
413        }
414        function getTime(){
415            var time = new Date();
416            var Milliseconds = time.getTime();
417            return Milliseconds;
418        }
419        let begin = 0;
420        let times = 0;
421        try {
422            reminderAgent.publishReminder(calendar, (err, reminderId) => {
423                begin = getTime();
424                try {
425                    reminderAgent.cancelReminder(reminderId).then(() => {
426                        let end = getTime();
427                        times = end - begin;
428                        if (times < 50) {
429                            expect(true).assertTrue();
430                        } else {
431                            expect(false).assertTrue();
432                        }
433                    })
434                } catch (e) {
435                    expect(false).assertTrue();
436                };
437
438            })
439        } catch (e) {
440            expect(false).assertTrue();
441        };
442        setTimeout(() => {
443            done();
444        }, 500);
445    })
446
447    /*
448     * @tc.name: testReminderHelper011
449     * @tc.desc: test spent time by getValidReminders with not (callback)
450     * @tc.type: FUNC
451     * @tc.require:
452     */
453    it("testReminderHelper011", 0, async function (done) {
454        function reminderCallback(err, reminders){
455            let end = getTime();
456            times = end - begin;
457            if (times < 50) {
458                expect(true).assertTrue();
459            } else {
460                expect(false).assertTrue();
461            }
462            setTimeout(() => {
463                done();
464            }, 500);
465        }
466        function getTime(){
467            var time = new Date();
468            var Milliseconds = time.getTime();
469            return Milliseconds;
470        }
471        let begin = getTime();
472        let times = 0;
473        try {
474            reminderAgent.getValidReminders(reminderCallback)
475        } catch (e) {
476            expect(false).assertTrue();
477        };
478    })
479
480    /*
481     * @tc.name: testReminderHelper012
482     * @tc.desc: test spent time by getValidReminders with not (promise)
483     * @tc.type: FUNC
484     * @tc.require:
485     */
486    it("testReminderHelper012", 0, async function (done) {
487        function getTime(){
488            var time = new Date();
489            var Milliseconds = time.getTime();
490            return Milliseconds;
491        }
492        let begin = getTime();
493        try {
494            reminderAgent.getValidReminders().then((reminders) => {
495                let end = getTime();
496                let times = end - begin;
497                if (times < 50) {
498                    expect(true).assertTrue();
499                } else {
500                    expect(false).assertTrue();
501                }
502            })
503        } catch (e) {
504            expect(false).assertTrue();
505        };
506        setTimeout(() => {
507            done();
508        }, 500);
509    })
510
511
512    /*
513     * @tc.name: testReminderHelper013
514     * @tc.desc: test spent time by cancelAllReminders (callback)
515     * @tc.type: FUNC
516     * @tc.require:
517     */
518    it("testReminderHelper013", 0, async function (done) {
519        function reminderCallback(err, data){
520            let end = getTime();
521            times = end - begin;
522            if (times < 50) {
523                expect(true).assertTrue();
524            } else {
525                expect(false).assertTrue();
526            }
527            setTimeout(() => {
528                done();
529            }, 500);
530        }
531        function getTime(){
532            var time = new Date();
533            var Milliseconds = time.getTime();
534            return Milliseconds;
535        }
536        let begin = getTime();
537        let times = 0;
538        try {
539            reminderAgent.cancelAllReminders(reminderCallback)
540        } catch (e) {
541            expect(false).assertTrue();
542        };
543    })
544
545    /*
546     * @tc.name: testReminderHelper014
547     * @tc.desc: test spent time by cancelAllReminders (promise)
548     * @tc.type: FUNC
549     * @tc.require:
550     */
551    it("testReminderHelper014", 0, async function (done) {
552        function getTime(){
553            var time = new Date();
554            var Milliseconds = time.getTime();
555            return Milliseconds;
556        }
557        let begin = getTime();
558        try {
559            reminderAgent.cancelAllReminders().then(() => {
560                let end = getTime();
561                let times = end - begin;
562                if (times < 50) {
563                    expect(true).assertTrue();
564                } else {
565                    expect(false).assertTrue();
566                }
567            })
568        } catch (e) {
569            expect(false).assertTrue();
570        };
571        setTimeout(() => {
572            done();
573        }, 500);
574    })
575
576    /*
577     * @tc.name: testReminderHelper015
578     * @tc.desc: test spent time by addNotificationSlot (callback)
579     * @tc.type: FUNC
580     * @tc.require:
581     */
582    it("testReminderHelper015", 0, async function (done) {
583        function reminderCallback(err, data){
584            let end = getTime();
585            times = end - begin;
586            if (times < 50) {
587                expect(true).assertTrue();
588            } else {
589                expect(false).assertTrue();
590            }
591            setTimeout(() => {
592                done();
593            }, 500);
594        }
595        function getTime(){
596            var time = new Date();
597            var Milliseconds = time.getTime();
598            return Milliseconds;
599        }
600        let begin = getTime();
601        let times = 0;
602        try {
603            reminderAgent.addNotificationSlot(1, reminderCallback)
604        } catch (e) {
605            expect(true).assertTrue();
606        };
607        done();
608    })
609
610    /*
611     * @tc.name: testReminderHelper016
612     * @tc.desc: test spent time by addNotificationSlot (promise)
613     * @tc.type: FUNC
614     * @tc.require:
615     */
616    it("testReminderHelper016", 0, async function (done) {
617        function getTime(){
618            var time = new Date();
619            var Milliseconds = time.getTime();
620            return Milliseconds;
621        }
622        let begin = getTime();
623        try {
624            reminderAgent.addNotificationSlot(1).then(() => {
625                let end = getTime();
626                let times = end - begin;
627                if (times < 50) {
628                    expect(true).assertTrue();
629                } else {
630                    expect(false).assertTrue();
631                }
632            })
633        } catch (e) {
634            expect(true).assertTrue();
635        };
636
637        setTimeout(() => {
638            done();
639        }, 500);
640    })
641
642    /*
643     * @tc.name: testReminderHelper017
644     * @tc.desc: test spent time by removeNotificationSlot (callback)
645     * @tc.type: FUNC
646     * @tc.require:
647     */
648    it("testReminderHelper017", 0, async function (done) {
649        var tarRemoveSlot = {
650            type: 1
651        }
652        function reminderCallback(err, data){
653            let end = getTime();
654            times = end - begin;
655            if (times < 50) {
656                expect(true).assertTrue();
657            } else {
658                expect(false).assertTrue();
659            }
660            setTimeout(() => {
661                done();
662            }, 500);
663        }
664        function getTime(){
665            var time = new Date();
666            var Milliseconds = time.getTime();
667            return Milliseconds;
668        }
669        let begin = getTime();
670        let times = 0;
671        try {
672            reminderAgent.addNotificationSlot(tarRemoveSlot.type, (err, data) => {
673                begin = getTime();
674                reminderAgent.removeNotificationSlot(1, reminderCallback)
675            });
676        } catch (e) {
677            expect(true).assertTrue();
678        };
679        done();
680    })
681
682    /*
683     * @tc.name: testReminderHelper018
684     * @tc.desc: test spent time by cancelAllReminders (promise)
685     * @tc.type: FUNC
686     * @tc.require:
687     */
688    it("testReminderHelper018", 0, async function (done) {
689        var tarRemoveSlot = {
690            type: 1
691        }
692        function getTime(){
693            var time = new Date();
694            var Milliseconds = time.getTime();
695            return Milliseconds;
696        }
697        try {
698            reminderAgent.addNotificationSlot(tarRemoveSlot.type, (err, data) => {
699                let begin = getTime();
700                reminderAgent.removeNotificationSlot(tarRemoveSlot.type).then(() => {
701                    let end = getTime();
702                    let times = end - begin;
703                    if (times < 50) {
704                        expect(true).assertTrue();
705                    } else {
706                        expect(false).assertTrue();
707                    }
708                })
709            });
710        } catch (e) {
711            expect(true).assertTrue();
712        };
713
714        setTimeout(() => {
715            done();
716        }, 500);
717    })
718
719    /*
720     * @tc.name: testReminderHelper019
721     * @tc.desc: test publishReminder can return correct reminder id.
722     * @tc.type: FUNC
723     * @tc.require: SR000GGTRB AR000GH8EH AR000GH8E9 AR00GH8EH
724     */
725    it("testReminderHelper019", 0, async function (done) {
726        let timer = {
727            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
728            triggerTimeInSeconds: 100
729        }
730        let expectId = -1;
731        try {
732            reminderAgent.publishReminder(timer).then((reminderId) => {
733                expectId = reminderId + 1;
734                try {
735                    reminderAgent.publishReminder(timer).then((reminderId) => {
736                        if (reminderId === expectId){
737                            expect(true).assertTrue();
738                            setTimeout(() => {
739                                done();
740                            }, 500);
741                        }
742                    }, (error) => {
743                        expect(false).assertTrue();
744                        setTimeout(() => {
745                            done();
746                        }, 500);
747                    });
748                } catch (e) {
749                    expect(false).assertTrue();
750                };
751
752            });
753        } catch (e) {
754            expect(false).assertTrue();
755        };
756    })
757
758    /*
759     * @tc.name: testReminderHelper020
760     * @tc.desc: test publishReminder can return correct reminder id.
761     * @tc.type: FUNC
762     * @tc.require: SR000GGTRB AR000GH8EH AR000GH8E9 AR00GH8EH
763     */
764    it("testReminderHelper020", 0, async function (done) {
765        let timer = {
766            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
767            triggerTimeInSeconds: 100
768        }
769        let expectId = -1;
770        function reminderCallback(err, reminderId) {
771            expect(reminderId).assertEqual(expectId);
772        }
773        try {
774            reminderAgent.publishReminder(timer, (err, reminderId) => {
775                expectId = reminderId + 1;
776                try {
777                    reminderAgent.publishReminder(timer, reminderCallback);
778                } catch (e) {
779                    expect(false).assertTrue();
780                };
781            })
782        } catch (e) {
783            expect(false).assertTrue();
784        };
785        done();
786    })
787
788    /*
789     * @tc.name: testReminderHelper021
790     * @tc.desc: test addNotificationSlot instance with null
791     * @tc.type: FUNC
792     * @tc.require: SR000GGTRB AR000GH8EC
793     */
794    it("testReminderHelper021", 0, async function (done) {
795        function reminderCallback(err, data){
796            expect(true).assertEqual(true);
797        }
798        try {
799            reminderAgent.addNotificationSlot(0, reminderCallback);
800        } catch (e) {
801            expect(true).assertTrue();
802        };
803        done();
804    })
805
806    /*
807     * @tc.name: testReminderHelper022
808     * @tc.desc: test addNotificationSlot instance with null
809     * @tc.type: FUNC
810     * @tc.require: SR000GGTRB AR000GH8EC
811     */
812    it("testReminderHelper022", 0, async function (done) {
813        let mySlot = null;
814        let promise = new Promise((resolve, reject) => {
815            try {
816                reminderAgent.addNotificationSlot(mySlot).then(() => {
817                    resolve();
818                })
819            } catch (e) {
820                expect(true).assertTrue();
821            };
822            reject(new Error('errr occurred.'));
823        });
824        promise.then(() => {
825        }, err => {
826            let i = 0;
827            expect(0).assertEqual(i);
828        }).catch(res => {});
829        done();
830    })
831
832    /*
833     * @tc.name: testReminderHelper023
834     * @tc.desc: test addNotificationSlot with normal value
835     * @tc.type: FUNC
836     * @tc.require: SR000GGTRB AR000GH8EC
837     */
838    it("testReminderHelper023", 0, async function (done) {
839        let mySlot = {
840            type: 2
841        }
842        try {
843            reminderAgent.addNotificationSlot(mySlot).then(() => {
844                let i = 0;
845                expect(i).assertEqual(0);
846            });
847        } catch (e) {
848            expect(true).assertTrue();
849        };
850        done();
851    })
852
853    /*
854     * @tc.name: testReminderHelper024
855     * @tc.desc: test addNotificationSlot with normal value
856     * @tc.type: FUNC
857     * @tc.require: SR000GGTRB AR000GH8EC
858     */
859    it("testReminderHelper024", 0, async function (done) {
860        try {
861            reminderAgent.addNotificationSlot(3, (err, data) => {
862                let i = 0;
863                expect(i).assertEqual(0);
864            });
865        } catch (e) {
866            expect(true).assertTrue();
867        };
868        done();
869    })
870
871    /*
872     * @tc.name: testReminderHelper025
873     * @tc.desc: test cancelAllReminders can cancel all exist reminders
874     * @tc.type: FUNC
875     * @tc.require: SR000GGTRB AR000GH8EA
876     */
877    it("testReminderHelper025", 0, async function (done) {
878        let timer = {
879            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
880            triggerTimeInSeconds: 100
881        }
882        let calendar = {
883            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
884            dateTime : {
885                year: 2025,
886                month: 10,
887                day: 10,
888                hour: 23,
889                minute: 30
890            }
891        }
892        try {
893            reminderAgent.publishReminder(timer).then((reminderId) => {});
894            reminderAgent.publishReminder(calendar).then((reminderId) => {});
895            setTimeout(() => {
896                reminderAgent.cancelAllReminders().then(() => {
897                    reminderAgent.getValidReminders().then((reminders) => {
898                        expect(reminders.length === 0).assertEqual(true);
899                    });
900                });
901            }, 5000);
902        } catch (e) {
903            expect(false).assertTrue();
904        };
905        done();
906    })
907
908    /*
909     * @tc.name: testReminderHelper026
910     * @tc.desc: test cancelAllReminders can cancel all exist reminders
911     * @tc.type: FUNC
912     * @tc.require: SR000GGTRB AR000GH8EA AR000GH8EF AR000GH8EI
913     */
914    it("testReminderHelper026", 0, async function (done) {
915        let timer = {
916            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
917            triggerTimeInSeconds: 100
918        }
919        let calendar = {
920            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
921            dateTime : {
922                year: 2025,
923                month: 10,
924                day: 10,
925                hour: 23,
926                minute: 30
927            }
928        }
929        try {
930            reminderAgent.publishReminder(timer).then((reminderId) => {});
931            reminderAgent.publishReminder(calendar).then((reminderId) => {});
932            setTimeout(() => {
933                reminderAgent.cancelAllReminders((err, data) => {
934                    reminderAgent.getValidReminders().then((reminders) => {
935                        expect(reminders.length === 0).assertEqual(true);
936                    });
937                });
938            }, 5000);
939        } catch (e) {
940            expect(false).assertTrue();
941        };
942
943        done();
944    })
945
946    /*
947     * @tc.name: testReminderHelper027
948     * @tc.desc: test cancelReminder with not exit reminder.
949     * @tc.type: FUNC
950     * @tc.require: SR000GGTRB AR000GH8EA
951     */
952    it("testReminderHelper027", 0, async function (done) {
953        let timer = {
954            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
955            triggerTimeInSeconds: 3
956        }
957        let publishlength = -1;
958        let cancellength = -1;
959        let firstdiff = -1;
960        try {
961            reminderAgent.publishReminder(timer).then(() => {
962                reminderAgent.getValidReminders().then((reminders) => {
963                    publishlength=reminders.length
964                    reminderAgent.cancelReminder(0).then(() => {
965                        reminderAgent.getValidReminders().then((reminders) => {
966                            cancellength = reminders.length
967                            firstdiff = publishlength - cancellength;
968                            expect(0).assertEqual(firstdiff);
969                        });
970                    });
971                });
972            });
973        } catch (e) {
974            expect(true).assertTrue();
975        };
976        done();
977    })
978
979    /*
980     * @tc.name: testReminderHelper028
981     * @tc.desc: test cancelReminder with not exit reminder.
982     * @tc.type: FUNC
983     * @tc.require: SR000GGTRB AR000GH8EA
984     */
985    it("testReminderHelper028", 0, async function (done) {
986        let timer = {
987            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
988            triggerTimeInSeconds: 3
989        }
990        let publishlength = -1;
991        let cancellength = -1;
992        let firstdiff = -1;
993        try {
994            reminderAgent.publishReminder(timer).then(() => {
995                reminderAgent.getValidReminders((err, reminders) => {
996                    publishlength = reminders.length;
997                    reminderAgent.cancelReminder(0, (err, data)=>{
998                        reminderAgent.getValidReminders((err, reminders) => {
999                            cancellength = reminders.length;
1000                            firstdiff = publishlength - cancellength;
1001                            expect(0).assertEqual(firstdiff);
1002                        });
1003                    });
1004                });
1005            });
1006        } catch (e) {
1007            expect(true).assertTrue();
1008        };
1009        done();
1010    })
1011
1012        /*
1013     * @tc.name: testReminderHelper029
1014     * @tc.desc: test cancelReminder with exist reminder.
1015     * @tc.type: FUNC
1016     * @tc.require: SR000GGTRB AR000GH8EA
1017     */
1018    it("testReminderHelper029", 0, async function (done) {
1019        let alarm = {
1020            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1021            hour: 21,
1022            minute: 14,
1023            title: "this is title",
1024            content: "this is content"
1025        }
1026        let publishlength = -1;
1027        let cancellength = -1;
1028        let firstdiff = -1;
1029        try {
1030            reminderAgent.publishReminder(alarm, (err, reminderId) => {
1031                reminderAgent.getValidReminders((err, reminders) => {
1032                    publishlength = reminders.length;
1033                });
1034                setTimeout(() => {
1035                    reminderAgent.cancelReminder(reminderId, (err, data) => {
1036                        reminderAgent.getValidReminders((err, reminders) => {
1037                            cancellength = reminders.length;
1038                            firstdiff = publishlength - cancellength;
1039                            if (firstdiff === 0 || firstdiff === 1) {
1040                                expect(0).assertEqual(firstdiff);
1041                            }
1042                        });
1043                    });
1044                }, 1000);
1045            });
1046        } catch (e) {
1047            expect(false).assertTrue();
1048        };
1049
1050        done();
1051    })
1052
1053    /*
1054     * @tc.name: testReminderHelper030
1055     * @tc.desc: test cancelReminder with exist reminder.
1056     * @tc.type: FUNC
1057     * @tc.require: SR000GGTRB AR000GH8EA
1058     */
1059    it("testReminderHelper030", 0, async function (done) {
1060        let alarm = {
1061            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1062            hour: 21,
1063            minute: 14,
1064            title: "this is title",
1065            content: "this is content"
1066        }
1067        let publishlength = -1;
1068        let cancellength = -1;
1069        let firstdiff = -1;
1070        try {
1071            reminderAgent.publishReminder(alarm, (err, reminderId) => {
1072                reminderAgent.getValidReminders((err, reminders) => {
1073                    publishlength = reminders.length;
1074                });
1075                setTimeout(() => {
1076                    reminderAgent.cancelReminder(reminderId).then(() => {
1077                        reminderAgent.getValidReminders((err, reminders) => {
1078                            cancellength = reminders.length;
1079                            firstdiff = publishlength - cancellength;
1080                            if (firstdiff === 0 || firstdiff === 1) {
1081                                expect(0).assertEqual(firstdiff);
1082                            }
1083                        });
1084                    });
1085                }, 1000);
1086            });
1087        } catch (e) {
1088            expect(false).assertTrue();
1089        };
1090
1091        done();
1092    })
1093
1094    /*
1095     * @tc.name: testReminderHelper031
1096     * @tc.desc: test getValidReminders, verify all the information is correct.
1097     * @tc.type: FUNC
1098     * @tc.require: SR000GGTRB AR000GH8EB AR000GH8EF
1099     */
1100    it("testReminderHelper031", 0, async function (done) {
1101        var alarm = {
1102            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1103            hour: 21,
1104            minute: 14,
1105            title: "this is title",
1106            content: "this is content"
1107        }
1108        var timer = {
1109            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
1110            triggerTimeInSeconds: 100
1111        }
1112        try {
1113            reminderAgent.cancelAllReminders((err, data) => {
1114                reminderAgent.publishReminder(timer, (error, reminderId) => {});
1115                reminderAgent.publishReminder(alarm, (error, reminderId) => {});
1116                setTimeout(() => {
1117                    reminderAgent.getValidReminders().then((reminders) => {
1118                        expect(reminders.length).assertEqual(2);
1119                    });
1120                }, 1000);
1121            })
1122        } catch (e) {
1123            expect(false).assertTrue();
1124        };
1125        done();
1126    })
1127
1128    /*
1129     * @tc.name: testReminderHelper032
1130     * @tc.desc: test getValidReminders, verify all the information is correct.
1131     * @tc.type: FUNC
1132     * @tc.require: SR000GGTRB AR000GH8EB
1133     */
1134    it("testReminderHelper032", 0, async function (done) {
1135        var alarm = {
1136            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1137            hour: 21,
1138            minute: 14,
1139            title: "this is title",
1140            content: "this is content"
1141        }
1142        var timer = {
1143            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
1144            triggerTimeInSeconds: 100
1145        }
1146        try {
1147            reminderAgent.cancelAllReminders((err, data) => {
1148                reminderAgent.publishReminder(timer, (error, reminderId) => {});
1149                reminderAgent.publishReminder(alarm, (error, reminderId) => {});
1150                setTimeout(() => {
1151                    reminderAgent.getValidReminders((err, reminders) => {
1152                        expect(reminders.length).assertEqual(2);
1153                    });
1154                }, 1000);
1155            })
1156        } catch (e) {
1157            expect(false).assertTrue();
1158        };
1159
1160        done();
1161    })
1162
1163    /*
1164     * @tc.name: testReminderHelper033
1165     * @tc.desc: test removeNotificationSlot with not exist slot.
1166     * @tc.type: FUNC
1167     * @tc.require: SR000GGTRB AR000GH8ED
1168     */
1169    it("testReminderHelper033", 0, function (done) {
1170        function reminderCallback(err, data){
1171            let i = 0;
1172            expect(0).assertEqual(i);
1173        }
1174        try {
1175            reminderAgent.removeNotificationSlot(0, reminderCallback);
1176        } catch (e) {
1177            expect(true).assertTrue();
1178        };
1179        done();
1180    })
1181
1182    /*
1183     * @tc.name: testReminderHelper034
1184     * @tc.desc: test removeNotificationSlot with not exist slot.
1185     * @tc.type: FUNC
1186     * @tc.require: SR000GGTRB AR000GH8ED
1187     */
1188    it("testReminderHelper034", 0, function (done) {
1189       let promise = new Promise((resolve, reject) => {
1190            try {
1191                reminderAgent.removeNotificationSlot(1).then(() => {
1192                    resolve();
1193                });
1194            } catch (e) {
1195                expect(true).assertTrue();
1196            };
1197           reject(new Error('errr occurred.'));
1198       });
1199       promise.then(() => {
1200       }, err => {
1201           let i = 0;
1202           expect(0).assertEqual(i);
1203       }).catch(res => {});
1204       done();
1205    })
1206
1207    /*
1208     * @tc.name: testReminderHelper035
1209     * @tc.desc: test removeNotificationSlot with exist slot.
1210     * @tc.type: FUNC
1211     * @tc.require: SR000GGTRB AR000GH8ED
1212     */
1213    it("testReminderHelper035", 0, async function (done) {
1214        var tarRemoveSlot = {
1215            type: 1
1216        }
1217        try {
1218            reminderAgent.addNotificationSlot(tarRemoveSlot.type, (err, data) => {
1219                reminderAgent.removeNotificationSlot(tarRemoveSlot.type, (err, data) => {
1220                    expect(0).assertEqual(err.code);
1221                });
1222            });
1223        } catch (e) {
1224            expect(true).assertTrue();
1225        };
1226
1227        done();
1228    })
1229
1230    /*
1231     * @tc.name: testReminderHelper036
1232     * @tc.desc: test removeNotificationSlot with exist slot.
1233     * @tc.type: FUNC
1234     * @tc.require: SR000GGTRB AR000GH8ED
1235     */
1236    it("testReminderHelper036", 0, async function (done) {
1237        var tarRemoveSlot = {
1238            type: 1
1239        }
1240        try {
1241            reminderAgent.addNotificationSlot(tarRemoveSlot.type, (err, data) => {
1242                reminderAgent.removeNotificationSlot(tarRemoveSlot.type).then(() => {
1243                    let i = 0;
1244                    expect(0).assertEqual(i);
1245                });
1246            });
1247        } catch (e) {
1248            expect(true).assertTrue();
1249        };
1250
1251        done();
1252    })
1253
1254    /*
1255     * @tc.name: testReminderHelper037
1256     * @tc.desc: test getValidReminders.
1257     * @tc.type: FUNC
1258     * @tc.require: SR000GGTRB AR000GH8EB AR000GH8EG
1259     */
1260    it("testReminderHelper037", 0, async function (done) {
1261        let timer = {
1262            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
1263            triggerTimeInSeconds: 3
1264        }
1265        try {
1266            reminderAgent.publishReminder(timer).then((reminderId) => { });
1267            setTimeout(() => {
1268                reminderAgent.getValidReminders().then((reminders) => {
1269                    expect(reminders.length === 0).assertEqual(true);
1270                });
1271            }, 5000);
1272        } catch (e) {
1273            expect(false).assertTrue();
1274        };
1275        done();
1276    })
1277
1278    /*
1279     * @tc.name:testReminderHelper038
1280     * @tc.desc: test getValidReminders.
1281     * @tc.type: FUNC
1282     * @tc.require: SR000GGTRB AR000GH8EB AR000GH8EG
1283     */
1284    it("testReminderHelper038", 0, async function (done) {
1285        let timer = {
1286            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
1287            triggerTimeInSeconds: 3
1288        }
1289        try {
1290            reminderAgent.publishReminder(timer, (err, data) => { });
1291            setTimeout(() => {
1292                reminderAgent.getValidReminders((err, reminders) => {
1293                    expect(reminders.length === 0).assertEqual(true);
1294                });
1295            }, 5000);
1296        } catch (e) {
1297            expect(false).assertTrue();
1298        };
1299
1300        done();
1301    })
1302
1303    /*
1304     * @tc.name: testReminderHelper039
1305     * @tc.desc: test publishReminder a normal alarm.
1306     * @tc.type: FUNC
1307     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH
1308     */
1309    it("testReminderHelper039", 0, async function (done) {
1310        let alarm = {
1311            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1312            hour: 21,
1313            minute: 14,
1314            title: "this is title",
1315            content: "this is content"
1316        }
1317        let expectId = -1;
1318        try {
1319            reminderAgent.publishReminder(alarm).then((reminderId) => {
1320                expectId = reminderId + 1;
1321                reminderAgent.publishReminder(alarm).then((reminderId) => {
1322                    if (reminderId === expectId){
1323                        expect(reminderId).assertEqual(expectId);
1324                    }
1325                });
1326            });
1327        } catch (e) {
1328            expect(true).assertTrue();
1329        };
1330        done();
1331    })
1332
1333    /*
1334     * @tc.name: testReminderHelper040
1335     * @tc.desc: test publishReminder a normal alarm.
1336     * @tc.type: FUNC
1337     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH AR000GH8EE
1338     */
1339    it("testReminderHelper040", 0, async function (done) {
1340        let alarm = {
1341            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_ALARM,
1342            hour: 21,
1343            minute: 14,
1344            title: "this is title",
1345            content: "this is content"
1346        }
1347        let expectId = -1;
1348        function reminderCallback(err, reminderId) {
1349            expect(reminderId).assertEqual(expectId);
1350        }
1351        try {
1352            reminderAgent.publishReminder(alarm, (err, reminderId) => {
1353                expectId = reminderId + 1;
1354                reminderAgent.publishReminder(alarm, reminderCallback);
1355            })
1356        } catch (e) {
1357            expect(true).assertTrue();
1358        };
1359        done();
1360    })
1361
1362    /*
1363     * @tc.name: testReminderHelper041
1364     * @tc.desc: test publishReminder.
1365     * @tc.type: FUNC
1366     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH
1367     */
1368    it("testReminderHelper041", 0, function (done) {
1369        let calendar = {
1370            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
1371            dateTime : {
1372                year: 2025,
1373                month: 10,
1374                day: 10,
1375                hour: 23,
1376                minute: 30
1377            },
1378            repeatMonths:[2],
1379            repeatDays:[2],
1380            actionButton:[
1381                {
1382                    title:"close",
1383                    type:0
1384                },
1385                {
1386                    title:"snooze",
1387                    type:1
1388                }
1389            ],
1390            wantAgent:{
1391                pkgName:"com.test.pkg",
1392                abilityName:"com.test.pkg.MainAbility"
1393            },
1394            maxScreenWantAgent:{
1395                pkgName:"com.test.pkg",
1396                abilityName:"com.test.pkg.MainAbility"
1397            },
1398            ringDuration:5,
1399            snoozeTimes:2,
1400            timeInterval:5,
1401            title:"this is title",
1402            content:"this is content",
1403            expiredContent:"this reminder has expired",
1404            snoozeContent:"remind later",
1405            notificationId:100,
1406            slotType:3
1407        }
1408        try {
1409            reminderAgent.publishReminder(calendar).then((reminderId) => {
1410                reminderAgent.getValidReminders().then((reminders) => {
1411                    for (let i = 0; i < reminders.length; i++) {
1412                        console.log("getValidReminders = " + JSON.stringify(reminders[i]));
1413                        console.log("getValidReminders, reminderType = " + reminders[i].reminderType);
1414                        for (let j = 0; j < reminders[i].actionButton.length; j++) {
1415                            console.log("getValidReminders, actionButton.title = " + reminders[i].actionButton[j].title);
1416                            console.log("getValidReminders, actionButton.type = " + reminders[i].actionButton[j].type);
1417                        }
1418                        console.log("getValidReminders, wantAgent.pkgName = " + reminders[i].wantAgent.pkgName);
1419                        console.log("getValidReminders, wantAgent.abilityName = " + reminders[i].wantAgent.abilityName);
1420                        console.log("getValidReminders, maxScreenWantAgent.pkgName = "
1421                            + reminders[i].maxScreenWantAgent.pkgName);
1422                        console.log("getValidReminders, maxScreenWantAgent.abilityName = "
1423                            + reminders[i].maxScreenWantAgent.abilityName);
1424                        expect(reminders[i].ringDuration).assertEqual(5);
1425                        console.log("getValidReminders, ringDuration = " + reminders[i].ringDuration);
1426                        expect(reminders[i].snoozeTimes).assertEqual(2);
1427                        console.log("getValidReminders, snoozeTimes = " + reminders[i].snoozeTimes);
1428                        console.log("getValidReminders, timeInterval = " + reminders[i].timeInterval);
1429                        expect(reminders[i].title).assertEqual("this is title");
1430                        console.log("getValidReminders, title = " + reminders[i].title);
1431                        expect(reminders[i].content).assertEqual("this is content");
1432                        console.log("getValidReminders, content = " + reminders[i].content);
1433                        expect(reminders[i].expiredContent).assertEqual("this reminder has expired");
1434                        console.log("getValidReminders, expiredContent = " + reminders[i].expiredContent);
1435                        expect(reminders[i].snoozeContent).assertEqual("remind later");
1436                        console.log("getValidReminders, snoozeContent = " + reminders[i].snoozeContent);
1437                        expect(reminders[i].notificationId).assertEqual(100);
1438                        console.log("getValidReminders, notificationId = " + reminders[i].notificationId);
1439                        console.log("getValidReminders, slotType = " + reminders[i].slotType);
1440                    }
1441                })
1442            });
1443        } catch (e) {
1444            expect(true).assertTrue();
1445        };
1446        done();
1447    })
1448
1449    /*
1450     * @tc.name: testReminderHelper042
1451     * @tc.desc: test publishReminder.
1452     * @tc.type: FUNC
1453     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH
1454     */
1455    it("testReminderHelper042", 0, async function (done) {
1456        let calendar = {
1457            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
1458            dateTime : {
1459                year: 2025,
1460                month: 10,
1461                day: 10,
1462                hour: 23,
1463                minute: 30
1464            },
1465            repeatMonths:[2],
1466            repeatDays:[2],
1467            actionButton:[
1468                {
1469                    title:"close",
1470                    type:0
1471                },
1472                {
1473                    title:"snooze",
1474                    type:1
1475                }
1476            ],
1477            wantAgent:{
1478                pkgName:"com.test.pkg",
1479                abilityName:"com.test.pkg.MainAbility"
1480            },
1481            maxScreenWantAgent:{
1482                pkgName:"com.test.pkg",
1483                abilityName:"com.test.pkg.MainAbility"
1484            },
1485            ringDuration:5,
1486            snoozeTimes:2,
1487            timeInterval:5,
1488            title:"this is title",
1489            content:"this is content",
1490            expiredContent:"this reminder has expired",
1491            snoozeContent:"remind later",
1492            notificationId:100,
1493            slotType:3
1494        }
1495        try {
1496            reminderAgent.publishReminder(calendar, (err,reminderId) => {
1497                reminderAgent.getValidReminders().then((reminders) => {
1498                    for (let i = 0; i < reminders.length; i++) {
1499                        console.log("getValidReminders = " + JSON.stringify(reminders[i]));
1500                        console.log("getValidReminders, reminderType = " + reminders[i].reminderType);
1501                        for (let j = 0; j < reminders[i].actionButton.length; j++) {
1502                            console.log("getValidReminders, actionButton.title = " + reminders[i].actionButton[j].title);
1503                            console.log("getValidReminders, actionButton.type = " + reminders[i].actionButton[j].type);
1504                        }
1505                        console.log("getValidReminders, wantAgent.pkgName = " + reminders[i].wantAgent.pkgName);
1506                        console.log("getValidReminders, wantAgent.abilityName = " + reminders[i].wantAgent.abilityName);
1507                        console.log("getValidReminders, maxScreenWantAgent.pkgName = "
1508                            + reminders[i].maxScreenWantAgent.pkgName);
1509                        console.log("getValidReminders, maxScreenWantAgent.abilityName = "
1510                            + reminders[i].maxScreenWantAgent.abilityName);
1511                        expect(reminders[i].ringDuration).assertEqual(5);
1512                        console.log("getValidReminders, ringDuration = " + reminders[i].ringDuration);
1513                        expect(reminders[i].snoozeTimes).assertEqual(2);
1514                        console.log("getValidReminders, snoozeTimes = " + reminders[i].snoozeTimes);
1515                        console.log("getValidReminders, timeInterval = " + reminders[i].timeInterval);
1516                        expect(reminders[i].title).assertEqual("this is title");
1517                        console.log("getValidReminders, title = " + reminders[i].title);
1518                        expect(reminders[i].content).assertEqual("this is content");
1519                        console.log("getValidReminders, content = " + reminders[i].content);
1520                        expect(reminders[i].expiredContent).assertEqual("this reminder has expired");
1521                        console.log("getValidReminders, expiredContent = " + reminders[i].expiredContent);
1522                        expect(reminders[i].snoozeContent).assertEqual("remind later");
1523                        console.log("getValidReminders, snoozeContent = " + reminders[i].snoozeContent);
1524                        expect(reminders[i].notificationId).assertEqual(100);
1525                        console.log("getValidReminders, notificationId = " + reminders[i].notificationId);
1526                        console.log("getValidReminders, slotType = " + reminders[i].slotType);
1527                    }
1528                })
1529            });
1530        } catch (e) {
1531            expect(true).assertTrue();
1532        };
1533        done();
1534    })
1535
1536    /*
1537     * @tc.name: testReminderHelper043
1538     * @tc.desc: test publishReminder.
1539     * @tc.type: FUNC
1540     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH
1541     */
1542    it("testReminderHelper043", 0, async function (done) {
1543        let calendar = {
1544            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
1545            dateTime : {
1546                year: 2025,
1547                month: 10,
1548                day: 10,
1549                hour: 23,
1550                minute: 30
1551            },
1552            repeatMonths:[2],
1553            repeatDays:[2],
1554            actionButton:[
1555                {
1556                    title:"close",
1557                    type:0
1558                },
1559                {
1560                    title:"snooze",
1561                    type:1
1562                }
1563            ],
1564            wantAgent:{
1565                pkgName:"com.test.pkg",
1566                abilityName:"com.test.pkg.MainAbility"
1567            },
1568            maxScreenWantAgent:{
1569                pkgName:"com.test.pkg",
1570                abilityName:"com.test.pkg.MainAbility"
1571            },
1572            ringDuration:5,
1573            snoozeTimes:2,
1574            timeInterval:5,
1575            title:"this is title",
1576            content:"this is content",
1577            expiredContent:"this reminder has expired",
1578            snoozeContent:"remind later",
1579            notificationId:100,
1580            slotType:3
1581        }
1582        let expectId = -1;
1583        try {
1584            reminderAgent.publishReminder(calendar).then((reminderId) => {
1585                expectId = reminderId + 1;
1586                reminderAgent.publishReminder(calendar).then((reminderId) => {
1587                    if (reminderId === expectId){
1588                        expect(reminderId).assertEqual(expectId);
1589                    }
1590                });
1591            });
1592        } catch (e) {
1593            expect(true).assertTrue();
1594        };
1595        done();
1596    })
1597
1598    /*
1599     * @tc.name: testReminderHelper044
1600     * @tc.desc: test publishReminder.
1601     * @tc.type: FUNC
1602     * @tc.require: SR000GGTRB AR000GH8E9 AR00GH8EH
1603     */
1604    it("testReminderHelper044", 0, async function (done) {
1605        let calendar = {
1606            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_CALENDAR,
1607            dateTime : {
1608                year: 2025,
1609                month: 10,
1610                day: 10,
1611                hour: 23,
1612                minute: 30
1613            },
1614            repeatMonths:[2],
1615            repeatDays:[2],
1616            actionButton:[
1617                {
1618                    title:"close",
1619                    type:0
1620                },
1621                {
1622                    title:"snooze",
1623                    type:1
1624                }
1625            ],
1626            wantAgent:{
1627                pkgName:"com.test.pkg",
1628                abilityName:"com.test.pkg.MainAbility"
1629            },
1630            maxScreenWantAgent:{
1631                pkgName:"com.test.pkg",
1632                abilityName:"com.test.pkg.MainAbility"
1633            },
1634            ringDuration:5,
1635            snoozeTimes:2,
1636            timeInterval:5,
1637            title:"this is title",
1638            content:"this is content",
1639            expiredContent:"this reminder has expired",
1640            snoozeContent:"remind later",
1641            notificationId:100,
1642            slotType:3
1643        }
1644        let expectId = -1;
1645        function reminderCallback(err, reminderId) {
1646            expect(reminderId).assertEqual(expectId);
1647        }
1648        try {
1649            reminderAgent.publishReminder(calendar, (err, reminderId) => {
1650                expectId = reminderId + 1;
1651                reminderAgent.publishReminder(calendar, reminderCallback);
1652            })
1653        } catch (e) {
1654            expect(true).assertTrue();
1655        };
1656        done();
1657    })
1658
1659    /*
1660     * @tc.name: testReminderHelper045
1661     * @tc.desc: test publishReminder (max number limit of each application)
1662     * @tc.type: FUNC
1663     * @tc.require: SR000GGTRE AR000GH8E9 AR00GH8EH
1664     */
1665    it("testReminderHelper045", 0, async function (done) {
1666        let timer = {
1667            reminderType: reminderAgent.ReminderType.REMINDER_TYPE_TIMER,
1668            triggerTimeInSeconds: 100
1669        }
1670        let maxLimitNumsOfApp = 30;
1671        let firstId = 0;
1672        let secondId = 0;
1673        let diffId = 0;
1674        for (let i = 0; i < maxLimitNumsOfApp; i++) {
1675            (function (i) {
1676                var i = i;
1677                setTimeout(function () {
1678                    try {
1679                        reminderAgent.publishReminder(timer).then((reminderId) => {
1680                            if (i === 0) {
1681                                firstId = reminderId
1682                            }
1683                            if (i === 29) {
1684                                secondId = reminderId
1685                                diffId = secondId - firstId
1686                                expect(29).assertEqual(diffId);
1687                                i = null
1688                            }
1689                        });
1690                    } catch (e) {
1691                        expect(true).assertTrue();
1692                    };
1693                }, 500 * i);
1694            })(i);
1695        }
1696        done();
1697    })
1698})