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 "intention_event/framework/anr_handler/include/anr_handler.h"
17 #include <gtest/gtest.h>
18 #include "proto.h"
19 #include "util.h"
20 #include "window_manager_hilog.h"
21 
22 
23 using namespace testing;
24 using namespace testing::ext;
25 
26 namespace OHOS {
27 namespace Rosen {
28 constexpr int64_t MAX_MARK_PROCESS_DELAY_TIME_US { 3000000 };
29 constexpr int32_t INVALID_PERSISTENT_ID { -1 };
30 const std::string ANR_HANDLER_RUNNER { "ANR_HANDLER" };
31 class AnrHandlerTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp() override;
36     void TearDown() override;
37     ANRHandler anrHandler_;
38     static constexpr uint32_t WAIT_SYNC_IN_NS = 1000000;
39 };
40 
SetUpTestCase()41 void AnrHandlerTest::SetUpTestCase()
42 {
43 }
44 
TearDownTestCase()45 void AnrHandlerTest::TearDownTestCase()
46 {
47 }
48 
SetUp()49 void AnrHandlerTest::SetUp()
50 {
51 }
52 
TearDown()53 void AnrHandlerTest::TearDown()
54 {
55 }
56 
57 namespace {
58 /**
59  * @tc.name: HandleEventConsumed
60  * @tc.desc: test function : HandleEventConsumed
61  * @tc.type: FUNC
62  */
63 HWTEST_F(AnrHandlerTest, HandleEventConsumed, Function | SmallTest | Level1)
64 {
65     ANRHandler::SessionInfo sessionInfo;
66     anrHandler_.sessionStageMap_.clear();
67     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
68     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
69     anrHandler_.anrHandlerState_.sendStatus.emplace(0, true);
70     anrHandler_.HandleEventConsumed(0, 0);
71     usleep(WAIT_SYNC_IN_NS);
72     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 2);
73 
74     anrHandler_.anrHandlerState_.sendStatus[0] = false;
75     anrHandler_.HandleEventConsumed(0, MAX_MARK_PROCESS_DELAY_TIME_US);
76     usleep(WAIT_SYNC_IN_NS);
77     anrHandler_.HandleEventConsumed(0, 0);
78     usleep(WAIT_SYNC_IN_NS);
79 }
80 
81 /**
82  * @tc.name: OnWindowDestroyed
83  * @tc.desc: test function : OnWindowDestroyed
84  * @tc.type: FUNC
85  */
86 HWTEST_F(AnrHandlerTest, OnWindowDestroyed, Function | SmallTest | Level1)
87 {
88     ANRHandler::SessionInfo sessionInfo;
89     anrHandler_.sessionStageMap_.clear();
90     anrHandler_.anrHandlerState_.sendStatus.emplace(0, true);
91     anrHandler_.OnWindowDestroyed(0);
92     usleep(WAIT_SYNC_IN_NS);
93     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 0);
94 
95     anrHandler_.anrHandlerState_.sendStatus.emplace(0, true);
96     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
97     anrHandler_.OnWindowDestroyed(0);
98     usleep(WAIT_SYNC_IN_NS);
99     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 0);
100     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 0);
101 
102     anrHandler_.anrHandlerState_.sendStatus.emplace(0, true);
103     anrHandler_.sessionStageMap_.clear();
104     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
105     anrHandler_.OnWindowDestroyed(0);
106 }
107 
108 /**
109  * @tc.name: PostTask
110  * @tc.desc: test function : PostTask
111  * @tc.type: FUNC
112  */
113 HWTEST_F(AnrHandlerTest, PostTask, Function | SmallTest | Level1)
114 {
115     auto eventHandler = anrHandler_.eventHandler_;
116     usleep(WAIT_SYNC_IN_NS);
117     anrHandler_.eventHandler_ = nullptr;
__anonca8babef0202() 118     auto task = []() {
119         return;
120     };
121     bool ret = anrHandler_.PostTask(task, "testTask", 0);
122     anrHandler_.eventHandler_ = eventHandler;
123     ASSERT_EQ(ret, false);
124 }
125 
126 /**
127  * @tc.name: SetAnrHandleState
128  * @tc.desc: test function : SetAnrHandleState
129  * @tc.type: FUNC
130  */
131 HWTEST_F(AnrHandlerTest, SetAnrHandleState, Function | SmallTest | Level1)
132 {
133     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
134     anrHandler_.SetAnrHandleState(0, true);
135     ASSERT_EQ(anrHandler_.anrHandlerState_.eventsToReceipt.size(), 1);
136 
137     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
138     anrHandler_.SetAnrHandleState(0, false);
139     ASSERT_EQ(anrHandler_.anrHandlerState_.eventsToReceipt.size(), 0);
140 
141     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
142     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(0);
143     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(1);
144     anrHandler_.SetAnrHandleState(0, false);
145     ASSERT_EQ(anrHandler_.anrHandlerState_.eventsToReceipt.size(), 1);
146 }
147 
148 /**
149  * @tc.name: MarkProcessed
150  * @tc.desc: test function : MarkProcessed
151  * @tc.type: FUNC
152  */
153 HWTEST_F(AnrHandlerTest, MarkProcessed, Function | SmallTest | Level1)
154 {
155     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
156     anrHandler_.anrHandlerState_.sendStatus.clear();
157     anrHandler_.MarkProcessed();
158     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 1);
159 
160     anrHandler_.sessionStageMap_.clear();
161     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
162     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(0);
163     anrHandler_.MarkProcessed();
164     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 1);
165 
166     ANRHandler::SessionInfo sessionInfo;
167     anrHandler_.sessionStageMap_.clear();
168     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
169     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
170     anrHandler_.MarkProcessed();
171     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 2);
172 }
173 
174 /**
175  * @tc.name: SendEvent
176  * @tc.desc: test function : SendEvent
177  * @tc.type: FUNC
178  */
179 HWTEST_F(AnrHandlerTest, SendEvent, Function | SmallTest | Level1)
180 {
181     anrHandler_.sessionStageMap_.clear();
182     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
183     anrHandler_.anrHandlerState_.sendStatus.clear();
184     anrHandler_.SendEvent(0, 0);
185     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 1);
186 
187     auto eventHandler = anrHandler_.eventHandler_;
188     usleep(WAIT_SYNC_IN_NS);
189     anrHandler_.eventHandler_ = nullptr;
190     anrHandler_.SendEvent(0, 0);
191     anrHandler_.eventHandler_ = eventHandler;
192     ASSERT_EQ(anrHandler_.anrHandlerState_.sendStatus.size(), 1);
193 }
194 
195 /**
196  * @tc.name: ClearExpiredEvents
197  * @tc.desc: test function : ClearExpiredEvents
198  * @tc.type: FUNC
199  */
200 HWTEST_F(AnrHandlerTest, ClearExpiredEvents, Function | SmallTest | Level1)
201 {
202     anrHandler_.sessionStageMap_.clear();
203     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
204     anrHandler_.anrHandlerState_.sendStatus.clear();
205     anrHandler_.ClearExpiredEvents(0);
206     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 0);
207 
208     ANRHandler::SessionInfo sessionInfo;
209     sessionInfo.persistentId = 1;
210     anrHandler_.sessionStageMap_.clear();
211     anrHandler_.sessionStageMap_.emplace(2, sessionInfo);
212     anrHandler_.sessionStageMap_.emplace(3, sessionInfo);
213     anrHandler_.ClearExpiredEvents(3);
214     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 1);
215 
216     anrHandler_.sessionStageMap_.clear();
217     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
218     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
219     anrHandler_.ClearExpiredEvents(1);
220     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 1);
221 
222     anrHandler_.sessionStageMap_.clear();
223     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
224     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
225     anrHandler_.sessionStageMap_.emplace(2, sessionInfo);
226     anrHandler_.ClearExpiredEvents(2);
227     ASSERT_EQ(anrHandler_.sessionStageMap_.size(), 1);
228 }
229 
230 /**
231  * @tc.name: GetPersistentIdOfEvent
232  * @tc.desc: test function : GetPersistentIdOfEvent
233  * @tc.type: FUNC
234  */
235 HWTEST_F(AnrHandlerTest, GetPersistentIdOfEvent, Function | SmallTest | Level1)
236 {
237     anrHandler_.sessionStageMap_.clear();
238     int32_t ret = anrHandler_.GetPersistentIdOfEvent(0);
239     ASSERT_EQ(ret, INVALID_PERSISTENT_ID);
240 
241     ANRHandler::SessionInfo sessionInfo;
242     anrHandler_.sessionStageMap_.emplace(1, sessionInfo);
243     ret = anrHandler_.GetPersistentIdOfEvent(0);
244     ASSERT_EQ(ret, INVALID_PERSISTENT_ID);
245 
246     sessionInfo.persistentId = 123;
247     anrHandler_.sessionStageMap_[1] = sessionInfo;
248     ret = anrHandler_.GetPersistentIdOfEvent(1);
249     ASSERT_EQ(ret, 123);
250 }
251 
252 /**
253  * @tc.name: IsOnEventHandler
254  * @tc.desc: test function : IsOnEventHandler
255  * @tc.type: FUNC
256  */
257 HWTEST_F(AnrHandlerTest, IsOnEventHandler, Function | SmallTest | Level1)
258 {
259     anrHandler_.anrHandlerState_.sendStatus.clear();
260     bool ret = anrHandler_.IsOnEventHandler(0);
261     ASSERT_EQ(ret, false);
262 
263     anrHandler_.anrHandlerState_.sendStatus.emplace(0, true);
264     ret = anrHandler_.IsOnEventHandler(0);
265     ASSERT_EQ(ret, true);
266 
267     anrHandler_.anrHandlerState_.sendStatus.emplace(1, false);
268     ret = anrHandler_.IsOnEventHandler(1);
269     ASSERT_EQ(ret, false);
270 }
271 
272 /**
273  * @tc.name: UpdateLatestEventId
274  * @tc.desc: test function : UpdateLatestEventId
275  * @tc.type: FUNC
276  */
277 HWTEST_F(AnrHandlerTest, UpdateLatestEventId, Function | SmallTest | Level1)
278 {
279     ANRHandler::SessionInfo sessionInfo;
280     sessionInfo.persistentId = 0;
281     anrHandler_.anrHandlerState_.eventsToReceipt.clear();
282     anrHandler_.sessionStageMap_.clear();
283     anrHandler_.UpdateLatestEventId(0);
284     ASSERT_EQ(anrHandler_.anrHandlerState_.eventsToReceipt.size(), 0);
285 
286     anrHandler_.sessionStageMap_.emplace(0, sessionInfo);
287     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(0);
288     anrHandler_.UpdateLatestEventId(0);
289 
290     anrHandler_.sessionStageMap_.clear();
291     sessionInfo.persistentId = 1;
292     anrHandler_.sessionStageMap_.emplace(2, sessionInfo);
293     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(1);
294     anrHandler_.UpdateLatestEventId(2);
295 
296     anrHandler_.sessionStageMap_.clear();
297     sessionInfo.persistentId = 101;
298     anrHandler_.sessionStageMap_.emplace(2, sessionInfo);
299     anrHandler_.anrHandlerState_.eventsToReceipt.push_back(1);
300     anrHandler_.UpdateLatestEventId(2);
301 }
302 }
303 }
304 }