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 MockOccupiedAreaChangeListener : public IOccupiedAreaChangeListener {
31 public:
32     MOCK_METHOD2(OnSizeChange, void(const sptr<OccupiedAreaChangeInfo>& info,
33         const std::shared_ptr<RSTransaction>& rsTransaction));
34 };
35 
36 class MockMmiPointerEvent : public MMI::PointerEvent {
37 public:
MockMmiPointerEvent()38     MockMmiPointerEvent(): MMI::PointerEvent(0) {}
39 };
40 
41 class MockWindowDragListener : public IWindowDragListener {
42 public:
43     MOCK_METHOD3(OnDrag, void(int32_t x, int32_t y, DragEvent event));
44 };
45 
46 class WindowImplTest5 : public testing::Test {
47 public:
48     static void SetUpTestCase();
49     static void TearDownTestCase();
50     void SetUp() override;
51     void TearDown() override;
52 
53     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
54 
55 private:
56     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
57 };
SetUpTestCase()58 void WindowImplTest5::SetUpTestCase()
59 {
60 }
61 
TearDownTestCase()62 void WindowImplTest5::TearDownTestCase()
63 {
64 }
65 
SetUp()66 void WindowImplTest5::SetUp()
67 {
68 }
69 
TearDown()70 void WindowImplTest5::TearDown()
71 {
72     usleep(WAIT_SYNC_IN_NS);
73 }
74 
75 namespace {
76 /**
77  * @tc.name: IsAllowHaveSystemSubWindow
78  * @tc.desc: IsAllowHaveSystemSubWindow desc
79  * @tc.type: FUNC
80  */
81 HWTEST_F(WindowImplTest5, IsAllowHaveSystemSubWindow, Function | SmallTest | Level1)
82 {
83     sptr<WindowOption> option = new (std::nothrow) WindowOption();
84     ASSERT_NE(option, nullptr);
85     option->SetWindowName("IsAllowHaveSystemSubWindow");
86     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
87     ASSERT_NE(window, nullptr);
88     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW);
89     EXPECT_EQ(window->IsAllowHaveSystemSubWindow(), false);
90 
91     window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
92     EXPECT_EQ(window->IsAllowHaveSystemSubWindow(), false);
93 
94     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
95     EXPECT_EQ(window->IsAllowHaveSystemSubWindow(), false);
96 
97     window->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
98     EXPECT_EQ(window->IsAllowHaveSystemSubWindow(), true);
99 }
100 
101 /**
102  * @tc.name: NotifyMemoryLevel
103  * @tc.desc: NotifyMemoryLevel desc
104  * @tc.type: FUNC
105  */
106 HWTEST_F(WindowImplTest5, NotifyMemoryLevel, Function | SmallTest | Level1)
107 {
108     sptr<WindowOption> option = new (std::nothrow) WindowOption();
109     ASSERT_NE(option, nullptr);
110     option->SetWindowName("NotifyMemoryLevel");
111     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
112     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
113     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
114     ASSERT_NE(window, nullptr);
115     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
116     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
117     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
118     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
119     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
120 
121     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
122     EXPECT_CALL(*content, NotifyMemoryLevel(_)).Times(1).WillOnce(Return());
123     window->NotifyMemoryLevel(1);
124     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
125     EXPECT_CALL(*content, Destroy());
126     ASSERT_EQ(WMError::WM_OK, window->Destroy());
127 }
128 
129 /**
130  * @tc.name: SetRequestedOrientation
131  * @tc.desc: SetRequestedOrientation desc
132  * @tc.type: FUNC
133  */
134 HWTEST_F(WindowImplTest5, SetRequestedOrientation, Function | SmallTest | Level1)
135 {
136     sptr<WindowOption> option = new (std::nothrow) WindowOption();
137     ASSERT_NE(option, nullptr);
138     option->SetWindowName("SetRequestedOrientation");
139     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
140     ASSERT_NE(window, nullptr);
141     window->property_->SetRequestedOrientation(Orientation::BEGIN);
142     auto orientation = Orientation::BEGIN;
143     window->SetRequestedOrientation(orientation);
144 
145     orientation = Orientation::VERTICAL;
146     window->state_ = WindowState::STATE_CREATED;
147     window->SetRequestedOrientation(orientation);
148 
149     window->state_ = WindowState::STATE_SHOWN;
150     window->SetRequestedOrientation(orientation);
151     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
152 }
153 
154 /**
155  * @tc.name: GetSystemAlarmWindowDefaultSize
156  * @tc.desc: GetSystemAlarmWindowDefaultSize desc
157  * @tc.type: FUNC
158  */
159 HWTEST_F(WindowImplTest5, GetSystemAlarmWindowDefaultSize, Function | SmallTest | Level1)
160 {
161     sptr<WindowOption> option = new (std::nothrow) WindowOption();
162     ASSERT_NE(option, nullptr);
163     option->SetWindowName("GetSystemAlarmWindowDefaultSize");
164     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
165     ASSERT_NE(window, nullptr);
166 
167     Rect defaultRect { 10, 10, 10, 10 };
168 
169     SingletonContainer::GetInstance().destroyed_ = true;
170     window->GetSystemAlarmWindowDefaultSize(defaultRect);
171 
172     SingletonContainer::GetInstance().destroyed_ = false;
173     window->GetSystemAlarmWindowDefaultSize(defaultRect);
174 }
175 
176 /**
177  * @tc.name: CheckCameraFloatingWindowMultiCreated
178  * @tc.desc: CheckCameraFloatingWindowMultiCreated desc
179  * @tc.type: FUNC
180  */
181 HWTEST_F(WindowImplTest5, CheckCameraFloatingWindowMultiCreated, Function | SmallTest | Level1)
182 {
183     sptr<WindowOption> option = new (std::nothrow) WindowOption();
184     ASSERT_NE(option, nullptr);
185     option->SetWindowName("CheckCameraFloatingWindowMultiCreated");
186     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
187     ASSERT_NE(window, nullptr);
188     auto type = WindowType::WINDOW_TYPE_FLOAT;
189     EXPECT_EQ(window->CheckCameraFloatingWindowMultiCreated(type), false);
190 
191     type = WindowType::WINDOW_TYPE_FLOAT_CAMERA;
192     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
193     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
194     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
195     EXPECT_EQ(window->CheckCameraFloatingWindowMultiCreated(type), false);
196 
197     option->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
198     EXPECT_EQ(window->CheckCameraFloatingWindowMultiCreated(type), false);
199     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
200     ASSERT_EQ(WMError::WM_OK, window->Destroy());
201 }
202 
203 /**
204  * @tc.name: SetDefaultOption01
205  * @tc.desc: SetDefaultOption desc
206  * @tc.type: FUNC
207  */
208 HWTEST_F(WindowImplTest5, SetDefaultOption01, Function | SmallTest | Level1)
209 {
210     sptr<WindowOption> option = new (std::nothrow) WindowOption();
211     ASSERT_NE(option, nullptr);
212     option->SetWindowName("SetDefaultOption01");
213     option->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
214     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
215     ASSERT_NE(window, nullptr);
216     window->SetDefaultOption();
217 
218     window->property_->SetWindowType(WindowType::WINDOW_TYPE_NAVIGATION_BAR);
219     window->SetDefaultOption();
220 
221     window->property_->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
222     window->SetDefaultOption();
223 
224     window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
225     window->SetDefaultOption();
226 
227     window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_STATUS_BAR);
228     window->SetDefaultOption();
229 
230     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_ALARM_WINDOW);
231     window->SetDefaultOption();
232 
233     window->property_->SetWindowType(WindowType::WINDOW_TYPE_KEYGUARD);
234     window->SetDefaultOption();
235 
236     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DRAGGING_EFFECT);
237     window->SetDefaultOption();
238 
239     window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
240     window->SetDefaultOption();
241 
242     window->property_->SetWindowType(WindowType::WINDOW_TYPE_TOAST);
243     window->SetDefaultOption();
244 
245     window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
246     window->SetDefaultOption();
247 
248     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
249     window->SetDefaultOption();
250 
251     window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
252     window->SetDefaultOption();
253 }
254 
255 /**
256  * @tc.name: SetDefaultOption02
257  * @tc.desc: SetDefaultOption desc
258  * @tc.type: FUNC
259  */
260 HWTEST_F(WindowImplTest5, SetDefaultOption02, Function | SmallTest | Level1)
261 {
262     sptr<WindowOption> option = new (std::nothrow) WindowOption();
263     ASSERT_NE(option, nullptr);
264     option->SetWindowName("SetDefaultOption02");
265     option->SetWindowType(WindowType::WINDOW_TYPE_VOICE_INTERACTION);
266     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
267     ASSERT_NE(window, nullptr);
268     window->SetDefaultOption();
269 
270     window->property_->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_DOCK);
271     window->SetDefaultOption();
272 
273     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SEARCHING_BAR);
274     window->SetDefaultOption();
275 
276     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SCREENSHOT);
277     window->SetDefaultOption();
278 
279     window->property_->SetWindowType(WindowType::WINDOW_TYPE_GLOBAL_SEARCH);
280     window->SetDefaultOption();
281 
282     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
283     window->SetDefaultOption();
284 
285     window->property_->SetWindowType(WindowType::WINDOW_TYPE_BOOT_ANIMATION);
286     window->SetDefaultOption();
287 
288     window->property_->SetWindowType(WindowType::WINDOW_TYPE_POINTER);
289     window->SetDefaultOption();
290 
291     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
292     window->SetDefaultOption();
293 
294     window->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_TOAST);
295     window->SetDefaultOption();
296 
297     window->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
298     window->SetDefaultOption();
299 }
300 
301 /**
302  * @tc.name: UpdateActiveStatus
303  * @tc.desc: UpdateActiveStatus desc
304  * @tc.type: FUNC
305  */
306 HWTEST_F(WindowImplTest5, UpdateActiveStatus, Function | SmallTest | Level1)
307 {
308     sptr<WindowOption> option = new (std::nothrow) WindowOption();
309     ASSERT_NE(option, nullptr);
310     option->SetWindowName("UpdateActiveStatus");
311     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
312     ASSERT_NE(window, nullptr);
313 
314     bool isActive = true;
315     window->UpdateActiveStatus(isActive);
316 
317     isActive = false;
318     window->UpdateActiveStatus(isActive);
319 }
320 
321 /**
322  * @tc.name: NotifyForegroundInteractiveStatus
323  * @tc.desc: NotifyForegroundInteractiveStatus desc
324  * @tc.type: FUNC
325  */
326 HWTEST_F(WindowImplTest5, NotifyForegroundInteractiveStatus, Function | SmallTest | Level1)
327 {
328     sptr<WindowOption> option = new (std::nothrow) WindowOption();
329     ASSERT_NE(option, nullptr);
330     option->SetWindowName("NotifyForegroundInteractiveStatus");
331     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
332     ASSERT_NE(window, nullptr);
333 
334     bool interactive = false;
335     window->state_ = WindowState::STATE_INITIAL;
336     window->NotifyForegroundInteractiveStatus(interactive);
337 
338     window->state_ = WindowState::STATE_CREATED;
339     window->NotifyForegroundInteractiveStatus(interactive);
340 
341     window->state_ = WindowState::STATE_SHOWN;
342     window->NotifyForegroundInteractiveStatus(interactive);
343 
344     interactive = true;
345     window->NotifyForegroundInteractiveStatus(interactive);
346     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
347 }
348 
349 /**
350  * @tc.name: UpdateWindowState02
351  * @tc.desc: UpdateWindowState desc
352  * @tc.type: FUNC
353  */
354 HWTEST_F(WindowImplTest5, UpdateWindowState02, Function | SmallTest | Level1)
355 {
356     sptr<WindowOption> option = new (std::nothrow) WindowOption();
357     ASSERT_NE(option, nullptr);
358     option->SetWindowName("UpdateWindowState02");
359     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
360     ASSERT_NE(window, nullptr);
361     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
362     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
363     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
364     window->state_ = WindowState::STATE_CREATED;
365     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
366     window->context_ = context;
367 
368     WindowState state = WindowState::STATE_FROZEN;
369 
370     window->windowTag_ = WindowTag::MAIN_WINDOW;
371     window->UpdateWindowState(state);
372 
373     window->windowTag_ = WindowTag::SUB_WINDOW;
374     window->UpdateWindowState(state);
375 
376     state = WindowState::STATE_SHOWN;
377 
378     window->windowTag_ = WindowTag::MAIN_WINDOW;
379     window->UpdateWindowState(state);
380 
381     window->windowTag_ = WindowTag::SUB_WINDOW;
382     window->UpdateWindowState(state);
383 
384     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
385 
386     state = WindowState::STATE_HIDDEN;
387 
388     window->windowTag_ = WindowTag::MAIN_WINDOW;
389     window->UpdateWindowState(state);
390 
391     window->windowTag_ = WindowTag::SUB_WINDOW;
392     window->UpdateWindowState(state);
393 
394     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
395     ASSERT_EQ(WMError::WM_OK, window->Destroy());
396 }
397 
398 /**
399  * @tc.name: UpdateWindowStateUnfrozen
400  * @tc.desc: UpdateWindowStateUnfrozen desc
401  * @tc.type: FUNC
402  */
403 HWTEST_F(WindowImplTest5, UpdateWindowStateUnfrozen, Function | SmallTest | Level1)
404 {
405     sptr<WindowOption> option = new (std::nothrow) WindowOption();
406     ASSERT_NE(option, nullptr);
407     option->SetWindowName("UpdateWindowStateUnfrozen");
408     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
409     ASSERT_NE(window, nullptr);
410     window->context_ = nullptr;
411 
412     window->state_ = WindowState::STATE_CREATED;
413     window->UpdateWindowStateUnfrozen();
414 
415     window->state_ = WindowState::STATE_SHOWN;
416     window->UpdateWindowStateUnfrozen();
417 
418     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
419     window->context_ = context;
420 
421     window->windowTag_ = WindowTag::MAIN_WINDOW;
422     window->UpdateWindowStateUnfrozen();
423 
424     window->windowTag_ = WindowTag::SUB_WINDOW;
425     window->UpdateWindowStateUnfrozen();
426 
427     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
428     ASSERT_EQ(WMError::WM_OK, window->Destroy());
429 }
430 
431 /**
432  * @tc.name: UpdateFocusStatus
433  * @tc.desc: UpdateFocusStatus desc
434  * @tc.type: FUNC
435  */
436 HWTEST_F(WindowImplTest5, UpdateFocusStatus, Function | SmallTest | Level1)
437 {
438     sptr<WindowOption> option = new (std::nothrow) WindowOption();
439     ASSERT_NE(option, nullptr);
440     option->SetWindowName("UpdateFocusStatus");
441     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
442     ASSERT_NE(window, nullptr);
443 
444     bool focused = true;
445 
446     window->state_ = WindowState::STATE_CREATED;
447     window->UpdateFocusStatus(focused);
448 
449     window->state_ = WindowState::STATE_HIDDEN;
450     window->UpdateFocusStatus(focused);
451 
452     window->state_ = WindowState::STATE_SHOWN;
453     window->UpdateFocusStatus(focused);
454 
455     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
456     ASSERT_EQ(WMError::WM_OK, window->Destroy());
457 }
458 
459 /**
460  * @tc.name: UnregisterListener
461  * @tc.desc: UnregisterListener | RegisterListener desc
462  * @tc.type: FUNC
463  */
464 HWTEST_F(WindowImplTest5, UnregisterListener, Function | SmallTest | Level1)
465 {
466     sptr<WindowOption> option = new (std::nothrow) WindowOption();
467     ASSERT_NE(option, nullptr);
468     option->SetWindowName("UnregisterListener");
469     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
470     ASSERT_NE(window, nullptr);
471 
472     sptr<MockOccupiedAreaChangeListener> listener1;
473     window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
474     sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
475     ASSERT_NE(listener2, nullptr);
476     window->UnregisterOccupiedAreaChangeListener(listener2);
477     window->RegisterOccupiedAreaChangeListener(nullptr);
478     window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
479 }
480 
481 /**
482  * @tc.name: Close
483  * @tc.desc: Close test
484  * @tc.type: FUNC
485  */
486 HWTEST_F(WindowImplTest5, Close, Function | SmallTest | Level1)
487 {
488     sptr<WindowOption> option = new (std::nothrow) WindowOption();
489     ASSERT_NE(option, nullptr);
490     option->SetWindowName("Close");
491     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
492     ASSERT_NE(window, nullptr);
493 
494     window->state_ = WindowState::STATE_CREATED;
495     window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
496     ASSERT_EQ(window->Close(), WMError::WM_OK);
497 
498     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
499     window->context_ = context;
500     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
501     window->Close();
502     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
503 }
504 
505 /**
506  * @tc.name: GetVSyncPeriod
507  * @tc.desc: GetVSyncPeriod test
508  * @tc.type: FUNC
509  */
510 HWTEST_F(WindowImplTest5, GetVSyncPeriod, Function | SmallTest | Level1)
511 {
512     sptr<WindowOption> option = new (std::nothrow) WindowOption();
513     ASSERT_NE(option, nullptr);
514     option->SetWindowName("GetVSyncPeriod");
515     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
516     ASSERT_NE(window, nullptr);
517 
518     window->SetWindowState(WindowState::STATE_DESTROYED);
519     ASSERT_EQ(window->GetWindowState(), WindowState::STATE_DESTROYED);
520     SingletonContainer::GetInstance().destroyed_ = true;
521     ASSERT_EQ(window->GetVSyncPeriod(), 0);
522 
523     SingletonContainer::GetInstance().destroyed_ = false;
524     window->vsyncStation_ = std::make_shared<VsyncStation>(1);
525     window->GetVSyncPeriod();
526 
527     window->vsyncStation_ = nullptr;
528     ASSERT_EQ(window->GetVSyncPeriod(), 0);
529 }
530 
531 /**
532  * @tc.name: RequestVsync02
533  * @tc.desc: RequestVsync test
534  * @tc.type: FUNC
535  */
536 HWTEST_F(WindowImplTest5, RequestVsync02, Function | SmallTest | Level1)
537 {
538     sptr<WindowOption> option = new (std::nothrow) WindowOption();
539     ASSERT_NE(option, nullptr);
540     option->SetWindowName("RequestVsync02");
541     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
542     ASSERT_NE(window, nullptr);
543 
544     window->state_ = WindowState::STATE_CREATED;
545     std::shared_ptr<VsyncCallback> callback = std::make_shared<VsyncCallback>();
546 
547     SingletonContainer::GetInstance().destroyed_ = true;
548     window->RequestVsync(callback);
549 
550     SingletonContainer::GetInstance().destroyed_ = false;
551     window->vsyncStation_ = std::make_shared<VsyncStation>(1);
552     window->RequestVsync(callback);
553 
554     window->vsyncStation_ = nullptr;
555     window->RequestVsync(callback);
556     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
557 }
558 
559 /**
560  * @tc.name: ConsumePointerEvent02
561  * @tc.desc: ConsumePointerEvent test
562  * @tc.type: FUNC
563  */
564 HWTEST_F(WindowImplTest5, ConsumePointerEvent02, Function | SmallTest | Level1)
565 {
566     sptr<WindowOption> option = new (std::nothrow) WindowOption();
567     ASSERT_NE(option, nullptr);
568     option->SetWindowName("ConsumePointerEvent02");
569     option->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
570     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
571     ASSERT_NE(window, nullptr);
572 
573     Rect rect { 0, 0, 10u, 10u };
574     window->property_->SetWindowRect(rect);
575 
576     std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
577     MMI::PointerEvent::PointerItem item;
578     pointerEvent->SetPointerId(0);
579     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
580     window->ConsumePointerEvent(pointerEvent);
581 
582     item.SetPointerId(0);
583     item.SetDisplayX(15);
584     item.SetDisplayY(15);
585     pointerEvent->AddPointerItem(item);
586     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
587     pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
588     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
589     window->ConsumePointerEvent(pointerEvent);
590 
591     item.SetDisplayX(5);
592     item.SetDisplayY(5);
593     pointerEvent->UpdatePointerItem(0, item);
594     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
595     window->ConsumePointerEvent(pointerEvent);
596 
597     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
598     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
599     window->ConsumePointerEvent(pointerEvent);
600 
601     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
602     window->ConsumePointerEvent(pointerEvent);
603 
604     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
605     window->ConsumePointerEvent(pointerEvent);
606 
607     window->property_->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
608     window->ConsumePointerEvent(pointerEvent);
609 }
610 
611 /**
612  * @tc.name: PerfLauncherHotAreaIfNeed
613  * @tc.desc: PerfLauncherHotAreaIfNeed test
614  * @tc.type: FUNC
615  */
616 HWTEST_F(WindowImplTest5, PerfLauncherHotAreaIfNeed, Function | SmallTest | Level1)
617 {
618     sptr<WindowOption> option = new (std::nothrow) WindowOption();
619     ASSERT_NE(option, nullptr);
620     option->SetWindowName("PerfLauncherHotAreaIfNeed");
621     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
622     ASSERT_NE(window, nullptr);
623 
624     std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
625     pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
626     pointerEvent->SetPointerId(0);
627 
628     SingletonContainer::GetInstance().destroyed_ = true;
629     window->PerfLauncherHotAreaIfNeed(pointerEvent);
630 
631     SingletonContainer::GetInstance().destroyed_ = false;
632     window->PerfLauncherHotAreaIfNeed(pointerEvent);
633 }
634 
635 /**
636  * @tc.name: NotifyOccupiedAreaChange
637  * @tc.desc: NotifyOccupiedAreaChange test
638  * @tc.type: FUNC
639  */
640 HWTEST_F(WindowImplTest5, NotifyOccupiedAreaChange, Function | SmallTest | Level1)
641 {
642     sptr<WindowOption> option = new (std::nothrow) WindowOption();
643     ASSERT_NE(option, nullptr);
644     option->SetWindowName("NotifyOccupiedAreaChange");
645     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
646     ASSERT_NE(window, nullptr);
647 
648     sptr<MockOccupiedAreaChangeListener> listener;
649     window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener);
650     listener = new (std::nothrow) MockOccupiedAreaChangeListener();
651     ASSERT_NE(listener, nullptr);
652     window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener);
653     EXPECT_CALL(*listener, OnSizeChange(_, _));
654     sptr<OccupiedAreaChangeInfo> info = new (std::nothrow) OccupiedAreaChangeInfo();
655     ASSERT_NE(info, nullptr);
656     std::shared_ptr<RSTransaction> rsTransaction;
657     window->NotifyOccupiedAreaChange(info, rsTransaction);
658     window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
659 }
660 
661 /**
662  * @tc.name: NotifyDragEvent
663  * @tc.desc: NotifyDragEvent test
664  * @tc.type: FUNC
665  */
666 HWTEST_F(WindowImplTest5, NotifyDragEvent, Function | SmallTest | Level1)
667 {
668     sptr<WindowOption> option = new (std::nothrow) WindowOption();
669     ASSERT_NE(option, nullptr);
670     option->SetWindowName("NotifyDragEvent");
671     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
672     ASSERT_NE(window, nullptr);
673 
674     sptr<MockWindowDragListener> listener;
675     window->windowDragListeners_.push_back(listener);
676     listener = new (std::nothrow) MockWindowDragListener();
677     ASSERT_NE(listener, nullptr);
678     window->windowDragListeners_.push_back(listener);
679     EXPECT_CALL(*listener, OnDrag(_, _, _));
680     PointInfo point({10, 20});
681     window->NotifyDragEvent(point, DragEvent::DRAG_EVENT_OUT);
682     window->windowDragListeners_.clear();
683 }
684 
685 /**
686  * @tc.name: TransferPointerEvent02
687  * @tc.desc: TransferPointerEvent test
688  * @tc.type: FUNC
689  */
690 HWTEST_F(WindowImplTest5, TransferPointerEvent02, Function | SmallTest | Level1)
691 {
692     sptr<WindowOption> option = new (std::nothrow) WindowOption();
693     ASSERT_NE(option, nullptr);
694     option->SetWindowName("TransferPointerEvent02");
695     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
696     ASSERT_NE(window, nullptr);
697 
698     window->TransferPointerEvent(nullptr);
699 
700     window->windowSystemConfig_.isStretchable_ = true;
701     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
702 
703     std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
704     window->TransferPointerEvent(pointerEvent);
705 }
706 
707 /**
708  * @tc.name: ReadyToMoveOrDragWindow
709  * @tc.desc: ReadyToMoveOrDragWindow test
710  * @tc.type: FUNC
711  */
712 HWTEST_F(WindowImplTest5, ReadyToMoveOrDragWindow, Function | SmallTest | Level1)
713 {
714     sptr<WindowOption> option = new (std::nothrow) WindowOption();
715     ASSERT_NE(option, nullptr);
716     option->SetWindowName("ReadyToMoveOrDragWindow");
717     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
718     ASSERT_NE(window, nullptr);
719 
720     window->moveDragProperty_->pointEventStarted_ = false;
721     std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
722     MMI::PointerEvent::PointerItem item;
723     SingletonContainer::GetInstance().destroyed_ = true;
724     window->ReadyToMoveOrDragWindow(pointerEvent, item);
725 
726     SingletonContainer::GetInstance().destroyed_ = false;
727     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
728     window->ReadyToMoveOrDragWindow(pointerEvent, item);
729 
730     window->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
731     window->ReadyToMoveOrDragWindow(pointerEvent, item);
732 
733     window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
734     window->ReadyToMoveOrDragWindow(pointerEvent, item);
735 }
736 
737 /**
738  * @tc.name: StartMove04
739  * @tc.desc: StartMove test
740  * @tc.type: FUNC
741  */
742 HWTEST_F(WindowImplTest5, StartMove04, Function | SmallTest | Level1)
743 {
744     sptr<WindowOption> option = new (std::nothrow) WindowOption();
745     ASSERT_NE(option, nullptr);
746     option->SetWindowName("StartMove04");
747     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
748     ASSERT_NE(window, nullptr);
749 
750     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
751     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
752     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
753     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
754     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
755     window->moveDragProperty_->pointEventStarted_ = true;
756     window->moveDragProperty_->startDragFlag_ = false;
757     window->StartMove();
758 
759     window->moveDragProperty_->startDragFlag_ = true;
760     window->StartMove();
761 
762     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
763     ASSERT_EQ(WMError::WM_OK, window->Destroy());
764 }
765 
766 /**
767  * @tc.name: IsPointInDragHotZone
768  * @tc.desc: IsPointInDragHotZone test
769  * @tc.type: FUNC
770  */
771 HWTEST_F(WindowImplTest5, IsPointInDragHotZone, Function | SmallTest | Level1)
772 {
773     sptr<WindowOption> option = new (std::nothrow) WindowOption();
774     ASSERT_NE(option, nullptr);
775     option->SetWindowName("IsPointInDragHotZone");
776     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
777     ASSERT_NE(window, nullptr);
778 
779     Rect rect{ 10, 10, 10, 10 };
780     window->property_->SetWindowRect(rect);
781     window->moveDragProperty_->startRectExceptFrame_ = { 6, 6, 18, 18 };
782     window->moveDragProperty_->startRectExceptCorner_ = { 6, 6, 18, 18 };
783     ASSERT_EQ(window->IsPointInDragHotZone(6, 6, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
784 
785     ASSERT_EQ(window->IsPointInDragHotZone(5, 5, MMI::PointerEvent::SOURCE_TYPE_MOUSE), false);
786 
787     ASSERT_EQ(window->IsPointInDragHotZone(5, 5, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
788 
789     ASSERT_EQ(window->IsPointInDragHotZone(10, 10, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), false);
790 
791     window->moveDragProperty_->startRectExceptCorner_ = { 16, 16, 18, 18 };
792     ASSERT_EQ(window->IsPointInDragHotZone(10, 10, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
793 }
794 
795 /**
796  * @tc.name: CalculateStartRectExceptHotZone
797  * @tc.desc: CalculateStartRectExceptHotZone test
798  * @tc.type: FUNC
799  */
800 HWTEST_F(WindowImplTest5, CalculateStartRectExceptHotZone, Function | SmallTest | Level1)
801 {
802     sptr<WindowOption> option = new (std::nothrow) WindowOption();
803     ASSERT_NE(option, nullptr);
804     option->SetWindowName("CalculateStartRectExceptHotZone");
805     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
806     ASSERT_NE(window, nullptr);
807 
808     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
809     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
810     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
811 
812     window->property_->SetDisplayZoomState(true);
813     window->property_->SetTransform(Transform::Identity());
814     window->CalculateStartRectExceptHotZone(1.0);
815 
816     window->property_->SetDisplayZoomState(false);
817     window->CalculateStartRectExceptHotZone(1.0);
818     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
819     ASSERT_EQ(WMError::WM_OK, window->Destroy());
820 }
821 
822 /**
823  * @tc.name: PendingClose02
824  * @tc.desc: PendingClose test
825  * @tc.type: FUNC
826  */
827 HWTEST_F(WindowImplTest5, PendingClose02, Function | SmallTest | Level1)
828 {
829     sptr<WindowOption> option = new (std::nothrow) WindowOption();
830     ASSERT_NE(option, nullptr);
831     option->SetWindowName("PendingClose02");
832     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
833     ASSERT_NE(window, nullptr);
834 
835     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
836     window->context_ = nullptr;
837     window->PendingClose();
838 }
839 
840 /**
841  * @tc.name: Recover03
842  * @tc.desc: Recover test
843  * @tc.type: FUNC
844  */
845 HWTEST_F(WindowImplTest5, Recover03, Function | SmallTest | Level1)
846 {
847     sptr<WindowOption> option = new (std::nothrow) WindowOption();
848     ASSERT_NE(option, nullptr);
849     option->SetWindowName("Recover03");
850     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
851     ASSERT_NE(window, nullptr);
852 
853     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
854     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
855     window->Create(INVALID_WINDOW_ID);
856     window->state_ = WindowState::STATE_CREATED;
857     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
858     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
859     window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
860     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
861     ASSERT_EQ(window->Recover(), WMError::WM_OK);
862 
863     window->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
864     ASSERT_EQ(window->Recover(), WMError::WM_OK);
865     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
866     ASSERT_EQ(WMError::WM_OK, window->Destroy());
867 }
868 
869 /**
870  * @tc.name: Minimize03
871  * @tc.desc: Minimize test
872  * @tc.type: FUNC
873  */
874 HWTEST_F(WindowImplTest5, Minimize03, Function | SmallTest | Level1)
875 {
876     sptr<WindowOption> option = new (std::nothrow) WindowOption();
877     ASSERT_NE(option, nullptr);
878     option->SetWindowName("Minimize03");
879     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
880     ASSERT_NE(window, nullptr);
881 
882     window->state_ = WindowState::STATE_CREATED;
883     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
884     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
885     window->context_ = context;
886     window->Minimize();
887     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
888 }
889 
890 /**
891  * @tc.name: RegisterListener
892  * @tc.desc: UnregisterListener | RegisterListener desc
893  * @tc.type: FUNC
894  */
895 HWTEST_F(WindowImplTest5, RegisterListener, Function | SmallTest | Level1)
896 {
897     sptr<WindowOption> option = new (std::nothrow) WindowOption();
898     ASSERT_NE(option, nullptr);
899     option->SetWindowName("RegisterListener");
900     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
901     ASSERT_NE(window, nullptr);
902 
903     sptr<MockOccupiedAreaChangeListener> listener1;
904     window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
905     sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
906     ASSERT_NE(listener2, nullptr);
907     window->UnregisterOccupiedAreaChangeListener(nullptr);
908     window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener2);
909     window->RegisterOccupiedAreaChangeListener(listener2);
910     window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
911 }
912 
913 /**
914  * @tc.name: SetImmersiveModeEnabledState02
915  * @tc.desc: SetImmersiveModeEnabledState test
916  * @tc.type: FUNC
917  */
918 HWTEST_F(WindowImplTest5, SetImmersiveModeEnabledState02, Function | SmallTest | Level1)
919 {
920     sptr<WindowOption> option = new (std::nothrow) WindowOption();
921     ASSERT_NE(option, nullptr);
922     option->SetWindowName("SetImmersiveModeEnabledState02");
923     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
924     ASSERT_NE(window, nullptr);
925 
926     window->state_ = WindowState::STATE_INITIAL;
927     EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_ERROR_INVALID_WINDOW);
928 
929     window->state_ = WindowState::STATE_CREATED;
930     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
931 
932     window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
933     EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_ERROR_INVALID_WINDOW);
934 
935     window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
936     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
937     EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_OK);
938     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
939 }
940 
941 /**
942  * @tc.name: SetGlobalMaximizeMode
943  * @tc.desc: SetGlobalMaximizeMode test
944  * @tc.type: FUNC
945  */
946 HWTEST_F(WindowImplTest5, SetGlobalMaximizeMode, Function | SmallTest | Level1)
947 {
948     sptr<WindowOption> option = new (std::nothrow) WindowOption();
949     ASSERT_NE(option, nullptr);
950     option->SetWindowName("SetGlobalMaximizeMode");
951     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
952     ASSERT_NE(window, nullptr);
953 
954     window->state_ = WindowState::STATE_INITIAL;
955     EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_ERROR_INVALID_WINDOW);
956 
957     window->state_ = WindowState::STATE_CREATED;
958     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
959     EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_OK);
960 
961     window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
962     EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_ERROR_INVALID_PARAM);
963     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
964 }
965 
966 /**
967  * @tc.name: MaximizeFloating02
968  * @tc.desc: MaximizeFloating test
969  * @tc.type: FUNC
970  */
971 HWTEST_F(WindowImplTest5, MaximizeFloating02, Function | SmallTest | Level1)
972 {
973     sptr<WindowOption> option = new (std::nothrow) WindowOption();
974     ASSERT_NE(option, nullptr);
975     option->SetWindowName("MaximizeFloating02");
976     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
977     ASSERT_NE(window, nullptr);
978 
979     window->state_ = WindowState::STATE_CREATED;
980     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
981     window->MaximizeFloating();
982     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
983 }
984 
985 /**
986  * @tc.name: SetCallingWindow
987  * @tc.desc: SetCallingWindow test
988  * @tc.type: FUNC
989  */
990 HWTEST_F(WindowImplTest5, SetCallingWindow, Function | SmallTest | Level1)
991 {
992     sptr<WindowOption> option = new (std::nothrow) WindowOption();
993     ASSERT_NE(option, nullptr);
994     option->SetWindowName("SetCallingWindow");
995     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
996     ASSERT_NE(window, nullptr);
997 
998     window->state_ = WindowState::STATE_INITIAL;
999     window->SetCallingWindow(1);
1000 }
1001 
1002 /**
1003  * @tc.name: Resize
1004  * @tc.desc: Resize test
1005  * @tc.type: FUNC
1006  */
1007 HWTEST_F(WindowImplTest5, Resize, Function | SmallTest | Level1)
1008 {
1009     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1010     ASSERT_NE(option, nullptr);
1011     option->SetWindowName("Resize");
1012     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1013     ASSERT_NE(window, nullptr);
1014 
1015     window->state_ = WindowState::STATE_CREATED;
1016     EXPECT_EQ(window->Resize(10, 10), WMError::WM_OK);
1017 
1018     window->state_ = WindowState::STATE_HIDDEN;
1019     EXPECT_EQ(window->Resize(10, 10), WMError::WM_OK);
1020 
1021     window->state_ = WindowState::STATE_SHOWN;
1022     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1023     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1024     EXPECT_EQ(window->Resize(10, 10), WMError::WM_ERROR_INVALID_OPERATION);
1025 
1026     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1027     window->Resize(10, 10);
1028     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1029 }
1030 
1031 /**
1032  * @tc.name: MoveTo
1033  * @tc.desc: MoveTo test
1034  * @tc.type: FUNC
1035  */
1036 HWTEST_F(WindowImplTest5, MoveTo, Function | SmallTest | Level1)
1037 {
1038     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1039     ASSERT_NE(option, nullptr);
1040     option->SetWindowName("MoveTo");
1041     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1042     ASSERT_NE(window, nullptr);
1043 
1044     window->state_ = WindowState::STATE_CREATED;
1045     EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_OK);
1046 
1047     window->state_ = WindowState::STATE_HIDDEN;
1048     EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_OK);
1049 
1050     window->state_ = WindowState::STATE_SHOWN;
1051     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1052     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1053     EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_ERROR_INVALID_OPERATION);
1054 
1055     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1056     window->MoveTo(10, 10);
1057     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1058 }
1059 
1060 /**
1061  * @tc.name: AdjustWindowAnimationFlag
1062  * @tc.desc: AdjustWindowAnimationFlag test
1063  * @tc.type: FUNC
1064  */
1065 HWTEST_F(WindowImplTest5, AdjustWindowAnimationFlag, Function | SmallTest | Level1)
1066 {
1067     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1068     ASSERT_NE(option, nullptr);
1069     option->SetWindowName("AdjustWindowAnimationFlag");
1070     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1071     ASSERT_NE(window, nullptr);
1072 
1073     window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1074     sptr<IAnimationTransitionController> animationTransitionController = new (std::nothrow)
1075         IAnimationTransitionController();
1076     ASSERT_NE(animationTransitionController, nullptr);
1077     window->animationTransitionController_ = animationTransitionController;
1078 
1079     window->AdjustWindowAnimationFlag(true);
1080 
1081     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1082     window->needDefaultAnimation_ = true;
1083     window->AdjustWindowAnimationFlag(true);
1084 
1085     window->animationTransitionController_ = nullptr;
1086     window->needDefaultAnimation_ = false;
1087     window->AdjustWindowAnimationFlag(true);
1088 
1089     window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1090     window->AdjustWindowAnimationFlag(false);
1091 }
1092 
1093 /**
1094  * @tc.name: NeedToStopShowing
1095  * @tc.desc: NeedToStopShowing test
1096  * @tc.type: FUNC
1097  */
1098 HWTEST_F(WindowImplTest5, NeedToStopShowing, Function | SmallTest | Level1)
1099 {
1100     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1101     ASSERT_NE(option, nullptr);
1102     option->SetWindowName("NeedToStopShowing");
1103     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1104     ASSERT_NE(window, nullptr);
1105 
1106     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1107     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1108     EXPECT_EQ(window->NeedToStopShowing(), true);
1109 
1110     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY);
1111     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1112     window->property_->SetWindowFlags(1 << 2);
1113     EXPECT_EQ(window->NeedToStopShowing(), false);
1114 
1115     window->property_->SetWindowFlags(1);
1116     EXPECT_EQ(window->NeedToStopShowing(), false);
1117 }
1118 
1119 /**
1120  * @tc.name: DestroyFloatingWindow
1121  * @tc.desc: DestroyFloatingWindow test
1122  * @tc.type: FUNC
1123  */
1124 HWTEST_F(WindowImplTest5, DestroyFloatingWindow, Function | SmallTest | Level1)
1125 {
1126     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1127     ASSERT_NE(option, nullptr);
1128     option->SetWindowName("DestroyFloatingWindow");
1129     option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1130     option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
1131     option->SetWindowRect({ 1, 1, 1, 1 });
1132     option->SetBundleName("OK");
1133     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1134     ASSERT_NE(window, nullptr);
1135     window->DestroyFloatingWindow();
1136 
1137     std::map<uint32_t, std::vector<sptr<WindowImpl>>> appFloatingWindowMap;
1138     sptr<WindowImpl> windowImpl = new (std::nothrow) WindowImpl(option);
1139     ASSERT_NE(windowImpl, nullptr);
1140     std::vector<sptr<WindowImpl>> v;
1141     std::vector<sptr<WindowImpl>> v2;
1142     v.push_back(windowImpl);
1143     appFloatingWindowMap.insert({0, v});
1144     appFloatingWindowMap.insert({0, v2});
1145     window->appFloatingWindowMap_ = appFloatingWindowMap;
1146     window->DestroyFloatingWindow();
1147 }
1148 
1149 /**
1150  * @tc.name: DestroyDialogWindow
1151  * @tc.desc: DestroyDialogWindow test
1152  * @tc.type: FUNC
1153  */
1154 HWTEST_F(WindowImplTest5, DestroyDialogWindow, Function | SmallTest | Level1)
1155 {
1156     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1157     ASSERT_NE(option, nullptr);
1158     option->SetWindowName("DestroyDialogWindow");
1159     option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1160     option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
1161     option->SetWindowRect({ 1, 1, 1, 1 });
1162     option->SetBundleName("OK");
1163     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1164     ASSERT_NE(window, nullptr);
1165     window->DestroyFloatingWindow();
1166 
1167     std::map<uint32_t, std::vector<sptr<WindowImpl>>> appDialogWindowMap;
1168     sptr<WindowImpl> windowImpl = new (std::nothrow) WindowImpl(option);
1169     ASSERT_NE(windowImpl, nullptr);
1170     std::vector<sptr<WindowImpl>> v;
1171     std::vector<sptr<WindowImpl>> v2;
1172     v.push_back(windowImpl);
1173     appDialogWindowMap.insert({0, v});
1174     appDialogWindowMap.insert({0, v2});
1175     window->appDialogWindowMap_ = appDialogWindowMap;
1176     window->DestroyFloatingWindow();
1177 }
1178 
1179 /**
1180  * @tc.name: GetOriginalAbilityInfo
1181  * @tc.desc: GetOriginalAbilityInfo test
1182  * @tc.type: FUNC
1183  */
1184 HWTEST_F(WindowImplTest5, GetOriginalAbilityInfo, Function | SmallTest | Level1)
1185 {
1186     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1187     ASSERT_NE(option, nullptr);
1188     option->SetWindowName("GetOriginalAbilityInfo");
1189     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1190     ASSERT_NE(window, nullptr);
1191 
1192     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1193     window->context_ = context;
1194     window->GetOriginalAbilityInfo();
1195 }
1196 
1197 /**
1198  * @tc.name: WindowCreateCheck05
1199  * @tc.desc: WindowCreateCheck test
1200  * @tc.type: FUNC
1201  */
1202 HWTEST_F(WindowImplTest5, WindowCreateCheck05, Function | SmallTest | Level1)
1203 {
1204     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1205     ASSERT_NE(option, nullptr);
1206     option->SetWindowName("WindowCreateCheck05");
1207     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1208     ASSERT_NE(window, nullptr);
1209 
1210     window->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
1211     EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_OK);
1212 
1213     window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1214     EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_ERROR_INVALID_PARENT);
1215 
1216     window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
1217     sptr<WindowImpl> windowImpl1 = new (std::nothrow) WindowImpl(option);
1218     ASSERT_NE(windowImpl1, nullptr);
1219     windowImpl1->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
1220     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl1)));
1221     EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_ERROR_REPEAT_OPERATION);
1222 
1223     window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1224     sptr<WindowImpl> windowImpl2 = new (std::nothrow) WindowImpl(option);
1225     ASSERT_NE(windowImpl2, nullptr);
1226     windowImpl2->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1227     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(0, windowImpl2)));
1228     EXPECT_EQ(window->WindowCreateCheck(0), WMError::WM_ERROR_INVALID_PARENT);
1229 
1230     sptr<WindowImpl> windowImpl3 = new (std::nothrow) WindowImpl(option);
1231     ASSERT_NE(windowImpl3, nullptr);
1232     windowImpl3->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1233     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl3)));
1234     EXPECT_EQ(window->WindowCreateCheck(1), WMError::WM_OK);
1235 }
1236 
1237 /**
1238  * @tc.name: IsAppMainOrSubOrFloatingWindow
1239  * @tc.desc: IsAppMainOrSubOrFloatingWindow test
1240  * @tc.type: FUNC
1241  */
1242 HWTEST_F(WindowImplTest5, IsAppMainOrSubOrFloatingWindow, Function | SmallTest | Level1)
1243 {
1244     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1245     ASSERT_NE(option, nullptr);
1246     option->SetWindowName("IsAppMainOrSubOrFloatingWindow");
1247     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1248     ASSERT_NE(window, nullptr);
1249 
1250     window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1251     EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1252 
1253     window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1254     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, nullptr)));
1255     EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1256 
1257     sptr<WindowImpl> windowImpl1 = new (std::nothrow) WindowImpl(option);
1258     ASSERT_NE(windowImpl1, nullptr);
1259     windowImpl1->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1260     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl1)));
1261     EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1262 
1263     sptr<WindowImpl> windowImpl2 = new (std::nothrow) WindowImpl(option);
1264     ASSERT_NE(windowImpl2, nullptr);
1265     windowImpl2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1266     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl2)));
1267     EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1268 
1269     sptr<WindowImpl> windowImpl3 = new (std::nothrow) WindowImpl(option);
1270     ASSERT_NE(windowImpl3, nullptr);
1271     windowImpl3->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1272     std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1273     window->context_ = context;
1274     windowImpl3->context_ = context;
1275     WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl3)));
1276     EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1277 }
1278 
1279 /**
1280  * @tc.name: UpdateTitleButtonVisibility02
1281  * @tc.desc: UpdateTitleButtonVisibility test
1282  * @tc.type: FUNC
1283  */
1284 HWTEST_F(WindowImplTest5, UpdateTitleButtonVisibility02, Function | SmallTest | Level1)
1285 {
1286     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1287     ASSERT_NE(option, nullptr);
1288     option->SetWindowName("UpdateTitleButtonVisibility02");
1289     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1290     ASSERT_NE(window, nullptr);
1291 
1292     window->uiContent_ = nullptr;
1293     window->UpdateTitleButtonVisibility();
1294 
1295     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1296     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1297     EXPECT_CALL(*content, HideWindowTitleButton(_, _, _, _));
1298     window->windowSystemConfig_.isSystemDecorEnable_ = false;
1299     window->UpdateTitleButtonVisibility();
1300 
1301     window->windowSystemConfig_.isSystemDecorEnable_ = true;
1302     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1303     window->UpdateTitleButtonVisibility();
1304 }
1305 
1306 /**
1307  * @tc.name: GetConfigurationFromAbilityInfo02
1308  * @tc.desc: GetConfigurationFromAbilityInfo test
1309  * @tc.type: FUNC
1310  */
1311 HWTEST_F(WindowImplTest5, GetConfigurationFromAbilityInfo02, Function | SmallTest | Level1)
1312 {
1313     sptr<WindowOption> option = new (std::nothrow) WindowOption();
1314     ASSERT_NE(option, nullptr);
1315     option->SetWindowName("GetConfigurationFromAbilityInfo02");
1316     option->SetDisplayId(1);
1317     sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1318     ASSERT_NE(window, nullptr);
1319     ASSERT_EQ(1, window->GetDisplayId());
1320 
1321     std::shared_ptr<AbilityRuntime::AbilityContextImpl> context =
1322         std::make_shared<AbilityRuntime::AbilityContextImpl>();
1323     window->context_ = context;
1324     window->GetConfigurationFromAbilityInfo();
1325 
1326     std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
1327     context->SetAbilityInfo(info);
1328     window->GetConfigurationFromAbilityInfo();
1329 
1330     std::vector<AppExecFwk::SupportWindowMode> supportModes;
1331     supportModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1332     context->GetAbilityInfo()->windowModes = supportModes;
1333     window->GetConfigurationFromAbilityInfo();
1334 }
1335 
1336 /**
1337  * @tc.name: GetVirtualPixelRatio01
1338  * @tc.desc: GetVirtualPixelRatio test
1339  * @tc.type: FUNC
1340  */
1341 HWTEST_F(WindowImplTest5, GetVirtualPixelRatio01, Function | SmallTest | Level1)
1342 {
1343     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1344     option->SetWindowName("GetVirtualPixelRatio01");
1345     option->SetDisplayId(1);
1346     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1347     window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1348     window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1349 
1350     float vpr = 0.0f;
1351     window->property_->SetDisplayId(-1);
1352     vpr = window->GetVirtualPixelRatio();
1353     ASSERT_EQ(vpr, 1.0f);
1354 
1355     window->property_->SetDisplayId(0);
1356     vpr = window->GetVirtualPixelRatio();
1357     ASSERT_NE(vpr, 1.0f);
1358 }
1359 }
1360 } // namespace Rosen
1361 } // namespace OHOS