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