1/*
2 * Copyright (c) 2022-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#include "hisysevent_c_test.h"
16
17#include <climits>
18#include <securec.h>
19#include "def.h"
20#include "hisysevent_c.h"
21
22using namespace OHOS::HiviewDFX;
23using namespace testing::ext;
24
25namespace {
26const char TEST_DOMAIN[] = "TEST_DOMAIN";
27const char TEST_NAME[] = "TEST_NAME";
28}
29
30void HiSysEventCTest::SetUp()
31{}
32
33void HiSysEventCTest::TearDown()
34{}
35
36/**
37 * @tc.name: HiSysEventCTest001
38 * @tc.desc: Test writing of basic type data.
39 * @tc.type: FUNC
40 * @tc.require: issueI5O9JB
41 */
42HWTEST_F(HiSysEventCTest, HiSysEventCTest001, TestSize.Level3)
43{
44    /**
45     * @tc.steps: step1. create event.
46     * @tc.steps: step2. write event.
47     * @tc.steps: step3. check the result of writing.
48     */
49    HiSysEventParam param1 = {
50        .name = "KEY_BOOL_F",
51        .t = HISYSEVENT_BOOL,
52        .v = { .b = false },
53        .arraySize = 0,
54    };
55    HiSysEventParam param2 = {
56        .name = "KEY_BOOL_T",
57        .t = HISYSEVENT_BOOL,
58        .v = { .b = true },
59        .arraySize = 0,
60    };
61    HiSysEventParam param3 = {
62        .name = "KEY_INT8_MIN",
63        .t = HISYSEVENT_INT8,
64        .v = { .i8 = SCHAR_MIN },
65        .arraySize = 0,
66    };
67    HiSysEventParam param4 = {
68        .name = "KEY_INT8_MAX",
69        .t = HISYSEVENT_INT8,
70        .v = { .i8 = SCHAR_MAX },
71        .arraySize = 0,
72    };
73    HiSysEventParam param5 = {
74        .name = "KEY_UINT8_MIN",
75        .t = HISYSEVENT_UINT8,
76        .v = { .ui8 = 0 },
77        .arraySize = 0,
78    };
79    HiSysEventParam param6 = {
80        .name = "KEY_UINT8_MAX",
81        .t = HISYSEVENT_UINT8,
82        .v = { .ui8 = UCHAR_MAX },
83        .arraySize = 0,
84    };
85    HiSysEventParam param7 = {
86        .name = "KEY_INT16_MIN",
87        .t = HISYSEVENT_INT16,
88        .v = { .i16 = SHRT_MIN },
89        .arraySize = 0,
90    };
91    HiSysEventParam param8 = {
92        .name = "KEY_INT16_MAX",
93        .t = HISYSEVENT_INT16,
94        .v = { .i16 = SHRT_MAX },
95        .arraySize = 0,
96    };
97    HiSysEventParam param9 = {
98        .name = "KEY_UINT16_MIN",
99        .t = HISYSEVENT_UINT16,
100        .v = { .ui16 = 0 },
101        .arraySize = 0,
102    };
103    HiSysEventParam param10 = {
104        .name = "KEY_UINT16_MAX",
105        .t = HISYSEVENT_UINT16,
106        .v = { .ui16 = USHRT_MAX },
107        .arraySize = 0,
108    };
109    HiSysEventParam param11 = {
110        .name = "KEY_INT32_MIN",
111        .t = HISYSEVENT_INT32,
112        .v = { .i32 = INT_MIN },
113        .arraySize = 0,
114    };
115    HiSysEventParam param12 = {
116        .name = "KEY_INT32_MAX",
117        .t = HISYSEVENT_INT32,
118        .v = { .i32 = INT_MAX },
119        .arraySize = 0,
120    };
121    HiSysEventParam param13 = {
122        .name = "KEY_UINT32_MIN",
123        .t = HISYSEVENT_UINT32,
124        .v = { .ui32 = 0 },
125        .arraySize = 0,
126    };
127    HiSysEventParam param14 = {
128        .name = "KEY_UINT32_MAX",
129        .t = HISYSEVENT_UINT32,
130        .v = { .ui32 = UINT_MAX },
131        .arraySize = 0,
132    };
133    HiSysEventParam param15 = {
134        .name = "KEY_INT64_MIN",
135        .t = HISYSEVENT_INT64,
136        .v = { .i64 = LLONG_MIN },
137        .arraySize = 0,
138    };
139    HiSysEventParam param16 = {
140        .name = "KEY_INT64_MAX",
141        .t = HISYSEVENT_INT64,
142        .v = { .i64 = LLONG_MAX },
143        .arraySize = 0,
144    };
145    HiSysEventParam param17 = {
146        .name = "KEY_UINT64_MIN",
147        .t = HISYSEVENT_UINT64,
148        .v = { .ui64 = 0 },
149        .arraySize = 0,
150    };
151    HiSysEventParam param18 = {
152        .name = "KEY_UINT64_MAX",
153        .t = HISYSEVENT_UINT64,
154        .v = { .ui64 = ULLONG_MAX },
155        .arraySize = 0,
156    };
157    HiSysEventParam param19 = {
158        .name = "KEY_FLOAT",
159        .t = HISYSEVENT_FLOAT,
160        .v = { .f = 123.456 },
161        .arraySize = 0,
162    };
163    HiSysEventParam param20 = {
164        .name = "KEY_DOUBLE",
165        .t = HISYSEVENT_DOUBLE,
166        .v = { .d = 123.456789 },
167        .arraySize = 0,
168    };
169    char testStr[] = "STR_VALUE";
170    HiSysEventParam param21 = {
171        .name = "KEY_STRING",
172        .t = HISYSEVENT_STRING,
173        .v = { .s = testStr },
174        .arraySize = 0,
175    };
176
177    HiSysEventParam params[] = {
178        param1, param2, param3, param4, param5, param6, param7,
179        param8, param9, param10, param11, param12, param13, param14,
180        param15, param16, param17, param18, param19, param20, param21,
181    };
182    size_t len = sizeof(params) / sizeof(params[0]);
183    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_FAULT, params, len);
184    ASSERT_EQ(res, 0);
185}
186
187/**
188 * @tc.name: HiSysEventCTest002
189 * @tc.desc: Test writing of array type data.
190 * @tc.type: FUNC
191 * @tc.require: issueI5O9JB
192 */
193HWTEST_F(HiSysEventCTest, HiSysEventCTest002, TestSize.Level3)
194{
195    /**
196     * @tc.steps: step1. create event.
197     * @tc.steps: step2. write event.
198     * @tc.steps: step3. check the result of writing.
199     */
200    bool bArr[] = { true, false };
201    HiSysEventParam param1 = {
202        .name = "KEY_BOOL_ARR",
203        .t = HISYSEVENT_BOOL_ARRAY,
204        .v = { .array = bArr },
205        .arraySize = sizeof(bArr) / sizeof(bArr[0]),
206    };
207    int8_t int8Arr[] = { -1, 2, -3 };
208    HiSysEventParam param2 = {
209        .name = "KEY_INT8_ARR",
210        .t = HISYSEVENT_INT8_ARRAY,
211        .v = { .array = int8Arr },
212        .arraySize = sizeof(int8Arr) / sizeof(int8Arr[0]),
213    };
214    uint8_t uint8Arr[] = { 4, 5, 6 };
215    HiSysEventParam param3 = {
216        .name = "KEY_UINT8_ARR",
217        .t = HISYSEVENT_UINT8_ARRAY,
218        .v = { .array = uint8Arr },
219        .arraySize = sizeof(uint8Arr) / sizeof(uint8Arr[0]),
220    };
221    int16_t int16Arr[] = { -7, 8, -9 };
222    HiSysEventParam param4 = {
223        .name = "KEY_INT16_ARR",
224        .t = HISYSEVENT_INT16_ARRAY,
225        .v = { .array = int16Arr },
226        .arraySize = sizeof(int16Arr) / sizeof(int16Arr[0]),
227    };
228    uint16_t uint16Arr[] = { 10, 11, 12 };
229    HiSysEventParam param5 = {
230        .name = "KEY_UINT16_ARR",
231        .t = HISYSEVENT_UINT16_ARRAY,
232        .v = { .array = uint16Arr },
233        .arraySize = sizeof(uint16Arr) / sizeof(uint16Arr[0]),
234    };
235    int32_t int32Arr[] = { -13, 14, -15 };
236    HiSysEventParam param6 = {
237        .name = "KEY_INT32_ARR",
238        .t = HISYSEVENT_INT32_ARRAY,
239        .v = { .array = int32Arr },
240        .arraySize = sizeof(int32Arr) / sizeof(int32Arr[0]),
241    };
242    uint32_t uint32Arr[] = { 16, 17, 18 };
243    HiSysEventParam param7 = {
244        .name = "KEY_UINT32_ARR",
245        .t = HISYSEVENT_UINT32_ARRAY,
246        .v = { .array = uint32Arr },
247        .arraySize = sizeof(uint32Arr) / sizeof(uint32Arr[0]),
248    };
249    int64_t int64Arr[] = { -19, 20, -21 };
250    HiSysEventParam param8 = {
251        .name = "KEY_INT64_ARR",
252        .t = HISYSEVENT_INT64_ARRAY,
253        .v = { .array = int64Arr },
254        .arraySize = sizeof(int64Arr) / sizeof(int64Arr[0]),
255    };
256    uint64_t uint64Arr[] = { 22, 23, 24 };
257    HiSysEventParam param9 = {
258        .name = "KEY_UINT64_ARR",
259        .t = HISYSEVENT_UINT64_ARRAY,
260        .v = { .array = uint64Arr },
261        .arraySize = sizeof(uint64Arr) / sizeof(uint64Arr[0]),
262    };
263    float fArr[] = { 1.1, 2.2, 3.3 };
264    HiSysEventParam param10 = {
265        .name = "KEY_FLOAT_ARR",
266        .t = HISYSEVENT_FLOAT_ARRAY,
267        .v = { .array = fArr },
268        .arraySize = sizeof(fArr) / sizeof(fArr[0]),
269    };
270    double dArr[] = { 4.4, 5.5, 6.6 };
271    HiSysEventParam param11 = {
272        .name = "KEY_DOUBLE_ARR",
273        .t = HISYSEVENT_DOUBLE_ARRAY,
274        .v = { .array = dArr },
275        .arraySize = sizeof(dArr) / sizeof(dArr[0]),
276    };
277    char s1[] = "str1";
278    char s2[] = "str2";
279    char s3[] = "str3";
280    char* sArr[] = { s1, s2, s3 };
281    HiSysEventParam param12 = {
282        .name = "KEY_STRING_ARR",
283        .t = HISYSEVENT_STRING_ARRAY,
284        .v = { .array = sArr },
285        .arraySize = sizeof(sArr) / sizeof(sArr[0]),
286    };
287
288    HiSysEventParam params[] = {
289        param1, param2, param3, param4, param5, param6,
290        param7, param8, param9, param10, param11, param12,
291    };
292    size_t len = sizeof(params) / sizeof(params[0]);
293    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_STATISTIC, params, len);
294    ASSERT_EQ(res, 0);
295}
296
297/**
298 * @tc.name: HiSysEventCTest003
299 * @tc.desc: Test writing of base data.
300 * @tc.type: FUNC
301 * @tc.require: issueI5O9JB
302 */
303HWTEST_F(HiSysEventCTest, HiSysEventCTest003, TestSize.Level3)
304{
305    /**
306     * @tc.steps: step1. create event.
307     * @tc.steps: step2. write event.
308     * @tc.steps: step3. check the result of writing.
309     */
310    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
311    ASSERT_EQ(res, 0);
312
313    HiSysEventParam params1[] = {};
314    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_SECURITY, params1, 0);
315    ASSERT_EQ(res, 0);
316
317    char* sArr[] = {};
318    HiSysEventParam param = {
319        .name = "KEY_STRING_ARR",
320        .t = HISYSEVENT_STRING_ARRAY,
321        .v = { .array = sArr },
322        .arraySize = sizeof(sArr) / sizeof(sArr[0]),
323    };
324    HiSysEventParam params2[] = { param };
325    size_t len = sizeof(params2) / sizeof(params2[0]);
326    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params2, len);
327    ASSERT_EQ(res, 0);
328}
329
330/**
331 * @tc.name: HiSysEventCTest004
332 * @tc.desc: Test writing of invalid data.
333 * @tc.type: FUNC
334 * @tc.require: issueI5O9JB
335 */
336HWTEST_F(HiSysEventCTest, HiSysEventCTest004, TestSize.Level3)
337{
338    /**
339     * @tc.steps: step1. create event.
340     * @tc.steps: step2. write event.
341     * @tc.steps: step3. check the result of writing.
342     */
343    int res = OH_HiSysEvent_Write(nullptr, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
344    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
345
346    res = OH_HiSysEvent_Write(TEST_DOMAIN, nullptr, HISYSEVENT_SECURITY, nullptr, 0);
347    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
348
349    HiSysEventParam param = {
350        .name = "KEY_STRING",
351        .t = HISYSEVENT_STRING,
352        .v = { .s = nullptr },
353        .arraySize = 0,
354    };
355    HiSysEventParam params[] = { param };
356    size_t len = sizeof(params) / sizeof(params[0]);
357    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params, len);
358    ASSERT_EQ(res, ERR_VALUE_INVALID);
359
360    HiSysEventParam param1 = {
361        .name = "KEY_STRING_ARR",
362        .t = HISYSEVENT_STRING_ARRAY,
363        .v = { .array = nullptr },
364        .arraySize = 0,
365    };
366    HiSysEventParam params1[] = { param1 };
367    len = sizeof(params1) / sizeof(params1[0]);
368    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params1, len);
369    ASSERT_EQ(res, ERR_VALUE_INVALID);
370
371    HiSysEventParam param2 = {
372        .name = "KEY_INT32_ARR",
373        .t = HISYSEVENT_INT32_ARRAY,
374        .v = { .array = nullptr },
375        .arraySize = 2,
376    };
377    HiSysEventParam params2[] = { param2 };
378    len = sizeof(params2) / sizeof(params2[0]);
379    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params2, len);
380    ASSERT_EQ(res, ERR_VALUE_INVALID);
381
382    char c1[] = "str1";
383    char* strs[] = { nullptr,  c1 };
384    HiSysEventParam param3 = {
385        .name = "KEY_STRING_ARR",
386        .t = HISYSEVENT_STRING_ARRAY,
387        .v = { .array = strs },
388        .arraySize = 2,
389    };
390    HiSysEventParam params3[] = { param3 };
391    len = sizeof(params3) / sizeof(params3[0]);
392    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params3, len);
393    ASSERT_EQ(res, ERR_VALUE_INVALID);
394}
395
396/**
397 * @tc.name: HiSysEventCTest005
398 * @tc.desc: Test writing of invalid domain.
399 * @tc.type: FUNC
400 * @tc.require: issueI5O9JB
401 */
402HWTEST_F(HiSysEventCTest, HiSysEventCTest005, TestSize.Level3)
403{
404    /**
405     * @tc.steps: step1. create event.
406     * @tc.steps: step2. write event.
407     * @tc.steps: step3. check the result of writing.
408     */
409    const char* domain1 = "123domain";
410    int res = OH_HiSysEvent_Write(domain1, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
411    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
412
413    const char* domain2 = "_domain";
414    res = OH_HiSysEvent_Write(domain2, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
415    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
416
417    const char* domain3 = "";
418    res = OH_HiSysEvent_Write(domain3, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
419    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
420
421    std::string domain4(MAX_DOMAIN_LENGTH + 1, 'a');
422    res = OH_HiSysEvent_Write(domain4.c_str(), TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
423    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
424
425    const char* domain5 = "domain##5";
426    res = OH_HiSysEvent_Write(domain5, TEST_NAME, HISYSEVENT_SECURITY, nullptr, 0);
427    ASSERT_EQ(res, ERR_DOMAIN_NAME_INVALID);
428}
429
430/**
431 * @tc.name: HiSysEventCTest006
432 * @tc.desc: Test writing of invalid event name.
433 * @tc.type: FUNC
434 * @tc.require: issueI5O9JB
435 */
436HWTEST_F(HiSysEventCTest, HiSysEventCTest006, TestSize.Level3)
437{
438    /**
439     * @tc.steps: step1. create event.
440     * @tc.steps: step2. write event.
441     * @tc.steps: step3. check the result of writing.
442     */
443    const char* name1 = "123name";
444    int res = OH_HiSysEvent_Write(TEST_DOMAIN, name1, HISYSEVENT_SECURITY, nullptr, 0);
445    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
446
447    const char* name2 = "_name";
448    res = OH_HiSysEvent_Write(TEST_DOMAIN, name2, HISYSEVENT_SECURITY, nullptr, 0);
449    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
450
451    const char* name3 = "";
452    res = OH_HiSysEvent_Write(TEST_DOMAIN, name3, HISYSEVENT_SECURITY, nullptr, 0);
453    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
454
455    std::string name4(MAX_EVENT_NAME_LENGTH + 1, 'a');
456    res = OH_HiSysEvent_Write(TEST_DOMAIN, name4.c_str(), HISYSEVENT_SECURITY, nullptr, 0);
457    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
458
459    const char* name5 = "name##5";
460    res = OH_HiSysEvent_Write(TEST_DOMAIN, name5, HISYSEVENT_SECURITY, nullptr, 0);
461    ASSERT_EQ(res, ERR_EVENT_NAME_INVALID);
462}
463
464/**
465 * @tc.name: HiSysEventCTest007
466 * @tc.desc: Test writing of invalid key.
467 * @tc.type: FUNC
468 * @tc.require: issueI5O9JB
469 */
470HWTEST_F(HiSysEventCTest, HiSysEventCTest007, TestSize.Level3)
471{
472    /**
473     * @tc.steps: step1. create event.
474     * @tc.steps: step2. write event.
475     * @tc.steps: step3. check the result of writing.
476     */
477    HiSysEventParam param1 = {
478        .name = "",
479        .t = HISYSEVENT_INT32,
480        .v = { .i32 = 0 },
481        .arraySize = 0,
482    };
483    HiSysEventParam params1[] = { param1 };
484    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params1, 1);
485    ASSERT_EQ(res, ERR_KEY_NAME_INVALID);
486
487    HiSysEventParam param2 = {
488        .name = "_key1",
489        .t = HISYSEVENT_INT32,
490        .v = { .i32 = 0 },
491        .arraySize = 0,
492    };
493    HiSysEventParam params2[] = { param2 };
494    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params2, 1);
495    ASSERT_EQ(res, ERR_KEY_NAME_INVALID);
496
497    HiSysEventParam param3 = {
498        .name = "123_key2",
499        .t = HISYSEVENT_INT32,
500        .v = { .i32 = 0 },
501        .arraySize = 0,
502    };
503    HiSysEventParam params3[] = { param3 };
504    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params3, 1);
505    ASSERT_EQ(res, ERR_KEY_NAME_INVALID);
506
507    HiSysEventParam param4 = {
508        .name = "key3**",
509        .t = HISYSEVENT_INT32,
510        .v = { .i32 = 0 },
511        .arraySize = 0,
512    };
513    HiSysEventParam params4[] = { param4 };
514    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params4, 1);
515    ASSERT_EQ(res, ERR_KEY_NAME_INVALID);
516
517    HiSysEventParam param5 = {
518        .name = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
519        .t = HISYSEVENT_INT32,
520        .v = { .i32 = 0 },
521        .arraySize = 0,
522    };
523    HiSysEventParam params5[] = { param5 };
524    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params5, 1);
525    ASSERT_EQ(res, 0);
526}
527
528/**
529 * @tc.name: HiSysEventCTest008
530 * @tc.desc: Test writing of 129 params.
531 * @tc.type: FUNC
532 * @tc.require: issueI5O9JB
533 */
534HWTEST_F(HiSysEventCTest, HiSysEventCTest008, TestSize.Level3)
535{
536    /**
537     * @tc.steps: step1. create event.
538     * @tc.steps: step2. write event.
539     * @tc.steps: step3. check the result of writing.
540     */
541    HiSysEventParam params[MAX_PARAM_NUMBER + 1];
542    for (size_t i = 0; i <= MAX_PARAM_NUMBER; ++i) {
543        HiSysEventParam param = {
544            .t = HISYSEVENT_INT32,
545            .v = { .i32 = 0 },
546            .arraySize = 0,
547        };
548        std::string key = "key" + std::to_string(i);
549        if (strcpy_s(param.name, sizeof(param.name), key.c_str()) != EOK) {
550            ASSERT_TRUE(false);
551        }
552        params[i] = param;
553    }
554    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params, MAX_PARAM_NUMBER + 1);
555    ASSERT_EQ(res, ERR_KEY_NUMBER_TOO_MUCH);
556}
557
558/**
559 * @tc.name: HiSysEventCTest010
560 * @tc.desc: Test writing of long string params.
561 * @tc.type: FUNC
562 * @tc.require: issueI5O9JB
563 */
564HWTEST_F(HiSysEventCTest, HiSysEventCTest010, TestSize.Level3)
565{
566    /**
567     * @tc.steps: step1. create event.
568     * @tc.steps: step2. write event.
569     * @tc.steps: step3. check the result of writing.
570     */
571    size_t strLen = MAX_STRING_LENGTH + 1;
572    char* longStr = new char[strLen + 1];
573    for (size_t i = 0; i < strLen; ++i) {
574        longStr[i] = 'a';
575    }
576    longStr[strLen] = '\0';
577    HiSysEventParam param = {
578        .name = "KEY_STRING",
579        .t = HISYSEVENT_STRING,
580        .v = { .s = longStr },
581        .arraySize = 0,
582    };
583    HiSysEventParam params[] = { param };
584    size_t len = sizeof(params) / sizeof(params[0]);
585    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params, len);
586    ASSERT_EQ(res, ERR_VALUE_LENGTH_TOO_LONG);
587
588    char* srts[] = { longStr };
589    HiSysEventParam param2 = {
590        .name = "KEY_STRING_ARR",
591        .t = HISYSEVENT_STRING_ARRAY,
592        .v = { .array = srts },
593        .arraySize = 1,
594    };
595    HiSysEventParam params2[] = { param2 };
596    len = sizeof(params2) / sizeof(params2[0]);
597    res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params2, len);
598    ASSERT_EQ(res, ERR_VALUE_LENGTH_TOO_LONG);
599
600    delete[] longStr;
601}
602
603/**
604 * @tc.name: HiSysEventCTest011
605 * @tc.desc: Test writing of long array params.
606 * @tc.type: FUNC
607 * @tc.require: issueI5O9JB
608 */
609HWTEST_F(HiSysEventCTest, HiSysEventCTest011, TestSize.Level3)
610{
611    /**
612     * @tc.steps: step1. create event.
613     * @tc.steps: step2. write event.
614     * @tc.steps: step3. check the result of writing.
615     */
616    int32_t int32s[MAX_ARRAY_SIZE + 1] = { 0 };
617    for (size_t i = 0; i <= MAX_ARRAY_SIZE; ++i) {
618        int32s[i] = 1;
619    }
620    HiSysEventParam param = {
621        .name = "KEY_INT32_ARR",
622        .t = HISYSEVENT_INT32_ARRAY,
623        .v = { .array = int32s },
624        .arraySize = MAX_ARRAY_SIZE + 1,
625    };
626    HiSysEventParam params[] = { param };
627    size_t len = sizeof(params) / sizeof(params[0]);
628    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params, len);
629    ASSERT_EQ(res, ERR_ARRAY_TOO_MUCH);
630}
631
632/**
633 * @tc.name: HiSysEventCTest012
634 * @tc.desc: Test writing of oversize event.
635 * @tc.type: FUNC
636 * @tc.require: issueI5O9JB
637 */
638HWTEST_F(HiSysEventCTest, HiSysEventCTest012, TestSize.Level3)
639{
640    /**
641     * @tc.steps: step1. create event.
642     * @tc.steps: step2. write event.
643     * @tc.steps: step3. check the result of writing.
644     */
645    size_t strLen = MAX_STRING_LENGTH;
646    char* longStr = new char[strLen + 1];
647    for (size_t i = 0; i < strLen; ++i) {
648        longStr[i] = 'a';
649    }
650    longStr[strLen] = '\0';
651    char* srts[] = { longStr, longStr };
652    HiSysEventParam param = {
653        .name = "KEY_STRING_ARR",
654        .t = HISYSEVENT_STRING_ARRAY,
655        .v = { .array = srts },
656        .arraySize = 2,
657    };
658    HiSysEventParam params[] = { param };
659    size_t len = sizeof(params) / sizeof(params[0]);
660    int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, params, len);
661    ASSERT_EQ(res, ERR_OVER_SIZE);
662    delete[] longStr;
663}
664
665/**
666 * @tc.name: HiSysEventCTest013
667 * @tc.desc: Test writing events too frequently.
668 * @tc.type: FUNC
669 * @tc.require: issueI5O9JB
670 */
671HWTEST_F(HiSysEventCTest, HiSysEventCTest013, TestSize.Level3)
672{
673    /**
674     * @tc.steps: step1. create event.
675     * @tc.steps: step2. write event.
676     * @tc.steps: step3. check the result of writing.
677     */
678    for (int i = 0; i <= 100; i++) { // the frequency is limited to 100 events every 5 seconds
679        int res = OH_HiSysEvent_Write(TEST_DOMAIN, TEST_NAME, HISYSEVENT_BEHAVIOR, {}, 0);
680        if (i == 100) {
681            ASSERT_EQ(res, ERR_WRITE_IN_HIGH_FREQ);
682        } else {
683            ASSERT_EQ(res, 0);
684        }
685    }
686}
687