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