1 /*
2  * Copyright (c) 2024 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 #define private public
16 #define protected public
17 #include "freeze_manager.h"
18 #include "peruser_session.h"
19 #undef private
20 #include <gtest/gtest.h>
21 #include <gtest/hwext/gtest-multithread.h>
22 #include <sys/time.h>
23 
24 #include "event_handler.h"
25 #include "global.h"
26 using namespace testing::ext;
27 using namespace testing::mt;
28 namespace OHOS {
29 namespace MiscServices {
30 constexpr int32_t TASK_NUM = 100;
31 constexpr int32_t IPC_COST_TIME = 5000;
32 class ImeFreezeManagerTest : public testing::Test {
33 public:
SetUpTestCase(void)34     static void SetUpTestCase(void)
35     {
36         freezeManager_ = std::make_shared<FreezeManager>(-1);
37         auto runner = AppExecFwk::EventRunner::Create("test_freezeManager");
38         eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
39         freezeManager_->SetEventHandler(eventHandler_);
40     }
TearDownTestCase(void)41     static void TearDownTestCase(void)
42     {
43         freezeManager_->SetEventHandler(nullptr);
44         eventHandler_ = nullptr;
45     }
SetUp()46     void SetUp()
47     {
48         IMSA_HILOGI("ImeFreezeManagerTest::SetUp");
49     }
TearDown()50     void TearDown()
51     {
52         IMSA_HILOGI("ImeFreezeManagerTest::TearDown");
53         ClearState();
54     }
TestAttach(bool isSuccess)55     static void TestAttach(bool isSuccess)
56     {
57         IMSA_HILOGI("run in, isSuccess: %{public}d", isSuccess);
58         {
59             std::lock_guard<std::mutex> lock(mtx_);
60             freezeManager_->BeforeIpc(RequestType::START_INPUT);
61             CheckAllState(true, false);
62         }
63         usleep(IPC_COST_TIME);
64         {
65             std::lock_guard<std::mutex> lock(mtx_);
66             freezeManager_->AfterIpc(RequestType::START_INPUT, isSuccess);
67             CheckAllState(isSuccess, !isSuccess);
68         }
69     }
TestDetach()70     static void TestDetach()
71     {
72         IMSA_HILOGI("run in");
73         {
74             std::lock_guard<std::mutex> lock(mtx_);
75             freezeManager_->BeforeIpc(RequestType::STOP_INPUT);
76             CheckFreezable(false);
77         }
78         usleep(IPC_COST_TIME);
79         {
80             std::lock_guard<std::mutex> lock(mtx_);
81             freezeManager_->AfterIpc(RequestType::STOP_INPUT, true);
82             CheckAllState(false, true);
83         }
84     }
TestRequestShowInput(bool isSuccess)85     static void TestRequestShowInput(bool isSuccess)
86     {
87         IMSA_HILOGI("run in, isSuccess: %{public}d", isSuccess);
88         {
89             std::lock_guard<std::mutex> lock(mtx_);
90             bool ret = freezeManager_->IsIpcNeeded(RequestType::REQUEST_SHOW);
91             if (!ret) {
92                 return;
93             }
94             freezeManager_->BeforeIpc(RequestType::REQUEST_SHOW);
95             CheckFreezable(false);
96         }
97         usleep(IPC_COST_TIME);
98         {
99             std::lock_guard<std::mutex> lock(mtx_);
100             freezeManager_->AfterIpc(RequestType::REQUEST_SHOW, isSuccess);
101             if (isSuccess) {
102                 CheckAllState(true, false);
103             }
104         }
105     }
TestRequestHideInput(bool isSuccess)106     static void TestRequestHideInput(bool isSuccess)
107     {
108         IMSA_HILOGI("run in, isSuccess: %{public}d", isSuccess);
109         {
110             std::lock_guard<std::mutex> lock(mtx_);
111             bool ret = freezeManager_->IsIpcNeeded(RequestType::REQUEST_HIDE);
112             if (!ret) {
113                 return;
114             }
115             freezeManager_->BeforeIpc(RequestType::REQUEST_HIDE);
116             CheckFreezable(false);
117         }
118         usleep(IPC_COST_TIME);
119         {
120             std::lock_guard<std::mutex> lock(mtx_);
121             freezeManager_->AfterIpc(RequestType::REQUEST_HIDE, isSuccess);
122             if (isSuccess) {
123                 CheckAllState(false, true);
124             }
125         }
126     }
TestNormalIPC()127     static void TestNormalIPC()
128     {
129         IMSA_HILOGI("run in");
130         {
131             std::lock_guard<std::mutex> lock(mtx_);
132             freezeManager_->BeforeIpc(RequestType::NORMAL);
133             CheckFreezable(false);
134         }
135         usleep(IPC_COST_TIME);
136         {
137             std::lock_guard<std::mutex> lock(mtx_);
138             freezeManager_->AfterIpc(RequestType::NORMAL, true);
139         }
140     }
ClearState()141     static void ClearState()
142     {
143         IMSA_HILOGI("run in");
144         freezeManager_->isImeInUse_ = false;
145         freezeManager_->isFrozen_ = true;
146     }
FullTestTask()147     static void FullTestTask()
148     {
149         for (int32_t i = 0; i < TASK_NUM; i++) {
150             TestAttach(false);
151             TestAttach(true);
152             TestDetach();
153             TestRequestHideInput(true);
154             TestRequestHideInput(false);
155             TestNormalIPC();
156         }
157     }
158     static std::shared_ptr<FreezeManager> freezeManager_;
159     static std::shared_ptr<AppExecFwk::EventHandler> eventHandler_;
160     static std::mutex mtx_;
161 
162 private:
CheckAllState(bool imeInUse,bool freezable)163     static void CheckAllState(bool imeInUse, bool freezable)
164     {
165         EXPECT_EQ(freezeManager_->isImeInUse_, imeInUse);
166         EXPECT_EQ(freezeManager_->isFrozen_, freezable);
167     }
CheckImeInUse(bool imeInUse)168     static void CheckImeInUse(bool imeInUse)
169     {
170         EXPECT_EQ(freezeManager_->isImeInUse_, imeInUse);
171     }
CheckFreezable(bool freezable)172     static void CheckFreezable(bool freezable)
173     {
174         EXPECT_EQ(freezeManager_->isFrozen_, freezable);
175     }
176 };
177 std::shared_ptr<FreezeManager> ImeFreezeManagerTest::freezeManager_{ nullptr };
178 std::mutex ImeFreezeManagerTest::mtx_;
179 std::shared_ptr<AppExecFwk::EventHandler> ImeFreezeManagerTest::eventHandler_{ nullptr };
180 
181 /**
182  * @tc.name: SingleThread_StartInput_001
183  * @tc.desc: test start input
184  * @tc.type: FUNC
185  */
186 HWTEST_F(ImeFreezeManagerTest, SingleThread_StartInput_001, TestSize.Level0)
187 {
188     IMSA_HILOGI("ImeFreezeManagerTest::SingleThread_StartInput_001");
189     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
190     ClearState();
191     TestAttach(false);
192     TestAttach(true);
193 
194     ClearState();
195     TestAttach(true);
196     TestAttach(false);
197 
198     ClearState();
199     TestAttach(true);
200     TestAttach(true);
201 
202     ClearState();
203     TestAttach(false);
204     TestAttach(false);
205 }
206 
207 /**
208  * @tc.name: SingleThread_StartAndStopInput_001
209  * @tc.desc: test freeze manager
210  * @tc.type: FUNC
211  */
212 HWTEST_F(ImeFreezeManagerTest, SingleThread_StartAndStopInput_001, TestSize.Level0)
213 {
214     IMSA_HILOGI("ImeFreezeManagerTest::SingleThread_StartAndStopInput_001");
215     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
216     ClearState();
217     TestAttach(true);
218     TestDetach();
219 
220     ClearState();
221     TestAttach(false);
222     TestDetach();
223 
224     ClearState();
225     TestAttach(true);
226     TestDetach();
227     TestAttach(true);
228 }
229 
230 /**
231  * @tc.name: SingleThread_StartInputAndRequestHide_001
232  * @tc.desc: test freeze manager
233  * @tc.type: FUNC
234  */
235 HWTEST_F(ImeFreezeManagerTest, SingleThread_StartInputAndRequestHide_001, TestSize.Level0)
236 {
237     IMSA_HILOGI("ImeFreezeManagerTest::SingleThread_StartInputAndRequestHide_001");
238     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
239     ClearState();
240     TestAttach(true);
241     TestRequestHideInput(true);
242 
243     ClearState();
244     TestAttach(false);
245     TestRequestHideInput(true);
246 }
247 
248 /**
249  * @tc.name: SingleThread_StartInputAndNormalIPC_001
250  * @tc.desc: test freeze manager
251  * @tc.type: FUNC
252  */
253 HWTEST_F(ImeFreezeManagerTest, SingleThread_StartInputAndNormalIPC_001, TestSize.Level0)
254 {
255     IMSA_HILOGI("ImeFreezeManagerTest::SingleThread_StartInputAndNormalIPC_001");
256     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
257     ClearState();
258     TestNormalIPC();
259 
260     ClearState();
261     TestAttach(false);
262     TestNormalIPC();
263 
264     ClearState();
265     TestAttach(true);
266     TestNormalIPC();
267 }
268 
269 /**
270  * @tc.name: MultiThread_FullTest_001
271  * @tc.desc: test freeze manager
272  * @tc.type: FUNC
273  */
274 HWTEST_F(ImeFreezeManagerTest, MultiThread_FullTest_001, TestSize.Level0)
275 {
276     IMSA_HILOGI("ImeFreezeManagerTest::MultiThread_FullTest_001");
277     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
278     SET_THREAD_NUM(5);
279     GTEST_RUN_TASK(FullTestTask);
280 }
281 
282 /**
283  * @tc.name: SingleThread_RequestShow_001
284  * @tc.desc: test freeze manager
285  * @tc.type: FUNC
286  */
287 HWTEST_F(ImeFreezeManagerTest, SingleThread_RequestShow_001, TestSize.Level0)
288 {
289     IMSA_HILOGI("ImeFreezeManagerTest::SingleThread_RequestShow_001");
290     ASSERT_NE(ImeFreezeManagerTest::freezeManager_, nullptr);
291     ClearState();
292     TestRequestShowInput(true);
293 }
294 } // namespace MiscServices
295 } // namespace OHOS