1 /*
2 * Copyright (c) 2023 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
27 using namespace testing;
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace OHOS::AppExecFwk;
31
32 namespace OHOS {
33 namespace AppExecFwk {
34 class AppfreezeManagerTest : public testing::Test {
35 public:
AppfreezeManagerTest()36 AppfreezeManagerTest()
37 {}
~AppfreezeManagerTest()38 ~AppfreezeManagerTest()
39 {}
40 std::shared_ptr<AppfreezeManager> appfreezeManager = nullptr;
41 static void SetUpTestCase(void);
42 static void TearDownTestCase(void);
43 void SetUp();
44 void TearDown();
45 };
46
SetUpTestCase(void)47 void AppfreezeManagerTest::SetUpTestCase(void)
48 {}
49
TearDownTestCase(void)50 void AppfreezeManagerTest::TearDownTestCase(void)
51 {}
52
SetUp(void)53 void AppfreezeManagerTest::SetUp(void)
54 {
55 appfreezeManager = AppfreezeManager::GetInstance();
56 }
57
TearDown(void)58 void AppfreezeManagerTest::TearDown(void)
59 {
60 AppfreezeManager::DestroyInstance();
61 }
62
63 /**
64 * @tc.number: AppfreezeManagerTest_001
65 * @tc.desc: add testcase codecoverage
66 * @tc.type: FUNC
67 */
68 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_001, TestSize.Level1)
69 {
70 bool ret = appfreezeManager->IsHandleAppfreeze("");
71 EXPECT_TRUE(ret);
72 ret = appfreezeManager->IsHandleAppfreeze("AppfreezeManagerTest_001");
73 EXPECT_TRUE(ret);
74 }
75
76 /**
77 * @tc.number: AppfreezeManagerTest_002
78 * @tc.desc: add testcase codecoverage
79 * @tc.type: FUNC
80 */
81 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_002, TestSize.Level1)
82 {
83 FaultData faultData;
84 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
85 faultData.faultType = FaultDataType::APP_FREEZE;
86 AppfreezeManager::AppInfo appInfo;
87 int ret = appfreezeManager->AppfreezeHandle(faultData, appInfo);
88 EXPECT_EQ(ret, 0);
89 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
90 EXPECT_EQ(ret, 0);
91 ret = appfreezeManager->AcquireStack(faultData, appInfo, "test");
92 EXPECT_EQ(ret, 0);
93
94 faultData.errorObject.name = AppFreezeType::APP_INPUT_BLOCK;
95 ret = appfreezeManager->AppfreezeHandle(faultData, appInfo);
96 EXPECT_EQ(ret, 0);
97 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
98 EXPECT_EQ(ret, 0);
99 ret = appfreezeManager->AcquireStack(faultData, appInfo, "test");
100 EXPECT_EQ(ret, 0);
101 faultData.errorObject.name = AppFreezeType::LIFECYCLE_HALF_TIMEOUT;
102 ret = appfreezeManager->AppfreezeHandleWithStack(faultData, appInfo);
103 EXPECT_EQ(ret, 0);
104 }
105
106 /**
107 * @tc.number: AppfreezeManagerTest_003
108 * @tc.desc: add testcase codecoverage
109 * @tc.type: FUNC
110 */
111 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_003, TestSize.Level1)
112 {
113 FaultData faultData;
114 faultData.errorObject.name = AppFreezeType::APP_INPUT_BLOCK;
115 AppfreezeManager::AppInfo appInfo = {
116 .pid = 1,
117 .uid = 1,
118 .bundleName = "AppfreezeManagerTest_003",
119 .processName = "AppfreezeManagerTest_003",
120 };
121 int ret = appfreezeManager->NotifyANR(faultData, appInfo, "", "");
122 EXPECT_EQ(ret, 0);
123 }
124
125 /**
126 * @tc.number: AppfreezeManagerTest_004
127 * @tc.desc: add testcase codecoverage
128 * @tc.type: FUNC
129 */
130 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_004, TestSize.Level1)
131 {
132 AppfreezeManager::ParamInfo info;
133 int ret = appfreezeManager->LifecycleTimeoutHandle(info);
134 EXPECT_EQ(ret, -1);
135 AppfreezeManager::ParamInfo info1 = {
136 .typeId = AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT,
137 .eventName = AppFreezeType::APP_INPUT_BLOCK,
138 .bundleName = "",
139 .msg = "Test",
140 };
141 ret = appfreezeManager->LifecycleTimeoutHandle(info1);
142 EXPECT_EQ(ret, -1);
143 AppfreezeManager::ParamInfo info2 = {
144 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
145 .eventName = AppFreezeType::APP_INPUT_BLOCK,
146 .bundleName = "",
147 .msg = "Test",
148 };
149 ret = appfreezeManager->LifecycleTimeoutHandle(info2);
150 EXPECT_EQ(ret, -1);
151 AppfreezeManager::ParamInfo info3 = {
152 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
153 .eventName = AppFreezeType::LIFECYCLE_HALF_TIMEOUT,
154 .bundleName = "",
155 .msg = "Test",
156 };
157 FreezeUtil::LifecycleFlow flow;
158 flow.state = AbilityRuntime::FreezeUtil::TimeoutState::FOREGROUND;
159 ret = appfreezeManager->LifecycleTimeoutHandle(info3, flow);
160 EXPECT_EQ(ret, 0);
161 }
162
163 /**
164 * @tc.number: AppfreezeManagerTest_005
165 * @tc.desc: add testcase codecoverage
166 * @tc.type: FUNC
167 */
168 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_005, TestSize.Level1)
169 {
170 std::map<int, std::list<AppfreezeManager::PeerBinderInfo>> binderInfos;
171 AppfreezeManager::PeerBinderInfo infoOne= {3, 0, 0, 0};
172 binderInfos[1].push_back(infoOne);
173 AppfreezeManager::PeerBinderInfo infoTwo= {4, 0, 0, 0};
174 binderInfos[1].push_back(infoTwo);
175 std::set<int> pids;
176 AppfreezeManager::TerminalBinder terminalBinder = {0, 0, false};
177 appfreezeManager->ParseBinderPids(binderInfos, pids, 2, 8, terminalBinder);
178 EXPECT_EQ(pids.size(), 0);
179 appfreezeManager->ParseBinderPids(binderInfos, pids, 1, 0, terminalBinder);
180 EXPECT_EQ(pids.size(), 1);
181 }
182
183 /**
184 * @tc.number: AppfreezeManagerTest_006
185 * @tc.desc: add testcase codecoverage
186 * @tc.type: FUNC
187 */
188 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_006, TestSize.Level1)
189 {
190 std::string ret = appfreezeManager->CatcherStacktrace(0, "");
191 printf("ret: %s\n", ret.c_str());
192 ret = appfreezeManager->CatcherStacktrace(2, "");
193 printf("ret: %s\n", ret.c_str());
194 EXPECT_TRUE(!ret.empty());
195 appfreezeManager->ClearOldInfo();
196 int32_t pid = static_cast<int32_t>(getprocpid());
197 int state = AppfreezeManager::AppFreezeState::APPFREEZE_STATE_FREEZE;
198 bool result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid, "Test");
199 EXPECT_TRUE(!result);
200 appfreezeManager->ClearOldInfo();
201 result = appfreezeManager->IsProcessDebug(pid, "Test");
202 EXPECT_TRUE(!result);
203 result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid, "Test");
204 EXPECT_TRUE(result);
205 std::string errorName = "THREAD_BLOCK_3S";
206 result = appfreezeManager->IsNeedIgnoreFreezeEvent(12000, errorName);
207 EXPECT_TRUE(!result);
208 }
209
210 /**
211 * @tc.number: AppfreezeManagerTest_007
212 * @tc.desc: add testcase codecoverage
213 * @tc.type: FUNC
214 */
215 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_007, TestSize.Level1)
216 {
217 int32_t pid = static_cast<int32_t>(getprocpid());
218 int state = AppfreezeManager::AppFreezeState::APPFREEZE_STATE_IDLE;
219 EXPECT_EQ(appfreezeManager->GetFreezeState(pid), state);
220 appfreezeManager->SetFreezeState(pid,
221 AppfreezeManager::AppFreezeState::APPFREEZE_STATE_FREEZE, "Test");
222 appfreezeManager->SetFreezeState(pid, state, "Test");
223 EXPECT_EQ(appfreezeManager->GetFreezeState(pid), state);
224 }
225
226 /**
227 * @tc.number: AppfreezeManagerTest_AppFreezeFilter_001
228 * @tc.desc: add testcase codecoverage
229 * @tc.type: FUNC
230 */
231 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_AppFreezeFilter_001, TestSize.Level1)
232 {
233 int32_t pid = static_cast<int32_t>(getprocpid());
234 EXPECT_TRUE(!appfreezeManager->CancelAppFreezeDetect(pid, ""));
235 appfreezeManager->ResetAppfreezeState(pid, "");
236 EXPECT_TRUE(appfreezeManager->IsValidFreezeFilter(pid, ""));
237 appfreezeManager->RemoveDeathProcess("");
238 }
239
240 /**
241 * @tc.number: AppfreezeManagerTest_AppFreezeFilter_002
242 * @tc.desc: add testcase codecoverage
243 * @tc.type: FUNC
244 */
245 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_AppFreezeFilter_002, TestSize.Level1)
246 {
247 int32_t pid = static_cast<int32_t>(getprocpid());
248 std::string bundleName = "AppfreezeManagerTest_AppFreezeFilter_002";
249 EXPECT_TRUE(appfreezeManager->CancelAppFreezeDetect(pid, bundleName));
250 EXPECT_TRUE(appfreezeManager->IsProcessDebug(pid, bundleName));
251 appfreezeManager->RemoveDeathProcess(bundleName);
252 }
253
254 /**
255 * @tc.number: AppfreezeManagerTest_CatchStack_001
256 * @tc.desc: add testcase codecoverage
257 * @tc.type: FUNC
258 */
259 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_CatchStack_001, TestSize.Level1)
260 {
261 int32_t pid = static_cast<int32_t>(getprocpid());
262 std::string ret = "";
263 appfreezeManager->FindStackByPid(ret, pid);
264 EXPECT_TRUE(ret.empty());
265 appfreezeManager->catchStackMap_[pid] = "AppfreezeManagerTest_CatchStack_001";
266 appfreezeManager->FindStackByPid(ret, pid);
267 EXPECT_TRUE(!ret.empty());
268 EXPECT_TRUE(!appfreezeManager->catchStackMap_.empty());
269 appfreezeManager->DeleteStack(pid);
270 EXPECT_TRUE(appfreezeManager->catchStackMap_.empty());
271 }
272 } // namespace AppExecFwk
273 } // namespace OHOS
274