1/* 2 * Copyright (C) 2021-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16import hiAppEventV9 from "@ohos.hiviewdfx.hiAppEvent" 17import hiAppEvent from "@ohos.hiAppEvent" 18 19import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect} from 'deccjsunit/index' 20 21describe('HiAppEventJsTest', function () { 22 beforeAll(function() { 23 /* 24 * @tc.setup: setup invoked before all test cases 25 */ 26 console.info('HiAppEventJsTest beforeAll called') 27 }) 28 29 afterAll(function() { 30 /* 31 * @tc.teardown: teardown invoked after all test cases 32 */ 33 console.info('HiAppEventJsTest afterAll called') 34 }) 35 36 beforeEach(function() { 37 /* 38 * @tc.setup: setup invoked before each test case 39 */ 40 console.info('HiAppEventJsTest beforeEach called') 41 }) 42 43 afterEach(function() { 44 /* 45 * @tc.teardown: teardown invoked after each test case 46 */ 47 console.info('HiAppEventJsTest afterEach called') 48 }) 49 50 const TEST_DOMAIN = 'test_domain'; 51 const TEST_NAME = 'test_name'; 52 const TEST_TYPE = hiAppEvent.EventType.FAULT; 53 const TEST_TYPE_V9 = hiAppEventV9.EventType.FAULT; 54 const TEST_PARAMS = {}; 55 56 function simpleTrigger(curRow, curSize, holder) { 57 console.info("HiAppEventJsTest onTrigger curRow=" + curRow); 58 console.info("HiAppEventJsTest onTrigger curSize=" + curSize); 59 if (holder == null) { 60 console.info("HiAppEventJsTest onTrigger holder is null"); 61 } 62 } 63 64 function simpleWriteV9Test() { 65 hiAppEventV9.write({ 66 domain: "test_domain", 67 name: "test_name", 68 eventType: hiAppEventV9.EventType.FAULT, 69 params: {} 70 }, (err) => { 71 expect(err).assertNull() 72 }); 73 } 74 75 function createError(code, message) { 76 return { code: code.toString(), message: message }; 77 } 78 79 function createError2(name, type) { 80 return { code: "401", message: "Parameter error. The type of " + name + " must be " + type + "." }; 81 } 82 83 function createError3(name) { 84 return { code: "401", message: "Parameter error. The " + name + " parameter is mandatory." }; 85 } 86 87 function assertErrorEqual(actualErr, expectErr) { 88 if (expectErr) { 89 expect(actualErr.code).assertEqual(expectErr.code) 90 expect(actualErr.message).assertEqual(expectErr.message) 91 } else { 92 expect(actualErr).assertNull(); 93 } 94 } 95 96 function writeTest(name, type, params, code, done) { 97 hiAppEvent.write(name, type, params, (err, value) => { 98 let result = err ? err.code : value; 99 expect(result).assertEqual(code); 100 console.info('HiAppEventJsTest writeTest end, result=' + result); 101 done(); 102 }); 103 } 104 105 function writeParamsTest(params, code, done) { 106 writeTest(TEST_NAME, TEST_TYPE, params, code, done); 107 } 108 109 function writeNameTest(name, code, done) { 110 writeTest(name, TEST_TYPE, TEST_PARAMS, code, done); 111 } 112 113 function writeV9Test(eventInfo, expectErr, done, hasCatch) { 114 if (hasCatch) { 115 try { 116 hiAppEventV9.write(eventInfo, (err) => { 117 expect(err).assertNull() 118 }); 119 } catch (err) { 120 assertErrorEqual(err, expectErr); 121 console.info('HiAppEventJsTest writeV9Test_catch end'); 122 done(); 123 } 124 } else { 125 hiAppEventV9.write(eventInfo, (err) => { 126 assertErrorEqual(err, expectErr); 127 console.info('HiAppEventJsTest writeV9Test end'); 128 done(); 129 }); 130 } 131 } 132 133 function writeParamsV9Test(params, expectErr, done, hasCatch) { 134 let eventInfo = { 135 domain: TEST_DOMAIN, 136 name: TEST_NAME, 137 eventType: TEST_TYPE_V9, 138 params: params 139 }; 140 writeV9Test(eventInfo, expectErr, done, hasCatch); 141 } 142 143 function writeDomainV9Test(domain, expectErr, done, hasCatch) { 144 let eventInfo = { 145 domain: domain, 146 name: TEST_NAME, 147 eventType: TEST_TYPE_V9, 148 params: TEST_PARAMS 149 }; 150 writeV9Test(eventInfo, expectErr, done, hasCatch); 151 } 152 153 function writeNameV9Test(name, expectErr, done, hasCatch) { 154 let eventInfo = { 155 domain: TEST_DOMAIN, 156 name: name, 157 eventType: TEST_TYPE_V9, 158 params: TEST_PARAMS 159 }; 160 writeV9Test(eventInfo, expectErr, done, hasCatch); 161 } 162 163 function writeTypeV9Test(type, expectErr, done, hasCatch) { 164 let eventInfo = { 165 domain: TEST_DOMAIN, 166 name: TEST_NAME, 167 eventType: type, 168 params: TEST_PARAMS 169 }; 170 writeV9Test(eventInfo, expectErr, done, hasCatch); 171 } 172 173 function setEventConfigV9Test(name, configInfo, expectErr, done) { 174 hiAppEventV9.setEventConfig(name, configInfo).then((data) => { 175 expect(data).assertEqual(0); 176 done(); 177 }).catch((err) => { 178 assertErrorEqual(err, expectErr); 179 done(); 180 }); 181 } 182 183 function setEventConfigV9TestCatch(name, configInfo, expectErr, done) { 184 try { 185 setEventConfigV9Test(name, configInfo, expectErr, done); 186 } catch (err) { 187 assertErrorEqual(err, expectErr); 188 done(); 189 } 190 } 191 192 /** 193 * @tc.number HiAppEventJsTest001_1 194 * @tc.name: HiAppEventJsTest001_1 195 * @tc.desc: Test the write interface using callback. 196 * @tc.type: FUNC 197 * @tc.require: issueI4BY0R 198 */ 199 it('HiAppEventJsTest001_1', 0, async function (done) { 200 console.info('HiAppEventJsTest001_1 start'); 201 let params = { 202 "key_int": 100, 203 "key_string": "strValue", 204 "key_bool": true, 205 "key_float": 30949.374, 206 "key_int_arr": [1, 2, 3], 207 "key_string_arr": ["a", "b", "c"], 208 "key_float_arr": [1.1, 2.2, 3.0], 209 "key_bool_arr": [true, false, true] 210 }; 211 writeParamsTest(params, 0, done); 212 }); 213 214 /** 215 * @tc.number HiAppEventJsTest001_2 216 * @tc.name: HiAppEventJsTest001_2 217 * @tc.desc: Test the write interface using callback. 218 * @tc.type: FUNC 219 * @tc.require: issueI4BY0R 220 */ 221 it('HiAppEventJsTest001_2', 0, async function (done) { 222 console.info('HiAppEventJsTest001_2 start'); 223 let params = { 224 "key_int": 100, 225 "key_string": "strValue", 226 "key_bool": true, 227 "key_float": 30949.374, 228 "key_int_arr": [1, 2, 3], 229 "key_string_arr": ["a", "b", "c"], 230 "key_float_arr": [1.1, 2.2, 3.0], 231 "key_bool_arr": [true, false, true] 232 }; 233 writeParamsV9Test(params, null, done); 234 }); 235 236 /** 237 * @tc.number HiAppEventJsTest002_1 238 * @tc.name: HiAppEventJsTest002_1 239 * @tc.desc: Test the write interface using promise. 240 * @tc.type: FUNC 241 * @tc.require: issueI4BY0R 242 */ 243 it('HiAppEventJsTest002_1', 0, async function (done) { 244 console.info('HiAppEventJsTest002_1 start'); 245 hiAppEvent.write(TEST_NAME, TEST_TYPE_V9, TEST_PARAMS).then((value) => { 246 let result = value; 247 expect(result).assertEqual(0); 248 console.info('HiAppEventJsTest002_1 succ'); 249 done() 250 }).catch((err) => { 251 expect().assertFail(); 252 done() 253 }); 254 }); 255 256 /** 257 * @tc.number HiAppEventJsTest002_2 258 * @tc.name: HiAppEventJsTest002_2 259 * @tc.desc: Test the write interface using promise. 260 * @tc.type: FUNC 261 * @tc.require: issueI4BY0R 262 */ 263 it('HiAppEventJsTest002_2', 0, async function (done) { 264 console.info('HiAppEventJsTest002_2 start'); 265 let eventInfo = { 266 domain: TEST_DOMAIN, 267 name: TEST_NAME, 268 eventType: TEST_TYPE_V9, 269 params: TEST_PARAMS 270 }; 271 hiAppEventV9.write(eventInfo).then(() => { 272 console.info('HiAppEventJsTest002_2 succ'); 273 done(); 274 }).catch((err) => { 275 expect().assertFail(); 276 done(); 277 }); 278 }); 279 280 /** 281 * @tc.number HiAppEventJsTest003_1 282 * @tc.name: HiAppEventJsTest003_1 283 * @tc.desc: Error code 1 is returned when the event has an invalid key name. 284 * @tc.type: FUNC 285 * @tc.require: issueI4BY0R 286 */ 287 it('HiAppEventJsTest003_1', 0, async function (done) { 288 console.info('HiAppEventJsTest003_1 start'); 289 let params = { 290 "**":"ha", 291 "key_int":1, 292 "HH22":"ha", 293 "key_str":"str", 294 "":"empty", 295 "aa_":"underscore" 296 }; 297 writeParamsTest(params, 1, done); 298 }); 299 300 /** 301 * @tc.number HiAppEventJsTest003_2 302 * @tc.name: HiAppEventJsTest003_2 303 * @tc.desc: Error code 11101005 is returned when the event has an invalid key name. 304 * @tc.type: FUNC 305 * @tc.require: issueI4BY0R 306 */ 307 it('HiAppEventJsTest003_2', 0, async function (done) { 308 console.info('HiAppEventJsTest003_2 start'); 309 let params = { 310 "**":"ha", 311 "key_int":1, 312 "HH22":"ha", 313 "key_str":"str", 314 "":"empty", 315 "aa_":"underscore" 316 }; 317 let expectErr = createError(11101005, "Invalid event parameter name."); 318 writeParamsV9Test(params, expectErr, done); 319 320 const MAX_LENGTH_OF_PARAM_NAME = 32; 321 params = {}; 322 params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME + 1)] = "value"; 323 writeParamsV9Test(params, expectErr, done); 324 325 params = {}; 326 params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME - 1) + "_"] = "value"; 327 writeParamsV9Test(params, expectErr, done); 328 329 params = {}; 330 params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME)] = "value"; 331 writeParamsV9Test(params, null, done); 332 }); 333 334 /** 335 * @tc.number HiAppEventJsTest004_1 336 * @tc.name: HiAppEventJsTest004_1 337 * @tc.desc: Error code 3 is returned when the event has an invalid value type. 338 * @tc.type: FUNC 339 * @tc.require: issueI4BY0R 340 */ 341 it('HiAppEventJsTest004_1', 0, async function (done) { 342 console.info('HiAppEventJsTest004_1 start'); 343 let params = { 344 key_1_invalid: {}, 345 key_2_invalid: null, 346 key_str: "str" 347 }; 348 writeParamsTest(params, 3, done); 349 }); 350 351 /** 352 * @tc.number HiAppEventJsTest004_2 353 * @tc.name: HiAppEventJsTest004_2 354 * @tc.desc: Error code 401 is returned when the event has an invalid value type. 355 * @tc.type: FUNC 356 * @tc.require: issueI4BY0R 357 */ 358 it('HiAppEventJsTest004_2', 0, async function (done) { 359 console.info('HiAppEventJsTest004_2 start'); 360 let params = { 361 key_1_invalid: {}, 362 key_2_invalid: null, 363 key_str: "str" 364 }; 365 let expectErr = createError2("param value", "boolean|number|string|array[boolean|number|string]"); 366 writeParamsV9Test(params, expectErr, done, true); 367 }); 368 369 /** 370 * @tc.number HiAppEventJsTest005_1 371 * @tc.name: HiAppEventJsTest005_1 372 * @tc.desc: Error code 4 is returned when the event has an invalid string length. 373 * @tc.type: FUNC 374 * @tc.require: issueI4BY0R 375 */ 376 it('HiAppEventJsTest005_1', 0, async function (done) { 377 console.info('HiAppEventJsTest005_1 start'); 378 let longStr = "a".repeat(8 * 1024); 379 let invalidStr = "a".repeat(8 * 1024 + 1); 380 let params = { 381 key_long: longStr, 382 key_i_long: invalidStr, 383 key_long_arr: ["ha", longStr], 384 key_i_long_arr: ["ha", invalidStr], 385 key_str: "str" 386 }; 387 writeParamsTest(params, 4, done); 388 }); 389 390 /** 391 * @tc.number HiAppEventJsTest005_2 392 * @tc.name: HiAppEventJsTest005_2 393 * @tc.desc: Error code 11101004 is returned when the event has an invalid string length. 394 * @tc.type: FUNC 395 * @tc.require: issueI4BY0R 396 */ 397 it('HiAppEventJsTest005_2', 0, async function (done) { 398 console.info('HiAppEventJsTest005_2 start'); 399 let longStr = "a".repeat(8 * 1024); 400 let invalidStr = "a".repeat(8 * 1024 + 1); 401 let params = { 402 key_long: longStr, 403 key_i_long: invalidStr, 404 key_long_arr: ["ha", longStr], 405 key_i_long_arr: ["ha", invalidStr], 406 key_str: "str" 407 }; 408 let expectErr = createError(11101004, "Invalid string length of the event parameter."); 409 writeParamsV9Test(params, expectErr, done); 410 }); 411 412 /** 413 * @tc.number HiAppEventJsTest006_1 414 * @tc.name: HiAppEventJsTest006_1 415 * @tc.desc: Error code 5 is returned when the event has too many params. 416 * @tc.type: FUNC 417 * @tc.require: issueI4BY0R 418 */ 419 it('HiAppEventJsTest006_1', 0, async function (done) { 420 console.info('HiAppEventJsTest006_1 start'); 421 let params = {}; 422 for (var i = 1; i <= 33; i++) { 423 params["key" + i] = "value" + i; 424 } 425 writeParamsTest(params, 5, done); 426 }); 427 428 /** 429 * @tc.number HiAppEventJsTest006_2 430 * @tc.name: HiAppEventJsTest006_2 431 * @tc.desc: Error code 11101003 is returned when the event has too many params. 432 * @tc.type: FUNC 433 * @tc.require: issueI4BY0R 434 */ 435 it('HiAppEventJsTest006_2', 0, async function (done) { 436 console.info('HiAppEventJsTest006_2 start'); 437 let params = {}; 438 for (var i = 1; i <= 33; i++) { 439 params["key" + i] = "value" + i; 440 } 441 let expectErr = createError(11101003, "Invalid number of event parameters."); 442 writeParamsV9Test(params, expectErr, done); 443 }); 444 445 /** 446 * @tc.number HiAppEventJsTest007_1 447 * @tc.name: HiAppEventJsTest007_1 448 * @tc.desc: Error code 6 is returned when there is an array with too many elements. 449 * @tc.type: FUNC 450 * @tc.require: issueI4BY0R 451 */ 452 it('HiAppEventJsTest007_1', 0, async function (done) { 453 console.info('HiAppEventJsTest007_1 start'); 454 let longArr = new Array(100).fill(1); 455 let iLongArr = new Array(101).fill("a"); 456 let params = { 457 key_long_arr: longArr, 458 key_i_long_arr: iLongArr, 459 key_str: "str" 460 }; 461 writeParamsTest(params, 6, done); 462 }); 463 464 /** 465 * @tc.number HiAppEventJsTest007_2 466 * @tc.name: HiAppEventJsTest007_2 467 * @tc.desc: Error code 11101006 is returned when there is an array with too many elements. 468 * @tc.type: FUNC 469 * @tc.require: issueI4BY0R 470 */ 471 it('HiAppEventJsTest007_2', 0, async function (done) { 472 console.info('HiAppEventJsTest007_2 start'); 473 let longArr = new Array(100).fill(1); 474 let iLongArr = new Array(101).fill("a"); 475 let params = { 476 key_long_arr: longArr, 477 key_i_long_arr: iLongArr, 478 key_str: "str" 479 }; 480 let expectErr = createError(11101006, "Invalid array length of the event parameter."); 481 writeParamsV9Test(params, expectErr, done); 482 }); 483 484 /** 485 * @tc.number HiAppEventJsTest008_1 486 * @tc.name: HiAppEventJsTest008_1 487 * @tc.desc: Error code 7 is returned when there is an array with inconsistent or illegal parameter types. 488 * @tc.type: FUNC 489 * @tc.require: issueI4BY0R 490 */ 491 it('HiAppEventJsTest008_1', 0, async function (done) { 492 console.info('HiAppEventJsTest008_1 start'); 493 let params = { 494 key_arr_null: [null, null], 495 key_arr_obj: [{}], 496 key_arr_test1:[true, "ha"], 497 key_arr_test2:[123, "ha"], 498 key_str: "str" 499 }; 500 writeParamsTest(params, 7, done); 501 }); 502 503 /** 504 * @tc.number HiAppEventJsTest008_2 505 * @tc.name: HiAppEventJsTest008_2 506 * @tc.desc: Error code 401 is returned when there is an array with inconsistent or illegal parameter types. 507 * @tc.type: FUNC 508 * @tc.require: issueI4BY0R 509 */ 510 it('HiAppEventJsTest008_2', 0, async function (done) { 511 console.info('HiAppEventJsTest008_2 start'); 512 let params = { 513 key_arr_null: [null, null], 514 key_arr_obj: [{}], 515 key_arr_test1:[true, "ha"], 516 key_arr_test2:[123, "ha"], 517 key_str: "str" 518 }; 519 let expectErr = createError2("param value", "boolean|number|string|array[boolean|number|string]"); 520 writeParamsV9Test(params, expectErr, done, true); 521 }); 522 523 /** 524 * @tc.number HiAppEventJsTest009_1 525 * @tc.name: HiAppEventJsTest009_1 526 * @tc.desc: Error code -1 is returned when the event has invalid event name. 527 * @tc.type: FUNC 528 * @tc.require: issueI4BY0R 529 */ 530 it('HiAppEventJsTest009_1', 0, async function (done) { 531 console.info('HiAppEventJsTest009_1 start'); 532 writeNameTest("verify_test_1.**1", -1, done); 533 }); 534 535 /** 536 * @tc.number HiAppEventJsTest009_2 537 * @tc.name: HiAppEventJsTest009_2 538 * @tc.desc: Error code 11101002 is returned when the event has invalid event name. 539 * @tc.type: FUNC 540 * @tc.require: issueI4BY0R 541 */ 542 it('HiAppEventJsTest009_2', 0, async function (done) { 543 console.info('HiAppEventJsTest009_2 start'); 544 let expectErr = createError(11101002, "Invalid event name."); 545 writeNameV9Test("", expectErr, done); 546 }); 547 548 /** 549 * @tc.number HiAppEventJsTest009_3 550 * @tc.name: HiAppEventJsTest009_3 551 * @tc.desc: Error code 11101002 is returned when the event has invalid event name. 552 * @tc.type: FUNC 553 * @tc.require: issueI4BY0R 554 */ 555 it('HiAppEventJsTest009_3', 0, async function (done) { 556 console.info('HiAppEventJsTest009_3 start'); 557 let expectErr = createError(11101002, "Invalid event name."); 558 writeNameV9Test("VVtt_", expectErr, done); 559 }); 560 561 /** 562 * @tc.number HiAppEventJsTest009_4 563 * @tc.name: HiAppEventJsTest009_4 564 * @tc.desc: Error code 11101002 is returned when the event has invalid event name. 565 * @tc.type: FUNC 566 * @tc.require: issueI4BY0R 567 */ 568 it('HiAppEventJsTest009_4', 0, async function (done) { 569 console.info('HiAppEventJsTest009_3 start'); 570 const MAX_LENGTH_OF_EVENT_NAME = 48; 571 let expectErr = createError(11101002, "Invalid event name."); 572 writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME + 1), expectErr, done); 573 574 writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME - 1) + "_", expectErr, done); 575 576 writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME), null, done); 577 }); 578 579 /** 580 * @tc.number HiAppEventJsTest010_1 581 * @tc.name: HiAppEventJsTest010_1 582 * @tc.desc: Error code -2 is returned when the event has invalid eventName type, eventType type, keyValues type. 583 * @tc.type: FUNC 584 * @tc.require: issueI4BY0R 585 */ 586 it('HiAppEventJsTest010_1', 0, async function (done) { 587 console.info('HiAppEventJsTest010_1 start'); 588 writeTest(null, TEST_TYPE, TEST_PARAMS, -2, done); 589 }); 590 591 /** 592 * @tc.number HiAppEventJsTest010_2 593 * @tc.name: HiAppEventJsTest010_2 594 * @tc.desc: Error code -2 is returned when the event has invalid eventName type, eventType type, keyValues type. 595 * @tc.type: FUNC 596 * @tc.require: issueI4BY0R 597 */ 598 it('HiAppEventJsTest010_1', 0, async function (done) { 599 console.info('HiAppEventJsTest010_1 start'); 600 writeTest(TEST_NAME, "invalid", TEST_PARAMS, -2, done); 601 }); 602 603 /** 604 * @tc.number HiAppEventJsTest010_3 605 * @tc.name: HiAppEventJsTest010_3 606 * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type. 607 * @tc.type: FUNC 608 * @tc.require: issueI4BY0R 609 */ 610 it('HiAppEventJsTest010_3', 0, async function (done) { 611 console.info('HiAppEventJsTest010_3 start'); 612 613 // invalid AppEventInfo type 614 let expectErr = createError2("info", "AppEventInfo"); 615 writeV9Test(null, expectErr, done, true); 616 }); 617 618 /** 619 * @tc.number HiAppEventJsTest010_4 620 * @tc.name: HiAppEventJsTest010_4 621 * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type. 622 * @tc.type: FUNC 623 * @tc.require: issueI4BY0R 624 */ 625 it('HiAppEventJsTest010_4', 0, async function (done) { 626 console.info('HiAppEventJsTest010_4 start'); 627 628 // invalid event domain type 629 let expectErr = createError2("domain", "string"); 630 writeDomainV9Test(true, expectErr, done, true); 631 }); 632 633 /** 634 * @tc.number HiAppEventJsTest010_5 635 * @tc.name: HiAppEventJsTest010_5 636 * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type. 637 * @tc.type: FUNC 638 * @tc.require: issueI4BY0R 639 */ 640 it('HiAppEventJsTest010_5', 0, async function (done) { 641 console.info('HiAppEventJsTest010_5 start'); 642 643 // invalid event name type 644 let expectErr = createError2("name", "string"); 645 writeNameV9Test(null, expectErr, done, true); 646 }); 647 648 /** 649 * @tc.number HiAppEventJsTest010_6 650 * @tc.name: HiAppEventJsTest010_6 651 * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type. 652 * @tc.type: FUNC 653 * @tc.require: issueI4BY0R 654 */ 655 it('HiAppEventJsTest010_6', 0, async function (done) { 656 console.info('HiAppEventJsTest010_6 start'); 657 658 // invalid eventType type 659 let expectErr = createError2("eventType", "EventType"); 660 writeTypeV9Test(-1, expectErr, done, true); 661 }); 662 663 /** 664 * @tc.number HiAppEventJsTest010_7 665 * @tc.name: HiAppEventJsTest010_7 666 * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type. 667 * @tc.type: FUNC 668 * @tc.require: issueI4BY0R 669 */ 670 it('HiAppEventJsTest010_7', 0, async function (done) { 671 console.info('HiAppEventJsTest010_7 start'); 672 673 // invalid event params type 674 let expectErr = createError2("params", "object"); 675 writeParamsV9Test(null, expectErr, done, true); 676 }); 677 678 /** 679 * @tc.number HiAppEventJsTest011_1 680 * @tc.name: HiAppEventJsTest011_1 681 * @tc.desc: Error code -3 is returned when the event has invalid num of args. 682 * @tc.type: FUNC 683 * @tc.require: issueI4BY0R 684 */ 685 it('HiAppEventJsTest011_1', 0, async function (done) { 686 console.info('HiAppEventJsTest011_1 start'); 687 hiAppEvent.write().then(() => { 688 expect().assertFail(); 689 done(); 690 }).catch((err) => { 691 let result = err.code; 692 expect(result).assertEqual(-3); 693 done(); 694 console.info('HiAppEventJsTest011_1 end'); 695 }); 696 }); 697 698 /** 699 * @tc.number HiAppEventJsTest011_2 700 * @tc.name: HiAppEventJsTest011_2 701 * @tc.desc: Error code 401 is returned when the event has invalid num of args. 702 * @tc.type: FUNC 703 * @tc.require: issueI4BY0R 704 */ 705 it('HiAppEventJsTest011_2', 0, async function (done) { 706 console.info('HiAppEventJsTest011_2 start'); 707 708 // AppEventInfo not passed in 709 try { 710 hiAppEventV9.write(); 711 } catch (err) { 712 let expectErr = createError3("info") 713 assertErrorEqual(err, expectErr) 714 console.info('HiAppEventJsTest011_2 end'); 715 } 716 done(); 717 }); 718 719 /** 720 * @tc.number HiAppEventJsTest011_3 721 * @tc.name: HiAppEventJsTest011_3 722 * @tc.desc: Error code 401 is returned when the event has invalid num of args. 723 * @tc.type: FUNC 724 * @tc.require: issueI4BY0R 725 */ 726 it('HiAppEventJsTest011_3', 0, async function (done) { 727 console.info('HiAppEventJsTest011_3 start'); 728 729 // event domain not passed in 730 try { 731 hiAppEventV9.write({ 732 name: TEST_NAME, 733 eventType: TEST_TYPE_V9, 734 params: TEST_PARAMS, 735 }); 736 } catch (err) { 737 let expectErr = createError3("domain") 738 assertErrorEqual(err, expectErr) 739 console.info('HiAppEventJsTest011_3 end'); 740 } 741 done(); 742 }); 743 744 /** 745 * @tc.number HiAppEventJsTest011_4 746 * @tc.name: HiAppEventJsTest011_4 747 * @tc.desc: Error code 401 is returned when the event has invalid num of args. 748 * @tc.type: FUNC 749 * @tc.require: issueI4BY0R 750 */ 751 it('HiAppEventJsTest011_4', 0, async function (done) { 752 console.info('HiAppEventJsTest011_4 start'); 753 754 // event name not passed in 755 try { 756 hiAppEventV9.write({ 757 domain: TEST_DOMAIN, 758 eventType: TEST_TYPE_V9, 759 params: TEST_PARAMS, 760 }); 761 } catch (err) { 762 let expectErr = createError3("name") 763 assertErrorEqual(err, expectErr) 764 console.info('HiAppEventJsTest011_4 end'); 765 } 766 done(); 767 }); 768 769 /** 770 * @tc.number HiAppEventJsTest011_5 771 * @tc.name: HiAppEventJsTest011_5 772 * @tc.desc: Error code 401 is returned when the event has invalid num of args. 773 * @tc.type: FUNC 774 * @tc.require: issueI4BY0R 775 */ 776 it('HiAppEventJsTest011_5', 0, async function (done) { 777 console.info('HiAppEventJsTest011_5 start'); 778 779 // event type not passed in 780 try { 781 hiAppEventV9.write({ 782 domain: TEST_DOMAIN, 783 name: TEST_NAME, 784 params: TEST_PARAMS, 785 }); 786 } catch (err) { 787 let expectErr = createError3("eventType") 788 assertErrorEqual(err, expectErr) 789 console.info('HiAppEventJsTest011_5 end'); 790 } 791 done(); 792 }); 793 794 /** 795 * @tc.number HiAppEventJsTest011_6 796 * @tc.name: HiAppEventJsTest011_6 797 * @tc.desc: Error code 401 is returned when the event has invalid num of args. 798 * @tc.type: FUNC 799 * @tc.require: issueI4BY0R 800 */ 801 it('HiAppEventJsTest011_6', 0, async function (done) { 802 console.info('HiAppEventJsTest011_6 start'); 803 804 // event params not passed in 805 try { 806 hiAppEventV9.write({ 807 domain: TEST_DOMAIN, 808 name: TEST_NAME, 809 eventType: TEST_TYPE_V9, 810 }); 811 } catch (err) { 812 let expectErr = createError3("params") 813 assertErrorEqual(err, expectErr) 814 console.info('HiAppEventJsTest011_6 end'); 815 } 816 done(); 817 }); 818 819 /** 820 * @tc.number HiAppEventJsTest012 821 * @tc.name: HiAppEventJsTest012 822 * @tc.desc: Test event domain. 823 * @tc.type: FUNC 824 * @tc.require: issueI4BY0R 825 */ 826 it('HiAppEventJsTest012', 0, async function (done) { 827 console.info('HiAppEventJsTest012 start'); 828 829 const MAX_LEN_OF_DOMAIN = 32; 830 // Error code 11101001 is returned when the event has invalid event domain. 831 let expectErr = createError(11101001, "Invalid event domain."); 832 writeDomainV9Test("domain***", expectErr, done); 833 writeDomainV9Test("123domain", expectErr, done); 834 writeDomainV9Test("_domain", expectErr, done); 835 writeDomainV9Test("domain_", expectErr, done); 836 writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN - 1) + "_", expectErr, done); 837 writeDomainV9Test("", expectErr, done); 838 writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN + 1), expectErr, done); 839 840 // valid event domain. 841 writeDomainV9Test("a", null, done); 842 writeDomainV9Test("a1", null, done); 843 writeDomainV9Test("domainTest", null, done); 844 writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN), null, done); 845 }); 846 847 /** 848 * @tc.number HiAppEventJsTest013 849 * @tc.name: HiAppEventJsTest013 850 * @tc.desc: The number of event params exceeds 32 and invalid params exist. 851 * @tc.type: FUNC 852 * @tc.require: issueI8GWHC 853 */ 854 it('HiAppEventJsTest013', 0, async function (done) { 855 console.info('HiAppEventJsTest013 start'); 856 let params = {}; 857 for (var i = 1; i <= 33; i++) { 858 params["key" + i] = "value" + i; 859 } 860 let invalidKey = 'a'.repeat(17); 861 params[invalidKey] = 'value_invalid'; 862 let expectErr = createError(11101003, "Invalid number of event parameters."); 863 writeParamsV9Test(params, expectErr, done); 864 }); 865 866 /** 867 * @tc.number HiAppEventJsTest014 868 * @tc.name: HiAppEventJsTest014 869 * @tc.desc: The number of event params exceeds 32 and invalid params exist. 870 * @tc.type: FUNC 871 * @tc.require: issueI8GWHC 872 */ 873 it('HiAppEventJsTest014', 0, async function (done) { 874 console.info('HiAppEventJsTest014 start'); 875 let params = {}; 876 params["123xxx"] = "value_invalid"; // invalid param name 877 params["xxx_"] = "value_invalid"; // invalid param name 878 for (var i = 1; i <= 33; i++) { 879 params["key" + i] = "value" + i; 880 } 881 params['a'.repeat(33)] = 'value_invalid'; // invalid param name 882 let expectErr = createError(11101003, "Invalid number of event parameters."); 883 writeParamsV9Test(params, expectErr, done); 884 }); 885 886 /** 887 * @tc.number HiAppEventJsPresetTest001_1 888 * @tc.name: HiAppEventJsPresetTest001_1 889 * @tc.desc: Test preset events and preset parameters. 890 * @tc.type: FUNC 891 * @tc.require: issueI4BY0R 892 */ 893 it('HiAppEventJsPresetTest001_1', 0, async function (done) { 894 console.info('HiAppEventJsPresetTest001_1 start'); 895 writeTest(hiAppEvent.Event.USER_LOGIN, hiAppEvent.EventType.FAULT, { 896 [hiAppEvent.Param.USER_ID]: "123456" 897 }, 0, done); 898 }); 899 900 /** 901 * @tc.number HiAppEventJsPresetTest001_2 902 * @tc.name: HiAppEventJsPresetTest001_2 903 * @tc.desc: Test preset events and preset parameters. 904 * @tc.type: FUNC 905 * @tc.require: issueI4BY0R 906 */ 907 it('HiAppEventJsPresetTest001_2', 0, async function (done) { 908 console.info('HiAppEventJsPresetTest001_2 start'); 909 writeTest(hiAppEvent.Event.USER_LOGOUT, hiAppEvent.EventType.STATISTIC, { 910 [hiAppEvent.Param.USER_ID]: "123456" 911 }, 0, done); 912 }); 913 914 /** 915 * @tc.number HiAppEventJsPresetTest001_3 916 * @tc.name: HiAppEventJsPresetTest001_3 917 * @tc.desc: Test preset events and preset parameters. 918 * @tc.type: FUNC 919 * @tc.require: issueI4BY0R 920 */ 921 it('HiAppEventJsPresetTest001_3', 0, async function (done) { 922 console.info('HiAppEventJsPresetTest001_3 start'); 923 let eventInfo = { 924 domain: TEST_DOMAIN, 925 name: hiAppEventV9.event.DISTRIBUTED_SERVICE_START, 926 eventType: hiAppEventV9.EventType.SECURITY, 927 params: { 928 [hiAppEventV9.param.DISTRIBUTED_SERVICE_NAME]: "test_service", 929 [hiAppEventV9.param.DISTRIBUTED_SERVICE_INSTANCE_ID]: "123", 930 }, 931 }; 932 writeV9Test(eventInfo, null, done); 933 }); 934 935 /** 936 * @tc.number HiAppEventConfigureTest001_1 937 * @tc.name: HiAppEventConfigureTest001_1 938 * @tc.desc: Error code -99 is returned when the logging function is disabled. 939 * @tc.type: FUNC 940 * @tc.require: issueI4BY0R 941 */ 942 it('HiAppEventConfigureTest001_1', 0, async function (done) { 943 console.info('HiAppEventConfigureTest001_1 start'); 944 let res = hiAppEvent.configure({ 945 disable: true 946 }); 947 expect(res).assertTrue(); 948 949 writeNameTest("config_test", -99, done); 950 }); 951 952 /** 953 * @tc.number HiAppEventConfigureTest001_2 954 * @tc.name: HiAppEventConfigureTest001_2 955 * @tc.desc: Error code 11100001 is returned when the logging function is disabled. 956 * @tc.type: FUNC 957 * @tc.require: issueI4BY0R 958 */ 959 it('HiAppEventConfigureTest001_2', 0, async function (done) { 960 console.info('HiAppEventConfigureTest001_2 start'); 961 hiAppEventV9.configure({ 962 disable: true 963 }); 964 965 let expectErr = createError(11100001, "Function disabled."); 966 writeNameV9Test("config_test", expectErr, done); 967 }); 968 969 /** 970 * @tc.number HiAppEventConfigureTest002 971 * @tc.name: HiAppEventConfigureTest002 972 * @tc.desc: Correctly configure the event logging function. 973 * @tc.type: FUNC 974 * @tc.require: issueI4BY0R 975 */ 976 it('HiAppEventConfigureTest002', 0, function () { 977 console.info('HiAppEventConfigureTest002 start'); 978 let result = false; 979 result = hiAppEvent.configure({ 980 disable: false, 981 maxStorage: "10G" 982 }); 983 expect(result).assertTrue() 984 985 try { 986 hiAppEventV9.configure({ 987 disable: true, 988 maxStorage: "100m" 989 }); 990 hiAppEventV9.configure({ 991 disable: false, 992 maxStorage: "10M" 993 }); 994 } catch (err) { 995 expect().assertFail(); 996 } 997 998 console.info('HiAppEventConfigureTest002 end'); 999 }); 1000 1001 /** 1002 * @tc.number HiAppEventConfigureTest003 1003 * @tc.name: HiAppEventConfigureTest003 1004 * @tc.desc: Incorrectly configure the event logging function. 1005 * @tc.type: FUNC 1006 * @tc.require: issueI4BY0R 1007 */ 1008 it('HiAppEventConfigureTest003', 0, function () { 1009 console.info('HiAppEventConfigureTest003 start'); 1010 let result = true; 1011 1012 result = hiAppEvent.configure({ 1013 disable: false, 1014 maxStorage: "xxx" 1015 }) 1016 expect(result).assertFalse() 1017 1018 result = hiAppEvent.configure(null) 1019 expect(result).assertFalse() 1020 1021 result = hiAppEvent.configure({ 1022 disable: null, 1023 maxStorage: {} 1024 }) 1025 expect(result).assertFalse() 1026 1027 // ConfigOption not passed in 1028 try { 1029 hiAppEventV9.configure(); 1030 } catch (err) { 1031 let expectErr = createError3("config") 1032 assertErrorEqual(err, expectErr) 1033 } 1034 1035 // invalid ConfigOption type 1036 function configureTest(configOption, expectErr) { 1037 try { 1038 hiAppEventV9.configure(configOption); 1039 } catch (err) { 1040 assertErrorEqual(err, expectErr) 1041 } 1042 } 1043 let expectErr = createError2("config", "ConfigOption") 1044 configureTest(null, expectErr) 1045 configureTest([], expectErr) 1046 1047 // invalid ConfigOption.disable type 1048 expectErr = createError2("disable", "boolean") 1049 configureTest({ disable: 123 }, expectErr) 1050 1051 // invalid ConfigOption.maxStorage type 1052 expectErr = createError2("maxStorage", "string") 1053 configureTest({ maxStorage: null }, expectErr) 1054 1055 // invalid ConfigOption.maxStorage value 1056 expectErr = createError(11103001, "Invalid max storage quota value.") 1057 configureTest({ maxStorage: "**22" }, expectErr) 1058 1059 console.info('HiAppEventConfigureTest003 end'); 1060 }); 1061 1062 /** 1063 * @tc.number HiAppEventClearTest001 1064 * @tc.name: HiAppEventClearTest001 1065 * @tc.desc: clear the local data. 1066 * @tc.type: FUNC 1067 * @tc.require: issueI5NTOS 1068 */ 1069 it('HiAppEventClearTest001', 0, async function (done) { 1070 console.info('HiAppEventClearTest001 start'); 1071 1072 // 1. clear data 1073 let result = hiAppEventV9.clearData(); 1074 expect(result).assertUndefined(); 1075 1076 // 2. write event after clear data 1077 writeNameV9Test("clear_test", null, done); 1078 }); 1079 1080 /** 1081 * @tc.number HiAppEventWatcherTest001 1082 * @tc.name: HiAppEventWatcherTest001 1083 * @tc.desc: invalid watcher type. 1084 * @tc.type: FUNC 1085 * @tc.require: issueI5LB4N 1086 */ 1087 it('HiAppEventWatcherTest001', 0, function () { 1088 console.info('HiAppEventWatcherTest001 start'); 1089 1090 // watcher not passed in 1091 let expectErr = createError3("watcher") 1092 try { 1093 hiAppEventV9.addWatcher(); 1094 } catch (err) { 1095 assertErrorEqual(err, expectErr) 1096 } 1097 try { 1098 hiAppEventV9.removeWatcher(); 1099 } catch (err) { 1100 assertErrorEqual(err, expectErr) 1101 } 1102 1103 // invalid watcher type 1104 expectErr = createError2("watcher", "Watcher") 1105 function addWatcherTypeTest(watcher) { 1106 try { 1107 hiAppEventV9.addWatcher(watcher); 1108 } catch (err) { 1109 assertErrorEqual(err, expectErr) 1110 } 1111 } 1112 function removeWatcherTypeTest(watcher) { 1113 try { 1114 hiAppEventV9.removeWatcher(watcher); 1115 } catch (err) { 1116 assertErrorEqual(err, expectErr) 1117 } 1118 } 1119 addWatcherTypeTest(null); 1120 addWatcherTypeTest(123); 1121 removeWatcherTypeTest(null); 1122 removeWatcherTypeTest(123); 1123 1124 console.info('HiAppEventWatcherTest001 end'); 1125 }); 1126 1127 /** 1128 * @tc.number HiAppEventWatcherTest002 1129 * @tc.name: HiAppEventWatcherTest002 1130 * @tc.desc: invalid watcher name. 1131 * @tc.type: FUNC 1132 * @tc.require: issueI5LB4N 1133 */ 1134 it('HiAppEventWatcherTest002', 0, function () { 1135 console.info('HiAppEventWatcherTest002 start'); 1136 1137 // watcher name not passed in 1138 try { 1139 hiAppEventV9.addWatcher({}); 1140 } catch (err) { 1141 let expectErr = createError3("name") 1142 assertErrorEqual(err, expectErr) 1143 } 1144 1145 // invalid watcher name type 1146 function watcherNameTest(name, expectErr) { 1147 try { 1148 hiAppEventV9.addWatcher({ 1149 name: name 1150 }); 1151 } catch (err) { 1152 assertErrorEqual(err, expectErr) 1153 } 1154 } 1155 let expectErr = createError2("name", "string"); 1156 watcherNameTest(null, expectErr); 1157 watcherNameTest(true, expectErr); 1158 watcherNameTest(123, expectErr); 1159 1160 const MAX_LEN_OF_WATCHER = 32; 1161 // invalid watcher name value 1162 expectErr = createError(11102001, "Invalid watcher name.") 1163 watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER + 1), expectErr); 1164 watcherNameTest("", expectErr); 1165 watcherNameTest("watcher_***", expectErr); 1166 watcherNameTest("Watcher_test", null); 1167 watcherNameTest("_watcher_test", expectErr); 1168 watcherNameTest("watcher_", expectErr); 1169 watcherNameTest("123watcher", expectErr); 1170 watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER - 1) + "_", expectErr); 1171 watcherNameTest("a", null); 1172 watcherNameTest("a1", null); 1173 watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER), null); 1174 1175 console.info('HiAppEventWatcherTest002 end'); 1176 }); 1177 1178 /** 1179 * @tc.number HiAppEventWatcherTest003 1180 * @tc.name: HiAppEventWatcherTest003 1181 * @tc.desc: invalid watcher trigger condition. 1182 * @tc.type: FUNC 1183 * @tc.require: issueI5LB4N 1184 */ 1185 it('HiAppEventWatcherTest003', 0, function () { 1186 console.info('HiAppEventWatcherTest003 start'); 1187 1188 // invalid triggerCondition type 1189 function triggerConditionTest(condition, expectErr) { 1190 try { 1191 hiAppEventV9.addWatcher({ 1192 name: "watcher", 1193 triggerCondition: condition 1194 }); 1195 } catch (err) { 1196 assertErrorEqual(err, expectErr) 1197 } 1198 } 1199 let expectErr = createError2("triggerCondition", "TriggerCondition") 1200 triggerConditionTest(null, expectErr); 1201 triggerConditionTest(123, expectErr); 1202 1203 // invalid triggerCondition.row type 1204 function rowTest(row, expectErr) { 1205 triggerConditionTest({ row: row }, expectErr); 1206 } 1207 expectErr = createError2("row", "number") 1208 rowTest(null, expectErr) 1209 rowTest("str", expectErr) 1210 1211 // invalid triggerCondition.row value 1212 expectErr = createError(11102003, "Invalid row value.") 1213 rowTest(-1, expectErr) 1214 rowTest(-100, expectErr) 1215 1216 // invalid triggerCondition.size type 1217 function sizeTest(size, expectErr) { 1218 triggerConditionTest({ size: size }, expectErr); 1219 } 1220 expectErr = createError2("size", "number") 1221 sizeTest(null, expectErr) 1222 sizeTest(true, expectErr) 1223 1224 // invalid triggerCondition.size value 1225 expectErr = createError(11102004, "Invalid size value.") 1226 sizeTest(-1, expectErr) 1227 sizeTest(-100, expectErr) 1228 1229 // invalid triggerCondition.timeout type 1230 function timeoutTest(timeout) { 1231 triggerConditionTest({ timeout: timeout }, expectErr); 1232 } 1233 expectErr = createError2("timeout", "number") 1234 timeoutTest(null, expectErr) 1235 timeoutTest({}, expectErr) 1236 1237 // invalid triggerCondition.timeout value 1238 expectErr = createError(11102005, "Invalid timeout value.") 1239 timeoutTest(-1, expectErr) 1240 timeoutTest(-100, expectErr) 1241 1242 console.info('HiAppEventWatcherTest003 end'); 1243 }); 1244 1245 /** 1246 * @tc.number HiAppEventWatcherTest004 1247 * @tc.name: HiAppEventWatcherTest004 1248 * @tc.desc: invalid watcher filters. 1249 * @tc.type: FUNC 1250 * @tc.require: issueI5LB4N 1251 */ 1252 it('HiAppEventWatcherTest004', 0, function () { 1253 console.info('HiAppEventWatcherTest004 start'); 1254 1255 // invalid appEventFilters type 1256 function appEventFiltersTest(filters, expectErr) { 1257 try { 1258 hiAppEventV9.addWatcher({ 1259 name: "watcher", 1260 appEventFilters: filters 1261 }); 1262 } catch (err) { 1263 assertErrorEqual(err, expectErr) 1264 } 1265 } 1266 let expectErr = createError2("appEventFilters", "AppEventFilter[]") 1267 appEventFiltersTest(null, expectErr) 1268 appEventFiltersTest({}, expectErr) 1269 appEventFiltersTest("invalid", expectErr) 1270 appEventFiltersTest([1, 2], expectErr) 1271 appEventFiltersTest(["str1", "str2"], expectErr) 1272 1273 // appEventFilter.domain not passed in 1274 function appEventFilterTest(filter, expectErr) { 1275 appEventFiltersTest([filter], expectErr) 1276 } 1277 expectErr = createError3("domain") 1278 appEventFilterTest({}, expectErr) 1279 1280 // invalid appEventFilter.domain type 1281 function domainTest(domain, expectErr) { 1282 appEventFilterTest({ domain: domain }, expectErr) 1283 } 1284 expectErr = createError2("domain", "string") 1285 domainTest(null, expectErr) 1286 domainTest(123, expectErr) 1287 1288 // invalid appEventFilter.domain value 1289 expectErr = createError(11102002, "Invalid filtering event domain.") 1290 domainTest("**xx", expectErr) 1291 domainTest("123test", expectErr) 1292 domainTest("test_", expectErr) 1293 domainTest("a".repeat(33), expectErr) 1294 domainTest("", expectErr) 1295 domainTest("a", null) 1296 domainTest("a1", null) 1297 domainTest("Domain_1", null) 1298 1299 // invalid appEventFilter.eventTypes type 1300 function eventTypesTest(eventTypes, expectErr) { 1301 appEventFilterTest({ 1302 domain: "test_domain", 1303 eventTypes: eventTypes 1304 }, expectErr) 1305 } 1306 expectErr = createError2("eventTypes", "EventType[]") 1307 eventTypesTest(null, expectErr) 1308 eventTypesTest("invalid", expectErr) 1309 eventTypesTest(["invalid"], expectErr) 1310 eventTypesTest([10, -1], expectErr) 1311 1312 console.info('HiAppEventWatcherTest004 end'); 1313 }); 1314 1315 /** 1316 * @tc.number HiAppEventWatcherTest005 1317 * @tc.name: HiAppEventWatcherTest005 1318 * @tc.desc: invalid watcher onTrigger. 1319 * @tc.type: FUNC 1320 * @tc.require: issueI5LB4N 1321 */ 1322 it('HiAppEventWatcherTest005', 0, function () { 1323 console.info('HiAppEventWatcherTest005 start'); 1324 1325 function onTriggerTest(onTrigger, expectErr) { 1326 try { 1327 hiAppEventV9.addWatcher({ 1328 name: "watcher", 1329 onTrigger: onTrigger 1330 }); 1331 } catch (err) { 1332 assertErrorEqual(err, expectErr) 1333 } 1334 } 1335 let expectErr = createError2("onTrigger", "function") 1336 onTriggerTest(null, expectErr) 1337 onTriggerTest("invalid", expectErr) 1338 1339 console.info('HiAppEventWatcherTest005 end'); 1340 }); 1341 1342 /** 1343 * @tc.number HiAppEventWatcherTest006 1344 * @tc.name: HiAppEventWatcherTest006 1345 * @tc.desc: add valid watcher. 1346 * @tc.type: FUNC 1347 * @tc.require: issueI5LB4N 1348 */ 1349 it('HiAppEventWatcherTest006', 0, function () { 1350 console.info('HiAppEventWatcherTest006 start'); 1351 let result = true; 1352 let watcher1 = { 1353 name: "watcher1", 1354 }; 1355 result = hiAppEventV9.addWatcher(watcher1); 1356 expect(result != null).assertTrue() 1357 1358 let watcher2 = { 1359 name: "watcher2", 1360 triggerCondition: {} 1361 }; 1362 result = hiAppEventV9.addWatcher(watcher2); 1363 expect(result != null).assertTrue() 1364 1365 let watcher3 = { 1366 name: "watcher3", 1367 triggerCondition: { 1368 row: 5 1369 }, 1370 onTrigger: simpleTrigger 1371 }; 1372 result = hiAppEventV9.addWatcher(watcher3); 1373 expect(result != null).assertTrue() 1374 1375 let watcher4 = { 1376 name: "watcher4", 1377 triggerCondition: { 1378 size: 1000 1379 }, 1380 onTrigger: simpleTrigger 1381 }; 1382 result = hiAppEventV9.addWatcher(watcher4); 1383 expect(result != null).assertTrue() 1384 1385 let watcher5 = { 1386 name: "watcher5", 1387 triggerCondition: { 1388 timeOut: 2 1389 }, 1390 onTrigger: simpleTrigger 1391 }; 1392 result = hiAppEventV9.addWatcher(watcher5); 1393 expect(result != null).assertTrue() 1394 1395 let watcher6 = { 1396 name: "watcher6", 1397 triggerCondition: { 1398 row: 5, 1399 size: 1000, 1400 timeOut: 2 1401 }, 1402 onTrigger: simpleTrigger 1403 }; 1404 result = hiAppEventV9.addWatcher(watcher6); 1405 expect(result != null).assertTrue() 1406 1407 let watcher7 = { 1408 name: "watcher7", 1409 appEventFilters: [] 1410 }; 1411 result = hiAppEventV9.addWatcher(watcher7); 1412 expect(result != null).assertTrue() 1413 1414 let watcher8 = { 1415 name: "watcher8", 1416 appEventFilters: [ 1417 {domain: "domain_test", eventTypes: []}, 1418 {domain: "default", eventTypes: [hiAppEventV9.EventType.FAULT, hiAppEventV9.EventType.BEHAVIOR]}, 1419 ] 1420 }; 1421 result = hiAppEventV9.addWatcher(watcher8); 1422 expect(result != null).assertTrue() 1423 1424 hiAppEventV9.removeWatcher(watcher1); 1425 hiAppEventV9.removeWatcher(watcher2); 1426 hiAppEventV9.removeWatcher(watcher3); 1427 hiAppEventV9.removeWatcher(watcher4); 1428 hiAppEventV9.removeWatcher(watcher5); 1429 hiAppEventV9.removeWatcher(watcher6); 1430 hiAppEventV9.removeWatcher(watcher7); 1431 hiAppEventV9.removeWatcher(watcher8); 1432 console.info('HiAppEventWatcherTest006 end'); 1433 }); 1434 1435 /** 1436 * @tc.number HiAppEventWatcherTest007 1437 * @tc.name: HiAppEventWatcherTest007 1438 * @tc.desc: watcher.onTrigger row test. 1439 * @tc.type: FUNC 1440 * @tc.require: issueI5KYYI 1441 */ 1442 it('HiAppEventWatcherTest007', 0, async function (done) { 1443 console.info('HiAppEventWatcherTest007 start'); 1444 let watcher = { 1445 name: "watcher_007", 1446 appEventFilters: [ 1447 { domain: TEST_DOMAIN }, 1448 ], 1449 triggerCondition: { 1450 row: 1 1451 }, 1452 onTrigger: function (curRow, curSize, holder) { 1453 console.info('HiAppEventWatcherTest007.onTrigger start'); 1454 expect(curRow).assertEqual(1) 1455 expect(curSize > 0).assertTrue() 1456 expect(holder != null).assertTrue() 1457 1458 let eventPkg = holder.takeNext(); 1459 expect(eventPkg != null).assertTrue() 1460 expect(eventPkg.packageId).assertEqual(0) 1461 expect(eventPkg.row).assertEqual(1) 1462 expect(eventPkg.size > 0).assertTrue() 1463 expect(eventPkg.data.length).assertEqual(1) 1464 expect(eventPkg.data[0].length > 0).assertTrue() 1465 console.info('HiAppEventWatcherTest007.onTrigger end'); 1466 } 1467 }; 1468 let result = hiAppEventV9.addWatcher(watcher); 1469 expect(result != null).assertTrue() 1470 1471 simpleWriteV9Test(); 1472 1473 setTimeout(() => { 1474 hiAppEventV9.removeWatcher(watcher); 1475 console.info('HiAppEventWatcherTest007 end'); 1476 done(); 1477 }, 1000); 1478 }); 1479 1480 /** 1481 * @tc.number HiAppEventWatcherTest008 1482 * @tc.name: HiAppEventWatcherTest008 1483 * @tc.desc: watcher.onTrigger size test. 1484 * @tc.type: FUNC 1485 * @tc.require: issueI5KYYI 1486 */ 1487 it('HiAppEventWatcherTest008', 0, async function (done) { 1488 console.info('HiAppEventWatcherTest008 start'); 1489 let watcher = { 1490 name: "watcher_008", 1491 appEventFilters: [ 1492 { domain: TEST_DOMAIN }, 1493 ], 1494 triggerCondition: { 1495 row: 10, 1496 size: 200, 1497 }, 1498 onTrigger: function (curRow, curSize, holder) { 1499 console.info('HiAppEventWatcherTest008.onTrigger start'); 1500 expect(curRow).assertEqual(2) 1501 expect(curSize >= 200).assertTrue() 1502 expect(holder != null).assertTrue() 1503 1504 holder.setSize(curSize); 1505 let eventPkg = holder.takeNext(); 1506 expect(eventPkg != null).assertTrue() 1507 expect(eventPkg.packageId).assertEqual(0) 1508 expect(eventPkg.row).assertEqual(2) 1509 expect(eventPkg.size >= 200).assertTrue() 1510 expect(eventPkg.data.length).assertEqual(2) 1511 expect(eventPkg.data[0].length > 0).assertTrue() 1512 expect(eventPkg.data[1].length > 0).assertTrue() 1513 console.info('HiAppEventWatcherTest008.onTrigger end'); 1514 } 1515 }; 1516 let result = hiAppEventV9.addWatcher(watcher); 1517 expect(result != null).assertTrue() 1518 1519 simpleWriteV9Test(); 1520 simpleWriteV9Test(); 1521 1522 setTimeout(() => { 1523 hiAppEventV9.removeWatcher(watcher); 1524 console.info('HiAppEventWatcherTest008 end'); 1525 done(); 1526 }, 1000); 1527 }); 1528 1529 /** 1530 * @tc.number HiAppEventWatcherTest009 1531 * @tc.name: HiAppEventWatcherTest009 1532 * @tc.desc: watcher.onTrigger timeout test. 1533 * @tc.type: FUNC 1534 * @tc.require: issueI5KYYI 1535 */ 1536 it('HiAppEventWatcherTest009', 0, async function (done) { 1537 console.info('HiAppEventWatcherTest009 start'); 1538 let watcher = { 1539 name: "watcher", 1540 triggerCondition: { 1541 timeOut: 1 1542 }, 1543 onTrigger: function (curRow, curSize, holder) { 1544 console.info('HiAppEventWatcherTest009.onTrigger start'); 1545 expect(curRow).assertEqual(1) 1546 expect(curSize > 0).assertTrue() 1547 expect(holder != null).assertTrue() 1548 1549 let eventPkg = holder.takeNext(); 1550 expect(eventPkg != null).assertTrue() 1551 expect(eventPkg.packageId).assertEqual(0) 1552 expect(eventPkg.row).assertEqual(1) 1553 expect(eventPkg.size > 0).assertTrue() 1554 expect(eventPkg.data.length).assertEqual(1) 1555 expect(eventPkg.data[0].length > 0).assertTrue() 1556 console.info('HiAppEventWatcherTest009.onTrigger end'); 1557 } 1558 }; 1559 let result = hiAppEventV9.addWatcher(watcher); 1560 expect(result != null).assertTrue() 1561 1562 simpleWriteV9Test(); 1563 1564 setTimeout(() => { 1565 hiAppEventV9.removeWatcher(watcher); 1566 console.info('HiAppEventWatcherTest009 end'); 1567 done(); 1568 }, 3000); 1569 }); 1570 1571 /** 1572 * @tc.number HiAppEventWatcherTest010 1573 * @tc.name: HiAppEventWatcherTest010 1574 * @tc.desc: watcher.holder test. 1575 * @tc.type: FUNC 1576 * @tc.require: issueI5NTOD 1577 */ 1578 it('HiAppEventWatcherTest010', 0, async function (done) { 1579 console.info('HiAppEventWatcherTest010 start'); 1580 let watcher = { 1581 name: "watcher", 1582 }; 1583 let holder = hiAppEventV9.addWatcher(watcher); 1584 expect(holder != null).assertTrue() 1585 1586 simpleWriteV9Test(); 1587 1588 setTimeout(() => { 1589 let eventPkg = holder.takeNext(); 1590 expect(eventPkg != null).assertTrue(); 1591 expect(eventPkg.packageId).assertEqual(0); 1592 expect(eventPkg.row).assertEqual(1); 1593 expect(eventPkg.size > 0).assertTrue(); 1594 expect(eventPkg.data.length).assertEqual(1); 1595 expect(eventPkg.data[0].length > 0).assertTrue(); 1596 hiAppEventV9.removeWatcher(watcher); 1597 console.info('HiAppEventWatcherTest010 end'); 1598 done(); 1599 }, 1000); 1600 }); 1601 1602 /** 1603 * @tc.number HiAppEventWatcherTest011 1604 * @tc.name: HiAppEventWatcherTest011 1605 * @tc.desc: invalid watcher.holder test. 1606 * @tc.type: FUNC 1607 * @tc.require: issueI5NTOD 1608 */ 1609 it('HiAppEventWatcherTest011', 0, function () { 1610 console.info('HiAppEventWatcherTest011 start'); 1611 let watcher = { 1612 name: "watcher", 1613 }; 1614 let holder = hiAppEventV9.addWatcher(watcher); 1615 expect(holder != null).assertTrue() 1616 1617 // size not passed in 1618 try { 1619 holder.setSize() 1620 } catch (err) { 1621 let expectErr = createError3("size"); 1622 assertErrorEqual(err, expectErr) 1623 } 1624 1625 // invalid size type 1626 function holderSetSizeTest(holder, size, expectErr) { 1627 try { 1628 holder.setSize(size) 1629 } catch (err) { 1630 assertErrorEqual(err, expectErr) 1631 } 1632 } 1633 let expectErr = createError2("size", "number"); 1634 holderSetSizeTest(holder, null, expectErr); 1635 holderSetSizeTest(holder, {}, expectErr); 1636 1637 // invalid size value 1638 expectErr = createError(11104001, "Invalid size value."); 1639 holderSetSizeTest(holder, -1, expectErr); 1640 holderSetSizeTest(holder, -100, expectErr); 1641 1642 hiAppEventV9.removeWatcher(watcher) 1643 console.info('HiAppEventWatcherTest011 end') 1644 }); 1645 1646 /** 1647 * @tc.number HiAppEventWatcherTest012 1648 * @tc.name: HiAppEventWatcherTest012 1649 * @tc.desc: watcher.holder constructor test. 1650 * @tc.type: FUNC 1651 * @tc.require: issueI5KYYI 1652 */ 1653 it('HiAppEventWatcherTest012', 0, async function (done) { 1654 console.info('HiAppEventWatcherTest012 start'); 1655 let watcher = { 1656 name: "watcher", 1657 }; 1658 hiAppEventV9.addWatcher(watcher); 1659 1660 let params = { 1661 "key_int": 100, 1662 "key_string": "strValue", 1663 "key_bool": true, 1664 "key_float": 30949.374, 1665 "key_int_arr": [1, 2, 3], 1666 "key_string_arr": ["a", "b", "c"], 1667 "key_float_arr": [1.1, 2.2, 3.0], 1668 "key_bool_arr": [true, false, true] 1669 }; 1670 hiAppEventV9.write({ 1671 domain: "test_domain", 1672 name: "test_name", 1673 eventType: hiAppEventV9.EventType.FAULT, 1674 params: params 1675 }, (err) => { 1676 expect(err).assertNull(); 1677 1678 let holder = new hiAppEventV9.AppEventPackageHolder("watcher"); 1679 let eventPkg = holder.takeNext(); 1680 expect(eventPkg != null).assertTrue(); 1681 expect(eventPkg.data.length == 1).assertTrue(); 1682 let paramJsonStr = JSON.stringify(params);; 1683 expect(eventPkg.data[0].includes(paramJsonStr.substr(1, paramJsonStr.length - 2))).assertTrue(); 1684 hiAppEventV9.removeWatcher(watcher); 1685 console.info('HiAppEventWatcherTest012 end'); 1686 done(); 1687 }); 1688 }); 1689 1690 /** 1691 * @tc.number HiAppEventWatcherTest013 1692 * @tc.name: HiAppEventWatcherTest013 1693 * @tc.desc: watcher.onTrigger test after clear up. 1694 * @tc.type: FUNC 1695 * @tc.require: issueI8H07G 1696 */ 1697 it('HiAppEventWatcherTest013', 0, async function (done) { 1698 console.info('HiAppEventWatcherTest013 start'); 1699 let testRow = 5; 1700 let watcher = { 1701 name: "watcher", 1702 triggerCondition: { 1703 row: testRow 1704 }, 1705 onTrigger: function (curRow, curSize, holder) { 1706 console.info('HiAppEventWatcherTest013.onTrigger start'); 1707 holder.setRow(testRow); 1708 let eventPkg = holder.takeNext(); 1709 expect(eventPkg.data.length).assertEqual(testRow) 1710 console.info('HiAppEventWatcherTest013.onTrigger end'); 1711 } 1712 }; 1713 hiAppEventV9.addWatcher(watcher); 1714 1715 setTimeout(() => { 1716 for (var i = 1; i <= 3; i++) { 1717 simpleWriteV9Test(); 1718 } 1719 }, 1000); 1720 1721 setTimeout(() => { 1722 hiAppEventV9.clearData(); 1723 }, 2000); 1724 1725 setTimeout(() => { 1726 for (var i = 1; i <= testRow; i++) { 1727 simpleWriteV9Test(); 1728 } 1729 }, 3000); 1730 1731 setTimeout(() => { 1732 hiAppEventV9.removeWatcher(watcher); 1733 console.info('HiAppEventWatcherTest013 end'); 1734 done(); 1735 }, 4000); 1736 }); 1737 1738 function simpleReceive(domain, eventArray) { 1739 console.info('HiAppEventWatcherTest.onReceive start domain=' + domain + ', event size=' + 1740 eventArray.length); 1741 for (var key in eventArray) { 1742 console.info('HiAppEventWatcherTest event_name=' + eventArray[key]['name'] + ', size=' + 1743 eventArray[key]['appEventInfos'].length); 1744 } 1745 console.info('HiAppEventWatcherTest.onReceive end'); 1746 } 1747 1748 /** 1749 * @tc.number HiAppEventWatcherTest014 1750 * @tc.name: HiAppEventWatcherTest014 1751 * @tc.desc: watcher.onReceive test. 1752 * @tc.type: FUNC 1753 * @tc.require: issueI5KYYI 1754 */ 1755 it('HiAppEventWatcherTest014', 0, async function (done) { 1756 console.info('HiAppEventWatcherTest014 start'); 1757 let watcher = { 1758 name: "watcheros1", 1759 appEventFilters: [ 1760 { 1761 domain: hiAppEventV9.domain.OS, 1762 names: [ 1763 hiAppEventV9.event.APP_CRASH, 1764 hiAppEventV9.event.APP_FREEZE, 1765 "APP_START", 1766 hiAppEventV9.event.APP_LAUNCH, 1767 hiAppEventV9.event.SCROLL_JANK, 1768 hiAppEventV9.event.CPU_USAGE_HIGH, 1769 hiAppEventV9.event.BATTERY_USAGE, 1770 hiAppEventV9.event.RESOURCE_OVERLIMIT, 1771 hiAppEventV9.event.ADDRESS_SANITIZER 1772 ] 1773 }, 1774 ], 1775 onReceive: simpleReceive 1776 }; 1777 let result = hiAppEventV9.addWatcher(watcher); 1778 expect(result != null).assertTrue(); 1779 1780 setTimeout(() => { 1781 hiAppEventV9.removeWatcher(watcher); 1782 console.info('HiAppEventWatcherTest014 end'); 1783 done(); 1784 }, 1000); 1785 }); 1786 1787 /** 1788 * @tc.number HiAppEventWatcherTest015 1789 * @tc.name: HiAppEventWatcherTest015 1790 * @tc.desc: watcher.onReceive test. 1791 * @tc.type: FUNC 1792 * @tc.require: issueI5KYYI 1793 */ 1794 it('HiAppEventWatcherTest015', 0, async function (done) { 1795 console.info('HiAppEventWatcherTest015 start'); 1796 let watcher = { 1797 name: "watcher", 1798 appEventFilters: [ 1799 {domain: "test_domain", names: ["test_name"]}, 1800 ], 1801 onReceive: simpleReceive 1802 }; 1803 let result = hiAppEventV9.addWatcher(watcher); 1804 expect(result != null).assertTrue(); 1805 1806 simpleWriteV9Test(); 1807 1808 setTimeout(() => { 1809 hiAppEventV9.removeWatcher(watcher); 1810 console.info('HiAppEventWatcherTest015 end'); 1811 done(); 1812 }, 1000); 1813 }); 1814 1815 /** 1816 * @tc.number HiAppEventWatcherTest016 1817 * @tc.name: HiAppEventWatcherTest016 1818 * @tc.desc: watcher.onReceive test. 1819 * @tc.type: FUNC 1820 * @tc.require: issueI5KYYI 1821 */ 1822 it('HiAppEventWatcherTest016', 0, async function (done) { 1823 console.info('HiAppEventWatcherTest016 start'); 1824 let result = true; 1825 let watcher1 = { 1826 name: "watcheros1", 1827 appEventFilters: [ 1828 { 1829 domain: hiAppEventV9.domain.OS, 1830 names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"] 1831 }, 1832 ], 1833 onReceive: simpleReceive 1834 }; 1835 result = hiAppEventV9.addWatcher(watcher1); 1836 expect(result != null).assertTrue(); 1837 1838 let watcher2 = { 1839 name: "watcheros2", 1840 appEventFilters: [ 1841 { 1842 domain: hiAppEventV9.domain.OS, 1843 names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"] 1844 }, 1845 ], 1846 onReceive: simpleReceive, 1847 onTrigger: simpleTrigger 1848 }; 1849 result = hiAppEventV9.addWatcher(watcher2); 1850 expect(result != null).assertTrue(); 1851 1852 let watcher3 = { 1853 name: "watcheros3", 1854 appEventFilters: [ 1855 { 1856 domain: hiAppEventV9.domain.OS, 1857 names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"] 1858 }, 1859 ], 1860 onTrigger: simpleTrigger 1861 }; 1862 result = hiAppEventV9.addWatcher(watcher3); 1863 expect(result != null).assertTrue(); 1864 1865 setTimeout(() => { 1866 hiAppEventV9.removeWatcher(watcher1); 1867 hiAppEventV9.removeWatcher(watcher2); 1868 hiAppEventV9.removeWatcher(watcher3); 1869 console.info('HiAppEventWatcherTest016 end'); 1870 done(); 1871 }, 1000); 1872 }); 1873 1874 /** 1875 * @tc.number HiAppEventSetEventConfigTest001 1876 * @tc.name: HiAppEventSetEventConfigTest001 1877 * @tc.desc: Test the SetEventConfig interface. 1878 * @tc.type: FUNC 1879 * @tc.require: issueI8U2VO 1880 */ 1881 it('HiAppEventSetEventConfigTest001', 0, async function (done) { 1882 console.info('HiAppEventSetEventConfigTest001 start'); 1883 let configInfo1 = { // default, collect stack and trace 1884 "log_type": "0", 1885 }; 1886 let configInfo2 = { // collect stack 1887 "log_type": "1", 1888 "ignore_startup_time": "10", 1889 "sample_interval": "100", 1890 "sample_count": "21", 1891 "report_times_per_app": "3" 1892 }; 1893 let configInfo3 = { // collect trace 1894 "log_type": "2", 1895 }; 1896 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo1, null, done); 1897 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo2, null, done); 1898 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo3, null, done); 1899 console.info('HiAppEventSetEventConfigTest001 end'); 1900 }); 1901 1902 /** 1903 * @tc.number HiAppEventSetEventConfigTest002 1904 * @tc.name: HiAppEventSetEventConfigTest002 1905 * @tc.desc: Test the SetEventConfig interface with invalid name. 1906 * @tc.type: FUNC 1907 * @tc.require: issueI8U2VO 1908 */ 1909 it('HiAppEventSetEventConfigTest002', 0, async function (done) { 1910 console.info('HiAppEventSetEventConfigTest002 start'); 1911 let configInfo = { 1912 "log_type": "0", 1913 }; 1914 let expectErr1 = createError2("name", "string"); 1915 setEventConfigV9TestCatch(0, configInfo, expectErr1, done); 1916 setEventConfigV9TestCatch(true, configInfo, expectErr1, done); 1917 1918 let expectErr2 = createError(401, "Invalid param value for event config."); 1919 setEventConfigV9Test("", configInfo, expectErr2, done); 1920 setEventConfigV9Test(null, configInfo, expectErr2, done); 1921 setEventConfigV9Test("INVALID_NAME", configInfo, expectErr2, done); 1922 console.info('HiAppEventSetEventConfigTest002 end'); 1923 }); 1924 1925 /** 1926 * @tc.number HiAppEventSetEventConfigTest003 1927 * @tc.name: HiAppEventSetEventConfigTest003 1928 * @tc.desc: Test the SetEventConfig interface with invalid config type. 1929 * @tc.type: FUNC 1930 * @tc.require: issueI8U2VO 1931 */ 1932 it('HiAppEventSetEventConfigTest003', 0, async function (done) { 1933 console.info('HiAppEventSetEventConfigTest003 start'); 1934 let expectErr = createError2("value", "object"); 1935 setEventConfigV9TestCatch("MAIN_THREAD_JANK", 0, expectErr, done); 1936 setEventConfigV9TestCatch("MAIN_THREAD_JANK", "", expectErr, done); 1937 setEventConfigV9TestCatch("MAIN_THREAD_JANK", true, expectErr, done); 1938 setEventConfigV9TestCatch("MAIN_THREAD_JANK", null, expectErr, done); 1939 console.info('HiAppEventSetEventConfigTest003 end'); 1940 }); 1941 1942 /** 1943 * @tc.number HiAppEventSetEventConfigTest004 1944 * @tc.name: HiAppEventSetEventConfigTest004 1945 * @tc.desc: Test the SetEventConfig interface when the config is empty. 1946 * @tc.type: FUNC 1947 * @tc.require: issueI8U2VO 1948 */ 1949 it('HiAppEventSetEventConfigTest004', 0, async function (done) { 1950 console.info('HiAppEventSetEventConfigTest004 start'); 1951 let configInfo = {}; 1952 try { 1953 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo, null, done); 1954 } catch (err) { 1955 expect(err.message == "Cannot read property then of undefined").assertTrue(); 1956 done(); 1957 } 1958 console.info('HiAppEventSetEventConfigTest004 end'); 1959 }); 1960 1961 /** 1962 * @tc.number HiAppEventSetEventConfigTest005 1963 * @tc.name: HiAppEventSetEventConfigTest005 1964 * @tc.desc: Error code 401 is returned when the config log_type is invalid. 1965 * @tc.type: FUNC 1966 * @tc.require: issueI8U2VO 1967 */ 1968 it('HiAppEventSetEventConfigTest005', 0, async function (done) { 1969 console.info('HiAppEventSetEventConfigTest005 start'); 1970 let configInfo1 = { 1971 "log_type": "-1", 1972 }; 1973 let configInfo2 = { 1974 "log_type": "abc", 1975 }; 1976 let configInfo3 = { 1977 "log_type": "", 1978 }; 1979 let configInfo4 = { 1980 "log_type": null, 1981 }; 1982 let expectErr = createError(401, "Invalid param value for event config."); 1983 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo1, expectErr, done); 1984 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo2, expectErr, done); 1985 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo3, expectErr, done); 1986 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo4, expectErr, done); 1987 console.info('HiAppEventSetEventConfigTest005 end'); 1988 }); 1989 1990 /** 1991 * @tc.number HiAppEventSetEventConfigTest006 1992 * @tc.name: HiAppEventSetEventConfigTest006 1993 * @tc.desc: Error code 401 is returned when the config log_type=1, but item number is not 5. 1994 * @tc.type: FUNC 1995 * @tc.require: issueI8U2VO 1996 */ 1997 it('HiAppEventSetEventConfigTest006', 0, async function (done) { 1998 console.info('HiAppEventSetEventConfigTest006 start'); 1999 let configInfo = { 2000 "log_type": "1", 2001 "sample_interval": "100", 2002 "sample_count": "21", 2003 }; 2004 let expectErr = createError(401, "Invalid param value for event config."); 2005 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo, expectErr, done); 2006 console.info('HiAppEventSetEventConfigTest006 end'); 2007 }); 2008 2009 /** 2010 * @tc.number HiAppEventSetEventConfigTest007 2011 * @tc.name: HiAppEventSetEventConfigTest007 2012 * @tc.desc: Error code 401 is returned when the value param item value is invalid. 2013 * @tc.type: FUNC 2014 * @tc.require: issueI8U2VO 2015 */ 2016 it('HiAppEventSetEventConfigTest007', 0, async function (done) { 2017 console.info('HiAppEventSetEventConfigTest007 start'); 2018 let configInfo1 = { 2019 "log_type": "1", 2020 "ignore_startup_time": "10", 2021 "sample_interval": "-1", 2022 "sample_count": "21", 2023 "report_times_per_app": "3" 2024 }; 2025 let configInfo2 = { 2026 "log_type": "1", 2027 "ignore_startup_time": "10", 2028 "sample_interval": "49", 2029 "sample_count": "21", 2030 "report_times_per_app": "3" 2031 }; 2032 let configInfo3 = { 2033 "log_type": "1", 2034 "ignore_startup_time": "10", 2035 "sample_interval": "50", 2036 "sample_count": "21", 2037 "report_times_per_app": "3" 2038 }; 2039 let configInfo4 = { 2040 "log_type": "1", 2041 "ignore_startup_time": "10", 2042 "sample_interval": "92233720368547758079223372036854775807", 2043 "sample_count": "21", 2044 "report_times_per_app": "3" 2045 }; 2046 let configInfo5 = { 2047 "log_type": "1", 2048 "ignore_startup_time": "10", 2049 "sample_interval": "aa", 2050 "sample_count": "21", 2051 "report_times_per_app": "3" 2052 }; 2053 let expectErr = createError(401, "Invalid param value for event config."); 2054 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo1, expectErr, done); 2055 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo2, expectErr, done); 2056 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo3, expectErr, done); 2057 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo4, expectErr, done); 2058 setEventConfigV9Test("MAIN_THREAD_JANK", configInfo5, expectErr, done); 2059 console.info('HiAppEventSetEventConfigTest007 end'); 2060 }); 2061});