1 /*
2 * Copyright (c) 2021-2025 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
16 #include "hisysevent_native_test.h"
17
18 #include <functional>
19 #include <iosfwd>
20 #include <string>
21 #include <thread>
22 #include <unistd.h>
23 #include <vector>
24
25 #include "gtest/gtest-message.h"
26 #include "gtest/gtest-test-part.h"
27 #include "gtest/hwext/gtest-ext.h"
28 #include "gtest/hwext/gtest-tag.h"
29 #include "hilog/log.h"
30
31 #include "def.h"
32 #include "event_socket_factory.h"
33 #include "hisysevent.h"
34 #include "hisysevent_base_manager.h"
35 #include "hisysevent_manager.h"
36 #include "hisysevent_record.h"
37 #include "hisysevent_query_callback.h"
38 #include "hisysevent_listener.h"
39 #include "ret_code.h"
40 #include "rule_type.h"
41 #include "securec.h"
42
43 #ifndef SYS_EVENT_PARAMS
44 #define SYS_EVENT_PARAMS(A) "key"#A, 0 + (A), "keyA"#A, 1 + (A), "keyB"#A, 2 + (A), "keyC"#A, 3 + (A), \
45 "keyD"#A, 4 + (A), "keyE"#A, 5 + (A), "keyF"#A, 6 + (A), "keyG"#A, 7 + (A), "keyH"#A, 8 + (A), \
46 "keyI"#A, 9 + (A)
47 #endif
48 using namespace testing::ext;
49 using namespace OHOS::HiviewDFX;
50
51 #undef LOG_DOMAIN
52 #define LOG_DOMAIN 0xD002D08
53
54 #undef LOG_TAG
55 #define LOG_TAG "HISYSEVENT_NATIVE_TEST"
56
57 namespace {
58 constexpr char TEST_DOMAIN[] = "DEMO";
59 constexpr char TEST_DOMAIN2[] = "KERNEL_VENDOR";
WriteSysEventByMarcoInterface()60 int32_t WriteSysEventByMarcoInterface()
61 {
62 return HiSysEventWrite(TEST_DOMAIN, "DEMO_EVENTNAME", HiSysEvent::EventType::FAULT,
63 "PARAM_KEY", "PARAM_VAL");
64 }
65
66 class Watcher : public HiSysEventListener {
67 public:
Watcher()68 Watcher() {}
~Watcher()69 virtual ~Watcher() {}
70
OnEvent(std::shared_ptr<HiSysEventRecord> sysEvent)71 void OnEvent(std::shared_ptr<HiSysEventRecord> sysEvent) final
72 {
73 if (sysEvent == nullptr) {
74 return;
75 }
76 HILOG_DEBUG(LOG_CORE, "domain: %{public}s, eventName: %{public}s, eventType: %{public}d, extra: %{public}s.",
77 sysEvent->GetDomain().c_str(), sysEvent->GetEventName().c_str(), sysEvent->GetEventType(),
78 sysEvent->AsJson().c_str());
79 }
80
OnServiceDied()81 void OnServiceDied() final
82 {
83 HILOG_DEBUG(LOG_CORE, "OnServiceDied");
84 }
85 };
86
87 using OnQueryCallback = std::function<bool(std::shared_ptr<std::vector<HiSysEventRecord>>)>;
88 using OnCompleteCallback = std::function<bool(int32_t, int32_t)>;
89
90 class Querier : public HiSysEventQueryCallback {
91 public:
Querier(OnQueryCallback onQueryCallback=nullptr,OnCompleteCallback onCompleteCallback=nullptr)92 explicit Querier(OnQueryCallback onQueryCallback = nullptr, OnCompleteCallback onCompleteCallback = nullptr)
93 : onQueryCallback(onQueryCallback), onCompleteCallback(onCompleteCallback) {}
~Querier()94 virtual ~Querier() {}
95
OnQuery(std::shared_ptr<std::vector<HiSysEventRecord>> sysEvents)96 void OnQuery(std::shared_ptr<std::vector<HiSysEventRecord>> sysEvents) final
97 {
98 if (onQueryCallback != nullptr) {
99 ASSERT_TRUE(onQueryCallback(sysEvents));
100 }
101 }
102
OnComplete(int32_t reason,int32_t total)103 void OnComplete(int32_t reason, int32_t total) final
104 {
105 if (onCompleteCallback != nullptr) {
106 ASSERT_TRUE(onCompleteCallback(reason, total));
107 }
108 }
109
110 private:
111 OnQueryCallback onQueryCallback;
112 OnCompleteCallback onCompleteCallback;
113 };
114
BuildRawData(RawData & data,const std::string & domain,const std::string & name,HiSysEvent::EventType type)115 void BuildRawData(RawData& data, const std::string& domain, const std::string& name, HiSysEvent::EventType type)
116 {
117 struct Encoded::HiSysEventHeader header = {
118 {0}, {0}, 0, 0, 0, 0, 0, 0, 0, 0
119 };
120 auto ret = memcpy_s(header.domain, MAX_DOMAIN_LENGTH, domain.c_str(), domain.length());
121 ASSERT_EQ(ret, EOK);
122 header.domain[domain.length()] = '\0';
123 ret = memcpy_s(header.name, MAX_EVENT_NAME_LENGTH, name.c_str(), name.length());
124 ASSERT_EQ(ret, EOK);
125 header.name[name.length()] = '\0';
126 header.type = type - 1; // 1 is offset
127 int32_t len = sizeof(struct Encoded::HiSysEventHeader) + sizeof(int32_t);
128 (void)data.Update(reinterpret_cast<uint8_t*>(&len), sizeof(int32_t), 0);
129 (void)data.Update(reinterpret_cast<uint8_t*>(&header), sizeof(struct Encoded::HiSysEventHeader),
130 sizeof(int32_t));
131 }
132 }
133
WrapSysEventWriteAssertion(int32_t ret,bool cond)134 static bool WrapSysEventWriteAssertion(int32_t ret, bool cond)
135 {
136 return cond || ret == OHOS::HiviewDFX::ERR_SEND_FAIL ||
137 ret == OHOS::HiviewDFX::ERR_WRITE_IN_HIGH_FREQ ||
138 ret == OHOS::HiviewDFX::ERR_DOMAIN_MASKED ||
139 ret == OHOS::HiviewDFX::ERR_TOO_MANY_CONCURRENT_QUERIES ||
140 ret == OHOS::HiviewDFX::ERR_QUERY_TOO_FREQUENTLY;
141 }
142
SetUpTestCase(void)143 void HiSysEventNativeTest::SetUpTestCase(void)
144 {
145 }
146
TearDownTestCase(void)147 void HiSysEventNativeTest::TearDownTestCase(void)
148 {
149 }
150
SetUp(void)151 void HiSysEventNativeTest::SetUp(void)
152 {
153 }
154
TearDown(void)155 void HiSysEventNativeTest::TearDown(void)
156 {
157 }
158
159 /**
160 * @tc.name: TestHiSysEventManagerQueryWithInvalidQueryRules001
161 * @tc.desc: Query with query rules which contains empty domain
162 * @tc.type: FUNC
163 * @tc.require: issueI62B10
164 */
165 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerQueryWithInvalidQueryRules001, TestSize.Level1)
166 {
167 sleep(1);
168 auto querier = std::make_shared<Querier>();
169 long long defaultTimeStap = -1;
170 int queryCount = 10;
171 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
172 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
173 std::vector<std::string> eventNames {"EVENT_NAME"};
174 OHOS::HiviewDFX::QueryRule rule("", eventNames); // empty domain
175 queryRules.emplace_back(rule);
176 auto ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
177 // only process with root or shell uid return OHOS::HiviewDFX::IPC_CALL_SUCCEED
178 ASSERT_TRUE(ret == OHOS::HiviewDFX::ERR_QUERY_RULE_INVALID || ret == OHOS::HiviewDFX::IPC_CALL_SUCCEED);
179 }
180
181 /**
182 * @tc.name: TestHiSysEventManagerQueryWithInvalidQueryRules002
183 * @tc.desc: Query with query rules which contains empty event names
184 * @tc.type: FUNC
185 * @tc.require: issueI62B10
186 */
187 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerQueryWithInvalidQueryRules002, TestSize.Level1)
188 {
189 sleep(1);
190 auto querier = std::make_shared<Querier>();
191 long long defaultTimeStap = -1;
192 int queryCount = 10;
193 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
194 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
195 std::vector<std::string> eventNames; // empty event name
196 OHOS::HiviewDFX::QueryRule rule("DOMAIN", eventNames);
197 queryRules.emplace_back(rule);
198 auto ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
199 // only process with root or shell uid return OHOS::HiviewDFX::IPC_CALL_SUCCEED
200 ASSERT_TRUE(ret == OHOS::HiviewDFX::ERR_QUERY_RULE_INVALID || ret == OHOS::HiviewDFX::IPC_CALL_SUCCEED);
201 }
202
203 /**
204 * @tc.name: TestSubscribeSysEventByTag
205 * @tc.desc: Subscribe sysevent by event tag
206 * @tc.type: FUNC
207 * @tc.require: issueI62B10
208 */
209 HWTEST_F(HiSysEventNativeTest, TestSubscribeSysEventByTag, TestSize.Level1)
210 {
211 auto watcher = std::make_shared<Watcher>();
212 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "TAG", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
213 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
214 sysRules.emplace_back(listenerRule);
215 auto ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
216 ASSERT_EQ(ret, IPC_CALL_SUCCEED);
217 ret = OHOS::HiviewDFX::HiSysEventManager::RemoveListener(watcher);
218 ASSERT_EQ(ret, IPC_CALL_SUCCEED);
219 }
220
221 /**
222 * @tc.name: TestHiSysEventNormal001
223 * @tc.desc: Test normal write.
224 * @tc.type: FUNC
225 * @tc.require: AR000G2QKU AR000FT2Q1
226 */
227 HWTEST_F(HiSysEventNativeTest, TestHiSysEventNormal001, TestSize.Level1)
228 {
229 /**
230 * @tc.steps: step1.make sure SystemAbilityManager is started.
231 */
232 static constexpr char domain[] = "DEMO";
233 std::string eventName = "NORMAL001";
234
235 bool testBoolValue = true;
236 char testCharValue = 'a';
237 short testShortValue = -100;
238 int testIntValue = -200;
239 long testLongValue = -300;
240 long long testLongLongValue = -400;
241
242 unsigned char testUnsignedCharValue = 'a';
243 unsigned short testUnsignedShortValue = 100;
244 unsigned int testUnsignedIntValue = 200;
245 unsigned long testUnsignedLongValue = 300;
246 unsigned long long testUnsignedLongLongValue = 400;
247
248 float testFloatValue = 1.1;
249 double testDoubleValue = 2.2;
250 std::string testStringValue = "abc";
251
252 std::vector<bool> testBoolValues;
253 testBoolValues.push_back(true);
254 testBoolValues.push_back(true);
255 testBoolValues.push_back(false);
256
257 std::vector<char> testCharValues;
258 testCharValues.push_back('a');
259 testCharValues.push_back('b');
260 testCharValues.push_back('c');
261
262 std::vector<unsigned char> testUnsignedCharValues;
263 testUnsignedCharValues.push_back('a');
264 testUnsignedCharValues.push_back('b');
265 testUnsignedCharValues.push_back('c');
266
267 std::vector<short> testShortValues;
268 testShortValues.push_back(-100);
269 testShortValues.push_back(-200);
270 testShortValues.push_back(-300);
271
272 std::vector<unsigned short> testUnsignedShortValues;
273 testUnsignedShortValues.push_back(100);
274 testUnsignedShortValues.push_back(200);
275 testUnsignedShortValues.push_back(300);
276
277 std::vector<int> testIntValues;
278 testIntValues.push_back(-1000);
279 testIntValues.push_back(-2000);
280 testIntValues.push_back(-3000);
281
282 std::vector<unsigned int> testUnsignedIntValues;
283 testUnsignedIntValues.push_back(1000);
284 testUnsignedIntValues.push_back(2000);
285 testUnsignedIntValues.push_back(3000);
286
287 std::vector<long> testLongValues;
288 testLongValues.push_back(-10000);
289 testLongValues.push_back(-20000);
290 testLongValues.push_back(-30000);
291
292 std::vector<unsigned long> testUnsignedLongValues;
293 testUnsignedLongValues.push_back(10000);
294 testUnsignedLongValues.push_back(20000);
295 testUnsignedLongValues.push_back(30000);
296
297 std::vector<long long> testLongLongValues;
298 testLongLongValues.push_back(-100000);
299 testLongLongValues.push_back(-200000);
300 testLongLongValues.push_back(-300000);
301
302 std::vector<unsigned long long> testUnsignedLongLongValues;
303 testUnsignedLongLongValues.push_back(100000);
304 testUnsignedLongLongValues.push_back(200000);
305 testUnsignedLongLongValues.push_back(300000);
306
307 std::vector<float> testFloatValues;
308 testFloatValues.push_back(1.1);
309 testFloatValues.push_back(2.2);
310 testFloatValues.push_back(3.3);
311
312 std::vector<double> testDoubleValues;
313 testDoubleValues.push_back(10.1);
314 testDoubleValues.push_back(20.2);
315 testDoubleValues.push_back(30.3);
316
317 std::vector<std::string> testStringValues;
318 testStringValues.push_back(std::string("a"));
319 testStringValues.push_back(std::string("b"));
320 testStringValues.push_back(std::string("c"));
321
322 HILOG_INFO(LOG_CORE, "test hisysevent normal write");
323 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT,
324 "keyBool", testBoolValue, "keyChar", testCharValue, "keyShort", testShortValue,
325 "keyInt", testIntValue, "KeyLong", testLongValue, "KeyLongLong", testLongLongValue,
326 "keyUnsignedChar", testUnsignedCharValue, "keyUnsignedShort", testUnsignedShortValue,
327 "keyUnsignedInt", testUnsignedIntValue, "keyUnsignedLong", testUnsignedLongValue,
328 "keyUnsignedLongLong", testUnsignedLongLongValue, "keyFloat", testFloatValue,
329 "keyDouble", testDoubleValue, "keyString1", testStringValue, "keyString2", "efg",
330 "keyBools", testBoolValues, "keyChars", testCharValues, "keyUnsignedChars", testUnsignedCharValues,
331 "keyShorts", testShortValues, "keyUnsignedShorts", testUnsignedShortValues,
332 "keyInts", testIntValues, "keyUnsignedInts", testUnsignedIntValues, "keyLongs", testLongValues,
333 "keyUnsignedLongs", testUnsignedLongValues, "keyLongLongs", testLongLongValues,
334 "keyUnsignedLongLongs", testUnsignedLongLongValues, "keyFloats", testFloatValues,
335 "keyDoubles", testDoubleValues, "keyStrings", testStringValues);
336 HILOG_INFO(LOG_CORE, "normal write, retCode=%{public}d", result);
337 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
338 }
339
340 /**
341 * @tc.name: TestHiSysEventDomainSpecialChar002
342 * @tc.desc: Test domain has special char.
343 * @tc.type: FUNC
344 * @tc.require: AR000G2QKU AR000FT2Q1
345 */
346 HWTEST_F(HiSysEventNativeTest, TestHiSysEventDomainSpecialChar002, TestSize.Level1)
347 {
348 /**
349 * @tc.steps: step1.make sure write sys event.
350 */
351 static constexpr char domain[] = "_demo";
352 std::string eventName = "DOMAIN_SPECIAL_CHAR";
353 HILOG_INFO(LOG_CORE, "test hisysevent domain has special char");
354 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT);
355 HILOG_INFO(LOG_CORE, "domain has special char, retCode=%{public}d", result);
356 ASSERT_LT(result, 0);
357 }
358
359 /**
360 * @tc.name: TestHiSysEventDomainEmpty003
361 * @tc.desc: Test domain is empty.
362 * @tc.type: FUNC
363 * @tc.require: AR000G2QKU AR000FT2Q1
364 */
365 HWTEST_F(HiSysEventNativeTest, TestHiSysEventDomainEmpty003, TestSize.Level1)
366 {
367 /**
368 * @tc.steps: step1.make sure write sys event.
369 */
370 static constexpr char domain[] = "";
371 std::string eventName = "DOMAIN_EMPTY";
372 HILOG_INFO(LOG_CORE, "test hisysevent domain is empty");
373 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT);
374 HILOG_INFO(LOG_CORE, "domain is empty, retCode=%{public}d", result);
375 ASSERT_LT(result, 0);
376 }
377
378 /**
379 * @tc.name: TestHiSysEventDomainTooLong004
380 * @tc.desc: Test domain is too long.
381 * @tc.type: FUNC
382 * @tc.require: AR000G2QKU AR000FT2Q1
383 */
384 HWTEST_F(HiSysEventNativeTest, TestHiSysEventDomainTooLong004, TestSize.Level1)
385 {
386 /**
387 * @tc.steps: step1.make sure write sys event.
388 */
389 static constexpr char domain16[] = "AAAAAAAAAAAAAAAA";
390 std::string eventName = "DOMAIN_TOO_LONG_16";
391 HILOG_INFO(LOG_CORE, "test hisysevent domain is too long, normal length");
392
393 int result = 0;
394 result = HiSysEventWrite(domain16, eventName, HiSysEvent::EventType::FAULT);
395 HILOG_INFO(LOG_CORE, "domain too long, equal 16 retCode=%{public}d", result);
396
397 HILOG_INFO(LOG_CORE, "test hisysevent domain is too long");
398 static constexpr char domain17[] = "AAAAAAAAAAAAAAAAL";
399 eventName = "DOMAIN_TOO_LONG_17";
400 result = HiSysEventWrite(domain17, eventName, HiSysEvent::EventType::FAULT);
401 HILOG_INFO(LOG_CORE, "domain is too long, more than 16 retCode=%{public}d", result);
402 ASSERT_LT(result, 0);
403 }
404
405 /**
406 * @tc.name: TesetHiSysEventSpecailEventName005
407 * @tc.desc: Test event name has special char.
408 * @tc.type: FUNC
409 * @tc.require: AR000G2QKU AR000FT2Q1
410 */
411 HWTEST_F(HiSysEventNativeTest, TesetHiSysEventSpecailEventName005, TestSize.Level1)
412 {
413 /**
414 * @tc.steps: step1.make sure write sys event.
415 */
416 static constexpr char domain[] = "SPEC_EVT_NAME";
417 std::string eventName = "_SPECIAL_CHAR";
418 HILOG_INFO(LOG_CORE, "test hisysevent event name has special char");
419 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT);
420 HILOG_INFO(LOG_CORE, "event name has special char, retCode=%{public}d", result);
421 ASSERT_LT(result, 0);
422 }
423
424 /**
425 * @tc.name: TestHiSysEventNameEmpty006
426 * @tc.desc: Test event name is empty.
427 * @tc.type: FUNC
428 * @tc.require: AR000G2QKU AR000FT2Q1
429 */
430 HWTEST_F(HiSysEventNativeTest, TestHiSysEventNameEmpty006, TestSize.Level1)
431 {
432 /**
433 * @tc.steps: step1.make sure write sys event.
434 */
435 static constexpr char domain[] = "EMPTY";
436 std::string eventName = "";
437 HILOG_INFO(LOG_CORE, "test hisysevent event name is empty");
438 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT);
439 HILOG_INFO(LOG_CORE, "event name is empty, retCode=%{public}d", result);
440 ASSERT_LT(result, 0);
441 }
442
443 /**
444 * @tc.name: TesetHiSysEventNameTooLong007
445 * @tc.desc: Test event name too long.
446 * @tc.type: FUNC
447 * @tc.require: AR000G2QKU AR000FT2Q1
448 */
449 HWTEST_F(HiSysEventNativeTest, TesetHiSysEventNameTooLong007, TestSize.Level1)
450 {
451 /**
452 * @tc.steps: step1.make sure write sys event.
453 */
454 static constexpr char domain32[] = "NAME_32";
455 std::string eventName = "";
456 HILOG_INFO(LOG_CORE, "test hisysevent event name is too long, normal length");
457 int normal = 32;
458 for (int index = 0; index < normal; index++) {
459 eventName.append("N");
460 }
461 int result = 0;
462 result = HiSysEventWrite(domain32, eventName, HiSysEvent::EventType::FAULT);
463 HILOG_INFO(LOG_CORE, "event name is too long, equal 32, retCode=%{public}d", result);
464 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
465
466 HILOG_INFO(LOG_CORE, "test hisysevent event name is too long");
467 static constexpr char domain33[] = "NAME_33";
468 eventName.append("L");
469 result = HiSysEventWrite(domain33, eventName, HiSysEvent::EventType::FAULT);
470 HILOG_INFO(LOG_CORE, "event name is too long, more than 32, retCode=%{public}d", result);
471 ASSERT_LT(result, 0);
472 }
473
474 /**
475 * @tc.name: TestHiSysEventKeySpecialChar008
476 * @tc.desc: Test key has specail char.
477 * @tc.type: FUNC
478 * @tc.require: AR000G2QKU AR000FT2Q1
479 */
480 HWTEST_F(HiSysEventNativeTest, TestHiSysEventKeySpecialChar008, TestSize.Level1)
481 {
482 /**
483 * @tc.steps: step1.make sure write sys event.
484 */
485 static constexpr char domain[] = "DEMO";
486 std::string eventName = "HiSysEvent006";
487 std::string key1 = "_key1";
488 std::string key2 = "key2";
489 int result = 0;
490 HILOG_INFO(LOG_CORE, "test hisysevent key has special char");
491 bool value1 = true;
492 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value1, key2, value1);
493 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
494
495 short value2 = 2;
496 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value2, key2, value2);
497 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
498
499 unsigned short value3 = 3;
500 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value3, key2, value3);
501 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
502
503 int value4 = 4;
504 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value4, key2, value4);
505 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
506
507 unsigned int value5 = 5;
508 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value5, key2, value5);
509 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
510
511 long value6 = 6;
512 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value6, key2, value6);
513 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
514
515 unsigned long value7 = 7;
516 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value7, key2, value7);
517 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
518
519 long long value8 = 8;
520 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value8, key2, value8);
521 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
522
523 unsigned long long value9 = 9;
524 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value9, key2, value9);
525 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
526
527 char value10 = 'a';
528 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value10, key2, value10);
529 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
530
531 unsigned char value11 = 'b';
532 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value11, key2, value11);
533 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
534
535 float value12 = 12.12;
536 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value12, key2, value12);
537 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
538
539 double value13 = 13.13;
540 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key1, value13, key2, value13);
541 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
542 }
543
544
545 /**
546 * @tc.name: TestHiSysEventEscape009
547 * @tc.desc: Test key's value need escape.
548 * @tc.type: FUNC
549 * @tc.require: AR000G2QKU AR000FT2Q1
550 */
551 HWTEST_F(HiSysEventNativeTest, TestHiSysEventEscape009, TestSize.Level1)
552 {
553 /**
554 * @tc.steps: step1.make sure write sys event.
555 */
556 static constexpr char domain[] = "DEMO";
557 std::string eventName = "ESCAPE";
558 HILOG_INFO(LOG_CORE, "test hisysevent escape char");
559 std::string value = "\"escapeByCpp\"";
560 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", value);
561 HILOG_INFO(LOG_CORE, "key's value has espcae char, retCode=%{public}d", result);
562 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
563 }
564
565 /**
566 * @tc.name: TestHiSysEventKeyEmpty010
567 * @tc.desc: Test key is empty.
568 * @tc.type: FUNC
569 * @tc.require: AR000G2QKU AR000FT2Q1
570 */
571 HWTEST_F(HiSysEventNativeTest, TestHiSysEventKeyEmpty010, TestSize.Level1)
572 {
573 /**
574 * @tc.steps: step1.make sure write sys event.
575 */
576 static constexpr char domain[] = "DEMO";
577 std::string eventName = "KEY_EMPTY";
578 HILOG_INFO(LOG_CORE, "test hisysevent key is empty");
579 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT,
580 "", "valueIsEmpty", "key2", "notEmpty");
581 HILOG_INFO(LOG_CORE, "key is empty, retCode=%{public}d", result);
582 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
583 }
584
585 /**
586 * @tc.name: TestHiSysEventKeySpecialChar011
587 * @tc.desc: Test key has special char.
588 * @tc.type: FUNC
589 * @tc.require: AR000G2QKU AR000FT2Q1
590 */
591 HWTEST_F(HiSysEventNativeTest, TestHiSysEventKeySpecialChar011, TestSize.Level1)
592 {
593 /**
594 * @tc.steps: step1.make sure write sys event.
595 */
596 static constexpr char domain[] = "DEMO";
597 std::string eventName = "KEY_SPECIAL_CHAR";
598 HILOG_INFO(LOG_CORE, "test hisysevent key is special");
599 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT,
600 "_key1", "special", "key2", "normal");
601 HILOG_INFO(LOG_CORE, "key has special char, retCode=%{public}d", result);
602 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
603 }
604
605 /**
606 * @tc.name: TestHiSysEventKeyTooLong012
607 * @tc.desc: Test key is too long.
608 * @tc.type: FUNC
609 * @tc.require: AR000G2QKU AR000FT2Q1
610 */
611 HWTEST_F(HiSysEventNativeTest, TestHiSysEventKeyTooLong012, TestSize.Level1)
612 {
613 /**
614 * @tc.steps: step1.make sure write sys event.
615 */
616 static constexpr char domain[] = "DEMO";
617 std::string eventName = "KEY_48";
618 HILOG_INFO(LOG_CORE, "test hisysevent key 48 char");
619 std::string key = "";
620 int normal = 48;
621 for (int index = 0; index < normal; index++) {
622 key.append("V");
623 }
624 int result = 0;
625 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key, "48length", "key2", "normal");
626 HILOG_INFO(LOG_CORE, "key equal 48 char, retCode=%{public}d", result);
627 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
628
629 HILOG_INFO(LOG_CORE, "test hisysevent key 49 char");
630 eventName = "KEY_49";
631 key.append("V");
632 result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, key, "49length", "key2", "normal");
633 HILOG_INFO(LOG_CORE, "key more than 48 char, retCode=%{public}d", result);
634 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
635 }
636
637 /**
638 * @tc.name: TestHiSysEvent128Keys013
639 * @tc.desc: Test 128 key.
640 * @tc.type: FUNC
641 * @tc.require: AR000G2QKU AR000FT2Q1
642 */
643 HWTEST_F(HiSysEventNativeTest, TestHiSysEvent128Keys013, TestSize.Level1)
644 {
645 /**
646 * @tc.steps: step1.make sure write sys event.
647 */
648 static constexpr char domain[] = "TEST";
649 std::string eventName = "KEY_EQUAL_128";
650 HILOG_INFO(LOG_CORE, "test hisysevent 128 keys");
651 std::string k = "k";
652 bool v = true;
653 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT,
654 SYS_EVENT_PARAMS(10), SYS_EVENT_PARAMS(20), SYS_EVENT_PARAMS(30), SYS_EVENT_PARAMS(40), SYS_EVENT_PARAMS(50),
655 SYS_EVENT_PARAMS(60), SYS_EVENT_PARAMS(70), SYS_EVENT_PARAMS(80), SYS_EVENT_PARAMS(90), SYS_EVENT_PARAMS(100),
656 SYS_EVENT_PARAMS(110), SYS_EVENT_PARAMS(120),
657 k, v, k, v, k, v, k, v, k, v, k, v, k, v, k, v);
658 HILOG_INFO(LOG_CORE, "has 128 key, retCode=%{public}d", result);
659 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
660 }
661
662 /**
663 * @tc.name: TestHiSysEvent129Keys014
664 * @tc.desc: Test 129 key.
665 * @tc.type: FUNC
666 * @tc.require: AR000G2QKU AR000FT2Q1
667 */
668 HWTEST_F(HiSysEventNativeTest, TestHiSysEvent129Keys014, TestSize.Level1)
669 {
670 /**
671 * @tc.steps: step1.make sure write sys event.
672 */
673 static constexpr char domain[] = "TEST";
674 std::string eventName = "KEY_EQUAL_129";
675 HILOG_INFO(LOG_CORE, "test hisysevent 129 key");
676 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT,
677 SYS_EVENT_PARAMS(10), SYS_EVENT_PARAMS(20), SYS_EVENT_PARAMS(30), SYS_EVENT_PARAMS(40), SYS_EVENT_PARAMS(50),
678 SYS_EVENT_PARAMS(60), SYS_EVENT_PARAMS(70), SYS_EVENT_PARAMS(80), SYS_EVENT_PARAMS(90), SYS_EVENT_PARAMS(100),
679 SYS_EVENT_PARAMS(110), SYS_EVENT_PARAMS(120),
680 "key1", true, "key2", true, "key3", true, "key4", true, "key5", true,
681 "key6", true, "key7", true, "key8", true, "key9", true);
682 HILOG_INFO(LOG_CORE, "has 129 key, retCode=%{public}d", result);
683 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
684 }
685
686 /**
687 * @tc.name: TestHiSysEventStringValueEqual256K015
688 * @tc.desc: Test 256K string.
689 * @tc.type: FUNC
690 * @tc.require: AR000G2QKU AR000FT2Q1
691 */
692 HWTEST_F(HiSysEventNativeTest, TestHiSysEventStringValueEqual256K015, TestSize.Level1)
693 {
694 /**
695 * @tc.steps: step1.make sure write sys event.
696 */
697 static constexpr char domain[] = "TEST";
698 std::string eventName = "EQUAL_256K";
699 HILOG_INFO(LOG_CORE, "test key's value 256K string");
700 std::string value;
701 int length = 256 * 1024;
702 for (int index = 0; index < length; index++) {
703 value.push_back('1' + index % 10);
704 }
705 sleep(1); // make sure hiview read all data before send large data
706 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", value);
707 HILOG_INFO(LOG_CORE, "string length is 256K, retCode=%{public}d", result);
708 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
709 }
710
711 /**
712 * @tc.name: TestHiSysEventStringValueMoreThan256K016
713 * @tc.desc: Test 256K + 1 string.
714 * @tc.type: FUNC
715 * @tc.require: AR000G2QKU AR000FT2Q1
716 */
717 HWTEST_F(HiSysEventNativeTest, TestHiSysEventStringValueMoreThan256K016, TestSize.Level1)
718 {
719 /**
720 * @tc.steps: step1.make sure write sys event.
721 */
722 static constexpr char domain[] = "DEMO";
723 std::string eventName = "MORETHAN256K";
724 HILOG_INFO(LOG_CORE, "test more than 256K string");
725 std::string value;
726 int length = 256 * 1024 + 1;
727 for (int index = 0; index < length; index++) {
728 value.push_back('1' + index % 10);
729 }
730 sleep(1); // make sure hiview read all data before send large data
731 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", value);
732 HILOG_INFO(LOG_CORE, "string length is more than 256K, retCode=%{public}d", result);
733 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
734 }
735
736 /**
737 * @tc.name: TestHiSysEventArray100Item017
738 * @tc.desc: Test bool array item 100.
739 * @tc.type: FUNC
740 * @tc.require: AR000G2QKU AR000FT2Q1
741 */
742 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray100Item017, TestSize.Level1)
743 {
744 /**
745 * @tc.steps: step1.make sure write sys event.
746 */
747 static constexpr char domain[] = "DEMO";
748 std::string eventName = "BOOL_ARRAY_100";
749 HILOG_INFO(LOG_CORE, "test bool array 100 item");
750 std::vector<bool> values;
751 int maxItem = 100;
752 for (int index = 0; index < maxItem; index++) {
753 values.push_back(true);
754 }
755 sleep(1); // make sure hiview read all data before send large data
756 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
757 HILOG_INFO(LOG_CORE, "array bool list 100, retCode=%{public}d", result);
758 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
759 }
760
761 /**
762 * @tc.name: TestHiSysEventArray101Item018
763 * @tc.desc: Test bool array item 101.
764 * @tc.type: FUNC
765 * @tc.require: AR000G2QKU AR000FT2Q1
766 */
767 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray101Item018, TestSize.Level1)
768 {
769 /**
770 * @tc.steps: step1.make sure write sys event.
771 */
772 static constexpr char domain[] = "DEMO";
773 std::string eventName = "BOOL_ARRAY_101";
774 HILOG_INFO(LOG_CORE, "test bool array 101 item");
775 std::vector<bool> values;
776 int maxItem = 101;
777 for (int index = 0; index < maxItem; index++) {
778 values.push_back(true);
779 }
780 sleep(1); // make sure hiview read all data before send large data
781 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
782 HILOG_INFO(LOG_CORE, "array bool list 101, retCode=%{public}d", result);
783 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
784 }
785
786 /**
787 * @tc.name: TestHiSysEventArray100CharItem019
788 * @tc.desc: Test char array item 100.
789 * @tc.type: FUNC
790 * @tc.require: AR000G2QKU AR000FT2Q1
791 */
792 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray100CharItem019, TestSize.Level1)
793 {
794 /**
795 * @tc.steps: step1.make sure write sys event.
796 */
797 static constexpr char domain[] = "DEMO";
798 std::string eventName = "CHAR_ARRAY_100";
799 HILOG_INFO(LOG_CORE, "test char array 100 item");
800 std::vector<char> values;
801 int maxItem = 100;
802 for (int index = 0; index < maxItem; index++) {
803 values.push_back('a');
804 }
805 sleep(1); // make sure hiview read all data before send large data
806 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
807 HILOG_INFO(LOG_CORE, "array char list 100, retCode=%{public}d", result);
808 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
809 }
810
811 /**
812 * @tc.name: TestHiSysEventArray101CharItem020
813 * @tc.desc: Test char array item 101.
814 * @tc.type: FUNC
815 * @tc.require: AR000G2QKU AR000FT2Q1
816 */
817 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray101CharItem020, TestSize.Level1)
818 {
819 /**
820 * @tc.steps: step1.make sure write sys event.
821 */
822 static constexpr char domain[] = "DEMO";
823 std::string eventName = "CHAR_ARRAY_101";
824 HILOG_INFO(LOG_CORE, "test char array 101 item");
825 std::vector<char> values;
826 int maxItem = 101;
827 for (int index = 0; index < maxItem; index++) {
828 values.push_back('z');
829 }
830 sleep(1); // make sure hiview read all data before send large data
831 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
832 HILOG_INFO(LOG_CORE, "array char list 101, retCode=%{public}d", result);
833 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
834 }
835
836 /**
837 * @tc.name: TestHiSysEventArray100UnsignedCharItem021
838 * @tc.desc: Test unsigned char array item 100.
839 * @tc.type: FUNC
840 * @tc.require: AR000G2QKU AR000FT2Q1
841 */
842 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray100UnsignedCharItem021, TestSize.Level1)
843 {
844 /**
845 * @tc.steps: step1.make sure write sys event.
846 */
847 static constexpr char domain[] = "DEMO";
848 std::string eventName = "UCHAR_ARRAY_100";
849 HILOG_INFO(LOG_CORE, "test unsigned char array 100 item");
850 std::vector<unsigned char> values;
851 int maxItem = 100;
852 for (int index = 0; index < maxItem; index++) {
853 values.push_back('a');
854 }
855 sleep(1); // make sure hiview read all data before send large data
856 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
857 HILOG_INFO(LOG_CORE, "array unsigned char list 100, retCode=%{public}d", result);
858 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
859 }
860
861 /**
862 * @tc.name: TestHiSysEventArray101UnsignedCharItem022
863 * @tc.desc: Test unsigned char array item 101.
864 * @tc.type: FUNC
865 * @tc.require: AR000G2QKU AR000FT2Q1
866 */
867 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray101UnsignedCharItem022, TestSize.Level1)
868 {
869 /**
870 * @tc.steps: step1.make sure write sys event.
871 */
872 static constexpr char domain[] = "DEMO";
873 std::string eventName = "UCHAR_ARRAY_101";
874 HILOG_INFO(LOG_CORE, "test unsigned char array 101 item");
875 std::vector<unsigned char> values;
876 int maxItem = 101;
877 for (int index = 0; index < maxItem; index++) {
878 values.push_back('z');
879 }
880 sleep(1); // make sure hiview read all data before send large data
881 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
882 HILOG_INFO(LOG_CORE, "array unsigned char list 101, retCode=%{public}d", result);
883 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > OHOS::HiviewDFX::SUCCESS));
884 }
885
886
887 /**
888 * @tc.name: TestHiSysEventArray100StringItem023
889 * @tc.desc: Test string array item 100.
890 * @tc.type: FUNC
891 * @tc.require: AR000G2QKU AR000FT2Q1
892 */
893 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray100StringItem023, TestSize.Level1)
894 {
895 /**
896 * @tc.steps: step1.make sure write sys event.
897 */
898 static constexpr char domain[] = "DEMO";
899 std::string eventName = "STR_ARRAY_100";
900 HILOG_INFO(LOG_CORE, "test string array 100 item");
901 std::vector<std::string> values;
902 int maxItem = 100;
903 for (int index = 0; index < maxItem; index++) {
904 values.push_back("a");
905 }
906 sleep(1); // make sure hiview read all data before send large data
907 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
908 HILOG_INFO(LOG_CORE, "array string list 100, retCode=%{public}d", result);
909 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::SUCCESS));
910 }
911
912 /**
913 * @tc.name: TestHiSysEventArray101StringItem024
914 * @tc.desc: Test string array item 101.
915 * @tc.type: FUNC
916 * @tc.require: AR000G2QKU AR000FT2Q1
917 */
918 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArray101StringItem024, TestSize.Level1)
919 {
920 /**
921 * @tc.steps: step1.make sure write sys event.
922 */
923 static constexpr char domain[] = "DEMO";
924 std::string eventName = "STR_ARRAY_101";
925 HILOG_INFO(LOG_CORE, "test string array 101 item");
926 std::vector<std::string> values;
927 int maxItem = 101;
928 for (int index = 0; index < maxItem; index++) {
929 values.push_back("z");
930 }
931 sleep(1); // make sure hiview read all data before send large data
932 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
933 HILOG_INFO(LOG_CORE, "array string list 101, retCode=%{public}d", result);
934 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > 0));
935 }
936
937 /**
938 * @tc.name: TestHiSysEventArrayStringValueEqual256K025
939 * @tc.desc: Test array item 256K string.
940 * @tc.type: FUNC
941 * @tc.require: AR000G2QKU AR000FT2Q1
942 */
943 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArrayStringValueEqual256K025, TestSize.Level1)
944 {
945 /**
946 * @tc.steps: step1.make sure write sys event.
947 */
948 static constexpr char domain[] = "TEST";
949 std::string eventName = "EQUAL_256K";
950 HILOG_INFO(LOG_CORE, "test array item value 256K string");
951 std::string value;
952 int length = 256 * 1024;
953 for (int index = 0; index < length; index++) {
954 value.push_back('1' + index % 10);
955 }
956 sleep(1); // make sure hiview read all data before send large data
957 std::vector<std::string> values;
958 values.push_back("c");
959 values.push_back(value);
960 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
961 HILOG_INFO(LOG_CORE, "array item value length is 256K, retCode=%{public}d", result);
962 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == 0));
963 }
964
965 /**
966 * @tc.name: TestHiSysEventArrayStringValueMoreThan256K016
967 * @tc.desc: Test 256K + 1 string.
968 * @tc.type: FUNC
969 * @tc.require: AR000G2QKU AR000FT2Q1
970 */
971 HWTEST_F(HiSysEventNativeTest, TestHiSysEventArrayStringValueMoreThan256K026, TestSize.Level1)
972 {
973 /**
974 * @tc.steps: step1.make sure write sys event.
975 */
976 static constexpr char domain[] = "DEMO";
977 std::string eventName = "MORETHAN256K";
978 HILOG_INFO(LOG_CORE, "test array item value more than 256K string");
979 std::string value;
980 int length = 256 * 1024 + 1;
981 for (int index = 0; index < length; index++) {
982 value.push_back('1' + index % 10);
983 }
984 sleep(1); // make sure hiview read all data before send large data
985 std::vector<std::string> values;
986 values.push_back("c");
987 values.push_back(value);
988 int result = HiSysEventWrite(domain, eventName, HiSysEvent::EventType::FAULT, "key1", values);
989 HILOG_INFO(LOG_CORE, "array item value length is more than 256K, retCode=%{public}d", result);
990 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result > 0));
991 }
992
993 /**
994 * @tc.name: TestDefensingHiSysEventStorm
995 * @tc.desc: Write event more than 100 times in 5 seconds
996 * @tc.type: FUNC
997 * @tc.require: issueI5FNPQ
998 */
999 HWTEST_F(HiSysEventNativeTest, TestDefensingHiSysEventStorm, TestSize.Level1)
1000 {
1001 int writeCount = 102;
1002 for (int i = 0; i < writeCount; i++) {
1003 auto result = WriteSysEventByMarcoInterface();
1004 if (i < HISYSEVENT_THRESHOLD) {
1005 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == 0));
1006 } else {
1007 ASSERT_TRUE(WrapSysEventWriteAssertion(result, result == OHOS::HiviewDFX::ERR_WRITE_IN_HIGH_FREQ));
1008 }
1009 }
1010 }
1011
1012 /**
1013 * @tc.name: TestAddAndRemoveListener
1014 * @tc.desc: Add listener and then remove it
1015 * @tc.type: FUNC
1016 * @tc.require: issueI5KDIG
1017 */
1018 HWTEST_F(HiSysEventNativeTest, TestAddAndRemoveListener, TestSize.Level1)
1019 {
1020 auto watcher = std::make_shared<Watcher>();
1021 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
1022 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
1023 sysRules.emplace_back(listenerRule);
1024 auto ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(nullptr, sysRules);
1025 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1026 ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
1027 ASSERT_EQ(ret, 0);
1028 ret = OHOS::HiviewDFX::HiSysEventManager::RemoveListener(nullptr);
1029 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1030 auto newWatcher = std::make_shared<Watcher>();
1031 ret = OHOS::HiviewDFX::HiSysEventManager::RemoveListener(newWatcher);
1032 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1033 ret = OHOS::HiviewDFX::HiSysEventManager::RemoveListener(watcher);
1034 ASSERT_EQ(ret, 0);
1035 }
1036
1037 /**
1038 * @tc.name: TestEnableAndDisableDebugMode
1039 * @tc.desc: Enable debug mode and then disable it on listener
1040 * @tc.type: FUNC
1041 * @tc.require: issueI5KDIG
1042 */
1043 HWTEST_F(HiSysEventNativeTest, TestEnableAndDisableDebugMode, TestSize.Level1)
1044 {
1045 auto watcher = std::make_shared<Watcher>();
1046 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
1047 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
1048 sysRules.emplace_back(listenerRule);
1049 auto ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
1050 ASSERT_EQ(ret, 0);
1051 }
1052
1053 /**
1054 * @tc.name: TestHiSysEventBaseManagerAddAndRemoveListener
1055 * @tc.desc: Add a base listener and then remove it
1056 * @tc.type: FUNC
1057 * @tc.require: issueI5OA3F
1058 */
1059 HWTEST_F(HiSysEventNativeTest, TestHiSysEventBaseManagerAddAndRemoveListener, TestSize.Level1)
1060 {
1061 auto watcher = std::make_shared<Watcher>();
1062 auto baseWatcher = std::make_shared<HiSysEventBaseListener>(watcher);
1063 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
1064 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
1065 sysRules.emplace_back(listenerRule);
1066 auto ret = OHOS::HiviewDFX::HiSysEventBaseManager::AddListener(nullptr, sysRules);
1067 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1068 ret = OHOS::HiviewDFX::HiSysEventBaseManager::AddListener(baseWatcher, sysRules);
1069 ASSERT_EQ(ret, 0);
1070 ret = OHOS::HiviewDFX::HiSysEventBaseManager::RemoveListener(nullptr);
1071 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1072 auto newBaseWatcher = std::make_shared<HiSysEventBaseListener>(watcher);
1073 ret = OHOS::HiviewDFX::HiSysEventBaseManager::RemoveListener(newBaseWatcher);
1074 ASSERT_EQ(ret, ERR_LISTENER_NOT_EXIST);
1075 ret = OHOS::HiviewDFX::HiSysEventBaseManager::RemoveListener(baseWatcher);
1076 ASSERT_EQ(ret, 0);
1077 }
1078
1079 /**
1080 * @tc.name: TestHiSysEventBaseManagerQueryEvent
1081 * @tc.desc: Query sys events by base manager
1082 * @tc.type: FUNC
1083 * @tc.require: issueI5KDIG
1084 */
1085 HWTEST_F(HiSysEventNativeTest, TestHiSysEventBaseManagerQueryEvent, TestSize.Level1)
1086 {
1087 auto querier = std::make_shared<Querier>();
1088 long long defaultTimeStap = -1;
1089 int queryCount = 10;
1090 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
1091 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
1092 auto baseQuerier = std::make_shared<HiSysEventBaseQueryCallback>(querier);
1093 auto ret = OHOS::HiviewDFX::HiSysEventBaseManager::Query(args, queryRules, baseQuerier);
1094 ASSERT_EQ(ret, 0);
1095 }
1096
1097 /**
1098 * @tc.name: TestHiSysEventManagerAddListenerWithTooManyRules
1099 * @tc.desc: Add listener with more than 20 rules
1100 * @tc.type: FUNC
1101 * @tc.require: issueI5KDIG
1102 */
1103 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerAddListenerWithTooManyRules, TestSize.Level1)
1104 {
1105 auto watcher = std::make_shared<Watcher>();
1106 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
1107 int ruleCount = 20;
1108 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
1109 while (ruleCount-- > 0) {
1110 sysRules.emplace_back(listenerRule);
1111 }
1112 auto ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
1113 ASSERT_EQ(ret, 0);
1114 sysRules.emplace_back(listenerRule);
1115 ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(watcher, sysRules);
1116 ASSERT_EQ(ret, OHOS::HiviewDFX::ERR_TOO_MANY_WATCH_RULES);
1117 }
1118
1119 /**
1120 * @tc.name: TestHiSysEventManagerAddTooManyEventListener
1121 * @tc.desc: Adding more than 30 event listener
1122 * @tc.type: FUNC
1123 * @tc.require: issueI5KDIG
1124 */
1125 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerAddTooManyEventListener, TestSize.Level1)
1126 {
1127 OHOS::HiviewDFX::ListenerRule listenerRule("DOMAIN", "EVENT_NAME", "", OHOS::HiviewDFX::RuleType::WHOLE_WORD);
1128 std::vector<OHOS::HiviewDFX::ListenerRule> sysRules;
1129 sysRules.emplace_back(listenerRule);
1130 int cnt = 30;
1131 int32_t ret = 0;
1132 while (cnt-- > 0) {
1133 ret = OHOS::HiviewDFX::HiSysEventManager::AddListener(std::make_shared<Watcher>(), sysRules);
1134 }
1135 ASSERT_EQ(ret, OHOS::HiviewDFX::ERR_TOO_MANY_WATCHERS);
1136 }
1137
1138 /**
1139 * @tc.name: TestHiSysEventManagerQueryWithTooManyRules
1140 * @tc.desc: Query with 11 query rules
1141 * @tc.type: FUNC
1142 * @tc.require: issueI5L2RV
1143 */
1144 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerQueryWithTooManyRules, TestSize.Level1)
1145 {
1146 auto querier = std::make_shared<Querier>();
1147 long long defaultTimeStap = -1;
1148 int queryCount = 10;
1149 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
1150 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
1151 int rulesCount = 101; // limit to 100
1152 while (rulesCount-- > 0) {
1153 std::vector<std::string> eventNames {"EVENT_NAME"};
1154 OHOS::HiviewDFX::QueryRule rule("DOMAIN", eventNames);
1155 queryRules.emplace_back(rule);
1156 }
1157 auto ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
1158 ASSERT_EQ(ret, OHOS::HiviewDFX::ERR_TOO_MANY_QUERY_RULES);
1159 }
1160
1161 /**
1162 * @tc.name: TestHiSysEventManagerTooManyConcurrentQueries
1163 * @tc.desc: Query more than 4 times at same time
1164 * @tc.type: FUNC
1165 * @tc.require: issueI5L2RV
1166 */
1167 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerTooManyConcurrentQueries, TestSize.Level1)
1168 {
1169 auto querier = std::make_shared<Querier>();
1170 long long defaultTimeStap = -1;
1171 int queryCount = 10;
1172 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
1173 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
1174 int threadCount = 5;
1175 auto ret = OHOS::HiviewDFX::IPC_CALL_SUCCEED;
1176 for (int i = 0; i < threadCount; i++) {
__anonf3e3fcb70202() 1177 std::thread t([&ret, &args, &queryRules, &querier] () {
1178 ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
1179 });
1180 t.join();
1181 }
1182 ASSERT_TRUE((ret == OHOS::HiviewDFX::ERR_TOO_MANY_CONCURRENT_QUERIES) ||
1183 (ret == OHOS::HiviewDFX::ERR_QUERY_TOO_FREQUENTLY) ||
1184 (ret == OHOS::HiviewDFX::IPC_CALL_SUCCEED));
1185 }
1186
1187 /**
1188 * @tc.name: TestHiSysEventManagerQueryTooFrequently
1189 * @tc.desc: Query twice in 1 seconds
1190 * @tc.type: FUNC
1191 * @tc.require: issueI5L2RV
1192 */
1193 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerQueryTooFrequently, TestSize.Level1)
1194 {
1195 auto querier = std::make_shared<Querier>();
1196 long long defaultTimeStap = -1;
1197 int queryCount = 10;
1198 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
1199 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
1200 const int threshhold = 50;
1201 const int delayDuration = 1; // 1 second
1202 for (int i = 0; i < 2; i++) { // 2 cycles
1203 sleep(delayDuration);
1204 for (int j = 0; j <= threshhold; j++) { // more than 50 queries in 1 second is never allowed
1205 auto ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
1206 ASSERT_TRUE((ret == OHOS::HiviewDFX::ERR_QUERY_TOO_FREQUENTLY) ||
1207 (ret == OHOS::HiviewDFX::IPC_CALL_SUCCEED));
1208 }
1209 }
1210 }
1211
1212 /**
1213 * @tc.name: TestInitHiSysEventRecordWithIncorrectStr
1214 * @tc.desc: Init a hisysevent record with an incorrect string
1215 * @tc.type: FUNC
1216 * @tc.require: issueI5OA3F
1217 */
1218 HWTEST_F(HiSysEventNativeTest, TestInitHiSysEventRecordWithIncorrectStr, TestSize.Level1)
1219 {
1220 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1221 \"PARAM_A\":\"param a\",";
1222 HiSysEventRecord record(JSON_STR);
1223 int64_t val = 0;
1224 int ret = record.GetParamValue("type_", val);
1225 ASSERT_EQ(ret, ERR_INIT_FAILED);
1226 }
1227
1228 /**
1229 * @tc.name: TestParseValueByInvalidKeyFromHiSysEventRecord
1230 * @tc.desc: Parse value by a invalid key from a hisysevent record
1231 * @tc.type: FUNC
1232 * @tc.require: issueI5OA3F
1233 */
1234 HWTEST_F(HiSysEventNativeTest, TestParseValueByInvalidKeyFromHiSysEventRecord, TestSize.Level1)
1235 {
1236 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1237 \"PARAM_A\":\"param a\",\"PARAM_B\":\"param b\"}";
1238 HiSysEventRecord record(JSON_STR);
1239 int64_t val = 0;
1240 int ret = record.GetParamValue("XXX", val);
1241 ASSERT_EQ(ret, ERR_KEY_NOT_EXIST);
1242 }
1243
1244 /**
1245 * @tc.name: TestParseValueByInvalidTypeFromHiSysEventRecord
1246 * @tc.desc: Parse value by a invalid type from a hisysevent record
1247 * @tc.type: FUNC
1248 * @tc.require: issueI5OA3F
1249 */
1250 HWTEST_F(HiSysEventNativeTest, TestParseValueByInvalidTypeFromHiSysEventRecord, TestSize.Level1)
1251 {
1252 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1253 \"PARAM_A\":\"param a\",\"PARAM_B\":\"param b\"}";
1254 HiSysEventRecord record(JSON_STR);
1255 int64_t val = 0;
1256 int ret = record.GetParamValue("PARAM_B", val);
1257 ASSERT_EQ(ret, ERR_TYPE_NOT_MATCH);
1258 }
1259
1260 /**
1261 * @tc.name: TestParseEventDomainNameTypeFromHiSysEventRecord
1262 * @tc.desc: Parse event domain, name and type from a hisysevent record
1263 * @tc.type: FUNC
1264 * @tc.require: issueI5OA3F
1265 */
1266 HWTEST_F(HiSysEventNativeTest, TestParseEventDomainNameTypeFromHiSysEventRecord, TestSize.Level1)
1267 {
1268 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1269 \"PARAM_A\":\"param a\",\"PARAM_B\":\"param b\"}";
1270 HiSysEventRecord record(JSON_STR);
1271 ASSERT_EQ(record.GetDomain(), "DEMO");
1272 ASSERT_EQ(record.GetEventName(), "EVENT_NAME_A");
1273 ASSERT_EQ(record.GetEventType(), 4);
1274 }
1275
1276 /**
1277 * @tc.name: TestParseInt64ValueFromHiSysEventRecord
1278 * @tc.desc: Parse int64 value from a hisysevent record
1279 * @tc.type: FUNC
1280 * @tc.require: issueI5OA3F
1281 */
1282 HWTEST_F(HiSysEventNativeTest, TestParseInt64ValueFromHiSysEventRecord, TestSize.Level1)
1283 {
1284 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1285 \"PARAM_A\":-1,\"PARAM_B\":\"param b\"}";
1286 HiSysEventRecord record(JSON_STR);
1287 int64_t val = 0;
1288 int ret = record.GetParamValue("PARAM_A", val);
1289 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1290 ASSERT_EQ(val, -1);
1291 }
1292
1293 /**
1294 * @tc.name: TestParseUInt64ValueFromHiSysEventRecord
1295 * @tc.desc: Parse uint64 value from a hisysevent record
1296 * @tc.type: FUNC
1297 * @tc.require: issueI5OA3F
1298 */
1299 HWTEST_F(HiSysEventNativeTest, TestParseUInt64ValueFromHiSysEventRecord, TestSize.Level1)
1300 {
1301 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1302 \"PARAM_A\":3,\"PARAM_B\":\"param b\"}";
1303 HiSysEventRecord record(JSON_STR);
1304 uint64_t val = 0;
1305 int ret = record.GetParamValue("PARAM_A", val);
1306 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1307 ASSERT_EQ(val, 3);
1308 }
1309
1310 /**
1311 * @tc.name: TestParseDoubleValueFromHiSysEventRecord
1312 * @tc.desc: Parse double value from a hisysevent record
1313 * @tc.type: FUNC
1314 * @tc.require: issueI5OA3F
1315 */
1316 HWTEST_F(HiSysEventNativeTest, TestParseDoubleValueFromHiSysEventRecord, TestSize.Level1)
1317 {
1318 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1319 \"PARAM_A\":3.4,\"PARAM_B\":\"param b\"}";
1320 HiSysEventRecord record(JSON_STR);
1321 double val = 0;
1322 int ret = record.GetParamValue("PARAM_A", val);
1323 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1324 ASSERT_LT(abs(val - 3.4), 1e-8);
1325 }
1326
1327 /**
1328 * @tc.name: TestParseStringValueFromHiSysEventRecord
1329 * @tc.desc: Parse string value from a hisysevent record
1330 * @tc.type: FUNC
1331 * @tc.require: issueI5OA3F
1332 */
1333 HWTEST_F(HiSysEventNativeTest, TestParseStringValueFromHiSysEventRecord, TestSize.Level1)
1334 {
1335 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1336 \"PARAM_A\":3.4,\"PARAM_B\":\"param b\"}";
1337 HiSysEventRecord record(JSON_STR);
1338 std::string val;
1339 int ret = record.GetParamValue("PARAM_B", val);
1340 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1341 ASSERT_EQ(val, "param b");
1342 }
1343
1344 /**
1345 * @tc.name: TestParseInt64ArrayFromHiSysEventRecord
1346 * @tc.desc: Parse int64 array from a hisysevent record
1347 * @tc.type: FUNC
1348 * @tc.require: issueI5OA3F
1349 */
1350 HWTEST_F(HiSysEventNativeTest, TestParseInt64ArrayFromHiSysEventRecord, TestSize.Level1)
1351 {
1352 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1353 \"PARAM_A\":3.4,\"PARAM_B\":[-1, 0, 1]}";
1354 HiSysEventRecord record(JSON_STR);
1355 std::vector<int64_t> val;
1356 int ret = record.GetParamValue("PARAM_B", val);
1357 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1358 ASSERT_EQ(val.size(), 3);
1359 ASSERT_EQ(val[0], -1);
1360 }
1361
1362 /**
1363 * @tc.name: TestParseUInt64ArrayFromHiSysEventRecord
1364 * @tc.desc: Parse uint64 array from a hisysevent record
1365 * @tc.type: FUNC
1366 * @tc.require: issueI5OA3F
1367 */
1368 HWTEST_F(HiSysEventNativeTest, TestParseUInt64ArrayFromHiSysEventRecord, TestSize.Level1)
1369 {
1370 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1371 \"PARAM_A\":3.4,\"PARAM_B\":[1, 2, 3]}";
1372 HiSysEventRecord record(JSON_STR);
1373 std::vector<uint64_t> val;
1374 int ret = record.GetParamValue("PARAM_B", val);
1375 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1376 ASSERT_EQ(val.size(), 3);
1377 ASSERT_EQ(val[0], 1);
1378 }
1379
1380 /**
1381 * @tc.name: TestParseDoubleArrayFromHiSysEventRecord
1382 * @tc.desc: Parse double array from a hisysevent record
1383 * @tc.type: FUNC
1384 * @tc.require: issueI5OA3F
1385 */
1386 HWTEST_F(HiSysEventNativeTest, TestParseDoubleArrayFromHiSysEventRecord, TestSize.Level1)
1387 {
1388 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1389 \"PARAM_A\":3.4,\"PARAM_B\":[2.1, 0.0, 3.3]}";
1390 HiSysEventRecord record(JSON_STR);
1391 std::vector<double> val;
1392 int ret = record.GetParamValue("PARAM_B", val);
1393 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1394 ASSERT_EQ(val.size(), 3);
1395 ASSERT_LT(abs(val[0] - 2.1), 1e-8);
1396 }
1397
1398 /**
1399 * @tc.name: TestParseStringArrayFromHiSysEventRecord
1400 * @tc.desc: Parse string array from a hisysevent record
1401 * @tc.type: FUNC
1402 * @tc.require: issueI5OA3F
1403 */
1404 HWTEST_F(HiSysEventNativeTest, TestParseStringArrayFromHiSysEventRecord, TestSize.Level1)
1405 {
1406 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1407 \"PARAM_A\":3.4,\"PARAM_B\":[\"123\", \"456\", \"789\"]}";
1408 HiSysEventRecord record(JSON_STR);
1409 std::vector<std::string> val;
1410 int ret = record.GetParamValue("PARAM_B", val);
1411 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1412 ASSERT_EQ(val.size(), 3);
1413 ASSERT_EQ(val[0], "123");
1414 }
1415
1416 /**
1417 * @tc.name: TestParseParamsFromHiSysEventRecord
1418 * @tc.desc: Parse some inlined parameters from a hisysevent record
1419 * @tc.type: FUNC
1420 * @tc.require: issueI5OA3F
1421 */
1422 HWTEST_F(HiSysEventNativeTest, TestParseParamsFromHiSysEventRecord, TestSize.Level1)
1423 {
1424 constexpr char JSON_STR[] = "{\"domain_\":\"SAMGR\",\"name_\":\"SAMGR_ADD_SYSTEMABILITY_FAIL\",\"type_\":1,\
1425 \"time_\":1502114170549,\"tz_\":\"+0000\",\"pid_\":398,\"tid_\":398,\"uid_\":1099,\"SAID\":1155,\
1426 \"FILE_NAME\":\"libexternal_vpn_service.z.so\",\"level_\":\"CRITICAL\",\"tag_\":\"fault\",\
1427 \"id_\":\"14947264126694503475\",\"traceid_\":243156040590758234, \"spanid_\":11870123,\
1428 \"pspanid_\":28408891,\"trace_flag_\":1,\"info_\":\"\"}";
1429 HiSysEventRecord record(JSON_STR);
1430 auto time = record.GetTime();
1431 ASSERT_GT(time, 0);
1432 auto timeZone = record.GetTimeZone();
1433 ASSERT_EQ(timeZone.size(), 5);
1434 auto pid = record.GetPid();
1435 ASSERT_GT(pid, 0);
1436 auto tid = record.GetTid();
1437 ASSERT_GT(tid, 0);
1438 auto uid = record.GetUid();
1439 ASSERT_GT(uid, 0);
1440 auto traceId = record.GetTraceId();
1441 ASSERT_GE(traceId, 0);
1442 auto spanId = record.GetSpanId();
1443 ASSERT_GE(spanId, 0);
1444 auto pspanId = record.GetPspanId();
1445 ASSERT_GE(pspanId, 0);
1446 auto traceFlag = record.GetTraceFlag();
1447 ASSERT_GE(traceFlag, 0);
1448 auto level = record.GetLevel();
1449 ASSERT_EQ(level, "CRITICAL");
1450 auto tag = record.GetTag();
1451 ASSERT_GE(timeZone.size(), 0);
1452 std::vector<std::string> paramNames;
1453 record.GetParamNames(paramNames);
__anonf3e3fcb70302(auto& name) 1454 ASSERT_TRUE(std::any_of(paramNames.begin(), paramNames.end(), [] (auto& name) {
1455 return name == "domain_" || name == "name_" || name == "type_";
1456 }));
1457 }
1458
1459 /**
1460 * @tc.name: TestParseParamsFromUninitializedHiSysEventRecord
1461 * @tc.desc: Parse parameters from a uninitialized hisysevent record
1462 * @tc.type: FUNC
1463 * @tc.require: issueI5OA3F
1464 */
1465 HWTEST_F(HiSysEventNativeTest, TestParseParamsFromUninitializedHiSysEventRecord, TestSize.Level1)
1466 {
1467 constexpr char JSON_STR[] = "";
1468 HiSysEventRecord record(JSON_STR);
1469 auto time = record.GetTime();
1470 ASSERT_EQ(time, 0);
1471 auto timeZone = record.GetTimeZone();
1472 ASSERT_EQ(timeZone.size(), 0);
1473 auto traceId = record.GetTraceId();
1474 ASSERT_EQ(traceId, 0);
1475 }
1476
1477 /**
1478 * @tc.name: TestParseWrongTypeParamsFromUninitializedHiSysEventRecord
1479 * @tc.desc: Parse parameters with unmatched type from a hisysevent record
1480 * @tc.type: FUNC
1481 * @tc.require: issueI5OA3F
1482 */
1483 HWTEST_F(HiSysEventNativeTest, TestParseWrongTypeParamsFromUninitializedHiSysEventRecord, TestSize.Level1)
1484 {
1485 constexpr char JSON_STR[] = "{\"domain_\":\"DEMO\",\"name_\":\"EVENT_NAME_A\",\"type_\":4,\
1486 \"PARAM_A\":3.4,\"UINT64_T\":18446744073709551610,\"DOUBLE_T\":3.3,\"INT64_T\":9223372036854775800,\
1487 \"PARAM_B\":[\"123\", \"456\", \"789\"],\"PARAM_C\":[]}";
1488 HiSysEventRecord record(JSON_STR);
1489 double num = 0;
1490 auto ret = record.GetParamValue("domain_", num);
1491 ASSERT_EQ(ret, ERR_TYPE_NOT_MATCH);
1492 std::vector<std::string> paramC;
1493 ret = record.GetParamValue("name_", paramC);
1494 ASSERT_EQ(ret, ERR_TYPE_NOT_MATCH);
1495 ret = record.GetParamValue("PARAM_C", paramC);
1496 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1497 uint64_t uint64TypeParam = 0;
1498 ret = record.GetParamValue("UINT64_T", uint64TypeParam);
1499 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1500 int64_t int64TypeParam = 0;
1501 ret = record.GetParamValue("INT64_T", int64TypeParam);
1502 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1503 double doubleTypeParam = 0;
1504 ret = record.GetParamValue("DOUBLE_T", doubleTypeParam);
1505 ASSERT_EQ(ret, VALUE_PARSED_SUCCEED);
1506 double doubleTypeParam2 = 0;
1507 ret = record.GetParamValue("DOUBLE_T_NOT_EXIST", doubleTypeParam2);
1508 ASSERT_EQ(ret, ERR_KEY_NOT_EXIST);
1509 }
1510
1511 /**
1512 * @tc.name: TestHiSysEventManagerQueryWithDefaultQueryArgument
1513 * @tc.desc: Query with default arugumen
1514 * @tc.type: FUNC
1515 * @tc.require: issueI5L2RV
1516 */
1517 HWTEST_F(HiSysEventNativeTest, TestHiSysEventManagerQueryWithDefaultQueryArgument, TestSize.Level1)
1518 {
1519 int eventWroiteCnt = 3;
1520 for (int index = 0; index < eventWroiteCnt; index++) {
1521 HiSysEventWrite(TEST_DOMAIN2, "POWER_KEY", HiSysEvent::EventType::FAULT, "DESC", "in test case");
1522 }
1523 sleep(2);
__anonf3e3fcb70402(std::shared_ptr<std::vector<HiSysEventRecord>> sysEvents) 1524 auto querier = std::make_shared<Querier>([] (std::shared_ptr<std::vector<HiSysEventRecord>> sysEvents) {
1525 return true;
1526 }, [] (int32_t reason, int32_t total) {
1527 return total > 0;
1528 });
1529 long long defaultTimeStap = -1; // default value
1530 int queryCount = -1; // default value
1531 struct OHOS::HiviewDFX::QueryArg args(defaultTimeStap, defaultTimeStap, queryCount);
1532 std::vector<OHOS::HiviewDFX::QueryRule> queryRules;
1533 std::vector<std::string> eventNames {"POWER_KEY"};
1534 OHOS::HiviewDFX::QueryRule rule("KERNEL_VENDOR", eventNames); // empty domain
1535 queryRules.emplace_back(rule);
1536 auto ret = OHOS::HiviewDFX::HiSysEventManager::Query(args, queryRules, querier);
1537 ASSERT_EQ(ret, OHOS::HiviewDFX::IPC_CALL_SUCCEED);
1538 }
1539
1540 /**
1541 * @tc.name: TestEventSocketFactory1
1542 * @tc.desc: Test apis of EventSocketFactory
1543 * @tc.type: FUNC
1544 * @tc.require: issueIC70PG
1545 */
1546 HWTEST_F(HiSysEventNativeTest, TestEventSocketFactory1, TestSize.Level1)
1547 {
1548 RawData data;
1549 BuildRawData(data, "AAFWK", "APP_INPUT_BLOCK", HiSysEvent::EventType::FAULT);
1550 auto socketAddr = EventSocketFactory::GetEventSocket(data);
1551 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1552 BuildRawData(data, "AAFWK", "BUSSINESS_THREAD_BLOCK_3S", HiSysEvent::EventType::FAULT);
1553 socketAddr = EventSocketFactory::GetEventSocket(data);
1554 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1555 BuildRawData(data, "AAFWK", "BUSSINESS_THREAD_BLOCK_6S", HiSysEvent::EventType::FAULT);
1556 socketAddr = EventSocketFactory::GetEventSocket(data);
1557 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1558 BuildRawData(data, "AAFWK", "LIFECYCLE_HALF_TIMEOUT", HiSysEvent::EventType::FAULT);
1559 socketAddr = EventSocketFactory::GetEventSocket(data);
1560 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1561 BuildRawData(data, "AAFWK", "LIFECYCLE_TIME_OUT", HiSysEvent::EventType::FAULT);
1562 socketAddr = EventSocketFactory::GetEventSocket(data);
1563 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1564 BuildRawData(data, "AAFWK", "THREAD_BLOCK_3S", HiSysEvent::EventType::FAULT);
1565 socketAddr = EventSocketFactory::GetEventSocket(data);
1566 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1567 BuildRawData(data, "AAFWK", "THREAD_BLOCK_6S", HiSysEvent::EventType::FAULT);
1568 socketAddr = EventSocketFactory::GetEventSocket(data);
1569 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1570 BuildRawData(data, "AAFWK", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1571 socketAddr = EventSocketFactory::GetEventSocket(data);
1572 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1573 }
1574
1575 /**
1576 * @tc.name: TestEventSocketFactory2
1577 * @tc.desc: Test apis of EventSocketFactory
1578 * @tc.type: FUNC
1579 * @tc.require: issueIC70PG
1580 */
1581 HWTEST_F(HiSysEventNativeTest, TestEventSocketFactory2, TestSize.Level1)
1582 {
1583 RawData data;
1584 BuildRawData(data, "ACE", "UI_BLOCK_3S", HiSysEvent::EventType::FAULT);
1585 auto socketAddr = EventSocketFactory::GetEventSocket(data);
1586 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1587 BuildRawData(data, "ACE", "UI_BLOCK_6S", HiSysEvent::EventType::FAULT);
1588 socketAddr = EventSocketFactory::GetEventSocket(data);
1589 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1590 BuildRawData(data, "ACE", "UI_BLOCK_RECOVERED", HiSysEvent::EventType::FAULT);
1591 socketAddr = EventSocketFactory::GetEventSocket(data);
1592 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1593 BuildRawData(data, "ACE", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1594 socketAddr = EventSocketFactory::GetEventSocket(data);
1595 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1596 }
1597
1598 /**
1599 * @tc.name: TestEventSocketFactory3
1600 * @tc.desc: Test apis of EventSocketFactory
1601 * @tc.type: FUNC
1602 * @tc.require: issueIC70PG
1603 */
1604 HWTEST_F(HiSysEventNativeTest, TestEventSocketFactory3, TestSize.Level1)
1605 {
1606 RawData data;
1607 BuildRawData(data, "FRAMEWORK", "IPC_FULL", HiSysEvent::EventType::FAULT);
1608 auto socketAddr = EventSocketFactory::GetEventSocket(data);
1609 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1610 BuildRawData(data, "FRAMEWORK", "SERVICE_BLOCK", HiSysEvent::EventType::FAULT);
1611 socketAddr = EventSocketFactory::GetEventSocket(data);
1612 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1613 BuildRawData(data, "FRAMEWORK", "SERVICE_TIMEOUT", HiSysEvent::EventType::FAULT);
1614 socketAddr = EventSocketFactory::GetEventSocket(data);
1615 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1616 BuildRawData(data, "FRAMEWORK", "SERVICE_WARNING", HiSysEvent::EventType::FAULT);
1617 socketAddr = EventSocketFactory::GetEventSocket(data);
1618 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1619 BuildRawData(data, "FRAMEWORK", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1620 socketAddr = EventSocketFactory::GetEventSocket(data);
1621 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1622 }
1623
1624 /**
1625 * @tc.name: TestEventSocketFactory4
1626 * @tc.desc: Test apis of EventSocketFactory
1627 * @tc.type: FUNC
1628 * @tc.require: issueIC70PG
1629 */
1630 HWTEST_F(HiSysEventNativeTest, TestEventSocketFactory4, TestSize.Level1)
1631 {
1632 RawData data;
1633 BuildRawData(data, "RELIABILITY", "ANY_NAME", HiSysEvent::EventType::FAULT);
1634 auto socketAddr = EventSocketFactory::GetEventSocket(data);
1635 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1636 BuildRawData(data, "RELIABILITY", "ANY_NAME", HiSysEvent::EventType::BEHAVIOR);
1637 socketAddr = EventSocketFactory::GetEventSocket(data);
1638 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1639 }
1640
1641 /**
1642 * @tc.name: TestEventSocketFactory5
1643 * @tc.desc: Test apis of EventSocketFactory
1644 * @tc.type: FUNC
1645 * @tc.require: issueIC70PG
1646 */
1647 HWTEST_F(HiSysEventNativeTest, TestEventSocketFactory5, TestSize.Level1)
1648 {
1649 RawData data;
1650 BuildRawData(data, "GRAPHIC", "NO_DRAW", HiSysEvent::EventType::FAULT);
1651 auto socketAddr = EventSocketFactory::GetEventSocket(data);
1652 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1653 BuildRawData(data, "GRAPHIC", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1654 socketAddr = EventSocketFactory::GetEventSocket(data);
1655 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1656
1657 BuildRawData(data, "MULTIMODALINPUT", "TARGET_POINTER_EVENT_FAILURE", HiSysEvent::EventType::FAULT);
1658 socketAddr = EventSocketFactory::GetEventSocket(data);
1659 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1660 BuildRawData(data, "MULTIMODALINPUT", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1661 socketAddr = EventSocketFactory::GetEventSocket(data);
1662 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1663
1664 BuildRawData(data, "POWER", "SCREEN_ON_TIMEOUT", HiSysEvent::EventType::FAULT);
1665 socketAddr = EventSocketFactory::GetEventSocket(data);
1666 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1667 BuildRawData(data, "POWER", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1668 socketAddr = EventSocketFactory::GetEventSocket(data);
1669 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1670
1671 BuildRawData(data, "WINDOWMANAGER", "NO_FOCUS_WINDOW", HiSysEvent::EventType::FAULT);
1672 socketAddr = EventSocketFactory::GetEventSocket(data);
1673 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1674 BuildRawData(data, "WINDOWMANAGER", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1675 socketAddr = EventSocketFactory::GetEventSocket(data);
1676 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1677
1678 BuildRawData(data, "SCHEDULE_EXT", "SYSTEM_LOAD_LEVEL_CHANGED", HiSysEvent::EventType::FAULT);
1679 socketAddr = EventSocketFactory::GetEventSocket(data);
1680 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent_fast");
1681 BuildRawData(data, "SCHEDULE_EXT", "EXCLUDED_NAME", HiSysEvent::EventType::FAULT);
1682 socketAddr = EventSocketFactory::GetEventSocket(data);
1683 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1684
1685 BuildRawData(data, "EXCLUDED_DOMAIN", "ANY_NAME", HiSysEvent::EventType::FAULT);
1686 socketAddr = EventSocketFactory::GetEventSocket(data);
1687 ASSERT_EQ(std::string(socketAddr.sun_path), "/dev/unix/socket/hisysevent");
1688 }
1689
1690