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
22 using namespace OHOS::HiviewDFX;
23 using namespace testing::ext;
24
25 namespace {
26 const char TEST_DOMAIN[] = "TEST_DOMAIN";
27 const char TEST_NAME[] = "TEST_NAME";
28 }
29
SetUp()30 void HiSysEventCTest::SetUp()
31 {}
32
TearDown()33 void 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 */
42 HWTEST_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 */
193 HWTEST_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 */
303 HWTEST_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 */
336 HWTEST_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 */
402 HWTEST_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 */
436 HWTEST_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 */
470 HWTEST_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 */
534 HWTEST_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 */
564 HWTEST_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 */
609 HWTEST_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 */
638 HWTEST_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 */
671 HWTEST_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