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