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
16 #include <gtest/gtest.h>
17 #include "ability_context_impl.h"
18 #include "display_manager_proxy.h"
19 #include "mock_uicontent.h"
20 #include "mock_window_adapter.h"
21 #include "singleton_mocker.h"
22 #include "window_impl.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
30 class MockAceAbilityHandler : public IAceAbilityHandler {
31 public:
32 MOCK_METHOD1(SetBackgroundColor, void(uint32_t color));
33 MOCK_METHOD0(GetBackgroundColor, uint32_t());
34 };
35
36 class MockAnimationTransitionController : public IAnimationTransitionController {
37 public:
38 MOCK_METHOD0(AnimationForShown, void());
39 MOCK_METHOD0(AnimationForHidden, void());
40 };
41
42 class MockDialogDeathRecipientListener : public IDialogDeathRecipientListener {
43 public:
44 MOCK_CONST_METHOD0(OnDialogDeathRecipient, void());
45 };
46
47 class MockScreenshotListener : public IScreenshotListener {
48 public:
49 MOCK_METHOD0(OnScreenshot, void());
50 };
51
52 class MockDialogTargetTouchListener : public IDialogTargetTouchListener {
53 public:
54 MOCK_CONST_METHOD0(OnDialogTargetTouch, void());
55 };
56
57 class MockWindowChangeListener : public IWindowChangeListener {
58 public:
59 MOCK_METHOD3(OnSizeChange,
60 void(Rect rect, WindowSizeChangeReason reason, const std::shared_ptr<RSTransaction>& rsTransaction));
61 MOCK_METHOD2(OnModeChange, void(WindowMode mode, bool hasDeco));
62 MOCK_METHOD1(NotifyTransformChange, void(const Transform& transform));
63 };
64
65 class MockAvoidAreaChangedListener : public IAvoidAreaChangedListener {
66 public:
67 MOCK_METHOD2(OnAvoidAreaChanged, void(const AvoidArea avoidArea, AvoidAreaType type));
68 };
69
70 class MockDisplayMoveListener : public IDisplayMoveListener {
71 public:
72 MOCK_METHOD2(OnDisplayMove, void(DisplayId from, DisplayId to));
73 };
74
75 class MockInputEventConsumer : public IInputEventConsumer {
76 public:
77 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::KeyEvent>&));
78 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::PointerEvent>&));
79 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::AxisEvent>&));
80 };
81
82 class MockKeyEvent : public MMI::KeyEvent {
83 public:
MockKeyEvent()84 MockKeyEvent() : MMI::KeyEvent(0) {}
85 };
86
87 class MockPointerEvent : public MMI::PointerEvent {
88 public:
MockPointerEvent()89 MockPointerEvent() : MMI::PointerEvent(0) {}
90 };
91
92 class WindowImplTest3 : public testing::Test {
93 public:
94 static void SetUpTestCase();
95 static void TearDownTestCase();
96 void SetUp() override;
97 void TearDown() override;
98
99 static inline std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
100 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
101
102 private:
103 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
104 };
SetUpTestCase()105 void WindowImplTest3::SetUpTestCase() {}
106
TearDownTestCase()107 void WindowImplTest3::TearDownTestCase() {}
108
SetUp()109 void WindowImplTest3::SetUp() {}
110
TearDown()111 void WindowImplTest3::TearDown()
112 {
113 usleep(WAIT_SYNC_IN_NS);
114 }
115
116 namespace {
117 /**
118 * @tc.name: RegisterAnimationTransitionController
119 * @tc.desc: RegisterAnimationTransitionController test
120 * @tc.type: FUNC
121 */
122 HWTEST_F(WindowImplTest3, RegisterAnimationTransitionController, Function | SmallTest | Level3)
123 {
124 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
125 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
126 sptr<IAnimationTransitionController> listener;
127 ASSERT_EQ(nullptr, listener);
128 window->RegisterAnimationTransitionController(listener);
129 listener = sptr<MockAnimationTransitionController>::MakeSptr();
130 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
131 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
132 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
133 window->RegisterAnimationTransitionController(listener);
134 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
135 window->RegisterAnimationTransitionController(listener);
136 window->property_->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
137 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
138 window->RegisterAnimationTransitionController(listener);
139 }
140
141 /**
142 * @tc.name: RegisterDialogDeathRecipientListener
143 * @tc.desc: RegisterDialogDeathRecipientListener | NotifyDestroy test
144 * @tc.type: FUNC
145 */
146 HWTEST_F(WindowImplTest3, RegisterDialogDeathRecipientListener, Function | SmallTest | Level3)
147 {
148 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
149 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
150
151 sptr<MockDialogDeathRecipientListener> listener;
152 ASSERT_EQ(nullptr, listener);
153 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
154 listener = sptr<MockDialogDeathRecipientListener>::MakeSptr();
155 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
156 EXPECT_CALL(*listener, OnDialogDeathRecipient());
157 window->NotifyDestroy();
158 window->UnregisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
159 window->NotifyDestroy();
160 }
161
162 /**
163 * @tc.name: NotifyScreenshot
164 * @tc.desc: NotifyScreenshot test
165 * @tc.type: FUNC
166 */
167 HWTEST_F(WindowImplTest3, NotifyScreenshot, Function | SmallTest | Level3)
168 {
169 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
170 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
171
172 sptr<MockScreenshotListener> listener;
173 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener));
174 listener = sptr<MockScreenshotListener>::MakeSptr();
175 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener));
176 EXPECT_CALL(*listener, OnScreenshot()).Times(1);
177 window->NotifyScreenshot();
178 window->screenshotListeners_[window->GetWindowId()].clear();
179 }
180
181 /**
182 * @tc.name: NotifyTouchDialogTarget
183 * @tc.desc: NotifyTouchDialogTarget test
184 * @tc.type: FUNC
185 */
186 HWTEST_F(WindowImplTest3, NotifyTouchDialogTarget, Function | SmallTest | Level3)
187 {
188 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
189 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
190
191 sptr<MockDialogTargetTouchListener> listener;
192 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener));
193 listener = sptr<MockDialogTargetTouchListener>::MakeSptr();
194 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener));
195 EXPECT_CALL(*listener, OnDialogTargetTouch());
196 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
197 window->NotifyTouchDialogTarget();
198 window->dialogTargetTouchListeners_[window->GetWindowId()].clear();
199 }
200
201 /**
202 * @tc.name: NotifySizeChange
203 * @tc.desc: NotifySizeChange test
204 * @tc.type: FUNC
205 */
206 HWTEST_F(WindowImplTest3, NotifySizeChange, Function | SmallTest | Level3)
207 {
208 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
209 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
210
211 sptr<MockWindowChangeListener> listener;
212 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
213 listener = sptr<MockWindowChangeListener>::MakeSptr();
214 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
215 EXPECT_CALL(*listener, OnSizeChange(_, _, _));
216 Rect rect;
217 window->NotifySizeChange(rect, WindowSizeChangeReason::UNDEFINED);
218 window->windowChangeListeners_[window->GetWindowId()].clear();
219 }
220
221 /**
222 * @tc.name: NotifyModeChange
223 * @tc.desc: NotifyModeChange test
224 * @tc.type: FUNC
225 */
226 HWTEST_F(WindowImplTest3, NotifyModeChange, Function | SmallTest | Level3)
227 {
228 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
229 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
230
231 sptr<MockWindowChangeListener> listener;
232 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
233 listener = sptr<MockWindowChangeListener>::MakeSptr();
234 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
235 EXPECT_CALL(*listener, OnModeChange(_, _));
236 window->NotifyModeChange(WindowMode::WINDOW_MODE_UNDEFINED);
237 window->windowChangeListeners_[window->GetWindowId()].clear();
238 }
239
240 /**
241 * @tc.name: NotifyAvoidAreaChange
242 * @tc.desc: NotifyAvoidAreaChange test
243 * @tc.type: FUNC
244 */
245 HWTEST_F(WindowImplTest3, NotifyAvoidAreaChange, Function | SmallTest | Level3)
246 {
247 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
248 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
249
250 sptr<MockAvoidAreaChangedListener> listener;
251 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener));
252 listener = sptr<MockAvoidAreaChangedListener>::MakeSptr();
253 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener));
254 EXPECT_CALL(*listener, OnAvoidAreaChanged(_, _));
255 sptr<AvoidArea> avoidArea = sptr<AvoidArea>::MakeSptr();
256 window->NotifyAvoidAreaChange(avoidArea, AvoidAreaType::TYPE_CUTOUT);
257 window->avoidAreaChangeListeners_[window->GetWindowId()].clear();
258 }
259
260 /**
261 * @tc.name: NotifyDisplayMoveChange
262 * @tc.desc: NotifyDisplayMoveChange test
263 * @tc.type: FUNC
264 */
265 HWTEST_F(WindowImplTest3, NotifyDisplayMoveChange, Function | SmallTest | Level3)
266 {
267 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
268 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
269
270 sptr<MockDisplayMoveListener> listener;
271 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener));
272 listener = sptr<MockDisplayMoveListener>::MakeSptr();
273 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener));
274 EXPECT_CALL(*listener, OnDisplayMove(_, _));
275 window->NotifyDisplayMoveChange(DisplayId{}, DisplayId{});
276 }
277
278 /**
279 * @tc.name: SetAceAbilityHandler
280 * @tc.desc: SetAceAbilityHandler test
281 * @tc.type: FUNC
282 */
283 HWTEST_F(WindowImplTest3, SetAceAbilityHandler, Function | SmallTest | Level3)
284 {
285 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
286 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
287
288 sptr<IAceAbilityHandler> handler;
289 ASSERT_EQ(nullptr, handler);
290 window->SetAceAbilityHandler(handler);
291 handler = sptr<MockAceAbilityHandler>::MakeSptr();
292 window->SetAceAbilityHandler(handler);
293 }
294
295 /**
296 * @tc.name: HandleBackKeyPressedEvent
297 * @tc.desc: HandleBackKeyPressedEvent test
298 * @tc.type: FUNC
299 */
300 HWTEST_F(WindowImplTest3, HandleBackKeyPressedEvent, Function | SmallTest | Level3)
301 {
302 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
303 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
304 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
305 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType());
306 std::shared_ptr<MMI::KeyEvent> keyEvent;
307 window->HandleBackKeyPressedEvent(keyEvent);
308
309 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
310 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
311 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
312 EXPECT_CALL(*content, ProcessBackPressed()).WillOnce(Return(false));
313 window->HandleBackKeyPressedEvent(keyEvent);
314
315 window->inputEventConsumer_.reset(new MockInputEventConsumer);
316 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()), OnInputEvent(keyEvent))
317 .WillOnce(Return(true));
318 window->HandleBackKeyPressedEvent(keyEvent);
319 }
320
321 /**
322 * @tc.name: ConsumeKeyEvent
323 * @tc.desc: ConsumeKeyEvent test
324 * @tc.type: FUNC
325 */
326 HWTEST_F(WindowImplTest3, ConsumeKeyEvent, Function | SmallTest | Level3)
327 {
328 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
329 option->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
330 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
331 std::shared_ptr<MMI::KeyEvent> keyEvent = std::make_shared<MockKeyEvent>();
332 EXPECT_CALL(m->Mock(), DispatchKeyEvent(_, _));
333 window->ConsumeKeyEvent(keyEvent);
334 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
335 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
336 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
337 EXPECT_CALL(*content, ProcessKeyEvent(_, _));
338 window->ConsumeKeyEvent(keyEvent);
339
340 window->inputEventConsumer_.reset(new MockInputEventConsumer);
341 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()), OnInputEvent(keyEvent));
342 window->ConsumeKeyEvent(keyEvent);
343
344 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
345 keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
346 window->inputEventConsumer_ = nullptr;
347 EXPECT_CALL(*content, ProcessBackPressed());
348 window->ConsumeKeyEvent(keyEvent);
349 }
350
351 /**
352 * @tc.name: ConsumePointerEvent
353 * @tc.desc: ConsumePointerEvent test
354 * @tc.type: FUNC
355 */
356 HWTEST_F(WindowImplTest3, ConsumePointerEvent, Function | SmallTest | Level3)
357 {
358 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
359 option->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
360 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
361 Rect rect{ 0, 0, 10u, 10u };
362 window->property_->SetWindowRect(rect);
363 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
364 MMI::PointerEvent::PointerItem item;
365 pointerEvent->SetPointerId(0);
366 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
367 window->ConsumePointerEvent(pointerEvent);
368
369 item.SetPointerId(0);
370 item.SetDisplayX(15); // 15 : position x
371 item.SetDisplayY(15); // 15 : position y
372 pointerEvent->AddPointerItem(item);
373 window->ConsumePointerEvent(pointerEvent);
374
375 item.SetDisplayX(5); // 5 : position x
376 item.SetDisplayY(5); // 5 : position y
377 pointerEvent->UpdatePointerItem(0, item);
378 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
379 window->ConsumePointerEvent(pointerEvent);
380 }
381
382 /**
383 * @tc.name: HandleModeChangeHotZones
384 * @tc.desc: HandleModeChangeHotZones test
385 * @tc.type: FUNC
386 */
387 HWTEST_F(WindowImplTest3, HandleModeChangeHotZones, Function | SmallTest | Level3)
388 {
389 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
390 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
391 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
392 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
393 window->HandleModeChangeHotZones(0, 0);
394 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
395 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
396 window->HandleModeChangeHotZones(0, 0);
397 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
398 window->HandleModeChangeHotZones(0, 0);
399 }
400
401 /**
402 * @tc.name: UpdatePointerEventForStretchableWindow
403 * @tc.desc: UpdatePointerEventForStretchableWindow test
404 * @tc.type: FUNC
405 */
406 HWTEST_F(WindowImplTest3, UpdatePointerEventForStretchableWindow, Function | SmallTest | Level3)
407 {
408 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
409 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
410 window->property_->SetWindowRect(Rect{ 0, 0, 10, 10 });
411 window->property_->SetOriginRect(Rect{ 0, 0, 100, 100 });
412 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
413 MMI::PointerEvent::PointerItem item;
414 ASSERT_FALSE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item));
415 window->UpdatePointerEventForStretchableWindow(pointerEvent);
416 pointerEvent->SetPointerId(0);
417 item.SetPointerId(0);
418 item.SetDisplayX(5); // 5 : position x
419 item.SetDisplayY(5); // 5 : position y
420 pointerEvent->AddPointerItem(item);
421 window->UpdatePointerEventForStretchableWindow(pointerEvent);
422 ASSERT_TRUE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item));
423 ASSERT_EQ(50, item.GetDisplayX());
424 ASSERT_EQ(50, item.GetDisplayY());
425 }
426
427 /**
428 * @tc.name: MoveDrag
429 * @tc.desc: StartMove | ReadyToMoveOrDragWindow | EndMoveOrDragWindow test
430 * @tc.type: FUNC
431 */
432 HWTEST_F(WindowImplTest3, MoveDrag, Function | SmallTest | Level3)
433 {
434 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
435 option->SetWindowName("MoveDrag");
436 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
437 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
438 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
439 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
440 window->RestoreSplitWindowMode(0u);
441 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
442 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
443 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
444
445 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
446 window->Show();
447 window->moveDragProperty_->startDragFlag_ = false;
448 window->moveDragProperty_->pointEventStarted_ = true;
449 window->StartMove();
450 window->moveDragProperty_->pointEventStarted_ = false;
451 window->StartMove();
452
453 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
454 MMI::PointerEvent::PointerItem item;
455 pointerEvent->SetTargetDisplayId(0);
456 item.SetDisplayX(10000);
457 item.SetDisplayY(10000);
458
459 window->moveDragProperty_->pointEventStarted_ = true;
460 window->ReadyToMoveOrDragWindow(pointerEvent, item);
461 window->moveDragProperty_->startMoveFlag_ = true;
462 window->moveDragProperty_->startDragFlag_ = true;
463 EXPECT_CALL(m->Mock(), ProcessPointUp(_)).Times(2);
464 window->EndMoveOrDragWindow(
465 uint32_t(), uint32_t(), window->moveDragProperty_->startPointerId_, window->moveDragProperty_->sourceType_);
466
467 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
468 ASSERT_EQ(WMError::WM_OK, window->Destroy());
469 }
470
471 /**
472 * @tc.name: TransferPointerEvent
473 * @tc.desc: TransferPointerEvent test
474 * @tc.type: FUNC
475 */
476 HWTEST_F(WindowImplTest3, TransferPointerEvent, Function | SmallTest | Level3)
477 {
478 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
479 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
480 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
481 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
482 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
483 window->windowSystemConfig_.isStretchable_ = true;
484 window->TransferPointerEvent(pointerEvent);
485 window->windowSystemConfig_.isStretchable_ = false;
486 window->TransferPointerEvent(pointerEvent);
487 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
488 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
489 EXPECT_CALL(*content, ProcessPointerEvent(_));
490 window->TransferPointerEvent(pointerEvent);
491
492 window->inputEventConsumer_.reset(new MockInputEventConsumer);
493 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()),
494 OnInputEvent(pointerEvent));
495 window->TransferPointerEvent(pointerEvent);
496 }
497
498 /**
499 * @tc.name: UpdateConfiguration
500 * @tc.desc: UpdateConfiguration test
501 * @tc.type: FUNC
502 */
503 HWTEST_F(WindowImplTest3, UpdateConfiguration, Function | SmallTest | Level3)
504 {
505 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
506 option->SetWindowName("UpdateConfiguration");
507 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
508 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
509 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
510 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
511 window->RestoreSplitWindowMode(0u);
512 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
513 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
514 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
515
516 option = sptr<WindowOption>::MakeSptr();
517 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
518 option->SetWindowName("subwindow");
519 sptr<WindowImpl> subWindow = sptr<WindowImpl>::MakeSptr(option);
520 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
521 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
522 ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId()));
523 std::shared_ptr<AppExecFwk::Configuration> configuration;
524 window->UpdateConfiguration(configuration);
525
526 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
527 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
528 subWindow->uiContent_ = std::make_unique<Ace::UIContentMocker>();
529 Ace::UIContentMocker* subContent = reinterpret_cast<Ace::UIContentMocker*>(subWindow->uiContent_.get());
530 EXPECT_CALL(*content, UpdateConfiguration(_));
531 EXPECT_CALL(*subContent, UpdateConfiguration(_));
532 window->UpdateConfiguration(configuration);
533 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
534 EXPECT_CALL(*content, Destroy());
535 EXPECT_CALL(*subContent, Destroy());
536 ASSERT_EQ(WMError::WM_OK, window->Destroy());
537 }
538
539 /**
540 * @tc.name: UpdateConfigurationForSpecified
541 * @tc.desc: UpdateConfigurationForSpecified test
542 * @tc.type: FUNC
543 */
544 HWTEST_F(WindowImplTest3, UpdateConfigurationForSpecified, Function | SmallTest | Level3)
545 {
546 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
547 option->SetWindowName("UpdateConfigurationForSpecified");
548 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
549 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
550 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
551 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
552 window->RestoreSplitWindowMode(0u);
553 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
554 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
555 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
556
557 option = sptr<WindowOption>::MakeSptr();
558 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
559 option->SetWindowName("subwindow");
560 sptr<WindowImpl> subWindow = sptr<WindowImpl>::MakeSptr(option);
561 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
562 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
563 ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId()));
564 std::shared_ptr<AppExecFwk::Configuration> configuration;
565 std::shared_ptr<Global::Resource::ResourceManager> resourceManager;
566 window->UpdateConfigurationForSpecified(configuration, resourceManager);
567
568 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
569 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
570 subWindow->uiContent_ = std::make_unique<Ace::UIContentMocker>();
571 Ace::UIContentMocker* subContent = reinterpret_cast<Ace::UIContentMocker*>(subWindow->uiContent_.get());
572 EXPECT_CALL(*content, UpdateConfiguration(_, _));
573 EXPECT_CALL(*subContent, UpdateConfiguration(_, _));
574 window->UpdateConfigurationForSpecified(configuration, resourceManager);
575 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
576 EXPECT_CALL(*content, Destroy());
577 EXPECT_CALL(*subContent, Destroy());
578 ASSERT_EQ(WMError::WM_OK, window->Destroy());
579 }
580
581 /**
582 * @tc.name: UpdateWindowState
583 * @tc.desc: UpdateWindowState test
584 * @tc.type: FUNC
585 */
586 HWTEST_F(WindowImplTest3, UpdateWindowState, Function | SmallTest | Level3)
587 {
588 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
589 option->SetWindowName("UpdateWindowState");
590 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
591 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
592 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
593 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
594 window->RestoreSplitWindowMode(0u);
595 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
596 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
597 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
598
599 window->UpdateWindowState(WindowState::STATE_FROZEN);
600 window->UpdateWindowState(WindowState::STATE_UNFROZEN);
601 window->UpdateWindowState(WindowState::STATE_SHOWN);
602 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
603 window->UpdateWindowState(WindowState::STATE_HIDDEN);
604 window->UpdateWindowState(WindowState::STATE_INITIAL);
605 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
606 ASSERT_EQ(WMError::WM_OK, window->Destroy());
607 }
608
609 /**
610 * @tc.name: RestoreSplitWindowMode
611 * @tc.desc: RestoreSplitWindowMode test
612 * @tc.type: FUNC
613 */
614 HWTEST_F(WindowImplTest3, RestoreSplitWindowMode, Function | SmallTest | Level3)
615 {
616 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
617 option->SetWindowName("RestoreSplitWindowMode");
618 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
619 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
620 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
621 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
622 window->RestoreSplitWindowMode(0u);
623 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
624 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
625 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
626 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
627 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
628 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_UNDEFINED));
629 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
630 ASSERT_EQ(WMError::WM_OK, window->Destroy());
631 }
632
633 /**
634 * @tc.name: IsFocused
635 * @tc.desc: IsFocused test
636 * @tc.type: FUNC
637 */
638 HWTEST_F(WindowImplTest3, IsFocused, Function | SmallTest | Level3)
639 {
640 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
641 option->SetWindowName("IsFocused");
642 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
643 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
644 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
645 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
646
647 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
648 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
649 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
650
651 window->UpdateFocusStatus(false);
652 ASSERT_FALSE(window->IsFocused());
653 window->UpdateFocusStatus(true);
654 ASSERT_TRUE(window->IsFocused());
655 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
656 ASSERT_EQ(WMError::WM_OK, window->Destroy());
657 }
658
659 /**
660 * @tc.name: UpdateSubWindowStateAndNotify
661 * @tc.desc: update subwindow state
662 * @tc.type: FUNC
663 */
664 HWTEST_F(WindowImplTest3, UpdateSubWindowStateAndNotify, Function | SmallTest | Level3)
665 {
666 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
667 option->SetWindowName("main");
668 sptr<WindowImpl> mainWindow = sptr<WindowImpl>::MakeSptr(option);
669
670 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
671 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId()));
672
673 option = sptr<WindowOption>::MakeSptr();
674 option->SetWindowName("sub");
675 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
676 sptr<WindowImpl> subWindow = sptr<WindowImpl>::MakeSptr(option);
677 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
678 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
679 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
680
681 // main window hide
682 mainWindow->state_ = WindowState::STATE_HIDDEN;
683 subWindow->state_ = WindowState::STATE_SHOWN;
684 subWindow->subWindowState_ = WindowState::STATE_SHOWN;
685 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
686 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
687
688 // main window show
689 mainWindow->state_ = WindowState::STATE_SHOWN;
690 subWindow->state_ = WindowState::STATE_SHOWN;
691 subWindow->subWindowState_ = WindowState::STATE_HIDDEN;
692 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
693 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_SHOWN);
694
695 subWindow->state_ = WindowState::STATE_HIDDEN;
696 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
697 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
698
699 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
700 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
701 }
702
703 /**
704 * @tc.name: UpdateWindowStateWhenHide
705 * @tc.desc: UpdateWindowStateWhenHide test
706 * @tc.type: FUNC
707 */
708 HWTEST_F(WindowImplTest3, UpdateWindowStateWhenHide, Function | SmallTest | Level3)
709 {
710 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
711 option->SetWindowName("main");
712 sptr<WindowImpl> mainWindow = sptr<WindowImpl>::MakeSptr(option);
713 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
714 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenHide());
715
716 option = sptr<WindowOption>::MakeSptr();
717 option->SetWindowName("sub");
718 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
719 sptr<WindowImpl> subWindow = sptr<WindowImpl>::MakeSptr(option);
720 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
721 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
722 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
723 subWindow->subWindowState_ = WindowState::STATE_SHOWN;
724 subWindow->UpdateWindowStateWhenHide();
725 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
726 subWindow->subWindowState_ = WindowState::STATE_HIDDEN;
727 subWindow->UpdateWindowStateWhenHide();
728 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
729
730 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
731 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
732 ASSERT_EQ(WMError::WM_OK, subWindow->Destroy());
733 }
734
735 /**
736 * @tc.name: UpdateWindowStateWhenShow
737 * @tc.desc: UpdateWindowStateWhenShow test
738 * @tc.type: FUNC
739 */
740 HWTEST_F(WindowImplTest3, UpdateWindowStateWhenShow, Function | SmallTest | Level3)
741 {
742 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
743 option->SetWindowName("main");
744 sptr<WindowImpl> mainWindow = sptr<WindowImpl>::MakeSptr(option);
745 if (mainWindow->Create(INVALID_WINDOW_ID) != WMError::WM_OK) {
746 ASSERT_NE(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
747 }
748
749 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenShow());
750
751 option = sptr<WindowOption>::MakeSptr();
752 option->SetWindowName("sub");
753 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
754 sptr<WindowImpl> subWindow = sptr<WindowImpl>::MakeSptr(option);
755 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
756 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
757 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
758 ASSERT_EQ(WmErrorCode::WM_OK, subWindow->UpdateWindowStateWhenShow());
759
760 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
761 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
762 }
763
764 /**
765 * @tc.name: RaiseToAppTop
766 * @tc.desc: RaiseToAppTop test
767 * @tc.type: FUNC
768 */
769 HWTEST_F(WindowImplTest3, RaiseToAppTop, Function | SmallTest | Level3)
770 {
771 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
772 option->parentId_ = INVALID_WINDOW_ID;
773 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
774 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RaiseToAppTop());
775
776 window->SetWindowState(WindowState::STATE_CREATED);
777 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARENT, window->RaiseToAppTop());
778
779 window->property_->parentId_ = 100000;
780 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
781 ASSERT_EQ(WMError::WM_ERROR_INVALID_CALLING, window->RaiseToAppTop());
782
783 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
784 window->state_ = WindowState::STATE_HIDDEN;
785 ASSERT_EQ(WMError::WM_DO_NOTHING, window->RaiseToAppTop());
786
787 window->state_ = WindowState::STATE_SHOWN;
788 EXPECT_CALL(m->Mock(), RaiseToAppTop(_)).Times(1).WillOnce(Return(WMError::WM_OK));
789 ASSERT_EQ(WMError::WM_OK, window->RaiseToAppTop());
790
791 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
792 ASSERT_EQ(WMError::WM_OK, window->Destroy());
793 }
794
795 /**
796 * @tc.name: UpdateDecorEnable
797 * @tc.desc: UpdateDecorEnable test
798 * @tc.type: FUNC
799 */
800 HWTEST_F(WindowImplTest3, UpdateDecorEnable, Function | SmallTest | Level3)
801 {
802 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
803 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
804 window->property_->mode_ = WindowMode::WINDOW_MODE_FULLSCREEN;
805 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
806 window->windowSystemConfig_.isSystemDecorEnable_ = true;
807 window->windowSystemConfig_.decorWindowModeSupportType_ = WINDOW_MODE_SUPPORT_FLOATING;
808 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
809 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
810 sptr<MockWindowChangeListener> listener = sptr<MockWindowChangeListener>::MakeSptr();
811 window->RegisterWindowChangeListener(sptr<IWindowChangeListener>(listener));
812
813 EXPECT_CALL(*content, UpdateWindowMode(_, _));
814 EXPECT_CALL(*listener, OnModeChange(_, _));
815 window->UpdateDecorEnable(true);
816 ASSERT_TRUE(window->IsDecorEnable());
817 ASSERT_FALSE(window->property_->GetDecorEnable());
818 window->windowSystemConfig_.decorWindowModeSupportType_ = WINDOW_MODE_SUPPORT_ALL;
819 window->UpdateDecorEnable();
820 ASSERT_TRUE(window->IsDecorEnable());
821 ASSERT_TRUE(window->property_->GetDecorEnable());
822 window->property_->type_ = WindowType::WINDOW_TYPE_FLOAT;
823 window->UpdateDecorEnable();
824 ASSERT_FALSE(window->IsDecorEnable());
825 ASSERT_FALSE(window->property_->GetDecorEnable());
826 window->UnregisterWindowChangeListener(sptr<IWindowChangeListener>(listener));
827 ASSERT_EQ(WMError::WM_OK, window->Destroy());
828 }
829
830 /**
831 * @tc.name: Find01
832 * @tc.desc: Find one exit window
833 * @tc.type: FUNC
834 */
835 HWTEST_F(WindowImplTest3, Find01, Function | SmallTest | Level2)
836 {
837 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
838 option->SetWindowName("Find01");
839 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
840 ASSERT_EQ(nullptr, WindowImpl::Find("Find01"));
841 ASSERT_EQ(WMError::WM_OK, window->Destroy());
842 }
843
844 /**
845 * @tc.name: Find02
846 * @tc.desc: Find one no exit window
847 * @tc.type: FUNC
848 */
849 HWTEST_F(WindowImplTest3, Find02, Function | SmallTest | Level2)
850 {
851 ASSERT_EQ(nullptr, WindowImpl::Find("Find02"));
852 }
853
854 /**
855 * @tc.name: Find03
856 * @tc.desc: Find window with empty name
857 * @tc.type: FUNC
858 */
859 HWTEST_F(WindowImplTest3, Find03, Function | SmallTest | Level2)
860 {
861 ASSERT_EQ(nullptr, WindowImpl::Find(""));
862 }
863
864 /**
865 * @tc.name: FindWindowById02
866 * @tc.desc: Find one top window
867 * @tc.type: FUNC
868 */
869 HWTEST_F(WindowImplTest3, FindWindowById02, Function | SmallTest | Level2)
870 {
871 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
872 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
873 option->SetWindowName("FindWindowById02");
874 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
875 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
876 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
877 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
878
879 ASSERT_NE(nullptr, window->FindWindowById(window->property_->GetWindowId()));
880
881 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
882 ASSERT_EQ(WMError::WM_OK, window->Destroy());
883 }
884
885 /**
886 * @tc.name: FindWindowById03
887 * @tc.desc: Find one no exit window
888 * @tc.type: FUNC
889 */
890 HWTEST_F(WindowImplTest3, FindWindowById03, Function | SmallTest | Level2)
891 {
892 ASSERT_EQ(nullptr, WindowImpl::FindWindowById(0));
893 }
894
895 /**
896 * @tc.name: GetTopWindowWithId02
897 * @tc.desc: Not get topwindow
898 * @tc.type: FUNC
899 */
900 HWTEST_F(WindowImplTest3, GetTopWindowWithId02, Function | SmallTest | Level2)
901 {
902 ASSERT_EQ(nullptr, WindowImpl::GetTopWindowWithId(0));
903 }
904
905 /**
906 * @tc.name: UpdateConfigurationForAll01
907 * @tc.desc: UpdateConfigurationForAll01 Test
908 * @tc.type: FUNC
909 */
910 HWTEST_F(WindowImplTest3, UpdateConfigurationForAll01, Function | SmallTest | Level2)
911 {
912 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
913 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
914 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
915 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
916 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
917 std::shared_ptr<AppExecFwk::Configuration> configuration;
918 sptr<Window>(window)->UpdateConfigurationForAll(configuration);
919 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
920 ASSERT_EQ(WMError::WM_OK, window->Destroy());
921 }
922
923 /**
924 * @tc.name: UpdateConfigurationForAll02
925 * @tc.desc: UpdateConfigurationForAll02 Test
926 * @tc.type: FUNC
927 */
928 HWTEST_F(WindowImplTest3, UpdateConfigurationForAll02, Function | SmallTest | Level2)
929 {
930 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
931 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
932 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
933 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
934 auto abilityContext = std::make_shared<AbilityRuntime::AbilityContextImpl>();
935 ASSERT_NE(nullptr, abilityContext);
936 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID, abilityContext));
937 std::vector<std::shared_ptr<AbilityRuntime::Context>> ignoreWindowContexts;
938 ignoreWindowContexts.push_back(abilityContext);
939 std::shared_ptr<AppExecFwk::Configuration> configuration;
940 window->UpdateConfigurationForAll(configuration, ignoreWindowContexts);
941 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
942 ASSERT_EQ(WMError::WM_OK, window->Destroy());
943 }
944
945 /**
946 * @tc.name: GetSurfaceNode01
947 * @tc.desc: GetSurfaceNode01 Test
948 * @tc.type: FUNC
949 */
950 HWTEST_F(WindowImplTest3, GetSurfaceNode01, Function | SmallTest | Level3)
951 {
952 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
953 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
954 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
955 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
956 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
957 ASSERT_NE(nullptr, sptr<Window>(window)->GetSurfaceNode());
958 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
959 ASSERT_EQ(WMError::WM_OK, window->Destroy());
960 }
961
962 /**
963 * @tc.name: GetRequestRect
964 * @tc.desc: get subwindow
965 * @tc.type: FUNC
966 */
967 HWTEST_F(WindowImplTest3, GetRequestRect, Function | SmallTest | Level2)
968 {
969 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
970 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
971 Rect a{ 0, 0, 0, 0 };
972 ASSERT_EQ(a, window->GetRequestRect());
973 }
974
975 /**
976 * @tc.name: GetAlpha
977 * @tc.desc: GetAlpha Test
978 * @tc.type: FUNC
979 */
980 HWTEST_F(WindowImplTest3, GetAlpha, Function | SmallTest | Level2)
981 {
982 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
983 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
984 ASSERT_EQ(1.0f, window->GetAlpha());
985 }
986
987 /**
988 * @tc.name: GetWindowState
989 * @tc.desc: GetWindowState Test
990 * @tc.type: FUNC
991 */
992 HWTEST_F(WindowImplTest3, GetWindowState, Function | SmallTest | Level2)
993 {
994 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
995 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
996 ASSERT_EQ(WindowState::STATE_INITIAL, window->GetWindowState());
997 }
998
999 /**
1000 * @tc.name: SetFocusable03
1001 * @tc.desc: SetFocusable Test
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(WindowImplTest3, SetFocusable03, Function | SmallTest | Level2)
1005 {
1006 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1007 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1008 WMError err = window->SetFocusable(false);
1009 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, err);
1010 }
1011
1012 /**
1013 * @tc.name: SetWindowType05
1014 * @tc.desc: SetWindowType Test
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(WindowImplTest3, SetWindowType05, Function | SmallTest | Level2)
1018 {
1019 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1020 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1021 option->SetWindowName("SetWindowType05");
1022 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1023 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1024 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1025 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1026 ASSERT_EQ(WMError::WM_OK, window->SetWindowType(WindowType::APP_WINDOW_BASE));
1027 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1028 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1029 }
1030
1031 /**
1032 * @tc.name: SetAlpha01
1033 * @tc.desc: SetAlpha Test
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(WindowImplTest3, SetAlpha01, Function | SmallTest | Level2)
1037 {
1038 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1039 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1040 option->SetWindowName("SetAlpha01");
1041 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1042 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1043 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1044 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1045 ASSERT_EQ(WMError::WM_OK, window->SetAlpha(1.0f));
1046 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1047 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1048 }
1049
1050 /**
1051 * @tc.name: CreateWindowImpl
1052 * @tc.desc: CreateSurfaceNode with different type
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(WindowImplTest3, CreateWindowImpl, Function | SmallTest | Level3)
1056 {
1057 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1058 option->SetWindowName("CreateSurfaceNode");
1059 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1060 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1061 option->SetWindowRect({ 1, 1, 1, 1 });
1062 option->SetBundleName("OK");
1063 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1064
1065 sptr<WindowOption> option1 = sptr<WindowOption>::MakeSptr();
1066 option1->SetWindowName("CreateSurfaceNode1");
1067 option1->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1068 option1->SetWindowType(WindowType::WINDOW_TYPE_BOOT_ANIMATION);
1069 option1->SetWindowRect({ 1, 1, 1, 1 });
1070 sptr<WindowImpl> window1 = sptr<WindowImpl>::MakeSptr(option1);
1071 sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
1072 option2->SetWindowName("CreateSurfaceNode2");
1073 option2->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1074 option2->SetWindowType(WindowType::WINDOW_TYPE_POINTER);
1075 option2->SetWindowRect({ 1, 1, 1, 1 });
1076 sptr<WindowImpl> window2 = sptr<WindowImpl>::MakeSptr(option2);
1077
1078 sptr<WindowOption> option3 = sptr<WindowOption>::MakeSptr();
1079 option3->SetWindowName("CreateSurfaceNode3");
1080 option3->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1081 option3->SetWindowType(WindowType::WINDOW_TYPE_FREEZE_DISPLAY);
1082 option3->SetWindowRect({ 1, 1, 1, 1 });
1083 sptr<WindowImpl> window3 = sptr<WindowImpl>::MakeSptr(option3);
1084
1085 sptr<WindowOption> option4 = sptr<WindowOption>::MakeSptr();
1086 option4->SetWindowName("CreateSurfaceNode4");
1087 option4->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1088 option4->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1089 option4->SetWindowRect({ 1, 1, 1, 1 });
1090 sptr<WindowImpl> window4 = sptr<WindowImpl>::MakeSptr(option4);
1091 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1092 ASSERT_EQ(WMError::WM_OK, window1->Destroy());
1093 ASSERT_EQ(WMError::WM_OK, window2->Destroy());
1094 ASSERT_EQ(WMError::WM_OK, window3->Destroy());
1095 ASSERT_EQ(WMError::WM_OK, window4->Destroy());
1096 }
1097
1098 /**
1099 * @tc.name: Create
1100 * @tc.desc: Create
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(WindowImplTest3, Create, Function | SmallTest | Level3)
1104 {
1105 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1106 option->SetWindowName("CreateSurfaceNode5");
1107 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1108 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1109 option->SetWindowRect({ 1, 1, 1, 1 });
1110 option->SetBundleName("OK");
1111 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1112
1113 WMError res = window->Create(INVALID_WINDOW_ID);
1114 ASSERT_EQ(WMError::WM_OK, res);
1115
1116 sptr<WindowImpl> window1 = sptr<WindowImpl>::MakeSptr(option); // the same name
1117 res = window1->Create(INVALID_WINDOW_ID);
1118 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res);
1119 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1120 ASSERT_EQ(WMError::WM_OK, window1->Destroy());
1121 }
1122
1123 /**
1124 * @tc.name: Create1
1125 * @tc.desc: Create WindowCreateCheck
1126 * @tc.type: FUNC
1127 */
1128 HWTEST_F(WindowImplTest3, Create1, Function | SmallTest | Level3)
1129 {
1130 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1131 option->SetWindowName("WindowCreateCheck");
1132 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1133 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
1134 option->SetWindowRect({ 1, 1, 1, 1 });
1135 option->SetBundleName("OK");
1136 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1137 WMError res = window->Create(INVALID_WINDOW_ID);
1138 ASSERT_EQ(WMError::WM_OK, res);
1139
1140 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1141 sptr<WindowImpl> window1 = sptr<WindowImpl>::MakeSptr(option);
1142 ASSERT_NE(window1, nullptr);
1143 res = window1->Create(INVALID_WINDOW_ID);
1144 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res);
1145
1146 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1147 sptr<WindowImpl> window2 = sptr<WindowImpl>::MakeSptr(option);
1148 ASSERT_NE(window2, nullptr);
1149 res = window1->Create(INVALID_WINDOW_ID);
1150 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res);
1151 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1152 ASSERT_EQ(WMError::WM_OK, window1->Destroy());
1153 ASSERT_EQ(WMError::WM_OK, window2->Destroy());
1154 }
1155
1156 /**
1157 * @tc.name: Create2
1158 * @tc.desc: Create WindowCreateCheck
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(WindowImplTest3, Create2, Function | SmallTest | Level3)
1162 {
1163 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1164 option->SetWindowName("WindowCreateCheck1");
1165 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1166 option->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
1167 option->SetWindowRect({ 1, 1, 1, 1 });
1168 option->SetBundleName("OK");
1169 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1170 WMError res = window->Create(1);
1171 ASSERT_EQ(WMError::WM_OK, res);
1172
1173 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1174 sptr<WindowImpl> window1 = sptr<WindowImpl>::MakeSptr(option);
1175 ASSERT_NE(window1, nullptr);
1176 res = window1->Create(1);
1177 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res);
1178
1179 option->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1180 sptr<WindowImpl> window2 = sptr<WindowImpl>::MakeSptr(option);
1181 ASSERT_NE(window2, nullptr);
1182 res = window2->Create(1);
1183 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, res);
1184 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1185 ASSERT_EQ(WMError::WM_OK, window1->Destroy());
1186 ASSERT_EQ(WMError::WM_OK, window2->Destroy());
1187 }
1188
1189 /**
1190 * @tc.name: GetTopWindowWithId
1191 * @tc.desc: CreateSurfaceNode with different type
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(WindowImplTest3, GetTopWindowWithId, Function | SmallTest | Level3)
1195 {
1196 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1197 option->SetWindowName("GetTopWindowWithId");
1198 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1199 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1200 option->SetWindowRect({ 1, 1, 1, 1 });
1201 option->SetBundleName("OK");
1202 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1203 sptr<Window> topWindow = window->GetTopWindowWithId(INVALID_WINDOW_ID);
1204 ASSERT_EQ(topWindow, nullptr);
1205
1206 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1207 }
1208
1209 /**
1210 * @tc.name: NotifyForegroundInteractiveStatus
1211 * @tc.desc: NotifyForegroundInteractiveStatus Test
1212 * @tc.type: FUNC
1213 */
1214 HWTEST_F(WindowImplTest3, NotifyForegroundInteractiveStatus, Function | SmallTest | Level2)
1215 {
1216 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1217 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1218 bool interactive = false;
1219 window->NotifyForegroundInteractiveStatus(interactive);
1220 window->SetWindowState(WindowState::STATE_DESTROYED);
1221 interactive = true;
1222 window->NotifyForegroundInteractiveStatus(interactive);
1223 ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
1224 }
1225
1226 /**
1227 * @tc.name: GetTopWindowWithContext
1228 * @tc.desc: GetTopWindowWithContexttest01
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(WindowImplTest3, GetTopWindowWithContext01, Function | SmallTest | Level3)
1232 {
1233 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1234 option->SetWindowName("GetTopWindowWithContext01");
1235 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1236 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1237 option->SetWindowRect({ 1, 1, 1, 1 });
1238 option->SetBundleName("OK");
1239 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1240 std::shared_ptr<AbilityRuntime::Context> context;
1241 ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithContext(context));
1242 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1243 }
1244
1245 /**
1246 * @tc.name: GetSubWindow
1247 * @tc.desc: GetSubWindowtest02
1248 * @tc.type: FUNC
1249 */
1250 HWTEST_F(WindowImplTest3, GetSubWindowtext02, Function | SmallTest | Level3)
1251 {
1252 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1253 option->SetWindowName("GetSubWindowtest02");
1254 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1255 option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1256 option->SetWindowRect({ 1, 1, 1, 1 });
1257 option->SetBundleName("OK");
1258 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1259 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1260 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1261 auto subWindowVec = sptr<Window>(window)->GetSubWindow(window->GetWindowId());
1262 if (subWindowVec.size() == 1) {
1263 ASSERT_EQ(1, subWindowVec.size());
1264 }
1265 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1266 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1267 }
1268
1269 /**
1270 * @tc.name: SetFloatingMaximize
1271 * @tc.desc: SetFloatingMaximize test
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(WindowImplTest3, SetFloatingMaximize, Function | SmallTest | Level3)
1275 {
1276 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1277 option->SetWindowName("SetFloatingMaximize");
1278 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1279 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1280 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1281 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1282 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1283 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1284 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1285 window->UpdateWindowModeSupportType(0);
1286 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFloatingMaximize(true));
1287 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1288 }
1289
1290 /**
1291 * @tc.name: SetAspectRatio
1292 * @tc.desc: SetAspectRatio Test
1293 * @tc.type: FUNC
1294 */
1295 HWTEST_F(WindowImplTest3, SetAspectRatio, Function | SmallTest | Level2)
1296 {
1297 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1298 option->SetWindowName("SetAspectRatio");
1299 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1300 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1301 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1302 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(1.1));
1303 option->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1304 ASSERT_EQ(WMError::WM_OK, window->SetAspectRatio(1.1));
1305 }
1306
1307 /**
1308 * @tc.name: SetAspectRatio02
1309 * @tc.desc: SetAspectRatio Test
1310 * @tc.type: FUNC
1311 */
1312 HWTEST_F(WindowImplTest3, SetAspectRatio02, Function | SmallTest | Level2)
1313 {
1314 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1315 option->SetWindowName("SetAspectRatio02");
1316 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1317 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1318 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetAspectRatio(0.0));
1319 }
1320
1321 /**
1322 * @tc.name: MapDialogWindowToAppIfNeeded
1323 * @tc.desc: MapDialogWindowToAppIfNeededtest
1324 * @tc.type: FUNC
1325 */
1326 HWTEST_F(WindowImplTest3, MapDialogWindowToAppIfNeededtest, Function | SmallTest | Level3)
1327 {
1328 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1329 option->SetWindowName("MapDialogWindowToAppIfNeededtest");
1330 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1331 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1332 option->SetWindowRect({ 1, 1, 1, 1 });
1333 option->SetBundleName("OK");
1334 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1335 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1336 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1337 window->MapDialogWindowToAppIfNeeded();
1338 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1339 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1340 }
1341
1342 /**
1343 * @tc.name: GetConfigurationFromAbilityInfo
1344 * @tc.desc: GetConfigurationFromAbilityInfotest
1345 * @tc.type: FUNC
1346 */
1347 HWTEST_F(WindowImplTest3, GetConfigurationFromAbilityInfotest, Function | SmallTest | Level3)
1348 {
1349 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1350 option->SetWindowName("GetConfigurationFromAbilityInfotest");
1351 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1352 option->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1353 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1354 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1355 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1356 window->MapDialogWindowToAppIfNeeded();
1357 window->GetConfigurationFromAbilityInfo();
1358 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1359 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1360 }
1361
1362 /**
1363 * @tc.name: SetSnapshotSkip
1364 * @tc.desc: SetSnapshotSkip test
1365 * @tc.type: FUNC
1366 * @tc.require: issueI5MYNX
1367 */
1368 HWTEST_F(WindowImplTest3, SetSnapshotSkip, Function | SmallTest | Level3)
1369 {
1370 sptr<WindowOption> option = new WindowOption();
1371 option->SetWindowName("SetSnapshotSkip");
1372 sptr<WindowImpl> window = new WindowImpl(option);
1373 ASSERT_NE(nullptr, window);
1374 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSnapshotSkip(true));
1375 }
1376
1377 /**
1378 * @tc.name: MaximizeFloating
1379 * @tc.desc: MaximizeFloating test
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(WindowImplTest3, MaximizeFloating, Function | SmallTest | Level3)
1383 {
1384 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1385 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1386 option->SetWindowName("MaximizeFloating");
1387 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1388 window->MaximizeFloating();
1389 ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->GetWindowMode());
1390 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1391 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1392 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1393 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1394 window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1395 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1396 window->Show();
1397 window->MaximizeFloating();
1398 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
1399 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1400 window->Hide();
1401 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1402 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1403 }
1404
1405 /**
1406 * @tc.name: GetTopWindowWithId03
1407 * @tc.desc: GetTopWindowWithId test
1408 * @tc.type: FUNC
1409 */
1410 HWTEST_F(WindowImplTest3, GetTopWindowWithId03, Function | SmallTest | Level3)
1411 {
1412 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1413 option->SetWindowName("GetTopWindowWithId03");
1414 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1415 uint32_t mainWinId = 0;
1416 uint32_t windowId = 1;
1417 string winName = "test";
1418 WindowImpl::windowMap_.insert(std::make_pair(winName, std::pair<uint32_t, sptr<Window>>(windowId, window)));
1419
1420 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).WillRepeatedly(Return(WMError::WM_ERROR_DEVICE_NOT_SUPPORT));
1421 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId));
1422
1423 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _))
1424 .WillRepeatedly(DoAll(SetArgReferee<1>(windowId), Return(WMError::WM_OK)));
1425 ASSERT_NE(nullptr, window->GetTopWindowWithId(mainWinId));
1426 uint32_t topWinId = 1;
1427 ASSERT_EQ(WindowImpl::FindWindowById(topWinId), window->GetTopWindowWithId(mainWinId));
1428
1429 uint32_t tempWindowId = 3;
1430 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _))
1431 .WillRepeatedly(DoAll(SetArgReferee<1>(tempWindowId), Return(WMError::WM_OK)));
1432 ASSERT_EQ(nullptr, window->GetTopWindowWithId(mainWinId));
1433
1434 WindowImpl::windowMap_.erase(winName);
1435 }
1436
1437 /**
1438 * @tc.name: GetTopWindowWithContext02
1439 * @tc.desc: GetTopWindowWithContext test
1440 * @tc.type: FUNC
1441 */
1442 HWTEST_F(WindowImplTest3, GetTopWindowWithContext02, Function | SmallTest | Level3)
1443 {
1444 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1445 option->SetWindowName("GetTopWindowWithContext02");
1446 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1447 std::shared_ptr<AbilityRuntime::Context> context;
1448 uint32_t mainWinId = INVALID_WINDOW_ID;
1449
1450 WMError ret = WMError::WM_ERROR_DEVICE_NOT_SUPPORT;
1451 ASSERT_NE(WMError::WM_OK, ret);
1452 ASSERT_EQ(INVALID_WINDOW_ID, mainWinId);
1453 ASSERT_EQ(nullptr, window->GetTopWindowWithContext(context));
1454 ret = WMError::WM_OK;
1455 uint32_t topWinId = INVALID_WINDOW_ID;
1456 ASSERT_EQ(WindowImpl::FindWindowById(topWinId), window->GetTopWindowWithContext(context));
1457 }
1458
1459 /**
1460 * @tc.name: GetSubWindow03
1461 * @tc.desc: GetSubWindowtest
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(WindowImplTest3, GetSubWindow03, Function | SmallTest | Level3)
1465 {
1466 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1467 option->SetWindowName("GetSubWindow03");
1468 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1469 uint32_t parentId = 0;
1470
1471 ASSERT_EQ(std::vector<sptr<Window>>(), window->GetSubWindow(parentId));
1472 }
1473
1474 /**
1475 * @tc.name: SetNeedDefaultAnimation
1476 * @tc.desc: SetNeedDefaultAnimation
1477 * @tc.type: FUNC
1478 */
1479 HWTEST_F(WindowImplTest3, SetNeedDefaultAnimation, Function | SmallTest | Level3)
1480 {
1481 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1482 option->SetWindowName("SetNeedDefaultAnimation");
1483 sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1484 bool defaultAnimation = true;
1485 window->SetNeedDefaultAnimation(defaultAnimation);
1486 EXPECT_EQ(true, window->needDefaultAnimation_);
1487 EXPECT_EQ(WMError::WM_OK, window->SetTextFieldAvoidInfo(2.0, 3.0));
1488 }
1489 } // namespace
1490 } // namespace Rosen
1491 } // namespace OHOS
1492