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     ASSERT_EQ(freezeDetectorPlugin->CanProcessEvent(event), false);
602 }
603 
604 /**
605  * @tc.name: FreezeDetectorPlugin006
606  * @tc.desc: FreezeDetectorPlugin send LIFECYCLE_TIMEOUT
607  * @tc.type: FUNC
608  * @tc.require: AR000H3T5D
609  */
610 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPluginTest006, TestSize.Level3)
611 {
612     auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
613     auto event = std::make_shared<Event>("sender", "event");
614     freezeDetectorPlugin->OnEventListeningCallback(*(event.get()));
615 }
616 
617 /**
618  * @tc.name: FreezeDetectorPlugin007
619  * @tc.desc: add testcase coverage
620  * @tc.type: FUNC
621  */
622 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPluginTest007, TestSize.Level3)
623 {
624     auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
625     freezeDetectorPlugin->RemoveRedundantNewline("test1\\ntest2\\ntest3");
626     WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
627         .InitDomain("KERNEL_VENDOR")
628         .InitStringId("SCREEN_ON")
629         .Build();
630     freezeDetectorPlugin->ProcessEvent(watchPoint);
631 }
632 
633 /**
634  * @tc.name: FreezeCommon_001
635  * @tc.desc: FreezeDetector
636  */
637 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_001, TestSize.Level3)
638 {
639     auto freezeCommon = std::make_unique<FreezeCommon>();
640     ASSERT_EQ(freezeCommon->Init(), true);
641     ASSERT_EQ(freezeCommon->IsBetaVersion(), true);
642 }
643 
644 /**
645  * @tc.name: FreezeCommon_002
646  * @tc.desc: FreezeDetector
647  */
648 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_002, TestSize.Level3)
649 {
650     auto freezeCommon = std::make_unique<FreezeCommon>();
651     ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
652     freezeCommon->Init();
653     ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
654 }
655 
656 /**
657  * @tc.name: FreezeCommon_003
658  * @tc.desc: FreezeDetector
659  */
660 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_003, TestSize.Level3)
661 {
662     auto freezeCommon = std::make_unique<FreezeCommon>();
663     ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
664     freezeCommon->Init();
665     ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
666 }
667 
668 /**
669  * @tc.name: FreezeCommon_004
670  * @tc.desc: FreezeDetector
671  */
672 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_004, TestSize.Level3)
673 {
674     auto freezeCommon = std::make_unique<FreezeCommon>();
675     ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
676     freezeCommon->Init();
677     ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
678 }
679 
680 /**
681  * @tc.name: FreezeCommon_005
682  * @tc.desc: FreezeDetector
683  */
684 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_005, TestSize.Level3)
685 {
686     auto freezeCommon = std::make_unique<FreezeCommon>();
687     freezeCommon->Init();
688     FreezeResult result;
689     result.SetId(1);
690     ASSERT_EQ(freezeCommon->IsSystemResult(result), true);
691     result.SetId(0);
692     ASSERT_EQ(freezeCommon->IsSystemResult(result), false);
693 }
694 
695 /**
696  * @tc.name: FreezeCommon_006
697  * @tc.desc: FreezeDetector
698  */
699 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_006, TestSize.Level3)
700 {
701     auto freezeCommon = std::make_unique<FreezeCommon>();
702     freezeCommon->Init();
703     FreezeResult result;
704     result.SetId(0);
705     ASSERT_EQ(freezeCommon->IsApplicationResult(result), true);
706     result.SetId(1);
707     ASSERT_EQ(freezeCommon->IsApplicationResult(result), false);
708 }
709 
710 /**
711  * @tc.name: FreezeCommon_007
712  * @tc.desc: FreezeDetector
713  */
714 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_007, TestSize.Level3)
715 {
716     auto freezeCommon = std::make_unique<FreezeCommon>();
717     freezeCommon->GetPrincipalStringIds();
718     freezeCommon->Init();
719     freezeCommon->GetPrincipalStringIds();
720 }
721 
722 /**
723  * @tc.name: FreezeCommon_008
724  * @tc.desc: FreezeDetector
725  */
726 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_008, TestSize.Level3)
727 {
728     auto freezeCommon = std::make_unique<FreezeCommon>();
729     freezeCommon->WriteStartInfoToFd(0, "FreezeCommon_008 test");
730     freezeCommon->WriteEndInfoToFd(0, "FreezeCommon_008 test");
731     ASSERT_TRUE(freezeCommon != nullptr);
732 }
733 
734 /**
735  * @tc.name: FreezeWatchPoint_001
736  * @tc.desc: FreezeDetector
737  */
738 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_001, TestSize.Level3)
739 {
740     WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
741         .InitDomain("KERNEL_VENDOR")
742         .InitStringId("SCREEN_ON")
743         .InitTimestamp(TimeUtil::GetMilliseconds())
744         .Build();
745     auto wp1 = std::make_unique<WatchPoint>(point);
746     std::string logPath = "/data/test/test_data/LOG001.log";
747     wp1->SetLogPath(logPath);
748     ASSERT_EQ(wp1->GetLogPath(), logPath);
749 }
750 
751 /**
752  * @tc.name: FreezeWatchPoint_002
753  * @tc.desc: FreezeDetector
754  */
755 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_002, TestSize.Level3)
756 {
757     WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
758         .InitDomain("KERNEL_VENDOR")
759         .InitStringId("SCREEN_ON")
760         .InitTimestamp(TimeUtil::GetMilliseconds())
761         .Build();
762     auto wp1 = std::make_unique<WatchPoint>(point);
763     long seq = 1000L;
764     wp1->SetSeq(seq);
765     ASSERT_EQ(wp1->GetSeq(), seq);
766 }
767 
768 /**
769  * @tc.name: FreezeWatchPoint_003
770  * @tc.desc: FreezeDetector
771  */
772 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_003, TestSize.Level3)
773 {
774     WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
775         .InitDomain("KERNEL_VENDOR")
776         .InitStringId("SCREEN_ON")
777         .InitMsg("Test")
778         .InitTimestamp(1687859103947)
779         .Build();
780     auto wp = std::make_unique<WatchPoint>(watchPoint);
781 
782     WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
783         .InitDomain("KERNEL_VENDOR")
784         .InitStringId("SCREEN_ON")
785         .InitTimestamp(1687859103950)
786         .Build();
787     auto wp1 = std::make_unique<WatchPoint>(watchPoint1);
788     bool ret = wp < wp1;
789     printf("wp < wp1: %s\n", ret ? "true" : "false");
790     ret = wp == wp1;
791     printf("wp = wp1: %s\n", ret ? "true" : "false");
792     std::string result = wp->GetMsg();
793     EXPECT_TRUE(!wp->GetMsg().empty());
794     EXPECT_TRUE(wp1->GetMsg().empty());
795 }
796 
797 /**
798  * @tc.name: FreezeWatchPoint_004
799  * @tc.desc: FreezeDetector
800  */
801 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_004, TestSize.Level3)
802 {
803     auto wp1 = std::make_unique<WatchPoint>();
804     ASSERT_EQ(wp1->GetSeq(), 0);
805 }
806 
807 /**
808  * @tc.name: FreezeWatchPoint_005
809  * @tc.desc: FreezeDetector
810  */
811 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_005, TestSize.Level3)
812 {
813     WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
814         .InitDomain("KERNEL_VENDOR")
815         .InitStringId("SCREEN_ON")
816         .InitTimestamp(1687859103947)
817         .InitPid(1000)
818         .InitTid(1000)
819         .InitUid(1000)
820         .InitProcessName("processName")
821         .InitPackageName("com.package.name")
822         .InitHitraceTime("20230627")
823         .InitSysrqTime("20230627")
824         .Build();
825     auto wp1 = std::make_unique<WatchPoint>(watchPoint);
826     ASSERT_EQ(wp1->GetTid(), 1000);
827 }
828 
829 /**
830  * @tc.name: FreezeDBHelper_001
831  * @tc.desc: FreezeDetector
832  */
833 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_001, TestSize.Level3)
834 {
835     auto freezeCommon = nullptr;
836     auto db = std::make_unique<DBHelper>(freezeCommon);
837     ASSERT_NE(db, nullptr);
838     std::string watchPackage = "com.package.name";
839     std::vector<WatchPoint> list;
840     WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
841         .InitDomain("ACE")
842         .InitStringId("UI_BLOCK_3S")
843         .InitPackageName(watchPackage)
844         .InitTimestamp(TimeUtil::GetMilliseconds())
845         .Build();
846     list.push_back(watchPoint);
847     WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
848         .InitDomain("ACE")
849         .InitStringId("UI_BLOCK_RECOVERED")
850         .InitPackageName(watchPackage)
851         .InitTimestamp(TimeUtil::GetMilliseconds())
852         .Build();
853     list.push_back(watchPoint1);
854     unsigned long long start = TimeUtil::GetMilliseconds() - 5L;
855     unsigned long long end = TimeUtil::GetMilliseconds();
856     auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
857     DBHelper::WatchParams params = {watchPoint.GetPid(), watchPoint.GetPackageName()};
858     db->SelectEventFromDB(start, end, list, params, result);
859 }
860 
861 /**
862  * @tc.name: FreezeDBHelper_002
863  * @tc.desc: FreezeDetector
864  */
865 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_002, TestSize.Level3)
866 {
867     auto freezeCommon = std::make_shared<FreezeCommon>();
868     bool ret1 = freezeCommon->Init();
869     ASSERT_EQ(ret1, true);
870     auto db = std::make_unique<DBHelper>(freezeCommon);
871     ASSERT_NE(db, nullptr);
872     std::string watchPackage = "com.package.name";
873     std::vector <WatchPoint> list;
874     WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
875         .InitDomain("ACE")
876         .InitStringId("UI_BLOCK_3S")
877         .InitPackageName(watchPackage)
878         .InitTimestamp(TimeUtil::GetMilliseconds())
879         .Build();
880     list.push_back(watchPoint);
881     WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
882         .InitDomain("ACE")
883         .InitStringId("UI_BLOCK_RECOVERED")
884         .InitPackageName(watchPackage)
885         .InitTimestamp(TimeUtil::GetMilliseconds())
886         .Build();
887     list.push_back(watchPoint1);
888     unsigned long long start = TimeUtil::GetMilliseconds() + 1000L;
889     unsigned long long end = TimeUtil::GetMilliseconds();
890     auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
891     DBHelper::WatchParams params = {watchPoint.GetPid(), watchPoint.GetPackageName()};
892     db->SelectEventFromDB(start, end, list, params, result);
893 }
894 }
895 }
896