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 }
102
103 /**
104 * @tc.number: AppfreezeManagerTest_003
105 * @tc.desc: add testcase codecoverage
106 * @tc.type: FUNC
107 */
108 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_003, TestSize.Level1)
109 {
110 FaultData faultData;
111 faultData.errorObject.name = AppFreezeType::APP_INPUT_BLOCK;
112 AppfreezeManager::AppInfo appInfo = {
113 .pid = 1,
114 .uid = 1,
115 .bundleName = "AppfreezeManagerTest_003",
116 .processName = "AppfreezeManagerTest_003",
117 };
118 int ret = appfreezeManager->NotifyANR(faultData, appInfo, "", "");
119 EXPECT_EQ(ret, 0);
120 }
121
122 /**
123 * @tc.number: AppfreezeManagerTest_004
124 * @tc.desc: add testcase codecoverage
125 * @tc.type: FUNC
126 */
127 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_004, TestSize.Level1)
128 {
129 AppfreezeManager::ParamInfo info;
130 int ret = appfreezeManager->LifecycleTimeoutHandle(info);
131 EXPECT_EQ(ret, -1);
132 AppfreezeManager::ParamInfo info1 = {
133 .typeId = AppfreezeManager::TypeAttribute::NORMAL_TIMEOUT,
134 .eventName = AppFreezeType::APP_INPUT_BLOCK,
135 .bundleName = "",
136 .msg = "Test",
137 };
138 ret = appfreezeManager->LifecycleTimeoutHandle(info1);
139 EXPECT_EQ(ret, -1);
140 AppfreezeManager::ParamInfo info2 = {
141 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
142 .eventName = AppFreezeType::APP_INPUT_BLOCK,
143 .bundleName = "",
144 .msg = "Test",
145 };
146 ret = appfreezeManager->LifecycleTimeoutHandle(info2);
147 EXPECT_EQ(ret, -1);
148 AppfreezeManager::ParamInfo info3 = {
149 .typeId = AppfreezeManager::TypeAttribute::CRITICAL_TIMEOUT,
150 .eventName = AppFreezeType::LIFECYCLE_HALF_TIMEOUT,
151 .bundleName = "",
152 .msg = "Test",
153 };
154 FreezeUtil::LifecycleFlow flow;
155 flow.state = AbilityRuntime::FreezeUtil::TimeoutState::FOREGROUND;
156 ret = appfreezeManager->LifecycleTimeoutHandle(info3, flow);
157 EXPECT_EQ(ret, 0);
158 }
159
160 /**
161 * @tc.number: AppfreezeManagerTest_005
162 * @tc.desc: add testcase codecoverage
163 * @tc.type: FUNC
164 */
165 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_005, TestSize.Level1)
166 {
167 std::map<int, std::set<int>> binderInfo;
168 std::set<int> ids;
169 ids.insert(1);
170 binderInfo.insert(std::pair<int, std::set<int>>(0, ids));
171 ids.insert(0);
172 binderInfo.insert(std::pair<int, std::set<int>>(1, ids));
173 std::set<int> pids;
174 appfreezeManager->ParseBinderPids(binderInfo, pids, 2, 8);
175 EXPECT_EQ(pids.size(), 0);
176 appfreezeManager->ParseBinderPids(binderInfo, pids, 1, 0);
177 EXPECT_EQ(pids.size(), 2);
178 }
179
180 /**
181 * @tc.number: AppfreezeManagerTest_006
182 * @tc.desc: add testcase codecoverage
183 * @tc.type: FUNC
184 */
185 HWTEST_F(AppfreezeManagerTest, AppfreezeManagerTest_006, TestSize.Level1)
186 {
187 std::string ret = appfreezeManager->CatcherStacktrace(0);
188 printf("ret: %s\n", ret.c_str());
189 ret = appfreezeManager->CatcherStacktrace(2);
190 printf("ret: %s\n", ret.c_str());
191 EXPECT_TRUE(!ret.empty());
192 appfreezeManager->ClearOldInfo();
193 int32_t pid = static_cast<int32_t>(getprocpid());
194 int state = AppfreezeManager::AppFreezeState::APPFREEZE_STATE_FREEZE;
195 bool result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid);
196 EXPECT_TRUE(!result);
197 appfreezeManager->ClearOldInfo();
198 result = appfreezeManager->IsProcessDebug(pid, "Test");
199 EXPECT_TRUE(!result);
200 result = appfreezeManager->IsNeedIgnoreFreezeEvent(pid);
201 EXPECT_TRUE(result);
202 }
203 } // namespace AppExecFwk
204 } // namespace OHOS
205