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 
35 using namespace testing::ext;
36 using namespace OHOS::HiviewDFX;
37 namespace OHOS {
38 namespace HiviewDFX {
39 SysEventSource source;
SetUp()40 void EventLoggerTest::SetUp()
41 {
42     printf("SetUp.\n");
43 }
44 
TearDown()45 void EventLoggerTest::TearDown()
46 {
47     printf("TearDown.\n");
48 }
49 
SetUpTestCase()50 void EventLoggerTest::SetUpTestCase()
51 {
52     HiviewPlatform platform;
53     source.SetHiviewContext(&platform);
54     source.OnLoad();
55 }
56 
TearDownTestCase()57 void EventLoggerTest::TearDownTestCase()
58 {
59     source.OnUnload();
60 }
61 
62 /**
63  * @tc.name: EventLoggerTest_OnEvent_001
64  * @tc.desc: add testcase coverage
65  * @tc.type: FUNC
66  */
HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_001, TestSize.Level3)67 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_001, TestSize.Level3)
68 {
69     auto eventLogger = std::make_shared<EventLogger>();
70     std::shared_ptr<Event> event = nullptr;
71     EXPECT_FALSE(eventLogger->OnEvent(event));
72 }
73 
74 /**
75  * @tc.name: EventLoggerTest_OnEvent_002
76  * @tc.desc: add testcase coverage
77  * @tc.type: FUNC
78  */
HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_002, TestSize.Level3)79 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_002, TestSize.Level3)
80 {
81     auto eventLogger = std::make_shared<EventLogger>();
82     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
83     std::shared_ptr<SysEvent> sysEvent1 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
84         nullptr, jsonStr);
85     sysEvent1->eventName_ = "GESTURE_NAVIGATION_BACK";
86     sysEvent1->SetEventValue("PID", getpid());
87     std::shared_ptr<OHOS::HiviewDFX::Event> event1 = std::static_pointer_cast<Event>(sysEvent1);
88     EXPECT_EQ(eventLogger->OnEvent(event1), true);
89 #ifdef WINDOW_MANAGER_ENABLE
90     sptr<Rosen::FocusChangeInfo> focusChangeInfo;
91     sptr<EventFocusListener> eventFocusListener_ = EventFocusListener::GetInstance();
92     eventFocusListener_->OnFocused(focusChangeInfo);
93     eventFocusListener_->OnUnfocused(focusChangeInfo);
94     EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
95     EXPECT_EQ(eventLogger->OnEvent(event1), true);
96 #endif
97 }
98 
99 /**
100  * @tc.name: EventLoggerTest_OnEvent_003
101  * @tc.desc: add testcase coverage
102  * @tc.type: FUNC
103  */
HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_003, TestSize.Level3)104 HWTEST_F(EventLoggerTest, EventLoggerTest_OnEvent_003, TestSize.Level3)
105 {
106     auto eventLogger = std::make_shared<EventLogger>();
107     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
108     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>("EventLoggerTest_001",
109         nullptr, jsonStr);
110     EXPECT_EQ(eventLogger->IsHandleAppfreeze(sysEvent), true);
111     sysEvent->SetEventValue("PACKAGE_NAME", "EventLoggerTest");
112     EXPECT_EQ(eventLogger->IsHandleAppfreeze(sysEvent), true);
113     sysEvent->SetEventValue("PID", 0);
114     sysEvent->SetEventValue("eventLog_action", "");
115     std::shared_ptr<OHOS::HiviewDFX::Event> event = std::static_pointer_cast<Event>(sysEvent);
116     EXPECT_EQ(eventLogger->OnEvent(event), true);
117     sysEvent->eventName_ = "THREAD_BLOCK_6S";
118     event = std::static_pointer_cast<Event>(sysEvent);
119     EXPECT_EQ(eventLogger->OnEvent(event), true);
120 }
121 
122 /**
123  * @tc.name: EventLoggerTest_IsInterestedPipelineEvent_001
124  * @tc.desc: add testcase coverage
125  * @tc.type: FUNC
126  */
HWTEST_F(EventLoggerTest, EventLoggerTest_IsInterestedPipelineEvent_001, TestSize.Level3)127 HWTEST_F(EventLoggerTest, EventLoggerTest_IsInterestedPipelineEvent_001, TestSize.Level3)
128 {
129     auto eventLogger = std::make_shared<EventLogger>();
130     EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(nullptr));
131     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
132     std::string testName = "EventLoggerTest_002";
133     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
134         nullptr, jsonStr);
135     sysEvent->eventId_ = 1000001;
136     EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(sysEvent));
137     sysEvent->eventId_ = 1;
138     sysEvent->eventName_ = "UninterestedEvent";
139     EXPECT_FALSE(eventLogger->IsInterestedPipelineEvent(sysEvent));
140     sysEvent->eventName_ = "InterestedEvent";
141     eventLogger->eventLoggerConfig_[sysEvent->eventName_] =
142         EventLoggerConfig::EventLoggerConfigData();
143     EXPECT_TRUE(eventLogger->IsInterestedPipelineEvent(sysEvent));
144 }
145 
146 /**
147  * @tc.name: EventLoggerTest_CheckProcessRepeatFreeze_001
148  * @tc.desc: add testcase coverage
149  * @tc.type: FUNC
150  */
HWTEST_F(EventLoggerTest, EventLoggerTest_CheckProcessRepeatFreeze_001, TestSize.Level3)151 HWTEST_F(EventLoggerTest, EventLoggerTest_CheckProcessRepeatFreeze_001, TestSize.Level3)
152 {
153     auto eventLogger = std::make_shared<EventLogger>();
154     long pid = getprocpid();
155     eventLogger->lastPid_ = pid;
156     bool ret = eventLogger->CheckProcessRepeatFreeze("THREAD_BLOCK_6S", pid);
157     EXPECT_TRUE(ret);
158 }
159 
160 /**
161  * @tc.name: EventLoggerTest_002
162  * @tc.desc: add testcase coverage
163  * @tc.type: FUNC
164  */
HWTEST_F(EventLoggerTest, EventLoggerTest_002, TestSize.Level3)165 HWTEST_F(EventLoggerTest, EventLoggerTest_002, TestSize.Level3)
166 {
167     auto eventLogger = std::make_shared<EventLogger>();
168     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
169     std::string testName = "EventLoggerTest_002";
170     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
171         nullptr, jsonStr);
172     sysEvent->SetEventValue("EVENTNAME", testName);
173     sysEvent->SetEventValue("MODULE_NAME", testName);
174     sysEvent->SetEventValue("PACKAGE_NAME", testName);
175     sysEvent->SetEventValue("PROCESS_NAME", testName);
176     sysEvent->SetEventValue("eventLog_action", "pb:1");
177     sysEvent->SetEventValue("eventLog_interval", 1);
178     sysEvent->SetEventValue("STACK", "TEST\\nTEST\\nTEST");
179     sysEvent->SetEventValue("MSG", "TEST\\nTEST\\nTEST");
180     EXPECT_EQ(eventLogger->WriteCommonHead(1, sysEvent), true);
181     sysEvent->eventName_ = "UI_BLOCK_6S";
182     sysEvent->SetEventValue("BINDER_INFO", "async\\nEventLoggerTest");
183     std::vector<std::string> binderPids;
184     EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids), true);
185     sysEvent->SetEventValue("BINDER_INFO", "context");
186     binderPids.clear();
187     EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids), true);
188     std::string binderInfo = "1:1\\n1:1\\n" + std::to_string(getpid()) +
189         ":1\\n1:1\\n1:1\\n1:1\\n1:1";
190     sysEvent->SetEventValue("BINDER_INFO", binderInfo);
191     binderPids.clear();
192     EXPECT_EQ(eventLogger->WriteFreezeJsonInfo(1, 1, sysEvent, binderPids), true);
193     eventLogger->IsInterestedPipelineEvent(sysEvent);
194 }
195 
196 /**
197  * @tc.name: EventLoggerTest_003
198  * @tc.desc: add testcase coverage
199  * @tc.type: FUNC
200  */
HWTEST_F(EventLoggerTest, EventLoggerTest_003, TestSize.Level3)201 HWTEST_F(EventLoggerTest, EventLoggerTest_003, TestSize.Level3)
202 {
203     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
204     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>("EventLoggerTest_003",
205         nullptr, jsonStr);
206     sysEvent->SetEventValue("eventLog_interval", 1);
207     sysEvent->SetEventValue("PID", getpid());
208     sysEvent->SetEventValue("NAME", "EventLoggerTest_003");
209     auto eventLogger = std::make_shared<EventLogger>();
210     eventLogger->eventTagTime_["NAME"] = 100;
211     eventLogger->eventTagTime_["EventLoggerTest_003"] = 100;
212     bool ret = eventLogger->JudgmentRateLimiting(sysEvent);
213     EXPECT_EQ(ret, true);
214     sysEvent->eventName_ = "GET_DISPLAY_SNAPSHOT";
215     sysEvent->happenTime_ = TimeUtil::GetMilliseconds();
216     sysEvent->SetEventValue("UID", getuid());
217     sysEvent->SetValue("eventLog_action", "pb:1\npb:2");
218     std::shared_ptr<EventLoop> loop = std::make_shared<EventLoop>("eventLoop");
219     loop->StartLoop();
220     eventLogger->BindWorkLoop(loop);
221     eventLogger->threadLoop_ = loop;
222     eventLogger->StartLogCollect(sysEvent);
223     ret = eventLogger->UpdateDB(sysEvent, "nolog");
224     EXPECT_EQ(ret, true);
225 }
226 
227 /**
228  * @tc.name: EventLoggerTest_004
229  * @tc.desc: add testcase coverage
230  * @tc.type: FUNC
231  */
HWTEST_F(EventLoggerTest, EventLoggerTest_004, TestSize.Level3)232 HWTEST_F(EventLoggerTest, EventLoggerTest_004, TestSize.Level3)
233 {
234     auto eventLogger = std::make_shared<EventLogger>();
235     eventLogger->cmdlineContent_ = "reboot_reason = EventLoggerTest "
236         "normal_reset_type = EventLoggerTest\\n";
237     eventLogger->rebootReasons_.push_back("EventLoggerTest");
238     std::string ret = eventLogger->GetRebootReason();
239     EXPECT_EQ(ret, "LONG_PRESS");
240     eventLogger->ProcessRebootEvent();
241     eventLogger->cmdlineContent_ = "reboot_reason";
242     ret = eventLogger->GetRebootReason();
243     EXPECT_EQ(ret, "");
244     eventLogger->ProcessRebootEvent();
245     EXPECT_EQ(eventLogger->GetListenerName(), "EventLogger");
246 }
247 
248 /**
249  * @tc.name: EventLoggerTest_005
250  * @tc.desc: add testcase coverage
251  * @tc.type: FUNC
252  */
HWTEST_F(EventLoggerTest, EventLoggerTest_005, TestSize.Level3)253 HWTEST_F(EventLoggerTest, EventLoggerTest_005, TestSize.Level3)
254 {
255     auto eventLogger = std::make_shared<EventLogger>();
256     eventLogger->GetCmdlineContent();
257     eventLogger->GetRebootReasonConfig();
258     auto event = std::make_shared<Event>("sender", "event");
259     event->messageType_ = Event::MessageType::PLUGIN_MAINTENANCE;
260     bool ret = eventLogger->CanProcessRebootEvent(*(event.get()));
261     EXPECT_EQ(ret, true);
262 }
263 
264 /**
265  * @tc.name: EventLoggerTest_006
266  * @tc.desc: Loging aging test
267  * @tc.type: FUNC
268  */
HWTEST_F(EventLoggerTest, EventLoggerTest_006, TestSize.Level3)269 HWTEST_F(EventLoggerTest, EventLoggerTest_006, TestSize.Level3)
270 {
271     auto eventLogger = std::make_shared<EventLogger>();
272     eventLogger->OnLoad();
273     HiSysEventWrite(HiSysEvent::Domain::AAFWK, "THREAD_BLOCK_3S", HiSysEvent::EventType::FAULT,
274         "MODULE", "foundation", "MSG", "test remove");
275     sleep(3);
276     HiSysEventWrite(HiSysEvent::Domain::AAFWK, "THREAD_BLOCK_6S", HiSysEvent::EventType::FAULT,
277         "MODULE", "foundation", "MSG", "test remove");
278     sleep(3);
279     HiSysEventWrite(HiSysEvent::Domain::AAFWK, "LIFECYCLE_HALF_TIMEOUT", HiSysEvent::EventType::FAULT,
280         "MODULE", "foundation", "MSG", "test remove");
281     std::vector<LogFile> logFileList = eventLogger->logStore_->GetLogFiles();
282     auto beforeSize = static_cast<long>(logFileList.size());
283     printf("Before-- logFileList num: %ld\n", beforeSize);
284     auto iter = logFileList.begin();
285     while (iter != logFileList.end()) {
286         auto beforeIter = iter;
287         iter++;
288         EXPECT_TRUE(beforeIter < iter);
289     }
290     auto folderSize = FileUtil::GetFolderSize(EventLogger::LOGGER_EVENT_LOG_PATH);
291     uint32_t maxSize = 10240; // test value
292     eventLogger->logStore_->SetMaxSize(maxSize);
293     eventLogger->logStore_->ClearOldestFilesIfNeeded();
294     auto size = FileUtil::GetFolderSize(EventLogger::LOGGER_EVENT_LOG_PATH);
295     auto listSize = static_cast<long>(eventLogger->logStore_->GetLogFiles().size());
296     printf("After-- logFileList num: %ld\n", listSize);
297     if (listSize == beforeSize) {
298         EXPECT_TRUE(size == folderSize);
299     } else {
300         EXPECT_TRUE(size < folderSize);
301     }
302     eventLogger->OnUnload();
303 }
304 
305 /**
306  * @tc.name: EventLoggerTest_007
307  * @tc.desc: add testcase coverage
308  * @tc.type: FUNC
309  */
310 HWTEST_F(EventLoggerTest, EventLoggerTest_007, TestSize.Level3)
311 {
312     auto eventLogger = std::make_shared<EventLogger>();
313     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
314     std::string testName = "GET_DISPLAY_SNAPSHOT";
315     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
316         nullptr, jsonStr);
317     sysEvent->SetEventValue("PID", getpid());
318     sysEvent->eventName_ = "GET_DISPLAY_SNAPSHOT";
319     sysEvent->happenTime_ = TimeUtil::GetMilliseconds();
320     sysEvent->eventId_ = 1;
321     std::string logFile = "";
322     eventLogger->StartFfrtDump(sysEvent);
323     int result = eventLogger->GetFile(sysEvent, logFile, true);
324     printf("GetFile result=%d\n", result);
325     EXPECT_TRUE(logFile.size() > 0);
326     result = eventLogger->GetFile(sysEvent, logFile, false);
327     EXPECT_TRUE(result > 0);
328     EXPECT_TRUE(logFile.size() > 0);
329     sysEvent->eventName_ = "TEST";
330     sysEvent->SetEventValue("PID", 10001); // test value
331     eventLogger->StartFfrtDump(sysEvent);
332     result = eventLogger->GetFile(sysEvent, logFile, false);
333     EXPECT_TRUE(result > 0);
334     EXPECT_TRUE(logFile.size() > 0);
335     result = eventLogger->GetFile(sysEvent, logFile, true);
336     printf("GetFile result=%d\n", result);
337     EXPECT_TRUE(logFile.size() > 0);
338     sysEvent->SetEventValue("FREEZE_MEMORY", "test\\ntest");
339     eventLogger->CollectMemInfo(0, sysEvent);
340 }
341 
342 /**
343  * @tc.name: EventLoggerTest_008
344  * @tc.desc: add testcase coverage
345  * @tc.type: FUNC
346  */
347 HWTEST_F(EventLoggerTest, EventLoggerTest_008, TestSize.Level3)
348 {
349     auto eventLogger = std::make_shared<EventLogger>();
350     eventLogger->OnLoad();
351 
352     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
353     long pid = getpid();
354 #ifdef WINDOW_MANAGER_ENABLE
355     EventFocusListener::RegisterFocusListener();
356     EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
357 #endif
358     uint64_t curentTime = TimeUtil::GetMilliseconds();
359     for (int i = 0; i < 5 ; i++) {
360         std::shared_ptr<SysEvent> sysEvent1 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
361             nullptr, jsonStr);
362         sysEvent1->SetEventValue("PID", pid);
363         sysEvent1->happenTime_ = curentTime;
364         std::shared_ptr<OHOS::HiviewDFX::Event> event1 = std::static_pointer_cast<Event>(sysEvent1);
365         EXPECT_EQ(eventLogger->OnEvent(event1), true);
366         usleep(200 * 1000);
367         curentTime += 200;
368     }
369 
370     std::shared_ptr<SysEvent> sysEvent2 = std::make_shared<SysEvent>("FREQUENT_CLICK_WARNING",
371         nullptr, jsonStr);
372     sysEvent2->SetEventValue("PID", pid);
373     sysEvent2->happenTime_ = TimeUtil::GetMilliseconds();
374     std::shared_ptr<OHOS::HiviewDFX::Event> event2 = std::static_pointer_cast<Event>(sysEvent2);
375     EXPECT_EQ(eventLogger->OnEvent(event2), true);
376 
377     sysEvent2->eventName_ = "FORM_BLOCK_CALLSTACK";
378     sysEvent2->domain_ = "FORM_MANAGER";
379     eventLogger->WriteCallStack(sysEvent2, 0);
380 }
381 
382 /**
383  * @tc.name: EventLoggerTest_009
384  * @tc.desc: add testcase coverage
385  * @tc.type: FUNC
386  */
387 HWTEST_F(EventLoggerTest, EventLoggerTest_009, TestSize.Level3)
388 {
389     auto eventLogger = std::make_shared<EventLogger>();
390     eventLogger->OnLoad();
391 
392     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
393     long pid = getpid();
394 #ifdef WINDOW_MANAGER_ENABLE
395     uint64_t curentTime = TimeUtil::GetMilliseconds();
396     while (eventLogger->backTimes_.size() < 4) {
397         eventLogger->backTimes_.push_back(curentTime);
398         curentTime += 100;
399     }
400 
401     std::shared_ptr<SysEvent> sysEvent2 = std::make_shared<SysEvent>("GESTURE_NAVIGATION_BACK",
402         nullptr, jsonStr);
403     sysEvent2->SetEventValue("PID", pid);
404     sysEvent2->happenTime_ = TimeUtil::GetMilliseconds();
405     EventFocusListener::lastChangedTime_ = 0;
406     eventLogger->ReportUserPanicWarning(sysEvent2, pid);
407 #endif
408 
409     std::shared_ptr<SysEvent> sysEvent3 = std::make_shared<SysEvent>("FREQUENT_CLICK_WARNING",
410         nullptr, jsonStr);
411     sysEvent3->SetEventValue("PID", pid);
412     sysEvent3->happenTime_ = 4000; // test value
413 #ifdef WINDOW_MANAGER_ENABLE
414     eventLogger->ReportUserPanicWarning(sysEvent3, pid);
415     sysEvent3->happenTime_ = 2500; // test value
416     eventLogger->ReportUserPanicWarning(sysEvent3, pid);
417 #endif
418     EXPECT_TRUE(true);
419 }
420 
421 /**
422  * @tc.name: EventLoggerTest_010
423  * @tc.desc: add testcase coverage
424  * @tc.type: FUNC
425  */
426 HWTEST_F(EventLoggerTest, EventLoggerTest_010, TestSize.Level3)
427 {
428     auto eventLogger = std::make_shared<EventLogger>();
429     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
430     long pid = getpid();
431     std::string testName = "FREQUENT_CLICK_WARNING";
432     std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
433         nullptr, jsonStr);
434     event->eventName_ = testName;
435     event->SetEventValue("PID", pid);
436 #ifdef WINDOW_MANAGER_ENABLE
437     EventFocusListener::lastChangedTime_ = 900; // test value
438     event->happenTime_ = 1000; // test value
439     eventLogger->ReportUserPanicWarning(event, pid);
440     EXPECT_TRUE(eventLogger->backTimes_.empty());
441     event->happenTime_ = 4000; // test value
442     event->SetEventValue("PROCESS_NAME", "EventLoggerTest_010");
443     eventLogger->ReportUserPanicWarning(event, pid);
444     EXPECT_TRUE(eventLogger->backTimes_.empty());
445 #endif
446 }
447 
448 /**
449  * @tc.name: EventLoggerTest_011
450  * @tc.desc: add testcase coverage
451  * @tc.type: FUNC
452  */
453 HWTEST_F(EventLoggerTest, EventLoggerTest_011, TestSize.Level3)
454 {
455     auto eventLogger = std::make_shared<EventLogger>();
456     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
457     long pid = getpid();
458     std::string testName = "EventLoggerTest_011";
459     std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
460         nullptr, jsonStr);
461     event->eventName_ = testName;
462     event->SetEventValue("PID", pid);
463 #ifdef WINDOW_MANAGER_ENABLE
464     EXPECT_TRUE(eventLogger->backTimes_.empty());
465     EventFocusListener::lastChangedTime_ = 0; // test value
466     event->happenTime_ = 3000; // test value
467     eventLogger->ReportUserPanicWarning(event, pid);
468     EXPECT_EQ(eventLogger->backTimes_.size(), 1);
469     while (eventLogger->backTimes_.size() <= 5) {
470         int count = 1000; // test value
471         eventLogger->backTimes_.push_back(count++);
472     }
473     EXPECT_TRUE(eventLogger->backTimes_.size() > 5);
474     eventLogger->ReportUserPanicWarning(event, pid);
475     EXPECT_TRUE(eventLogger->backTimes_.empty());
476 #endif
477 }
478 
479 /**
480  * @tc.name: EventLoggerTest_012
481  * @tc.desc: add testcase coverage
482  * @tc.type: FUNC
483  */
484 HWTEST_F(EventLoggerTest, EventLoggerTest_012, TestSize.Level3)
485 {
486     auto eventLogger = std::make_shared<EventLogger>();
487     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
488     long pid = getpid();
489     std::string testName = "EventLoggerTest_012";
490     std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
491         nullptr, jsonStr);
492     event->eventName_ = testName;
493     event->SetEventValue("PID", pid);
494 #ifdef WINDOW_MANAGER_ENABLE
495     EXPECT_TRUE(eventLogger->backTimes_.empty());
496     EventFocusListener::lastChangedTime_ = 0; // test value
497     event->happenTime_ = 5000; // test value
498     while (eventLogger->backTimes_.size() < 5) {
499         int count = 1000; // test value
500         eventLogger->backTimes_.push_back(count++);
501     }
502     EXPECT_TRUE(eventLogger->backTimes_.size() > 0);
503     eventLogger->ReportUserPanicWarning(event, pid);
504     EXPECT_EQ(eventLogger->backTimes_.size(), 4);
505 #endif
506 }
507 
508 /**
509  * @tc.name: EventLoggerTest_013
510  * @tc.desc: add testcase coverage
511  * @tc.type: FUNC
512  */
513 HWTEST_F(EventLoggerTest, EventLoggerTest_013, TestSize.Level3)
514 {
515     InitSeLinuxEnabled();
516     auto eventLogger = std::make_shared<EventLogger>();
517     auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
518     long pid = getpid();
519     std::string testName = "EventLoggerTest_013";
520     std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
521         nullptr, jsonStr);
522     eventLogger->WriteCallStack(event, 0);
523     event->SetEventValue("PID", pid);
524     event->SetEventValue("EVENT_KEY_FORM_BLOCK_CALLSTACK", testName);
525     event->SetEventValue("EVENT_KEY_FORM_BLOCK_APPNAME", testName);
526     event->eventName_ = "FORM_BLOCK_CALLSTACK";
527     event->domain_ = "FORM_MANAGER";
528     eventLogger->WriteCallStack(event, 0);
529     std::string stackPath = "";
530     auto ret = eventLogger->GetAppFreezeFile(stackPath);
531     EXPECT_TRUE(ret.empty());
532     stackPath = "/data/test/catcherFile";
533     auto fd = open(stackPath.c_str(), O_CREAT | O_WRONLY | O_TRUNC, DEFAULT_MODE);
534     if (fd < 0) {
535         printf("Fail to create catcherFile. errno: %d\n", errno);
536         FAIL();
537     }
538     eventLogger->GetAppFreezeFile(stackPath);
539     close(fd);
540     CancelSeLinuxEnabled();
541 }
542 
543 /**
544  * @tc.name: EventLoggerTest_014
545  * @tc.desc: add testcase coverage
546  * @tc.type: FUNC
547  */
548 HWTEST_F(EventLoggerTest, EventLoggerTest_014, TestSize.Level3)
549 {
550     auto eventLogger = std::make_shared<EventLogger>();
551     eventLogger->OnLoad();
552 #ifdef WINDOW_MANAGER_ENABLE
553     EventFocusListener::RegisterFocusListener();
554     EventFocusListener::registerState_ = EventFocusListener::REGISTERED;
555     eventLogger->OnUnload();
556     EXPECT_EQ(EventFocusListener::registerState_, EventFocusListener::UNREGISTERED);
557 #endif
558 }
559 
560 /**
561  * @tc.name: EventLoggerTest_015
562  * @tc.desc: add testcase coverage
563  * @tc.type: FUNC
564  */
565 HWTEST_F(EventLoggerTest, EventLoggerTest_015, TestSize.Level3)
566 {
567     auto eventLogger = std::make_shared<EventLogger>();
568     std::string stack = "";
569     bool result = eventLogger->IsKernelStack(stack);
570     EXPECT_TRUE(!result);
571     stack = "Stack backtrace";
572     result = eventLogger->IsKernelStack(stack);
573     EXPECT_TRUE(result);
574 }
575 
576 /**
577  * @tc.name: EventLoggerTest_016
578  * @tc.desc: add testcase coverage
579  * @tc.type: FUNC
580  */
581 HWTEST_F(EventLoggerTest, EventLoggerTest_016, TestSize.Level3)
582 {
583     auto eventLogger = std::make_shared<EventLogger>();
584     std::string stack = "TEST\\nTEST\\nTEST";
585     std::string kernelStack = "";
586     std::string contentStack = "Test";
587     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
588     std::string testName = "EventLoggerTest_016";
589     std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
590         nullptr, jsonStr);
591     sysEvent->SetEventValue("PROCESS_NAME", testName);
592     sysEvent->SetEventValue("APP_RUNNING_UNIQUE_ID", "Test");
593     sysEvent->SetEventValue("STACK", stack);
594     sysEvent->SetEventValue("MSG", stack);
595     sysEvent->eventName_ = "UI_BLOCK_6S";
596     sysEvent->SetEventValue("BINDER_INFO", "async\\nEventLoggerTest");
597     eventLogger->GetAppFreezeStack(1, sysEvent, stack, "msg", kernelStack);
598     EXPECT_TRUE(kernelStack.empty());
599     eventLogger->GetNoJsonStack(stack, contentStack, kernelStack, false);
600     EXPECT_TRUE(kernelStack.empty());
601     stack = "Test:Stack backtrace";
602     sysEvent->SetEventValue("STACK", stack);
603     eventLogger->GetAppFreezeStack(1, sysEvent, stack, "msg", kernelStack);
604     EXPECT_TRUE(!kernelStack.empty());
605     eventLogger->GetNoJsonStack(stack, contentStack, kernelStack, false);
606     EXPECT_TRUE(!kernelStack.empty());
607 }
608 
609 /**
610  * @tc.name: EventLoggerTest_017
611  * @tc.desc: add testcase coverage
612  * @tc.type: FUNC
613  */
614 HWTEST_F(EventLoggerTest, EventLoggerTest_017, TestSize.Level3)
615 {
616     auto eventLogger = std::make_shared<EventLogger>();
617     std::string stack = "";
618     auto jsonStr = "{\"domain_\":\"RELIABILITY\"}";
619     std::string testName = "EventLoggerTest_017";
620     std::shared_ptr<SysEvent> event = std::make_shared<SysEvent>(testName,
621         nullptr, jsonStr);
622     event->eventName_ = testName;
623     int testValue = 1; // test value
624     event->SetEventValue("PID", testValue);
625     event->happenTime_ = TimeUtil::GetMilliseconds();
626     std::string kernelStack = "";
627     eventLogger->WriteKernelStackToFile(event, testValue, kernelStack);
628     kernelStack = "Test";
629     EXPECT_TRUE(!kernelStack.empty());
630     eventLogger->WriteKernelStackToFile(event, testValue, kernelStack);
631 }
632 
633 /**
634  * @tc.name: EventLoggerTest_018
635  * @tc.desc: add testcase coverage
636  * @tc.type: FUNC
637  */
638 HWTEST_F(EventLoggerTest, EventLoggerTest_018, TestSize.Level3)
639 {
640     auto eventLogger = std::make_shared<EventLogger>();
641     std::string binderInfo = "";
642     std::string binderPeerStack = "";
643     eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
644     EXPECT_TRUE(binderPeerStack.empty());
645     binderInfo = "Test";
646     eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
647     EXPECT_TRUE(binderPeerStack.empty());
648     binderInfo = "PeerBinder catcher stacktrace for pid : 111\n Stack "
649         "backtrace: Test\n PeerBinder catcher stacktrace for pid : 112\n Test";
650     eventLogger->ParsePeerStack(binderInfo, binderPeerStack);
651     EXPECT_TRUE(!binderPeerStack.empty());
652 }
653 
654 /**
655  * @tc.name: EventLoggerTest_019
656  * @tc.desc: add testcase coverage
657  * @tc.type: FUNC
658  */
659 HWTEST_F(EventLoggerTest, EventLoggerTest_019, TestSize.Level3)
660 {
661     auto eventLogger = std::make_shared<EventLogger>();
662     EXPECT_TRUE(!eventLogger->StabilityGetTempFreqInfo().empty());
663 }
664 } // namespace HiviewDFX
665 } // namespace OHOS
666