1 /*
2 * Copyright (c) 2023-2025 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
16 #include <gtest/gtest.h>
17
18 #define private public
19 #include "appfreeze_manager.h"
20 #undef private
21
22 #include "cpp/mutex.h"
23 #include "cpp/condition_variable.h"
24 #include "fault_data.h"
25 #include "freeze_util.h"
26 #ifdef ABILITY_RUNTIME_HITRACE_ENABLE
27 #include "hitrace/hitracechain.h"
28 #endif
29
30 using namespace testing;
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::AppExecFwk;
34
35 namespace OHOS {
36 namespace AppExecFwk {
37 class AppfreezeManagerTest : public testing::Test {
38 public:
AppfreezeManagerTest()39 AppfreezeManagerTest()
40 {}
~AppfreezeManagerTest()41 ~AppfreezeManagerTest()
42 {}
43 std::shared_ptr<AppfreezeManager> appfreezeManager = nullptr;
44 static void SetUpTestCase(void);
45 static void TearDownTestCase(void);
46 void SetUp();
47 void TearDown();
48 };
49
SetUpTestCase(void)50 void AppfreezeManagerTest::SetUpTestCase(void)
51 {}
52
TearDownTestCase(void)53 void AppfreezeManagerTest::TearDownTestCase(void)
54 {}
55
SetUp(void)56 void AppfreezeManagerTest::SetUp(void)
57 {
58 appfreezeManager = AppfreezeManager::GetInstance();
59 }
60
TearDown(void)61 void AppfreezeManagerTest::TearDown(void)
62 {
63 AppfreezeManager::DestroyInstance();
64 }
65
66 /**
67 * @tc.number: AppfreezeManagerTest_001
68 * @tc.desc: add testcase codecoverage
69 * @tc.type: FUNC
70 */
71 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_001, TestSize.Level0)
72 {
73 bool ret = appfreezeManager->IsHandleAppfreeze("");
74 EXPECT_TRUE(ret);
75 ret = appfreezeManager->IsHandleAppfreeze("AppfreezeManagerTest_001");
76 EXPECT_TRUE(ret);
77 }
78
79 /**
80 * @tc.number: AppfreezeManagerTest_002
81 * @tc.desc: add testcase codecoverage
82 * @tc.type: FUNC
83 */
84 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_002, TestSize.Level1)
85 {
86 FaultData faultData;
87 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
88 faultData.faultType = FaultDataType::APP_FREEZE;
89 AppfreezeManager::AppInfo appInfo;
90 int ret = appfreezeManager->AppfreezeHandle(faultData, appInfo);
91 EXPECT_EQ(ret, 0);
92 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
93 EXPECT_EQ(ret, 0);
94 ret = appfreezeManager->AcquireStack(faultData, appInfo, "test");
95 EXPECT_EQ(ret, 0);
96
97 faultData.errorObject.name = AppFreezeType::APP_INPUT_BLOCK;
98 ret = appfreezeManager->AppfreezeHandle(faultData, appInfo);
99 EXPECT_EQ(ret, 0);
100 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
101 EXPECT_EQ(ret, 0);
102 ret = appfreezeManager->AcquireStack(faultData, appInfo, "test");
103 EXPECT_EQ(ret, 0);
104 faultData.errorObject.name = AppFreezeType::LIFECYCLE_HALF_TIMEOUT;
105 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
106 EXPECT_EQ(ret, 0);
107 }
108
109 /**
110 * @tc.number: AppfreezeManagerTest_003
111 * @tc.desc: add testcase codecoverage
112 * @tc.type: FUNC
113 */
114 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_003, TestSize.Level1)
115 {
116 FaultData faultData;
117 faultData.errorObject.name = AppFreezeType::APP_INPUT_BLOCK;
118 AppfreezeManager::AppInfo appInfo = {
119 .pid = 1,
120 .uid = 1,
121 .bundleName = "AppfreezeManagerTest_003",
122 .processName = "AppfreezeManagerTest_003",
123 };
124 int ret = appfreezeManager->NotifyANR(faultData, appInfo, "", "");
125 EXPECT_EQ(ret, 0);
126 }
127
128 /**
129 * @tc.number: AppfreezeManagerTest_004
130 * @tc.desc: add testcase codecoverage
131 * @tc.type: FUNC
132 */
133 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_004, TestSize.Level1)
134 {
135 AppfreezeManager::ParamInfo info;
136 int ret = appfreezeManager->LifecycleTimeoutHandle(info);
137 EXPECT_EQ(ret, -1);
138 AppfreezeManager::ParamInfo info1 = {
139 .typeId = AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT,
140 .eventName = AppFreezeType::APP_INPUT_BLOCK,
141 .bundleName = "",
142 .msg = "Test",
143 };
144 ret = appfreezeManager->LifecycleTimeoutHandle(info1);
145 EXPECT_EQ(ret, -1);
146 AppfreezeManager::ParamInfo info2 = {
147 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
148 .eventName = AppFreezeType::APP_INPUT_BLOCK,
149 .bundleName = "",
150 .msg = "Test",
151 };
152 ret = appfreezeManager->LifecycleTimeoutHandle(info2);
153 EXPECT_EQ(ret, -1);
154 AppfreezeManager::ParamInfo info3 = {
155 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
156 .eventName = AppFreezeType::LIFECYCLE_HALF_TIMEOUT,
157 .bundleName = "",
158 .msg = "Test",
159 };
160 FreezeUtil::LifecycleFlow flow;
161 flow.state = AbilityRuntime::FreezeUtil::TimeoutState::FOREGROUND;
162 ret = appfreezeManager->LifecycleTimeoutHandle(info3, flow);
163 EXPECT_EQ(ret, 0);
164 }
165
166 /**
167 * @tc.number: AppfreezeManagerTest_005
168 * @tc.desc: add testcase codecoverage
169 * @tc.type: FUNC
170 */
171 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_005, TestSize.Level1)
172 {
173 std::map<int, std::list<AppfreezeManager::PeerBinderInfo>> binderInfos;
174 AppfreezeManager::PeerBinderInfo infoOne= {1, 2, 3, 5};
175 binderInfos[infoOne.clientPid].push_back(infoOne);
176 AppfreezeManager::PeerBinderInfo infoTwo= {1, 3, 4, 0};
177 binderInfos[infoTwo.clientPid].push_back(infoTwo);
178 AppfreezeManager::PeerBinderInfo infoThree= {4, 0, 5, 6};
179 binderInfos[infoThree.clientPid].push_back(infoThree);
180 AppfreezeManager::PeerBinderInfo infoFour= {5, 6, 11, 7};
181 binderInfos[infoFour.clientPid].push_back(infoFour);
182
183 std::set<int> pids;
184 AppfreezeManager::TerminalBinder terminalBinder = {0, 0};
185 AppfreezeManager::ParseBinderParam params = {1, 3, 2, 0};
186 appfreezeManager->ParseBinderPids(binderInfos, pids, params, true, terminalBinder);
187 EXPECT_EQ(pids.size(), 0);
188 params = {1, 3, 1, 0};
189 appfreezeManager->ParseBinderPids(binderInfos, pids, params, true, terminalBinder);
190 EXPECT_EQ(pids.size(), 4);
191 EXPECT_EQ(terminalBinder.pid, infoFour.serverPid);
192 EXPECT_EQ(terminalBinder.tid, infoFour.serverTid);
193 }
194
195 /**
196 * @tc.number: AppfreezeManagerTest_006
197 * @tc.desc: add testcase codecoverage
198 * @tc.type: FUNC
199 */
200 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_006, TestSize.Level1)
201 {
202 std::string ret = appfreezeManager->CatcherStacktrace(0, "");
203 printf("ret: %s\n", ret.c_str());
204 ret = appfreezeManager->CatcherStacktrace(2, "");
205 printf("ret: %s\n", ret.c_str());
206 EXPECT_TRUE(!ret.empty());
207 appfreezeManager->ClearOldInfo();
208 int32_t pid = static_cast<int32_t>(getprocpid());
209 int state = AppfreezeManager::AppFreezeState::APPFREEZE_STATE_FREEZE;
210 bool result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid, "Test");
211 EXPECT_TRUE(!result);
212 appfreezeManager->ClearOldInfo();
213 result = appfreezeManager->IsProcessDebug(pid, "Test");
214 EXPECT_TRUE(!result);
215 result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid, "Test");
216 EXPECT_TRUE(result);
217 std::string errorName = "THREAD_BLOCK_3S";
218 result = appfreezeManager->IsNeedIgnoreFreezeEvent(12000, errorName);
219 EXPECT_TRUE(!result);
220 }
221
222 /**
223 * @tc.number: AppfreezeManagerTest_007
224 * @tc.desc: add testcase codecoverage
225 * @tc.type: FUNC
226 */
227 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_007, TestSize.Level1)
228 {
229 std::string str = "123";
230 uint16_t index = 1;
231 std::string ret = appfreezeManager->StrSplit(str, index);
232 EXPECT_EQ(ret, "");
233 str = "123:456";
234 ret = appfreezeManager->StrSplit(str, index);
235 EXPECT_EQ(ret, "456");
236 }
237
238 /**
239 * @tc.number: AppfreezeManagerTest_008
240 * @tc.desc: add testcase codecoverage
241 * @tc.type: FUNC
242 */
243 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_008, TestSize.Level1)
244 {
245 int32_t pid = static_cast<int32_t>(getprocpid());
246 int state = AppfreezeManager::AppFreezeState::APPFREEZE_STATE_IDLE;
247 EXPECT_EQ(appfreezeManager->GetFreezeState(pid), state);
248 appfreezeManager->SetFreezeState(pid,
249 AppfreezeManager::AppFreezeState::APPFREEZE_STATE_FREEZE, "Test");
250 appfreezeManager->SetFreezeState(pid, state, "Test");
251 EXPECT_EQ(appfreezeManager->GetFreezeState(pid), state);
252 }
253
254 /**
255 * @tc.number: AppfreezeManagerTest_AppFreezeFilter_001
256 * @tc.desc: add testcase codecoverage
257 * @tc.type: FUNC
258 */
259 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_AppFreezeFilter_001, TestSize.Level0)
260 {
261 int32_t pid = static_cast<int32_t>(getprocpid());
262 EXPECT_TRUE(!appfreezeManager->CancelAppFreezeDetect(pid, ""));
263 appfreezeManager->ResetAppfreezeState(pid, "");
264 EXPECT_TRUE(appfreezeManager->IsValidFreezeFilter(pid, ""));
265 appfreezeManager->RemoveDeathProcess("");
266 }
267
268 /**
269 * @tc.number: AppfreezeManagerTest_AppFreezeFilter_002
270 * @tc.desc: add testcase codecoverage
271 * @tc.type: FUNC
272 */
273 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_AppFreezeFilter_002, TestSize.Level1)
274 {
275 int32_t pid = static_cast<int32_t>(getprocpid());
276 std::string bundleName = "AppfreezeManagerTest_AppFreezeFilter_002";
277 EXPECT_TRUE(appfreezeManager->CancelAppFreezeDetect(pid, bundleName));
278 EXPECT_TRUE(!appfreezeManager->IsProcessDebug(pid, bundleName));
279 appfreezeManager->RemoveDeathProcess(bundleName);
280 }
281
282 /**
283 * @tc.number: AppfreezeManagerTest_CatchStack_001
284 * @tc.desc: add testcase codecoverage
285 * @tc.type: FUNC
286 */
287 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_CatchStack_001, TestSize.Level1)
288 {
289 int32_t pid = static_cast<int32_t>(getprocpid());
290 std::string ret = "";
291 appfreezeManager->FindStackByPid(ret, pid);
292 EXPECT_TRUE(ret.empty());
293 appfreezeManager->catchStackMap_[pid] = "AppfreezeManagerTest_CatchStack_001";
294 appfreezeManager->FindStackByPid(ret, pid);
295 EXPECT_TRUE(!ret.empty());
296 EXPECT_TRUE(!appfreezeManager->catchStackMap_.empty());
297 appfreezeManager->DeleteStack(pid);
298 EXPECT_TRUE(appfreezeManager->catchStackMap_.empty());
299 }
300
301 /**
302 * @tc.number: AppfreezeManagerTest_ParseDecToHex_001
303 * @tc.desc: add testcase codecoverage
304 * @tc.type: FUNC
305 */
306 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_ParseDecToHex_001, TestSize.Level1)
307 {
308 std::string ret = appfreezeManager->ParseDecToHex(1234); // test value
309 EXPECT_EQ(ret, "4d2");
310 }
311
312 #ifdef ABILITY_RUNTIME_HITRACE_ENABLE
313 /**
314 * @tc.number: AppfreezeManagerTest_GetHitraceId_001
315 * @tc.desc: add testcase codecoverage
316 * @tc.type: FUNC
317 */
318 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_GetHitraceId_001, TestSize.Level1)
319 {
320 AppfreezeManager::HitraceInfo info;
321 bool ret = appfreezeManager->GetHitraceId(info);
322 EXPECT_TRUE(!ret);
323 OHOS::HiviewDFX::HiTraceChain::Begin("AppfreezeManagerTest_GetHitraceId_001", 0);
324 appfreezeManager->GetHitraceId(info);
325 FaultData faultData;
326 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
327 AppfreezeManager::AppInfo appInfo = {
328 .pid = getpid(),
329 .uid = getuid(),
330 .bundleName = "AppfreezeManagerTest_GetHitraceId_001",
331 .processName = "AppfreezeManagerTest_GetHitraceId_001",
332 };
333 int result = appfreezeManager->NotifyANR(faultData, appInfo, "test", "test");
334 EXPECT_EQ(result, 0);
335 }
336 #endif
337
338 /**
339 * @tc.number: AppfreezeManagerTest_ReportAppfreezeCpuInfo_001
340 * @tc.desc: add testcase
341 * @tc.type: FUNC
342 */
343 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_ReportAppfreezeCpuInfo_001, TestSize.Level1)
344 {
345 FaultData faultData;
346 std::string bundleName = "AppfreezeManagerTest";
347 faultData.appfreezeInfo = "test.txt";
348 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_3S;
349 AppfreezeManager::AppInfo appInfo = {
350 .pid = getpid(),
351 .uid = getuid(),
352 .bundleName = bundleName,
353 .processName = bundleName,
354 };
355 std::string freezeInfoFile = appfreezeManager->ReportAppfreezeCpuInfo(faultData, appInfo);
356 EXPECT_EQ(freezeInfoFile, "");
357 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
358 freezeInfoFile = appfreezeManager->ReportAppfreezeCpuInfo(faultData, appInfo);
359 EXPECT_TRUE(freezeInfoFile.empty());
360 faultData.errorObject.name = AppFreezeType::LIFECYCLE_HALF_TIMEOUT;
361 freezeInfoFile = appfreezeManager->ReportAppfreezeCpuInfo(faultData, appInfo);
362 EXPECT_EQ(freezeInfoFile, "");
363 faultData.errorObject.name = AppFreezeType::LIFECYCLE_TIMEOUT;
364 freezeInfoFile = appfreezeManager->ReportAppfreezeCpuInfo(faultData, appInfo);
365 }
366
367 /**
368 * @tc.number: AppfreezeManagerTest_GetFaultNotifyData_001
369 * @tc.desc: add testcase
370 * @tc.type: FUNC
371 */
372 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_GetFaultNotifyData_001, TestSize.Level1)
373 {
374 FaultData faultData;
375 int pid = getpid();
376 FaultData faultNotifyData = appfreezeManager->GetFaultNotifyData(faultData, pid);
377 EXPECT_EQ(faultNotifyData.eventId, -1);
378 faultData.eventId = 10;
379 faultNotifyData = appfreezeManager->GetFaultNotifyData(faultData, pid);
380 EXPECT_EQ(faultNotifyData.eventId, 10);
381 }
382
383 /**
384 * @tc.number: AppfreezeManagerTest_GetFirstLine_001
385 * @tc.desc: add testcase
386 * @tc.type: FUNC
387 */
388 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_GetFirstLine_001, TestSize.Level1)
389 {
390 std::string ret = appfreezeManager->GetFirstLine("../111");
391 EXPECT_EQ(ret, "");
392 appfreezeManager->GetFirstLine("/data/log/test");
393 }
394 } // namespace AppExecFwk
395 } // namespace OHOS
396