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 #include "sys_event.h"
28
29 #include "freeze_common.h"
30 #include "rule_cluster.h"
31 #include "resolver.h"
32 #include "watch_point.h"
33
34 using namespace testing::ext;
35 namespace OHOS {
36 namespace HiviewDFX {
SetUp()37 void FreezeDetectorUnittest::SetUp()
38 {
39 /**
40 * @tc.setup: create work directories
41 */
42 printf("SetUp.\n");
43 }
SetUpTestCase()44 void FreezeDetectorUnittest::SetUpTestCase()
45 {
46 /**
47 * @tc.setup: all first
48 */
49 printf("SetUpTestCase.\n");
50 }
51
TearDownTestCase()52 void FreezeDetectorUnittest::TearDownTestCase()
53 {
54 /**
55 * @tc.setup: all end
56 */
57 printf("TearDownTestCase.\n");
58 }
59
TearDown()60 void FreezeDetectorUnittest::TearDown()
61 {
62 /**
63 * @tc.teardown: destroy the event loop we have created
64 */
65 printf("TearDown.\n");
66 }
67
68 /**
69 * @tc.name: FreezeResolver_001
70 * @tc.desc: FreezeDetector
71 */
72 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_001, TestSize.Level3)
73 {
74 FreezeResolver freezeResolver(nullptr);
75 ASSERT_EQ(freezeResolver.Init(), false);
76 }
77
78 /**
79 * @tc.name: FreezeResolver_002
80 * @tc.desc: FreezeDetector
81 */
82 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_002, TestSize.Level3)
83 {
84 auto freezeCommon = std::make_shared<FreezeCommon>();
85 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
86 ASSERT_EQ(freezeResolver->Init(), false);
87 }
88
89 /**
90 * @tc.name: FreezeResolver_003
91 * @tc.desc: FreezeDetector
92 */
93 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_003, TestSize.Level3)
94 {
95 auto freezeCommon = std::make_shared<FreezeCommon>();
96 bool ret1 = freezeCommon->Init();
97 ASSERT_EQ(ret1, true);
98 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
99 ASSERT_EQ(freezeResolver->Init(), true);
100 }
101
102 /**
103 * @tc.name: FreezeResolver_004
104 * @tc.desc: FreezeDetector
105 */
106 HWTEST_F(FreezeDetectorUnittest, FreezeResolver_004, TestSize.Level3)
107 {
108 auto freezeCommon = std::make_shared<FreezeCommon>();
109 bool ret1 = freezeCommon->Init();
110 ASSERT_EQ(ret1, true);
111 auto freezeResolver = std::make_unique<FreezeResolver>(freezeCommon);
112 ASSERT_EQ(freezeResolver->Init(), true);
113 auto time = freezeResolver->GetTimeZone();
114 ASSERT_NE(time, "");
115 }
116
117 /**
118 * @tc.name: FreezeVender_001
119 * @tc.desc: FreezeDetector
120 */
121 HWTEST_F(FreezeDetectorUnittest, FreezeVender_001, TestSize.Level3)
122 {
123 auto vendor = std::make_unique<Vendor>(nullptr);
124 ASSERT_EQ(vendor->Init(), false);
125 std::list<WatchPoint> list;
126 FreezeResult result;
127 ASSERT_EQ(vendor->ReduceRelevanceEvents(list, result), false);
128 }
129
130 /**
131 * @tc.name: FreezeVender_002
132 * @tc.desc: FreezeDetector
133 */
134 HWTEST_F(FreezeDetectorUnittest, FreezeVender_002, TestSize.Level3)
135 {
136 auto freezeCommon = std::make_shared<FreezeCommon>();
137 bool ret1 = freezeCommon->Init();
138 ASSERT_EQ(ret1, true);
139 auto vendor = std::make_unique<Vendor>(freezeCommon);
140 ASSERT_EQ(vendor->Init(), true);
141 std::list<WatchPoint> list;
142 FreezeResult result;
143 result.SetId(3);
144 ASSERT_EQ(vendor->ReduceRelevanceEvents(list, result), false);
145 }
146
147 /**
148 * @tc.name: FreezeVender_003
149 * @tc.desc: FreezeDetector
150 */
151 HWTEST_F(FreezeDetectorUnittest, FreezeVender_003, TestSize.Level3)
152 {
153 auto freezeCommon = std::make_shared<FreezeCommon>();
154 bool ret1 = freezeCommon->Init();
155 ASSERT_EQ(ret1, true);
156 auto vendor = std::make_unique<Vendor>(freezeCommon);
157 ASSERT_EQ(vendor->Init(), true);
158 std::list<WatchPoint> list;
159 FreezeResult result;
160 result.SetId(1);
161 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
162 .InitDomain("KERNEL_VENDOR")
163 .InitStringId("SCREEN_ON")
164 .InitTimestamp(TimeUtil::GetMilliseconds())
165 .Build();
166 list.push_back(watchPoint1);
167 WatchPoint watchPoint2 = OHOS::HiviewDFX::WatchPoint::Builder()
168 .InitDomain("KERNEL_VENDOR3")
169 .InitStringId("SCREEN_ON223")
170 .InitTimestamp(TimeUtil::GetMilliseconds())
171 .Build();
172 list.push_back(watchPoint2);
173 ASSERT_EQ(vendor->ReduceRelevanceEvents(list, result), true);
174 }
175
176 /**
177 * @tc.name: FreezeVender_004
178 * @tc.desc: FreezeDetector
179 */
180 HWTEST_F(FreezeDetectorUnittest, FreezeVender_004, TestSize.Level3)
181 {
182 auto freezeCommon = std::make_shared<FreezeCommon>();
183 bool ret1 = freezeCommon->Init();
184 ASSERT_EQ(ret1, true);
185 auto vendor = std::make_unique<Vendor>(freezeCommon);
186 ASSERT_EQ(vendor->Init(), true);
187 std::list<WatchPoint> list;
188 FreezeResult result;
189 result.SetId(0);
190 WatchPoint watchPoint1 = OHOS::HiviewDFX::WatchPoint::Builder()
191 .InitDomain("KERNEL_VENDOR")
192 .InitStringId("SCREEN_ON")
193 .InitTimestamp(TimeUtil::GetMilliseconds())
194 .Build();
195 list.push_back(watchPoint1);
196 WatchPoint watchPoint2 = OHOS::HiviewDFX::WatchPoint::Builder()
197 .InitDomain("AAFWK")
198 .InitStringId("LIFECYCLE_TIMEOUT")
199 .InitTimestamp(TimeUtil::GetMilliseconds())
200 .Build();
201 list.push_back(watchPoint2);
202 ASSERT_EQ(vendor->ReduceRelevanceEvents(list, result), true);
203 }
204 }
205 }
206