1 /*
2 * Copyright (c) 2022 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 #include "event_runner.h"
19 #include "pointer_event.h"
20 #include "window_inner_manager.h"
21 #include "wm_common.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace Rosen {
27 using InnerTask = std::function<void()>;
28 using EventRunner = OHOS::AppExecFwk::EventRunner;
29 using EventHandler = OHOS::AppExecFwk::EventHandler;
30 using EventPriority = OHOS::AppExecFwk::EventQueue::Priority;
31
32 namespace {
33 const std::string INNER_WM_THREAD_NAME = "TestInnerWindowManager";
34 constexpr int32_t TEST_CUSTOM_ID = 100;
35 }
36
37 class WindowInnerManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp() override;
42 void TearDown() override;
43 sptr<WindowInnerManager> wim_ = new WindowInnerManager();
44 };
45
SetUpTestCase()46 void WindowInnerManagerTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void WindowInnerManagerTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void WindowInnerManagerTest::SetUp()
55 {
56 }
57
TearDown()58 void WindowInnerManagerTest::TearDown()
59 {
60 }
61
62 namespace {
63 /**
64 * @tc.name: Stop
65 * @tc.desc: test WindowInnerManager Stop
66 * @tc.type: FUNC
67 */
68 HWTEST_F(WindowInnerManagerTest, Stop, Function | SmallTest | Level2)
69 {
70 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
71 windowInnerManager.state_ = InnerWMRunningState::STATE_RUNNING;
72 windowInnerManager.eventLoop_ = nullptr;
73 windowInnerManager.eventHandler_ = nullptr;
74 windowInnerManager.moveDragController_ = nullptr;
75 windowInnerManager.Stop();
76 ASSERT_EQ(InnerWMRunningState::STATE_NOT_START, windowInnerManager.state_);
77
78 windowInnerManager.eventLoop_ = AppExecFwk::EventRunner::Create(INNER_WM_THREAD_NAME);
79 windowInnerManager.eventHandler_ = std::make_shared<EventHandler>(windowInnerManager.eventLoop_);
80 windowInnerManager.moveDragController_ = new MoveDragController();
81 windowInnerManager.Stop();
82 ASSERT_EQ(0, windowInnerManager.eventLoop_.use_count());
83 ASSERT_EQ(0, windowInnerManager.eventHandler_.use_count());
84 }
85
86 /**
87 * @tc.name: NotifyServerReadyToMoveOrDrag
88 * @tc.desc: test WindowInnerManager NotifyServerReadyToMoveOrDrag
89 * @tc.type: FUNC
90 */
91 HWTEST_F(WindowInnerManagerTest, NotifyServerReadyToMoveOrDrag, Function | SmallTest | Level2)
92 {
93 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
94 windowInnerManager.eventHandler_ = nullptr;
95 windowInnerManager.moveDragController_ = new MoveDragController();
96 windowInnerManager.moveDragController_->activeWindowId_ = 1;
97 uint32_t windowId = 1;
98 sptr<WindowProperty> property = new WindowProperty();
99 ASSERT_NE(property, nullptr);
100 sptr<MoveDragProperty> moveDragProperty = new MoveDragProperty();
101 ASSERT_NE(moveDragProperty, nullptr);
102 auto result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
103 ASSERT_EQ(false, result);
104
105 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
106 result = windowInnerManager.NotifyServerReadyToMoveOrDrag(windowId, property, moveDragProperty);
107 ASSERT_EQ(true, result);
108 }
109
110 /**
111 * @tc.name: NotifyWindowEndUpMovingOrDragging
112 * @tc.desc: test WindowInnerManager NotifyWindowEndUpMovingOrDragging
113 * @tc.type: FUNC
114 */
115 HWTEST_F(WindowInnerManagerTest, NotifyWindowEndUpMovingOrDragging, Function | SmallTest | Level2)
116 {
117 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
118 windowInnerManager.eventHandler_ = nullptr;
119 windowInnerManager.moveDragController_ = new MoveDragController();
120 windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
121
122 uint32_t windowId = INVALID_WINDOW_ID;
123 windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
124 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
125
126 windowId = TEST_CUSTOM_ID;
127 windowInnerManager.NotifyWindowEndUpMovingOrDragging(windowId);
128 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
129 }
130 /**
131 * @tc.name: NotifyWindowRemovedOrDestroyed
132 * @tc.desc: test WindowInnerManager NotifyWindowRemovedOrDestroyed
133 * @tc.type: FUNC
134 */
135 HWTEST_F(WindowInnerManagerTest, NotifyWindowRemovedOrDestroyed, Function | SmallTest | Level2)
136 {
137 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
138 windowInnerManager.eventHandler_ = nullptr;
139 windowInnerManager.moveDragController_ = new MoveDragController();
140 windowInnerManager.moveDragController_->activeWindowId_ = TEST_CUSTOM_ID;
141
142 uint32_t windowId = INVALID_WINDOW_ID;
143 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
144 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, TEST_CUSTOM_ID);
145
146 windowId = TEST_CUSTOM_ID;
147
148 auto moveDragProperty = windowInnerManager.moveDragController_->moveDragProperty_;
149 moveDragProperty->startDragFlag_ = true;
150 moveDragProperty->startMoveFlag_ = true;
151 windowInnerManager.NotifyWindowRemovedOrDestroyed(windowId);
152 ASSERT_EQ(windowInnerManager.moveDragController_->activeWindowId_, INVALID_WINDOW_ID);
153 }
154 /**
155 * @tc.name: ConsumePointerEvent
156 * @tc.desc: test WindowInnerManager ConsumePointerEvent
157 * @tc.type: FUNC
158 */
159 HWTEST_F(WindowInnerManagerTest, ConsumePointerEvent, Function | SmallTest | Level2)
160 {
161 WindowInnerManager& windowInnerManager = WindowInnerManager::GetInstance();
162 windowInnerManager.eventHandler_ = nullptr;
163 windowInnerManager.moveDragController_ = new MoveDragController();
164
165 auto pointerEvent = MMI::PointerEvent::Create();
166 pointerEvent->processedCallback_ = nullptr;
167 pointerEvent->sourceType_ = MMI::PointerEvent::SOURCE_TYPE_MOUSE;
168 pointerEvent->buttonId_ = MMI::PointerEvent::MOUSE_BUTTON_RIGHT;
169 pointerEvent->pointerAction_ = MMI::PointerEvent::POINTER_ACTION_MOVE;
170
171 pointerEvent->agentWindowId_ = 1;
172 windowInnerManager.moveDragController_->activeWindowId_ = 1;
173 windowInnerManager.ConsumePointerEvent(pointerEvent);
174 ASSERT_NE(windowInnerManager.moveDragController_->moveEvent_, nullptr);
175 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
176
177 pointerEvent->agentWindowId_ = 1;
178 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
179 windowInnerManager.ConsumePointerEvent(pointerEvent);
180 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
181
182 pointerEvent->agentWindowId_ = INVALID_WINDOW_ID;
183 windowInnerManager.moveDragController_->activeWindowId_ = INVALID_WINDOW_ID;
184 windowInnerManager.ConsumePointerEvent(pointerEvent);
185 ASSERT_EQ(windowInnerManager.moveDragController_->moveEvent_->agentWindowId_, pointerEvent->agentWindowId_);
186 }
187
188 /**
189 * @tc.name: Start
190 * @tc.desc: test WindowInnerManager Start
191 * @tc.type: FUNC
192 */
193 HWTEST_F(WindowInnerManagerTest, Start, Function | SmallTest | Level2)
194 {
195 wim_->state_ = InnerWMRunningState::STATE_RUNNING;
196 bool enableRecentholder = false;
197 wim_->Start(enableRecentholder);
198 ASSERT_EQ(wim_->state_, InnerWMRunningState::STATE_RUNNING);
199 }
200
201 /**
202 * @tc.name: CreateInnerWindow
203 * @tc.desc: test WindowInnerManager CreateInnerWindow
204 * @tc.type: FUNC
205 */
206 HWTEST_F(WindowInnerManagerTest, CreateInnerWindow, Function | SmallTest | Level2)
207 {
208 wim_->isRecentHolderEnable_ = true;
209 std::string name = "test";
210 DisplayId displayId = 1;
211 Rect rect = {0.0, 0.0, 100.0, 100.0};
212 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
213 WindowMode mode = WindowMode::WINDOW_MODE_FLOATING;
214 wim_->CreateInnerWindow(name, displayId, rect, type, mode);
215 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
216 }
217
218 /**
219 * @tc.name: DestroyInnerWindow
220 * @tc.desc: test WindowInnerManager DestroyInnerWindow
221 * @tc.type: FUNC
222 */
223 HWTEST_F(WindowInnerManagerTest, DestroyInnerWindow, Function | SmallTest | Level2)
224 {
225 wim_->isRecentHolderEnable_ = true;
226 DisplayId displayId = 1;
227 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
228 wim_->DestroyInnerWindow(displayId, type);
229 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
230 }
231
232 /**
233 * @tc.name: UpdateInnerWindow
234 * @tc.desc: test WindowInnerManager UpdateInnerWindow
235 * @tc.type: FUNC
236 */
237 HWTEST_F(WindowInnerManagerTest, UpdateInnerWindow, Function | SmallTest | Level2)
238 {
239 wim_->isRecentHolderEnable_ = true;
240 DisplayId displayId = 1;
241 WindowType type = WindowType::WINDOW_TYPE_PLACEHOLDER;
242 uint32_t width = 200;
243 uint32_t height = 200;
244 wim_->UpdateInnerWindow(displayId, type, width, height);
245 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
246 }
247
248 /**
249 * @tc.name: TerminateAbility
250 * @tc.desc: test WindowInnerManager TerminateAbility
251 * @tc.type: FUNC
252 */
253 HWTEST_F(WindowInnerManagerTest, TerminateAbility, Function | SmallTest | Level2)
254 {
255 wim_->isRecentHolderEnable_ = true;
256 wptr<WindowNode> node1 = nullptr;
257 wim_->TerminateAbility(node1);
258 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
259 }
260
261 /**
262 * @tc.name: CloseAbility
263 * @tc.desc: test WindowInnerManager CloseAbility
264 * @tc.type: FUNC
265 */
266 HWTEST_F(WindowInnerManagerTest, CloseAbility, Function | SmallTest | Level2)
267 {
268 wim_->isRecentHolderEnable_ = true;
269 wptr<WindowNode> node1 = nullptr;
270 wim_->CloseAbility(node1);
271 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
272 }
273
274 /**
275 * @tc.name: CompleteFirstFrameDrawing
276 * @tc.desc: test WindowInnerManager CompleteFirstFrameDrawing
277 * @tc.type: FUNC
278 */
279 HWTEST_F(WindowInnerManagerTest, CompleteFirstFrameDrawing, Function | SmallTest | Level2)
280 {
281 wim_->isRecentHolderEnable_ = true;
282 wptr<WindowNode> node1 = nullptr;
283 wim_->CompleteFirstFrameDrawing(node1);
284 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
285 }
286
287 /**
288 * @tc.name: UpdateMissionSnapShot
289 * @tc.desc: test WindowInnerManager UpdateMissionSnapShot
290 * @tc.type: FUNC
291 */
292 HWTEST_F(WindowInnerManagerTest, UpdateMissionSnapShot, Function | SmallTest | Level2)
293 {
294 wim_->isRecentHolderEnable_ = true;
295 wptr<WindowNode> node1 = nullptr;
296 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
297 wim_->UpdateMissionSnapShot(node1, pixelMap);
298 ASSERT_EQ(wim_->isRecentHolderEnable_, true);
299 }
300
301 /**
302 * @tc.name: GetPid
303 * @tc.desc: test WindowInnerManager GetPid
304 * @tc.type: FUNC
305 */
306 HWTEST_F(WindowInnerManagerTest, GetPid, Function | SmallTest | Level2)
307 {
308 ASSERT_EQ(wim_->GetPid(), INVALID_PID);
309 }
310
311 /**
312 * @tc.name: SetInputEventConsumer
313 * @tc.desc: test WindowInnerManager SetInputEventConsumer
314 * @tc.type: FUNC
315 */
316 HWTEST_F(WindowInnerManagerTest, SetInputEventConsumer, Function | SmallTest | Level2)
317 {
318 wim_->moveDragController_ = nullptr;
319 wim_->SetInputEventConsumer();
320 ASSERT_EQ(wim_->moveDragController_, nullptr);
321 wim_->moveDragController_ = new MoveDragController();
322 wim_->SetInputEventConsumer();
323 ASSERT_NE(wim_->moveDragController_, nullptr);
324 }
325
326 /**
327 * @tc.name: StartWindowInfoReportLoop
328 * @tc.desc: test WindowInnerManager StartWindowInfoReportLoop
329 * @tc.type: FUNC
330 */
331 HWTEST_F(WindowInnerManagerTest, StartWindowInfoReportLoop, Function | SmallTest | Level2)
332 {
333 wim_->isReportTaskStart_ = true;
334 wim_->eventHandler_ = nullptr;
335 wim_->StartWindowInfoReportLoop();
336 ASSERT_EQ(wim_->isReportTaskStart_, true);
337 wim_->isReportTaskStart_ = false;
338 wim_->eventHandler_ = std::make_shared<EventHandler>(EventRunner::Create());
339 wim_->StartWindowInfoReportLoop();
340 ASSERT_EQ(wim_->isReportTaskStart_, true);
341 }
342 }
343 }
344 }
345