1 /*
2 * Copyright (c) 2023 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 "event_logger_test.h"
16
17 #include <fcntl.h>
18 #include "common_utils.h"
19 #include "hisysevent.h"
20 #include "hiview_platform.h"
21
22 #define private public
23 #include "event_logger.h"
24 #undef private
25 #include "event.h"
26 #include "hiview_platform.h"
27 #include "sysevent_source.h"
28 #ifdef WINDOW_MANAGER_ENABLE
29 #include "focus_change_info.h"
30 #include "event_focus_listener.h"
31 #endif
32 #include "time_util.h"
33 #include "eventlogger_util_test.h"
34 #include "parameters.h"
35 #include "db_helper.h"
36 #include "freeze_common.h"
37 #include "event_logger_util.h"
38
39 using namespace testing::ext;
40 using namespace OHOS::HiviewDFX;
41 namespace OHOS {
42 namespace HiviewDFX {
43 SysEventSource source;
44 static std::string TEST_PATH = "/data/test/log/test.txt";
SetUp()45 void EventLoggerTest::SetUp()
46 {
47 printf("SetUp.\n");
48 InitSeLinuxEnabled();
49 }
50
TearDown()51 void EventLoggerTest::TearDown()
52 {
53 printf("TearDown.\n");
54 CancelSeLinuxEnabled();
55 }
56
SetUpTestCase()57 void EventLoggerTest::SetUpTestCase()
58 {
59 HiviewPlatform platform;
60 source.SetHiviewContext(&platform);
61 source.OnLoad();
62 }
63
TearDownTestCase()64 void EventLoggerTest::TearDownTestCase()
65 {
66 source.OnUnload();
67 }
68
69 /**
70 * @tc.name: EventLoggerTest_OnEvent_001
71 * @tc.desc: EventLoggerTest
72 * @tc.type: FUNC
73 */
74 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_001, TestSize.Level0)
75 {
76 auto eventLogger = std::make_shared<EventLogger>();
77 std::shared_ptr<Event> event = nullptr;
78 EXPECT_FALSE(eventLogger->OnEvent(event));
79 }
80
81 /**
82 * @tc.name: EventLoggerTest_OnEvent_002
83 * @tc.desc: EventLoggerTest
84 * @tc.type: FUNC
85 */
86 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_002, TestSize.Level3)
87 {
88 auto eventLogger = std::make_shared<EventLogger>();
89 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
90 std::shared_ptr<SysEvent> sysEvent1 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
91 nullptr, jsonStr);
92 sysEvent1->eventName_ = "GESTURE_NAVIGATION_BACK";
93 sysEvent1->SetEventValue("PID", getpid());
94 std::shared_ptr<OHOS::HiviewDFX::Event> event1 = std::static_pointer_cast<Event>(sysEvent1);
95 EXPECT_EQ(eventLogger->OnEvent(event1), true);
96 #ifdef WINDOW_MANAGER_ENABLE
97 sptr<Rosen::FocusChangeInfo> focusChangeInfo;
98 sptr<EventFocusListener> eventFocusListener_ = EventFocusListener::GetInstance();
99 eventFocusListener_->OnFocused(focusChangeInfo);
100 eventFocusListener_->OnUnfocused(focusChangeInfo);
101 EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
102 EXPECT_EQ(eventLogger->OnEvent(event1), true);
103 #endif
104 }
105
106 /**
107 * @tc.name: EventLoggerTest_OnEvent_003
108 * @tc.desc: EventLoggerTest
109 * @tc.type: FUNC
110 */
111 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_003, TestSize.Level3)
112 {
113 auto eventLogger = std::make_shared<EventLogger>();
114 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
115 std::string testName = "EventLoggerTest_OnEvent_003";
116 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
117 nullptr, jsonStr);
118 EXPECT_EQ(eventLogger->IsHandleAppfreeze(sysEvent), true);
119 sysEvent->SetEventValue("PACKAGE_NAME", testName);
120 sysEvent->SetEventValue("PID", 0);
121 sysEvent->SetEventValue("eventLog_action", "");
122 std::shared_ptr<OHOS::HiviewDFX::Event> event = std::static_pointer_cast<Event>(sysEvent);
123 EXPECT_EQ(eventLogger->OnEvent(event), true);
124 sysEvent->eventName_ = "THREAD_BLOCK_6S";
125 event = std::static_pointer_cast<Event>(sysEvent);
126 sysEvent->SetValue("eventLog_action", "pb:1");
127 EXPECT_EQ(eventLogger->OnEvent(event), true);
128 OHOS::system::SetParameter("hiviewdfx.appfreeze.filter_bundle_name", testName);
129 EXPECT_FALSE(eventLogger->IsHandleAppfreeze(sysEvent));
130 event = std::static_pointer_cast<Event>(sysEvent);
131 EXPECT_EQ(eventLogger->OnEvent(event), true);
132 OHOS::system::SetParameter("hiviewdfx.appfreeze.filter_bundle_name", "test");
133 }
134
135 /**
136 * @tc.name: EventLoggerTest_OnEvent_004
137 * @tc.desc: EventLoggerTest
138 * @tc.type: FUNC
139 */
140 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_004, TestSize.Level3)
141 {
142 auto eventLogger = std::make_shared<EventLogger>();
143 eventLogger->OnLoad();
144 sleep(1);
145
146 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
147 long pid = getpid();
148 #ifdef WINDOW_MANAGER_ENABLE
149 EventFocusListener::RegisterFocusListener();
150 EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
151 #endif
152 uint64_t curentTime = TimeUtil::GetMilliseconds();
153 for (int i = 0; i < 5 ; i++) {
154 std::shared_ptr<SysEvent> sysEvent1 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
155 nullptr, jsonStr);
156 sysEvent1->SetEventValue("PID", pid);
157 sysEvent1->happenTime_ = curentTime;
158 std::shared_ptr<OHOS::HiviewDFX::Event> event1 = std::static_pointer_cast<Event>(sysEvent1);
159 EXPECT_EQ(eventLogger->OnEvent(event1), true);
160 usleep(200 * 1000);
161 curentTime += 200;
162 }
163 std::shared_ptr<SysEvent> sysEvent2 = std::make_shared<SysEvent>("FREQUENT_CLICK_WARNING",
164 nullptr, jsonStr);
165 sysEvent2->SetEventValue("PID", pid);
166 sysEvent2->happenTime_ = TimeUtil::GetMilliseconds();
167 std::shared_ptr<OHOS::HiviewDFX::Event> event2 = std::static_pointer_cast<Event>(sysEvent2);
168 EXPECT_EQ(eventLogger->OnEvent(event2), true);
169 eventLogger->OnUnload();
170 }
171
172 /**
173 * @tc.name: EventLoggerTest_IsInterestedPipelineEvent_001
174 * @tc.desc: EventLoggerTest
175 * @tc.type: FUNC
176 */
177 HWTEST_F(EventLoggerTest, EventLoggerTest_IsInterestedPipelineEvent_001, TestSize.Level3)
178 {
179 auto eventLogger = std::make_shared<EventLogger>();
180 EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(nullptr));
181 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
182 std::string testName = "EventLoggerTest_002";
183 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
184 nullptr, jsonStr);
185 sysEvent->eventId_ = 1000001;
186 EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(sysEvent));
187 sysEvent->eventId_ = 1;
188 sysEvent->eventName_ = "UninterestedEvent";
189 EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(sysEvent));
190 sysEvent->eventName_ = "InterestedEvent";
191 eventLogger->eventLoggerConfig_[sysEvent->eventName_] =
192 EventLoggerConfig::EventLoggerConfigData();
193 EXPECT_TRUE(eventLogger->IsInterestedPipelineEvent(sysEvent));
194 }
195
196 /**
197 * @tc.name: EventLoggerTest_CheckProcessRepeatFreeze_001
198 * @tc.desc: EventLoggerTest
199 * @tc.type: FUNC
200 */
201 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckProcessRepeatFreeze_001, TestSize.Level3)
202 {
203 auto eventLogger = std::make_shared<EventLogger>();
204 long pid = getprocpid();
205 eventLogger->lastPid_ = pid;
206 bool ret = eventLogger->CheckProcessRepeatFreeze("THREAD_BLOCK_6S", pid);
207 EXPECT_TRUE(ret);
208 }
209
210 /**
211 * @tc.name: EventLoggerTest_WriteCommonHead_001
212 * @tc.desc: EventLoggerTest
213 * @tc.type: FUNC
214 */
215 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteCommonHead_001, TestSize.Level3)
216 {
217 auto eventLogger = std::make_shared<EventLogger>();
218 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
219 std::string testName = "EventLoggerTest_002";
220 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
221 nullptr, jsonStr);
222 sysEvent->SetEventValue("EVENTNAME", testName);
223 sysEvent->SetEventValue("MODULE_NAME", testName);
224 sysEvent->SetEventValue("PACKAGE_NAME", testName);
225 sysEvent->SetEventValue("PROCESS_NAME", testName);
226 sysEvent->SetEventValue("eventLog_action", "pb:1");
227 sysEvent->SetEventValue("eventLog_interval", 1);
228 sysEvent->SetEventValue("STACK", "TEST\\nTEST\\nTEST");
229 sysEvent->SetEventValue("MSG", "TEST\\nTEST\\nTEST");
230 EXPECT_EQ(eventLogger->WriteCommonHead(1, sysEvent), true);
231 sysEvent->SetEventValue("TID", gettid());
232 EXPECT_EQ(eventLogger->WriteCommonHead(1, sysEvent), true);
233 }
234
235 /**
236 * @tc.name: EventLoggerTest_CheckEventOnContinue_001
237 * @tc.desc: EventLoggerTest
238 * @tc.type: FUNC
239 */
240 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckEventOnContinue_001, TestSize.Level3)
241 {
242 auto eventLogger = std::make_shared<EventLogger>();
243 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
244 std::string testName = "EventLoggerTest_CheckEventOnContinue_001";
245 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
246 nullptr, jsonStr);
247 eventLogger->CheckEventOnContinue(sysEvent);
248 EXPECT_TRUE(sysEvent != nullptr);
249 }
250
251 /**
252 * @tc.name: EventLoggerTest_GetAppFreezeFile_001
253 * @tc.desc: EventLoggerTest
254 * @tc.type: FUNC
255 */
256 HWTEST_F(EventLoggerTest, EventLoggerTest_GetAppFreezeFile_001, TestSize.Level3)
257 {
258 auto eventLogger = std::make_shared<EventLogger>();
259 std::string testFile = "/data/test/log/testFile";
260 auto ret = eventLogger->GetAppFreezeFile(testFile);
261 EXPECT_TRUE(ret.empty());
262 ret = eventLogger->GetAppFreezeFile(TEST_PATH);
263 EXPECT_TRUE(!ret.empty());
264 }
265
266 /**
267 * @tc.name: EventLoggerTest_WriteFreezeJsonInfo_001
268 * @tc.desc: EventLoggerTest
269 * @tc.type: FUNC
270 */
271 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteFreezeJsonInfo_001, TestSize.Level0)
272 {
273 auto eventLogger = std::make_shared<EventLogger>();
274 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
275 std::string testName = "EventLoggerTest_WriteFreezeJsonInfo_001";
276 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
277 nullptr, jsonStr);
278 sysEvent->SetEventValue("EVENTNAME", testName);
279 sysEvent->SetEventValue("MODULE_NAME", testName);
280 sysEvent->SetEventValue("PACKAGE_NAME", testName);
281 sysEvent->SetEventValue("PROCESS_NAME", testName);
282 sysEvent->SetEventValue("eventLog_action", "pb:1");
283 sysEvent->SetEventValue("eventLog_interval", 1);
284 sysEvent->SetEventValue("STACK", "TEST\\nTEST\\nTEST");
285 sysEvent->SetEventValue("MSG", "TEST\\nTEST\\nTEST");
286 sysEvent->eventName_ = "UI_BLOCK_6S";
287 sysEvent->SetEventValue("BINDER_INFO", "async\\nEventLoggerTest");
288 std::vector<std::string> binderPids;
289 std::string threadStack;
290 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
291 sysEvent->SetEventValue("BINDER_INFO", "context");
292 binderPids.clear();
293 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
294 std::string binderInfo = "1:1\\n1:1\\n" + std::to_string(getpid()) +
295 ":1\\n1:1\\n1:1\\n1:1\\n1:1";
296 sysEvent->SetEventValue("BINDER_INFO", binderInfo);
297 binderPids.clear();
298 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
299 }
300
301 /**
302 * @tc.name: EventLoggerTest_WriteFreezeJsonInfo_002
303 * @tc.desc: EventLoggerTest
304 * @tc.type: FUNC
305 */
306 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteFreezeJsonInfo_002, TestSize.Level3)
307 {
308 auto eventLogger = std::make_shared<EventLogger>();
309 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
310 std::string testName = "EventLoggerTest_WriteFreezeJsonInfo_002";
311 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
312 nullptr, jsonStr);
313 std::vector<std::string> binderPids;
314 sysEvent->eventName_ = "THREAD_BLOCK_6S";
315 sysEvent->SetEventValue("BINDER_INFO", TEST_PATH + ", "
316 "async\\tEventLoggerTest\\n 1:2 2:3 3:4 3:4 context");
317 std::string threadStack;
318 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
319 sysEvent->eventName_ = "LIFECYCLE_TIMEOUT";
320 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
321 sysEvent->SetEventValue("BINDER_INFO", TEST_PATH + ", "
322 "22000:22000 to 12001:12001 code 9 wait:1 s test");
323 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
324 }
325
326 /**
327 * @tc.name: EventLoggerTest_WriteFreezeJsonInfo_003
328 * @tc.desc: EventLoggerTest
329 * @tc.type: FUNC
330 */
331 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteFreezeJsonInfo_003, TestSize.Level3)
332 {
333 auto eventLogger = std::make_shared<EventLogger>();
334 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
335 std::string testName = "EventLoggerTest_WriteFreezeJsonInfo_003";
336 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
337 nullptr, jsonStr);
338 std::vector<std::string> binderPids;
339 EXPECT_TRUE(FileUtil::FileExists("/data/test/log/test.txt"));
340 sysEvent->eventName_ = "LIFECYCLE_TIMEOUT";
341 std::string threadStack;
342 EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids, threadStack), true);
343 }
344
345 /**
346 * @tc.name: EventLoggerTest_JudgmentRateLimiting_001
347 * @tc.desc: EventLoggerTest
348 * @tc.type: FUNC
349 */
350 HWTEST_F(EventLoggerTest, EventLoggerTest_JudgmentRateLimiting_001, TestSize.Level3)
351 {
352 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
353 std::string testName = "EventLoggerTest_JudgmentRateLimiting_001";
354 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
355 nullptr, jsonStr);
356 sysEvent->SetEventValue("eventLog_interval", 0);
357 auto eventLogger = std::make_shared<EventLogger>();
358 bool ret = eventLogger->JudgmentRateLimiting(sysEvent);
359 EXPECT_EQ(ret, true);
360 sysEvent->SetEventValue("eventLog_interval", 1);
361 sysEvent->SetEventValue("PID", getpid());
362 sysEvent->SetEventValue("NAME", testName);
363 eventLogger->eventTagTime_["NAME"] = 100;
364 eventLogger->eventTagTime_[testName] = 100;
365 ret = eventLogger->JudgmentRateLimiting(sysEvent);
366 EXPECT_EQ(ret, true);
367 sysEvent->SetValue("eventLog_interval", 0);
368 ret = eventLogger->JudgmentRateLimiting(sysEvent);
369 EXPECT_EQ(ret, true);
370 int32_t interval = sysEvent->GetIntValue("eventLog_interval");
371 EXPECT_EQ(interval, 0);
372 }
373
374 /**
375 * @tc.name: EventLoggerTest_StartLogCollect_001
376 * @tc.desc: EventLoggerTest
377 * @tc.type: FUNC
378 */
379 HWTEST_F(EventLoggerTest, EventLoggerTest_StartLogCollect_001, TestSize.Level3)
380 {
381 auto eventLogger = std::make_shared<EventLogger>();
382 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
383 std::string testName = "EventLoggerTest_StartLogCollect_001";
384 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
385 nullptr, jsonStr);
386 sysEvent->SetEventValue("eventLog_interval", 1);
387 sysEvent->eventName_ = "GET_DISPLAY_SNAPSHOT";
388 sysEvent->SetEventValue("PID", getpid());
389 sysEvent->happenTime_ = TimeUtil::GetMilliseconds();
390 sysEvent->SetEventValue("UID", getuid());
391 sysEvent->SetValue("eventLog_action", "pb:1\npb:2");
392 std::shared_ptr<EventLoop> loop = std::make_shared<EventLoop>("eventLoop");
393 loop->StartLoop();
394 eventLogger->BindWorkLoop(loop);
395 eventLogger->threadLoop_ = loop;
396 eventLogger->StartLogCollect(sysEvent);
397 sysEvent->eventName_ = "THREAD_BLOCK_3S";
398 eventLogger->StartLogCollect(sysEvent);
399 EXPECT_TRUE(sysEvent != nullptr);
400 sysEvent->SetEventValue("MSG", "Test\nnotifyAppFault exception\n");
401 eventLogger->StartLogCollect(sysEvent);
402 EXPECT_TRUE(sysEvent != nullptr);
403 }
404
405 /**
406 * @tc.name: EventLoggerTest_UpdateDB_001
407 * @tc.desc: EventLoggerTest
408 * @tc.type: FUNC
409 */
410 HWTEST_F(EventLoggerTest, EventLoggerTest_UpdateDB_001, TestSize.Level3)
411 {
412 auto eventLogger = std::make_shared<EventLogger>();
413 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
414 std::string testName = "EventLoggerTest_UpdateDB_001";
415 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
416 nullptr, jsonStr);
417 bool ret = eventLogger->UpdateDB(sysEvent, "nolog");
418 EXPECT_TRUE(ret);
419 ret = eventLogger->UpdateDB(sysEvent, "log");
420 EXPECT_TRUE(ret);
421 }
422
423 /**
424 * @tc.name: EventLoggerTest_GetCmdlineContent_001
425 * @tc.desc: EventLoggerTest
426 * @tc.type: FUNC
427 */
428 HWTEST_F(EventLoggerTest, EventLoggerTest_GetCmdlineContent_001, TestSize.Level3)
429 {
430 auto eventLogger = std::make_shared<EventLogger>();
431 eventLogger->cmdlinePath_ = "";
432 eventLogger->GetCmdlineContent();
433 eventLogger->cmdlinePath_ = "/proc/cmdline";
434 EXPECT_TRUE(!eventLogger->cmdlinePath_.empty());
435 }
436
437 /**
438 * @tc.name: EventLoggerTest_ProcessRebootEvent_001
439 * @tc.desc: EventLoggerTest
440 * @tc.type: FUNC
441 */
442 HWTEST_F(EventLoggerTest, EventLoggerTest_ProcessRebootEvent_001, TestSize.Level3)
443 {
444 auto eventLogger = std::make_shared<EventLogger>();
445 eventLogger->cmdlineContent_ = "reboot_reason = EventLoggerTest "
446 "normal_reset_type = EventLoggerTest\\n";
447 eventLogger->rebootReasons_.push_back("EventLoggerTest");
448 std::string ret = eventLogger->GetRebootReason();
449 EXPECT_EQ(ret, "LONG_PRESS");
450 eventLogger->ProcessRebootEvent();
451 eventLogger->cmdlineContent_ = "reboot_reason";
452 ret = eventLogger->GetRebootReason();
453 EXPECT_EQ(ret, "");
454 eventLogger->ProcessRebootEvent();
455 }
456
457 /**
458 * @tc.name: EventLoggerTest_GetListenerName_001
459 * @tc.desc: EventLoggerTest
460 * @tc.type: FUNC
461 */
462 HWTEST_F(EventLoggerTest, EventLoggerTest_GetListenerName_001, TestSize.Level3)
463 {
464 auto eventLogger = std::make_shared<EventLogger>();
465 EXPECT_EQ(eventLogger->GetListenerName(), "EventLogger");
466 }
467
468 /**
469 * @tc.name: EventLoggerTest_GetConfig_001
470 * @tc.desc: EventLoggerTest
471 * @tc.type: FUNC
472 */
473 HWTEST_F(EventLoggerTest, EventLoggerTest_GetConfig_001, TestSize.Level3)
474 {
475 auto eventLogger = std::make_shared<EventLogger>();
476 eventLogger->GetCmdlineContent();
477 eventLogger->GetRebootReasonConfig();
478 EXPECT_TRUE(eventLogger != nullptr);
479 }
480
481 /**
482 * @tc.name: EventLoggerTest_OnUnorderedEvent_001
483 * @tc.desc: EventLoggerTest
484 * @tc.type: FUNC
485 */
486 HWTEST_F(EventLoggerTest, EventLoggerTest_OnUnorderedEvent_001, TestSize.Level3)
487 {
488 auto eventLogger = std::make_shared<EventLogger>();
489 auto event = std::make_shared<Event>("sender", "event");
490 event->messageType_ = Event::MessageType::PLUGIN_MAINTENANCE;
491 bool ret = eventLogger->CanProcessRebootEvent(*(event.get()));
492 EXPECT_EQ(ret, true);
493 std::shared_ptr<EventLoop> loop = std::make_shared<EventLoop>("eventLoop");
494 loop->StartLoop();
495 eventLogger->BindWorkLoop(loop);
496 eventLogger->threadLoop_ = loop;
497 eventLogger->OnUnorderedEvent(*(event.get()));
498 }
499
500 /**
501 * @tc.name: EventLoggerTest_OnUnorderedEvent_002
502 * @tc.desc: EventLoggerTest
503 * @tc.type: FUNC
504 */
505 HWTEST_F(EventLoggerTest, EventLoggerTest_OnUnorderedEvent_002, TestSize.Level3)
506 {
507 auto eventLogger = std::make_shared<EventLogger>();
508 auto event = std::make_shared<Event>("sender", "event");
509 event->messageType_ = Event::MessageType::TELEMETRY_EVENT;
510 #ifdef HILOG_CATCHER_ENABLE
511 eventLogger->OnUnorderedEvent(*(event.get()));
512 #endif
513 bool ret = eventLogger->CanProcessRebootEvent(*(event.get()));
514 EXPECT_EQ(ret, false);
515 }
516
517 /**
518 * @tc.name: EventLoggerTest_ClearOldFile_001
519 * @tc.desc: Loging aging test
520 * @tc.type: FUNC
521 */
522 HWTEST_F(EventLoggerTest, EventLoggerTest_ClearOldFile_001, TestSize.Level3)
523 {
524 auto eventLogger = std::make_shared<EventLogger>();
525 eventLogger->OnLoad();
526 sleep(1);
527 HiSysEventWrite(HiSysEvent::Domain::AAFWK, "THREAD_BLOCK_3S", HiSysEvent::EventType::FAULT,
528 "MODULE", "foundation", "MSG", "test remove");
529 sleep(3);
530 HiSysEventWrite(HiSysEvent::Domain::AAFWK, "THREAD_BLOCK_6S", HiSysEvent::EventType::FAULT,
531 "MODULE", "foundation", "MSG", "test remove", "HITRACE_ID", "1234", "SPAN_ID", "34");
532 sleep(3);
533 HiSysEventWrite(HiSysEvent::Domain::AAFWK, "LIFECYCLE_HALF_TIMEOUT", HiSysEvent::EventType::FAULT,
534 "MODULE", "foundation", "MSG", "test remove");
535 std::vector<LogFile> logFileList = eventLogger->logStore_->GetLogFiles();
536 auto beforeSize = static_cast<long>(logFileList.size());
537 printf("Before-- logFileList num: %ld\n", beforeSize);
538 auto iter = logFileList.begin();
539 while (iter != logFileList.end()) {
540 auto beforeIter = iter;
541 iter++;
542 EXPECT_TRUE(beforeIter < iter);
543 }
544 auto folderSize = FileUtil::GetFolderSize(EventLogger::LOGGER_EVENT_LOG_PATH);
545 uint32_t maxSize = 10240; // test value
546 eventLogger->logStore_->SetMaxSize(maxSize);
547 eventLogger->logStore_->ClearOldestFilesIfNeeded();
548 auto size = FileUtil::GetFolderSize(EventLogger::LOGGER_EVENT_LOG_PATH);
549 auto listSize = static_cast<long>(eventLogger->logStore_->GetLogFiles().size());
550 printf("After-- logFileList num: %ld\n", listSize);
551 if (listSize == beforeSize) {
552 EXPECT_TRUE(size == folderSize);
553 } else {
554 EXPECT_TRUE(size < folderSize);
555 }
556 eventLogger->OnUnload();
557 }
558
559 /**
560 * @tc.name: EventLoggerTest_GetFile_001
561 * @tc.desc: EventLoggerTest
562 * @tc.type: FUNC
563 */
564 HWTEST_F(EventLoggerTest, EventLoggerTest_GetFile_001, TestSize.Level3)
565 {
566 auto eventLogger = std::make_shared<EventLogger>();
567 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
568 std::string testName = "GET_DISPLAY_SNAPSHOT";
569 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
570 nullptr, jsonStr);
571 sysEvent->SetEventValue("PID", getpid());
572 sysEvent->eventName_ = "GET_DISPLAY_SNAPSHOT";
573 sysEvent->happenTime_ = TimeUtil::GetMilliseconds();
574 sysEvent->eventId_ = 1;
575 std::string logFile = "";
576 eventLogger->StartFfrtDump(sysEvent);
577 int result = eventLogger->GetFile(sysEvent, logFile, true);
578 printf("GetFile result=%d\n", result);
579 EXPECT_TRUE(logFile.size() > 0);
580 result = eventLogger->GetFile(sysEvent, logFile, false);
581 EXPECT_TRUE(result > 0);
582 EXPECT_TRUE(logFile.size() > 0);
583 sysEvent->eventName_ = "TEST";
584 sysEvent->SetEventValue("PID", 10001); // test value
585 eventLogger->StartFfrtDump(sysEvent);
586 result = eventLogger->GetFile(sysEvent, logFile, false);
587 EXPECT_TRUE(result > 0);
588 EXPECT_TRUE(logFile.size() > 0);
589 result = eventLogger->GetFile(sysEvent, logFile, true);
590 printf("GetFile result=%d\n", result);
591 EXPECT_TRUE(logFile.size() > 0);
592 }
593
594 /**
595 * @tc.name: EventLoggerTest_ReportUserPanicWarning_001
596 * @tc.desc: EventLoggerTest
597 * @tc.type: FUNC
598 */
599 HWTEST_F(EventLoggerTest, EventLoggerTest_ReportUserPanicWarning_001, TestSize.Level0)
600 {
601 auto eventLogger = std::make_shared<EventLogger>();
602 eventLogger->OnLoad();
603 sleep(1);
604
605 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
606 long pid = getpid();
607 #ifdef WINDOW_MANAGER_ENABLE
608 uint64_t curentTime = TimeUtil::GetMilliseconds();
609 while (eventLogger->backTimes_.size() < 4) {
610 eventLogger->backTimes_.push_back(curentTime);
611 curentTime += 100;
612 }
613
614 std::shared_ptr<SysEvent> sysEvent2 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
615 nullptr, jsonStr);
616 sysEvent2->SetEventValue("PID", pid);
617 sysEvent2->happenTime_ = TimeUtil::GetMilliseconds();
618 EventFocusListener::lastChangedTime_ = 0;
619 eventLogger->ReportUserPanicWarning(sysEvent2, pid);
620 #endif
621
622 std::shared_ptr<SysEvent> sysEvent3 = std::make_shared<SysEvent>("FREQUENT_CLICK_WARNING",
623 nullptr, jsonStr);
624 sysEvent3->SetEventValue("PID", pid);
625 sysEvent3->happenTime_ = 4000; // test value
626 #ifdef WINDOW_MANAGER_ENABLE
627 eventLogger->ReportUserPanicWarning(sysEvent3, pid);
628 sysEvent3->happenTime_ = 2500; // test value
629 eventLogger->ReportUserPanicWarning(sysEvent3, pid);
630 #endif
631 EXPECT_TRUE(true);
632 eventLogger->OnUnload();
633 }
634
635 /**
636 * @tc.name: EventLoggerTest_ReportUserPanicWarning_002
637 * @tc.desc: EventLoggerTest
638 * @tc.type: FUNC
639 */
640 HWTEST_F(EventLoggerTest, EventLoggerTest_ReportUserPanicWarning_002, TestSize.Level3)
641 {
642 auto eventLogger = std::make_shared<EventLogger>();
643 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
644 long pid = getpid();
645 std::string testName = "FREQUENT_CLICK_WARNING";
646 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
647 nullptr, jsonStr);
648 event->eventName_ = testName;
649 event->SetEventValue("PID", pid);
650 #ifdef WINDOW_MANAGER_ENABLE
651 EventFocusListener::lastChangedTime_ = 900; // test value
652 event->happenTime_ = 1000; // test value
653 eventLogger->ReportUserPanicWarning(event, pid);
654 EXPECT_TRUE(eventLogger->backTimes_.empty());
655 event->happenTime_ = 4000; // test value
656 event->SetEventValue("PROCESS_NAME", "EventLoggerTest_ReportUserPanicWarning_002");
657 eventLogger->ReportUserPanicWarning(event, pid);
658 EXPECT_TRUE(eventLogger->backTimes_.empty());
659 #endif
660 }
661
662 /**
663 * @tc.name: EventLoggerTest_ReportUserPanicWarning_003
664 * @tc.desc: EventLoggerTest
665 * @tc.type: FUNC
666 */
667 HWTEST_F(EventLoggerTest, EventLoggerTest_ReportUserPanicWarning_003, TestSize.Level3)
668 {
669 auto eventLogger = std::make_shared<EventLogger>();
670 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
671 long pid = getpid();
672 std::string testName = "EventLoggerTest_ReportUserPanicWarning_003";
673 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
674 nullptr, jsonStr);
675 event->eventName_ = testName;
676 event->SetEventValue("PID", pid);
677 #ifdef WINDOW_MANAGER_ENABLE
678 EXPECT_TRUE(eventLogger->backTimes_.empty());
679 EventFocusListener::lastChangedTime_ = 0; // test value
680 event->happenTime_ = 3000; // test value
681 eventLogger->ReportUserPanicWarning(event, pid);
682 EXPECT_EQ(eventLogger->backTimes_.size(), 1);
683 while (eventLogger->backTimes_.size() <= 5) {
684 int count = 1000; // test value
685 eventLogger->backTimes_.push_back(count++);
686 }
687 EXPECT_TRUE(eventLogger->backTimes_.size() > 5);
688 eventLogger->ReportUserPanicWarning(event, pid);
689 EXPECT_TRUE(eventLogger->backTimes_.empty());
690 #endif
691 }
692
693 /**
694 * @tc.name: EventLoggerTest_ReportUserPanicWarning_004
695 * @tc.desc: EventLoggerTest
696 * @tc.type: FUNC
697 */
698 HWTEST_F(EventLoggerTest, EventLoggerTest_ReportUserPanicWarning_004, TestSize.Level3)
699 {
700 auto eventLogger = std::make_shared<EventLogger>();
701 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
702 long pid = getpid();
703 std::string testName = "EventLoggerTest_ReportUserPanicWarning_004";
704 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
705 nullptr, jsonStr);
706 event->eventName_ = testName;
707 event->SetEventValue("PID", pid);
708 #ifdef WINDOW_MANAGER_ENABLE
709 EXPECT_TRUE(eventLogger->backTimes_.empty());
710 EventFocusListener::lastChangedTime_ = 0; // test value
711 event->happenTime_ = 5000; // test value
712 while (eventLogger->backTimes_.size() < 5) {
713 int count = 1000; // test value
714 eventLogger->backTimes_.push_back(count++);
715 }
716 EXPECT_TRUE(eventLogger->backTimes_.size() > 0);
717 eventLogger->ReportUserPanicWarning(event, pid);
718 EXPECT_EQ(eventLogger->backTimes_.size(), 4);
719 #endif
720 }
721
722 /**
723 * @tc.name: EventLoggerTest_WriteCallStack_001
724 * @tc.desc: EventLoggerTest
725 * @tc.type: FUNC
726 */
727 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteCallStack_001, TestSize.Level3)
728 {
729 auto eventLogger = std::make_shared<EventLogger>();
730 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
731 long pid = getpid();
732 std::string testName = "EventLoggerTest_WriteCallStack_001";
733 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
734 nullptr, jsonStr);
735 eventLogger->WriteCallStack(event, 0);
736 event->SetEventValue("PID", pid);
737 event->SetEventValue("EVENT_KEY_FORM_BLOCK_CALLSTACK", testName);
738 event->SetEventValue("EVENT_KEY_FORM_BLOCK_APPNAME", testName);
739 event->eventName_ = "FORM_BLOCK_CALLSTACK";
740 event->domain_ = "FORM_MANAGER";
741 eventLogger->WriteCallStack(event, 0);
742 EXPECT_TRUE(!event->GetEventValue("EVENT_KEY_FORM_BLOCK_APPNAME").empty());
743 }
744
745 /**
746 * @tc.name: EventLoggerTest_RegisterFocusListener_001
747 * @tc.desc: EventLoggerTest
748 * @tc.type: FUNC
749 */
750 HWTEST_F(EventLoggerTest, EventLoggerTest_RegisterFocusListener_001, TestSize.Level3)
751 {
752 auto eventLogger = std::make_shared<EventLogger>();
753 eventLogger->OnLoad();
754 sleep(1);
755 #ifdef WINDOW_MANAGER_ENABLE
756 EventFocusListener::RegisterFocusListener();
757 EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
758 eventLogger->OnUnload();
759 EXPECT_EQ(EventFocusListener::registerState_, EventFocusListener::UNREGISTERED);
760 #else
761 eventLogger->OnUnload();
762 #endif
763 }
764
765 /**
766 * @tc.name: EventLoggerTest_FreezeFilterTraceOn_001
767 * @tc.desc: EventLoggerTest
768 * @tc.type: FUNC
769 */
770 HWTEST_F(EventLoggerTest, EventLoggerTest_FreezeFilterTraceOn_001, TestSize.Level3)
771 {
772 auto eventLogger = std::make_shared<EventLogger>();
773 #ifdef HITRACE_CATCHER_ENABLE
774 std::string testName = "EventLoggerTest_FreezeFilterTraceOn_001";
775 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
776 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
777 nullptr, jsonStr);
778 event->SetEventValue("PROCESS_NAME", "EventLoggerTest");
779 event->eventName_ = "APP_INPUT_BLOCK";
780 eventLogger->FreezeFilterTraceOn(event, true);
781 eventLogger->FreezeFilterTraceOn(event, false);
782 event->eventName_ = "THREAD_BLOCK_3S";
783 eventLogger->FreezeFilterTraceOn(event, false);
784 #endif
785 EXPECT_EQ(event->GetEventValue("PACKAGE_NAME"), "");
786 }
787
788 /**
789 * @tc.name: EventLoggerTest_IsHandleAppfreeze_001
790 * @tc.desc: EventLoggerTest
791 * @tc.type: FUNC
792 */
793 HWTEST_F(EventLoggerTest, EventLoggerTest_IsHandleAppfreeze_001, TestSize.Level3)
794 {
795 auto eventLogger = std::make_shared<EventLogger>();
796 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
797 long pid = getpid();
798 std::string testName = "EventLoggerTest_IsHandleAppfreeze_001";
799 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
800 nullptr, jsonStr);
801 event->SetEventValue("PACKAGE_NAME", testName);
802 OHOS::system::SetParameter("hiviewdfx.appfreeze.filter_bundle_name", testName);
803 EXPECT_FALSE(eventLogger->IsHandleAppfreeze(event));
804 }
805
806 /**
807 * @tc.name: EventLoggerTest_IsKernelStack_001
808 * @tc.desc: EventLoggerTest
809 * @tc.type: FUNC
810 */
811 HWTEST_F(EventLoggerTest, EventLoggerTest_IsKernelStack_001, TestSize.Level3)
812 {
813 auto eventLogger = std::make_shared<EventLogger>();
814 std::string stack = "";
815 bool result = eventLogger->IsKernelStack(stack);
816 EXPECT_TRUE(!result);
817 stack = "Stack backtrace";
818 result = eventLogger->IsKernelStack(stack);
819 EXPECT_TRUE(result);
820 }
821
822 /**
823 * @tc.name: EventLoggerTest_GetAppFreezeStack_001
824 * @tc.desc: EventLoggerTest
825 * @tc.type: FUNC
826 */
827 HWTEST_F(EventLoggerTest, EventLoggerTest_GetAppFreezeStack_001, TestSize.Level3)
828 {
829 auto eventLogger = std::make_shared<EventLogger>();
830 std::string stack = "TEST\\nTEST\\nTEST";
831 std::string kernelStack = "";
832 std::string contentStack = "Test";
833 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
834 std::string testName = "EventLoggerTest_GetAppFreezeStack_001";
835 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
836 nullptr, jsonStr);
837 sysEvent->SetEventValue("PROCESS_NAME", testName);
838 sysEvent->SetEventValue("APP_RUNNING_UNIQUE_ID", "Test");
839 sysEvent->SetEventValue("STACK", stack);
840 sysEvent->SetEventValue("MSG", stack);
841 sysEvent->eventName_ = "UI_BLOCK_6S";
842 sysEvent->SetEventValue("BINDER_INFO", "async\\nEventLoggerTest");
843 eventLogger->GetAppFreezeStack(-1, sysEvent, stack, "msg", kernelStack);
844 EXPECT_TRUE(kernelStack.empty());
845 eventLogger->GetAppFreezeStack(1, sysEvent, stack, "msg", kernelStack);
846 EXPECT_TRUE(kernelStack.empty());
847 eventLogger->GetNoJsonStack(stack, contentStack, kernelStack, false);
848 EXPECT_TRUE(kernelStack.empty());
849 stack = "Test:Stack backtrace";
850 sysEvent->SetEventValue("STACK", stack);
851 eventLogger->GetAppFreezeStack(1, sysEvent, stack, "msg", kernelStack);
852 EXPECT_TRUE(!kernelStack.empty());
853 eventLogger->GetNoJsonStack(stack, contentStack, kernelStack, false);
854 EXPECT_TRUE(!kernelStack.empty());
855 sysEvent->SetEventValue("APP_RUNNING_UNIQUE_ID", "Test");
856 sysEvent->SetEventValue("STACK", "/data/test/log/test.txt");
857 eventLogger->GetAppFreezeStack(1, sysEvent, stack, "msg", kernelStack);
858 EXPECT_TRUE(!kernelStack.empty());
859 std::string msg = "Fault time:Test\nmainHandler dump is:\n Test\nEvent "
860 "{Test}\nLow priority event queue information:test\nTotal size of Low events : 10\n";
861 eventLogger->GetAppFreezeStack(1, sysEvent, stack, msg, kernelStack);
862 EXPECT_TRUE(!kernelStack.empty());
863 }
864
865 /**
866 * @tc.name: EventLoggerTest_WriteKernelStackToFile_001
867 * @tc.desc: EventLoggerTest
868 * @tc.type: FUNC
869 */
870 HWTEST_F(EventLoggerTest, EventLoggerTest_WriteKernelStackToFile_001, TestSize.Level3)
871 {
872 auto eventLogger = std::make_shared<EventLogger>();
873 std::string stack = "";
874 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
875 std::string testName = "EventLoggerTest_WriteKernelStackToFile_001";
876 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
877 nullptr, jsonStr);
878 event->eventName_ = testName;
879 int testValue = 1; // test value
880 event->SetEventValue("PID", testValue);
881 event->happenTime_ = TimeUtil::GetMilliseconds();
882 std::string kernelStack = "";
883 eventLogger->WriteKernelStackToFile(event, testValue, kernelStack);
884 kernelStack = "Test";
885 EXPECT_TRUE(!kernelStack.empty());
886 eventLogger->WriteKernelStackToFile(event, testValue, kernelStack);
887 }
888
889 /**
890 * @tc.name: EventLoggerTest_ParsePeerStack_001
891 * @tc.desc: EventLoggerTest
892 * @tc.type: FUNC
893 */
894 HWTEST_F(EventLoggerTest, EventLoggerTest_ParsePeerStack_001, TestSize.Level3)
895 {
896 auto eventLogger = std::make_shared<EventLogger>();
897 std::string binderInfo = "";
898 std::string binderPeerStack = "";
899 eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
900 EXPECT_TRUE(binderPeerStack.empty());
901 binderInfo = "Test";
902 eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
903 EXPECT_TRUE(binderPeerStack.empty());
904 binderInfo = "Binder catcher stacktrace, type is peer, pid : 111\n Stack "
905 "backtrace: Test\n Binder catcher stacktrace, type is peer, pid : 112\n Test";
906 eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
907 EXPECT_TRUE(!binderPeerStack.empty());
908 binderPeerStack = "";
909 binderInfo = "111\n Stack backtrace: Test\n 112\n Test";
910 eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
911 EXPECT_TRUE(binderPeerStack.empty());
912 }
913
914 /**
915 * @tc.name: EventLoggerTest_GetEventPid_001
916 * @tc.desc: EventLoggerTest
917 * @tc.type: FUNC
918 */
919 HWTEST_F(EventLoggerTest, EventLoggerTest_GetEventPid_001, TestSize.Level0)
920 {
921 auto eventLogger = std::make_shared<EventLogger>();
922 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
923 std::string testName = "EventLoggerTest_GetEventPid_001";
924 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
925 nullptr, jsonStr);
926 event->SetEventValue("PID", 1);
927 event->SetEventValue("PACKAGE_NAME", testName);
928 event->eventName_ = testName;
929 EXPECT_TRUE(eventLogger->GetEventPid(event) > 0);
930 }
931
932 /**
933 * @tc.name: EventLoggerTest_GetEventPid_002
934 * @tc.desc: EventLoggerTest
935 * @tc.type: FUNC
936 */
937 HWTEST_F(EventLoggerTest, EventLoggerTest_GetEventPid_002, TestSize.Level3)
938 {
939 auto eventLogger = std::make_shared<EventLogger>();
940 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
941 std::string testName = "EventLoggerTest_GetEventPid_002";
942 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
943 nullptr, jsonStr);
944 event->SetEventValue("PID", 0);
945 EXPECT_TRUE(event->GetEventIntValue("PID") <= 0);
946 event->SetEventValue("PACKAGE_NAME", "foundation");
947 event->eventName_ = testName;
948 EXPECT_TRUE(eventLogger->GetEventPid(event) > 0);
949 }
950
951 /**
952 * @tc.name: EventLoggerTest_SetEventTerminalBinder_001
953 * @tc.desc: EventLoggerTest
954 * @tc.type: FUNC
955 */
956 HWTEST_F(EventLoggerTest, EventLoggerTest_SetEventTerminalBinder_001, TestSize.Level3)
957 {
958 auto eventLogger = std::make_shared<EventLogger>();
959 eventLogger->OnLoad();
960 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
961 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>("testSender", nullptr, jsonStr);
962 event->eventName_ = "THREAD_BLOCK_3S";
963 std::string threadStack = "";
964 eventLogger->SetEventTerminalBinder(event, threadStack, 0);
965 EXPECT_EQ(event->GetEventValue("TERMINAL_THREAD_STACK"), "");
966 threadStack = "thread_block_3s thread stack";
967 int fd = eventLogger->logStore_->CreateLogFile("test_set_terminal_binder");
968 if (fd > 0) {
969 eventLogger->SetEventTerminalBinder(event, threadStack, fd);
970 EXPECT_EQ(event->GetEventValue("TERMINAL_THREAD_STACK"), "thread_block_3s thread stack");
971 close(fd);
972 }
973 threadStack = "ipc_full thread stack";
974 event->eventName_ = "IPC_FULL";
975 eventLogger->SetEventTerminalBinder(event, threadStack, 0);
976 EXPECT_EQ(event->GetEventValue("TERMINAL_THREAD_STACK"), "ipc_full thread stack");
977 eventLogger->OnUnload();
978 }
979
980 /**
981 * @tc.name: EventLoggerTest_CheckScreenOnRepeat_001
982 * @tc.desc: EventLoggerTest
983 * @tc.type: FUNC
984 */
985 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckScreenOnRepeat_001, TestSize.Level3)
986 {
987 auto eventLogger = std::make_shared<EventLogger>();
988 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
989 std::string testName = "APP_INPUT_BLOCK";
990 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName, nullptr, jsonStr);
991 event->eventName_ = testName;
992 eventLogger->CheckScreenOnRepeat(event);
993 EXPECT_TRUE(event->eventName_ != "SCREEN_ON");
994 }
995
996 /**
997 * @tc.name: EventLoggerTest_AddBootScanEvent_001
998 * @tc.desc: EventLoggerTest
999 * @tc.type: FUNC
1000 */
1001 HWTEST_F(EventLoggerTest, EventLoggerTest_AddBootScanEvent_001, TestSize.Level3)
1002 {
1003 auto eventLogger = std::make_shared<EventLogger>();
1004 eventLogger->AddBootScanEvent();
1005 EXPECT_TRUE(eventLogger != nullptr);
1006 }
1007
1008 /**
1009 * @tc.name: EventLoggerTest_StartBootScan_001
1010 * @tc.desc: EventLoggerTest
1011 * @tc.type: FUNC
1012 */
1013 HWTEST_F(EventLoggerTest, EventLoggerTest_StartBootScan_001, TestSize.Level3)
1014 {
1015 std::string path = "/data/log/faultlog/freeze/appfreeze-com.test.demo-20020191-20250320154130";
1016 auto fd = open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, DEFAULT_MODE);
1017 if (fd < 0) {
1018 printf("Fail to create File. errno: %d\n", errno);
1019 FAIL();
1020 }
1021 FileUtil::SaveStringToFd(fd, "\ntesttest\nPID:12345\nSTRINGID:THREAD_BLOCK_6S\nTest\n");
1022 StartBootScan();
1023 close(fd);
1024 }
1025
1026 /**
1027 * @tc.name: EventLoggerTest_StartBootScan_002
1028 * @tc.desc: EventLoggerTest
1029 * @tc.type: FUNC
1030 */
1031 HWTEST_F(EventLoggerTest, EventLoggerTest_StartBootScan_002, TestSize.Level3)
1032 {
1033 std::string path = "/data/log/faultlog/freeze/crash-com.test.demo-20020191-20250320154130";
1034 auto fd = open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, DEFAULT_MODE);
1035 if (fd < 0) {
1036 printf("Fail to create File. errno: %d\n", errno);
1037 FAIL();
1038 }
1039 FileUtil::SaveStringToFd(fd, "\ntesttest\nPID:12345\nSTRINGID:THREAD_BLOCK_6S\nTest\n");
1040 StartBootScan();
1041 close(fd);
1042 }
1043
1044 /**
1045 * @tc.name: EventLoggerTest_GetFileLastAccessTimeStamp_001
1046 * @tc.desc: EventLoggerTest
1047 * @tc.type: FUNC
1048 */
1049 HWTEST_F(EventLoggerTest, EventLoggerTest_GetFileLastAccessTimeStamp_001, TestSize.Level3)
1050 {
1051 time_t ret = GetFileLastAccessTimeStamp("EventLoggerTest");
1052 ret = GetFileLastAccessTimeStamp("/data/test/log/test.txt");
1053 EXPECT_TRUE(ret >= 0);
1054 }
1055
1056 /**
1057 * @tc.name: EventLoggerTest_SaveFreezeInfoToFile_001
1058 * @tc.desc: EventLoggerTest
1059 * @tc.type: FUNC
1060 */
1061 HWTEST_F(EventLoggerTest, EventLoggerTest_SaveFreezeInfoToFile_001, TestSize.Level3)
1062 {
1063 auto eventLogger = std::make_shared<EventLogger>();
1064 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
1065 std::string testName = "EventLoggerTest_SaveFreezeInfoToFile_001";
1066 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
1067 nullptr, jsonStr);
1068 eventLogger->SaveFreezeInfoToFile(event);
1069 std::string path = "/data/test/log/test.txt";
1070 auto fd = open(path.c_str(), O_CREAT | O_WRONLY | O_TRUNC, DEFAULT_MODE);
1071 if (fd < 0) {
1072 printf("Fail to create File. errno: %d\n", errno);
1073 FAIL();
1074 }
1075 event->SetEventValue("FREEZE_INFO_PATH", path);
1076 eventLogger->SaveFreezeInfoToFile(event);
1077 FileUtil::SaveStringToFd(fd, "\123456\n");
1078 close(fd);
1079 event->SetEventValue("UID", getuid());
1080 event->SetEventValue("PACKAGE_NAME", "EventLoggerTest");
1081 eventLogger->SaveFreezeInfoToFile(event);
1082 EXPECT_TRUE(eventLogger != nullptr);
1083 }
1084
1085 /**
1086 * @tc.name: EventLoggerTest_CheckFfrtEvent_001
1087 * @tc.desc: EventLoggerTest
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckFfrtEvent_001, TestSize.Level3)
1091 {
1092 auto eventLogger = std::make_shared<EventLogger>();
1093 auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
1094 std::string testName = "EventLoggerTest_CheckFfrtEvent_001";
1095 std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
1096 nullptr, jsonStr);
1097 bool ret = eventLogger->CheckFfrtEvent(event);
1098 EXPECT_TRUE(ret);
1099 event->eventName_ = "CONGESTION";
1100 ret = eventLogger->CheckFfrtEvent(event);
1101 printf("ret: %d\n", ret);
1102 event->SetEventValue("SENARIO", "Long_Task");
1103 eventLogger->CheckFfrtEvent(event);
1104 }
1105
1106 /**
1107 * @tc.name: EventLoggerTest_CheckFfrtEvent_002
1108 * @tc.desc: EventLoggerTest
1109 * @tc.type: FUNC
1110 */
1111 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckFfrtEvent_002, TestSize.Level3)
1112 {
1113 auto eventLogger = std::make_shared<EventLogger>();
1114 int ret = HiSysEventWrite(HiSysEvent::Domain::FFRT, "CONGESTION", HiSysEvent::EventType::FAULT,
1115 "SENARIO", "Long_Task",
1116 "PROCESS_NAME", "foundation",
1117 "MSG", "test remove");
1118 sleep(1);
1119 EXPECT_TRUE(ret == 0);
1120
1121 ret = HiSysEventWrite(HiSysEvent::Domain::FFRT, "CONGESTION", HiSysEvent::EventType::FAULT,
1122 "SENARIO", "Test",
1123 "PROCESS_NAME", "EventLoggerTest_CheckFfrtEvent_002",
1124 "MSG", "test remove");
1125 sleep(1);
1126 EXPECT_TRUE(ret == 0);
1127
1128 ret = HiSysEventWrite(HiSysEvent::Domain::FFRT, "CONGESTION", HiSysEvent::EventType::FAULT,
1129 "SENARIO", "Test",
1130 "PROCESS_NAME", "foundation",
1131 "MSG", "test remove");
1132 sleep(1);
1133 EXPECT_TRUE(ret == 0);
1134 EXPECT_TRUE(eventLogger);
1135 }
1136 } // namespace HiviewDFX
1137 } // namespace OHOS
1138