1 /*
2 * Copyright (c) 2022-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_inner.h"
20 #include "application_anr_listener.h"
21 #undef private
22
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::AppExecFwk;
27
28 namespace OHOS {
29 namespace AppExecFwk {
30 class AppfreezeInnerTest : public testing::Test {
31 public:
AppfreezeInnerTest()32 AppfreezeInnerTest()
33 {}
~AppfreezeInnerTest()34 ~AppfreezeInnerTest()
35 {}
36 std::shared_ptr<AppfreezeInner> appfreezeInner = nullptr;
37 static void SetUpTestCase(void);
38 static void TearDownTestCase(void);
39 void SetUp();
40 void TearDown();
41 };
42
SetUpTestCase(void)43 void AppfreezeInnerTest::SetUpTestCase(void)
44 {}
45
TearDownTestCase(void)46 void AppfreezeInnerTest::TearDownTestCase(void)
47 {}
48
SetUp(void)49 void AppfreezeInnerTest::SetUp(void)
50 {
51 appfreezeInner = AppfreezeInner::GetInstance();
52 }
53
TearDown(void)54 void AppfreezeInnerTest::TearDown(void)
55 {
56 AppfreezeInner::DestroyInstance();
57 }
58
59 /**
60 * @tc.number: AppfreezeInnerTest_SetMainHandler_001
61 * @tc.name: SetMainHandler
62 * @tc.desc: Verify that function SetMainHandler.
63 */
64 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__SetMainHandler_001, TestSize.Level0)
65 {
66 GTEST_LOG_(INFO) << "AppfreezeInner__SetMainHandler_001 start";
67 std::shared_ptr<EventHandler> eventHandler = std::make_shared<EventHandler>();
68 EXPECT_TRUE(eventHandler != nullptr);
69 AppfreezeInner::SetMainHandler(eventHandler);
70 GTEST_LOG_(INFO) << "AppfreezeInner__SetMainHandler_001 end";
71 }
72
73 /**
74 * @tc.number: AppfreezeInnerTest_SetApplicationInfo_001
75 * @tc.name: SetApplicationInfo
76 * @tc.desc: Verify that function SetApplicationInfo.
77 */
78 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__SetApplicationInfo_001, TestSize.Level0)
79 {
80 GTEST_LOG_(INFO) << "AppfreezeInner__SetApplicationInfo_001 start";
81 std::shared_ptr<ApplicationInfo> applicationInfo = std::make_shared<ApplicationInfo>();
82 EXPECT_TRUE(applicationInfo != nullptr);
83 appfreezeInner->SetApplicationInfo(applicationInfo);
84 GTEST_LOG_(INFO) << "AppfreezeInner__SetApplicationInfo_001 end";
85 }
86
87 /**
88 * @tc.number: AppfreezeInnerTest_ThreadBlock_001
89 * @tc.name: ThreadBlock
90 * @tc.desc: Verify that function ThreadBlock.
91 */
92 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__ThreadBlock_001, TestSize.Level1)
93 {
94 GTEST_LOG_(INFO) << "AppfreezeInner__ThreadBlock_001 start";
95 std::atomic_bool isSixSecondEvent = false;
96 appfreezeInner->ThreadBlock(isSixSecondEvent);
97 EXPECT_TRUE(isSixSecondEvent);
98 GTEST_LOG_(INFO) << "AppfreezeInner__ThreadBlock_001 end";
99 }
100
101 /**
102 * @tc.number: AppfreezeInnerTest_ThreadBlock_002
103 * @tc.name: ThreadBlock
104 * @tc.desc: Verify that function ThreadBlock.
105 */
106 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__ThreadBlock_002, TestSize.Level1)
107 {
108 GTEST_LOG_(INFO) << "AppfreezeInner__ThreadBlock_002 start";
109 std::atomic_bool isSixSecondEvent = true;
110 appfreezeInner->ThreadBlock(isSixSecondEvent);
111 EXPECT_TRUE(isSixSecondEvent);
112
113 appfreezeInner->SetAppDebug(true);
114 appfreezeInner->ThreadBlock(isSixSecondEvent);
115 EXPECT_TRUE(isSixSecondEvent);
116 GTEST_LOG_(INFO) << "AppfreezeInner__ThreadBlock_002 end";
117 }
118
119 /**
120 * @tc.number: AppfreezeInner_IsNeedIgnoreFreezeEvent_001
121 * @tc.name: IsNeedIgnoreFreezeEvent
122 * @tc.desc: Verify that function IsNeedIgnoreFreezeEvent.
123 */
124 HWTEST_F(AppfreezeInnerTest, AppfreezeInner_IsNeedIgnoreFreezeEvent_001, TestSize.Level1)
125 {
126 std::atomic_bool isSixSecondEvent = true;
127 appfreezeInner->isAppDebug_ = false;
128 appfreezeInner->ThreadBlock(isSixSecondEvent);
129 EXPECT_TRUE(isSixSecondEvent);
130 int32_t pid = static_cast<int32_t>(getprocpid());
131 std::shared_ptr<AAFwk::ApplicationAnrListener> listener =
132 std::make_shared<AAFwk::ApplicationAnrListener>();
133 listener->OnAnr(pid, 0);
134 int left = 61; // over 1min
135 while (left > 0) {
136 left = sleep(left);
137 }
138 listener->OnAnr(pid, 0);
139 }
140
141 /**
142 * @tc.number: AppfreezeInner__AppfreezeHandle_001
143 * @tc.name: AppfreezeHandle
144 * @tc.desc: Verify that function AppfreezeHandle.
145 */
146 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__AppfreezeHandle_001, TestSize.Level1)
147 {
148 GTEST_LOG_(INFO) << "AppfreezeInner__AppfreezeHandle_001 start";
149 FaultData faultData;
150 faultData.state = 1;
151 faultData.errorObject.message = AppFreezeType::THREAD_BLOCK_6S;
152 faultData.faultType = FaultDataType::APP_FREEZE;
153 faultData.timeoutMarkers = "";
154 bool onlyMainThread = true;
155 std::shared_ptr<ApplicationInfo> applicationInfo = std::make_shared<ApplicationInfo>();
156 appfreezeInner->SetApplicationInfo(applicationInfo);
157 int ret = appfreezeInner->AppfreezeHandle(faultData, onlyMainThread);
158 EXPECT_EQ(ret, 0);
159 ret = appfreezeInner->AcquireStack(faultData, onlyMainThread);
160 EXPECT_EQ(ret, 0);
161 appfreezeInner->SetAppDebug(true);
162 ret = appfreezeInner->AppfreezeHandle(faultData, onlyMainThread);
163 EXPECT_EQ(ret, -1);
164 GTEST_LOG_(INFO) << "AppfreezeInner__AppfreezeHandle_001 end";
165 }
166
167 /**
168 * @tc.number: AppfreezeInner__AcquireStack_001
169 * @tc.name: AcquireStack
170 * @tc.desc: Verify that function AcquireStack.
171 */
172 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__AcquireStack_001, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "AppfreezeInner__AcquireStack_001 start";
175
176 FaultData faultData;
177 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
178 bool onlyMainThread = true;
179 int ret = appfreezeInner->AcquireStack(faultData, onlyMainThread);
180 EXPECT_EQ(ret, 0);
181 GTEST_LOG_(INFO) << "AppfreezeInner__AcquireStack_001 end";
182 }
183
184 /**
185 * @tc.number: AppfreezeInner_IsExitApp_001
186 * @tc.name: IsExitApp
187 * @tc.desc: Verify that function IsExitApp.
188 */
189 HWTEST_F(AppfreezeInnerTest, AppfreezeInner_IsExitApp_001, TestSize.Level1)
190 {
191 bool ret = appfreezeInner->IsExitApp(AppFreezeType::THREAD_BLOCK_6S);
192 EXPECT_EQ(ret, true);
193 ret = appfreezeInner->IsExitApp(AppFreezeType::LIFECYCLE_HALF_TIMEOUT);
194 EXPECT_EQ(ret, false);
195 }
196
197 /**
198 * @tc.number: AppfreezeInner_NotifyANR
199 * @tc.name: NotifyANR
200 * @tc.desc: Verify that function IsExitApp.
201 */
202 HWTEST_F(AppfreezeInnerTest, AppfreezeInner_NotifyANR, TestSize.Level1)
203 {
204 FaultData faultData;
205 faultData.errorObject.name = AppFreezeType::THREAD_BLOCK_6S;
206 int ret = appfreezeInner->NotifyANR(faultData);
207 EXPECT_EQ(ret, -1);
208 std::shared_ptr<EventHandler> eventHandler = std::make_shared<EventHandler>();
209 EXPECT_TRUE(eventHandler != nullptr);
210 AppfreezeInner::SetMainHandler(eventHandler);
211 ret = appfreezeInner->NotifyANR(faultData);
212 EXPECT_EQ(ret, -1);
213 ret = appfreezeInner->AcquireStack(faultData, true);
214 EXPECT_EQ(ret, 0);
215 appfreezeInner->AppFreezeRecovery();
216 }
217
218 /**
219 * @tc.number: AppfreezeInner__Dump_001
220 * @tc.name: Dump
221 * @tc.desc: Verify that function Dump.
222 */
223 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__Dump_001, TestSize.Level1)
224 {
225 GTEST_LOG_(INFO) << "AppfreezeInner__Dump_001 start";
226 std::string msgContent = "App main thread is not response!";
227 MainHandlerDumper handlerDumper;
228 handlerDumper.Dump(msgContent);
229 EXPECT_EQ(msgContent, handlerDumper.GetDumpInfo());
230 GTEST_LOG_(INFO) << "AppfreezeInner__Dump_001 end";
231 }
232
233 /**
234 * @tc.number: AppfreezeInner__Dump_002
235 * @tc.name: Dump
236 * @tc.desc: Verify that function Dump.
237 */
238 HWTEST_F(AppfreezeInnerTest, AppfreezeInner__Dump_002, TestSize.Level1)
239 {
240 GTEST_LOG_(INFO) << "AppfreezeInner__Dump_002 start";
241 MainHandlerDumper handlerDumper;
242 EXPECT_EQ("", handlerDumper.GetTag());
243 GTEST_LOG_(INFO) << "AppfreezeInner__Dump_002 end";
244 }
245
246 /**
247 * @tc.number: AppfreezeInner_AppfreezeHandleOverReportCount_001
248 * @tc.name: AppfreezeHandleOverReportCount
249 * @tc.desc: Verify that function AppfreezeHandleOverReportCount.
250 */
251 HWTEST_F(AppfreezeInnerTest, AppfreezeInner_AppfreezeHandleOverReportCount_001, TestSize.Level1)
252 {
253 bool isSixSecondEvent = true;
254 appfreezeInner->AppfreezeHandleOverReportCount(isSixSecondEvent);
255 isSixSecondEvent = false;
256 appfreezeInner->AppfreezeHandleOverReportCount(isSixSecondEvent);
257 EXPECT_TRUE(!isSixSecondEvent);
258 }
259
260 /**
261 * @tc.number: AppfreezeInner_GetProcStatm_001
262 * @tc.name: GetProcStatm
263 * @tc.desc: Verify that function GetProcStatm.
264 */
265 HWTEST_F(AppfreezeInnerTest, AppfreezeInner_GetProcStatm_001, TestSize.Level1)
266 {
267 int32_t pid = static_cast<int32_t>(getpid());
268 std::string procStatm = appfreezeInner->GetProcStatm(pid);
269 EXPECT_TRUE(!procStatm.empty());
270 pid = -1;
271 procStatm = appfreezeInner->GetProcStatm(pid);
272 EXPECT_TRUE(procStatm.empty());
273 }
274 } // namespace AppExecFwk
275 } // namespace OHOS
276