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