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    /**
174     * @tc.number HiAppEventJsTest001_1
175     * @tc.name: HiAppEventJsTest001_1
176     * @tc.desc: Test the write interface using callback.
177     * @tc.type: FUNC
178     * @tc.require: issueI4BY0R
179     */
180    it('HiAppEventJsTest001_1', 0, async function (done) {
181        console.info('HiAppEventJsTest001_1 start');
182        let params = {
183            "key_int": 100,
184            "key_string": "strValue",
185            "key_bool": true,
186            "key_float": 30949.374,
187            "key_int_arr": [1, 2, 3],
188            "key_string_arr": ["a", "b", "c"],
189            "key_float_arr": [1.1, 2.2, 3.0],
190            "key_bool_arr": [true, false, true]
191        };
192        writeParamsTest(params, 0, done);
193    });
194
195    /**
196     * @tc.number HiAppEventJsTest001_2
197     * @tc.name: HiAppEventJsTest001_2
198     * @tc.desc: Test the write interface using callback.
199     * @tc.type: FUNC
200     * @tc.require: issueI4BY0R
201     */
202    it('HiAppEventJsTest001_2', 0, async function (done) {
203        console.info('HiAppEventJsTest001_2 start');
204        let params = {
205            "key_int": 100,
206            "key_string": "strValue",
207            "key_bool": true,
208            "key_float": 30949.374,
209            "key_int_arr": [1, 2, 3],
210            "key_string_arr": ["a", "b", "c"],
211            "key_float_arr": [1.1, 2.2, 3.0],
212            "key_bool_arr": [true, false, true]
213        };
214        writeParamsV9Test(params, null, done);
215    });
216
217    /**
218     * @tc.number HiAppEventJsTest002_1
219     * @tc.name: HiAppEventJsTest002_1
220     * @tc.desc: Test the write interface using promise.
221     * @tc.type: FUNC
222     * @tc.require: issueI4BY0R
223     */
224    it('HiAppEventJsTest002_1', 0, async function (done) {
225        console.info('HiAppEventJsTest002_1 start');
226        hiAppEvent.write(TEST_NAME, TEST_TYPE_V9, TEST_PARAMS).then((value) => {
227            let result = value;
228            expect(result).assertEqual(0);
229            console.info('HiAppEventJsTest002_1 succ');
230            done()
231        }).catch((err) => {
232            expect().assertFail();
233            done()
234        });
235    });
236
237    /**
238     * @tc.number HiAppEventJsTest002_2
239     * @tc.name: HiAppEventJsTest002_2
240     * @tc.desc: Test the write interface using promise.
241     * @tc.type: FUNC
242     * @tc.require: issueI4BY0R
243     */
244    it('HiAppEventJsTest002_2', 0, async function (done) {
245        console.info('HiAppEventJsTest002_2 start');
246        let eventInfo = {
247            domain: TEST_DOMAIN,
248            name: TEST_NAME,
249            eventType: TEST_TYPE_V9,
250            params: TEST_PARAMS
251        };
252        hiAppEventV9.write(eventInfo).then(() => {
253            console.info('HiAppEventJsTest002_2 succ');
254            done();
255        }).catch((err) => {
256            expect().assertFail();
257            done();
258        });
259    });
260
261    /**
262     * @tc.number HiAppEventJsTest003_1
263     * @tc.name: HiAppEventJsTest003_1
264     * @tc.desc: Error code 1 is returned when the event has an invalid key name.
265     * @tc.type: FUNC
266     * @tc.require: issueI4BY0R
267     */
268    it('HiAppEventJsTest003_1', 0, async function (done) {
269        console.info('HiAppEventJsTest003_1 start');
270        let params = {
271            "**":"ha",
272            "key_int":1,
273            "HH22":"ha",
274            "key_str":"str",
275            "":"empty",
276            "aa_":"underscore"
277        };
278        writeParamsTest(params, 1, done);
279    });
280
281    /**
282     * @tc.number HiAppEventJsTest003_2
283     * @tc.name: HiAppEventJsTest003_2
284     * @tc.desc: Error code 11101005 is returned when the event has an invalid key name.
285     * @tc.type: FUNC
286     * @tc.require: issueI4BY0R
287     */
288    it('HiAppEventJsTest003_2', 0, async function (done) {
289        console.info('HiAppEventJsTest003_2 start');
290        let params = {
291            "**":"ha",
292            "key_int":1,
293            "HH22":"ha",
294            "key_str":"str",
295            "":"empty",
296            "aa_":"underscore"
297        };
298        let expectErr = createError(11101005, "Invalid event parameter name.");
299        writeParamsV9Test(params, expectErr, done);
300
301        const MAX_LENGTH_OF_PARAM_NAME = 32;
302        params = {};
303        params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME + 1)] = "value";
304        writeParamsV9Test(params, expectErr, done);
305
306        params = {};
307        params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME - 1) + "_"] = "value";
308        writeParamsV9Test(params, expectErr, done);
309
310        params = {};
311        params['a'.repeat(MAX_LENGTH_OF_PARAM_NAME)] = "value";
312        writeParamsV9Test(params, null, done);
313    });
314
315    /**
316     * @tc.number HiAppEventJsTest004_1
317     * @tc.name: HiAppEventJsTest004_1
318     * @tc.desc: Error code 3 is returned when the event has an invalid value type.
319     * @tc.type: FUNC
320     * @tc.require: issueI4BY0R
321     */
322    it('HiAppEventJsTest004_1', 0, async function (done) {
323        console.info('HiAppEventJsTest004_1 start');
324        let params = {
325            key_1_invalid: {},
326            key_2_invalid: null,
327            key_str: "str"
328        };
329        writeParamsTest(params, 3, done);
330    });
331
332    /**
333     * @tc.number HiAppEventJsTest004_2
334     * @tc.name: HiAppEventJsTest004_2
335     * @tc.desc: Error code 401 is returned when the event has an invalid value type.
336     * @tc.type: FUNC
337     * @tc.require: issueI4BY0R
338     */
339    it('HiAppEventJsTest004_2', 0, async function (done) {
340        console.info('HiAppEventJsTest004_2 start');
341        let params = {
342            key_1_invalid: {},
343            key_2_invalid: null,
344            key_str: "str"
345        };
346        let expectErr = createError2("param value", "boolean|number|string|array[boolean|number|string]");
347        writeParamsV9Test(params, expectErr, done, true);
348    });
349
350    /**
351     * @tc.number HiAppEventJsTest005_1
352     * @tc.name: HiAppEventJsTest005_1
353     * @tc.desc: Error code 4 is returned when the event has an invalid string length.
354     * @tc.type: FUNC
355     * @tc.require: issueI4BY0R
356     */
357    it('HiAppEventJsTest005_1', 0, async function (done) {
358        console.info('HiAppEventJsTest005_1 start');
359        let longStr = "a".repeat(8 * 1024);
360        let invalidStr = "a".repeat(8 * 1024 + 1);
361        let params = {
362            key_long: longStr,
363            key_i_long: invalidStr,
364            key_long_arr: ["ha", longStr],
365            key_i_long_arr: ["ha", invalidStr],
366            key_str: "str"
367        };
368        writeParamsTest(params, 4, done);
369    });
370
371    /**
372     * @tc.number HiAppEventJsTest005_2
373     * @tc.name: HiAppEventJsTest005_2
374     * @tc.desc: Error code 11101004 is returned when the event has an invalid string length.
375     * @tc.type: FUNC
376     * @tc.require: issueI4BY0R
377     */
378    it('HiAppEventJsTest005_2', 0, async function (done) {
379        console.info('HiAppEventJsTest005_2 start');
380        let longStr = "a".repeat(8 * 1024);
381        let invalidStr = "a".repeat(8 * 1024 + 1);
382        let params = {
383            key_long: longStr,
384            key_i_long: invalidStr,
385            key_long_arr: ["ha", longStr],
386            key_i_long_arr: ["ha", invalidStr],
387            key_str: "str"
388        };
389        let expectErr = createError(11101004, "Invalid string length of the event parameter.");
390        writeParamsV9Test(params, expectErr, done);
391    });
392
393    /**
394     * @tc.number HiAppEventJsTest006_1
395     * @tc.name: HiAppEventJsTest006_1
396     * @tc.desc: Error code 5 is returned when the event has too many params.
397     * @tc.type: FUNC
398     * @tc.require: issueI4BY0R
399     */
400    it('HiAppEventJsTest006_1', 0, async function (done) {
401        console.info('HiAppEventJsTest006_1 start');
402        let params = {};
403        for (var i = 1; i <= 33; i++) {
404            params["key" + i] = "value" + i;
405        }
406        writeParamsTest(params, 5, done);
407    });
408
409    /**
410     * @tc.number HiAppEventJsTest006_2
411     * @tc.name: HiAppEventJsTest006_2
412     * @tc.desc: Error code 11101003 is returned when the event has too many params.
413     * @tc.type: FUNC
414     * @tc.require: issueI4BY0R
415     */
416    it('HiAppEventJsTest006_2', 0, async function (done) {
417        console.info('HiAppEventJsTest006_2 start');
418        let params = {};
419        for (var i = 1; i <= 33; i++) {
420            params["key" + i] = "value" + i;
421        }
422        let expectErr = createError(11101003, "Invalid number of event parameters.");
423        writeParamsV9Test(params, expectErr, done);
424    });
425
426    /**
427     * @tc.number HiAppEventJsTest007_1
428     * @tc.name: HiAppEventJsTest007_1
429     * @tc.desc: Error code 6 is returned when there is an array with too many elements.
430     * @tc.type: FUNC
431     * @tc.require: issueI4BY0R
432     */
433    it('HiAppEventJsTest007_1', 0, async function (done) {
434        console.info('HiAppEventJsTest007_1 start');
435        let longArr = new Array(100).fill(1);
436        let iLongArr = new Array(101).fill("a");
437        let params = {
438            key_long_arr: longArr,
439            key_i_long_arr: iLongArr,
440            key_str: "str"
441        };
442        writeParamsTest(params, 6, done);
443    });
444
445    /**
446     * @tc.number HiAppEventJsTest007_2
447     * @tc.name: HiAppEventJsTest007_2
448     * @tc.desc: Error code 11101006 is returned when there is an array with too many elements.
449     * @tc.type: FUNC
450     * @tc.require: issueI4BY0R
451     */
452    it('HiAppEventJsTest007_2', 0, async function (done) {
453        console.info('HiAppEventJsTest007_2 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        let expectErr = createError(11101006, "Invalid array length of the event parameter.");
462        writeParamsV9Test(params, expectErr, done);
463    });
464
465    /**
466     * @tc.number HiAppEventJsTest008_1
467     * @tc.name: HiAppEventJsTest008_1
468     * @tc.desc: Error code 7 is returned when there is an array with inconsistent or illegal parameter types.
469     * @tc.type: FUNC
470     * @tc.require: issueI4BY0R
471     */
472    it('HiAppEventJsTest008_1', 0, async function (done) {
473        console.info('HiAppEventJsTest008_1 start');
474        let params = {
475            key_arr_null: [null, null],
476            key_arr_obj: [{}],
477            key_arr_test1:[true, "ha"],
478            key_arr_test2:[123, "ha"],
479            key_str: "str"
480        };
481        writeParamsTest(params, 7, done);
482    });
483
484    /**
485     * @tc.number HiAppEventJsTest008_2
486     * @tc.name: HiAppEventJsTest008_2
487     * @tc.desc: Error code 401 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_2', 0, async function (done) {
492        console.info('HiAppEventJsTest008_2 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        let expectErr = createError2("param value", "boolean|number|string|array[boolean|number|string]");
501        writeParamsV9Test(params, expectErr, done, true);
502    });
503
504    /**
505     * @tc.number HiAppEventJsTest009_1
506     * @tc.name: HiAppEventJsTest009_1
507     * @tc.desc: Error code -1 is returned when the event has invalid event name.
508     * @tc.type: FUNC
509     * @tc.require: issueI4BY0R
510     */
511    it('HiAppEventJsTest009_1', 0, async function (done) {
512        console.info('HiAppEventJsTest009_1 start');
513        writeNameTest("verify_test_1.**1", -1, done);
514    });
515
516    /**
517     * @tc.number HiAppEventJsTest009_2
518     * @tc.name: HiAppEventJsTest009_2
519     * @tc.desc: Error code 11101002 is returned when the event has invalid event name.
520     * @tc.type: FUNC
521     * @tc.require: issueI4BY0R
522     */
523    it('HiAppEventJsTest009_2', 0, async function (done) {
524        console.info('HiAppEventJsTest009_2 start');
525        let expectErr = createError(11101002, "Invalid event name.");
526        writeNameV9Test("", expectErr, done);
527    });
528
529    /**
530     * @tc.number HiAppEventJsTest009_3
531     * @tc.name: HiAppEventJsTest009_3
532     * @tc.desc: Error code 11101002 is returned when the event has invalid event name.
533     * @tc.type: FUNC
534     * @tc.require: issueI4BY0R
535     */
536    it('HiAppEventJsTest009_3', 0, async function (done) {
537        console.info('HiAppEventJsTest009_3 start');
538        let expectErr = createError(11101002, "Invalid event name.");
539        writeNameV9Test("VVtt_", expectErr, done);
540    });
541
542    /**
543     * @tc.number HiAppEventJsTest009_4
544     * @tc.name: HiAppEventJsTest009_4
545     * @tc.desc: Error code 11101002 is returned when the event has invalid event name.
546     * @tc.type: FUNC
547     * @tc.require: issueI4BY0R
548     */
549    it('HiAppEventJsTest009_4', 0, async function (done) {
550        console.info('HiAppEventJsTest009_3 start');
551        const MAX_LENGTH_OF_EVENT_NAME = 48;
552        let expectErr = createError(11101002, "Invalid event name.");
553        writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME + 1), expectErr, done);
554
555        writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME - 1) + "_", expectErr, done);
556
557        writeNameV9Test("a".repeat(MAX_LENGTH_OF_EVENT_NAME), null, done);
558    });
559
560    /**
561     * @tc.number HiAppEventJsTest010_1
562     * @tc.name: HiAppEventJsTest010_1
563     * @tc.desc: Error code -2 is returned when the event has invalid eventName type, eventType type, keyValues type.
564     * @tc.type: FUNC
565     * @tc.require: issueI4BY0R
566     */
567    it('HiAppEventJsTest010_1', 0, async function (done) {
568        console.info('HiAppEventJsTest010_1 start');
569        writeTest(null, TEST_TYPE, TEST_PARAMS, -2, done);
570    });
571
572    /**
573     * @tc.number HiAppEventJsTest010_2
574     * @tc.name: HiAppEventJsTest010_2
575     * @tc.desc: Error code -2 is returned when the event has invalid eventName type, eventType type, keyValues type.
576     * @tc.type: FUNC
577     * @tc.require: issueI4BY0R
578     */
579    it('HiAppEventJsTest010_1', 0, async function (done) {
580        console.info('HiAppEventJsTest010_1 start');
581        writeTest(TEST_NAME, "invalid", TEST_PARAMS, -2, done);
582    });
583
584    /**
585     * @tc.number HiAppEventJsTest010_3
586     * @tc.name: HiAppEventJsTest010_3
587     * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type.
588     * @tc.type: FUNC
589     * @tc.require: issueI4BY0R
590     */
591    it('HiAppEventJsTest010_3', 0, async function (done) {
592        console.info('HiAppEventJsTest010_3 start');
593
594        // invalid AppEventInfo type
595        let expectErr = createError2("info", "AppEventInfo");
596        writeV9Test(null, expectErr, done, true);
597    });
598
599    /**
600     * @tc.number HiAppEventJsTest010_4
601     * @tc.name: HiAppEventJsTest010_4
602     * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type.
603     * @tc.type: FUNC
604     * @tc.require: issueI4BY0R
605     */
606    it('HiAppEventJsTest010_4', 0, async function (done) {
607        console.info('HiAppEventJsTest010_4 start');
608
609        // invalid event domain type
610        let expectErr = createError2("domain", "string");
611        writeDomainV9Test(true, expectErr, done, true);
612    });
613
614    /**
615     * @tc.number HiAppEventJsTest010_5
616     * @tc.name: HiAppEventJsTest010_5
617     * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type.
618     * @tc.type: FUNC
619     * @tc.require: issueI4BY0R
620     */
621    it('HiAppEventJsTest010_5', 0, async function (done) {
622        console.info('HiAppEventJsTest010_5 start');
623
624        // invalid event name type
625        let expectErr = createError2("name", "string");
626        writeNameV9Test(null, expectErr, done, true);
627    });
628
629    /**
630     * @tc.number HiAppEventJsTest010_6
631     * @tc.name: HiAppEventJsTest010_6
632     * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type.
633     * @tc.type: FUNC
634     * @tc.require: issueI4BY0R
635     */
636    it('HiAppEventJsTest010_6', 0, async function (done) {
637        console.info('HiAppEventJsTest010_6 start');
638
639        // invalid eventType type
640        let expectErr = createError2("eventType", "EventType");
641        writeTypeV9Test(-1, expectErr, done, true);
642    });
643
644    /**
645     * @tc.number HiAppEventJsTest010_7
646     * @tc.name: HiAppEventJsTest010_7
647     * @tc.desc: Error code 401 is returned when the event has invalid eventName type, eventType type, keyValues type.
648     * @tc.type: FUNC
649     * @tc.require: issueI4BY0R
650     */
651    it('HiAppEventJsTest010_7', 0, async function (done) {
652        console.info('HiAppEventJsTest010_7 start');
653
654        // invalid event params type
655        let expectErr = createError2("params", "object");
656        writeParamsV9Test(null, expectErr, done, true);
657    });
658
659    /**
660     * @tc.number HiAppEventJsTest011_1
661     * @tc.name: HiAppEventJsTest011_1
662     * @tc.desc: Error code -3 is returned when the event has invalid num of args.
663     * @tc.type: FUNC
664     * @tc.require: issueI4BY0R
665     */
666    it('HiAppEventJsTest011_1', 0, async function (done) {
667        console.info('HiAppEventJsTest011_1 start');
668        hiAppEvent.write().then(() => {
669            expect().assertFail();
670            done();
671        }).catch((err) => {
672            let result = err.code;
673            expect(result).assertEqual(-3);
674            done();
675            console.info('HiAppEventJsTest011_1 end');
676        });
677    });
678
679    /**
680     * @tc.number HiAppEventJsTest011_2
681     * @tc.name: HiAppEventJsTest011_2
682     * @tc.desc: Error code 401 is returned when the event has invalid num of args.
683     * @tc.type: FUNC
684     * @tc.require: issueI4BY0R
685     */
686    it('HiAppEventJsTest011_2', 0, async function (done) {
687        console.info('HiAppEventJsTest011_2 start');
688
689        // AppEventInfo not passed in
690        try {
691            hiAppEventV9.write();
692        } catch (err) {
693            let expectErr = createError3("info")
694            assertErrorEqual(err, expectErr)
695            console.info('HiAppEventJsTest011_2 end');
696        }
697        done();
698    });
699
700    /**
701     * @tc.number HiAppEventJsTest011_3
702     * @tc.name: HiAppEventJsTest011_3
703     * @tc.desc: Error code 401 is returned when the event has invalid num of args.
704     * @tc.type: FUNC
705     * @tc.require: issueI4BY0R
706     */
707    it('HiAppEventJsTest011_3', 0, async function (done) {
708        console.info('HiAppEventJsTest011_3 start');
709
710        // event domain not passed in
711        try {
712            hiAppEventV9.write({
713                name: TEST_NAME,
714                eventType: TEST_TYPE_V9,
715                params: TEST_PARAMS,
716            });
717        } catch (err) {
718            let expectErr = createError3("domain")
719            assertErrorEqual(err, expectErr)
720            console.info('HiAppEventJsTest011_3 end');
721        }
722        done();
723    });
724
725    /**
726     * @tc.number HiAppEventJsTest011_4
727     * @tc.name: HiAppEventJsTest011_4
728     * @tc.desc: Error code 401 is returned when the event has invalid num of args.
729     * @tc.type: FUNC
730     * @tc.require: issueI4BY0R
731     */
732    it('HiAppEventJsTest011_4', 0, async function (done) {
733        console.info('HiAppEventJsTest011_4 start');
734
735        // event name not passed in
736        try {
737            hiAppEventV9.write({
738                domain: TEST_DOMAIN,
739                eventType: TEST_TYPE_V9,
740                params: TEST_PARAMS,
741            });
742        } catch (err) {
743            let expectErr = createError3("name")
744            assertErrorEqual(err, expectErr)
745            console.info('HiAppEventJsTest011_4 end');
746        }
747        done();
748    });
749
750    /**
751     * @tc.number HiAppEventJsTest011_5
752     * @tc.name: HiAppEventJsTest011_5
753     * @tc.desc: Error code 401 is returned when the event has invalid num of args.
754     * @tc.type: FUNC
755     * @tc.require: issueI4BY0R
756     */
757    it('HiAppEventJsTest011_5', 0, async function (done) {
758        console.info('HiAppEventJsTest011_5 start');
759
760        // event type not passed in
761        try {
762            hiAppEventV9.write({
763                domain: TEST_DOMAIN,
764                name: TEST_NAME,
765                params: TEST_PARAMS,
766            });
767        } catch (err) {
768            let expectErr = createError3("eventType")
769            assertErrorEqual(err, expectErr)
770            console.info('HiAppEventJsTest011_5 end');
771        }
772        done();
773    });
774
775    /**
776     * @tc.number HiAppEventJsTest011_6
777     * @tc.name: HiAppEventJsTest011_6
778     * @tc.desc: Error code 401 is returned when the event has invalid num of args.
779     * @tc.type: FUNC
780     * @tc.require: issueI4BY0R
781     */
782    it('HiAppEventJsTest011_6', 0, async function (done) {
783        console.info('HiAppEventJsTest011_6 start');
784
785        // event params not passed in
786        try {
787            hiAppEventV9.write({
788                domain: TEST_DOMAIN,
789                name: TEST_NAME,
790                eventType: TEST_TYPE_V9,
791            });
792        } catch (err) {
793            let expectErr = createError3("params")
794            assertErrorEqual(err, expectErr)
795            console.info('HiAppEventJsTest011_6 end');
796        }
797        done();
798    });
799
800    /**
801     * @tc.number HiAppEventJsTest012
802     * @tc.name: HiAppEventJsTest012
803     * @tc.desc: Test event domain.
804     * @tc.type: FUNC
805     * @tc.require: issueI4BY0R
806     */
807    it('HiAppEventJsTest012', 0, async function (done) {
808        console.info('HiAppEventJsTest012 start');
809
810        const MAX_LEN_OF_DOMAIN = 32;
811        // Error code 11101001 is returned when the event has invalid event domain.
812        let expectErr = createError(11101001, "Invalid event domain.");
813        writeDomainV9Test("domain***", expectErr, done);
814        writeDomainV9Test("123domain", expectErr, done);
815        writeDomainV9Test("_domain", expectErr, done);
816        writeDomainV9Test("domain_", expectErr, done);
817        writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN - 1) + "_", expectErr, done);
818        writeDomainV9Test("", expectErr, done);
819        writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN + 1), expectErr, done);
820
821        // valid event domain.
822        writeDomainV9Test("a", null, done);
823        writeDomainV9Test("a1", null, done);
824        writeDomainV9Test("domainTest", null, done);
825        writeDomainV9Test("a".repeat(MAX_LEN_OF_DOMAIN), null, done);
826    });
827
828    /**
829     * @tc.number HiAppEventJsTest013
830     * @tc.name: HiAppEventJsTest013
831     * @tc.desc: The number of event params exceeds 32 and invalid params exist.
832     * @tc.type: FUNC
833     * @tc.require: issueI8GWHC
834     */
835     it('HiAppEventJsTest013', 0, async function (done) {
836        console.info('HiAppEventJsTest013 start');
837        let params = {};
838        for (var i = 1; i <= 33; i++) {
839            params["key" + i] = "value" + i;
840        }
841        let invalidKey = 'a'.repeat(17);
842        params[invalidKey] = 'value_invalid';
843        let expectErr = createError(11101003, "Invalid number of event parameters.");
844        writeParamsV9Test(params, expectErr, done);
845    });
846
847    /**
848     * @tc.number HiAppEventJsTest014
849     * @tc.name: HiAppEventJsTest014
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('HiAppEventJsTest014', 0, async function (done) {
855        console.info('HiAppEventJsTest014 start');
856        let params = {};
857        params["123xxx"] = "value_invalid"; // invalid param name
858        params["xxx_"] = "value_invalid"; // invalid param name
859        for (var i = 1; i <= 33; i++) {
860            params["key" + i] = "value" + i;
861        }
862        params['a'.repeat(33)] = 'value_invalid'; // invalid param name
863        let expectErr = createError(11101003, "Invalid number of event parameters.");
864        writeParamsV9Test(params, expectErr, done);
865    });
866
867    /**
868     * @tc.number HiAppEventJsPresetTest001_1
869     * @tc.name: HiAppEventJsPresetTest001_1
870     * @tc.desc: Test preset events and preset parameters.
871     * @tc.type: FUNC
872     * @tc.require: issueI4BY0R
873     */
874    it('HiAppEventJsPresetTest001_1', 0, async function (done) {
875        console.info('HiAppEventJsPresetTest001_1 start');
876        writeTest(hiAppEvent.Event.USER_LOGIN, hiAppEvent.EventType.FAULT, {
877            [hiAppEvent.Param.USER_ID]: "123456"
878        }, 0, done);
879    });
880
881    /**
882     * @tc.number HiAppEventJsPresetTest001_2
883     * @tc.name: HiAppEventJsPresetTest001_2
884     * @tc.desc: Test preset events and preset parameters.
885     * @tc.type: FUNC
886     * @tc.require: issueI4BY0R
887     */
888     it('HiAppEventJsPresetTest001_2', 0, async function (done) {
889        console.info('HiAppEventJsPresetTest001_2 start');
890        writeTest(hiAppEvent.Event.USER_LOGOUT, hiAppEvent.EventType.STATISTIC, {
891            [hiAppEvent.Param.USER_ID]: "123456"
892        }, 0, done);
893    });
894
895    /**
896     * @tc.number HiAppEventJsPresetTest001_3
897     * @tc.name: HiAppEventJsPresetTest001_3
898     * @tc.desc: Test preset events and preset parameters.
899     * @tc.type: FUNC
900     * @tc.require: issueI4BY0R
901     */
902     it('HiAppEventJsPresetTest001_3', 0, async function (done) {
903        console.info('HiAppEventJsPresetTest001_3 start');
904        let eventInfo = {
905            domain: TEST_DOMAIN,
906            name: hiAppEventV9.event.DISTRIBUTED_SERVICE_START,
907            eventType: hiAppEventV9.EventType.SECURITY,
908            params: {
909                [hiAppEventV9.param.DISTRIBUTED_SERVICE_NAME]: "test_service",
910                [hiAppEventV9.param.DISTRIBUTED_SERVICE_INSTANCE_ID]: "123",
911            },
912        };
913        writeV9Test(eventInfo, null, done);
914    });
915
916    /**
917     * @tc.number HiAppEventConfigureTest001_1
918     * @tc.name: HiAppEventConfigureTest001_1
919     * @tc.desc: Error code -99 is returned when the logging function is disabled.
920     * @tc.type: FUNC
921     * @tc.require: issueI4BY0R
922     */
923    it('HiAppEventConfigureTest001_1', 0, async function (done) {
924        console.info('HiAppEventConfigureTest001_1 start');
925        let res = hiAppEvent.configure({
926            disable: true
927        });
928        expect(res).assertTrue();
929
930        writeNameTest("config_test", -99, done);
931    });
932
933    /**
934     * @tc.number HiAppEventConfigureTest001_2
935     * @tc.name: HiAppEventConfigureTest001_2
936     * @tc.desc: Error code 11100001 is returned when the logging function is disabled.
937     * @tc.type: FUNC
938     * @tc.require: issueI4BY0R
939     */
940     it('HiAppEventConfigureTest001_2', 0, async function (done) {
941        console.info('HiAppEventConfigureTest001_2 start');
942        hiAppEventV9.configure({
943            disable: true
944        });
945
946        let expectErr = createError(11100001, "Function disabled.");
947        writeNameV9Test("config_test", expectErr, done);
948    });
949
950    /**
951     * @tc.number HiAppEventConfigureTest002
952     * @tc.name: HiAppEventConfigureTest002
953     * @tc.desc: Correctly configure the event logging function.
954     * @tc.type: FUNC
955     * @tc.require: issueI4BY0R
956     */
957    it('HiAppEventConfigureTest002', 0, function () {
958        console.info('HiAppEventConfigureTest002 start');
959        let result = false;
960        result = hiAppEvent.configure({
961            disable: false,
962            maxStorage: "10G"
963        });
964        expect(result).assertTrue()
965
966        try {
967            hiAppEventV9.configure({
968                disable: true,
969                maxStorage: "100m"
970            });
971            hiAppEventV9.configure({
972                disable: false,
973                maxStorage: "10M"
974            });
975        } catch (err) {
976            expect().assertFail();
977        }
978
979        console.info('HiAppEventConfigureTest002 end');
980    });
981
982    /**
983     * @tc.number HiAppEventConfigureTest003
984     * @tc.name: HiAppEventConfigureTest003
985     * @tc.desc: Incorrectly configure the event logging function.
986     * @tc.type: FUNC
987     * @tc.require: issueI4BY0R
988     */
989    it('HiAppEventConfigureTest003', 0, function () {
990        console.info('HiAppEventConfigureTest003 start');
991        let result = true;
992
993        result = hiAppEvent.configure({
994            disable: false,
995            maxStorage: "xxx"
996        })
997        expect(result).assertFalse()
998
999        result = hiAppEvent.configure(null)
1000        expect(result).assertFalse()
1001
1002        result = hiAppEvent.configure({
1003            disable: null,
1004            maxStorage: {}
1005        })
1006        expect(result).assertFalse()
1007
1008        // ConfigOption not passed in
1009        try {
1010            hiAppEventV9.configure();
1011        } catch (err) {
1012            let expectErr = createError3("config")
1013            assertErrorEqual(err, expectErr)
1014        }
1015
1016        // invalid ConfigOption type
1017        function configureTest(configOption, expectErr) {
1018            try {
1019                hiAppEventV9.configure(configOption);
1020            } catch (err) {
1021                assertErrorEqual(err, expectErr)
1022            }
1023        }
1024        let expectErr = createError2("config", "ConfigOption")
1025        configureTest(null, expectErr)
1026        configureTest([], expectErr)
1027
1028        // invalid ConfigOption.disable type
1029        expectErr = createError2("disable", "boolean")
1030        configureTest({ disable: 123 }, expectErr)
1031
1032        // invalid ConfigOption.maxStorage type
1033        expectErr = createError2("maxStorage", "string")
1034        configureTest({ maxStorage: null }, expectErr)
1035
1036        // invalid ConfigOption.maxStorage value
1037        expectErr = createError(11103001, "Invalid max storage quota value.")
1038        configureTest({ maxStorage: "**22" }, expectErr)
1039
1040        console.info('HiAppEventConfigureTest003 end');
1041    });
1042
1043    /**
1044     * @tc.number HiAppEventClearTest001
1045     * @tc.name: HiAppEventClearTest001
1046     * @tc.desc: clear the local data.
1047     * @tc.type: FUNC
1048     * @tc.require: issueI5NTOS
1049     */
1050    it('HiAppEventClearTest001', 0, async function (done) {
1051        console.info('HiAppEventClearTest001 start');
1052
1053        // 1. clear data
1054        let result = hiAppEventV9.clearData();
1055        expect(result).assertUndefined();
1056
1057        // 2. write event after clear data
1058        writeNameV9Test("clear_test", null, done);
1059    });
1060
1061    /**
1062     * @tc.number HiAppEventWatcherTest001
1063     * @tc.name: HiAppEventWatcherTest001
1064     * @tc.desc: invalid watcher type.
1065     * @tc.type: FUNC
1066     * @tc.require: issueI5LB4N
1067     */
1068    it('HiAppEventWatcherTest001', 0, function () {
1069        console.info('HiAppEventWatcherTest001 start');
1070
1071        // watcher not passed in
1072        let expectErr = createError3("watcher")
1073        try {
1074            hiAppEventV9.addWatcher();
1075        } catch (err) {
1076            assertErrorEqual(err, expectErr)
1077        }
1078        try {
1079            hiAppEventV9.removeWatcher();
1080        } catch (err) {
1081            assertErrorEqual(err, expectErr)
1082        }
1083
1084        // invalid watcher type
1085        expectErr = createError2("watcher", "Watcher")
1086        function addWatcherTypeTest(watcher) {
1087            try {
1088                hiAppEventV9.addWatcher(watcher);
1089            } catch (err) {
1090                assertErrorEqual(err, expectErr)
1091            }
1092        }
1093        function removeWatcherTypeTest(watcher) {
1094            try {
1095                hiAppEventV9.removeWatcher(watcher);
1096            } catch (err) {
1097                assertErrorEqual(err, expectErr)
1098            }
1099        }
1100        addWatcherTypeTest(null);
1101        addWatcherTypeTest(123);
1102        removeWatcherTypeTest(null);
1103        removeWatcherTypeTest(123);
1104
1105        console.info('HiAppEventWatcherTest001 end');
1106    });
1107
1108    /**
1109     * @tc.number HiAppEventWatcherTest002
1110     * @tc.name: HiAppEventWatcherTest002
1111     * @tc.desc: invalid watcher name.
1112     * @tc.type: FUNC
1113     * @tc.require: issueI5LB4N
1114     */
1115    it('HiAppEventWatcherTest002', 0, function () {
1116        console.info('HiAppEventWatcherTest002 start');
1117
1118        // watcher name not passed in
1119        try {
1120            hiAppEventV9.addWatcher({});
1121        } catch (err) {
1122            let expectErr = createError3("name")
1123            assertErrorEqual(err, expectErr)
1124        }
1125
1126        // invalid watcher name type
1127        function watcherNameTest(name, expectErr) {
1128            try {
1129                hiAppEventV9.addWatcher({
1130                    name: name
1131                });
1132            } catch (err) {
1133                assertErrorEqual(err, expectErr)
1134            }
1135        }
1136        let expectErr = createError2("name", "string");
1137        watcherNameTest(null, expectErr);
1138        watcherNameTest(true, expectErr);
1139        watcherNameTest(123, expectErr);
1140
1141        const MAX_LEN_OF_WATCHER = 32;
1142        // invalid watcher name value
1143        expectErr = createError(11102001, "Invalid watcher name.")
1144        watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER + 1), expectErr);
1145        watcherNameTest("", expectErr);
1146        watcherNameTest("watcher_***", expectErr);
1147        watcherNameTest("Watcher_test", null);
1148        watcherNameTest("_watcher_test", expectErr);
1149        watcherNameTest("watcher_", expectErr);
1150        watcherNameTest("123watcher", expectErr);
1151        watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER - 1) + "_", expectErr);
1152        watcherNameTest("a", null);
1153        watcherNameTest("a1", null);
1154        watcherNameTest("a".repeat(MAX_LEN_OF_WATCHER), null);
1155
1156        console.info('HiAppEventWatcherTest002 end');
1157    });
1158
1159    /**
1160     * @tc.number HiAppEventWatcherTest003
1161     * @tc.name: HiAppEventWatcherTest003
1162     * @tc.desc: invalid watcher trigger condition.
1163     * @tc.type: FUNC
1164     * @tc.require: issueI5LB4N
1165     */
1166    it('HiAppEventWatcherTest003', 0, function () {
1167        console.info('HiAppEventWatcherTest003 start');
1168
1169        // invalid triggerCondition type
1170        function triggerConditionTest(condition, expectErr) {
1171            try {
1172                hiAppEventV9.addWatcher({
1173                    name: "watcher",
1174                    triggerCondition: condition
1175                });
1176            } catch (err) {
1177                assertErrorEqual(err, expectErr)
1178            }
1179        }
1180        let expectErr = createError2("triggerCondition", "TriggerCondition")
1181        triggerConditionTest(null, expectErr);
1182        triggerConditionTest(123, expectErr);
1183
1184        // invalid triggerCondition.row type
1185        function rowTest(row, expectErr) {
1186            triggerConditionTest({ row: row }, expectErr);
1187        }
1188        expectErr = createError2("row", "number")
1189        rowTest(null, expectErr)
1190        rowTest("str", expectErr)
1191
1192        // invalid triggerCondition.row value
1193        expectErr = createError(11102003, "Invalid row value.")
1194        rowTest(-1, expectErr)
1195        rowTest(-100, expectErr)
1196
1197        // invalid triggerCondition.size type
1198        function sizeTest(size, expectErr) {
1199            triggerConditionTest({ size: size }, expectErr);
1200        }
1201        expectErr = createError2("size", "number")
1202        sizeTest(null, expectErr)
1203        sizeTest(true, expectErr)
1204
1205        // invalid triggerCondition.size value
1206        expectErr = createError(11102004, "Invalid size value.")
1207        sizeTest(-1, expectErr)
1208        sizeTest(-100, expectErr)
1209
1210        // invalid triggerCondition.timeout type
1211        function timeoutTest(timeout) {
1212            triggerConditionTest({ timeout: timeout }, expectErr);
1213        }
1214        expectErr = createError2("timeout", "number")
1215        timeoutTest(null, expectErr)
1216        timeoutTest({}, expectErr)
1217
1218        // invalid triggerCondition.timeout value
1219        expectErr = createError(11102005, "Invalid timeout value.")
1220        timeoutTest(-1, expectErr)
1221        timeoutTest(-100, expectErr)
1222
1223        console.info('HiAppEventWatcherTest003 end');
1224    });
1225
1226    /**
1227     * @tc.number HiAppEventWatcherTest004
1228     * @tc.name: HiAppEventWatcherTest004
1229     * @tc.desc: invalid watcher filters.
1230     * @tc.type: FUNC
1231     * @tc.require: issueI5LB4N
1232     */
1233    it('HiAppEventWatcherTest004', 0, function () {
1234        console.info('HiAppEventWatcherTest004 start');
1235
1236        // invalid appEventFilters type
1237        function appEventFiltersTest(filters, expectErr) {
1238            try {
1239                hiAppEventV9.addWatcher({
1240                    name: "watcher",
1241                    appEventFilters: filters
1242                });
1243            } catch (err) {
1244                assertErrorEqual(err, expectErr)
1245            }
1246        }
1247        let expectErr = createError2("appEventFilters", "AppEventFilter[]")
1248        appEventFiltersTest(null, expectErr)
1249        appEventFiltersTest({}, expectErr)
1250        appEventFiltersTest("invalid", expectErr)
1251        appEventFiltersTest([1, 2], expectErr)
1252        appEventFiltersTest(["str1", "str2"], expectErr)
1253
1254        // appEventFilter.domain not passed in
1255        function appEventFilterTest(filter, expectErr) {
1256            appEventFiltersTest([filter], expectErr)
1257        }
1258        expectErr = createError3("domain")
1259        appEventFilterTest({}, expectErr)
1260
1261        // invalid appEventFilter.domain type
1262        function domainTest(domain, expectErr) {
1263            appEventFilterTest({ domain: domain }, expectErr)
1264        }
1265        expectErr = createError2("domain", "string")
1266        domainTest(null, expectErr)
1267        domainTest(123, expectErr)
1268
1269        // invalid appEventFilter.domain value
1270        expectErr = createError(11102002, "Invalid filtering event domain.")
1271        domainTest("**xx", expectErr)
1272        domainTest("123test", expectErr)
1273        domainTest("test_", expectErr)
1274        domainTest("a".repeat(33), expectErr)
1275        domainTest("", expectErr)
1276        domainTest("a", null)
1277        domainTest("a1", null)
1278        domainTest("Domain_1", null)
1279
1280        // invalid appEventFilter.eventTypes type
1281        function eventTypesTest(eventTypes, expectErr) {
1282            appEventFilterTest({
1283                domain: "test_domain",
1284                eventTypes: eventTypes
1285            }, expectErr)
1286        }
1287        expectErr = createError2("eventTypes", "EventType[]")
1288        eventTypesTest(null, expectErr)
1289        eventTypesTest("invalid", expectErr)
1290        eventTypesTest(["invalid"], expectErr)
1291        eventTypesTest([10, -1], expectErr)
1292
1293        console.info('HiAppEventWatcherTest004 end');
1294    });
1295
1296    /**
1297     * @tc.number HiAppEventWatcherTest005
1298     * @tc.name: HiAppEventWatcherTest005
1299     * @tc.desc: invalid watcher onTrigger.
1300     * @tc.type: FUNC
1301     * @tc.require: issueI5LB4N
1302     */
1303    it('HiAppEventWatcherTest005', 0, function () {
1304        console.info('HiAppEventWatcherTest005 start');
1305
1306        function onTriggerTest(onTrigger, expectErr) {
1307            try {
1308                hiAppEventV9.addWatcher({
1309                    name: "watcher",
1310                    onTrigger: onTrigger
1311                });
1312            } catch (err) {
1313                assertErrorEqual(err, expectErr)
1314            }
1315        }
1316        let expectErr = createError2("onTrigger", "function")
1317        onTriggerTest(null, expectErr)
1318        onTriggerTest("invalid", expectErr)
1319
1320        console.info('HiAppEventWatcherTest005 end');
1321    });
1322
1323    /**
1324     * @tc.number HiAppEventWatcherTest006
1325     * @tc.name: HiAppEventWatcherTest006
1326     * @tc.desc: add valid watcher.
1327     * @tc.type: FUNC
1328     * @tc.require: issueI5LB4N
1329     */
1330    it('HiAppEventWatcherTest006', 0, function () {
1331        console.info('HiAppEventWatcherTest006 start');
1332        let result = true;
1333        let watcher1 = {
1334            name: "watcher1",
1335        };
1336        result = hiAppEventV9.addWatcher(watcher1);
1337        expect(result != null).assertTrue()
1338
1339        let watcher2 = {
1340            name: "watcher2",
1341            triggerCondition: {}
1342        };
1343        result = hiAppEventV9.addWatcher(watcher2);
1344        expect(result != null).assertTrue()
1345
1346        let watcher3 = {
1347            name: "watcher3",
1348            triggerCondition: {
1349                row: 5
1350            },
1351            onTrigger: simpleTrigger
1352        };
1353        result = hiAppEventV9.addWatcher(watcher3);
1354        expect(result != null).assertTrue()
1355
1356        let watcher4 = {
1357            name: "watcher4",
1358            triggerCondition: {
1359                size: 1000
1360            },
1361            onTrigger: simpleTrigger
1362        };
1363        result = hiAppEventV9.addWatcher(watcher4);
1364        expect(result != null).assertTrue()
1365
1366        let watcher5 = {
1367            name: "watcher5",
1368            triggerCondition: {
1369                timeOut: 2
1370            },
1371            onTrigger: simpleTrigger
1372        };
1373        result = hiAppEventV9.addWatcher(watcher5);
1374        expect(result != null).assertTrue()
1375
1376        let watcher6 = {
1377            name: "watcher6",
1378            triggerCondition: {
1379                row: 5,
1380                size: 1000,
1381                timeOut: 2
1382            },
1383            onTrigger: simpleTrigger
1384        };
1385        result = hiAppEventV9.addWatcher(watcher6);
1386        expect(result != null).assertTrue()
1387
1388        let watcher7 = {
1389            name: "watcher7",
1390            appEventFilters: []
1391        };
1392        result = hiAppEventV9.addWatcher(watcher7);
1393        expect(result != null).assertTrue()
1394
1395        let watcher8 = {
1396            name: "watcher8",
1397            appEventFilters: [
1398                {domain: "domain_test", eventTypes: []},
1399                {domain: "default", eventTypes: [hiAppEventV9.EventType.FAULT, hiAppEventV9.EventType.BEHAVIOR]},
1400            ]
1401        };
1402        result = hiAppEventV9.addWatcher(watcher8);
1403        expect(result != null).assertTrue()
1404
1405        hiAppEventV9.removeWatcher(watcher1);
1406        hiAppEventV9.removeWatcher(watcher2);
1407        hiAppEventV9.removeWatcher(watcher3);
1408        hiAppEventV9.removeWatcher(watcher4);
1409        hiAppEventV9.removeWatcher(watcher5);
1410        hiAppEventV9.removeWatcher(watcher6);
1411        hiAppEventV9.removeWatcher(watcher7);
1412        hiAppEventV9.removeWatcher(watcher8);
1413        console.info('HiAppEventWatcherTest006 end');
1414    });
1415
1416    /**
1417     * @tc.number HiAppEventWatcherTest007
1418     * @tc.name: HiAppEventWatcherTest007
1419     * @tc.desc: watcher.onTrigger row test.
1420     * @tc.type: FUNC
1421     * @tc.require: issueI5KYYI
1422     */
1423    it('HiAppEventWatcherTest007', 0, async function (done) {
1424        console.info('HiAppEventWatcherTest007 start');
1425        let watcher = {
1426            name: "watcher_007",
1427            appEventFilters: [
1428                { domain: TEST_DOMAIN },
1429            ],
1430            triggerCondition: {
1431                row: 1
1432            },
1433            onTrigger: function (curRow, curSize, holder) {
1434                console.info('HiAppEventWatcherTest007.onTrigger start');
1435                expect(curRow).assertEqual(1)
1436                expect(curSize > 0).assertTrue()
1437                expect(holder != null).assertTrue()
1438
1439                let eventPkg = holder.takeNext();
1440                expect(eventPkg != null).assertTrue()
1441                expect(eventPkg.packageId).assertEqual(0)
1442                expect(eventPkg.row).assertEqual(1)
1443                expect(eventPkg.size > 0).assertTrue()
1444                expect(eventPkg.data.length).assertEqual(1)
1445                expect(eventPkg.data[0].length > 0).assertTrue()
1446                console.info('HiAppEventWatcherTest007.onTrigger end');
1447            }
1448        };
1449        let result = hiAppEventV9.addWatcher(watcher);
1450        expect(result != null).assertTrue()
1451
1452        simpleWriteV9Test();
1453
1454        setTimeout(() => {
1455            hiAppEventV9.removeWatcher(watcher);
1456            console.info('HiAppEventWatcherTest007 end');
1457            done();
1458        }, 1000);
1459    });
1460
1461    /**
1462     * @tc.number HiAppEventWatcherTest008
1463     * @tc.name: HiAppEventWatcherTest008
1464     * @tc.desc: watcher.onTrigger size test.
1465     * @tc.type: FUNC
1466     * @tc.require: issueI5KYYI
1467     */
1468    it('HiAppEventWatcherTest008', 0, async function (done) {
1469        console.info('HiAppEventWatcherTest008 start');
1470        let watcher = {
1471            name: "watcher_008",
1472            appEventFilters: [
1473                { domain: TEST_DOMAIN },
1474            ],
1475            triggerCondition: {
1476                row: 10,
1477                size: 200,
1478            },
1479            onTrigger: function (curRow, curSize, holder) {
1480                console.info('HiAppEventWatcherTest008.onTrigger start');
1481                expect(curRow).assertEqual(2)
1482                expect(curSize >= 200).assertTrue()
1483                expect(holder != null).assertTrue()
1484
1485                holder.setSize(curSize);
1486                let eventPkg = holder.takeNext();
1487                expect(eventPkg != null).assertTrue()
1488                expect(eventPkg.packageId).assertEqual(0)
1489                expect(eventPkg.row).assertEqual(2)
1490                expect(eventPkg.size >= 200).assertTrue()
1491                expect(eventPkg.data.length).assertEqual(2)
1492                expect(eventPkg.data[0].length > 0).assertTrue()
1493                expect(eventPkg.data[1].length > 0).assertTrue()
1494                console.info('HiAppEventWatcherTest008.onTrigger end');
1495            }
1496        };
1497        let result = hiAppEventV9.addWatcher(watcher);
1498        expect(result != null).assertTrue()
1499
1500        simpleWriteV9Test();
1501        simpleWriteV9Test();
1502
1503        setTimeout(() => {
1504            hiAppEventV9.removeWatcher(watcher);
1505            console.info('HiAppEventWatcherTest008 end');
1506            done();
1507        }, 1000);
1508    });
1509
1510    /**
1511     * @tc.number HiAppEventWatcherTest009
1512     * @tc.name: HiAppEventWatcherTest009
1513     * @tc.desc: watcher.onTrigger timeout test.
1514     * @tc.type: FUNC
1515     * @tc.require: issueI5KYYI
1516     */
1517    it('HiAppEventWatcherTest009', 0, async function (done) {
1518        console.info('HiAppEventWatcherTest009 start');
1519        let watcher = {
1520            name: "watcher",
1521            triggerCondition: {
1522                timeOut: 1
1523            },
1524            onTrigger: function (curRow, curSize, holder) {
1525                console.info('HiAppEventWatcherTest009.onTrigger start');
1526                expect(curRow).assertEqual(1)
1527                expect(curSize > 0).assertTrue()
1528                expect(holder != null).assertTrue()
1529
1530                let eventPkg = holder.takeNext();
1531                expect(eventPkg != null).assertTrue()
1532                expect(eventPkg.packageId).assertEqual(0)
1533                expect(eventPkg.row).assertEqual(1)
1534                expect(eventPkg.size > 0).assertTrue()
1535                expect(eventPkg.data.length).assertEqual(1)
1536                expect(eventPkg.data[0].length > 0).assertTrue()
1537                console.info('HiAppEventWatcherTest009.onTrigger end');
1538            }
1539        };
1540        let result = hiAppEventV9.addWatcher(watcher);
1541        expect(result != null).assertTrue()
1542
1543        simpleWriteV9Test();
1544
1545        setTimeout(() => {
1546            hiAppEventV9.removeWatcher(watcher);
1547            console.info('HiAppEventWatcherTest009 end');
1548            done();
1549        }, 3000);
1550    });
1551
1552    /**
1553     * @tc.number HiAppEventWatcherTest010
1554     * @tc.name: HiAppEventWatcherTest010
1555     * @tc.desc: watcher.holder test.
1556     * @tc.type: FUNC
1557     * @tc.require: issueI5NTOD
1558     */
1559    it('HiAppEventWatcherTest010', 0, async function (done) {
1560        console.info('HiAppEventWatcherTest010 start');
1561        let watcher = {
1562            name: "watcher",
1563        };
1564        let holder = hiAppEventV9.addWatcher(watcher);
1565        expect(holder != null).assertTrue()
1566
1567        simpleWriteV9Test();
1568
1569        setTimeout(() => {
1570            let eventPkg = holder.takeNext();
1571            expect(eventPkg != null).assertTrue();
1572            expect(eventPkg.packageId).assertEqual(0);
1573            expect(eventPkg.row).assertEqual(1);
1574            expect(eventPkg.size > 0).assertTrue();
1575            expect(eventPkg.data.length).assertEqual(1);
1576            expect(eventPkg.data[0].length > 0).assertTrue();
1577            hiAppEventV9.removeWatcher(watcher);
1578            console.info('HiAppEventWatcherTest010 end');
1579            done();
1580        }, 1000);
1581    });
1582
1583    /**
1584     * @tc.number HiAppEventWatcherTest011
1585     * @tc.name: HiAppEventWatcherTest011
1586     * @tc.desc: invalid watcher.holder test.
1587     * @tc.type: FUNC
1588     * @tc.require: issueI5NTOD
1589     */
1590    it('HiAppEventWatcherTest011', 0, function () {
1591        console.info('HiAppEventWatcherTest011 start');
1592        let watcher = {
1593            name: "watcher",
1594        };
1595        let holder = hiAppEventV9.addWatcher(watcher);
1596        expect(holder != null).assertTrue()
1597
1598        // size not passed in
1599        try {
1600            holder.setSize()
1601        } catch (err) {
1602            let expectErr = createError3("size");
1603            assertErrorEqual(err, expectErr)
1604        }
1605
1606        // invalid size type
1607        function holderSetSizeTest(holder, size, expectErr) {
1608            try {
1609                holder.setSize(size)
1610            } catch (err) {
1611                assertErrorEqual(err, expectErr)
1612            }
1613        }
1614        let expectErr = createError2("size", "number");
1615        holderSetSizeTest(holder, null, expectErr);
1616        holderSetSizeTest(holder, {}, expectErr);
1617
1618        // invalid size value
1619        expectErr = createError(11104001, "Invalid size value.");
1620        holderSetSizeTest(holder, -1, expectErr);
1621        holderSetSizeTest(holder, -100, expectErr);
1622
1623        hiAppEventV9.removeWatcher(watcher)
1624        console.info('HiAppEventWatcherTest011 end')
1625    });
1626
1627    /**
1628     * @tc.number HiAppEventWatcherTest012
1629     * @tc.name: HiAppEventWatcherTest012
1630     * @tc.desc: watcher.holder constructor test.
1631     * @tc.type: FUNC
1632     * @tc.require: issueI5KYYI
1633     */
1634     it('HiAppEventWatcherTest012', 0, async function (done) {
1635        console.info('HiAppEventWatcherTest012 start');
1636        let watcher = {
1637            name: "watcher",
1638        };
1639        hiAppEventV9.addWatcher(watcher);
1640
1641        let params = {
1642            "key_int": 100,
1643            "key_string": "strValue",
1644            "key_bool": true,
1645            "key_float": 30949.374,
1646            "key_int_arr": [1, 2, 3],
1647            "key_string_arr": ["a", "b", "c"],
1648            "key_float_arr": [1.1, 2.2, 3.0],
1649            "key_bool_arr": [true, false, true]
1650        };
1651        hiAppEventV9.write({
1652            domain: "test_domain",
1653            name: "test_name",
1654            eventType: hiAppEventV9.EventType.FAULT,
1655            params: params
1656        }, (err) => {
1657            expect(err).assertNull();
1658
1659            let holder = new hiAppEventV9.AppEventPackageHolder("watcher");
1660            let eventPkg = holder.takeNext();
1661            expect(eventPkg != null).assertTrue();
1662            expect(eventPkg.data.length == 1).assertTrue();
1663            let paramJsonStr = JSON.stringify(params);;
1664            expect(eventPkg.data[0].includes(paramJsonStr.substr(1, paramJsonStr.length - 2))).assertTrue();
1665            hiAppEventV9.removeWatcher(watcher);
1666            console.info('HiAppEventWatcherTest012 end');
1667            done();
1668        });
1669    });
1670
1671    /**
1672     * @tc.number HiAppEventWatcherTest013
1673     * @tc.name: HiAppEventWatcherTest013
1674     * @tc.desc: watcher.onTrigger test after clear up.
1675     * @tc.type: FUNC
1676     * @tc.require: issueI8H07G
1677     */
1678     it('HiAppEventWatcherTest013', 0, async function (done) {
1679        console.info('HiAppEventWatcherTest013 start');
1680        let testRow = 5;
1681        let watcher = {
1682            name: "watcher",
1683            triggerCondition: {
1684                row: testRow
1685            },
1686            onTrigger: function (curRow, curSize, holder) {
1687                console.info('HiAppEventWatcherTest013.onTrigger start');
1688                holder.setRow(testRow);
1689                let eventPkg = holder.takeNext();
1690                expect(eventPkg.data.length).assertEqual(testRow)
1691                console.info('HiAppEventWatcherTest013.onTrigger end');
1692            }
1693        };
1694        hiAppEventV9.addWatcher(watcher);
1695
1696        setTimeout(() => {
1697            for (var i = 1; i <= 3; i++) {
1698                simpleWriteV9Test();
1699            }
1700        }, 1000);
1701
1702        setTimeout(() => {
1703            hiAppEventV9.clearData();
1704        }, 2000);
1705
1706        setTimeout(() => {
1707            for (var i = 1; i <= testRow; i++) {
1708                simpleWriteV9Test();
1709            }
1710        }, 3000);
1711
1712        setTimeout(() => {
1713            hiAppEventV9.removeWatcher(watcher);
1714            console.info('HiAppEventWatcherTest013 end');
1715            done();
1716        }, 4000);
1717    });
1718
1719    function simpleReceive(domain, eventArray) {
1720        console.info('HiAppEventWatcherTest.onReceive start domain=' + domain + ', event size=' +
1721            eventArray.length);
1722        for (var key in eventArray) {
1723            console.info('HiAppEventWatcherTest event_name=' + eventArray[key]['name'] + ', size=' +
1724                eventArray[key]['appEventInfos'].length);
1725        }
1726        console.info('HiAppEventWatcherTest.onReceive end');
1727    }
1728
1729    /**
1730     * @tc.number HiAppEventWatcherTest014
1731     * @tc.name: HiAppEventWatcherTest014
1732     * @tc.desc: watcher.onReceive test.
1733     * @tc.type: FUNC
1734     * @tc.require: issueI5KYYI
1735     */
1736    it('HiAppEventWatcherTest014', 0, async function (done) {
1737        console.info('HiAppEventWatcherTest014 start');
1738        let watcher = {
1739            name: "watcheros1",
1740            appEventFilters: [
1741                {
1742                    domain: hiAppEventV9.domain.OS,
1743                    names: [
1744                        hiAppEventV9.event.APP_CRASH,
1745                        hiAppEventV9.event.APP_FREEZE,
1746                        "APP_START",
1747                        hiAppEventV9.event.APP_LAUNCH,
1748                        hiAppEventV9.event.SCROLL_JANK,
1749                        hiAppEventV9.event.CPU_USAGE_HIGH,
1750                        hiAppEventV9.event.BATTERY_USAGE,
1751                        hiAppEventV9.event.RESOURCE_OVERLIMIT,
1752                        hiAppEventV9.event.ADDRESS_SANITIZER
1753                    ]
1754                },
1755            ],
1756            onReceive: simpleReceive
1757        };
1758        let result = hiAppEventV9.addWatcher(watcher);
1759        expect(result != null).assertTrue();
1760
1761        setTimeout(() => {
1762            hiAppEventV9.removeWatcher(watcher);
1763            console.info('HiAppEventWatcherTest014 end');
1764            done();
1765        }, 1000);
1766    });
1767
1768    /**
1769     * @tc.number HiAppEventWatcherTest015
1770     * @tc.name: HiAppEventWatcherTest015
1771     * @tc.desc: watcher.onReceive test.
1772     * @tc.type: FUNC
1773     * @tc.require: issueI5KYYI
1774     */
1775    it('HiAppEventWatcherTest015', 0, async function (done) {
1776        console.info('HiAppEventWatcherTest015 start');
1777        let watcher = {
1778            name: "watcher",
1779            appEventFilters: [
1780                {domain: "test_domain", names: ["test_name"]},
1781            ],
1782            onReceive: simpleReceive
1783        };
1784        let result = hiAppEventV9.addWatcher(watcher);
1785        expect(result != null).assertTrue();
1786
1787        simpleWriteV9Test();
1788
1789        setTimeout(() => {
1790            hiAppEventV9.removeWatcher(watcher);
1791            console.info('HiAppEventWatcherTest015 end');
1792            done();
1793        }, 1000);
1794    });
1795
1796    /**
1797     * @tc.number HiAppEventWatcherTest016
1798     * @tc.name: HiAppEventWatcherTest016
1799     * @tc.desc: watcher.onReceive test.
1800     * @tc.type: FUNC
1801     * @tc.require: issueI5KYYI
1802     */
1803    it('HiAppEventWatcherTest016', 0, async function (done) {
1804        console.info('HiAppEventWatcherTest016 start');
1805        let result = true;
1806        let watcher1 = {
1807            name: "watcheros1",
1808            appEventFilters: [
1809                {
1810                    domain: hiAppEventV9.domain.OS,
1811                    names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"]
1812                },
1813            ],
1814            onReceive: simpleReceive
1815        };
1816        result = hiAppEventV9.addWatcher(watcher1);
1817        expect(result != null).assertTrue();
1818
1819        let watcher2 = {
1820            name: "watcheros2",
1821            appEventFilters: [
1822                {
1823                    domain: hiAppEventV9.domain.OS,
1824                    names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"]
1825                },
1826            ],
1827            onReceive: simpleReceive,
1828            onTrigger: simpleTrigger
1829        };
1830        result = hiAppEventV9.addWatcher(watcher2);
1831        expect(result != null).assertTrue();
1832
1833        let watcher3 = {
1834            name: "watcheros3",
1835            appEventFilters: [
1836                {
1837                    domain: hiAppEventV9.domain.OS,
1838                    names: [hiAppEventV9.event.APP_CRASH, hiAppEventV9.event.APP_FREEZE, "APP_START"]
1839                },
1840            ],
1841            onTrigger: simpleTrigger
1842        };
1843        result = hiAppEventV9.addWatcher(watcher3);
1844        expect(result != null).assertTrue();
1845
1846        setTimeout(() => {
1847            hiAppEventV9.removeWatcher(watcher1);
1848            hiAppEventV9.removeWatcher(watcher2);
1849            hiAppEventV9.removeWatcher(watcher3);
1850            console.info('HiAppEventWatcherTest016 end');
1851            done();
1852        }, 1000);
1853    });
1854});