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