1/** 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from "@ohos/hypium" 16import inputMethod from '@ohos.inputMethod'; 17import inputMethodEngine from '@ohos.inputMethodEngine'; 18import subtype from '@ohos.InputMethodSubtype'; 19import commonEventManager from '@ohos.commonEventManager'; 20import display from '@ohos.display'; 21import { Driver, ON, MatchPattern, Component, Rect } from '@ohos.UiTest' 22import { BusinessError } from '@ohos.base' 23 24export default function inputMethodAbility() { 25 describe('inputMethodAbility', () => { 26 let extra: ESObject = {}; 27 let inputServer: ESObject = { 28 packageName: '', 29 methodId: '', 30 name: '', 31 id: '', 32 extra: extra 33 } 34 35 let rectInfo: Rect; 36 let textArea: Component; 37 let driver = Driver.create(); 38 let dis = display.getDefaultDisplaySync(); 39 let inputDemoService: subtype; 40 let inputMethodController = inputMethod.getController(); 41 42 beforeAll(async (done: Function) => { 43 let inputM = inputMethod.getCurrentInputMethod() 44 console.info("====>beforeAll: switchInputMethod to: " + JSON.stringify(inputM)); 45 inputServer.packageName = inputM.packageName; 46 inputServer.methodId = inputM.methodId; 47 inputServer.name = inputM.packageName; 48 inputServer.id = inputM.methodId; 49 console.info("====>beforeAll inputMethodStageJSUnit start"); 50 inputDemoService = { 51 id: 'inputStageService', 52 label: '', 53 name: 'com.acts.inputmethodengine.test', 54 mode: 'lower', 55 locale: '', 56 language: '', 57 icon: '', 58 iconId: 0, 59 extra: {}, 60 } 61 try { 62 await inputMethod.switchCurrentInputMethodSubtype(inputDemoService); 63 textArea = await driver.findComponent(ON.type('TextArea')); 64 rectInfo = await textArea.getBounds(); 65 console.info('====>beforeAll inputMethodSwitch textArea rectInfo: ' + JSON.stringify(rectInfo)); 66 setTimeout(() => { 67 runCmd() 68 console.info("====>beforeAll inputMethodStageJSUnit switchCurrentInputMethodSubtype success"); 69 done(); 70 }, 2000) 71 } catch (err) { 72 console.info("====>beforeAll inputMethodStageJSUnit switchCurrentInputMethodSubtype failed"); 73 } 74 }) 75 76 afterAll(async (done: Function) => { 77 done(); 78 }) 79 80 let runCmd = async () => { 81 let cursor_x = rectInfo.left + 20 + Math.floor(Math.random() * (rectInfo.right - rectInfo.left) * 0.9); 82 let cursor_y = rectInfo.top + 20 + Math.floor(Math.random() * (rectInfo.bottom - rectInfo.top) * 0.9); 83 console.info(`====>start click x: ${cursor_x} y: ${cursor_y}`) 84 await driver.click(cursor_x, cursor_y) 85 } 86 87 /* 88 * @tc.number inputMethodEngine_test_001 89 * @tc.name inputMethodEngine_test_001 90 * @tc.desc Function test 91 * @tc.size MediumTest 92 * @tc.type Function 93 * @tc.level Level2 94 */ 95 it('inputMethodEngine_test_001', 0, async (done: Function) => { 96 let keyType = inputMethodEngine.ENTER_KEY_TYPE_UNSPECIFIED; 97 console.info("====>inputMethodEngine_test_001 result:" + keyType); 98 expect(keyType).assertEqual(0); 99 done(); 100 }); 101 102 /* 103 * @tc.number inputMethodEngine_test_002 104 * @tc.name inputMethodEngine_test_002 105 * @tc.desc Function test 106 * @tc.size MediumTest 107 * @tc.type Function 108 * @tc.level Level2 109 */ 110 it('inputMethodEngine_test_002', 0, async (done: Function) => { 111 let keyType = inputMethodEngine.ENTER_KEY_TYPE_GO; 112 console.info("====>inputMethodEngine_test_002 result:" + keyType); 113 expect(keyType).assertEqual(2); 114 done(); 115 }); 116 117 /* 118 * @tc.number inputMethodEngine_test_003 119 * @tc.name inputMethodEngine_test_003 120 * @tc.desc Function test 121 * @tc.size MediumTest 122 * @tc.type Function 123 * @tc.level Level2 124 */ 125 it('inputMethodEngine_test_003', 0, async (done: Function) => { 126 let keyType = inputMethodEngine.ENTER_KEY_TYPE_SEARCH; 127 console.info("====>inputMethodEngine_test_003 result:" + keyType); 128 expect(keyType).assertEqual(3); 129 done(); 130 }); 131 132 /* 133 * @tc.number inputMethodEngine_test_004 134 * @tc.name inputMethodEngine_test_004 135 * @tc.desc Function test 136 * @tc.size MediumTest 137 * @tc.type Function 138 * @tc.level Level2 139 */ 140 it('inputMethodEngine_test_004', 0, async (done: Function) => { 141 let keyType = inputMethodEngine.ENTER_KEY_TYPE_SEND; 142 console.info("====>inputMethodEngine_test_004 result:" + keyType); 143 expect(keyType).assertEqual(4); 144 done(); 145 }); 146 147 /* 148 * @tc.number inputMethodEngine_test_005 149 * @tc.name inputMethodEngine_test_005 150 * @tc.desc Function test 151 * @tc.size MediumTest 152 * @tc.type Function 153 * @tc.level Level2 154 */ 155 it('inputMethodEngine_test_005', 0, async (done: Function) => { 156 let keyType = inputMethodEngine.ENTER_KEY_TYPE_NEXT; 157 console.info("====>inputMethodEngine_test_005 result:" + keyType); 158 expect(keyType).assertEqual(5); 159 done(); 160 }); 161 162 /* 163 * @tc.number inputMethodEngine_test_006 164 * @tc.name inputMethodEngine_test_006 165 * @tc.desc Function test 166 * @tc.size MediumTest 167 * @tc.type Function 168 * @tc.level Level2 169 */ 170 it('inputMethodEngine_test_006', 0, async (done: Function) => { 171 let keyType = inputMethodEngine.ENTER_KEY_TYPE_DONE; 172 console.info("====>inputMethodEngine_test_006 result:" + keyType); 173 expect(keyType).assertEqual(6); 174 done(); 175 }); 176 177 /* 178 * @tc.number inputMethodEngine_test_007 179 * @tc.name inputMethodEngine_test_007 180 * @tc.desc Function test 181 * @tc.size MediumTest 182 * @tc.type Function 183 * @tc.level Level2 184 */ 185 it('inputMethodEngine_test_007', 0, async (done: Function) => { 186 let keyType = inputMethodEngine.ENTER_KEY_TYPE_PREVIOUS; 187 console.info("====>inputMethodEngine_test_007 result:" + keyType); 188 expect(keyType).assertEqual(7); 189 done(); 190 }); 191 192 /* 193 * @tc.number inputMethodEngine_test_008 194 * @tc.name inputMethodEngine_test_008 195 * @tc.desc Function test 196 * @tc.size MediumTest 197 * @tc.type Function 198 * @tc.level Level2 199 */ 200 it('inputMethodEngine_test_008', 0, async (done: Function) => { 201 let keyType = inputMethodEngine.PATTERN_NULL; 202 console.info("====>inputMethodEngine_test_008 result:" + keyType); 203 expect(keyType).assertEqual(-1); 204 done(); 205 }); 206 207 /* 208 * @tc.number inputMethodEngine_test_009 209 * @tc.name inputMethodEngine_test_009 210 * @tc.desc Function test 211 * @tc.size MediumTest 212 * @tc.type Function 213 * @tc.level Level2 214 */ 215 it('inputMethodEngine_test_009', 0, async (done: Function) => { 216 let keyType = inputMethodEngine.PATTERN_TEXT; 217 console.info("====>inputMethodEngine_test_009 result:" + keyType); 218 expect(keyType).assertEqual(0); 219 done(); 220 }); 221 222 /* 223 * @tc.number inputMethodEngine_test_010 224 * @tc.name inputMethodEngine_test_010 225 * @tc.desc Function test 226 * @tc.size MediumTest 227 * @tc.type Function 228 * @tc.level Level2 229 */ 230 it('inputMethodEngine_test_010', 0, async (done: Function) => { 231 let keyType = inputMethodEngine.PATTERN_NUMBER; 232 console.info("====>inputMethodEngine_test_010 result:" + keyType); 233 expect(keyType).assertEqual(2); 234 done(); 235 }); 236 237 /* 238 * @tc.number inputMethodEngine_test_011 239 * @tc.name inputMethodEngine_test_011 240 * @tc.desc Function test 241 * @tc.size MediumTest 242 * @tc.type Function 243 * @tc.level Level2 244 */ 245 it('inputMethodEngine_test_011', 0, async (done: Function) => { 246 let keyType = inputMethodEngine.PATTERN_PHONE; 247 console.info("====>inputMethodEngine_test_011 result:" + keyType); 248 expect(keyType).assertEqual(3); 249 done(); 250 }); 251 252 /* 253 * @tc.number inputMethodEngine_test_012 254 * @tc.name inputMethodEngine_test_012 255 * @tc.desc Function test 256 * @tc.size MediumTest 257 * @tc.type Function 258 * @tc.level Level2 259 */ 260 it('inputMethodEngine_test_012', 0, async (done: Function) => { 261 let keyType = inputMethodEngine.PATTERN_DATETIME; 262 console.info("====>inputMethodEngine_test_012 result:" + keyType); 263 expect(keyType).assertEqual(4); 264 done(); 265 }); 266 267 /* 268 * @tc.number inputMethodEngine_test_013 269 * @tc.name inputMethodEngine_test_013 270 * @tc.desc Function test 271 * @tc.size MediumTest 272 * @tc.type Function 273 * @tc.level Level2 274 */ 275 it('inputMethodEngine_test_013', 0, async (done: Function) => { 276 let keyType = inputMethodEngine.PATTERN_EMAIL; 277 console.info("====>inputMethodEngine_test_013 result:" + keyType); 278 expect(keyType).assertEqual(5); 279 done(); 280 }); 281 282 /* 283 * @tc.number inputMethodEngine_test_014 284 * @tc.name inputMethodEngine_test_014 285 * @tc.desc Function test 286 * @tc.size MediumTest 287 * @tc.type Function 288 * @tc.level Level2 289 */ 290 it('inputMethodEngine_test_014', 0, async (done: Function) => { 291 let keyType = inputMethodEngine.PATTERN_URI; 292 console.info("====>inputMethodEngine_test_014 result:" + keyType); 293 expect(keyType).assertEqual(6); 294 done(); 295 }); 296 297 /* 298 * @tc.number inputMethodEngine_test_015 299 * @tc.name inputMethodEngine_test_015 300 * @tc.desc Function test 301 * @tc.size MediumTest 302 * @tc.type Function 303 * @tc.level Level2 304 */ 305 it('inputMethodEngine_test_015', 0, async (done: Function) => { 306 let keyType = inputMethodEngine.PATTERN_PASSWORD; 307 console.info("====>inputMethodEngine_test_015 result:" + keyType); 308 expect(keyType).assertEqual(7); 309 done(); 310 }); 311 312 /* 313 * @tc.number inputMethodEngine_test_016 314 * @tc.name inputMethodEngine_test_016 315 * @tc.desc Function test 316 * @tc.size MediumTest 317 * @tc.type Function 318 * @tc.level Level2 319 */ 320 it('inputMethodEngine_test_016', 0, async (done: Function) => { 321 let keyType = inputMethodEngine.FLAG_SELECTING; 322 console.info("====>inputMethodEngine_test_016 result:" + keyType); 323 expect(keyType).assertEqual(2); 324 done(); 325 }); 326 327 /* 328 * @tc.number inputMethodEngine_test_017 329 * @tc.name inputMethodEngine_test_017 330 * @tc.desc Function test 331 * @tc.size MediumTest 332 * @tc.type Function 333 * @tc.level Level2 334 */ 335 it('inputMethodEngine_test_017', 0, async (done: Function) => { 336 let keyType = inputMethodEngine.FLAG_SINGLE_LINE; 337 console.info("====>inputMethodEngine_test_017 result:" + keyType); 338 expect(keyType).assertEqual(1); 339 done(); 340 }); 341 342 /* 343 * @tc.number inputMethodEngine_test_018 344 * @tc.name inputMethodEngine_test_018 345 * @tc.desc Function test 346 * @tc.size MediumTest 347 * @tc.type Function 348 * @tc.level Level2 349 */ 350 it('inputMethodEngine_test_018', 0, async (done: Function) => { 351 let keyType = inputMethodEngine.DISPLAY_MODE_PART; 352 console.info("====>inputMethodEngine_test_018 result:" + keyType); 353 expect(keyType).assertEqual(0); 354 done(); 355 }); 356 357 /* 358 * @tc.number inputMethodEngine_test_019 359 * @tc.name inputMethodEngine_test_019 360 * @tc.desc Function test 361 * @tc.size MediumTest 362 * @tc.type Function 363 * @tc.level Level2 364 */ 365 it('inputMethodEngine_test_019', 0, async (done: Function) => { 366 let keyType = inputMethodEngine.DISPLAY_MODE_FULL; 367 console.info("====>inputMethodEngine_test_019 result:" + keyType); 368 expect(keyType).assertEqual(1); 369 done(); 370 }); 371 372 /* 373 * @tc.number inputMethodEngine_test_020 374 * @tc.name inputMethodEngine_test_020 375 * @tc.desc Function test 376 * @tc.size MediumTest 377 * @tc.type Function 378 * @tc.level Level2 379 */ 380 it('inputMethodEngine_test_020', 0, async (done: Function) => { 381 let keyType = inputMethodEngine.OPTION_ASCII; 382 console.info("====>inputMethodEngine_test_020 result:" + keyType); 383 expect(keyType).assertEqual(20); 384 done(); 385 }); 386 387 /* 388 * @tc.number inputMethodEngine_test_021 389 * @tc.name inputMethodEngine_test_021 390 * @tc.desc Function test 391 * @tc.size MediumTest 392 * @tc.type Function 393 * @tc.level Level2 394 */ 395 it('inputMethodEngine_test_021', 0, async (done: Function) => { 396 let keyType = inputMethodEngine.OPTION_NONE; 397 console.info("====>inputMethodEngine_test_021 result:" + keyType); 398 expect(keyType).assertEqual(0); 399 done(); 400 }); 401 402 /* 403 * @tc.number inputMethodEngine_test_022 404 * @tc.name inputMethodEngine_test_022 405 * @tc.desc Function test 406 * @tc.size MediumTest 407 * @tc.type Function 408 * @tc.level Level2 409 */ 410 it('inputMethodEngine_test_022', 0, async (done: Function) => { 411 let keyType = inputMethodEngine.OPTION_AUTO_CAP_CHARACTERS; 412 console.info("====>inputMethodEngine_test_022 result:" + keyType); 413 expect(keyType).assertEqual(2); 414 done(); 415 }); 416 417 /* 418 * @tc.number inputMethodEngine_test_023 419 * @tc.name inputMethodEngine_test_023 420 * @tc.desc Function test 421 * @tc.size MediumTest 422 * @tc.type Function 423 * @tc.level Level2 424 */ 425 it('inputMethodEngine_test_023', 0, async (done: Function) => { 426 let keyType = inputMethodEngine.OPTION_AUTO_CAP_SENTENCES; 427 console.info("====>inputMethodEngine_test_023 result:" + keyType); 428 expect(keyType).assertEqual(8); 429 done(); 430 }); 431 432 /* 433 * @tc.number inputMethodEngine_test_024 434 * @tc.name inputMethodEngine_test_024 435 * @tc.desc Function test 436 * @tc.size MediumTest 437 * @tc.type Function 438 * @tc.level Level2 439 */ 440 it('inputMethodEngine_test_024', 0, async (done: Function) => { 441 let keyType = inputMethodEngine.OPTION_AUTO_WORDS; 442 console.info("====>inputMethodEngine_test_024 result:" + keyType); 443 expect(keyType).assertEqual(4); 444 done(); 445 }); 446 447 /* 448 * @tc.number inputMethodEngine_test_025 449 * @tc.name inputMethodEngine_test_025 450 * @tc.desc Function test 451 * @tc.size MediumTest 452 * @tc.type Function 453 * @tc.level Level2 454 */ 455 it('inputMethodEngine_test_025', 0, async (done: Function) => { 456 let keyType = inputMethodEngine.OPTION_MULTI_LINE; 457 console.info("====>inputMethodEngine_test_025 result:" + keyType); 458 expect(keyType).assertEqual(1); 459 done(); 460 }); 461 462 /* 463 * @tc.number inputMethodEngine_test_026 464 * @tc.name inputMethodEngine_test_026 465 * @tc.desc Function test 466 * @tc.size MediumTest 467 * @tc.type Function 468 * @tc.level Level2 469 */ 470 it('inputMethodEngine_test_026', 0, async (done: Function) => { 471 let keyType = inputMethodEngine.OPTION_NO_FULLSCREEN; 472 console.info("====>inputMethodEngine_test_026 result:" + keyType); 473 expect(keyType).assertEqual(10); 474 done(); 475 }); 476 477 /* 478 * @tc.number inputMethodEngine_test_027 479 * @tc.name inputMethodEngine_test_027 480 * @tc.desc Function test 481 * @tc.size MediumTest 482 * @tc.type Function 483 * @tc.level Level2 484 */ 485 it('inputMethodEngine_test_027', 0, async (done: Function) => { 486 let keyType = inputMethodEngine.PATTERN_PASSWORD_SCREEN_LOCK; 487 console.info("====>inputMethodEngine_test_027 result:" + keyType); 488 expect(keyType).assertEqual(9); 489 done(); 490 }); 491 492 /* 493 * @tc.number inputMethodEngine_test_028 494 * @tc.name inputMethodEngine_test_028 495 * @tc.desc Function test 496 * @tc.size MediumTest 497 * @tc.type Function 498 * @tc.level Level2 499 */ 500 it('inputMethodEngine_test_028', 0, async (done: Function) => { 501 let keyType = inputMethodEngine.PATTERN_PASSWORD_NUMBER; 502 console.info("====>inputMethodEngine_test_028 result:" + keyType); 503 expect(keyType).assertEqual(8); 504 done(); 505 }); 506 507 /* 508 * @tc.number inputMethodEngine_test_029 509 * @tc.name inputMethodEngine_test_029 510 * @tc.desc Function test 511 * @tc.size MediumTest 512 * @tc.type Function 513 * @tc.level Level2 514 */ 515 it('inputMethodEngine_test_029', 0, async (done: Function) => { 516 let keyType = inputMethodEngine.ENTER_KEY_TYPE_NEWLINE; 517 console.info("====>inputMethodEngine_test_029 result:" + keyType); 518 expect(keyType).assertEqual(8); 519 done(); 520 }); 521 522 /* 523 * @tc.number Sub_Misc_inputMethodEngine_ExtendAction_0100 524 * @tc.name Sub_Misc_inputMethodEngine_ExtendAction_0100 525 * @tc.desc Function test 526 * @tc.size MediumTest 527 * @tc.type Function 528 * @tc.level Level2 529 */ 530 it('Sub_Misc_inputMethodEngine_ExtendAction_0100', 0, async (done: Function) => { 531 let select_all = inputMethodEngine.ExtendAction.SELECT_ALL; 532 console.info("====>Sub_Misc_inputMethodEngine_ExtendAction_0100 select_all:" + select_all); 533 expect(select_all).assertEqual(0); 534 let cut = inputMethodEngine.ExtendAction.CUT; 535 console.info("====>Sub_Misc_inputMethodEngine_ExtendAction_0100 cut:" + cut); 536 expect(cut).assertEqual(3); 537 let copy = inputMethodEngine.ExtendAction.COPY; 538 console.info("====>Sub_Misc_inputMethodEngine_ExtendAction_0100 copy:" + copy); 539 expect(copy).assertEqual(4); 540 let paste = inputMethodEngine.ExtendAction.PASTE; 541 console.info("====>Sub_Misc_inputMethodEngine_ExtendAction_0100 paste:" + paste); 542 expect(paste).assertEqual(5); 543 done(); 544 }); 545 546 /* 547 * @tc.number Sub_Misc_inputMethodEngine_ExtendAction_0101 548 * @tc.name Sub_Misc_inputMethodEngine_ExtendAction_0101 549 * @tc.desc Function test 550 * @tc.size MediumTest 551 * @tc.type Function 552 * @tc.level Level2 553 */ 554 it('inputMethodAbility_test_getInputMethodAbility_001', 0, async (done: Function) => { 555 556 let unSubscriberCallback = (err: BusinessError) => { 557 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 unSubscriberCallback start"); 558 if (err) { 559 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 unSubscriberCallback failed:" + 560 JSON.stringify(err)); 561 } else { 562 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 unSubscriberCallback finish"); 563 } 564 } 565 566 let subscriberCallback = (err: BusinessError, data: ESObject) => { 567 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 subscriberCallback data:" 568 + JSON.stringify(data)); 569 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 570 let t = setTimeout(() => { 571 try { 572 expect(data.data).assertEqual("SUCCESS"); 573 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 end"); 574 clearTimeout(t); 575 done(); 576 } catch (err) { 577 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 err:" + JSON.stringify(err)); 578 clearTimeout(t); 579 done(); 580 } 581 }, 500) 582 } 583 584 let publishCallback = (err: BusinessError) => { 585 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 publishCallback start"); 586 if (err) { 587 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 publishCallback failed:" + 588 JSON.stringify(err)); 589 } 590 } 591 592 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 593 events: ["inputMethodAbility_test_getInputMethodAbility_001"] 594 } 595 let subscriber: ESObject; 596 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 597 try { 598 subscriber = data; 599 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 subscriber data:" + 600 JSON.stringify(data)); 601 commonEventManager.subscribe(subscriber, subscriberCallback); 602 console.info("====>inputMethodAbility_test_getInputMethodAbility_001 subscriber finish"); 603 } catch (err) { 604 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 605 } 606 607 let t = setTimeout(async () => { 608 clearTimeout(t); 609 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 610 code: 1 611 } 612 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 613 }, 500) 614 615 }).catch((err: BusinessError) => { 616 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 617 }) 618 }); 619 620 /* 621 * @tc.number inputMethodAbility_test_getKeyboardDelegate_001 622 * @tc.name inputMethodAbility_test_getKeyboardDelegate_001 623 * @tc.desc Function test 624 * @tc.size MediumTest 625 * @tc.type Function 626 * @tc.level Level2 627 */ 628 it('inputMethodAbility_test_getKeyboardDelegate_001', 0, async (done: Function) => { 629 630 let unSubscriberCallback = (err: BusinessError) => { 631 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 unSubscriberCallback start"); 632 if (err) { 633 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 unSubscriberCallback failed:" + 634 JSON.stringify(err)); 635 } else { 636 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 unSubscriberCallback finish"); 637 } 638 } 639 640 let subscriberCallback = (err: BusinessError, data: ESObject) => { 641 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 subscriberCallback data:" 642 + JSON.stringify(data)); 643 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 644 let t = setTimeout(() => { 645 try { 646 expect(data.data).assertEqual("SUCCESS"); 647 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 end"); 648 clearTimeout(t); 649 done(); 650 } catch (err) { 651 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 err:" + JSON.stringify(err)); 652 clearTimeout(t); 653 done(); 654 } 655 }, 500) 656 } 657 658 let publishCallback = (err: BusinessError) => { 659 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 publishCallback start"); 660 if (err) { 661 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 publishCallback failed:" + 662 JSON.stringify(err)); 663 } 664 } 665 666 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 667 events: ["inputMethodAbility_test_getKeyboardDelegate_001"] 668 } 669 let subscriber: ESObject; 670 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 671 try { 672 subscriber = data; 673 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 subscriber data:" + JSON.stringify(data)); 674 commonEventManager.subscribe(subscriber, subscriberCallback); 675 console.info("====>inputMethodAbility_test_getKeyboardDelegate_001 subscriber finish"); 676 } catch (err) { 677 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 678 } 679 680 let t = setTimeout(async () => { 681 clearTimeout(t); 682 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 683 code: 2 684 } 685 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 686 }, 500) 687 688 }).catch((err: BusinessError) => { 689 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 690 }) 691 }); 692 693 /* 694 * @tc.number inputMethodAbility_test_028 695 * @tc.name inputMethodAbility_test_028 696 * @tc.desc Function test 697 * @tc.size MediumTest 698 * @tc.type Function 699 * @tc.level Level2 700 */ 701 it('inputMethodAbility_test_028', 0, async (done: Function) => { 702 703 let unSubscriberCallback = (err: BusinessError) => { 704 console.info("====>inputMethodAbility_test_028 unSubscriberCallback start"); 705 if (err) { 706 console.info("====>inputMethodAbility_test_028 unSubscriberCallback failed:" + 707 JSON.stringify(err)); 708 } else { 709 console.info("====>inputMethodAbility_test_028 unSubscriberCallback finish"); 710 } 711 } 712 713 let subscriberCallback = (err: BusinessError, data: ESObject) => { 714 console.info("====>inputMethodAbility_test_028 subscriberCallback data:" 715 + JSON.stringify(data)); 716 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 717 let t = setTimeout(() => { 718 try { 719 expect(data.data).assertEqual("SUCCESS"); 720 console.info("====>inputMethodAbility_test_028 end"); 721 clearTimeout(t); 722 done(); 723 } catch (err) { 724 console.info("====>inputMethodAbility_test_028 err:" + JSON.stringify(err)); 725 clearTimeout(t); 726 done(); 727 } 728 }, 500) 729 } 730 731 let publishCallback = (err: BusinessError) => { 732 console.info("====>inputMethodAbility_test_028 publishCallback start"); 733 if (err) { 734 console.info("====>inputMethodAbility_test_028 publishCallback failed:" + JSON.stringify(err)); 735 } 736 } 737 738 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 739 events: ["inputMethodAbility_test_028"] 740 } 741 let subscriber: ESObject; 742 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 743 try { 744 subscriber = data; 745 console.info("====>inputMethodAbility_test_028 subscriber data:" + JSON.stringify(data)); 746 commonEventManager.subscribe(subscriber, subscriberCallback); 747 console.info("====>inputMethodAbility_test_028 subscriber finish"); 748 } catch (err) { 749 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 750 } 751 752 let t = setTimeout(async () => { 753 clearTimeout(t); 754 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 755 code: 28 756 } 757 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 758 }, 500) 759 760 }).catch((err: BusinessError) => { 761 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 762 }) 763 }); 764 765 /* 766 * @tc.number inputMethodAbility_test_029 767 * @tc.name inputMethodAbility_test_029 768 * @tc.desc Function test 769 * @tc.size MediumTest 770 * @tc.type Function 771 * @tc.level Level2 772 */ 773 it('inputMethodAbility_test_029', 0, async (done: Function) => { 774 775 let unSubscriberCallback = (err: BusinessError) => { 776 console.info("====>inputMethodAbility_test_029 unSubscriberCallback start"); 777 if (err) { 778 console.info("====>inputMethodAbility_test_029 unSubscriberCallback failed:" + 779 JSON.stringify(err)); 780 } else { 781 console.info("====>inputMethodAbility_test_029 unSubscriberCallback finish"); 782 } 783 } 784 785 let subscriberCallback = (err: BusinessError, data: ESObject) => { 786 console.info("====>inputMethodAbility_test_029 subscriberCallback data:" 787 + JSON.stringify(data)); 788 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 789 let t = setTimeout(() => { 790 try { 791 expect(data.data).assertEqual("SUCCESS"); 792 console.info("====>inputMethodAbility_test_029 end"); 793 clearTimeout(t); 794 done(); 795 } catch (err) { 796 console.info("====>inputMethodAbility_test_029 err:" + JSON.stringify(err)); 797 clearTimeout(t); 798 done(); 799 } 800 }, 500) 801 } 802 803 let publishCallback = (err: BusinessError) => { 804 console.info("====>inputMethodAbility_test_029 publishCallback start"); 805 if (err) { 806 console.info("====>inputMethodAbility_test_029 publishCallback failed:" + JSON.stringify(err)); 807 } 808 } 809 810 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 811 events: ["inputMethodAbility_test_029"] 812 } 813 let subscriber: ESObject; 814 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 815 try { 816 subscriber = data; 817 console.info("====>inputMethodAbility_test_029 subscriber data:" + JSON.stringify(data)); 818 commonEventManager.subscribe(subscriber, subscriberCallback); 819 console.info("====>inputMethodAbility_test_029 subscriber finish"); 820 } catch (err) { 821 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 822 } 823 824 let t = setTimeout(async () => { 825 clearTimeout(t); 826 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 827 code: 29 828 } 829 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback) 830 }, 500) 831 832 }).catch((err: BusinessError) => { 833 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 834 }) 835 }); 836 837 /* 838 * @tc.number inputMethodAbility_test_030 839 * @tc.name inputMethodAbility_test_030 840 * @tc.desc Function test 841 * @tc.size MediumTest 842 * @tc.type Function 843 * @tc.level Level2 844 */ 845 it('inputMethodAbility_test_030', 0, async (done: Function) => { 846 847 let unSubscriberCallback = (err: BusinessError) => { 848 console.info("====>inputMethodAbility_test_030 unSubscriberCallback start"); 849 if (err) { 850 console.info("====>inputMethodAbility_test_030 unSubscriberCallback failed:" + 851 JSON.stringify(err)); 852 } else { 853 console.info("====>inputMethodAbility_test_030 unSubscriberCallback finish"); 854 } 855 } 856 857 let subscriberCallback = (err: BusinessError, data: ESObject) => { 858 console.info("====>inputMethodAbility_test_030 subscriberCallback data:" 859 + JSON.stringify(data)); 860 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 861 let t = setTimeout(() => { 862 try { 863 expect(data.data).assertEqual("SUCCESS"); 864 console.info("====>inputMethodAbility_test_030 end"); 865 clearTimeout(t); 866 done(); 867 } catch (err) { 868 console.info("====>inputMethodAbility_test_030 err:" + JSON.stringify(err)); 869 clearTimeout(t); 870 done(); 871 } 872 }, 500) 873 } 874 875 let publishCallback = (err: BusinessError) => { 876 console.info("====>inputMethodAbility_test_030 publishCallback start"); 877 if (err) { 878 console.info("====>inputMethodAbility_test_030 publishCallback failed:" + JSON.stringify(err)); 879 } 880 } 881 882 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 883 events: ["inputMethodAbility_test_030"] 884 } 885 let subscriber: ESObject; 886 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 887 try { 888 subscriber = data; 889 console.info("====>inputMethodAbility_test_030 subscriber data:" + JSON.stringify(data)) 890 commonEventManager.subscribe(subscriber, subscriberCallback); 891 console.info("====>inputMethodAbility_test_030 subscriber finish"); 892 } catch (err) { 893 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 894 } 895 896 let t = setTimeout(async () => { 897 clearTimeout(t); 898 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 899 code: 30 900 } 901 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 902 }, 500) 903 904 }).catch((err: BusinessError) => { 905 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 906 }) 907 }); 908 909 /* 910 * @tc.number inputMethodAbility_test_031 911 * @tc.name inputMethodAbility_test_031 912 * @tc.desc Function test 913 * @tc.size MediumTest 914 * @tc.type Function 915 * @tc.level Level2 916 */ 917 it('inputMethodAbility_test_031', 0, async (done: Function) => { 918 919 let unSubscriberCallback = (err: BusinessError) => { 920 console.info("====>inputMethodAbility_test_031 unSubscriberCallback start"); 921 if (err) { 922 console.info("====>inputMethodAbility_test_031 unSubscriberCallback failed:" + 923 JSON.stringify(err)); 924 } else { 925 console.info("====>inputMethodAbility_test_031 unSubscriberCallback finish"); 926 } 927 } 928 929 let subscriberCallback = (err: BusinessError, data: ESObject) => { 930 console.info("====>inputMethodAbility_test_031 subscriberCallback data:" 931 + JSON.stringify(data)); 932 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 933 let t = setTimeout(() => { 934 try { 935 expect(data.data).assertEqual("SUCCESS"); 936 console.info("====>inputMethodAbility_test_031 end"); 937 clearTimeout(t); 938 done(); 939 } catch (err) { 940 console.info("====>inputMethodAbility_test_031 err:" + JSON.stringify(err)); 941 clearTimeout(t); 942 done(); 943 } 944 }, 500) 945 } 946 947 let publishCallback = (err: BusinessError) => { 948 console.info("====>inputMethodAbility_test_031 publishCallback start"); 949 if (err) { 950 console.info("====>inputMethodAbility_test_031 publishCallback failed:" + JSON.stringify(err)); 951 } 952 } 953 954 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 955 events: ["inputMethodAbility_test_031"] 956 } 957 let subscriber: ESObject; 958 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 959 try { 960 subscriber = data; 961 console.info("====>inputMethodAbility_test_031 subscriber data:" + JSON.stringify(data)) 962 commonEventManager.subscribe(subscriber, subscriberCallback); 963 console.info("====>inputMethodAbility_test_031 subscriber finish"); 964 } catch (err) { 965 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 966 } 967 968 let t = setTimeout(async () => { 969 clearTimeout(t); 970 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 971 code: 31 972 } 973 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 974 }, 500) 975 976 }).catch((err: BusinessError) => { 977 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 978 }) 979 }); 980 981 /* 982 * @tc.number inputMethodAbility_test_032 983 * @tc.name inputMethodAbility_test_032 984 * @tc.desc Function test 985 * @tc.size MediumTest 986 * @tc.type Function 987 * @tc.level Level2 988 */ 989 it('inputMethodAbility_test_032', 0, async (done: Function) => { 990 991 let unSubscriberCallback = (err: BusinessError) => { 992 console.info("====>inputMethodAbility_test_032 unSubscriberCallback start"); 993 if (err) { 994 console.info("====>inputMethodAbility_test_032 unSubscriberCallback failed:" + 995 JSON.stringify(err)); 996 } else { 997 console.info("====>inputMethodAbility_test_032 unSubscriberCallback finish"); 998 } 999 } 1000 1001 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1002 console.info("====>inputMethodAbility_test_032 subscriberCallback data:" 1003 + JSON.stringify(data)); 1004 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1005 let t = setTimeout(() => { 1006 try { 1007 expect(data.data).assertEqual("SUCCESS"); 1008 console.info("====>inputMethodAbility_test_032 end"); 1009 clearTimeout(t); 1010 done(); 1011 } catch (err) { 1012 console.info("====>inputMethodAbility_test_032 err:" + JSON.stringify(err)); 1013 clearTimeout(t); 1014 done(); 1015 } 1016 }, 500) 1017 } 1018 1019 let publishCallback = (err: BusinessError) => { 1020 console.info("====>inputMethodAbility_test_032 publishCallback start"); 1021 if (err) { 1022 console.info("====>inputMethodAbility_test_032 publishCallback failed:" + JSON.stringify(err)); 1023 } 1024 } 1025 1026 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1027 events: ["inputMethodAbility_test_032"] 1028 } 1029 let subscriber: ESObject; 1030 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1031 try { 1032 subscriber = data; 1033 console.info("====>inputMethodAbility_test_032 subscriber data:" + JSON.stringify(data)) 1034 commonEventManager.subscribe(subscriber, subscriberCallback); 1035 console.info("====>inputMethodAbility_test_032 subscriber finish"); 1036 } catch (err) { 1037 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1038 } 1039 1040 let t = setTimeout(async () => { 1041 clearTimeout(t); 1042 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1043 code: 32 1044 } 1045 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1046 }, 500) 1047 1048 }).catch((err: BusinessError) => { 1049 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1050 }) 1051 }); 1052 1053 /* 1054 * @tc.number inputMethodAbility_test_033 1055 * @tc.name inputMethodAbility_test_033 1056 * @tc.desc Function test 1057 * @tc.size MediumTest 1058 * @tc.type Function 1059 * @tc.level Level2 1060 */ 1061 it('inputMethodAbility_test_033', 0, async (done: Function) => { 1062 1063 let unSubscriberCallback = (err: BusinessError) => { 1064 console.info("====>inputMethodAbility_test_033 unSubscriberCallback start"); 1065 if (err) { 1066 console.info("====>inputMethodAbility_test_033 unSubscriberCallback failed:" + 1067 JSON.stringify(err)); 1068 } else { 1069 console.info("====>inputMethodAbility_test_033 unSubscriberCallback finish"); 1070 } 1071 } 1072 1073 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1074 console.info("====>inputMethodAbility_test_033 subscriberCallback data:" 1075 + JSON.stringify(data)); 1076 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1077 let t = setTimeout(() => { 1078 try { 1079 expect(data.data).assertEqual("SUCCESS"); 1080 console.info("====>inputMethodAbility_test_033 end"); 1081 clearTimeout(t); 1082 done(); 1083 } catch (err) { 1084 console.info("====>inputMethodAbility_test_033 err:" + JSON.stringify(err)); 1085 clearTimeout(t); 1086 done(); 1087 } 1088 }, 500) 1089 } 1090 1091 let publishCallback = (err: BusinessError) => { 1092 console.info("====>inputMethodAbility_test_033 publishCallback start"); 1093 if (err) { 1094 console.info("====>inputMethodAbility_test_033 publishCallback failed:" + JSON.stringify(err)); 1095 } 1096 } 1097 1098 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1099 events: ["inputMethodAbility_test_033"] 1100 } 1101 let subscriber: ESObject; 1102 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1103 try { 1104 subscriber = data; 1105 console.info("====>inputMethodAbility_test_033 subscriber data:" + JSON.stringify(data)) 1106 commonEventManager.subscribe(subscriber, subscriberCallback); 1107 console.info("====>inputMethodAbility_test_033 subscriber finish"); 1108 } catch (err) { 1109 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1110 } 1111 1112 let t = setTimeout(async () => { 1113 clearTimeout(t); 1114 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1115 code: 33 1116 } 1117 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1118 }, 500) 1119 1120 }).catch((err: BusinessError) => { 1121 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1122 }) 1123 }); 1124 1125 /* 1126 * @tc.number inputMethodAbility_test_034 1127 * @tc.name inputMethodAbility_test_034 1128 * @tc.desc Function test 1129 * @tc.size MediumTest 1130 * @tc.type Function 1131 * @tc.level Level2 1132 */ 1133 it('inputMethodAbility_test_034', 0, async (done: Function) => { 1134 1135 let unSubscriberCallback = (err: BusinessError) => { 1136 console.info("====>inputMethodAbility_test_034 unSubscriberCallback start"); 1137 if (err) { 1138 console.info("====>inputMethodAbility_test_034 unSubscriberCallback failed:" + 1139 JSON.stringify(err)); 1140 } else { 1141 console.info("====>inputMethodAbility_test_034 unSubscriberCallback finish"); 1142 } 1143 } 1144 1145 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1146 console.info("====>inputMethodAbility_test_034 subscriberCallback data:" 1147 + JSON.stringify(data)); 1148 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1149 let t = setTimeout(() => { 1150 try { 1151 expect(data.data).assertEqual("SUCCESS"); 1152 console.info("====>inputMethodAbility_test_034 end"); 1153 clearTimeout(t); 1154 done(); 1155 } catch (err) { 1156 console.info("====>inputMethodAbility_test_034 err:" + JSON.stringify(err)); 1157 clearTimeout(t); 1158 done(); 1159 } 1160 }, 500) 1161 } 1162 1163 let publishCallback = (err: BusinessError) => { 1164 console.info("====>inputMethodAbility_test_034 publishCallback start"); 1165 if (err) { 1166 console.info("====>inputMethodAbility_test_034 publishCallback failed:" + JSON.stringify(err)); 1167 } 1168 } 1169 1170 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1171 events: ["inputMethodAbility_test_034"] 1172 } 1173 let subscriber: ESObject; 1174 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1175 try { 1176 subscriber = data; 1177 console.info("====>inputMethodAbility_test_034 subscriber data:" + JSON.stringify(data)); 1178 commonEventManager.subscribe(subscriber, subscriberCallback); 1179 console.info("====>inputMethodAbility_test_034 subscriber finish"); 1180 } catch (err) { 1181 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1182 } 1183 1184 let t = setTimeout(async () => { 1185 clearTimeout(t); 1186 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1187 code: 34 1188 } 1189 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1190 }, 500) 1191 1192 }).catch((err: BusinessError) => { 1193 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1194 }) 1195 }); 1196 1197 /* 1198 * @tc.number inputMethodAbility_test_035 1199 * @tc.name inputMethodAbility_test_035 1200 * @tc.desc Function test 1201 * @tc.size MediumTest 1202 * @tc.type Function 1203 * @tc.level Level2 1204 */ 1205 it('inputMethodAbility_test_035', 0, async (done: Function) => { 1206 1207 let unSubscriberCallback = (err: BusinessError) => { 1208 console.info("====>inputMethodAbility_test_035 unSubscriberCallback start"); 1209 if (err) { 1210 console.info("====>inputMethodAbility_test_035 unSubscriberCallback failed:" + 1211 JSON.stringify(err)); 1212 } else { 1213 console.info("====>inputMethodAbility_test_035 unSubscriberCallback finish"); 1214 } 1215 } 1216 1217 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1218 console.info("====>inputMethodAbility_test_035 subscriberCallback data:" 1219 + JSON.stringify(data)); 1220 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1221 let t = setTimeout(() => { 1222 try { 1223 expect(data.data).assertEqual("SUCCESS"); 1224 console.info("====>inputMethodAbility_test_035 end"); 1225 clearTimeout(t); 1226 done(); 1227 } catch (err) { 1228 console.info("====>inputMethodAbility_test_035 err:" + JSON.stringify(err)); 1229 clearTimeout(t); 1230 done(); 1231 } 1232 }, 500) 1233 } 1234 1235 let publishCallback = (err: BusinessError) => { 1236 console.info("====>inputMethodAbility_test_035 publishCallback start"); 1237 if (err) { 1238 console.info("====>inputMethodAbility_test_035 publishCallback failed:" + JSON.stringify(err)); 1239 } 1240 } 1241 1242 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1243 events: ["inputMethodAbility_test_035"] 1244 } 1245 let subscriber: ESObject; 1246 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1247 try { 1248 subscriber = data; 1249 console.info("====>inputMethodAbility_test_035 subscriber data:" + JSON.stringify(data)); 1250 commonEventManager.subscribe(subscriber, subscriberCallback); 1251 console.info("====>inputMethodAbility_test_035 subscriber finish"); 1252 } catch (err) { 1253 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1254 } 1255 1256 let t = setTimeout(async () => { 1257 clearTimeout(t); 1258 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1259 code: 35 1260 } 1261 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1262 }, 500) 1263 1264 }).catch((err: BusinessError) => { 1265 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1266 }) 1267 }); 1268 1269 /* 1270 * @tc.number inputMethodAbility_test_036 1271 * @tc.name inputMethodAbility_test_036 1272 * @tc.desc Function test 1273 * @tc.size MediumTest 1274 * @tc.type Function 1275 * @tc.level Level2 1276 */ 1277 it('inputMethodAbility_test_036', 0, async (done: Function) => { 1278 1279 let unSubscriberCallback = (err: BusinessError) => { 1280 console.info("====>inputMethodAbility_test_036 unSubscriberCallback start"); 1281 if (err) { 1282 console.info("====>inputMethodAbility_test_036 unSubscriberCallback failed:" + 1283 JSON.stringify(err)); 1284 } else { 1285 console.info("====>inputMethodAbility_test_036 unSubscriberCallback finish"); 1286 } 1287 } 1288 1289 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1290 console.info("====>inputMethodAbility_test_036 subscriberCallback data:" 1291 + JSON.stringify(data)); 1292 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1293 let t = setTimeout(() => { 1294 try { 1295 expect(data.data).assertEqual("SUCCESS"); 1296 console.info("====>inputMethodAbility_test_036 end"); 1297 clearTimeout(t); 1298 done(); 1299 } catch (err) { 1300 console.info("====>inputMethodAbility_test_036 err:" + JSON.stringify(err)); 1301 clearTimeout(t); 1302 done(); 1303 } 1304 }, 500) 1305 } 1306 1307 let publishCallback = (err: BusinessError) => { 1308 console.info("====>inputMethodAbility_test_036 publishCallback start"); 1309 if (err) { 1310 console.info("====>inputMethodAbility_test_036 publishCallback failed:" + JSON.stringify(err)); 1311 } 1312 } 1313 1314 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1315 events: ["inputMethodAbility_test_036"] 1316 } 1317 let subscriber: ESObject; 1318 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1319 try { 1320 subscriber = data; 1321 console.info("====>inputMethodAbility_test_036 subscriber data:" + JSON.stringify(data)); 1322 commonEventManager.subscribe(subscriber, subscriberCallback); 1323 console.info("====>inputMethodAbility_test_036 subscriber finish"); 1324 } catch (err) { 1325 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1326 } 1327 1328 let t = setTimeout(async () => { 1329 clearTimeout(t); 1330 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1331 code: 36 1332 }; 1333 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1334 }, 500) 1335 1336 }).catch((err: BusinessError) => { 1337 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1338 }) 1339 }); 1340 1341 /* 1342 * @tc.number inputMethodAbility_test_037 1343 * @tc.name inputMethodAbility_test_037 1344 * @tc.desc Function test 1345 * @tc.size MediumTest 1346 * @tc.type Function 1347 * @tc.level Level2 1348 */ 1349 it('inputMethodAbility_test_037', 0, async (done: Function) => { 1350 1351 let unSubscriberCallback = (err: BusinessError) => { 1352 console.info("====>inputMethodAbility_test_037 unSubscriberCallback start"); 1353 if (err) { 1354 console.info("====>inputMethodAbility_test_037 unSubscriberCallback failed:" + 1355 JSON.stringify(err)); 1356 } else { 1357 console.info("====>inputMethodAbility_test_037 unSubscriberCallback finish"); 1358 } 1359 } 1360 1361 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1362 console.info("====>inputMethodAbility_test_037 subscriberCallback data:" 1363 + JSON.stringify(data)); 1364 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1365 let t = setTimeout(() => { 1366 try { 1367 expect(data.data).assertEqual("SUCCESS"); 1368 console.info("====>inputMethodAbility_test_037 end"); 1369 clearTimeout(t); 1370 done(); 1371 } catch (err) { 1372 console.info("====>inputMethodAbility_test_037 err:" + JSON.stringify(err)); 1373 clearTimeout(t); 1374 done(); 1375 } 1376 }, 500) 1377 } 1378 1379 let publishCallback = (err: BusinessError) => { 1380 console.info("====>inputMethodAbility_test_037 publishCallback start"); 1381 if (err) { 1382 console.info("====>inputMethodAbility_test_037 publishCallback failed:" + JSON.stringify(err)); 1383 } 1384 } 1385 1386 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1387 events: ["inputMethodAbility_test_037"] 1388 } 1389 let subscriber: ESObject; 1390 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1391 try { 1392 subscriber = data; 1393 console.info("====>inputMethodAbility_test_037 subscriber data:" + JSON.stringify(data)) 1394 commonEventManager.subscribe(subscriber, subscriberCallback); 1395 console.info("====>inputMethodAbility_test_037 subscriber finish"); 1396 } catch (err) { 1397 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1398 } 1399 1400 let t = setTimeout(async () => { 1401 clearTimeout(t); 1402 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1403 code: 37 1404 } 1405 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1406 }, 500) 1407 1408 }).catch((err: BusinessError) => { 1409 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1410 }) 1411 }); 1412 1413 /* 1414 * @tc.number inputMethodAbility_test_038 1415 * @tc.name inputMethodAbility_test_038 1416 * @tc.desc Function test 1417 * @tc.size MediumTest 1418 * @tc.type Function 1419 * @tc.level Level2 1420 */ 1421 it('inputMethodAbility_test_038', 0, async (done: Function) => { 1422 1423 let unSubscriberCallback = (err: BusinessError) => { 1424 console.info("====>inputMethodAbility_test_038 unSubscriberCallback start"); 1425 if (err) { 1426 console.info("====>inputMethodAbility_test_038 unSubscriberCallback failed:" + 1427 JSON.stringify(err)); 1428 } else { 1429 console.info("====>inputMethodAbility_test_038 unSubscriberCallback finish"); 1430 } 1431 } 1432 1433 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1434 console.info("====>inputMethodAbility_test_038 subscriberCallback data:" 1435 + JSON.stringify(data)); 1436 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1437 let t = setTimeout(() => { 1438 try { 1439 expect(data.data).assertEqual("SUCCESS"); 1440 console.info("====>inputMethodAbility_test_038 end"); 1441 clearTimeout(t); 1442 done(); 1443 } catch (err) { 1444 console.info("====>inputMethodAbility_test_038 err:" + JSON.stringify(err)); 1445 clearTimeout(t); 1446 done(); 1447 } 1448 }, 500) 1449 } 1450 1451 let publishCallback = (err: BusinessError) => { 1452 console.info("====>inputMethodAbility_test_038 publishCallback start"); 1453 if (err) { 1454 console.info("====>inputMethodAbility_test_038 publishCallback failed:" + JSON.stringify(err)); 1455 } 1456 } 1457 1458 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1459 events: ["inputMethodAbility_test_038"] 1460 } 1461 let subscriber: ESObject; 1462 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1463 try { 1464 subscriber = data; 1465 console.info("====>inputMethodAbility_test_038 subscriber data:" + JSON.stringify(data)); 1466 commonEventManager.subscribe(subscriber, subscriberCallback); 1467 console.info("====>inputMethodAbility_test_038 subscriber finish"); 1468 } catch (err) { 1469 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1470 } 1471 1472 let t = setTimeout(async () => { 1473 clearTimeout(t); 1474 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1475 code: 38 1476 } 1477 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1478 }, 500) 1479 1480 }).catch((err: BusinessError) => { 1481 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1482 }) 1483 }); 1484 1485 /* 1486 * @tc.number inputMethodAbility_test_039 1487 * @tc.name inputMethodAbility_test_039 1488 * @tc.desc Function test 1489 * @tc.size MediumTest 1490 * @tc.type Function 1491 * @tc.level Level2 1492 */ 1493 it('inputMethodAbility_test_039', 0, async (done: Function) => { 1494 1495 let unSubscriberCallback = (err: BusinessError) => { 1496 console.info("====>inputMethodAbility_test_039 unSubscriberCallback start"); 1497 if (err) { 1498 console.info("====>inputMethodAbility_test_039 unSubscriberCallback failed:" + 1499 JSON.stringify(err)); 1500 } else { 1501 console.info("====>inputMethodAbility_test_039 unSubscriberCallback finish"); 1502 } 1503 } 1504 1505 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1506 console.info("====>inputMethodAbility_test_039 subscriberCallback data:" 1507 + JSON.stringify(data)); 1508 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1509 let t = setTimeout(() => { 1510 try { 1511 expect(data.data).assertEqual("SUCCESS"); 1512 console.info("====>inputMethodAbility_test_039 end"); 1513 clearTimeout(t); 1514 done(); 1515 } catch (err) { 1516 console.info("====>inputMethodAbility_test_039 err:" + JSON.stringify(err)); 1517 clearTimeout(t); 1518 done(); 1519 } 1520 }, 500) 1521 } 1522 1523 let publishCallback = (err: BusinessError) => { 1524 console.info("====>inputMethodAbility_test_039 publishCallback start"); 1525 if (err) { 1526 console.info("====>inputMethodAbility_test_039 publishCallback failed:" + JSON.stringify(err)); 1527 } 1528 } 1529 1530 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1531 events: ["inputMethodAbility_test_039"] 1532 } 1533 let subscriber: ESObject; 1534 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1535 try { 1536 subscriber = data; 1537 console.info("====>inputMethodAbility_test_039 subscriber data:" + JSON.stringify(data)) 1538 commonEventManager.subscribe(subscriber, subscriberCallback); 1539 console.info("====>inputMethodAbility_test_039 subscriber finish"); 1540 } catch (err) { 1541 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1542 } 1543 1544 let t = setTimeout(async () => { 1545 clearTimeout(t); 1546 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1547 code: 39 1548 } 1549 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1550 }, 500) 1551 1552 }).catch((err: BusinessError) => { 1553 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1554 }) 1555 }); 1556 1557 /* 1558 * @tc.number inputMethodAbility_test_040 1559 * @tc.name inputMethodAbility_test_040 1560 * @tc.desc Function test 1561 * @tc.size MediumTest 1562 * @tc.type Function 1563 * @tc.level Level2 1564 */ 1565 it('inputMethodAbility_test_040', 0, async (done: Function) => { 1566 1567 let unSubscriberCallback = (err: BusinessError) => { 1568 console.info("====>inputMethodAbility_test_040 unSubscriberCallback start"); 1569 if (err) { 1570 console.info("====>inputMethodAbility_test_040 unSubscriberCallback failed:" + 1571 JSON.stringify(err)); 1572 } else { 1573 console.info("====>inputMethodAbility_test_040 unSubscriberCallback finish"); 1574 } 1575 } 1576 1577 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1578 console.info("====>inputMethodAbility_test_040 subscriberCallback data:" 1579 + JSON.stringify(data)); 1580 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1581 let t = setTimeout(() => { 1582 try { 1583 expect(data.data).assertEqual("SUCCESS"); 1584 console.info("====>inputMethodAbility_test_040 end"); 1585 clearTimeout(t); 1586 done(); 1587 } catch (err) { 1588 console.info("====>inputMethodAbility_test_040 err:" + JSON.stringify(err)); 1589 clearTimeout(t); 1590 done(); 1591 } 1592 }, 500) 1593 } 1594 1595 let publishCallback = (err: BusinessError) => { 1596 console.info("====>inputMethodAbility_test_040 publishCallback start"); 1597 if (err) { 1598 console.info("====>inputMethodAbility_test_040 publishCallback failed:" + JSON.stringify(err)); 1599 } 1600 } 1601 1602 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1603 events: ["inputMethodAbility_test_040"] 1604 } 1605 let subscriber: ESObject; 1606 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1607 try { 1608 subscriber = data; 1609 console.info("====>inputMethodAbility_test_040 subscriber data:" + JSON.stringify(data)) 1610 commonEventManager.subscribe(subscriber, subscriberCallback); 1611 console.info("====>inputMethodAbility_test_040 subscriber finish"); 1612 } catch (err) { 1613 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1614 } 1615 1616 let t = setTimeout(async () => { 1617 clearTimeout(t); 1618 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1619 code: 40 1620 } 1621 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1622 }, 500) 1623 1624 }).catch((err: BusinessError) => { 1625 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1626 }) 1627 }); 1628 1629 /* 1630 * @tc.number inputMethodAbility_test_041 1631 * @tc.name inputMethodAbility_test_041 1632 * @tc.desc Function test 1633 * @tc.size MediumTest 1634 * @tc.type Function 1635 * @tc.level Level2 1636 */ 1637 it('inputMethodAbility_test_041', 0, async (done: Function) => { 1638 1639 let unSubscriberCallback = (err: BusinessError) => { 1640 console.info("====>inputMethodAbility_test_041 unSubscriberCallback start"); 1641 if (err) { 1642 console.info("====>inputMethodAbility_test_041 unSubscriberCallback failed:" + 1643 JSON.stringify(err)); 1644 } else { 1645 console.info("====>inputMethodAbility_test_041 unSubscriberCallback finish"); 1646 } 1647 } 1648 1649 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1650 console.info("====>inputMethodAbility_test_041 subscriberCallback data:" 1651 + JSON.stringify(data)); 1652 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1653 let t = setTimeout(() => { 1654 try { 1655 expect(data.data).assertEqual("SUCCESS"); 1656 console.info("====>inputMethodAbility_test_041 end"); 1657 clearTimeout(t); 1658 done(); 1659 } catch (err) { 1660 console.info("====>inputMethodAbility_test_041 err:" + JSON.stringify(err)); 1661 clearTimeout(t); 1662 done(); 1663 } 1664 }, 500) 1665 } 1666 1667 let publishCallback = (err: BusinessError) => { 1668 console.info("====>inputMethodAbility_test_041 publishCallback start"); 1669 if (err) { 1670 console.info("====>inputMethodAbility_test_041 publishCallback failed:" + JSON.stringify(err)); 1671 } 1672 } 1673 1674 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1675 events: ["inputMethodAbility_test_041"] 1676 } 1677 let subscriber: ESObject; 1678 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1679 try { 1680 subscriber = data; 1681 console.info("====>inputMethodAbility_test_041 subscriber data:" + JSON.stringify(data)) 1682 commonEventManager.subscribe(subscriber, subscriberCallback); 1683 console.info("====>inputMethodAbility_test_041 subscriber finish"); 1684 } catch (err) { 1685 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1686 } 1687 1688 let t = setTimeout(async () => { 1689 clearTimeout(t); 1690 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1691 code: 41 1692 } 1693 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1694 }, 500) 1695 1696 }).catch((err: BusinessError) => { 1697 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1698 }) 1699 }); 1700 1701 /* 1702 * @tc.number inputMethodAbility_test_042 1703 * @tc.name inputMethodAbility_test_042 1704 * @tc.desc Function test 1705 * @tc.size MediumTest 1706 * @tc.type Function 1707 * @tc.level Level2 1708 */ 1709 it('inputMethodAbility_test_042', 0, async (done: Function) => { 1710 1711 let unSubscriberCallback = (err: BusinessError) => { 1712 console.info("====>inputMethodAbility_test_042 unSubscriberCallback start"); 1713 if (err) { 1714 console.info("====>inputMethodAbility_test_042 unSubscriberCallback failed:" + 1715 JSON.stringify(err)); 1716 } else { 1717 console.info("====>inputMethodAbility_test_042 unSubscriberCallback finish"); 1718 } 1719 } 1720 1721 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1722 console.info("====>inputMethodAbility_test_042 subscriberCallback data:" 1723 + JSON.stringify(data)); 1724 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1725 let t = setTimeout(() => { 1726 try { 1727 expect(data.data).assertEqual("SUCCESS"); 1728 console.info("====>inputMethodAbility_test_042 end"); 1729 clearTimeout(t); 1730 done(); 1731 } catch (err) { 1732 console.info("====>inputMethodAbility_test_042 err:" + JSON.stringify(err)); 1733 clearTimeout(t); 1734 done(); 1735 } 1736 }, 500) 1737 } 1738 1739 let publishCallback = (err: BusinessError) => { 1740 console.info("====>inputMethodAbility_test_042 publishCallback start"); 1741 if (err) { 1742 console.info("====>inputMethodAbility_test_042 publishCallback failed:" + JSON.stringify(err)); 1743 } 1744 } 1745 1746 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1747 events: ["inputMethodAbility_test_042"] 1748 } 1749 let subscriber: ESObject; 1750 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1751 try { 1752 subscriber = data; 1753 console.info("====>inputMethodAbility_test_042 subscriber data:" + JSON.stringify(data)); 1754 commonEventManager.subscribe(subscriber, subscriberCallback); 1755 console.info("====>inputMethodAbility_test_042 subscriber finish"); 1756 } catch (err) { 1757 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1758 } 1759 1760 let t = setTimeout(async () => { 1761 clearTimeout(t); 1762 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1763 code: 42 1764 } 1765 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1766 }, 500) 1767 1768 }).catch((err: BusinessError) => { 1769 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1770 }) 1771 }); 1772 1773 /* 1774 * @tc.number inputMethodAbility_test_043 1775 * @tc.name inputMethodAbility_test_043 1776 * @tc.desc Function test 1777 * @tc.size MediumTest 1778 * @tc.type Function 1779 * @tc.level Level2 1780 */ 1781 it('inputMethodAbility_test_043', 0, async (done: Function) => { 1782 1783 let unSubscriberCallback = (err: BusinessError) => { 1784 console.info("====>inputMethodAbility_test_043 unSubscriberCallback start"); 1785 if (err) { 1786 console.info("====>inputMethodAbility_test_043 unSubscriberCallback failed:" + 1787 JSON.stringify(err)); 1788 } else { 1789 console.info("====>inputMethodAbility_test_043 unSubscriberCallback finish"); 1790 } 1791 } 1792 1793 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1794 console.info("====>inputMethodAbility_test_043 subscriberCallback data:" 1795 + JSON.stringify(data)); 1796 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1797 let t = setTimeout(() => { 1798 try { 1799 expect(data.data).assertEqual("SUCCESS"); 1800 console.info("====>inputMethodAbility_test_043 end"); 1801 clearTimeout(t); 1802 done(); 1803 } catch (err) { 1804 console.info("====>inputMethodAbility_test_043 err:" + JSON.stringify(err)); 1805 clearTimeout(t); 1806 done(); 1807 } 1808 }, 500) 1809 } 1810 1811 let publishCallback = (err: BusinessError) => { 1812 console.info("====>inputMethodAbility_test_043 publishCallback start"); 1813 if (err) { 1814 console.info("====>inputMethodAbility_test_043 publishCallback failed:" + JSON.stringify(err)); 1815 } 1816 } 1817 1818 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1819 events: ["inputMethodAbility_test_043"] 1820 } 1821 let subscriber: ESObject; 1822 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1823 try { 1824 subscriber = data; 1825 console.info("====>inputMethodAbility_test_043 subscriber data:" + JSON.stringify(data)); 1826 commonEventManager.subscribe(subscriber, subscriberCallback); 1827 console.info("====>inputMethodAbility_test_043 subscriber finish"); 1828 } catch (err) { 1829 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1830 } 1831 1832 let t = setTimeout(async () => { 1833 clearTimeout(t); 1834 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1835 code: 43 1836 } 1837 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1838 }, 500) 1839 1840 }).catch((err: BusinessError) => { 1841 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1842 }) 1843 }); 1844 1845 /* 1846 * @tc.number inputMethodAbility_test_044 1847 * @tc.name inputMethodAbility_test_044 1848 * @tc.desc Function test 1849 * @tc.size MediumTest 1850 * @tc.type Function 1851 * @tc.level Level2 1852 */ 1853 it('inputMethodEngine_test_044', 0, async (done: Function) => { 1854 let keyType = inputMethodEngine.WINDOW_TYPE_INPUT_METHOD_FLOAT; 1855 console.info("====>inputMethodEngine_test_044 result:" + keyType); 1856 expect(keyType).assertEqual(2105); 1857 done(); 1858 }); 1859 1860 /* 1861 * @tc.number inputMethodAbility_test_045 1862 * @tc.name inputMethodAbility_test_045 1863 * @tc.desc Function test 1864 * @tc.size MediumTest 1865 * @tc.type Function 1866 * @tc.level Level2 1867 */ 1868 it('inputMethodAbility_test_045', 0, async (done: Function) => { 1869 1870 let unSubscriberCallback = (err: BusinessError) => { 1871 console.info("====>inputMethodAbility_test_045 unSubscriberCallback start"); 1872 if (err) { 1873 console.info("====>inputMethodAbility_test_045 unSubscriberCallback failed:" + 1874 JSON.stringify(err)); 1875 } else { 1876 console.info("====>inputMethodAbility_test_045 unSubscriberCallback finish"); 1877 } 1878 } 1879 1880 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1881 console.info("====>inputMethodAbility_test_045 subscriberCallback data:" 1882 + JSON.stringify(data)); 1883 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1884 let t = setTimeout(() => { 1885 try { 1886 expect(data.data).assertEqual("SUCCESS"); 1887 console.info("====>inputMethodAbility_test_045 end"); 1888 clearTimeout(t); 1889 done(); 1890 } catch (err) { 1891 console.info("====>inputMethodAbility_test_045 err:" + JSON.stringify(err)); 1892 clearTimeout(t); 1893 done(); 1894 } 1895 }, 500) 1896 } 1897 1898 let publishCallback = (err: BusinessError) => { 1899 console.info("====>inputMethodAbility_test_045 publishCallback start"); 1900 if (err) { 1901 console.info("====>inputMethodAbility_test_045 publishCallback failed:" + JSON.stringify(err)); 1902 } 1903 } 1904 1905 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1906 events: ["inputMethodAbility_test_045"] 1907 } 1908 let subscriber: ESObject; 1909 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1910 try { 1911 subscriber = data; 1912 console.info("====>inputMethodAbility_test_045 subscriber data:" + JSON.stringify(data)); 1913 commonEventManager.subscribe(subscriber, subscriberCallback); 1914 console.info("====>inputMethodAbility_test_045 subscriber finish"); 1915 } catch (err) { 1916 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1917 } 1918 1919 let t = setTimeout(async () => { 1920 clearTimeout(t); 1921 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1922 code: 45 1923 } 1924 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1925 }, 500) 1926 1927 }).catch((err: BusinessError) => { 1928 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 1929 }) 1930 }); 1931 1932 /* 1933 * @tc.number inputMethodAbility_test_046 1934 * @tc.name inputMethodAbility_test_046 1935 * @tc.desc Function test 1936 * @tc.size MediumTest 1937 * @tc.type Function 1938 * @tc.level Level2 1939 */ 1940 it('inputMethodAbility_test_046', 0, async (done: Function) => { 1941 1942 let unSubscriberCallback = (err: BusinessError) => { 1943 console.info("====>inputMethodAbility_test_046 unSubscriberCallback start"); 1944 if (err) { 1945 console.info("====>inputMethodAbility_test_046 unSubscriberCallback failed:" + 1946 JSON.stringify(err)); 1947 } else { 1948 console.info("====>inputMethodAbility_test_046 unSubscriberCallback finish") 1949 } 1950 } 1951 1952 let subscriberCallback = (err: BusinessError, data: ESObject) => { 1953 console.info("====>inputMethodAbility_test_046 subscriberCallback data:" 1954 + JSON.stringify(data)); 1955 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 1956 let t = setTimeout(() => { 1957 try { 1958 expect(data.data).assertEqual("SUCCESS"); 1959 console.info("====>inputMethodAbility_test_046 end"); 1960 clearTimeout(t); 1961 done(); 1962 } catch (err) { 1963 console.info("====>inputMethodAbility_test_046 err:" + JSON.stringify(err)); 1964 clearTimeout(t); 1965 done(); 1966 } 1967 }, 500) 1968 } 1969 1970 let publishCallback = (err: BusinessError) => { 1971 console.info("====>inputMethodAbility_test_046 publishCallback start"); 1972 if (err) { 1973 console.info("====>inputMethodAbility_test_046 publishCallback failed:" + JSON.stringify(err)); 1974 } 1975 } 1976 1977 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 1978 events: ["inputMethodAbility_test_046"] 1979 } 1980 let subscriber: ESObject; 1981 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 1982 try { 1983 subscriber = data; 1984 console.info("====>inputMethodAbility_test_046 subscriber data:" + JSON.stringify(data)); 1985 commonEventManager.subscribe(subscriber, subscriberCallback); 1986 console.info("====>inputMethodAbility_test_046 subscriber finish"); 1987 } catch (err) { 1988 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 1989 } 1990 1991 let t = setTimeout(async () => { 1992 clearTimeout(t); 1993 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 1994 code: 46 1995 } 1996 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 1997 }, 500) 1998 1999 }).catch((err: BusinessError) => { 2000 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2001 }) 2002 }); 2003 2004 /* 2005 * @tc.number inputMethodAbility_test_047 2006 * @tc.name inputMethodAbility_test_047 2007 * @tc.desc Function test 2008 * @tc.size MediumTest 2009 * @tc.type Function 2010 * @tc.level Level2 2011 */ 2012 it('inputMethodAbility_test_047', 0, async (done: Function) => { 2013 2014 let unSubscriberCallback = (err: BusinessError) => { 2015 console.info("====>inputMethodAbility_test_047 unSubscriberCallback start"); 2016 if (err) { 2017 console.info("====>inputMethodAbility_test_047 unSubscriberCallback failed:" + 2018 JSON.stringify(err)); 2019 } else { 2020 console.info("====>inputMethodAbility_test_047 unSubscriberCallback finish") 2021 } 2022 } 2023 2024 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2025 console.info("====>inputMethodAbility_test_047 subscriberCallback data:" 2026 + JSON.stringify(data)); 2027 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2028 let t = setTimeout(() => { 2029 try { 2030 expect(data.data).assertEqual("SUCCESS"); 2031 console.info("====>inputMethodAbility_test_047 end"); 2032 clearTimeout(t); 2033 done(); 2034 } catch (err) { 2035 console.info("====>inputMethodAbility_test_047 err:" + JSON.stringify(err)); 2036 clearTimeout(t); 2037 done(); 2038 } 2039 }, 500) 2040 } 2041 2042 let publishCallback = (err: BusinessError) => { 2043 console.info("====>inputMethodAbility_test_047 publishCallback start"); 2044 if (err) { 2045 console.info("====>inputMethodAbility_test_047 publishCallback failed:" + JSON.stringify(err)); 2046 } 2047 } 2048 2049 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2050 events: ["inputMethodAbility_test_047"] 2051 } 2052 let subscriber: ESObject; 2053 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2054 try { 2055 subscriber = data; 2056 console.info("====>inputMethodAbility_test_047 subscriber data:" + JSON.stringify(data)); 2057 commonEventManager.subscribe(subscriber, subscriberCallback); 2058 console.info("====>inputMethodAbility_test_047 subscriber finish"); 2059 } catch (err) { 2060 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2061 } 2062 2063 let t = setTimeout(async () => { 2064 clearTimeout(t); 2065 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2066 code: 47 2067 } 2068 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2069 }, 500) 2070 2071 }).catch((err: BusinessError) => { 2072 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2073 }) 2074 }); 2075 2076 /* 2077 * @tc.number inputMethodAbility_test_048 2078 * @tc.name inputMethodAbility_test_048 2079 * @tc.desc Function test 2080 * @tc.size MediumTest 2081 * @tc.type Function 2082 * @tc.level Level2 2083 */ 2084 it('inputMethodAbility_test_048', 0, async (done: Function) => { 2085 2086 let unSubscriberCallback = (err: BusinessError) => { 2087 console.info("====>inputMethodAbility_test_048 unSubscriberCallback start"); 2088 if (err) { 2089 console.info("====>inputMethodAbility_test_048 unSubscriberCallback failed:" + 2090 JSON.stringify(err)); 2091 } else { 2092 console.info("====>inputMethodAbility_test_048 unSubscriberCallback finish"); 2093 } 2094 } 2095 2096 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2097 console.info("====>inputMethodAbility_test_048 subscriberCallback data:" 2098 + JSON.stringify(data)); 2099 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2100 let t = setTimeout(() => { 2101 try { 2102 expect(data.data).assertEqual("SUCCESS"); 2103 console.info("====>inputMethodAbility_test_048 end"); 2104 clearTimeout(t); 2105 done(); 2106 } catch (err) { 2107 console.info("====>inputMethodAbility_test_048 err:" + JSON.stringify(err)); 2108 clearTimeout(t); 2109 done(); 2110 } 2111 }, 500) 2112 } 2113 2114 let publishCallback = (err: BusinessError) => { 2115 console.info("====>inputMethodAbility_test_048 publishCallback start"); 2116 if (err) { 2117 console.info("====>inputMethodAbility_test_048 publishCallback failed:" + JSON.stringify(err)); 2118 } 2119 } 2120 2121 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2122 events: ["inputMethodAbility_test_048"] 2123 } 2124 let subscriber: ESObject; 2125 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2126 try { 2127 subscriber = data; 2128 console.info("====>inputMethodAbility_test_048 subscriber data:" + JSON.stringify(data)); 2129 commonEventManager.subscribe(subscriber, subscriberCallback); 2130 console.info("====>inputMethodAbility_test_048 subscriber finish"); 2131 } catch (err) { 2132 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2133 } 2134 2135 let t = setTimeout(async () => { 2136 clearTimeout(t); 2137 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2138 code: 48 2139 } 2140 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2141 }, 500) 2142 2143 }).catch((err: BusinessError) => { 2144 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2145 }) 2146 }); 2147 2148 /* 2149 * @tc.number inputMethodAbility_test_049 2150 * @tc.name inputMethodAbility_test_049 2151 * @tc.desc Function test 2152 * @tc.size MediumTest 2153 * @tc.type Function 2154 * @tc.level Level2 2155 */ 2156 it('inputMethodAbility_test_049', 0, async (done: Function) => { 2157 2158 let unSubscriberCallback = (err: BusinessError) => { 2159 console.info("====>inputMethodAbility_test_049 unSubscriberCallback start"); 2160 if (err) { 2161 console.info("====>inputMethodAbility_test_049 unSubscriberCallback failed:" + 2162 JSON.stringify(err)); 2163 } else { 2164 console.info("====>inputMethodAbility_test_049 unSubscriberCallback finish"); 2165 } 2166 } 2167 2168 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2169 console.info("====>inputMethodAbility_test_049 subscriberCallback data:" 2170 + JSON.stringify(data)); 2171 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2172 let t = setTimeout(() => { 2173 try { 2174 expect(data.data).assertEqual("SUCCESS"); 2175 console.info("====>inputMethodAbility_test_049 end"); 2176 clearTimeout(t); 2177 done(); 2178 } catch (err) { 2179 console.info("====>inputMethodAbility_test_049 err:" + JSON.stringify(err)); 2180 clearTimeout(t); 2181 done(); 2182 } 2183 }, 500) 2184 } 2185 2186 let publishCallback = (err: BusinessError) => { 2187 console.info("====>inputMethodAbility_test_049 publishCallback start"); 2188 if (err) { 2189 console.info("====>inputMethodAbility_test_049 publishCallback failed:" + JSON.stringify(err)); 2190 } 2191 } 2192 2193 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2194 events: ["inputMethodAbility_test_049"] 2195 } 2196 let subscriber: ESObject; 2197 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2198 try { 2199 subscriber = data; 2200 console.info("====>inputMethodAbility_test_049 subscriber data:" + JSON.stringify(data)); 2201 commonEventManager.subscribe(subscriber, subscriberCallback); 2202 console.info("====>inputMethodAbility_test_049 subscriber finish"); 2203 } catch (err) { 2204 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2205 } 2206 2207 let t = setTimeout(async () => { 2208 clearTimeout(t); 2209 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2210 code: 49 2211 } 2212 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2213 }, 500) 2214 2215 }).catch((err: BusinessError) => { 2216 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2217 }) 2218 }); 2219 2220 /* 2221 * @tc.number inputMethodAbility_test_050 2222 * @tc.name inputMethodAbility_test_050 2223 * @tc.desc Function test 2224 * @tc.size MediumTest 2225 * @tc.type Function 2226 * @tc.level Level2 2227 */ 2228 it('inputMethodAbility_test_050', 0, async (done: Function) => { 2229 2230 let unSubscriberCallback = (err: BusinessError) => { 2231 console.info("====>inputMethodAbility_test_050 unSubscriberCallback start"); 2232 if (err) { 2233 console.info("====>inputMethodAbility_test_050 unSubscriberCallback failed:" + 2234 JSON.stringify(err)); 2235 } else { 2236 console.info("====>inputMethodAbility_test_050 unSubscriberCallback finish"); 2237 } 2238 } 2239 2240 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2241 console.info("====>inputMethodAbility_test_050 subscriberCallback data:" 2242 + JSON.stringify(data)); 2243 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2244 let t = setTimeout(() => { 2245 try { 2246 expect(data.data).assertEqual("SUCCESS"); 2247 console.info("====>inputMethodAbility_test_050 end"); 2248 clearTimeout(t); 2249 done(); 2250 } catch (err) { 2251 console.info("====>inputMethodAbility_test_050 err:" + JSON.stringify(err)); 2252 clearTimeout(t); 2253 done(); 2254 } 2255 }, 500) 2256 } 2257 2258 let publishCallback = (err: BusinessError) => { 2259 console.info("====>inputMethodAbility_test_050 publishCallback start"); 2260 if (err) { 2261 console.info("====>inputMethodAbility_test_050 publishCallback failed:" + JSON.stringify(err)); 2262 } 2263 } 2264 2265 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2266 events: ["inputMethodAbility_test_050"] 2267 } 2268 let subscriber: ESObject; 2269 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2270 try { 2271 subscriber = data; 2272 console.info("====>inputMethodAbility_test_050 subscriber data:" + JSON.stringify(data)); 2273 commonEventManager.subscribe(subscriber, subscriberCallback); 2274 console.info("====>inputMethodAbility_test_050 subscriber finish") 2275 } catch (err) { 2276 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2277 } 2278 2279 let t = setTimeout(async () => { 2280 clearTimeout(t); 2281 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2282 code: 50 2283 } 2284 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2285 }, 500) 2286 2287 }).catch((err: BusinessError) => { 2288 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2289 }) 2290 }); 2291 2292 /* 2293 * @tc.number inputMethodAbility_test_070 2294 * @tc.name inputMethodAbility_test_070 2295 * @tc.desc Function test 2296 * @tc.size MediumTest 2297 * @tc.type Function 2298 * @tc.level Level2 2299 */ 2300 it('inputMethodAbility_test_070', 0, async (done: Function) => { 2301 2302 let unSubscriberCallback = (err: BusinessError) => { 2303 console.info("====>inputMethodAbility_test_070 unSubscriberCallback start"); 2304 if (err) { 2305 console.info("====>inputMethodAbility_test_070 unSubscriberCallback failed:" + 2306 JSON.stringify(err)); 2307 } else { 2308 console.info("====>inputMethodAbility_test_070 unSubscriberCallback finish"); 2309 } 2310 } 2311 2312 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2313 console.info("====>inputMethodAbility_test_070 subscriberCallback data:" 2314 + JSON.stringify(data)); 2315 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2316 let t = setTimeout(() => { 2317 try { 2318 expect(data.data).assertEqual("SUCCESS"); 2319 console.info("====>inputMethodAbility_test_070 end"); 2320 clearTimeout(t); 2321 done(); 2322 } catch (err) { 2323 console.info("====>inputMethodAbility_test_070 err:" + JSON.stringify(err)); 2324 clearTimeout(t); 2325 done(); 2326 } 2327 }, 1000) 2328 } 2329 2330 let publishCallback = (err: BusinessError) => { 2331 console.info("====>inputMethodAbility_test_070 publishCallback start"); 2332 if (err) { 2333 console.info("====>inputMethodAbility_test_070 publishCallback failed:" + JSON.stringify(err)); 2334 } else { 2335 let t = setTimeout(() => { 2336 runCmd(); 2337 clearTimeout(t) 2338 }, 300) 2339 } 2340 } 2341 2342 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2343 events: ["inputMethodAbility_test_070"] 2344 } 2345 let subscriber: ESObject; 2346 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2347 try { 2348 subscriber = data; 2349 console.info("====>inputMethodAbility_test_070 subscriber data:" + JSON.stringify(data)); 2350 commonEventManager.subscribe(subscriber, subscriberCallback); 2351 console.info("====>inputMethodAbility_test_070 subscriber finish"); 2352 } catch (err) { 2353 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2354 } 2355 2356 let t = setTimeout(async () => { 2357 clearTimeout(t); 2358 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2359 code: 70 2360 } 2361 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2362 }, 500) 2363 2364 }).catch((err: BusinessError) => { 2365 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2366 }) 2367 }); 2368 2369 /* 2370 * @tc.number inputMethodAbility_test_071 2371 * @tc.name inputMethodAbility_test_071 2372 * @tc.desc Function test 2373 * @tc.size MediumTest 2374 * @tc.type Function 2375 * @tc.level Level2 2376 */ 2377 it('inputMethodAbility_test_071', 0, async (done: Function) => { 2378 2379 let unSubscriberCallback = (err: BusinessError) => { 2380 console.info("====>inputMethodAbility_test_071 unSubscriberCallback start"); 2381 if (err) { 2382 console.info("====>inputMethodAbility_test_071 unSubscriberCallback failed:" + 2383 JSON.stringify(err)); 2384 } else { 2385 console.info("====>inputMethodAbility_test_071 unSubscriberCallback finish"); 2386 } 2387 } 2388 2389 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2390 console.info("====>inputMethodAbility_test_071 subscriberCallback data:" 2391 + JSON.stringify(data)); 2392 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2393 let t = setTimeout(() => { 2394 try { 2395 expect(data.data).assertEqual("SUCCESS"); 2396 console.info("====>inputMethodAbility_test_071 end"); 2397 clearTimeout(t); 2398 done(); 2399 } catch (err) { 2400 console.info("====>inputMethodAbility_test_071 err:" + JSON.stringify(err)); 2401 clearTimeout(t); 2402 done(); 2403 } 2404 }, 1000) 2405 } 2406 2407 let publishCallback = (err: BusinessError) => { 2408 console.info("====>inputMethodAbility_test_071 publishCallback start"); 2409 if (err) { 2410 console.info("====>inputMethodAbility_test_071 publishCallback failed:" + JSON.stringify(err)); 2411 } else { 2412 let t = setTimeout(() => { 2413 runCmd(); 2414 clearTimeout(t) 2415 }, 200) 2416 } 2417 } 2418 2419 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2420 events: ["inputMethodAbility_test_071"] 2421 } 2422 let subscriber: ESObject; 2423 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2424 try { 2425 subscriber = data; 2426 console.info("====>inputMethodAbility_test_071 subscriber data:" + JSON.stringify(data)); 2427 commonEventManager.subscribe(subscriber, subscriberCallback); 2428 console.info("====>inputMethodAbility_test_071 subscriber finish"); 2429 } catch (err) { 2430 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2431 } 2432 2433 let t = setTimeout(async () => { 2434 clearTimeout(t); 2435 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2436 code: 71 2437 } 2438 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2439 }, 500) 2440 2441 }).catch((err: BusinessError) => { 2442 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2443 }) 2444 }); 2445 2446 /* 2447 * @tc.number inputMethodAbility_test_072 2448 * @tc.name inputMethodAbility_test_072 2449 * @tc.desc Function test 2450 * @tc.size MediumTest 2451 * @tc.type Function 2452 * @tc.level Level2 2453 */ 2454 it('inputMethodAbility_test_072', 0, async (done: Function) => { 2455 2456 let unSubscriberCallback = (err: BusinessError) => { 2457 console.info("====>inputMethodAbility_test_072 unSubscriberCallback start"); 2458 if (err) { 2459 console.info("====>inputMethodAbility_test_072 unSubscriberCallback failed:" + 2460 JSON.stringify(err)); 2461 } else { 2462 console.info("====>inputMethodAbility_test_072 unSubscriberCallback finish"); 2463 } 2464 } 2465 2466 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2467 console.info("====>inputMethodAbility_test_072 subscriberCallback data:" 2468 + JSON.stringify(data)); 2469 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2470 let t = setTimeout(() => { 2471 try { 2472 expect(data.data).assertEqual("SUCCESS"); 2473 console.info("====>inputMethodAbility_test_072 end"); 2474 clearTimeout(t); 2475 done(); 2476 } catch (err) { 2477 console.info("====>inputMethodAbility_test_072 err:" + JSON.stringify(err)); 2478 clearTimeout(t); 2479 done(); 2480 } 2481 }, 1000) 2482 } 2483 2484 let publishCallback = (err: BusinessError) => { 2485 console.info("====>inputMethodAbility_test_072 publishCallback start"); 2486 if (err) { 2487 console.info("====>inputMethodAbility_test_072 publishCallback failed:" + JSON.stringify(err)); 2488 } else { 2489 let t = setTimeout(() => { 2490 runCmd(); 2491 clearTimeout(t) 2492 }, 300) 2493 } 2494 } 2495 2496 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2497 events: ["inputMethodAbility_test_072"] 2498 } 2499 let subscriber: ESObject; 2500 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2501 try { 2502 subscriber = data; 2503 console.info("====>inputMethodAbility_test_072 subscriber data:" + JSON.stringify(data)); 2504 commonEventManager.subscribe(subscriber, subscriberCallback); 2505 console.info("====>inputMethodAbility_test_072 subscriber finish"); 2506 } catch (err) { 2507 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2508 } 2509 2510 let t = setTimeout(async () => { 2511 clearTimeout(t); 2512 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2513 code: 72 2514 } 2515 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2516 }, 500) 2517 2518 }).catch((err: BusinessError) => { 2519 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2520 }) 2521 }); 2522 2523 /* 2524 * @tc.number inputMethodAbility_test_073 2525 * @tc.name inputMethodAbility_test_073 2526 * @tc.desc Function test 2527 * @tc.size MediumTest 2528 * @tc.type Function 2529 * @tc.level Level2 2530 */ 2531 it('inputMethodAbility_test_073', 0, async (done: Function) => { 2532 2533 let unSubscriberCallback = (err: BusinessError) => { 2534 console.info("====>inputMethodAbility_test_073 unSubscriberCallback start"); 2535 if (err) { 2536 console.info("====>inputMethodAbility_test_073 unSubscriberCallback failed:" + 2537 JSON.stringify(err)); 2538 } else { 2539 console.info("====>inputMethodAbility_test_073 unSubscriberCallback finish"); 2540 } 2541 } 2542 2543 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2544 console.info("====>inputMethodAbility_test_073 subscriberCallback data:" 2545 + JSON.stringify(data)); 2546 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2547 let t = setTimeout(() => { 2548 try { 2549 expect(data.data).assertEqual("SUCCESS"); 2550 console.info("====>inputMethodAbility_test_073 end"); 2551 clearTimeout(t); 2552 done(); 2553 } catch (err) { 2554 console.info("====>inputMethodAbility_test_073 err:" + JSON.stringify(err)); 2555 clearTimeout(t); 2556 done(); 2557 } 2558 }, 1000) 2559 } 2560 2561 let publishCallback = (err: BusinessError) => { 2562 console.info("====>inputMethodAbility_test_073 publishCallback start"); 2563 if (err) { 2564 console.info("====>inputMethodAbility_test_073 publishCallback failed:" + JSON.stringify(err)); 2565 } else { 2566 let t1 = setTimeout(async () => { 2567 await driver.triggerKey(2000); 2568 clearTimeout(t1); 2569 }, 300); 2570 } 2571 } 2572 2573 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2574 events: ["inputMethodAbility_test_073"] 2575 } 2576 let subscriber: ESObject; 2577 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2578 try { 2579 subscriber = data; 2580 console.info("====>inputMethodAbility_test_073 subscriber data:" + JSON.stringify(data)); 2581 commonEventManager.subscribe(subscriber, subscriberCallback); 2582 console.info("====>inputMethodAbility_test_073 subscriber finish"); 2583 } catch (err) { 2584 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2585 } 2586 2587 let t = setTimeout(async () => { 2588 clearTimeout(t); 2589 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2590 code: 73 2591 } 2592 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2593 }, 500) 2594 2595 }).catch((err: BusinessError) => { 2596 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2597 }) 2598 }); 2599 2600 /* 2601 * @tc.number inputMethodAbility_test_074 2602 * @tc.name inputMethodAbility_test_074 2603 * @tc.desc Function test 2604 * @tc.size MediumTest 2605 * @tc.type Function 2606 * @tc.level Level2 2607 */ 2608 it('inputMethodAbility_test_074', 0, async (done: Function) => { 2609 2610 let unSubscriberCallback = (err: BusinessError) => { 2611 console.info("====>inputMethodAbility_test_074 unSubscriberCallback start"); 2612 if (err) { 2613 console.info("====>inputMethodAbility_test_074 unSubscriberCallback failed:" + 2614 JSON.stringify(err)); 2615 } else { 2616 console.info("====>inputMethodAbility_test_074 unSubscriberCallback finish"); 2617 } 2618 } 2619 2620 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2621 console.info("====>inputMethodAbility_test_074 subscriberCallback data:" 2622 + JSON.stringify(data)); 2623 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2624 let t = setTimeout(() => { 2625 try { 2626 expect(data.data).assertEqual("SUCCESS"); 2627 console.info("====>inputMethodAbility_test_074 end"); 2628 clearTimeout(t); 2629 done(); 2630 } catch (err) { 2631 console.info("====>inputMethodAbility_test_074 err:" + JSON.stringify(err)); 2632 clearTimeout(t); 2633 done(); 2634 } 2635 }, 1000); 2636 } 2637 2638 let publishCallback = (err: BusinessError) => { 2639 console.info("====>inputMethodAbility_test_074 publishCallback start"); 2640 if (err) { 2641 console.info("====>inputMethodAbility_test_074 publishCallback failed:" + JSON.stringify(err)); 2642 } else { 2643 let t = setTimeout(async () => { 2644 let inputMethodController = inputMethod.getInputMethodController(); 2645 let windowId: number = 2000; 2646 await inputMethodController.setCallingWindow(windowId) 2647 clearTimeout(t) 2648 }, 200) 2649 } 2650 } 2651 2652 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2653 events: ["inputMethodAbility_test_074"] 2654 } 2655 let subscriber: ESObject; 2656 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2657 try { 2658 subscriber = data; 2659 console.info("====>inputMethodAbility_test_074 subscriber data:" + JSON.stringify(data)); 2660 commonEventManager.subscribe(subscriber, subscriberCallback); 2661 console.info("====>inputMethodAbility_test_074 subscriber finish"); 2662 } catch (err) { 2663 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2664 } 2665 2666 let t = setTimeout(async () => { 2667 clearTimeout(t); 2668 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2669 code: 74 2670 } 2671 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2672 }, 500) 2673 2674 }).catch((err: BusinessError) => { 2675 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2676 }) 2677 }); 2678 2679 /* 2680 * @tc.number inputMethodAbility_test_101 2681 * @tc.name inputMethodAbility_test_101 2682 * @tc.desc Function test 2683 * @tc.size MediumTest 2684 * @tc.type Function 2685 * @tc.level Level2 2686 */ 2687 it('inputMethodAbility_test_101', 0, async (done: Function) => { 2688 2689 let unSubscriberCallback = (err: BusinessError) => { 2690 console.info("====>inputMethodAbility_test_101 unSubscriberCallback start"); 2691 if (err) { 2692 console.info("====>inputMethodAbility_test_101 unSubscriberCallback failed:" + 2693 JSON.stringify(err)); 2694 } else { 2695 console.info("====>inputMethodAbility_test_101 unSubscriberCallback finish"); 2696 } 2697 } 2698 2699 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2700 console.info("====>inputMethodAbility_test_101 subscriberCallback data:" 2701 + JSON.stringify(data)); 2702 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2703 let t = setTimeout(() => { 2704 try { 2705 expect(data.data).assertEqual("SUCCESS"); 2706 console.info("====>inputMethodAbility_test_101 end"); 2707 clearTimeout(t); 2708 done(); 2709 } catch (err) { 2710 console.info("====>inputMethodAbility_test_101 err:" + JSON.stringify(err)); 2711 clearTimeout(t); 2712 done(); 2713 } 2714 }, 500) 2715 } 2716 2717 let publishCallback = (err: BusinessError) => { 2718 console.info("====>inputMethodAbility_test_101 publishCallback start"); 2719 if (err) { 2720 console.info("====>inputMethodAbility_test_101 publishCallback failed:" + JSON.stringify(err)); 2721 } 2722 } 2723 2724 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2725 events: ["inputMethodAbility_test_101"] 2726 } 2727 let subscriber: ESObject; 2728 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2729 try { 2730 subscriber = data; 2731 console.info("====>inputMethodAbility_test_101 subscriber data:" + JSON.stringify(data)); 2732 commonEventManager.subscribe(subscriber, subscriberCallback); 2733 console.info("====>inputMethodAbility_test_101 subscriber finish"); 2734 } catch (err) { 2735 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2736 } 2737 2738 let t = setTimeout(async () => { 2739 clearTimeout(t); 2740 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2741 code: 101 2742 } 2743 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2744 }, 500) 2745 2746 }).catch((err: BusinessError) => { 2747 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2748 }) 2749 }); 2750 2751 /* 2752 * @tc.number inputMethodAbility_test_102 2753 * @tc.name inputMethodAbility_test_102 2754 * @tc.desc Function test 2755 * @tc.size MediumTest 2756 * @tc.type Function 2757 * @tc.level Level2 2758 */ 2759 it('inputMethodAbility_test_102', 0, async (done: Function) => { 2760 2761 let unSubscriberCallback = (err: BusinessError) => { 2762 console.info("====>inputMethodAbility_test_102 unSubscriberCallback start"); 2763 if (err) { 2764 console.info("====>inputMethodAbility_test_102 unSubscriberCallback failed:" + 2765 JSON.stringify(err)); 2766 } else { 2767 console.info("====>inputMethodAbility_test_102 unSubscriberCallback finish") 2768 } 2769 } 2770 2771 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2772 console.info("====>inputMethodAbility_test_102 subscriberCallback data:" 2773 + JSON.stringify(data)); 2774 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2775 let t = setTimeout(() => { 2776 try { 2777 expect(data.data).assertEqual("SUCCESS"); 2778 console.info("====>inputMethodAbility_test_102 end"); 2779 clearTimeout(t); 2780 done(); 2781 } catch (err) { 2782 console.info("====>inputMethodAbility_test_102 err:" + JSON.stringify(err)); 2783 clearTimeout(t); 2784 done(); 2785 } 2786 }, 500) 2787 } 2788 2789 let publishCallback = (err: BusinessError) => { 2790 console.info("====>inputMethodAbility_test_102 publishCallback start"); 2791 if (err) { 2792 console.info("====>inputMethodAbility_test_102 publishCallback failed:" + JSON.stringify(err)); 2793 } 2794 } 2795 2796 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2797 events: ["inputMethodAbility_test_102"] 2798 } 2799 let subscriber: ESObject; 2800 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2801 try { 2802 subscriber = data; 2803 console.info("====>inputMethodAbility_test_102 subscriber data:" + JSON.stringify(data)); 2804 commonEventManager.subscribe(subscriber, subscriberCallback); 2805 console.info("====>inputMethodAbility_test_102 subscriber finish"); 2806 } catch (err) { 2807 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2808 } 2809 2810 let t = setTimeout(async () => { 2811 clearTimeout(t); 2812 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2813 code: 102 2814 } 2815 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2816 }, 500) 2817 2818 }).catch((err: BusinessError) => { 2819 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2820 }) 2821 }); 2822 2823 /* 2824 * @tc.number inputMethodAbility_test_103 2825 * @tc.name inputMethodAbility_test_103 2826 * @tc.desc Function test 2827 * @tc.size MediumTest 2828 * @tc.type Function 2829 * @tc.level Level2 2830 */ 2831 it('inputMethodAbility_test_103', 0, async (done: Function) => { 2832 2833 let unSubscriberCallback = (err: BusinessError) => { 2834 console.info("====>inputMethodAbility_test_103 unSubscriberCallback start"); 2835 if (err) { 2836 console.info("====>inputMethodAbility_test_103 unSubscriberCallback failed:" + 2837 JSON.stringify(err)); 2838 } else { 2839 console.info("====>inputMethodAbility_test_103 unSubscriberCallback finish"); 2840 } 2841 } 2842 2843 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2844 console.info("====>inputMethodAbility_test_103 subscriberCallback data:" 2845 + JSON.stringify(data)); 2846 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2847 let t = setTimeout(() => { 2848 try { 2849 expect(data.data).assertEqual("SUCCESS"); 2850 console.info("====>inputMethodAbility_test_103 end"); 2851 clearTimeout(t); 2852 done(); 2853 } catch (err) { 2854 console.info("====>inputMethodAbility_test_103 err:" + JSON.stringify(err)); 2855 clearTimeout(t); 2856 done(); 2857 } 2858 }, 500) 2859 } 2860 2861 let publishCallback = (err: BusinessError) => { 2862 console.info("====>inputMethodAbility_test_103 publishCallback start"); 2863 if (err) { 2864 console.info("====>inputMethodAbility_test_103 publishCallback failed:" + JSON.stringify(err)); 2865 } 2866 } 2867 2868 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2869 events: ["inputMethodAbility_test_103"] 2870 } 2871 let subscriber: ESObject; 2872 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2873 try { 2874 subscriber = data; 2875 console.info("====>inputMethodAbility_test_103 subscriber data:" + JSON.stringify(data)); 2876 commonEventManager.subscribe(subscriber, subscriberCallback); 2877 console.info("====>inputMethodAbility_test_103 subscriber finish"); 2878 } catch (err) { 2879 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2880 } 2881 2882 let t = setTimeout(async () => { 2883 clearTimeout(t); 2884 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2885 code: 103 2886 } 2887 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2888 }, 500) 2889 2890 }).catch((err: BusinessError) => { 2891 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2892 }) 2893 }); 2894 2895 /* 2896 * @tc.number inputMethodAbility_test_104 2897 * @tc.name inputMethodAbility_test_104 2898 * @tc.desc Function test 2899 * @tc.size MediumTest 2900 * @tc.type Function 2901 * @tc.level Level2 2902 */ 2903 it('inputMethodAbility_test_104', 0, async (done: Function) => { 2904 2905 let unSubscriberCallback = (err: BusinessError) => { 2906 console.info("====>inputMethodAbility_test_104 unSubscriberCallback start"); 2907 if (err) { 2908 console.info("====>inputMethodAbility_test_104 unSubscriberCallback failed:" + 2909 JSON.stringify(err)); 2910 } else { 2911 console.info("====>inputMethodAbility_test_104 unSubscriberCallback finish"); 2912 } 2913 } 2914 2915 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2916 console.info("====>inputMethodAbility_test_104 subscriberCallback data:" 2917 + JSON.stringify(data)); 2918 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2919 let t = setTimeout(() => { 2920 try { 2921 expect(data.data).assertEqual("SUCCESS"); 2922 console.info("====>inputMethodAbility_test_104 end"); 2923 clearTimeout(t); 2924 done(); 2925 } catch (err) { 2926 console.info("====>inputMethodAbility_test_104 err:" + JSON.stringify(err)); 2927 clearTimeout(t); 2928 done(); 2929 } 2930 }, 500) 2931 } 2932 2933 let publishCallback = (err: BusinessError) => { 2934 console.info("====>inputMethodAbility_test_104 publishCallback start"); 2935 if (err) { 2936 console.info("====>inputMethodAbility_test_104 publishCallback failed:" + JSON.stringify(err)); 2937 } 2938 } 2939 2940 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 2941 events: ["inputMethodAbility_test_104"] 2942 } 2943 let subscriber: ESObject; 2944 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 2945 try { 2946 subscriber = data; 2947 console.info("====>inputMethodAbility_test_104 subscriber data:" + JSON.stringify(data)); 2948 commonEventManager.subscribe(subscriber, subscriberCallback); 2949 console.info("====>inputMethodAbility_test_104 subscriber finish"); 2950 } catch (err) { 2951 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 2952 } 2953 2954 let t = setTimeout(async () => { 2955 clearTimeout(t); 2956 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 2957 code: 104 2958 } 2959 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 2960 }, 500) 2961 2962 }).catch((err: BusinessError) => { 2963 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 2964 }) 2965 }); 2966 2967 /* 2968 * @tc.number inputMethodAbility_test_105 2969 * @tc.name inputMethodAbility_test_105 2970 * @tc.desc Function test 2971 * @tc.size MediumTest 2972 * @tc.type Function 2973 * @tc.level Level2 2974 */ 2975 it('inputMethodAbility_test_105', 0, async (done: Function) => { 2976 2977 let unSubscriberCallback = (err: BusinessError) => { 2978 console.info("====>inputMethodAbility_test_105 unSubscriberCallback start"); 2979 if (err) { 2980 console.info("====>inputMethodAbility_test_105 unSubscriberCallback failed:" + 2981 JSON.stringify(err)); 2982 } else { 2983 console.info("====>inputMethodAbility_test_105 unSubscriberCallback finish"); 2984 } 2985 } 2986 2987 let subscriberCallback = (err: BusinessError, data: ESObject) => { 2988 console.info("====>inputMethodAbility_test_105 subscriberCallback data:" 2989 + JSON.stringify(data)); 2990 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 2991 let t = setTimeout(() => { 2992 try { 2993 expect(data.data).assertEqual("SUCCESS"); 2994 console.info("====>inputMethodAbility_test_105 end"); 2995 clearTimeout(t); 2996 done(); 2997 } catch (err) { 2998 console.info("====>inputMethodAbility_test_105 err:" + JSON.stringify(err)); 2999 clearTimeout(t); 3000 done(); 3001 } 3002 }, 500) 3003 } 3004 3005 let publishCallback = (err: BusinessError) => { 3006 console.info("====>inputMethodAbility_test_105 publishCallback start"); 3007 if (err) { 3008 console.info("====>inputMethodAbility_test_105 publishCallback failed:" + JSON.stringify(err)); 3009 } 3010 } 3011 3012 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3013 events: ["inputMethodAbility_test_105"] 3014 } 3015 let subscriber: ESObject; 3016 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3017 try { 3018 subscriber = data; 3019 console.info("====>inputMethodAbility_test_105 subscriber data:" + JSON.stringify(data)); 3020 commonEventManager.subscribe(subscriber, subscriberCallback); 3021 console.info("====>inputMethodAbility_test_105 subscriber finish"); 3022 } catch (err) { 3023 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3024 } 3025 3026 let t = setTimeout(async () => { 3027 clearTimeout(t); 3028 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3029 code: 105 3030 } 3031 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3032 }, 500) 3033 3034 }).catch((err: BusinessError) => { 3035 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3036 }) 3037 }); 3038 3039 /* 3040 * @tc.number inputMethodAbility_test_106 3041 * @tc.name inputMethodAbility_test_106 3042 * @tc.desc Function test 3043 * @tc.size MediumTest 3044 * @tc.type Function 3045 * @tc.level Level2 3046 */ 3047 it('inputMethodAbility_test_106', 0, async (done: Function) => { 3048 3049 let unSubscriberCallback = (err: BusinessError) => { 3050 console.info("====>inputMethodAbility_test_106 unSubscriberCallback start"); 3051 if (err) { 3052 console.info("====>inputMethodAbility_test_106 unSubscriberCallback failed:" + 3053 JSON.stringify(err)); 3054 } else { 3055 console.info("====>inputMethodAbility_test_106 unSubscriberCallback finish"); 3056 } 3057 } 3058 3059 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3060 console.info("====>inputMethodAbility_test_106 subscriberCallback data:" 3061 + JSON.stringify(data)); 3062 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3063 let t = setTimeout(() => { 3064 try { 3065 expect(data.data).assertEqual("SUCCESS"); 3066 console.info("====>inputMethodAbility_test_106 end"); 3067 clearTimeout(t); 3068 done(); 3069 } catch (err) { 3070 console.info("====>inputMethodAbility_test_106 err:" + JSON.stringify(err)); 3071 clearTimeout(t); 3072 done(); 3073 } 3074 }, 500) 3075 } 3076 3077 let publishCallback = (err: BusinessError) => { 3078 console.info("====>inputMethodAbility_test_106 publishCallback start"); 3079 if (err) { 3080 console.info("====>inputMethodAbility_test_106 publishCallback failed:" + JSON.stringify(err)); 3081 } 3082 } 3083 3084 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3085 events: ["inputMethodAbility_test_106"] 3086 } 3087 let subscriber: ESObject; 3088 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3089 try { 3090 subscriber = data; 3091 console.info("====>inputMethodAbility_test_106 subscriber data:" + JSON.stringify(data)); 3092 commonEventManager.subscribe(subscriber, subscriberCallback); 3093 console.info("====>inputMethodAbility_test_106 subscriber finish"); 3094 } catch (err) { 3095 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3096 } 3097 3098 let t = setTimeout(async () => { 3099 clearTimeout(t); 3100 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3101 code: 106 3102 } 3103 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3104 }, 500) 3105 3106 }).catch((err: BusinessError) => { 3107 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3108 }) 3109 }); 3110 3111 /* 3112 * @tc.number Sub_Misc_inputMethod_onSelectByRange_0110 3113 * @tc.name Sub_Misc_inputMethod_onSelectByRange_0110 3114 * @tc.desc Function test 3115 * @tc.size MediumTest 3116 * @tc.type Function 3117 * @tc.level Level2 3118 */ 3119 it('Sub_Misc_inputMethod_onSelectByRange_0110', 0, async (done: Function) => { 3120 3121 let publishCallback = (err: BusinessError) => { 3122 console.info("====>Sub_Misc_inputMethod_onSelectByRange_0110 publishCallback start"); 3123 if (err) { 3124 console.info("====>Sub_Misc_inputMethod_onSelectByRange_0110 publishCallback failed:" + JSON.stringify(err)); 3125 } 3126 } 3127 3128 inputMethodController.on("selectByRange", async (range) => { 3129 console.info('====>Sub_Misc_inputMethod_onSelectByRange_0110 onSelectByRange start'); 3130 inputMethodController.off("selectByRange"); 3131 try { 3132 expect(range.start).assertEqual(0); 3133 expect(range.end).assertEqual(10); 3134 console.info('====>Sub_Misc_inputMethod_onSelectByRange_0110 Succeed onSelectByRange: ' + 3135 JSON.stringify(range)); 3136 done(); 3137 } catch (err) { 3138 console.info('====>Sub_Misc_inputMethod_onSelectByRange_0110 selectByRange success'); 3139 done(); 3140 } 3141 }); 3142 3143 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3144 code: 110 3145 } 3146 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3147 }); 3148 3149 /* 3150 * @tc.number Sub_Misc_inputMethod_onSelectByMovement_0120 3151 * @tc.name Sub_Misc_inputMethod_onSelectByMovement_0120 3152 * @tc.desc Function test 3153 * @tc.size MediumTest 3154 * @tc.type Function 3155 * @tc.level Level2 3156 */ 3157 it('Sub_Misc_inputMethod_onSelectByMovement_0120', 0, async (done: Function) => { 3158 3159 let publishCallback = (err: BusinessError) => { 3160 console.info("====>Sub_Misc_inputMethod_onSelectByMovement_0120 publishCallback start"); 3161 if (err) { 3162 console.info("====>Sub_Misc_inputMethod_onSelectByMovement_0120 publishCallback failed:" + 3163 JSON.stringify(err)); 3164 } 3165 } 3166 3167 inputMethodController.on("selectByMovement", async (movement) => { 3168 console.info('====>Sub_Misc_inputMethod_onSelectByMovement_0120 onSelectByMovement start'); 3169 inputMethodController.off("selectByMovement"); 3170 try { 3171 expect(movement.direction).assertEqual(2); 3172 console.info('====>Sub_Misc_inputMethod_onSelectByMovement_0120 Succeed onSelectByMovement: ' + 3173 JSON.stringify(movement)); 3174 done(); 3175 } catch (err) { 3176 console.info('====>Sub_Misc_inputMethod_onSelectByMovement_0120 onSelectByMovement catch err: ' + 3177 JSON.stringify(err)); 3178 done(); 3179 } 3180 }); 3181 3182 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3183 code: 120 3184 } 3185 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3186 }); 3187 3188 /* 3189 * @tc.number Sub_Misc_inputMethod_offSelectByRange_0130 3190 * @tc.name Sub_Misc_inputMethod_offSelectByRange_0130 3191 * @tc.desc Function test 3192 * @tc.size MediumTest 3193 * @tc.type Function 3194 * @tc.level Level2 3195 */ 3196 it('Sub_Misc_inputMethod_offSelectByRange_0130', 0, async (done: Function) => { 3197 3198 let publishCallback = (err: BusinessError) => { 3199 console.info("====>Sub_Misc_inputMethod_offSelectByRange_0130 publishCallback start"); 3200 if (err) { 3201 console.info("====>Sub_Misc_inputMethod_offSelectByRange_0130 publishCallback failed:" + JSON.stringify(err)); 3202 } 3203 } 3204 3205 let count = 0; 3206 inputMethodController.on("selectByRange", async (movement) => { 3207 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 offSelectByRange start'); 3208 inputMethodController.off("selectByRange"); 3209 count += 1; 3210 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 Succeed offSelectByRange: ' + 3211 JSON.stringify(movement)); 3212 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 count: ' + count); 3213 }); 3214 3215 let t = setTimeout(() => { 3216 try { 3217 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 setTimeout count: ' + count); 3218 expect(count).assertEqual(1); 3219 clearTimeout(t); 3220 done(); 3221 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 Succeed offSelectByRange '); 3222 } catch (err) { 3223 console.info('====>Sub_Misc_inputMethod_offSelectByRange_0130 offSelectByRange err: ' + JSON.stringify(err)); 3224 done(); 3225 } 3226 }, 1000); 3227 3228 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3229 code: 130 3230 } 3231 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3232 }); 3233 3234 /* 3235 * @tc.number Sub_Misc_inputMethod_offSelectByMovement_0140 3236 * @tc.name Sub_Misc_inputMethod_offSelectByMovement_0140 3237 * @tc.desc Function test 3238 * @tc.size MediumTest 3239 * @tc.type Function 3240 * @tc.level Level2 3241 */ 3242 it('Sub_Misc_inputMethod_offSelectByMovement_0140', 0, async (done: Function) => { 3243 3244 let publishCallback = (err: BusinessError) => { 3245 console.info("====>Sub_Misc_inputMethod_offSelectByMovement_0140 publishCallback start"); 3246 if (err) { 3247 console.info("====>Sub_Misc_inputMethod_offSelectByMovement_0140 publishCallback failed:" + 3248 JSON.stringify(err)); 3249 } 3250 } 3251 3252 let count = 0; 3253 inputMethodController.on("selectByMovement", async (movement) => { 3254 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 offSelectByMovement start'); 3255 inputMethodController.off("selectByMovement"); 3256 count += 1; 3257 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 Succeed offSelectByMovement: ' + 3258 JSON.stringify(movement)); 3259 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 count: ' + count); 3260 }); 3261 3262 let t = setTimeout(() => { 3263 try { 3264 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 setTimeout count: ' + count); 3265 expect(count).assertEqual(1); 3266 clearTimeout(t); 3267 done(); 3268 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 Succeed offSelectByMovement '); 3269 } catch (err) { 3270 console.info('====>Sub_Misc_inputMethod_offSelectByMovement_0140 offSelectByMovement err: ' + 3271 JSON.stringify(err)); 3272 done(); 3273 } 3274 }, 1000); 3275 3276 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3277 code: 140 3278 } 3279 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3280 }); 3281 3282 /* 3283 * @tc.number Sub_Misc_inputMethod_onImeChange_0150 3284 * @tc.name Sub_Misc_inputMethod_onImeChange_0150 3285 * @tc.desc Function test 3286 * @tc.size MediumTest 3287 * @tc.type Function 3288 * @tc.level Level2 3289 */ 3290 it('Sub_Misc_inputMethod_onImeChange_0150', 0, async (done: Function) => { 3291 let inputMethodSetting = inputMethod.getSetting(); 3292 let inputStageService: subtype = { 3293 id: 'inputStageService', 3294 label: '', 3295 name: 'com.acts.inputmethodengine.test', 3296 mode: 'lower', 3297 locale: '', 3298 language: '', 3299 icon: '', 3300 iconId: 0, 3301 extra: {}, 3302 } 3303 let inputDemoService: subtype = { 3304 id: "InputDemoService", 3305 label: "", 3306 name: "com.acts.inputmethodengine.test", 3307 mode: "lower", 3308 locale: "", 3309 language: "", 3310 icon: "", 3311 iconId: 0, 3312 extra: {} 3313 } 3314 inputMethodSetting.on("imeChange", async (inputMethodProperty, inputMethodSubtype) => { 3315 inputMethodSetting.off("imeChange"); 3316 await inputMethod.switchCurrentInputMethodSubtype(inputStageService); 3317 console.info("====>Sub_Misc_inputMethod_onImeChange_0150 inputMethodProperty:" + 3318 JSON.stringify(inputMethodProperty)); 3319 console.info("====>Sub_Misc_inputMethod_onImeChange_0150 inputMethodSubtype:" + 3320 JSON.stringify(inputMethodSubtype)); 3321 expect(typeof (inputMethodProperty) !== null).assertTrue(); 3322 expect(typeof (inputMethodSubtype) !== null).assertTrue(); 3323 done(); 3324 }) 3325 try { 3326 await inputMethod.switchCurrentInputMethodSubtype(inputDemoService); 3327 console.info("====>Sub_Misc_inputMethod_onImeChange_0150 switchInputMethod success" + 3328 JSON.stringify(inputServer)); 3329 } catch (err) { 3330 console.info("====>Sub_Misc_inputMethod_onImeChange_0150 switchInputMethod fail" + JSON.stringify(err)); 3331 } 3332 }); 3333 3334 /* 3335 * @tc.number Sub_Misc_inputMethod_offImeChange_0160 3336 * @tc.name Sub_Misc_inputMethod_offImeChange_0160 3337 * @tc.desc Function test 3338 * @tc.size MediumTest 3339 * @tc.type Function 3340 * @tc.level Level2 3341 */ 3342 it('Sub_Misc_inputMethod_offImeChange_0160', 0, async (done: Function) => { 3343 let count = 0; 3344 let inputMethodSetting = inputMethod.getSetting(); 3345 let inputStageService: subtype = { 3346 id: 'inputStageService', 3347 label: '', 3348 name: 'com.acts.inputmethodengine.test', 3349 mode: 'lower', 3350 locale: '', 3351 language: '', 3352 icon: '', 3353 iconId: 0, 3354 extra: {}, 3355 } 3356 let inputDemoService: subtype = { 3357 id: "InputDemoService", 3358 label: "", 3359 name: "com.acts.inputmethodengine.test", 3360 mode: "lower", 3361 locale: "", 3362 language: "", 3363 icon: "", 3364 iconId: 0, 3365 extra: {} 3366 } 3367 inputMethodSetting.on("imeChange", (inputMethodProperty, inputMethodSubtype) => { 3368 inputMethodSetting.off("imeChange"); 3369 count += 1; 3370 console.info("====>Sub_Misc_inputMethod_offImeChange_0160 count:" + count); 3371 }) 3372 3373 try { 3374 await inputMethod.switchCurrentInputMethodSubtype(inputDemoService); 3375 console.info('====>Sub_Misc_inputMethod_offImeChange_0160 switchInputMethod'); 3376 let t = setTimeout(async () => { 3377 clearTimeout(t); 3378 await inputMethod.switchCurrentInputMethodSubtype(inputStageService); 3379 }, 300); 3380 } catch (err) { 3381 console.info("====>Sub_Misc_inputMethod_offImeChange_0160 switchInputMethod fail" + JSON.stringify(err)); 3382 } 3383 3384 let t = setTimeout(() => { 3385 clearTimeout(t); 3386 try { 3387 console.info('====>Sub_Misc_inputMethod_offImeChange_0160 setTimeout count: ' + count); 3388 expect(count === 1).assertTrue(); 3389 } catch (err) { 3390 console.info("====>Sub_Misc_inputMethod_offImeChange_0160 switchInputMethod fail" + JSON.stringify(err)); 3391 } 3392 done(); 3393 }, 1000); 3394 }); 3395 3396 /* 3397 * @tc.number inputMethodAbility_test_091 3398 * @tc.name inputMethodAbility_test_091 3399 * @tc.desc Function test 3400 * @tc.size MediumTest 3401 * @tc.type Function 3402 * @tc.level Level2 3403 */ 3404 it('inputMethodAbility_test_091', 0, async (done: Function) => { 3405 let flag = true; 3406 3407 let unSubscriberCallback = (err: BusinessError) => { 3408 console.info("====>inputMethodAbility_test_091 unSubscriberCallback start"); 3409 if (err) { 3410 console.info("====>inputMethodAbility_test_091 unSubscriberCallback failed:" + 3411 JSON.stringify(err)); 3412 } else { 3413 console.info("====>inputMethodAbility_test_091 unSubscriberCallback finish"); 3414 } 3415 } 3416 3417 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3418 console.info("====>inputMethodAbility_test_091 subscriberCallback data:" + JSON.stringify(data)); 3419 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3420 flag = false; 3421 } 3422 3423 let publishCallback = (err: BusinessError) => { 3424 console.info("====>inputMethodAbility_test_091 publishCallback start"); 3425 if (err) { 3426 console.info("====>inputMethodAbility_test_091 publishCallback failed:" + JSON.stringify(err)); 3427 } else { 3428 let t = setTimeout(async () => { 3429 await inputMethod.switchInputMethod(inputServer); 3430 console.info("====>inputMethodAbility_test_091 setTimeout first: " + JSON.stringify(inputServer)); 3431 let t1 = setTimeout(async () => { 3432 console.info("====>inputMethodAbility_test_091 setTimeout second: " + flag); 3433 expect(flag).assertTrue(); 3434 clearTimeout(t1); 3435 await inputMethod.switchCurrentInputMethodSubtype(inputDemoService); 3436 console.info("====>inputMethodAbility_test_091 switchInputMethod second" + 3437 JSON.stringify(inputDemoService)); 3438 let t2 = setTimeout(() => { 3439 clearTimeout(t2) 3440 done(); 3441 }, 500) 3442 }, 1000) 3443 clearTimeout(t); 3444 }, 1000) 3445 } 3446 } 3447 3448 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3449 events: ["inputMethodAbility_test_091"] 3450 } 3451 let subscriber: ESObject; 3452 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3453 try { 3454 subscriber = data; 3455 console.info("====>inputMethodAbility_test_091 subscriber data:" + JSON.stringify(data)); 3456 commonEventManager.subscribe(subscriber, subscriberCallback); 3457 console.info("====>inputMethodAbility_test_091 subscriber finish"); 3458 } catch (err) { 3459 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3460 } 3461 3462 let t = setTimeout(async () => { 3463 clearTimeout(t); 3464 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3465 code: 91 3466 } 3467 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3468 }, 500) 3469 3470 }).catch((err: BusinessError) => { 3471 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3472 }) 3473 }); 3474 3475 /* 3476 * @tc.number Sub_Misc_inputMethod_sendExtendAction_0170 3477 * @tc.name Sub_Misc_inputMethod_sendExtendAction_0170 3478 * @tc.desc Function test 3479 * @tc.size MediumTest 3480 * @tc.type Function 3481 * @tc.level Level2 3482 */ 3483 it('Sub_Misc_inputMethod_sendExtendAction_0170', 0, async (done: Function) => { 3484 3485 let unSubscriberCallback = (err: BusinessError) => { 3486 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 unSubscriberCallback start"); 3487 if (err) { 3488 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 unSubscriberCallback failed:" + 3489 JSON.stringify(err)); 3490 } else { 3491 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 unSubscriberCallback finish"); 3492 } 3493 } 3494 3495 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3496 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 subscriberCallback data:" 3497 + JSON.stringify(data)); 3498 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3499 let t = setTimeout(() => { 3500 try { 3501 expect(data.data).assertEqual("SUCCESS"); 3502 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 end"); 3503 clearTimeout(t); 3504 done(); 3505 } catch (err) { 3506 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 err:" + JSON.stringify(err)); 3507 clearTimeout(t); 3508 done(); 3509 } 3510 }, 500) 3511 } 3512 3513 let publishCallback = (err: BusinessError) => { 3514 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 publishCallback start"); 3515 if (err) { 3516 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 publishCallback failed:" + JSON.stringify(err)); 3517 } 3518 } 3519 3520 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3521 events: ["Sub_Misc_inputMethod_sendExtendAction_0170"] 3522 } 3523 let subscriber: ESObject; 3524 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3525 try { 3526 subscriber = data; 3527 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 subscriber data:" + JSON.stringify(data)); 3528 commonEventManager.subscribe(subscriber, subscriberCallback); 3529 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0170 subscriber finish"); 3530 } catch (err) { 3531 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3532 } 3533 3534 let t = setTimeout(async () => { 3535 clearTimeout(t); 3536 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3537 code: 170 3538 } 3539 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3540 }, 500) 3541 }).catch((err: BusinessError) => { 3542 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3543 }) 3544 }); 3545 3546 /* 3547 * @tc.number Sub_Misc_inputMethod_sendExtendAction_0180 3548 * @tc.name Sub_Misc_inputMethod_sendExtendAction_0180 3549 * @tc.desc Function test 3550 * @tc.size MediumTest 3551 * @tc.type Function 3552 * @tc.level Level2 3553 */ 3554 it('Sub_Misc_inputMethod_sendExtendAction_0180', 0, async (done: Function) => { 3555 3556 let unSubscriberCallback = (err: BusinessError) => { 3557 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 unSubscriberCallback start"); 3558 if (err) { 3559 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 unSubscriberCallback failed:" + 3560 JSON.stringify(err)); 3561 } else { 3562 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 unSubscriberCallback finish"); 3563 } 3564 } 3565 3566 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3567 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 subscriberCallback data:" 3568 + JSON.stringify(data)); 3569 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3570 let t = setTimeout(() => { 3571 try { 3572 expect(data.data).assertEqual("SUCCESS"); 3573 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 end"); 3574 clearTimeout(t); 3575 done(); 3576 } catch (err) { 3577 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 err:" + JSON.stringify(err)); 3578 clearTimeout(t); 3579 done(); 3580 } 3581 }, 500) 3582 } 3583 3584 let publishCallback = (err: BusinessError) => { 3585 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 publishCallback start"); 3586 if (err) { 3587 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 publishCallback failed:" + JSON.stringify(err)); 3588 } 3589 } 3590 3591 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3592 events: ["Sub_Misc_inputMethod_sendExtendAction_0180"] 3593 } 3594 let subscriber: ESObject; 3595 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3596 try { 3597 subscriber = data; 3598 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 subscriber data:" + JSON.stringify(data)); 3599 commonEventManager.subscribe(subscriber, subscriberCallback); 3600 console.info("====>Sub_Misc_inputMethod_sendExtendAction_0180 subscriber finish"); 3601 } catch (err) { 3602 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3603 } 3604 3605 let t = setTimeout(async () => { 3606 clearTimeout(t); 3607 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3608 code: 180 3609 } 3610 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3611 }, 500) 3612 3613 }).catch((err: BusinessError) => { 3614 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3615 }) 3616 }); 3617 3618 /* 3619 * @tc.number Sub_Misc_inputMethod_getForward_sync_0200 3620 * @tc.name Sub_Misc_inputMethod_getForward_sync_0200 3621 * @tc.desc Function test 3622 * @tc.size MediumTest 3623 * @tc.type Function 3624 * @tc.level Level2 3625 */ 3626 it('Sub_Misc_inputMethod_getForward_sync_0200', 0, async (done: Function) => { 3627 3628 let unSubscriberCallback = (err: BusinessError) => { 3629 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 unSubscriberCallback start"); 3630 if (err) { 3631 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 unSubscriberCallback failed:" + 3632 JSON.stringify(err)); 3633 } else { 3634 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 unSubscriberCallback finish"); 3635 } 3636 } 3637 3638 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3639 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 subscriberCallback data:" 3640 + JSON.stringify(data)); 3641 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3642 let t = setTimeout(() => { 3643 try { 3644 expect(data.data).assertEqual("SUCCESS"); 3645 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 end"); 3646 clearTimeout(t); 3647 done(); 3648 } catch (err) { 3649 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 err:" + JSON.stringify(err)); 3650 clearTimeout(t); 3651 done(); 3652 } 3653 }, 500) 3654 } 3655 3656 let publishCallback = (err: BusinessError) => { 3657 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 publishCallback start"); 3658 if (err) { 3659 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 publishCallback failed:" + JSON.stringify(err)); 3660 } 3661 } 3662 3663 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3664 events: ["Sub_Misc_inputMethod_getForward_sync_0200"] 3665 } 3666 let subscriber: ESObject; 3667 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3668 try { 3669 subscriber = data; 3670 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 subscriber data:" + JSON.stringify(data)); 3671 commonEventManager.subscribe(subscriber, subscriberCallback); 3672 console.info("====>Sub_Misc_inputMethod_getForward_sync_0200 subscriber finish"); 3673 } catch (err) { 3674 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3675 } 3676 3677 let t = setTimeout(async () => { 3678 clearTimeout(t); 3679 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3680 code: 200 3681 } 3682 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3683 }, 500) 3684 3685 }).catch((err: BusinessError) => { 3686 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3687 }) 3688 }); 3689 3690 /* 3691 * @tc.number Sub_Misc_inputMethod_getForward_sync_0201 3692 * @tc.name Sub_Misc_inputMethod_getForward_sync_0201 3693 * @tc.desc Function test 3694 * @tc.size MediumTest 3695 * @tc.type Function 3696 * @tc.level Level2 3697 */ 3698 it('Sub_Misc_inputMethod_getForward_sync_0201', 0, async (done: Function) => { 3699 3700 let unSubscriberCallback = (err: BusinessError) => { 3701 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 unSubscriberCallback start"); 3702 if (err) { 3703 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 unSubscriberCallback failed:" + 3704 JSON.stringify(err)); 3705 } else { 3706 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 unSubscriberCallback finish"); 3707 } 3708 } 3709 3710 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3711 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 subscriberCallback data:" 3712 + JSON.stringify(data)); 3713 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3714 let t = setTimeout(() => { 3715 try { 3716 expect(data.data).assertEqual("SUCCESS"); 3717 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 end"); 3718 clearTimeout(t); 3719 done(); 3720 } catch (err) { 3721 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 err:" + JSON.stringify(err)); 3722 clearTimeout(t); 3723 done(); 3724 } 3725 }, 500) 3726 } 3727 3728 let publishCallback = (err: BusinessError) => { 3729 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 publishCallback start"); 3730 if (err) { 3731 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 publishCallback failed:" + JSON.stringify(err)); 3732 } 3733 } 3734 3735 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3736 events: ["Sub_Misc_inputMethod_getForward_sync_0201"] 3737 } 3738 let subscriber: ESObject; 3739 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3740 try { 3741 subscriber = data; 3742 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 subscriber data:" + JSON.stringify(data)); 3743 commonEventManager.subscribe(subscriber, subscriberCallback); 3744 console.info("====>Sub_Misc_inputMethod_getForward_sync_0201 subscriber finish"); 3745 } catch (err) { 3746 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3747 } 3748 3749 let t = setTimeout(async () => { 3750 clearTimeout(t); 3751 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3752 code: 201 3753 } 3754 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3755 }, 500) 3756 3757 }).catch((err: BusinessError) => { 3758 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3759 }) 3760 }); 3761 3762 /* 3763 * @tc.number Sub_Misc_inputMethod_getBackward_sync_0210 3764 * @tc.name Sub_Misc_inputMethod_getBackward_sync_0210 3765 * @tc.desc Function test 3766 * @tc.size MediumTest 3767 * @tc.type Function 3768 * @tc.level Level2 3769 */ 3770 it('Sub_Misc_inputMethod_getBackward_sync_0210', 0, async (done: Function) => { 3771 3772 let unSubscriberCallback = (err: BusinessError) => { 3773 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 unSubscriberCallback start"); 3774 if (err) { 3775 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 unSubscriberCallback failed:" + 3776 JSON.stringify(err)); 3777 } else { 3778 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 unSubscriberCallback finish"); 3779 } 3780 } 3781 3782 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3783 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 subscriberCallback data:" 3784 + JSON.stringify(data)); 3785 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3786 let t = setTimeout(() => { 3787 try { 3788 expect(data.data).assertEqual("SUCCESS"); 3789 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 end"); 3790 clearTimeout(t); 3791 done(); 3792 } catch (err) { 3793 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 err:" + JSON.stringify(err)); 3794 clearTimeout(t); 3795 done(); 3796 } 3797 }, 500) 3798 } 3799 3800 let publishCallback = (err: BusinessError) => { 3801 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 publishCallback start"); 3802 if (err) { 3803 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 publishCallback failed:" + JSON.stringify(err)); 3804 } 3805 } 3806 3807 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3808 events: ["Sub_Misc_inputMethod_getBackward_sync_0210"] 3809 } 3810 let subscriber: ESObject; 3811 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3812 try { 3813 subscriber = data; 3814 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 subscriber data:" + JSON.stringify(data)); 3815 commonEventManager.subscribe(subscriber, subscriberCallback); 3816 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0210 subscriber finish"); 3817 } catch (err) { 3818 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3819 } 3820 3821 let t = setTimeout(async () => { 3822 clearTimeout(t); 3823 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3824 code: 210 3825 } 3826 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3827 }, 500) 3828 3829 }).catch((err: BusinessError) => { 3830 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3831 }) 3832 }); 3833 3834 /* 3835 * @tc.number Sub_Misc_inputMethod_getBackward_sync_0211 3836 * @tc.name Sub_Misc_inputMethod_getBackward_sync_0211 3837 * @tc.desc Function test 3838 * @tc.size MediumTest 3839 * @tc.type Function 3840 * @tc.level Level2 3841 */ 3842 it('Sub_Misc_inputMethod_getBackward_sync_0211', 0, async (done: Function) => { 3843 3844 let unSubscriberCallback = (err: BusinessError) => { 3845 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 unSubscriberCallback start"); 3846 if (err) { 3847 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 unSubscriberCallback failed:" + 3848 JSON.stringify(err)); 3849 } else { 3850 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 unSubscriberCallback finish"); 3851 } 3852 } 3853 3854 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3855 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 subscriberCallback data:" 3856 + JSON.stringify(data)); 3857 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3858 let t = setTimeout(() => { 3859 try { 3860 expect(data.data).assertEqual("SUCCESS"); 3861 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 end"); 3862 clearTimeout(t); 3863 done(); 3864 } catch (err) { 3865 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 err:" + JSON.stringify(err)); 3866 clearTimeout(t); 3867 done(); 3868 } 3869 }, 500) 3870 } 3871 3872 let publishCallback = (err: BusinessError) => { 3873 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 publishCallback start"); 3874 if (err) { 3875 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 publishCallback failed:" + JSON.stringify(err)); 3876 } 3877 } 3878 3879 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3880 events: ["Sub_Misc_inputMethod_getBackward_sync_0211"] 3881 } 3882 let subscriber: ESObject; 3883 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3884 try { 3885 subscriber = data; 3886 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 subscriber data:" + JSON.stringify(data)); 3887 commonEventManager.subscribe(subscriber, subscriberCallback); 3888 console.info("====>Sub_Misc_inputMethod_getBackward_sync_0211 subscriber finish"); 3889 } catch (err) { 3890 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3891 } 3892 3893 let t = setTimeout(async () => { 3894 clearTimeout(t); 3895 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3896 code: 211 3897 } 3898 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3899 }, 500) 3900 3901 }).catch((err: BusinessError) => { 3902 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3903 }) 3904 }); 3905 3906 /* 3907 * @tc.number Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 3908 * @tc.name Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 3909 * @tc.desc Function test 3910 * @tc.size MediumTest 3911 * @tc.type Function 3912 * @tc.level Level2 3913 */ 3914 it('Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220', 0, async (done: Function) => { 3915 3916 let unSubscriberCallback = (err: BusinessError) => { 3917 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 unSubscriberCallback start"); 3918 if (err) { 3919 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 unSubscriberCallback failed:" + 3920 JSON.stringify(err)); 3921 } else { 3922 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 unSubscriberCallback finish"); 3923 } 3924 } 3925 3926 let subscriberCallback = (err: BusinessError, data: ESObject) => { 3927 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 subscriberCallback data:" 3928 + JSON.stringify(data)); 3929 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 3930 let t = setTimeout(() => { 3931 try { 3932 expect(data.data).assertEqual("SUCCESS"); 3933 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 end"); 3934 clearTimeout(t); 3935 done(); 3936 } catch (err) { 3937 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 err:" + JSON.stringify(err)); 3938 clearTimeout(t); 3939 done(); 3940 } 3941 }, 500) 3942 } 3943 3944 let publishCallback = (err: BusinessError) => { 3945 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 publishCallback start"); 3946 if (err) { 3947 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 publishCallback failed:" + 3948 JSON.stringify(err)); 3949 } 3950 } 3951 3952 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 3953 events: ["Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220"] 3954 } 3955 let subscriber: ESObject; 3956 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 3957 try { 3958 subscriber = data; 3959 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 subscriber data:" + 3960 JSON.stringify(data)); 3961 commonEventManager.subscribe(subscriber, subscriberCallback); 3962 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0220 subscriber finish"); 3963 } catch (err) { 3964 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 3965 } 3966 3967 let t = setTimeout(async () => { 3968 clearTimeout(t); 3969 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 3970 code: 220 3971 } 3972 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 3973 }, 500) 3974 3975 }).catch((err: BusinessError) => { 3976 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 3977 }) 3978 }); 3979 3980 /* 3981 * @tc.number Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 3982 * @tc.name Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 3983 * @tc.desc Function test 3984 * @tc.size MediumTest 3985 * @tc.type Function 3986 * @tc.level Level2 3987 */ 3988 it('Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221', 0, async (done: Function) => { 3989 3990 let unSubscriberCallback = (err: BusinessError) => { 3991 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 unSubscriberCallback start"); 3992 if (err) { 3993 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 unSubscriberCallback failed:" + 3994 JSON.stringify(err)); 3995 } else { 3996 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 unSubscriberCallback finish"); 3997 } 3998 } 3999 4000 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4001 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 subscriberCallback data:" 4002 + JSON.stringify(data)); 4003 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4004 let t = setTimeout(() => { 4005 try { 4006 expect(data.data).assertEqual("SUCCESS"); 4007 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 end"); 4008 clearTimeout(t); 4009 done(); 4010 } catch (err) { 4011 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 err:" + JSON.stringify(err)); 4012 clearTimeout(t); 4013 done(); 4014 } 4015 }, 500) 4016 } 4017 4018 let publishCallback = (err: BusinessError) => { 4019 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 publishCallback start"); 4020 if (err) { 4021 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 publishCallback failed:" + 4022 JSON.stringify(err)); 4023 } 4024 } 4025 4026 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4027 events: ["Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221"] 4028 } 4029 let subscriber: ESObject; 4030 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4031 try { 4032 subscriber = data; 4033 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 subscriber data:" + 4034 JSON.stringify(data)); 4035 commonEventManager.subscribe(subscriber, subscriberCallback); 4036 console.info("====>Sub_Misc_inputMethod_getTextIndexAtCursor_sync_0221 subscriber finish"); 4037 } catch (err) { 4038 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4039 } 4040 4041 let t = setTimeout(async () => { 4042 clearTimeout(t); 4043 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4044 code: 221 4045 } 4046 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4047 }, 500) 4048 4049 }).catch((err: BusinessError) => { 4050 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4051 }) 4052 }); 4053 4054 /* 4055 * @tc.number Sub_Misc_inputMethod_getEditorAttribute_sync_0230 4056 * @tc.name Sub_Misc_inputMethod_getEditorAttribute_sync_0230 4057 * @tc.desc Function test 4058 * @tc.size MediumTest 4059 * @tc.type Function 4060 * @tc.level Level2 4061 */ 4062 it('Sub_Misc_inputMethod_getEditorAttribute_sync_0230', 0, async (done: Function) => { 4063 4064 let unSubscriberCallback = (err: BusinessError) => { 4065 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 unSubscriberCallback start"); 4066 if (err) { 4067 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 unSubscriberCallback failed:" + 4068 JSON.stringify(err)); 4069 } else { 4070 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 unSubscriberCallback finish"); 4071 } 4072 } 4073 4074 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4075 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 subscriberCallback data:" 4076 + JSON.stringify(data)); 4077 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4078 let t = setTimeout(() => { 4079 try { 4080 expect(data.data).assertEqual("SUCCESS"); 4081 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 end"); 4082 clearTimeout(t); 4083 done(); 4084 } catch (err) { 4085 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 err:" + JSON.stringify(err)); 4086 clearTimeout(t); 4087 done(); 4088 } 4089 }, 500) 4090 } 4091 4092 let publishCallback = (err: BusinessError) => { 4093 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 publishCallback start"); 4094 if (err) { 4095 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 publishCallback failed:" + 4096 JSON.stringify(err)); 4097 } 4098 } 4099 4100 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4101 events: ["Sub_Misc_inputMethod_getEditorAttribute_sync_0230"] 4102 } 4103 let subscriber: ESObject; 4104 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4105 try { 4106 subscriber = data; 4107 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 subscriber data:" + 4108 JSON.stringify(data)); 4109 commonEventManager.subscribe(subscriber, subscriberCallback); 4110 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0230 subscriber finish"); 4111 } catch (err) { 4112 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4113 } 4114 4115 let t = setTimeout(async () => { 4116 clearTimeout(t); 4117 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4118 code: 230 4119 } 4120 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4121 }, 500) 4122 4123 }).catch((err: BusinessError) => { 4124 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4125 }) 4126 }); 4127 4128 /* 4129 * @tc.number Sub_Misc_inputMethod_getEditorAttribute_sync_0231 4130 * @tc.name Sub_Misc_inputMethod_getEditorAttribute_sync_0231 4131 * @tc.desc Function test 4132 * @tc.size MediumTest 4133 * @tc.type Function 4134 * @tc.level Level2 4135 */ 4136 it('Sub_Misc_inputMethod_getEditorAttribute_sync_0231', 0, async (done: Function) => { 4137 4138 let unSubscriberCallback = (err: BusinessError) => { 4139 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 unSubscriberCallback start"); 4140 if (err) { 4141 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 unSubscriberCallback failed:" + 4142 JSON.stringify(err)); 4143 } else { 4144 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 unSubscriberCallback finish"); 4145 } 4146 } 4147 4148 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4149 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 subscriberCallback data:" 4150 + JSON.stringify(data)); 4151 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4152 let t = setTimeout(() => { 4153 try { 4154 expect(data.data).assertEqual("SUCCESS"); 4155 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 end"); 4156 clearTimeout(t); 4157 done(); 4158 } catch (err) { 4159 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 err:" + JSON.stringify(err)); 4160 clearTimeout(t); 4161 done(); 4162 } 4163 }, 500) 4164 } 4165 4166 let publishCallback = (err: BusinessError) => { 4167 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 publishCallback start"); 4168 if (err) { 4169 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 publishCallback failed:" + 4170 JSON.stringify(err)); 4171 } 4172 } 4173 4174 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4175 events: ["Sub_Misc_inputMethod_getEditorAttribute_sync_0231"] 4176 } 4177 let subscriber: ESObject; 4178 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4179 try { 4180 subscriber = data; 4181 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 subscriber data:" + 4182 JSON.stringify(data)); 4183 commonEventManager.subscribe(subscriber, subscriberCallback); 4184 console.info("====>Sub_Misc_inputMethod_getEditorAttribute_sync_0231 subscriber finish"); 4185 } catch (err) { 4186 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4187 } 4188 4189 let t = setTimeout(async () => { 4190 clearTimeout(t); 4191 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4192 code: 231 4193 } 4194 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4195 }, 500) 4196 4197 }).catch((err: BusinessError) => { 4198 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4199 }) 4200 }); 4201 4202 /* 4203 * @tc.number Sub_Misc_inputMethod_moveCursor_sync_0240 4204 * @tc.name Sub_Misc_inputMethod_moveCursor_sync_0240 4205 * @tc.desc Function test 4206 * @tc.size MediumTest 4207 * @tc.type Function 4208 * @tc.level Level2 4209 */ 4210 it('Sub_Misc_inputMethod_moveCursor_sync_0240', 0, async (done: Function) => { 4211 4212 let unSubscriberCallback = (err: BusinessError) => { 4213 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 unSubscriberCallback start"); 4214 if (err) { 4215 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 unSubscriberCallback failed:" + 4216 JSON.stringify(err)); 4217 } else { 4218 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 unSubscriberCallback finish"); 4219 } 4220 } 4221 4222 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4223 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 subscriberCallback data:" 4224 + JSON.stringify(data)); 4225 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4226 let t = setTimeout(() => { 4227 try { 4228 expect(data.data).assertEqual("SUCCESS"); 4229 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 end"); 4230 clearTimeout(t); 4231 done(); 4232 } catch (err) { 4233 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 err:" + JSON.stringify(err)); 4234 clearTimeout(t); 4235 done(); 4236 } 4237 }, 500) 4238 } 4239 4240 let publishCallback = (err: BusinessError) => { 4241 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 publishCallback start"); 4242 if (err) { 4243 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 publishCallback failed:" + JSON.stringify(err)); 4244 } 4245 } 4246 4247 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4248 events: ["Sub_Misc_inputMethod_moveCursor_sync_0240"] 4249 } 4250 let subscriber: ESObject; 4251 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4252 try { 4253 subscriber = data; 4254 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 subscriber data:" + JSON.stringify(data)); 4255 commonEventManager.subscribe(subscriber, subscriberCallback); 4256 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0240 subscriber finish"); 4257 } catch (err) { 4258 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4259 } 4260 4261 let t = setTimeout(async () => { 4262 clearTimeout(t); 4263 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4264 code: 240 4265 } 4266 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4267 }, 500) 4268 4269 }).catch((err: BusinessError) => { 4270 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4271 }) 4272 }); 4273 4274 /* 4275 * @tc.number Sub_Misc_inputMethod_moveCursor_sync_0241 4276 * @tc.name Sub_Misc_inputMethod_moveCursor_sync_0241 4277 * @tc.desc Function test 4278 * @tc.size MediumTest 4279 * @tc.type Function 4280 * @tc.level Level2 4281 */ 4282 it('Sub_Misc_inputMethod_moveCursor_sync_0241', 0, async (done: Function) => { 4283 4284 let unSubscriberCallback = (err: BusinessError) => { 4285 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 unSubscriberCallback start"); 4286 if (err) { 4287 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 unSubscriberCallback failed:" + 4288 JSON.stringify(err)); 4289 } else { 4290 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 unSubscriberCallback finish"); 4291 } 4292 } 4293 4294 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4295 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 subscriberCallback data:" 4296 + JSON.stringify(data)); 4297 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4298 let t = setTimeout(() => { 4299 try { 4300 expect(data.data).assertEqual("SUCCESS"); 4301 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 end"); 4302 clearTimeout(t); 4303 done(); 4304 } catch (err) { 4305 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 err:" + JSON.stringify(err)); 4306 clearTimeout(t); 4307 done(); 4308 } 4309 }, 500) 4310 } 4311 4312 let publishCallback = (err: BusinessError) => { 4313 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 publishCallback start"); 4314 if (err) { 4315 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 publishCallback failed:" + JSON.stringify(err)); 4316 } 4317 } 4318 4319 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4320 events: ["Sub_Misc_inputMethod_moveCursor_sync_0241"] 4321 } 4322 let subscriber: ESObject; 4323 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4324 try { 4325 subscriber = data; 4326 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 subscriber data:" + JSON.stringify(data)); 4327 commonEventManager.subscribe(subscriber, subscriberCallback); 4328 console.info("====>Sub_Misc_inputMethod_moveCursor_sync_0241 subscriber finish"); 4329 } catch (err) { 4330 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4331 } 4332 4333 let t = setTimeout(async () => { 4334 clearTimeout(t); 4335 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4336 code: 241 4337 } 4338 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4339 }, 500) 4340 4341 }).catch((err: BusinessError) => { 4342 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4343 }) 4344 }); 4345 4346 /* 4347 * @tc.number Sub_Misc_inputMethod_deleteForward_sync_0250 4348 * @tc.name Sub_Misc_inputMethod_deleteForward_sync_0250 4349 * @tc.desc Function test 4350 * @tc.size MediumTest 4351 * @tc.type Function 4352 * @tc.level Level2 4353 */ 4354 it('Sub_Misc_inputMethod_deleteForward_sync_0250', 0, async (done: Function) => { 4355 4356 let unSubscriberCallback = (err: BusinessError) => { 4357 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 unSubscriberCallback start"); 4358 if (err) { 4359 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 unSubscriberCallback failed:" + 4360 JSON.stringify(err)); 4361 } else { 4362 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 unSubscriberCallback finish"); 4363 } 4364 } 4365 4366 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4367 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 subscriberCallback data:" 4368 + JSON.stringify(data)); 4369 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4370 let t = setTimeout(() => { 4371 try { 4372 expect(data.data).assertEqual("SUCCESS"); 4373 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 end"); 4374 clearTimeout(t); 4375 done(); 4376 } catch (err) { 4377 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 err:" + JSON.stringify(err)); 4378 clearTimeout(t); 4379 done(); 4380 } 4381 }, 500) 4382 } 4383 4384 let publishCallback = (err: BusinessError) => { 4385 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 publishCallback start"); 4386 if (err) { 4387 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 publishCallback failed:" + 4388 JSON.stringify(err)); 4389 } 4390 } 4391 4392 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4393 events: ["Sub_Misc_inputMethod_deleteForward_sync_0250"] 4394 } 4395 let subscriber: ESObject; 4396 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4397 try { 4398 subscriber = data; 4399 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 subscriber data:" + JSON.stringify(data)); 4400 commonEventManager.subscribe(subscriber, subscriberCallback); 4401 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0250 subscriber finish"); 4402 } catch (err) { 4403 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4404 } 4405 4406 let t = setTimeout(async () => { 4407 clearTimeout(t); 4408 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4409 code: 250 4410 } 4411 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4412 }, 500) 4413 4414 }).catch((err: BusinessError) => { 4415 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4416 }) 4417 }); 4418 4419 /* 4420 * @tc.number Sub_Misc_inputMethod_deleteForward_sync_0251 4421 * @tc.name Sub_Misc_inputMethod_deleteForward_sync_0251 4422 * @tc.desc Function test 4423 * @tc.size MediumTest 4424 * @tc.type Function 4425 * @tc.level Level2 4426 */ 4427 it('Sub_Misc_inputMethod_deleteForward_sync_0251', 0, async (done: Function) => { 4428 4429 let unSubscriberCallback = (err: BusinessError) => { 4430 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 unSubscriberCallback start"); 4431 if (err) { 4432 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 unSubscriberCallback failed:" + 4433 JSON.stringify(err)); 4434 } else { 4435 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 unSubscriberCallback finish"); 4436 } 4437 } 4438 4439 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4440 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 subscriberCallback data:" 4441 + JSON.stringify(data)); 4442 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4443 let t = setTimeout(() => { 4444 try { 4445 expect(data.data).assertEqual("SUCCESS"); 4446 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 end"); 4447 clearTimeout(t); 4448 done(); 4449 } catch (err) { 4450 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 err:" + JSON.stringify(err)); 4451 clearTimeout(t); 4452 done(); 4453 } 4454 }, 500) 4455 } 4456 4457 let publishCallback = (err: BusinessError) => { 4458 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 publishCallback start"); 4459 if (err) { 4460 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 publishCallback failed:" + 4461 JSON.stringify(err)); 4462 } 4463 } 4464 4465 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4466 events: ["Sub_Misc_inputMethod_deleteForward_sync_0251"] 4467 } 4468 let subscriber: ESObject; 4469 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4470 try { 4471 subscriber = data; 4472 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 subscriber data:" + JSON.stringify(data)); 4473 commonEventManager.subscribe(subscriber, subscriberCallback); 4474 console.info("====>Sub_Misc_inputMethod_deleteForward_sync_0251 subscriber finish"); 4475 } catch (err) { 4476 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4477 } 4478 4479 let t = setTimeout(async () => { 4480 clearTimeout(t); 4481 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4482 code: 251 4483 } 4484 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4485 }, 500) 4486 4487 }).catch((err: BusinessError) => { 4488 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4489 }) 4490 }); 4491 4492 /* 4493 * @tc.number Sub_Misc_inputMethod_deleteBackward_sync_0260 4494 * @tc.name Sub_Misc_inputMethod_deleteBackward_sync_0260 4495 * @tc.desc Function test 4496 * @tc.size MediumTest 4497 * @tc.type Function 4498 * @tc.level Level2 4499 */ 4500 it('Sub_Misc_inputMethod_deleteBackward_sync_0260', 0, async (done: Function) => { 4501 4502 let unSubscriberCallback = (err: BusinessError) => { 4503 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 unSubscriberCallback start"); 4504 if (err) { 4505 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 unSubscriberCallback failed:" + 4506 JSON.stringify(err)); 4507 } else { 4508 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 unSubscriberCallback finish"); 4509 } 4510 } 4511 4512 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4513 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 subscriberCallback data:" 4514 + JSON.stringify(data)); 4515 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4516 let t = setTimeout(() => { 4517 try { 4518 expect(data.data).assertEqual("SUCCESS"); 4519 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 end"); 4520 clearTimeout(t); 4521 done(); 4522 } catch (err) { 4523 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 err:" + JSON.stringify(err)); 4524 clearTimeout(t); 4525 done(); 4526 } 4527 }, 500) 4528 } 4529 4530 let publishCallback = (err: BusinessError) => { 4531 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 publishCallback start"); 4532 if (err) { 4533 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 publishCallback failed:" + 4534 JSON.stringify(err)); 4535 } 4536 } 4537 4538 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4539 events: ["Sub_Misc_inputMethod_deleteBackward_sync_0260"] 4540 } 4541 let subscriber: ESObject; 4542 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4543 try { 4544 subscriber = data; 4545 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 subscriber data:" + JSON.stringify(data)); 4546 commonEventManager.subscribe(subscriber, subscriberCallback); 4547 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0260 subscriber finish"); 4548 } catch (err) { 4549 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4550 } 4551 4552 let t = setTimeout(async () => { 4553 clearTimeout(t); 4554 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4555 code: 260 4556 } 4557 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4558 }, 500) 4559 4560 }).catch((err: BusinessError) => { 4561 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4562 }) 4563 }); 4564 4565 /* 4566 * @tc.number Sub_Misc_inputMethod_deleteBackward_sync_0261 4567 * @tc.name Sub_Misc_inputMethod_deleteBackward_sync_0261 4568 * @tc.desc Function test 4569 * @tc.size MediumTest 4570 * @tc.type Function 4571 * @tc.level Level2 4572 */ 4573 it('Sub_Misc_inputMethod_deleteBackward_sync_0261', 0, async (done: Function) => { 4574 4575 let unSubscriberCallback = (err: BusinessError) => { 4576 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 unSubscriberCallback start"); 4577 if (err) { 4578 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 unSubscriberCallback failed:" + 4579 JSON.stringify(err)); 4580 } else { 4581 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 unSubscriberCallback finish"); 4582 } 4583 } 4584 4585 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4586 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 subscriberCallback data:" 4587 + JSON.stringify(data)); 4588 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4589 let t = setTimeout(() => { 4590 try { 4591 expect(data.data).assertEqual("SUCCESS"); 4592 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 end"); 4593 clearTimeout(t); 4594 done(); 4595 } catch (err) { 4596 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 err:" + JSON.stringify(err)); 4597 clearTimeout(t); 4598 done(); 4599 } 4600 }, 500) 4601 } 4602 4603 let publishCallback = (err: BusinessError) => { 4604 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 publishCallback start"); 4605 if (err) { 4606 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 publishCallback failed:" + 4607 JSON.stringify(err)); 4608 } 4609 } 4610 4611 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4612 events: ["Sub_Misc_inputMethod_deleteBackward_sync_0261"] 4613 } 4614 let subscriber: ESObject; 4615 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4616 try { 4617 subscriber = data; 4618 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 subscriber data:" + JSON.stringify(data)); 4619 commonEventManager.subscribe(subscriber, subscriberCallback); 4620 console.info("====>Sub_Misc_inputMethod_deleteBackward_sync_0261 subscriber finish"); 4621 } catch (err) { 4622 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4623 } 4624 4625 let t = setTimeout(async () => { 4626 clearTimeout(t); 4627 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4628 code: 261 4629 } 4630 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4631 }, 500) 4632 4633 }).catch((err: BusinessError) => { 4634 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4635 }) 4636 }); 4637 4638 /* 4639 * @tc.number Sub_Misc_inputMethod_insertText_sync_0270 4640 * @tc.name Sub_Misc_inputMethod_insertText_sync_0270 4641 * @tc.desc Function test 4642 * @tc.size MediumTest 4643 * @tc.type Function 4644 * @tc.level Level2 4645 */ 4646 it('Sub_Misc_inputMethod_insertText_sync_0270', 0, async (done: Function) => { 4647 4648 let unSubscriberCallback = (err: BusinessError) => { 4649 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 unSubscriberCallback start"); 4650 if (err) { 4651 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 unSubscriberCallback failed:" + 4652 JSON.stringify(err)); 4653 } else { 4654 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 unSubscriberCallback finish"); 4655 } 4656 } 4657 4658 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4659 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 subscriberCallback data:" 4660 + JSON.stringify(data)); 4661 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4662 let t = setTimeout(() => { 4663 try { 4664 expect(data.data).assertEqual("SUCCESS"); 4665 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 end"); 4666 clearTimeout(t); 4667 done(); 4668 } catch (err) { 4669 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 err:" + JSON.stringify(err)); 4670 clearTimeout(t); 4671 done(); 4672 } 4673 }, 500) 4674 } 4675 4676 let publishCallback = (err: BusinessError) => { 4677 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 publishCallback start"); 4678 if (err) { 4679 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 publishCallback failed:" + JSON.stringify(err)); 4680 } 4681 } 4682 4683 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4684 events: ["Sub_Misc_inputMethod_insertText_sync_0270"] 4685 } 4686 let subscriber: ESObject; 4687 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4688 try { 4689 subscriber = data; 4690 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 subscriber data:" + JSON.stringify(data)); 4691 commonEventManager.subscribe(subscriber, subscriberCallback); 4692 console.info("====>Sub_Misc_inputMethod_insertText_sync_0270 subscriber finish"); 4693 } catch (err) { 4694 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4695 } 4696 4697 let t = setTimeout(async () => { 4698 clearTimeout(t); 4699 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4700 code: 270 4701 } 4702 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4703 }, 500) 4704 4705 4706 }).catch((err: BusinessError) => { 4707 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4708 }) 4709 }); 4710 4711 /* 4712 * @tc.number Sub_Misc_inputMethod_insertText_sync_0271 4713 * @tc.name Sub_Misc_inputMethod_insertText_sync_0271 4714 * @tc.desc Function test 4715 * @tc.size MediumTest 4716 * @tc.type Function 4717 * @tc.level Level2 4718 */ 4719 it('Sub_Misc_inputMethod_insertText_sync_0271', 0, async (done: Function) => { 4720 4721 let unSubscriberCallback = (err: BusinessError) => { 4722 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 unSubscriberCallback start"); 4723 if (err) { 4724 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 unSubscriberCallback failed:" + 4725 JSON.stringify(err)); 4726 } else { 4727 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 unSubscriberCallback finish"); 4728 } 4729 } 4730 4731 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4732 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 subscriberCallback data:" 4733 + JSON.stringify(data)); 4734 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4735 let t = setTimeout(() => { 4736 try { 4737 expect(data.data).assertEqual("SUCCESS"); 4738 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 end"); 4739 clearTimeout(t); 4740 done(); 4741 } catch (err) { 4742 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 err:" + JSON.stringify(err)); 4743 clearTimeout(t); 4744 done(); 4745 } 4746 }, 500) 4747 } 4748 4749 let publishCallback = (err: BusinessError) => { 4750 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 publishCallback start"); 4751 if (err) { 4752 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 publishCallback failed:" + JSON.stringify(err)); 4753 } 4754 } 4755 4756 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4757 events: ["Sub_Misc_inputMethod_insertText_sync_0271"] 4758 } 4759 let subscriber: ESObject; 4760 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4761 try { 4762 subscriber = data; 4763 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 subscriber data:" + JSON.stringify(data)); 4764 commonEventManager.subscribe(subscriber, subscriberCallback); 4765 console.info("====>Sub_Misc_inputMethod_insertText_sync_0271 subscriber finish"); 4766 } catch (err) { 4767 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4768 } 4769 4770 let t = setTimeout(async () => { 4771 clearTimeout(t); 4772 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4773 code: 271 4774 } 4775 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4776 }, 500) 4777 4778 }).catch((err: BusinessError) => { 4779 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4780 }) 4781 }); 4782 4783 /* 4784 * @tc.number Sub_Misc_inputMethod_selectByRange_sync_0280 4785 * @tc.name Sub_Misc_inputMethod_selectByRange_sync_0280 4786 * @tc.desc Function test 4787 * @tc.size MediumTest 4788 * @tc.type Function 4789 * @tc.level Level2 4790 */ 4791 it('Sub_Misc_inputMethod_selectByRange_sync_0280', 0, async (done: Function) => { 4792 4793 let unSubscriberCallback = (err: BusinessError) => { 4794 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 unSubscriberCallback start"); 4795 if (err) { 4796 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 unSubscriberCallback failed:" + 4797 JSON.stringify(err)); 4798 } else { 4799 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 unSubscriberCallback finish"); 4800 } 4801 } 4802 4803 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4804 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 subscriberCallback data:" 4805 + JSON.stringify(data)); 4806 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4807 let t = setTimeout(() => { 4808 try { 4809 expect(data.data).assertEqual("SUCCESS"); 4810 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 end"); 4811 clearTimeout(t); 4812 done(); 4813 } catch (err) { 4814 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 err:" + JSON.stringify(err)); 4815 clearTimeout(t); 4816 done(); 4817 } 4818 }, 500) 4819 } 4820 4821 let publishCallback = (err: BusinessError) => { 4822 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 publishCallback start"); 4823 if (err) { 4824 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 publishCallback failed:" + 4825 JSON.stringify(err)); 4826 } 4827 } 4828 4829 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4830 events: ["Sub_Misc_inputMethod_selectByRange_sync_0280"] 4831 } 4832 let subscriber: ESObject; 4833 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4834 try { 4835 subscriber = data; 4836 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 subscriber data:" + JSON.stringify(data)); 4837 commonEventManager.subscribe(subscriber, subscriberCallback); 4838 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0280 subscriber finish"); 4839 } catch (err) { 4840 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4841 } 4842 4843 let t = setTimeout(async () => { 4844 clearTimeout(t); 4845 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4846 code: 280 4847 } 4848 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4849 }, 500) 4850 4851 }).catch((err: BusinessError) => { 4852 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4853 }) 4854 }); 4855 4856 /* 4857 * @tc.number Sub_Misc_inputMethod_selectByRange_sync_0281 4858 * @tc.name Sub_Misc_inputMethod_selectByRange_sync_0281 4859 * @tc.desc Function test 4860 * @tc.size MediumTest 4861 * @tc.type Function 4862 * @tc.level Level2 4863 */ 4864 it('Sub_Misc_inputMethod_selectByRange_sync_0281', 0, async (done: Function) => { 4865 4866 let unSubscriberCallback = (err: BusinessError) => { 4867 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 unSubscriberCallback start"); 4868 if (err) { 4869 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 unSubscriberCallback failed:" + 4870 JSON.stringify(err)); 4871 } else { 4872 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 unSubscriberCallback finish"); 4873 } 4874 } 4875 4876 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4877 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 subscriberCallback data:" 4878 + JSON.stringify(data)); 4879 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4880 let t = setTimeout(() => { 4881 try { 4882 expect(data.data).assertEqual("SUCCESS"); 4883 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 end"); 4884 clearTimeout(t); 4885 done(); 4886 } catch (err) { 4887 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 err:" + JSON.stringify(err)); 4888 clearTimeout(t); 4889 done(); 4890 } 4891 }, 500) 4892 } 4893 4894 let publishCallback = (err: BusinessError) => { 4895 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 publishCallback start"); 4896 if (err) { 4897 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 publishCallback failed:" + 4898 JSON.stringify(err)); 4899 } 4900 } 4901 4902 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4903 events: ["Sub_Misc_inputMethod_selectByRange_sync_0281"] 4904 } 4905 let subscriber: ESObject; 4906 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4907 try { 4908 subscriber = data; 4909 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 subscriber data:" + JSON.stringify(data)); 4910 commonEventManager.subscribe(subscriber, subscriberCallback); 4911 console.info("====>Sub_Misc_inputMethod_selectByRange_sync_0281 subscriber finish"); 4912 } catch (err) { 4913 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4914 } 4915 4916 let t = setTimeout(async () => { 4917 clearTimeout(t); 4918 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4919 code: 281 4920 } 4921 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4922 }, 500) 4923 4924 }).catch((err: BusinessError) => { 4925 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4926 }) 4927 }); 4928 4929 /* 4930 * @tc.number Sub_Misc_inputMethod_selectByMovement_sync_0290 4931 * @tc.name Sub_Misc_inputMethod_selectByMovement_sync_0290 4932 * @tc.desc Function test 4933 * @tc.size MediumTest 4934 * @tc.type Function 4935 * @tc.level Level2 4936 */ 4937 it('Sub_Misc_inputMethod_selectByMovement_sync_0290', 0, async (done: Function) => { 4938 4939 let unSubscriberCallback = (err: BusinessError) => { 4940 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 unSubscriberCallback start"); 4941 if (err) { 4942 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 unSubscriberCallback failed:" + 4943 JSON.stringify(err)); 4944 } else { 4945 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 unSubscriberCallback finish"); 4946 } 4947 } 4948 4949 let subscriberCallback = (err: BusinessError, data: ESObject) => { 4950 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 subscriberCallback data:" 4951 + JSON.stringify(data)); 4952 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 4953 let t = setTimeout(() => { 4954 try { 4955 expect(data.data).assertEqual("SUCCESS"); 4956 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 end"); 4957 clearTimeout(t); 4958 done(); 4959 } catch (err) { 4960 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 err:" + JSON.stringify(err)); 4961 clearTimeout(t); 4962 done(); 4963 } 4964 }, 500) 4965 } 4966 4967 let publishCallback = (err: BusinessError) => { 4968 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 publishCallback start"); 4969 if (err) { 4970 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 publishCallback failed:" + 4971 JSON.stringify(err)); 4972 } 4973 } 4974 4975 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 4976 events: ["Sub_Misc_inputMethod_selectByMovement_sync_0290"] 4977 } 4978 let subscriber: ESObject; 4979 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 4980 try { 4981 subscriber = data; 4982 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 subscriber data:" + JSON.stringify(data)); 4983 commonEventManager.subscribe(subscriber, subscriberCallback); 4984 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0290 subscriber finish"); 4985 } catch (err) { 4986 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 4987 } 4988 4989 let t = setTimeout(async () => { 4990 clearTimeout(t); 4991 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 4992 code: 290 4993 } 4994 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 4995 }, 500) 4996 4997 }).catch((err: BusinessError) => { 4998 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 4999 }) 5000 }); 5001 5002 /* 5003 * @tc.number Sub_Misc_inputMethod_selectByMovement_sync_0291 5004 * @tc.name Sub_Misc_inputMethod_selectByMovement_sync_0291 5005 * @tc.desc Function test 5006 * @tc.size MediumTest 5007 * @tc.type Function 5008 * @tc.level Level2 5009 */ 5010 it('Sub_Misc_inputMethod_selectByMovement_sync_0291', 0, async (done: Function) => { 5011 5012 let unSubscriberCallback = (err: BusinessError) => { 5013 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 unSubscriberCallback start"); 5014 if (err) { 5015 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 unSubscriberCallback failed:" + 5016 JSON.stringify(err)); 5017 } else { 5018 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 unSubscriberCallback finish"); 5019 } 5020 } 5021 5022 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5023 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 subscriberCallback data:" 5024 + JSON.stringify(data)); 5025 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5026 let t = setTimeout(() => { 5027 try { 5028 expect(data.data).assertEqual("SUCCESS"); 5029 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 end"); 5030 clearTimeout(t); 5031 done(); 5032 } catch (err) { 5033 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 err:" + JSON.stringify(err)); 5034 clearTimeout(t); 5035 done(); 5036 } 5037 }, 500) 5038 } 5039 5040 let publishCallback = (err: BusinessError) => { 5041 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 publishCallback start"); 5042 if (err) { 5043 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 publishCallback failed:" + 5044 JSON.stringify(err)); 5045 } 5046 } 5047 5048 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5049 events: ["Sub_Misc_inputMethod_selectByMovement_sync_0291"] 5050 } 5051 let subscriber: ESObject; 5052 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5053 try { 5054 subscriber = data; 5055 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 subscriber data:" + JSON.stringify(data)); 5056 commonEventManager.subscribe(subscriber, subscriberCallback); 5057 console.info("====>Sub_Misc_inputMethod_selectByMovement_sync_0291 subscriber finish"); 5058 } catch (err) { 5059 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5060 } 5061 5062 let t = setTimeout(async () => { 5063 clearTimeout(t); 5064 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5065 code: 291 5066 } 5067 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5068 }, 500) 5069 5070 }).catch((err: BusinessError) => { 5071 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5072 }) 5073 }); 5074 5075 /* 5076 * @tc.number Sub_Misc_Request_InputMethod_selectContext_0400 5077 * @tc.name Sub_Misc_Request_InputMethod_selectContext_0400 5078 * @tc.desc Function test 5079 * @tc.size MediumTest 5080 * @tc.type Function 5081 * @tc.level Level2 5082 */ 5083 it('Sub_Misc_Request_InputMethod_selectContext_0400', 0, async (done: Function) => { 5084 5085 let unSubscriberCallback = (err: BusinessError) => { 5086 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 unSubscriberCallback start"); 5087 if (err) { 5088 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 unSubscriberCallback failed:" + 5089 JSON.stringify(err)); 5090 } else { 5091 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 unSubscriberCallback finish"); 5092 } 5093 } 5094 5095 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5096 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 subscriberCallback data:" 5097 + JSON.stringify(data)); 5098 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5099 let t = setTimeout(() => { 5100 try { 5101 expect(data.data).assertEqual("SUCCESS"); 5102 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 end"); 5103 clearTimeout(t); 5104 done(); 5105 } catch (err) { 5106 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 err:" + JSON.stringify(err)); 5107 clearTimeout(t); 5108 done(); 5109 } 5110 }, 500) 5111 } 5112 5113 let publishCallback = (err: BusinessError) => { 5114 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 publishCallback start"); 5115 if (err) { 5116 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 publishCallback failed:" + 5117 JSON.stringify(err)); 5118 } 5119 } 5120 5121 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5122 events: ["Sub_Misc_Request_InputMethod_selectContext_0400"] 5123 } 5124 let subscriber: ESObject; 5125 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5126 try { 5127 subscriber = data; 5128 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 subscriber data:" + JSON.stringify(data)); 5129 commonEventManager.subscribe(subscriber, subscriberCallback); 5130 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0400 subscriber finish"); 5131 } catch (err) { 5132 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5133 } 5134 5135 let t = setTimeout(async () => { 5136 clearTimeout(t); 5137 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5138 code: 300 5139 } 5140 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5141 }, 500) 5142 5143 }).catch((err: BusinessError) => { 5144 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5145 }) 5146 5147 5148 }); 5149 5150 /* 5151 * @tc.number Sub_Misc_Request_InputMethod_selectContext_0500 5152 * @tc.name Sub_Misc_Request_InputMethod_selectContext_0500 5153 * @tc.desc Function test 5154 * @tc.size MediumTest 5155 * @tc.type Function 5156 * @tc.level Level2 5157 */ 5158 it('Sub_Misc_Request_InputMethod_selectContext_0500', 0, async (done: Function) => { 5159 5160 let unSubscriberCallback = (err: BusinessError) => { 5161 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 unSubscriberCallback start"); 5162 if (err) { 5163 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 unSubscriberCallback failed:" + 5164 JSON.stringify(err)); 5165 } else { 5166 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 unSubscriberCallback finish"); 5167 } 5168 } 5169 5170 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5171 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 subscriberCallback data:" 5172 + JSON.stringify(data)); 5173 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5174 let t = setTimeout(() => { 5175 try { 5176 expect(data.data).assertEqual("SUCCESS"); 5177 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 end"); 5178 clearTimeout(t); 5179 done(); 5180 } catch (err) { 5181 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 err:" + JSON.stringify(err)); 5182 clearTimeout(t); 5183 done(); 5184 } 5185 }, 500) 5186 } 5187 5188 let publishCallback = (err: BusinessError) => { 5189 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 publishCallback start"); 5190 if (err) { 5191 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 publishCallback failed:" + 5192 JSON.stringify(err)); 5193 } 5194 } 5195 5196 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5197 events: ["Sub_Misc_Request_InputMethod_selectContext_0500"] 5198 } 5199 let subscriber: ESObject; 5200 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5201 try { 5202 subscriber = data; 5203 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 subscriber data:" + JSON.stringify(data)); 5204 commonEventManager.subscribe(subscriber, subscriberCallback); 5205 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0500 subscriber finish"); 5206 } catch (err) { 5207 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5208 } 5209 5210 let t = setTimeout(async () => { 5211 clearTimeout(t); 5212 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5213 code: 310 5214 } 5215 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5216 }, 500) 5217 }).catch((err: BusinessError) => { 5218 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5219 }) 5220 5221 5222 }); 5223 5224 /* 5225 * @tc.number Sub_Misc_Request_InputMethod_selectContext_0600 5226 * @tc.name Sub_Misc_Request_InputMethod_selectContext_0600 5227 * @tc.desc Function test 5228 * @tc.size MediumTest 5229 * @tc.type Function 5230 * @tc.level Level2 5231 */ 5232 it('Sub_Misc_Request_InputMethod_selectContext_0600', 0, async (done: Function) => { 5233 5234 let unSubscriberCallback = (err: BusinessError) => { 5235 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 unSubscriberCallback start"); 5236 if (err) { 5237 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 unSubscriberCallback failed:" + 5238 JSON.stringify(err)); 5239 } else { 5240 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 unSubscriberCallback finish"); 5241 } 5242 } 5243 5244 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5245 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 subscriberCallback data:" 5246 + JSON.stringify(data)); 5247 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5248 let t = setTimeout(() => { 5249 try { 5250 expect(data.data).assertEqual("SUCCESS"); 5251 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 end"); 5252 clearTimeout(t); 5253 done(); 5254 } catch (err) { 5255 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 err:" + JSON.stringify(err)); 5256 clearTimeout(t); 5257 done(); 5258 } 5259 }, 500) 5260 } 5261 5262 let publishCallback = (err: BusinessError) => { 5263 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 publishCallback start"); 5264 if (err) { 5265 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 publishCallback failed:" + 5266 JSON.stringify(err)); 5267 } 5268 } 5269 5270 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5271 events: ["Sub_Misc_Request_InputMethod_selectContext_0600"] 5272 } 5273 let subscriber: ESObject; 5274 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5275 try { 5276 subscriber = data; 5277 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 subscriber data:" + JSON.stringify(data)); 5278 commonEventManager.subscribe(subscriber, subscriberCallback); 5279 console.info("====>Sub_Misc_Request_InputMethod_selectContext_0600 subscriber finish"); 5280 } catch (err) { 5281 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5282 } 5283 5284 let t = setTimeout(async () => { 5285 clearTimeout(t); 5286 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5287 code: 320 5288 } 5289 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5290 }, 500) 5291 5292 }).catch((err: BusinessError) => { 5293 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5294 }) 5295 5296 5297 }); 5298 5299 /* 5300 * @tc.number SUB_InputMethod_IsTextPreviewSupport_0100 5301 * @tc.name SUB_InputMethod_IsTextPreviewSupport_0100 5302 * @tc.desc Function test 5303 * @tc.size MediumTest 5304 * @tc.type Function 5305 * @tc.level Level2 5306 */ 5307 it('SUB_InputMethod_IsTextPreviewSupport_0100', 0, async (done: Function) => { 5308 5309 let unSubscriberCallback = (err: BusinessError) => { 5310 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 unSubscriberCallback start"); 5311 if (err) { 5312 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 unSubscriberCallback failed:" + 5313 JSON.stringify(err)); 5314 } else { 5315 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 unSubscriberCallback finish"); 5316 } 5317 } 5318 5319 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5320 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 subscriberCallback data:" 5321 + JSON.stringify(data)); 5322 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5323 let t = setTimeout(() => { 5324 try { 5325 expect(data.data).assertEqual("SUCCESS"); 5326 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 end"); 5327 clearTimeout(t); 5328 done(); 5329 } catch (err) { 5330 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 err:" + JSON.stringify(err)); 5331 clearTimeout(t); 5332 done(); 5333 } 5334 }, 500) 5335 } 5336 5337 let publishCallback = (err: BusinessError) => { 5338 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 publishCallback start"); 5339 if (err) { 5340 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 publishCallback failed:" + JSON.stringify(err)); 5341 } 5342 } 5343 5344 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5345 events: ["SUB_InputMethod_IsTextPreviewSupport_0100"] 5346 } 5347 let subscriber: ESObject; 5348 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5349 try { 5350 subscriber = data; 5351 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 subscriber data:" + JSON.stringify(data)) 5352 commonEventManager.subscribe(subscriber, subscriberCallback); 5353 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0100 subscriber finish"); 5354 } catch (err) { 5355 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5356 } 5357 5358 let t = setTimeout(async () => { 5359 clearTimeout(t); 5360 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5361 code: 340 5362 } 5363 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5364 }, 500) 5365 5366 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5367 code: 340 5368 } 5369 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5370 }).catch((err: BusinessError) => { 5371 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5372 }) 5373 }); 5374 5375 /* 5376 * @tc.number SUB_InputMethod_IsTextPreviewSupport_0200 5377 * @tc.name SUB_InputMethod_IsTextPreviewSupport_0200 5378 * @tc.desc Function test 5379 * @tc.size MediumTest 5380 * @tc.type Function 5381 * @tc.level Level2 5382 */ 5383 it('SUB_InputMethod_IsTextPreviewSupport_0200', 0, async (done: Function) => { 5384 5385 let unSubscriberCallback = (err: BusinessError) => { 5386 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 unSubscriberCallback start"); 5387 if (err) { 5388 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 unSubscriberCallback failed:" + 5389 JSON.stringify(err)); 5390 } else { 5391 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 unSubscriberCallback finish"); 5392 } 5393 } 5394 5395 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5396 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 subscriberCallback data:" 5397 + JSON.stringify(data)); 5398 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5399 let t = setTimeout(() => { 5400 try { 5401 expect(data.data).assertEqual("SUCCESS"); 5402 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 end"); 5403 clearTimeout(t); 5404 done(); 5405 } catch (err) { 5406 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 err:" + JSON.stringify(err)); 5407 clearTimeout(t); 5408 done(); 5409 } 5410 }, 500) 5411 } 5412 5413 let publishCallback = (err: BusinessError) => { 5414 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 publishCallback start"); 5415 if (err) { 5416 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 publishCallback failed:" + JSON.stringify(err)); 5417 } 5418 } 5419 5420 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5421 events: ["SUB_InputMethod_IsTextPreviewSupport_0200"] 5422 } 5423 let subscriber: ESObject; 5424 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5425 try { 5426 subscriber = data; 5427 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 subscriber data:" + JSON.stringify(data)) 5428 commonEventManager.subscribe(subscriber, subscriberCallback); 5429 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0200 subscriber finish"); 5430 } catch (err) { 5431 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5432 } 5433 5434 let t = setTimeout(async () => { 5435 clearTimeout(t); 5436 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5437 code: 350 5438 } 5439 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5440 }, 500) 5441 5442 }).catch((err: BusinessError) => { 5443 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5444 }) 5445 }); 5446 5447 /* 5448 * @tc.number SUB_InputMethod_IsTextPreviewSupport_0300 5449 * @tc.name SUB_InputMethod_IsTextPreviewSupport_0300 5450 * @tc.desc Function test 5451 * @tc.size MediumTest 5452 * @tc.type Function 5453 * @tc.level Level2 5454 */ 5455 it('SUB_InputMethod_IsTextPreviewSupport_0300', 0, async (done: Function) => { 5456 5457 let unSubscriberCallback = (err: BusinessError) => { 5458 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 unSubscriberCallback start"); 5459 if (err) { 5460 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 unSubscriberCallback failed:" + 5461 JSON.stringify(err)); 5462 } else { 5463 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 unSubscriberCallback finish"); 5464 } 5465 } 5466 5467 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5468 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 subscriberCallback data:" 5469 + JSON.stringify(data)); 5470 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5471 let t = setTimeout(() => { 5472 try { 5473 expect(data.data).assertEqual("SUCCESS"); 5474 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 end"); 5475 clearTimeout(t); 5476 done(); 5477 } catch (err) { 5478 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 err:" + JSON.stringify(err)); 5479 clearTimeout(t); 5480 done(); 5481 } 5482 }, 500) 5483 } 5484 5485 let publishCallback = (err: BusinessError) => { 5486 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 publishCallback start"); 5487 if (err) { 5488 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 publishCallback failed:" + JSON.stringify(err)); 5489 } 5490 } 5491 5492 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5493 events: ["SUB_InputMethod_IsTextPreviewSupport_0300"] 5494 } 5495 let subscriber: ESObject; 5496 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5497 try { 5498 subscriber = data; 5499 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 subscriber data:" + JSON.stringify(data)) 5500 commonEventManager.subscribe(subscriber, subscriberCallback); 5501 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0300 subscriber finish"); 5502 } catch (err) { 5503 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5504 } 5505 5506 let t = setTimeout(async () => { 5507 clearTimeout(t); 5508 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5509 code: 360 5510 } 5511 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5512 }, 500) 5513 5514 }).catch((err: BusinessError) => { 5515 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5516 }) 5517 }); 5518 5519 /* 5520 * @tc.number SUB_InputMethod_IsTextPreviewSupport_0400 5521 * @tc.name SUB_InputMethod_IsTextPreviewSupport_0400 5522 * @tc.desc Function test 5523 * @tc.size MediumTest 5524 * @tc.type Function 5525 * @tc.level Level2 5526 */ 5527 it('SUB_InputMethod_IsTextPreviewSupport_0400', 0, async (done: Function) => { 5528 5529 let unSubscriberCallback = (err: BusinessError) => { 5530 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 unSubscriberCallback start"); 5531 if (err) { 5532 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 unSubscriberCallback failed:" + 5533 JSON.stringify(err)); 5534 } else { 5535 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 unSubscriberCallback finish"); 5536 } 5537 } 5538 5539 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5540 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 subscriberCallback data:" 5541 + JSON.stringify(data)); 5542 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5543 let t = setTimeout(() => { 5544 try { 5545 expect(data.data).assertEqual("SUCCESS"); 5546 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 end"); 5547 clearTimeout(t); 5548 done(); 5549 } catch (err) { 5550 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 err:" + JSON.stringify(err)); 5551 clearTimeout(t); 5552 done(); 5553 } 5554 }, 500) 5555 } 5556 5557 let publishCallback = (err: BusinessError) => { 5558 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 publishCallback start"); 5559 if (err) { 5560 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 publishCallback failed:" + JSON.stringify(err)); 5561 } 5562 } 5563 5564 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5565 events: ["SUB_InputMethod_IsTextPreviewSupport_0400"] 5566 } 5567 let subscriber: ESObject; 5568 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5569 try { 5570 subscriber = data; 5571 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 subscriber data:" + JSON.stringify(data)) 5572 commonEventManager.subscribe(subscriber, subscriberCallback); 5573 console.info("====>SUB_InputMethod_IsTextPreviewSupport_0400 subscriber finish"); 5574 } catch (err) { 5575 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5576 } 5577 5578 let t = setTimeout(async () => { 5579 clearTimeout(t); 5580 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5581 code: 370 5582 } 5583 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5584 }, 500) 5585 5586 }).catch((err: BusinessError) => { 5587 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5588 }) 5589 }); 5590 5591 /* 5592 * @tc.number SUB_InputMethod_IME_PrivateDateTransferred_0500 5593 * @tc.name SUB_InputMethod_IME_PrivateDateTransferred_0500 5594 * @tc.desc Function test 5595 * @tc.size MediumTest 5596 * @tc.type Function 5597 * @tc.level Level2 5598 */ 5599 it('SUB_InputMethod_IME_PrivateDateTransferred_0500', 0, async (done: Function) => { 5600 5601 let unSubscriberCallback = (err: BusinessError) => { 5602 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 unSubscriberCallback start"); 5603 if (err) { 5604 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 unSubscriberCallback failed:" + 5605 JSON.stringify(err)); 5606 } else { 5607 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 unSubscriberCallback finish"); 5608 } 5609 } 5610 5611 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5612 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 subscriberCallback data:" 5613 + JSON.stringify(data)); 5614 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5615 let t = setTimeout(() => { 5616 try { 5617 expect(data.data).assertEqual("SUCCESS"); 5618 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 end"); 5619 clearTimeout(t); 5620 done(); 5621 } catch (err) { 5622 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 err:" + JSON.stringify(err)); 5623 clearTimeout(t); 5624 done(); 5625 } 5626 }, 500) 5627 } 5628 5629 let publishCallback = (err: BusinessError) => { 5630 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 publishCallback start"); 5631 if (err) { 5632 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 publishCallback failed:" + 5633 JSON.stringify(err)); 5634 } 5635 } 5636 5637 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5638 events: ["SUB_InputMethod_IME_PrivateDateTransferred_0500"] 5639 } 5640 let subscriber: ESObject; 5641 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5642 try { 5643 subscriber = data; 5644 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 subscriber data:" + JSON.stringify(data)) 5645 commonEventManager.subscribe(subscriber, subscriberCallback); 5646 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0500 subscriber finish"); 5647 } catch (err) { 5648 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5649 } 5650 5651 let t = setTimeout(async () => { 5652 clearTimeout(t); 5653 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5654 code: 380 5655 } 5656 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5657 }, 500) 5658 5659 }).catch((err: BusinessError) => { 5660 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5661 }) 5662 }); 5663 5664 /* 5665 * @tc.number SUB_InputMethod_IME_PrivateDateTransferred_0600 5666 * @tc.name SUB_InputMethod_IME_PrivateDateTransferred_0600 5667 * @tc.desc Function test 5668 * @tc.size MediumTest 5669 * @tc.type Function 5670 * @tc.level Level2 5671 */ 5672 it('SUB_InputMethod_IME_PrivateDateTransferred_0600', 0, async (done: Function) => { 5673 5674 let unSubscriberCallback = (err: BusinessError) => { 5675 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 unSubscriberCallback start"); 5676 if (err) { 5677 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 unSubscriberCallback failed:" + 5678 JSON.stringify(err)); 5679 } else { 5680 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 unSubscriberCallback finish"); 5681 } 5682 } 5683 5684 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5685 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 subscriberCallback data:" 5686 + JSON.stringify(data)); 5687 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5688 let t = setTimeout(() => { 5689 try { 5690 expect(data.data).assertEqual("SUCCESS"); 5691 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 end"); 5692 clearTimeout(t); 5693 done(); 5694 } catch (err) { 5695 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 err:" + JSON.stringify(err)); 5696 clearTimeout(t); 5697 done(); 5698 } 5699 }, 500) 5700 } 5701 5702 let publishCallback = (err: BusinessError) => { 5703 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 publishCallback start"); 5704 if (err) { 5705 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 publishCallback failed:" + 5706 JSON.stringify(err)); 5707 } 5708 } 5709 5710 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5711 events: ["SUB_InputMethod_IME_PrivateDateTransferred_0600"] 5712 } 5713 let subscriber: ESObject; 5714 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5715 try { 5716 subscriber = data; 5717 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 subscriber data:" + JSON.stringify(data)) 5718 commonEventManager.subscribe(subscriber, subscriberCallback); 5719 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_0600 subscriber finish"); 5720 } catch (err) { 5721 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5722 } 5723 5724 let t = setTimeout(async () => { 5725 clearTimeout(t); 5726 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5727 code: 390 5728 } 5729 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5730 }, 500) 5731 5732 }).catch((err: BusinessError) => { 5733 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5734 }) 5735 }); 5736 5737 /* 5738 * @tc.number SUB_InputMethod_IME_PrivateDateTransferred_1100 5739 * @tc.name SUB_InputMethod_IME_PrivateDateTransferred_1100 5740 * @tc.desc Function test 5741 * @tc.size MediumTest 5742 * @tc.type Function 5743 * @tc.level Level2 5744 */ 5745 it('SUB_InputMethod_IME_PrivateDateTransferred_1100', 0, async (done: Function) => { 5746 5747 let unSubscriberCallback = (err: BusinessError) => { 5748 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 unSubscriberCallback start"); 5749 if (err) { 5750 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 unSubscriberCallback failed:" + 5751 JSON.stringify(err)); 5752 } else { 5753 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 unSubscriberCallback finish"); 5754 } 5755 } 5756 5757 let subscriberCallback = (err: BusinessError, data: ESObject) => { 5758 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 subscriberCallback data:" 5759 + JSON.stringify(data)); 5760 commonEventManager.unsubscribe(subscriber, unSubscriberCallback); 5761 let t = setTimeout(() => { 5762 try { 5763 expect(data.data).assertEqual("SUCCESS"); 5764 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 end"); 5765 clearTimeout(t); 5766 done(); 5767 } catch (err) { 5768 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 err:" + JSON.stringify(err)); 5769 clearTimeout(t); 5770 done(); 5771 } 5772 }, 500) 5773 } 5774 5775 let publishCallback = (err: BusinessError) => { 5776 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 publishCallback start"); 5777 if (err) { 5778 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 publishCallback failed:" + 5779 JSON.stringify(err)); 5780 } 5781 } 5782 5783 let commonEventSubscribeInfo: commonEventManager.CommonEventSubscribeInfo = { 5784 events: ["SUB_InputMethod_IME_PrivateDateTransferred_1100"] 5785 } 5786 let subscriber: ESObject; 5787 commonEventManager.createSubscriber(commonEventSubscribeInfo).then((data) => { 5788 try { 5789 subscriber = data; 5790 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 subscriber data:" + JSON.stringify(data)) 5791 commonEventManager.subscribe(subscriber, subscriberCallback); 5792 console.info("====>SUB_InputMethod_IME_PrivateDateTransferred_1100 subscriber finish"); 5793 } catch (err) { 5794 console.info(`====>Subscribe failed, code:${err.code}, message is ${err.message}`) 5795 } 5796 5797 let t = setTimeout(async () => { 5798 clearTimeout(t); 5799 let commonEventPublishData: commonEventManager.CommonEventPublishData = { 5800 code: 400 5801 } 5802 commonEventManager.publish('inputMethodAbilityTest', commonEventPublishData, publishCallback); 5803 }, 500) 5804 5805 }).catch((err: BusinessError) => { 5806 console.info(`====>createSubscriber failed, code:${err.code}, message is ${err.message}`) 5807 }) 5808 }); 5809 5810 }); 5811}; 5812