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