1 /*
2 * Copyright (c) 2022 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 "freeze_detector_unittest.h"
16
17 #include <fstream>
18 #include <iostream>
19 #include <memory>
20 #include <set>
21 #include <unistd.h>
22
23 #include "event.h"
24 #include "file_util.h"
25 #include "time_util.h"
26
27 #define private public
28 #include "freeze_common.h"
29 #include "rule_cluster.h"
30 #include "resolver.h"
31 #include "vendor.h"
32 #include "freeze_detector_plugin.h"
33 #undef private
34 #include "sys_event.h"
35 #include "sys_event_dao.h"
36 #include "watch_point.h"
37
38 using namespace testing::ext;
39 namespace OHOS {
40 namespace HiviewDFX {
SetUp()41 void FreezeDetectorUnittest::SetUp()
42 {
43 /**
44 * @tc.setup: create work directories
45 */
46 printf("SetUp.\n");
47 }
SetUpTestCase()48 void FreezeDetectorUnittest::SetUpTestCase()
49 {
50 /**
51 * @tc.setup: all first
52 */
53 printf("SetUpTestCase.\n");
54 }
55
TearDownTestCase()56 void FreezeDetectorUnittest::TearDownTestCase()
57 {
58 /**
59 * @tc.setup: all end
60 */
61 printf("TearDownTestCase.\n");
62 }
63
TearDown()64 void FreezeDetectorUnittest::TearDown()
65 {
66 /**
67 * @tc.teardown: destroy the event loop we have created
68 */
69 printf("TearDown.\n");
70 }
71
72 /**
73 * @tc.name: FreezeResolver_001
74 * @tc.desc: FreezeDetector
75 */
76 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_001, TestSize.Level0)
77 {
78 FreezeResolver freezeResolver(nullptr);
79 ASSERT_EQ(freezeResolver.Init(), false);
80 }
81
82 /**
83 * @tc.name: FreezeResolver_002
84 * @tc.desc: FreezeDetector
85 */
86 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_002, TestSize.Level3)
87 {
88 auto freezeCommon = std::make_shared<FreezeCommon>();
89 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
90 ASSERT_EQ(freezeResolver->Init(), false);
91 }
92
93 /**
94 * @tc.name: FreezeResolver_003
95 * @tc.desc: FreezeDetector
96 */
97 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_003, TestSize.Level3)
98 {
99 auto freezeCommon = std::make_shared<FreezeCommon>();
100 bool ret1 = freezeCommon->Init();
101 ASSERT_EQ(ret1, true);
102 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
103 ASSERT_EQ(freezeResolver->Init(), true);
104 }
105
106 /**
107 * @tc.name: FreezeResolver_004
108 * @tc.desc: FreezeDetector
109 */
110 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_004, TestSize.Level3)
111 {
112 auto freezeCommon = std::make_shared<FreezeCommon>();
113 bool ret1 = freezeCommon->Init();
114 ASSERT_EQ(ret1, true);
115 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
116 ASSERT_EQ(freezeResolver->Init(), true);
117 auto time = freezeResolver->GetTimeZone();
118 ASSERT_NE(time, "");
119 }
120
121 /**
122 * @tc.name: FreezeResolver_005
123 * @tc.desc: FreezeDetector
124 */
125 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_005, TestSize.Level3)
126 {
127 auto freezeCommon = std::make_shared<FreezeCommon>();
128 bool ret1 = freezeCommon->Init();
129 ASSERT_EQ(ret1, true);
130 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
131 ASSERT_EQ(freezeResolver->Init(), true);
132 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
133 .InitDomain("KERNEL_VENDOR")
134 .InitStringId("SCREEN_ON")
135 .InitTimestamp(TimeUtil::GetMilliseconds())
136 .Build();
137
138 ASSERT_EQ(freezeResolver->ProcessEvent(watchPoint), 0);
139 }
140
141 /**
142 * @tc.name: FreezeResolver_006
143 * @tc.desc: FreezeDetector
144 */
145 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_006, TestSize.Level3)
146 {
147 auto freezeCommon = std::make_shared<FreezeCommon>();
148 bool ret1 = freezeCommon->Init();
149 ASSERT_EQ(ret1, true);
150 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
151 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
152 .InitDomain("KERNEL_VENDOR")
153 .InitStringId("SCREEN_ON")
154 .InitTimestamp(TimeUtil::GetMilliseconds())
155 .Build();
156 ASSERT_EQ(freezeResolver->ProcessEvent(watchPoint), -1);
157 }
158
159 /**
160 * @tc.name: FreezeResolver_007
161 * @tc.desc: FreezeDetector
162 */
163 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_007, TestSize.Level3)
164 {
165 auto freezeCommon = std::make_shared<FreezeCommon>();
166 bool ret1 = freezeCommon->Init();
167 ASSERT_EQ(ret1, true);
168 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
169 ASSERT_EQ(freezeResolver->Init(), true);
170 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
171 .InitDomain("ACE")
172 .InitStringId("UI_BLOCK_3S")
173 .InitTimestamp(TimeUtil::GetMilliseconds())
174 .Build();
175 ASSERT_EQ(freezeResolver->ProcessEvent(watchPoint), -1);
176 }
177
178 /**
179 * @tc.name: FreezeResolver_008
180 * @tc.desc: FreezeDetector
181 */
182 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_008, TestSize.Level3)
183 {
184 auto freezeCommon = std::make_shared<FreezeCommon>();
185 bool ret1 = freezeCommon->Init();
186 ASSERT_EQ(ret1, true);
187 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
188 ASSERT_EQ(freezeResolver->Init(), true);
189 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
190 .InitDomain("ACE")
191 .InitStringId("UI_BLOCK_6S")
192 .InitTimestamp(TimeUtil::GetMilliseconds())
193 .Build();
194 std::vector<WatchPoint> list;
195 std::vector<FreezeResult> result;
196 EXPECT_FALSE(freezeResolver->JudgmentResult(watchPoint, list,
197 result));
198 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
199 .InitDomain("KERNEL_VENDOR")
200 .InitStringId("UI_BLOCK_RECOVERED")
201 .InitTimestamp(TimeUtil::GetMilliseconds())
202 .Build();
203 list.push_back(watchPoint1);
204 EXPECT_FALSE(freezeResolver->JudgmentResult(watchPoint, list,
205 result));
206 FreezeResult result1;
207 FreezeResult result2;
208 result2.SetAction("or");
209 result.push_back(result1);
210 result.push_back(result2);
211 EXPECT_FALSE(freezeResolver->JudgmentResult(watchPoint, list,
212 result));
213 EXPECT_FALSE(freezeResolver->JudgmentResult(watchPoint1, list,
214 result));
215 }
216
217 /**
218 * @tc.name: FreezeVender_001
219 * @tc.desc: FreezeDetector
220 */
221 HWTEST_F(FreezeDetectorUnittest, FreezeVender_001, TestSize.Level0)
222 {
223 auto vendor = std::make_unique<Vendor>(nullptr);
224 ASSERT_EQ(vendor->Init(), false);
225 }
226
227 /**
228 * @tc.name: FreezeVender_002
229 * @tc.desc: FreezeDetector
230 */
231 HWTEST_F(FreezeDetectorUnittest, FreezeVender_002, TestSize.Level3)
232 {
233 auto freezeCommon = std::make_shared<FreezeCommon>();
234 bool ret1 = freezeCommon->Init();
235 ASSERT_EQ(ret1, true);
236 auto vendor = std::make_unique<Vendor>(freezeCommon);
237 ASSERT_EQ(vendor->Init(), true);
238 }
239
240 /**
241 * @tc.name: FreezeVender_003
242 * @tc.desc: FreezeDetector
243 */
244 HWTEST_F(FreezeDetectorUnittest, FreezeVender_003, TestSize.Level3)
245 {
246 auto freezeCommon = std::make_shared<FreezeCommon>();
247 bool ret1 = freezeCommon->Init();
248 ASSERT_EQ(ret1, true);
249 auto vendor = std::make_unique<Vendor>(freezeCommon);
250 ASSERT_EQ(vendor->Init(), true);
251 ASSERT_EQ(vendor->GetTimeString(1687836954734), "20230627113554");
252 }
253
254 /**
255 * @tc.name: FreezeVender_004
256 * @tc.desc: FreezeDetector
257 */
258 HWTEST_F(FreezeDetectorUnittest, FreezeVender_004, TestSize.Level3)
259 {
260 auto freezeCommon = std::make_shared<FreezeCommon>();
261 bool ret1 = freezeCommon->Init();
262 ASSERT_EQ(ret1, true);
263 auto vendor = std::make_unique<Vendor>(freezeCommon);
264 ASSERT_EQ(vendor->Init(), true);
265
266 std::ostringstream oss;
267 std::string header = "header";
268 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
269 .InitDomain("KERNEL_VENDOR")
270 .InitStringId("SCREEN_ON")
271 .InitTimestamp(TimeUtil::GetMilliseconds())
272 .InitPid(1000)
273 .InitUid(1000)
274 .InitProcessName("processName")
275 .InitPackageName("com.package.name")
276 .InitMsg("msg")
277 .Build();
278 vendor->DumpEventInfo(oss, header, watchPoint);
279 }
280
281 /**
282 * @tc.name: FreezeVender_005
283 * @tc.desc: FreezeDetector
284 */
285 HWTEST_F(FreezeDetectorUnittest, FreezeVender_005, TestSize.Level3)
286 {
287 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
288 .InitDomain("KERNEL_VENDOR")
289 .InitStringId("SCREEN_ON")
290 .InitTimestamp(1687859103947)
291 .InitPid(1000)
292 .InitUid(1000)
293 .InitProcessName("processName")
294 .InitPackageName("com.package.name")
295 .InitHitraceTime("20230627")
296 .InitSysrqTime("20230627")
297 .InitHitraceIdInfo("hitraceId: 123")
298 .Build();
299
300 std::vector<WatchPoint> list;
301 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
302 .InitDomain("KERNEL_VENDOR")
303 .InitStringId("SCREEN_ON")
304 .InitTimestamp(TimeUtil::GetMilliseconds())
305 .InitLogPath("nolog")
306 .InitMsg("msg")
307 .Build();
308 list.push_back(watchPoint1);
309
310 WatchPoint watchPoint2 = OHOS::HiviewDFX::WatchPoint::Builder()
311 .InitDomain("AAFWK")
312 .InitStringId("THREAD_BLOCK_6S")
313 .InitTimestamp(TimeUtil::GetMilliseconds())
314 .InitLogPath("nolog")
315 .InitMsg("msg")
316 .Build();
317 list.push_back(watchPoint2);
318
319 std::vector<FreezeResult> result;
320
321 auto freezeCommon = std::make_shared<FreezeCommon>();
322 bool ret1 = freezeCommon->Init();
323 ASSERT_EQ(ret1, true);
324 auto vendor = std::make_unique<Vendor>(freezeCommon);
325 ASSERT_EQ(vendor->Init(), true);
326
327 ASSERT_TRUE(!vendor->MergeEventLog(watchPoint, list, result).empty());
328 }
329
330 /**
331 * @tc.name: FreezeVender_006
332 * @tc.desc: FreezeDetector
333 */
334 HWTEST_F(FreezeDetectorUnittest, FreezeVender_006, TestSize.Level3)
335 {
336 auto freezeCommon = std::make_shared<FreezeCommon>();
337 bool ret1 = freezeCommon->Init();
338 ASSERT_EQ(ret1, true);
339 auto vendor = std::make_unique<Vendor>(freezeCommon);
340 ASSERT_EQ(vendor->Init(), true);
341 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
342 .InitDomain("KERNEL_VENDOR")
343 .InitStringId("SCREEN_ON")
344 .InitTimestamp(TimeUtil::GetMilliseconds())
345 .InitProcessName("processName")
346 .InitPackageName("com.package.name")
347 .InitMsg("msg")
348 .Build();
349 std::vector<WatchPoint> list;
350 list.push_back(watchPoint);
351 vendor->MergeFreezeJsonFile(watchPoint, list);
352
353 auto vendor1 = std::make_unique<Vendor>(nullptr);
354 std::vector<FreezeResult> result;
355 std::string ret = vendor->MergeEventLog(watchPoint, list, result);
356 printf("MergeEventLog ret = %s\n.", ret.c_str());
357 }
358
359 /**
360 * @tc.name: FreezeVender_007
361 * @tc.desc: FreezeDetector
362 */
363 HWTEST_F(FreezeDetectorUnittest, FreezeVender_007, TestSize.Level3)
364 {
365 auto vendor1 = std::make_unique<Vendor>(nullptr);
366 EXPECT_EQ(vendor1->Init(), false);
367 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
368 .InitDomain("KERNEL_VENDOR")
369 .InitStringId("SCREEN_ON")
370 .InitTimestamp(TimeUtil::GetMilliseconds())
371 .InitProcessName("processName")
372 .InitPackageName("com.package.name")
373 .InitMsg("msg")
374 .Build();
375 vendor1->SendFaultLog(watchPoint, "test", "sysfreeze", "processName", "No");
376
377 auto freezeCommon = std::make_shared<FreezeCommon>();
378 bool ret1 = freezeCommon->Init();
379 EXPECT_EQ(ret1, true);
380 auto vendor = std::make_unique<Vendor>(freezeCommon);
381 EXPECT_EQ(vendor->Init(), true);
382 std::string ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::FREEZE);
383 EXPECT_EQ(ret, "FREEZE");
384 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::INACTIVE);
385 EXPECT_EQ(ret, "INACTIVE");
386 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::STAND_BY);
387 EXPECT_EQ(ret, "STAND_BY");
388 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::DOZE);
389 EXPECT_EQ(ret, "DOZE");
390 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::SLEEP);
391 EXPECT_EQ(ret, "SLEEP");
392 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::HIBERNATE);
393 EXPECT_EQ(ret, "HIBERNATE");
394 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::SHUTDOWN);
395 EXPECT_EQ(ret, "SHUTDOWN");
396 ret = vendor->GetPowerStateString(OHOS::PowerMgr::PowerState::UNKNOWN);
397 EXPECT_EQ(ret, "UNKNOWN");
398 }
399
400 /**
401 * @tc.name: FreezeVender_008
402 * @tc.desc: FreezeDetector
403 */
404 HWTEST_F(FreezeDetectorUnittest, FreezeVender_008, TestSize.Level3)
405 {
406 auto freezeCommon = std::make_shared<FreezeCommon>();
407 bool ret = freezeCommon->Init();
408 EXPECT_EQ(ret, true);
409 auto vendor = std::make_unique<Vendor>(freezeCommon);
410 EXPECT_EQ(vendor->Init(), true);
411
412 std::string processName = "render_service";
413 std::string isScbPro;
414 vendor->CheckProcessName(processName, isScbPro);
415 printf("%s %s\n", processName.c_str(), isScbPro.c_str());
416 EXPECT_EQ(processName, "render_service");
417 EXPECT_EQ(isScbPro, "No");
418 processName = "com.ohos.sceneboard";
419 vendor->CheckProcessName(processName, isScbPro);
420 printf("%s %s\n", processName.c_str(), isScbPro.c_str());
421 EXPECT_EQ(processName, "com.ohos.sceneboard");
422 EXPECT_EQ(isScbPro, "No");
423 processName = "com.ohos.sceneboard:Enability:2025";
424 vendor->CheckProcessName(processName, isScbPro);
425 printf("%s %s\n", processName.c_str(), isScbPro.c_str());
426 EXPECT_EQ(processName, "Enability");
427 EXPECT_EQ(isScbPro, "Yes");
428 processName = "com.ohos.sceneboard: ?!sys/comn/test:123 321";
429 vendor->CheckProcessName(processName, isScbPro);
430 printf("%s %s\n", processName.c_str(), isScbPro.c_str());
431 EXPECT_EQ(processName, "sys_comn_test");
432 EXPECT_EQ(isScbPro, "Yes");
433 }
434
435 /**
436 * @tc.name: FreezeVender_009
437 * @tc.desc: FreezeDetector
438 */
439 HWTEST_F(FreezeDetectorUnittest, FreezeVender_009, TestSize.Level3)
440 {
441 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
442 .InitDomain("AAFWK")
443 .InitStringId("THREAD_BLOCK_3S")
444 .InitTimestamp(TimeUtil::GetMilliseconds())
445 .InitProcessName("foundation")
446 .Build();
447 std::vector<WatchPoint> list;
448 list.push_back(watchPoint);
449
450 std::vector<FreezeResult> result;
451 auto freezeCommon = std::make_shared<FreezeCommon>();
452 bool ret1 = freezeCommon->Init();
453 ASSERT_EQ(ret1, true);
454 auto vendor = std::make_unique<Vendor>(freezeCommon);
455 ASSERT_EQ(vendor->Init(), true);
456 vendor->MergeEventLog(watchPoint, list, result).empty();
457
458 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
459 .InitDomain("FRAMEWORK")
460 .InitStringId("SERVICE_WARNING")
461 .InitTimestamp(TimeUtil::GetMilliseconds())
462 .InitProcessName("foundation")
463 .Build();
464 list.push_back(watchPoint1);
465 ASSERT_TRUE(vendor->MergeEventLog(watchPoint1, list, result).empty());
466
467 WatchPoint watchPoint2 = OHOS::HiviewDFX::WatchPoint::Builder()
468 .InitDomain("FRAMEWORK")
469 .InitStringId("SERVICE_WARNING")
470 .InitTimestamp(TimeUtil::GetMilliseconds())
471 .InitProcessName("FreezeVender_012")
472 .Build();
473 list.push_back(watchPoint2);
474 ASSERT_TRUE(vendor->MergeEventLog(watchPoint2, list, result).empty());
475 }
476
477 /**
478 * @tc.name: FreezeRuleCluster_001
479 * @tc.desc: FreezeDetector
480 */
481 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_001, TestSize.Level0)
482 {
483 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
484 ASSERT_EQ(freezeRuleCluster->Init(), true);
485 }
486
487 /**
488 * @tc.name: FreezeRuleCluster_002
489 * @tc.desc: FreezeDetector
490 */
491 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_002, TestSize.Level3)
492 {
493 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
494 ASSERT_EQ(freezeRuleCluster->Init(), true);
495 ASSERT_EQ(freezeRuleCluster->CheckFileSize("path"), false);
496 ASSERT_EQ(freezeRuleCluster->CheckFileSize("/system/etc/hiview/freeze_rules.xml"), true);
497 }
498
499 /**
500 * @tc.name: FreezeRuleCluster_003
501 * @tc.desc: FreezeDetector
502 */
503 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_003, TestSize.Level3)
504 {
505 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
506 ASSERT_EQ(freezeRuleCluster->Init(), true);
507 ASSERT_EQ(freezeRuleCluster->ParseRuleFile("path"), false);
508 ASSERT_EQ(freezeRuleCluster->ParseRuleFile("/system/etc/hiview/freeze_rules.xml"), true);
509 }
510
511 /**
512 * @tc.name: FreezeRuleCluster_004
513 * @tc.desc: FreezeDetector
514 */
515 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_004, TestSize.Level3)
516 {
517 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
518 ASSERT_EQ(freezeRuleCluster->Init(), true);
519
520 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
521 .InitDomain("KERNEL_VENDOR")
522 .InitStringId("SCREEN_ON")
523 .Build();
524
525 std::vector<FreezeResult> list;
526 FreezeResult result1;
527 result1.SetId(1);
528 FreezeResult result2;
529 result2.SetId(2);
530 list.push_back(result1);
531 list.push_back(result2);
532
533 ASSERT_EQ(freezeRuleCluster->GetResult(watchPoint, list), true);
534 }
535
536 /**
537 * @tc.name: FreezeRule_001
538 * @tc.desc: FreezeDetector
539 */
540 HWTEST_F(FreezeDetectorUnittest, FreezeRule_001, TestSize.Level0)
541 {
542 auto freezeRule = std::make_unique<FreezeRule>();
543 FreezeResult result;
544 result.SetId(1);
545
546 freezeRule->AddResult("KERNEL_VENDOR", "SCREEN_ON", result);
547 ASSERT_EQ(freezeRule->GetResult("KERNEL_VENDOR", "SCREEN_ON", result), true);
548 }
549
550 /**
551 * @tc.name: FreezeRule_002
552 * @tc.desc: FreezeDetector
553 */
554 HWTEST_F(FreezeDetectorUnittest, FreezeRule_002, TestSize.Level3)
555 {
556 auto freezeRule = std::make_unique<FreezeRule>();
557 FreezeResult result;
558 result.SetId(1);
559
560 ASSERT_EQ(freezeRule->GetResult("KERNEL_VENDOR", "SCREEN_ON", result), false);
561 }
562
563 /**
564 * @tc.name: FreezeDetectorPlugin_001
565 * @tc.desc: FreezeDetector
566 */
567 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_001, TestSize.Level0)
568 {
569 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
570 ASSERT_EQ(freezeDetectorPlugin->ReadyToLoad(), true);
571 freezeDetectorPlugin->OnLoad();
572 }
573
574 /**
575 * @tc.name: FreezeDetectorPlugin_002
576 * @tc.desc: FreezeDetector
577 */
578 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_002, TestSize.Level3)
579 {
580 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
581 auto event = std::make_shared<Event>("sender", "event");
582 ASSERT_EQ(freezeDetectorPlugin->OnEvent(event), false);
583 }
584
585 /**
586 * @tc.name: FreezeDetectorPlugin_003
587 * @tc.desc: FreezeDetector
588 */
589 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_003, TestSize.Level3)
590 {
591 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
592 freezeDetectorPlugin->OnLoad();
593 ASSERT_NE(freezeDetectorPlugin, nullptr);
594 }
595
596 /**
597 * @tc.name: FreezeDetectorPlugin_004
598 * @tc.desc: FreezeDetector
599 */
600 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_004, TestSize.Level3)
601 {
602 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
603 freezeDetectorPlugin->OnUnload();
604 ASSERT_NE(freezeDetectorPlugin, nullptr);
605 }
606
607 /**
608 * @tc.name: FreezeDetectorPlugin_005
609 * @tc.desc: FreezeDetector
610 */
611 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_005, TestSize.Level3)
612 {
613 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
614 auto event = std::make_shared<Event>("sender", "event");
615 freezeDetectorPlugin->OnEventListeningCallback(*(event.get()));
616 freezeDetectorPlugin->RemoveRedundantNewline("test1\\ntest2\\ntest3");
617 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
618 .InitDomain("KERNEL_VENDOR")
619 .InitStringId("SCREEN_ON")
620 .Build();
621 freezeDetectorPlugin->ProcessEvent(watchPoint);
622 ASSERT_EQ(freezeDetectorPlugin->CanProcessEvent(event), false);
623 }
624
625 /**
626 * @tc.name: FreezeDetectorPlugin_006
627 * @tc.desc: FreezeDetector
628 */
629 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_006, TestSize.Level3)
630 {
631 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
632 int uid = 10005;
633 unsigned long long eventTime = 1234567890;
634 std::string foreGround;
635 freezeDetectorPlugin->CheckForeGround(uid, getpid(), eventTime, foreGround);
636 ASSERT_EQ(foreGround, "No");
637 }
638
639 /**
640 * @tc.name: FreezeDetectorPlugin_007
641 * @tc.desc: FreezeDetector
642 */
643 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_007, TestSize.Level3)
644 {
645 auto jsonStr = "{\"domain_\":\"FORM_MANAGER\"}";
646 std::string testName = "FreezeDetectorPlugin_007";
647 std::shared_ptr<SysEvent> sysEvent = std::make_shared<SysEvent>(testName,
648 nullptr, jsonStr);
649 ASSERT_TRUE(sysEvent != nullptr);
650 sysEvent->eventName_ = testName;
651 sysEvent->SetSeq(1234567890);
652 sysEvent->SetEventValue(FreezeCommon::EVENT_PID, getpid());
653 sysEvent->SetEventValue(FreezeCommon::EVENT_TID, getpid());
654 sysEvent->SetEventValue(FreezeCommon::EVENT_UID, getuid());
655 sysEvent->SetEventValue(FreezeCommon::EVENT_PACKAGE_NAME, testName);
656 sysEvent->SetEventValue(FreezeCommon::EVENT_PROCESS_NAME, testName);
657 sysEvent->SetEventValue(FreezeCommon::HITRACE_TIME, "12453");
658 sysEvent->SetEventValue(FreezeCommon::SYSRQ_TIME, "12453");
659 sysEvent->SetEventValue(FreezeCommon::TERMINAL_THREAD_STACK, testName);
660 sysEvent->SetEventValue(EventStore::EventCol::INFO, testName);
661 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
662 freezeDetectorPlugin->MakeWatchPoint(*(sysEvent.get()));
663 sysEvent->SetEventValue(FreezeCommon::EVENT_TRACE_ID, "12345;123456");
664 freezeDetectorPlugin->MakeWatchPoint(*(sysEvent.get()));
665 ASSERT_TRUE(freezeDetectorPlugin != nullptr);
666 }
667
668 /**
669 * @tc.name: FreezeCommon_001
670 * @tc.desc: FreezeDetector
671 */
672 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_001, TestSize.Level0)
673 {
674 auto freezeCommon = std::make_unique<FreezeCommon>();
675 ASSERT_EQ(freezeCommon->Init(), true);
676 }
677
678 /**
679 * @tc.name: FreezeCommon_002
680 * @tc.desc: FreezeDetector
681 */
682 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_002, TestSize.Level3)
683 {
684 auto freezeCommon = std::make_unique<FreezeCommon>();
685 ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
686 freezeCommon->Init();
687 ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
688 }
689
690 /**
691 * @tc.name: FreezeCommon_003
692 * @tc.desc: FreezeDetector
693 */
694 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_003, TestSize.Level3)
695 {
696 auto freezeCommon = std::make_unique<FreezeCommon>();
697 ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
698 freezeCommon->Init();
699 ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
700 }
701
702 /**
703 * @tc.name: FreezeCommon_004
704 * @tc.desc: FreezeDetector
705 */
706 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_004, TestSize.Level3)
707 {
708 auto freezeCommon = std::make_unique<FreezeCommon>();
709 ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
710 freezeCommon->Init();
711 ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
712 }
713
714 /**
715 * @tc.name: FreezeCommon_005
716 * @tc.desc: FreezeDetector
717 */
718 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_005, TestSize.Level3)
719 {
720 auto freezeCommon = std::make_unique<FreezeCommon>();
721 ASSERT_TRUE(freezeCommon != nullptr);
722 freezeCommon->GetPrincipalStringIds();
723 freezeCommon->Init();
724 freezeCommon->GetPrincipalStringIds();
725 }
726
727 /**
728 * @tc.name: FreezeCommon_006
729 * @tc.desc: FreezeDetector
730 */
731 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_006, TestSize.Level3)
732 {
733 auto freezeCommon = std::make_unique<FreezeCommon>();
734 freezeCommon->WriteTimeInfoToFd(0, "FreezeCommon_008 test");
735 freezeCommon->WriteTimeInfoToFd(0, "FreezeCommon_008 test", false);
736 ASSERT_TRUE(freezeCommon != nullptr);
737 }
738
739 /**
740 * @tc.name: FreezeWatchPoint_001
741 * @tc.desc: FreezeDetector
742 */
743 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_001, TestSize.Level0)
744 {
745 WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
746 .InitDomain("KERNEL_VENDOR")
747 .InitStringId("SCREEN_ON")
748 .InitTimestamp(TimeUtil::GetMilliseconds())
749 .Build();
750 auto wp1 = std::make_unique<WatchPoint>(point);
751 std::string logPath = "/data/test/test_data/LOG001.log";
752 wp1->SetLogPath(logPath);
753 ASSERT_EQ(wp1->GetLogPath(), logPath);
754 }
755
756 /**
757 * @tc.name: FreezeWatchPoint_002
758 * @tc.desc: FreezeDetector
759 */
760 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_002, TestSize.Level3)
761 {
762 WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
763 .InitDomain("KERNEL_VENDOR")
764 .InitStringId("SCREEN_ON")
765 .InitTimestamp(TimeUtil::GetMilliseconds())
766 .Build();
767 auto wp1 = std::make_unique<WatchPoint>(point);
768 long seq = 1000L;
769 wp1->SetSeq(seq);
770 ASSERT_EQ(wp1->GetSeq(), seq);
771 }
772
773 /**
774 * @tc.name: FreezeWatchPoint_003
775 * @tc.desc: FreezeDetector
776 */
777 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_003, TestSize.Level3)
778 {
779 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
780 .InitDomain("KERNEL_VENDOR")
781 .InitStringId("SCREEN_ON")
782 .InitMsg("Test")
783 .InitTimestamp(1687859103947)
784 .Build();
785 auto wp = std::make_unique<WatchPoint>(watchPoint);
786
787 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
788 .InitDomain("KERNEL_VENDOR")
789 .InitStringId("SCREEN_ON")
790 .InitTimestamp(1687859103950)
791 .Build();
792 auto wp1 = std::make_unique<WatchPoint>(watchPoint1);
793 bool ret = wp < wp1;
794 printf("wp < wp1: %s\n", ret ? "true" : "false");
795 ret = wp == wp1;
796 printf("wp = wp1: %s\n", ret ? "true" : "false");
797 std::string result = wp->GetMsg();
798 EXPECT_TRUE(!wp->GetMsg().empty());
799 EXPECT_TRUE(wp1->GetMsg().empty());
800 }
801
802 /**
803 * @tc.name: FreezeWatchPoint_004
804 * @tc.desc: FreezeDetector
805 */
806 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_004, TestSize.Level3)
807 {
808 auto wp1 = std::make_unique<WatchPoint>();
809 ASSERT_EQ(wp1->GetSeq(), 0);
810 }
811
812 /**
813 * @tc.name: FreezeWatchPoint_005
814 * @tc.desc: FreezeDetector
815 */
816 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_005, TestSize.Level3)
817 {
818 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
819 .InitDomain("KERNEL_VENDOR")
820 .InitStringId("SCREEN_ON")
821 .InitTimestamp(1687859103947)
822 .InitPid(1000)
823 .InitTid(1000)
824 .InitUid(1000)
825 .InitProcessName("processName")
826 .InitPackageName("com.package.name")
827 .InitHitraceTime("20230627")
828 .InitSysrqTime("20230627")
829 .InitTerminalThreadStack("threadStaskTest")
830 .InitTelemetryId("telemetryIdTest")
831 .InitTraceName("traceNameTest")
832 .InitHitraceIdInfo("hitraceId: 123")
833 .InitProcStatm("123 45 678")
834 .InitHostResourceWarning("Yes")
835 .Build();
836 auto wp1 = std::make_unique<WatchPoint>(watchPoint);
837 ASSERT_EQ(wp1->GetTid(), 1000);
838 ASSERT_EQ(wp1->GetTerminalThreadStack(), "threadStaskTest");
839 ASSERT_EQ(wp1->GetTelemetryId(), "telemetryIdTest");
840 ASSERT_EQ(wp1->GetTraceName(), "traceNameTest");
841 ASSERT_EQ(wp1->GetProcStatm(), "123 45 678");
842 ASSERT_EQ(wp1->GetHostResourceWarning(), "Yes");
843 }
844
845 /**
846 * @tc.name: FreezeDBHelper_001
847 * @tc.desc: FreezeDetector
848 */
849 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_001, TestSize.Level0)
850 {
851 auto freezeCommon = nullptr;
852 auto db = std::make_unique<DBHelper>(freezeCommon);
853 ASSERT_NE(db, nullptr);
854 std::string watchPackage = "com.package.name";
855 std::vector<WatchPoint> list;
856 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
857 .InitDomain("ACE")
858 .InitStringId("UI_BLOCK_3S")
859 .InitPackageName(watchPackage)
860 .InitTimestamp(TimeUtil::GetMilliseconds())
861 .Build();
862 list.push_back(watchPoint);
863 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
864 .InitDomain("ACE")
865 .InitStringId("UI_BLOCK_RECOVERED")
866 .InitPackageName(watchPackage)
867 .InitTimestamp(TimeUtil::GetMilliseconds())
868 .Build();
869 list.push_back(watchPoint1);
870 unsigned long long start = TimeUtil::GetMilliseconds() - 5L;
871 unsigned long long end = TimeUtil::GetMilliseconds();
872 auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
873 DBHelper::WatchParams params = {watchPoint.GetPid(), 0, watchPoint.GetTimestamp(), watchPoint.GetPackageName()};
874 db->SelectEventFromDB(start, end, list, params, result);
875 std::vector<std::string> eventNames;
876 eventNames.push_back("UI_BLOCK_3S");
877 eventNames.push_back("UI_BLOCK_6S");
878 db->SelectRecords(start, end, "ACE", eventNames);
879 }
880
881 /**
882 * @tc.name: FreezeDBHelper_002
883 * @tc.desc: FreezeDetector
884 */
885 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_002, TestSize.Level3)
886 {
887 auto freezeCommon = std::make_shared<FreezeCommon>();
888 bool ret1 = freezeCommon->Init();
889 ASSERT_EQ(ret1, true);
890 auto db = std::make_unique<DBHelper>(freezeCommon);
891 ASSERT_NE(db, nullptr);
892 std::string watchPackage = "com.package.name";
893 std::vector <WatchPoint> list;
894 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
895 .InitDomain("ACE")
896 .InitStringId("UI_BLOCK_3S")
897 .InitPackageName(watchPackage)
898 .InitTimestamp(TimeUtil::GetMilliseconds())
899 .Build();
900 list.push_back(watchPoint);
901 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
902 .InitDomain("ACE")
903 .InitStringId("UI_BLOCK_RECOVERED")
904 .InitPackageName(watchPackage)
905 .InitTimestamp(TimeUtil::GetMilliseconds())
906 .Build();
907 list.push_back(watchPoint1);
908 unsigned long long start = TimeUtil::GetMilliseconds() + 1000L;
909 unsigned long long end = TimeUtil::GetMilliseconds();
910 auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
911 DBHelper::WatchParams params = {watchPoint.GetPid(), 0, watchPoint.GetTimestamp(), watchPoint.GetPackageName()};
912 db->SelectEventFromDB(start, end, list, params, result);
913 }
914
915 /**
916 * @tc.name: FreezeDBHelper_003
917 * @tc.desc: FreezeDetector
918 */
919 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_003, TestSize.Level3)
920 {
921 std::string jsonStr = R"~({"domain_":"AAFWK", "name_":"THREAD_BLOCK_3S", "type_":1, "time_":1501973701070, "tz_":
922 "+0800", "pid_":12000, "tid_":12000, "uid_":0, "FAULT_TYPE":"4", "PID":12000, "UID":0,
923 "MODULE":"FreezeDetectorUnittest", "REASON":"unittest for FreezeDetectorUnittest",
924 "SUMMARY":"summary for FreezeDBHelper", "LOG_PATH":"/data/log/test", "VERSION":"",
925 "HAPPEN_TIME":"1501973701", "PNAME":"/", "FIRST_FRAME":"/", "SECOND_FRAME":"/", "LAST_FRAME":"/", "FINGERPRINT":
926 "04c0d6f03c73da531f00eb112479a8a2f19f59fafba6a474dcbe455a13288f4d", "level_":"CRITICAL", "tag_":"STABILITY", "id_":
927 "17165544771317691984", "info_":""})~";
928 auto sysEvent = std::make_shared<SysEvent>("SysEventSource", nullptr, jsonStr);
929 sysEvent->SetLevel("MINOR");
930 sysEvent->SetEventSeq(447); // 447: test seq
931 EventStore::SysEventDao::Insert(sysEvent);
932
933 auto freezeCommon = std::make_shared<FreezeCommon>();
934 bool ret1 = freezeCommon->Init();
935 ASSERT_EQ(ret1, true);
936 auto db = std::make_unique<DBHelper>(freezeCommon);
937 ASSERT_NE(db, nullptr);
938 std::vector <WatchPoint> list;
939 unsigned long long start = 1501973701070;
940 unsigned long long end = 1501973701170;
941 DBHelper::WatchParams params = {12000, 0, start, "FreezeDetectorUnittest"};
942 auto result = FreezeResult(-14, "AAFWK", "THREAD_BLOCK_3S");
943 db->SelectEventFromDB(start, end, list, params, result);
944 auto result1 = FreezeResult(-6, "ACE", "UI_BLOCK_3S");
945 db->SelectEventFromDB(start, end, list, params, result1);
946 params = {10000, 10000, start, "FreezeDetectorUnittest"};
947 auto result2 = FreezeResult(-10, "AAFWK", "THREAD_BLOCK_3S");
948 result2.SetSamePackage("true");
949 db->SelectEventFromDB(start, end, list, params, result2);
950 ASSERT_TRUE(list.size() > 0);
951 }
952
953 /**
954 * @tc.name: FreezeDBHelper_004
955 * @tc.desc: FreezeDetector
956 */
957 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_004, TestSize.Level3)
958 {
959 auto freezeCommon = std::make_shared<FreezeCommon>();
960 bool ret1 = freezeCommon->Init();
961 ASSERT_EQ(ret1, true);
962 auto db = std::make_unique<DBHelper>(freezeCommon);
963 ASSERT_NE(db, nullptr);
964 unsigned long long start = 1501973701070;
965 unsigned long long end = 1501973701170;
966 std::string domain = "AAFWK";
967 std::vector<std::string> eventNames;
968 eventNames.push_back("UI_BLOCK_3S");
969 eventNames.push_back("THREAD_BLOCK_3S");
970 eventNames.push_back("THREAD_BLOCK_6S");
971 std::vector<SysEvent> result = db->SelectRecords(start, end, domain, eventNames);
972 ASSERT_TRUE(result.size() > 0);
973 }
974 }
975 }
976