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_EQ(vendor->MergeEventLog(watchPoint, list, result),
391 "/data/log/faultlog/sysfreeze-SCREEN_ON-1000-20230627174503.tmp");
392 }
393
394 /**
395 * @tc.name: FreezeVender_008
396 * @tc.desc: FreezeDetector
397 */
398 HWTEST_F(FreezeDetectorUnittest, FreezeVender_008, TestSize.Level3)
399 {
400 auto freezeCommon = std::make_shared<FreezeCommon>();
401 bool ret1 = freezeCommon->Init();
402 ASSERT_EQ(ret1, true);
403 auto vendor = std::make_unique<Vendor>(freezeCommon);
404 ASSERT_EQ(vendor->Init(), true);
405 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
406 .InitDomain("KERNEL_VENDOR")
407 .InitStringId("SCREEN_ON")
408 .InitTimestamp(TimeUtil::GetMilliseconds())
409 .InitProcessName("processName")
410 .InitPackageName("com.package.name")
411 .InitMsg("msg")
412 .Build();
413 std::vector<WatchPoint> list;
414 list.push_back(watchPoint);
415 vendor->MergeFreezeJsonFile(watchPoint, list);
416
417 auto vendor1 = std::make_unique<Vendor>(nullptr);
418 std::vector<FreezeResult> result;
419 std::string ret = vendor->MergeEventLog(watchPoint, list, result);
420 printf("MergeEventLog ret = %s\n.", ret.c_str());
421 }
422
423 /**
424 * @tc.name: FreezeRuleCluster_001
425 * @tc.desc: FreezeDetector
426 */
427 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_001, TestSize.Level3)
428 {
429 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
430 ASSERT_EQ(freezeRuleCluster->Init(), true);
431 }
432
433 /**
434 * @tc.name: FreezeRuleCluster_002
435 * @tc.desc: FreezeDetector
436 */
437 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_002, TestSize.Level3)
438 {
439 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
440 ASSERT_EQ(freezeRuleCluster->Init(), true);
441 ASSERT_EQ(freezeRuleCluster->CheckFileSize("path"), false);
442 ASSERT_EQ(freezeRuleCluster->CheckFileSize("/system/etc/hiview/freeze_rules.xml"), true);
443 }
444
445 /**
446 * @tc.name: FreezeRuleCluster_003
447 * @tc.desc: FreezeDetector
448 */
449 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_003, TestSize.Level3)
450 {
451 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
452 ASSERT_EQ(freezeRuleCluster->Init(), true);
453 ASSERT_EQ(freezeRuleCluster->ParseRuleFile("path"), false);
454 ASSERT_EQ(freezeRuleCluster->ParseRuleFile("/system/etc/hiview/freeze_rules.xml"), true);
455 }
456
457 /**
458 * @tc.name: FreezeRuleCluster_004
459 * @tc.desc: FreezeDetector
460 */
461 HWTEST_F(FreezeDetectorUnittest, FreezeRuleCluster_004, TestSize.Level3)
462 {
463 auto freezeRuleCluster = std::make_unique<FreezeRuleCluster>();
464 ASSERT_EQ(freezeRuleCluster->Init(), true);
465
466 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
467 .InitDomain("KERNEL_VENDOR")
468 .InitStringId("SCREEN_ON")
469 .Build();
470
471 std::vector<FreezeResult> list;
472 FreezeResult result1;
473 result1.SetId(1);
474 FreezeResult result2;
475 result2.SetId(2);
476 list.push_back(result1);
477 list.push_back(result2);
478
479 ASSERT_EQ(freezeRuleCluster->GetResult(watchPoint, list), true);
480 }
481
482 /**
483 * @tc.name: FreezeRule_001
484 * @tc.desc: FreezeDetector
485 */
486 HWTEST_F(FreezeDetectorUnittest, FreezeRule_001, TestSize.Level3)
487 {
488 auto freezeRule = std::make_unique<FreezeRule>();
489 FreezeResult result;
490 result.SetId(1);
491
492 freezeRule->AddResult("KERNEL_VENDOR", "SCREEN_ON", result);
493 ASSERT_EQ(freezeRule->GetResult("KERNEL_VENDOR", "SCREEN_ON", result), true);
494 }
495
496 /**
497 * @tc.name: FreezeRule_002
498 * @tc.desc: FreezeDetector
499 */
500 HWTEST_F(FreezeDetectorUnittest, FreezeRule_002, TestSize.Level3)
501 {
502 auto freezeRule = std::make_unique<FreezeRule>();
503 FreezeResult result;
504 result.SetId(1);
505
506 ASSERT_EQ(freezeRule->GetResult("KERNEL_VENDOR", "SCREEN_ON", result), false);
507 }
508
509 /**
510 * @tc.name: FreezeDetectorPlugin_001
511 * @tc.desc: FreezeDetector
512 */
513 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_001, TestSize.Level3)
514 {
515 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
516 ASSERT_EQ(freezeDetectorPlugin->ReadyToLoad(), true);
517 freezeDetectorPlugin->OnLoad();
518 }
519
520 /**
521 * @tc.name: FreezeDetectorPlugin_002
522 * @tc.desc: FreezeDetector
523 */
524 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_002, TestSize.Level3)
525 {
526 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
527 auto event = std::make_shared<Event>("sender", "event");
528 ASSERT_EQ(freezeDetectorPlugin->OnEvent(event), false);
529 }
530
531 /**
532 * @tc.name: FreezeDetectorPlugin_003
533 * @tc.desc: FreezeDetector
534 */
535 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_003, TestSize.Level3)
536 {
537 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
538 freezeDetectorPlugin->OnLoad();
539 ASSERT_NE(freezeDetectorPlugin, nullptr);
540 }
541
542 /**
543 * @tc.name: FreezeDetectorPlugin_004
544 * @tc.desc: FreezeDetector
545 */
546 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_004, TestSize.Level3)
547 {
548 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
549 freezeDetectorPlugin->OnUnload();
550 ASSERT_NE(freezeDetectorPlugin, nullptr);
551 }
552
553 /**
554 * @tc.name: FreezeDetectorPlugin_005
555 * @tc.desc: FreezeDetector
556 */
557 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPlugin_005, TestSize.Level3)
558 {
559 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
560 auto event = std::make_shared<Event>("sender", "event");
561 ASSERT_EQ(freezeDetectorPlugin->CanProcessEvent(event), false);
562 }
563
564 /**
565 * @tc.name: FreezeDetectorPlugin006
566 * @tc.desc: FreezeDetectorPlugin send LIFECYCLE_TIMEOUT
567 * @tc.type: FUNC
568 * @tc.require: AR000H3T5D
569 */
570 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPluginTest006, TestSize.Level3)
571 {
572 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
573 auto event = std::make_shared<Event>("sender", "event");
574 freezeDetectorPlugin->OnEventListeningCallback(*(event.get()));
575 }
576
577 /**
578 * @tc.name: FreezeDetectorPlugin007
579 * @tc.desc: add testcase coverage
580 * @tc.type: FUNC
581 */
582 HWTEST_F(FreezeDetectorUnittest, FreezeDetectorPluginTest007, TestSize.Level3)
583 {
584 auto freezeDetectorPlugin = std::make_unique<FreezeDetectorPlugin>();
585 freezeDetectorPlugin->RemoveRedundantNewline("test1\\ntest2\\ntest3");
586 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
587 .InitDomain("KERNEL_VENDOR")
588 .InitStringId("SCREEN_ON")
589 .Build();
590 freezeDetectorPlugin->ProcessEvent(watchPoint);
591 }
592
593 /**
594 * @tc.name: FreezeCommon_001
595 * @tc.desc: FreezeDetector
596 */
597 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_001, TestSize.Level3)
598 {
599 auto freezeCommon = std::make_unique<FreezeCommon>();
600 ASSERT_EQ(freezeCommon->Init(), true);
601 ASSERT_EQ(freezeCommon->IsBetaVersion(), true);
602 }
603
604 /**
605 * @tc.name: FreezeCommon_002
606 * @tc.desc: FreezeDetector
607 */
608 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_002, TestSize.Level3)
609 {
610 auto freezeCommon = std::make_unique<FreezeCommon>();
611 ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
612 freezeCommon->Init();
613 ASSERT_EQ(freezeCommon->IsFreezeEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
614 }
615
616 /**
617 * @tc.name: FreezeCommon_003
618 * @tc.desc: FreezeDetector
619 */
620 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_003, TestSize.Level3)
621 {
622 auto freezeCommon = std::make_unique<FreezeCommon>();
623 ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
624 freezeCommon->Init();
625 ASSERT_EQ(freezeCommon->IsApplicationEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
626 }
627
628 /**
629 * @tc.name: FreezeCommon_004
630 * @tc.desc: FreezeDetector
631 */
632 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_004, TestSize.Level3)
633 {
634 auto freezeCommon = std::make_unique<FreezeCommon>();
635 ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), false);
636 freezeCommon->Init();
637 ASSERT_EQ(freezeCommon->IsSystemEvent("KERNEL_VENDOR", "SCREEN_ON"), true);
638 }
639
640 /**
641 * @tc.name: FreezeCommon_005
642 * @tc.desc: FreezeDetector
643 */
644 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_005, TestSize.Level3)
645 {
646 auto freezeCommon = std::make_unique<FreezeCommon>();
647 freezeCommon->Init();
648 FreezeResult result;
649 result.SetId(1);
650 ASSERT_EQ(freezeCommon->IsSystemResult(result), true);
651 result.SetId(0);
652 ASSERT_EQ(freezeCommon->IsSystemResult(result), false);
653 }
654
655 /**
656 * @tc.name: FreezeCommon_006
657 * @tc.desc: FreezeDetector
658 */
659 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_006, TestSize.Level3)
660 {
661 auto freezeCommon = std::make_unique<FreezeCommon>();
662 freezeCommon->Init();
663 FreezeResult result;
664 result.SetId(0);
665 ASSERT_EQ(freezeCommon->IsApplicationResult(result), true);
666 result.SetId(1);
667 ASSERT_EQ(freezeCommon->IsApplicationResult(result), false);
668 }
669
670 /**
671 * @tc.name: FreezeCommon_007
672 * @tc.desc: FreezeDetector
673 */
674 HWTEST_F(FreezeDetectorUnittest, FreezeCommon_007, TestSize.Level3)
675 {
676 auto freezeCommon = std::make_unique<FreezeCommon>();
677 freezeCommon->GetPrincipalStringIds();
678 freezeCommon->Init();
679 freezeCommon->GetPrincipalStringIds();
680 }
681
682 /**
683 * @tc.name: FreezeWatchPoint_001
684 * @tc.desc: FreezeDetector
685 */
686 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_001, TestSize.Level3)
687 {
688 WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
689 .InitDomain("KERNEL_VENDOR")
690 .InitStringId("SCREEN_ON")
691 .InitTimestamp(TimeUtil::GetMilliseconds())
692 .Build();
693 auto wp1 = std::make_unique<WatchPoint>(point);
694 std::string logPath = "/data/test/test_data/LOG001.log";
695 wp1->SetLogPath(logPath);
696 ASSERT_EQ(wp1->GetLogPath(), logPath);
697 }
698
699 /**
700 * @tc.name: FreezeWatchPoint_002
701 * @tc.desc: FreezeDetector
702 */
703 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_002, TestSize.Level3)
704 {
705 WatchPoint point = OHOS::HiviewDFX::WatchPoint::Builder()
706 .InitDomain("KERNEL_VENDOR")
707 .InitStringId("SCREEN_ON")
708 .InitTimestamp(TimeUtil::GetMilliseconds())
709 .Build();
710 auto wp1 = std::make_unique<WatchPoint>(point);
711 long seq = 1000L;
712 wp1->SetSeq(seq);
713 ASSERT_EQ(wp1->GetSeq(), seq);
714 }
715
716 /**
717 * @tc.name: FreezeWatchPoint_003
718 * @tc.desc: FreezeDetector
719 */
720 HWTEST_F(FreezeDetectorUnittest, FreezeWatchPoint_003, TestSize.Level3)
721 {
722 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
723 .InitDomain("KERNEL_VENDOR")
724 .InitStringId("SCREEN_ON")
725 .InitTimestamp(1687859103947)
726 .Build();
727 auto wp = std::make_unique<WatchPoint>(watchPoint);
728
729 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
730 .InitDomain("KERNEL_VENDOR")
731 .InitStringId("SCREEN_ON")
732 .InitTimestamp(1687859103950)
733 .Build();
734 auto wp1 = std::make_unique<WatchPoint>(watchPoint1);
735 printf("wp < wp1: %s\n", wp < wp1 ? "true" : "false");
736 printf("wp = wp1: %s\n", wp == wp1 ? "true" : "false");
737 }
738
739 /**
740 * @tc.name: FreezeDBHelper_001
741 * @tc.desc: FreezeDetector
742 */
743 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_001, TestSize.Level3)
744 {
745 auto freezeCommon = nullptr;
746 auto db = std::make_unique<DBHelper>(freezeCommon);
747 ASSERT_NE(db, nullptr);
748 std::string watchPackage = "com.package.name";
749 std::vector<WatchPoint> list;
750 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
751 .InitDomain("ACE")
752 .InitStringId("UI_BLOCK_3S")
753 .InitPackageName(watchPackage)
754 .InitTimestamp(TimeUtil::GetMilliseconds())
755 .Build();
756 list.push_back(watchPoint);
757 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
758 .InitDomain("ACE")
759 .InitStringId("UI_BLOCK_RECOVERED")
760 .InitPackageName(watchPackage)
761 .InitTimestamp(TimeUtil::GetMilliseconds())
762 .Build();
763 list.push_back(watchPoint1);
764 unsigned long long start = TimeUtil::GetMilliseconds() - 5L;
765 unsigned long long end = TimeUtil::GetMilliseconds();
766 auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
767 db->SelectEventFromDB(start, end, list, watchPoint.GetPackageName(), result);
768 }
769
770 /**
771 * @tc.name: FreezeDBHelper_002
772 * @tc.desc: FreezeDetector
773 */
774 HWTEST_F(FreezeDetectorUnittest, FreezeDBHelper_002, TestSize.Level3)
775 {
776 auto freezeCommon = std::make_shared<FreezeCommon>();
777 bool ret1 = freezeCommon->Init();
778 ASSERT_EQ(ret1, true);
779 auto db = std::make_unique<DBHelper>(freezeCommon);
780 ASSERT_NE(db, nullptr);
781 std::string watchPackage = "com.package.name";
782 std::vector<WatchPoint> list;
783 WatchPoint watchPoint = OHOS::HiviewDFX::WatchPoint::Builder()
784 .InitDomain("ACE")
785 .InitStringId("UI_BLOCK_3S")
786 .InitPackageName(watchPackage)
787 .InitTimestamp(TimeUtil::GetMilliseconds())
788 .Build();
789 list.push_back(watchPoint);
790 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
791 .InitDomain("ACE")
792 .InitStringId("UI_BLOCK_RECOVERED")
793 .InitPackageName(watchPackage)
794 .InitTimestamp(TimeUtil::GetMilliseconds())
795 .Build();
796 list.push_back(watchPoint1);
797 unsigned long long start = TimeUtil::GetMilliseconds() + 1000L;
798 unsigned long long end = TimeUtil::GetMilliseconds();
799 auto result = FreezeResult(5, "ACE", "UI_BLOCK_3S");
800 db->SelectEventFromDB(start, end, list, watchPoint.GetPackageName(), result);
801 }
802 }
803 }
804