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