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