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