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
24using namespace testing;
25using namespace testing::ext;
26
27namespace OHOS {
28namespace Rosen {
29using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
30class MockOccupiedAreaChangeListener : public IOccupiedAreaChangeListener {
31public:
32    MOCK_METHOD2(OnSizeChange, void(const sptr<OccupiedAreaChangeInfo>& info,
33        const std::shared_ptr<RSTransaction>& rsTransaction));
34};
35
36class MockMmiPointerEvent : public MMI::PointerEvent {
37public:
38    MockMmiPointerEvent(): MMI::PointerEvent(0) {}
39};
40
41class MockWindowDragListener : public IWindowDragListener {
42public:
43    MOCK_METHOD3(OnDrag, void(int32_t x, int32_t y, DragEvent event));
44};
45
46class WindowImplTest5 : public testing::Test {
47public:
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
55private:
56    static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
57};
58void WindowImplTest5::SetUpTestCase()
59{
60}
61
62void WindowImplTest5::TearDownTestCase()
63{
64}
65
66void WindowImplTest5::SetUp()
67{
68}
69
70void WindowImplTest5::TearDown()
71{
72    usleep(WAIT_SYNC_IN_NS);
73}
74
75namespace {
76/**
77 * @tc.name: IsAllowHaveSystemSubWindow
78 * @tc.desc: IsAllowHaveSystemSubWindow desc
79 * @tc.type: FUNC
80 */
81HWTEST_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 */
106HWTEST_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 */
134HWTEST_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 */
159HWTEST_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 */
181HWTEST_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 */
208HWTEST_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 */
260HWTEST_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 */
306HWTEST_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 */
326HWTEST_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 */
354HWTEST_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 */
403HWTEST_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 */
436HWTEST_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: RegisterListener01
461 * @tc.desc: Run successfully
462 * @tc.type: FUNC
463 */
464HWTEST_F(WindowImplTest5, RegisterListener01, 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    ASSERT_EQ(window->RegisterOccupiedAreaChangeListener(listener2), WMError::WM_OK);
477    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
478}
479
480/**
481 * @tc.name: RegisterListener02
482 * @tc.desc: Listener is nullptr
483 * @tc.type: FUNC
484 */
485HWTEST_F(WindowImplTest5, RegisterListener02, Function | SmallTest | Level1)
486{
487    sptr<WindowOption> option = new (std::nothrow) WindowOption();
488    ASSERT_NE(option, nullptr);
489    option->SetWindowName("UnregisterListener");
490    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
491    ASSERT_NE(window, nullptr);
492
493    sptr<MockOccupiedAreaChangeListener> listener1;
494    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
495    sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
496    ASSERT_NE(listener2, nullptr);
497    ASSERT_EQ(window->RegisterOccupiedAreaChangeListener(nullptr), WMError::WM_ERROR_NULLPTR);
498    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
499}
500
501/**
502 * @tc.name: UnregisterListener01
503 * @tc.desc: Run successfully
504 * @tc.type: FUNC
505 */
506HWTEST_F(WindowImplTest5, UnregisterListener01, Function | SmallTest | Level1)
507{
508    sptr<WindowOption> option = new (std::nothrow) WindowOption();
509    ASSERT_NE(option, nullptr);
510    option->SetWindowName("UnregisterListener");
511    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
512    ASSERT_NE(window, nullptr);
513
514    sptr<MockOccupiedAreaChangeListener> listener1;
515    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
516    sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
517    ASSERT_NE(listener2, nullptr);
518    window->RegisterOccupiedAreaChangeListener(listener2);
519    ASSERT_EQ(window->UnregisterOccupiedAreaChangeListener(listener2), WMError::WM_OK);
520    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
521}
522
523/**
524 * @tc.name: UnregisterListener02
525 * @tc.desc: Listener is nullptr
526 * @tc.type: FUNC
527 */
528HWTEST_F(WindowImplTest5, UnregisterListener02, Function | SmallTest | Level1)
529{
530    sptr<WindowOption> option = new (std::nothrow) WindowOption();
531    ASSERT_NE(option, nullptr);
532    option->SetWindowName("UnregisterListener");
533    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
534    ASSERT_NE(window, nullptr);
535
536    sptr<MockOccupiedAreaChangeListener> listener1;
537    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
538    sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
539    ASSERT_NE(listener2, nullptr);
540    ASSERT_EQ(window->UnregisterOccupiedAreaChangeListener(nullptr), WMError::WM_ERROR_NULLPTR);
541    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
542}
543
544/**
545 * @tc.name: Close
546 * @tc.desc: Close test
547 * @tc.type: FUNC
548 */
549HWTEST_F(WindowImplTest5, Close, Function | SmallTest | Level1)
550{
551    sptr<WindowOption> option = new (std::nothrow) WindowOption();
552    ASSERT_NE(option, nullptr);
553    option->SetWindowName("Close");
554    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
555    ASSERT_NE(window, nullptr);
556
557    window->state_ = WindowState::STATE_CREATED;
558    window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
559    ASSERT_EQ(window->Close(), WMError::WM_OK);
560
561    std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
562    window->context_ = context;
563    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
564    window->Close();
565    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
566}
567
568/**
569 * @tc.name: GetVSyncPeriod
570 * @tc.desc: GetVSyncPeriod test
571 * @tc.type: FUNC
572 */
573HWTEST_F(WindowImplTest5, GetVSyncPeriod, Function | SmallTest | Level1)
574{
575    sptr<WindowOption> option = new (std::nothrow) WindowOption();
576    ASSERT_NE(option, nullptr);
577    option->SetWindowName("GetVSyncPeriod");
578    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
579    ASSERT_NE(window, nullptr);
580
581    window->SetWindowState(WindowState::STATE_DESTROYED);
582    ASSERT_EQ(window->GetWindowState(), WindowState::STATE_DESTROYED);
583    SingletonContainer::GetInstance().destroyed_ = true;
584    ASSERT_EQ(window->GetVSyncPeriod(), 0);
585
586    SingletonContainer::GetInstance().destroyed_ = false;
587    window->vsyncStation_ = std::make_shared<VsyncStation>(1);
588    window->GetVSyncPeriod();
589
590    window->vsyncStation_ = nullptr;
591    ASSERT_EQ(window->GetVSyncPeriod(), 0);
592}
593
594/**
595 * @tc.name: RequestVsync02
596 * @tc.desc: RequestVsync test
597 * @tc.type: FUNC
598 */
599HWTEST_F(WindowImplTest5, RequestVsync02, Function | SmallTest | Level1)
600{
601    sptr<WindowOption> option = new (std::nothrow) WindowOption();
602    ASSERT_NE(option, nullptr);
603    option->SetWindowName("RequestVsync02");
604    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
605    ASSERT_NE(window, nullptr);
606
607    window->state_ = WindowState::STATE_CREATED;
608    std::shared_ptr<VsyncCallback> callback = std::make_shared<VsyncCallback>();
609
610    SingletonContainer::GetInstance().destroyed_ = true;
611    window->RequestVsync(callback);
612
613    SingletonContainer::GetInstance().destroyed_ = false;
614    window->vsyncStation_ = std::make_shared<VsyncStation>(1);
615    window->RequestVsync(callback);
616
617    window->vsyncStation_ = nullptr;
618    window->RequestVsync(callback);
619    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
620}
621
622/**
623 * @tc.name: ConsumePointerEvent02
624 * @tc.desc: ConsumePointerEvent test
625 * @tc.type: FUNC
626 */
627HWTEST_F(WindowImplTest5, ConsumePointerEvent02, Function | SmallTest | Level1)
628{
629    sptr<WindowOption> option = new (std::nothrow) WindowOption();
630    ASSERT_NE(option, nullptr);
631    option->SetWindowName("ConsumePointerEvent02");
632    option->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
633    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
634    ASSERT_NE(window, nullptr);
635
636    Rect rect { 0, 0, 10u, 10u };
637    window->property_->SetWindowRect(rect);
638
639    std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
640    MMI::PointerEvent::PointerItem item;
641    pointerEvent->SetPointerId(0);
642    pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
643    window->ConsumePointerEvent(pointerEvent);
644
645    item.SetPointerId(0);
646    item.SetDisplayX(15);
647    item.SetDisplayY(15);
648    pointerEvent->AddPointerItem(item);
649    pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
650    pointerEvent->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
651    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
652    window->ConsumePointerEvent(pointerEvent);
653
654    item.SetDisplayX(5);
655    item.SetDisplayY(5);
656    pointerEvent->UpdatePointerItem(0, item);
657    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
658    window->ConsumePointerEvent(pointerEvent);
659
660    pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
661    window->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
662    window->ConsumePointerEvent(pointerEvent);
663
664    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
665    window->ConsumePointerEvent(pointerEvent);
666
667    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
668    window->ConsumePointerEvent(pointerEvent);
669
670    window->property_->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
671    window->ConsumePointerEvent(pointerEvent);
672}
673
674/**
675 * @tc.name: PerfLauncherHotAreaIfNeed
676 * @tc.desc: PerfLauncherHotAreaIfNeed test
677 * @tc.type: FUNC
678 */
679HWTEST_F(WindowImplTest5, PerfLauncherHotAreaIfNeed, Function | SmallTest | Level1)
680{
681    sptr<WindowOption> option = new (std::nothrow) WindowOption();
682    ASSERT_NE(option, nullptr);
683    option->SetWindowName("PerfLauncherHotAreaIfNeed");
684    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
685    ASSERT_NE(window, nullptr);
686
687    std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
688    pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
689    pointerEvent->SetPointerId(0);
690
691    SingletonContainer::GetInstance().destroyed_ = true;
692    window->PerfLauncherHotAreaIfNeed(pointerEvent);
693
694    SingletonContainer::GetInstance().destroyed_ = false;
695    window->PerfLauncherHotAreaIfNeed(pointerEvent);
696}
697
698/**
699 * @tc.name: NotifyOccupiedAreaChange
700 * @tc.desc: NotifyOccupiedAreaChange test
701 * @tc.type: FUNC
702 */
703HWTEST_F(WindowImplTest5, NotifyOccupiedAreaChange, Function | SmallTest | Level1)
704{
705    sptr<WindowOption> option = new (std::nothrow) WindowOption();
706    ASSERT_NE(option, nullptr);
707    option->SetWindowName("NotifyOccupiedAreaChange");
708    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
709    ASSERT_NE(window, nullptr);
710
711    sptr<MockOccupiedAreaChangeListener> listener;
712    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener);
713    listener = new (std::nothrow) MockOccupiedAreaChangeListener();
714    ASSERT_NE(listener, nullptr);
715    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener);
716    EXPECT_CALL(*listener, OnSizeChange(_, _));
717    sptr<OccupiedAreaChangeInfo> info = new (std::nothrow) OccupiedAreaChangeInfo();
718    ASSERT_NE(info, nullptr);
719    std::shared_ptr<RSTransaction> rsTransaction;
720    window->NotifyOccupiedAreaChange(info, rsTransaction);
721    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
722}
723
724/**
725 * @tc.name: NotifyDragEvent
726 * @tc.desc: NotifyDragEvent test
727 * @tc.type: FUNC
728 */
729HWTEST_F(WindowImplTest5, NotifyDragEvent, Function | SmallTest | Level1)
730{
731    sptr<WindowOption> option = new (std::nothrow) WindowOption();
732    ASSERT_NE(option, nullptr);
733    option->SetWindowName("NotifyDragEvent");
734    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
735    ASSERT_NE(window, nullptr);
736
737    sptr<MockWindowDragListener> listener;
738    window->windowDragListeners_.push_back(listener);
739    listener = new (std::nothrow) MockWindowDragListener();
740    ASSERT_NE(listener, nullptr);
741    window->windowDragListeners_.push_back(listener);
742    EXPECT_CALL(*listener, OnDrag(_, _, _));
743    PointInfo point({10, 20});
744    window->NotifyDragEvent(point, DragEvent::DRAG_EVENT_OUT);
745    window->windowDragListeners_.clear();
746}
747
748/**
749 * @tc.name: TransferPointerEvent02
750 * @tc.desc: TransferPointerEvent test
751 * @tc.type: FUNC
752 */
753HWTEST_F(WindowImplTest5, TransferPointerEvent02, Function | SmallTest | Level1)
754{
755    sptr<WindowOption> option = new (std::nothrow) WindowOption();
756    ASSERT_NE(option, nullptr);
757    option->SetWindowName("TransferPointerEvent02");
758    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
759    ASSERT_NE(window, nullptr);
760
761    window->TransferPointerEvent(nullptr);
762
763    window->windowSystemConfig_.isStretchable_ = true;
764    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
765
766    std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
767    window->TransferPointerEvent(pointerEvent);
768}
769
770/**
771 * @tc.name: ReadyToMoveOrDragWindow
772 * @tc.desc: ReadyToMoveOrDragWindow test
773 * @tc.type: FUNC
774 */
775HWTEST_F(WindowImplTest5, ReadyToMoveOrDragWindow, Function | SmallTest | Level1)
776{
777    sptr<WindowOption> option = new (std::nothrow) WindowOption();
778    ASSERT_NE(option, nullptr);
779    option->SetWindowName("ReadyToMoveOrDragWindow");
780    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
781    ASSERT_NE(window, nullptr);
782
783    window->moveDragProperty_->pointEventStarted_ = false;
784    std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockMmiPointerEvent>();
785    MMI::PointerEvent::PointerItem item;
786    SingletonContainer::GetInstance().destroyed_ = true;
787    window->ReadyToMoveOrDragWindow(pointerEvent, item);
788
789    SingletonContainer::GetInstance().destroyed_ = false;
790    window->property_->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
791    window->ReadyToMoveOrDragWindow(pointerEvent, item);
792
793    window->property_->SetMaximizeMode(MaximizeMode::MODE_RECOVER);
794    window->ReadyToMoveOrDragWindow(pointerEvent, item);
795
796    window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
797    window->ReadyToMoveOrDragWindow(pointerEvent, item);
798}
799
800/**
801 * @tc.name: StartMove04
802 * @tc.desc: StartMove test
803 * @tc.type: FUNC
804 */
805HWTEST_F(WindowImplTest5, StartMove04, Function | SmallTest | Level1)
806{
807    sptr<WindowOption> option = new (std::nothrow) WindowOption();
808    ASSERT_NE(option, nullptr);
809    option->SetWindowName("StartMove04");
810    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
811    ASSERT_NE(window, nullptr);
812
813    EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
814    EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
815    ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
816    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
817    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
818    window->moveDragProperty_->pointEventStarted_ = true;
819    window->moveDragProperty_->startDragFlag_ = false;
820    window->StartMove();
821
822    window->moveDragProperty_->startDragFlag_ = true;
823    window->StartMove();
824
825    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
826    ASSERT_EQ(WMError::WM_OK, window->Destroy());
827}
828
829/**
830 * @tc.name: IsPointInDragHotZone
831 * @tc.desc: IsPointInDragHotZone test
832 * @tc.type: FUNC
833 */
834HWTEST_F(WindowImplTest5, IsPointInDragHotZone, Function | SmallTest | Level1)
835{
836    sptr<WindowOption> option = new (std::nothrow) WindowOption();
837    ASSERT_NE(option, nullptr);
838    option->SetWindowName("IsPointInDragHotZone");
839    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
840    ASSERT_NE(window, nullptr);
841
842    Rect rect{ 10, 10, 10, 10 };
843    window->property_->SetWindowRect(rect);
844    window->moveDragProperty_->startRectExceptFrame_ = { 6, 6, 18, 18 };
845    window->moveDragProperty_->startRectExceptCorner_ = { 6, 6, 18, 18 };
846    ASSERT_EQ(window->IsPointInDragHotZone(6, 6, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
847
848    ASSERT_EQ(window->IsPointInDragHotZone(5, 5, MMI::PointerEvent::SOURCE_TYPE_MOUSE), false);
849
850    ASSERT_EQ(window->IsPointInDragHotZone(5, 5, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
851
852    ASSERT_EQ(window->IsPointInDragHotZone(10, 10, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), false);
853
854    window->moveDragProperty_->startRectExceptCorner_ = { 16, 16, 18, 18 };
855    ASSERT_EQ(window->IsPointInDragHotZone(10, 10, MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN), true);
856}
857
858/**
859 * @tc.name: CalculateStartRectExceptHotZone
860 * @tc.desc: CalculateStartRectExceptHotZone test
861 * @tc.type: FUNC
862 */
863HWTEST_F(WindowImplTest5, CalculateStartRectExceptHotZone, Function | SmallTest | Level1)
864{
865    sptr<WindowOption> option = new (std::nothrow) WindowOption();
866    ASSERT_NE(option, nullptr);
867    option->SetWindowName("CalculateStartRectExceptHotZone");
868    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
869    ASSERT_NE(window, nullptr);
870
871    EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
872    EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
873    ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
874
875    window->property_->SetDisplayZoomState(true);
876    window->property_->SetTransform(Transform::Identity());
877    window->CalculateStartRectExceptHotZone(1.0);
878
879    window->property_->SetDisplayZoomState(false);
880    window->CalculateStartRectExceptHotZone(1.0);
881    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
882    ASSERT_EQ(WMError::WM_OK, window->Destroy());
883}
884
885/**
886 * @tc.name: PendingClose02
887 * @tc.desc: PendingClose test
888 * @tc.type: FUNC
889 */
890HWTEST_F(WindowImplTest5, PendingClose02, Function | SmallTest | Level1)
891{
892    sptr<WindowOption> option = new (std::nothrow) WindowOption();
893    ASSERT_NE(option, nullptr);
894    option->SetWindowName("PendingClose02");
895    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
896    ASSERT_NE(window, nullptr);
897
898    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
899    window->context_ = nullptr;
900    window->PendingClose();
901}
902
903/**
904 * @tc.name: Recover03
905 * @tc.desc: Recover test
906 * @tc.type: FUNC
907 */
908HWTEST_F(WindowImplTest5, Recover03, Function | SmallTest | Level1)
909{
910    sptr<WindowOption> option = new (std::nothrow) WindowOption();
911    ASSERT_NE(option, nullptr);
912    option->SetWindowName("Recover03");
913    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
914    ASSERT_NE(window, nullptr);
915
916    EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
917    EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
918    window->Create(INVALID_WINDOW_ID);
919    window->state_ = WindowState::STATE_CREATED;
920    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
921    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
922    window->property_->SetMaximizeMode(MaximizeMode::MODE_AVOID_SYSTEM_BAR);
923    EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
924    ASSERT_EQ(window->Recover(), WMError::WM_OK);
925
926    window->property_->SetMaximizeMode(MaximizeMode::MODE_FULL_FILL);
927    ASSERT_EQ(window->Recover(), WMError::WM_OK);
928    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
929    ASSERT_EQ(WMError::WM_OK, window->Destroy());
930}
931
932/**
933 * @tc.name: Minimize03
934 * @tc.desc: Minimize test
935 * @tc.type: FUNC
936 */
937HWTEST_F(WindowImplTest5, Minimize03, Function | SmallTest | Level1)
938{
939    sptr<WindowOption> option = new (std::nothrow) WindowOption();
940    ASSERT_NE(option, nullptr);
941    option->SetWindowName("Minimize03");
942    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
943    ASSERT_NE(window, nullptr);
944
945    window->state_ = WindowState::STATE_CREATED;
946    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
947    std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
948    window->context_ = context;
949    window->Minimize();
950    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
951}
952
953/**
954 * @tc.name: RegisterListener
955 * @tc.desc: UnregisterListener | RegisterListener desc
956 * @tc.type: FUNC
957 */
958HWTEST_F(WindowImplTest5, RegisterListener, Function | SmallTest | Level1)
959{
960    sptr<WindowOption> option = new (std::nothrow) WindowOption();
961    ASSERT_NE(option, nullptr);
962    option->SetWindowName("RegisterListener");
963    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
964    ASSERT_NE(window, nullptr);
965
966    sptr<MockOccupiedAreaChangeListener> listener1;
967    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener1);
968    sptr<MockOccupiedAreaChangeListener> listener2 = new (std::nothrow) MockOccupiedAreaChangeListener();
969    ASSERT_NE(listener2, nullptr);
970    window->UnregisterOccupiedAreaChangeListener(nullptr);
971    window->occupiedAreaChangeListeners_[window->GetWindowId()].push_back(listener2);
972    window->RegisterOccupiedAreaChangeListener(listener2);
973    window->occupiedAreaChangeListeners_[window->GetWindowId()].clear();
974}
975
976/**
977 * @tc.name: SetImmersiveModeEnabledState02
978 * @tc.desc: SetImmersiveModeEnabledState test
979 * @tc.type: FUNC
980 */
981HWTEST_F(WindowImplTest5, SetImmersiveModeEnabledState02, Function | SmallTest | Level1)
982{
983    sptr<WindowOption> option = new (std::nothrow) WindowOption();
984    ASSERT_NE(option, nullptr);
985    option->SetWindowName("SetImmersiveModeEnabledState02");
986    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
987    ASSERT_NE(window, nullptr);
988
989    window->state_ = WindowState::STATE_INITIAL;
990    EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_ERROR_INVALID_WINDOW);
991
992    window->state_ = WindowState::STATE_CREATED;
993    window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
994
995    window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
996    EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_ERROR_INVALID_WINDOW);
997
998    window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
999    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1000    EXPECT_EQ(window->SetImmersiveModeEnabledState(true), WMError::WM_OK);
1001    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1002}
1003
1004/**
1005 * @tc.name: SetGlobalMaximizeMode
1006 * @tc.desc: SetGlobalMaximizeMode test
1007 * @tc.type: FUNC
1008 */
1009HWTEST_F(WindowImplTest5, SetGlobalMaximizeMode, Function | SmallTest | Level1)
1010{
1011    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1012    ASSERT_NE(option, nullptr);
1013    option->SetWindowName("SetGlobalMaximizeMode");
1014    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1015    ASSERT_NE(window, nullptr);
1016
1017    window->state_ = WindowState::STATE_INITIAL;
1018    EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_ERROR_INVALID_WINDOW);
1019
1020    window->state_ = WindowState::STATE_CREATED;
1021    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1022    EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_OK);
1023
1024    window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1025    EXPECT_EQ(window->SetGlobalMaximizeMode(MaximizeMode::MODE_RECOVER), WMError::WM_ERROR_INVALID_PARAM);
1026    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1027}
1028
1029/**
1030 * @tc.name: MaximizeFloating02
1031 * @tc.desc: MaximizeFloating test
1032 * @tc.type: FUNC
1033 */
1034HWTEST_F(WindowImplTest5, MaximizeFloating02, Function | SmallTest | Level1)
1035{
1036    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1037    ASSERT_NE(option, nullptr);
1038    option->SetWindowName("MaximizeFloating02");
1039    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1040    ASSERT_NE(window, nullptr);
1041
1042    window->state_ = WindowState::STATE_CREATED;
1043    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1044    window->MaximizeFloating();
1045    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1046}
1047
1048/**
1049 * @tc.name: SetCallingWindow
1050 * @tc.desc: SetCallingWindow test
1051 * @tc.type: FUNC
1052 */
1053HWTEST_F(WindowImplTest5, SetCallingWindow, Function | SmallTest | Level1)
1054{
1055    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1056    ASSERT_NE(option, nullptr);
1057    option->SetWindowName("SetCallingWindow");
1058    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1059    ASSERT_NE(window, nullptr);
1060
1061    window->state_ = WindowState::STATE_INITIAL;
1062    window->SetCallingWindow(1);
1063}
1064
1065/**
1066 * @tc.name: Resize
1067 * @tc.desc: Resize test
1068 * @tc.type: FUNC
1069 */
1070HWTEST_F(WindowImplTest5, Resize, Function | SmallTest | Level1)
1071{
1072    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1073    ASSERT_NE(option, nullptr);
1074    option->SetWindowName("Resize");
1075    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1076    ASSERT_NE(window, nullptr);
1077
1078    window->state_ = WindowState::STATE_INITIAL;
1079    EXPECT_EQ(window->Resize(10, 10), WMError::WM_ERROR_INVALID_WINDOW);
1080
1081    window->state_ = WindowState::STATE_CREATED;
1082    EXPECT_EQ(window->Resize(10, 10), WMError::WM_OK);
1083
1084    window->state_ = WindowState::STATE_HIDDEN;
1085    EXPECT_EQ(window->Resize(10, 10), WMError::WM_OK);
1086
1087    window->state_ = WindowState::STATE_SHOWN;
1088    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1089    EXPECT_EQ(window->Resize(10, 10), WMError::WM_ERROR_INVALID_OPERATION);
1090
1091    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1092    EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1093    EXPECT_EQ(window->Resize(10, 10), WMError::WM_OK);
1094    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1095    ASSERT_EQ(WMError::WM_OK, window->Destroy());
1096}
1097
1098/**
1099 * @tc.name: MoveTo
1100 * @tc.desc: MoveTo test
1101 * @tc.type: FUNC
1102 */
1103HWTEST_F(WindowImplTest5, MoveTo, Function | SmallTest | Level1)
1104{
1105    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1106    ASSERT_NE(option, nullptr);
1107    option->SetWindowName("MoveTo");
1108    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1109    ASSERT_NE(window, nullptr);
1110
1111    window->state_ = WindowState::STATE_CREATED;
1112    EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_OK);
1113
1114    window->state_ = WindowState::STATE_HIDDEN;
1115    EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_OK);
1116
1117    window->state_ = WindowState::STATE_SHOWN;
1118    EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1119    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1120    EXPECT_EQ(window->MoveTo(10, 10), WMError::WM_ERROR_INVALID_OPERATION);
1121
1122    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1123    window->MoveTo(10, 10);
1124    EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1125}
1126
1127/**
1128 * @tc.name: AdjustWindowAnimationFlag
1129 * @tc.desc: AdjustWindowAnimationFlag test
1130 * @tc.type: FUNC
1131 */
1132HWTEST_F(WindowImplTest5, AdjustWindowAnimationFlag, Function | SmallTest | Level1)
1133{
1134    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1135    ASSERT_NE(option, nullptr);
1136    option->SetWindowName("AdjustWindowAnimationFlag");
1137    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1138    ASSERT_NE(window, nullptr);
1139
1140    window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1141    sptr<IAnimationTransitionController> animationTransitionController = new (std::nothrow)
1142        IAnimationTransitionController();
1143    ASSERT_NE(animationTransitionController, nullptr);
1144    window->animationTransitionController_ = animationTransitionController;
1145
1146    window->AdjustWindowAnimationFlag(true);
1147
1148    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1149    window->needDefaultAnimation_ = true;
1150    window->AdjustWindowAnimationFlag(true);
1151
1152    window->animationTransitionController_ = nullptr;
1153    window->needDefaultAnimation_ = false;
1154    window->AdjustWindowAnimationFlag(true);
1155
1156    window->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1157    window->AdjustWindowAnimationFlag(false);
1158}
1159
1160/**
1161 * @tc.name: NeedToStopShowing
1162 * @tc.desc: NeedToStopShowing test
1163 * @tc.type: FUNC
1164 */
1165HWTEST_F(WindowImplTest5, NeedToStopShowing, Function | SmallTest | Level1)
1166{
1167    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1168    ASSERT_NE(option, nullptr);
1169    option->SetWindowName("NeedToStopShowing");
1170    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1171    ASSERT_NE(window, nullptr);
1172
1173    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1174    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1175    EXPECT_EQ(window->NeedToStopShowing(), true);
1176
1177    window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_SPLIT_PRIMARY);
1178    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY);
1179    window->property_->SetWindowFlags(1 << 2);
1180    EXPECT_EQ(window->NeedToStopShowing(), false);
1181
1182    window->property_->SetWindowFlags(1);
1183    EXPECT_EQ(window->NeedToStopShowing(), false);
1184}
1185
1186/**
1187 * @tc.name: DestroyFloatingWindow
1188 * @tc.desc: DestroyFloatingWindow test
1189 * @tc.type: FUNC
1190 */
1191HWTEST_F(WindowImplTest5, DestroyFloatingWindow, Function | SmallTest | Level1)
1192{
1193    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1194    ASSERT_NE(option, nullptr);
1195    option->SetWindowName("DestroyFloatingWindow");
1196    option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1197    option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
1198    option->SetWindowRect({ 1, 1, 1, 1 });
1199    option->SetBundleName("OK");
1200    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1201    ASSERT_NE(window, nullptr);
1202    window->DestroyFloatingWindow();
1203
1204    std::map<uint32_t, std::vector<sptr<WindowImpl>>> appFloatingWindowMap;
1205    sptr<WindowImpl> windowImpl = new (std::nothrow) WindowImpl(option);
1206    ASSERT_NE(windowImpl, nullptr);
1207    std::vector<sptr<WindowImpl>> v;
1208    std::vector<sptr<WindowImpl>> v2;
1209    v.push_back(windowImpl);
1210    appFloatingWindowMap.insert({0, v});
1211    appFloatingWindowMap.insert({0, v2});
1212    window->appFloatingWindowMap_ = appFloatingWindowMap;
1213    window->DestroyFloatingWindow();
1214}
1215
1216/**
1217 * @tc.name: DestroyDialogWindow
1218 * @tc.desc: DestroyDialogWindow test
1219 * @tc.type: FUNC
1220 */
1221HWTEST_F(WindowImplTest5, DestroyDialogWindow, Function | SmallTest | Level1)
1222{
1223    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1224    ASSERT_NE(option, nullptr);
1225    option->SetWindowName("DestroyDialogWindow");
1226    option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1227    option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
1228    option->SetWindowRect({ 1, 1, 1, 1 });
1229    option->SetBundleName("OK");
1230    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1231    ASSERT_NE(window, nullptr);
1232    window->DestroyFloatingWindow();
1233
1234    std::map<uint32_t, std::vector<sptr<WindowImpl>>> appDialogWindowMap;
1235    sptr<WindowImpl> windowImpl = new (std::nothrow) WindowImpl(option);
1236    ASSERT_NE(windowImpl, nullptr);
1237    std::vector<sptr<WindowImpl>> v;
1238    std::vector<sptr<WindowImpl>> v2;
1239    v.push_back(windowImpl);
1240    appDialogWindowMap.insert({0, v});
1241    appDialogWindowMap.insert({0, v2});
1242    window->appDialogWindowMap_ = appDialogWindowMap;
1243    window->DestroyFloatingWindow();
1244}
1245
1246/**
1247 * @tc.name: GetOriginalAbilityInfo
1248 * @tc.desc: GetOriginalAbilityInfo test
1249 * @tc.type: FUNC
1250 */
1251HWTEST_F(WindowImplTest5, GetOriginalAbilityInfo, Function | SmallTest | Level1)
1252{
1253    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1254    ASSERT_NE(option, nullptr);
1255    option->SetWindowName("GetOriginalAbilityInfo");
1256    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1257    ASSERT_NE(window, nullptr);
1258
1259    std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1260    window->context_ = context;
1261    window->GetOriginalAbilityInfo();
1262}
1263
1264/**
1265 * @tc.name: WindowCreateCheck05
1266 * @tc.desc: WindowCreateCheck test
1267 * @tc.type: FUNC
1268 */
1269HWTEST_F(WindowImplTest5, WindowCreateCheck05, Function | SmallTest | Level1)
1270{
1271    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1272    ASSERT_NE(option, nullptr);
1273    option->SetWindowName("WindowCreateCheck05");
1274    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1275    ASSERT_NE(window, nullptr);
1276
1277    window->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
1278    EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_OK);
1279
1280    window->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
1281    EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_ERROR_INVALID_PARENT);
1282
1283    window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
1284    sptr<WindowImpl> windowImpl1 = new (std::nothrow) WindowImpl(option);
1285    ASSERT_NE(windowImpl1, nullptr);
1286    windowImpl1->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_CAMERA);
1287    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl1)));
1288    EXPECT_EQ(window->WindowCreateCheck(INVALID_WINDOW_ID), WMError::WM_ERROR_REPEAT_OPERATION);
1289
1290    window->property_->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
1291    sptr<WindowImpl> windowImpl2 = new (std::nothrow) WindowImpl(option);
1292    ASSERT_NE(windowImpl2, nullptr);
1293    windowImpl2->property_->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1294    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(0, windowImpl2)));
1295    EXPECT_EQ(window->WindowCreateCheck(0), WMError::WM_ERROR_INVALID_PARENT);
1296
1297    sptr<WindowImpl> windowImpl3 = new (std::nothrow) WindowImpl(option);
1298    ASSERT_NE(windowImpl3, nullptr);
1299    windowImpl3->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1300    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl3)));
1301    EXPECT_EQ(window->WindowCreateCheck(1), WMError::WM_OK);
1302}
1303
1304/**
1305 * @tc.name: IsAppMainOrSubOrFloatingWindow
1306 * @tc.desc: IsAppMainOrSubOrFloatingWindow test
1307 * @tc.type: FUNC
1308 */
1309HWTEST_F(WindowImplTest5, IsAppMainOrSubOrFloatingWindow, Function | SmallTest | Level1)
1310{
1311    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1312    ASSERT_NE(option, nullptr);
1313    option->SetWindowName("IsAppMainOrSubOrFloatingWindow");
1314    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1315    ASSERT_NE(window, nullptr);
1316
1317    window->property_->SetWindowType(WindowType::SYSTEM_WINDOW_BASE);
1318    EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1319
1320    window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1321    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, nullptr)));
1322    EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1323
1324    sptr<WindowImpl> windowImpl1 = new (std::nothrow) WindowImpl(option);
1325    ASSERT_NE(windowImpl1, nullptr);
1326    windowImpl1->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1327    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl1)));
1328    EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1329
1330    sptr<WindowImpl> windowImpl2 = new (std::nothrow) WindowImpl(option);
1331    ASSERT_NE(windowImpl2, nullptr);
1332    windowImpl2->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1333    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl2)));
1334    EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1335
1336    sptr<WindowImpl> windowImpl3 = new (std::nothrow) WindowImpl(option);
1337    ASSERT_NE(windowImpl3, nullptr);
1338    windowImpl3->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1339    std::shared_ptr<AbilityRuntime::Context> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1340    window->context_ = context;
1341    windowImpl3->context_ = context;
1342    WindowImpl::windowMap_.insert(std::make_pair("test", std::pair<uint32_t, sptr<Window>>(1, windowImpl3)));
1343    EXPECT_EQ(window->IsAppMainOrSubOrFloatingWindow(), false);
1344}
1345
1346/**
1347 * @tc.name: UpdateTitleButtonVisibility02
1348 * @tc.desc: UpdateTitleButtonVisibility test
1349 * @tc.type: FUNC
1350 */
1351HWTEST_F(WindowImplTest5, UpdateTitleButtonVisibility02, Function | SmallTest | Level1)
1352{
1353    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1354    ASSERT_NE(option, nullptr);
1355    option->SetWindowName("UpdateTitleButtonVisibility02");
1356    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1357    ASSERT_NE(window, nullptr);
1358
1359    window->uiContent_ = nullptr;
1360    window->UpdateTitleButtonVisibility();
1361
1362    window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1363    Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1364    EXPECT_CALL(*content, HideWindowTitleButton(_, _, _, _));
1365    window->windowSystemConfig_.isSystemDecorEnable_ = false;
1366    window->UpdateTitleButtonVisibility();
1367
1368    window->windowSystemConfig_.isSystemDecorEnable_ = true;
1369    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1370    window->UpdateTitleButtonVisibility();
1371}
1372
1373/**
1374 * @tc.name: GetConfigurationFromAbilityInfo02
1375 * @tc.desc: GetConfigurationFromAbilityInfo test
1376 * @tc.type: FUNC
1377 */
1378HWTEST_F(WindowImplTest5, GetConfigurationFromAbilityInfo02, Function | SmallTest | Level1)
1379{
1380    sptr<WindowOption> option = new (std::nothrow) WindowOption();
1381    ASSERT_NE(option, nullptr);
1382    option->SetWindowName("GetConfigurationFromAbilityInfo02");
1383    option->SetDisplayId(1);
1384    sptr<WindowImpl> window = new (std::nothrow) WindowImpl(option);
1385    ASSERT_NE(window, nullptr);
1386    ASSERT_EQ(1, window->GetDisplayId());
1387
1388    std::shared_ptr<AbilityRuntime::AbilityContextImpl> context =
1389        std::make_shared<AbilityRuntime::AbilityContextImpl>();
1390    window->context_ = context;
1391    window->GetConfigurationFromAbilityInfo();
1392
1393    std::shared_ptr<AppExecFwk::AbilityInfo> info = std::make_shared<AppExecFwk::AbilityInfo>();
1394    context->SetAbilityInfo(info);
1395    window->GetConfigurationFromAbilityInfo();
1396
1397    std::vector<AppExecFwk::SupportWindowMode> supportModes;
1398    supportModes.push_back(AppExecFwk::SupportWindowMode::SPLIT);
1399    context->GetAbilityInfo()->windowModes = supportModes;
1400    window->GetConfigurationFromAbilityInfo();
1401}
1402
1403/**
1404 * @tc.name: GetVirtualPixelRatio01
1405 * @tc.desc: GetVirtualPixelRatio test
1406 * @tc.type: FUNC
1407 */
1408HWTEST_F(WindowImplTest5, GetVirtualPixelRatio01, Function | SmallTest | Level1)
1409{
1410    sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1411    option->SetWindowName("GetVirtualPixelRatio01");
1412    option->SetDisplayId(1);
1413    sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1414    window->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
1415    window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1416
1417    float vpr = -1.0f;
1418    window->property_->SetDisplayId(-1);
1419    vpr = window->GetVirtualPixelRatio();
1420    ASSERT_EQ(vpr, 0.0f);
1421
1422    window->property_->SetDisplayId(0);
1423    vpr = window->GetVirtualPixelRatio();
1424    ASSERT_NE(vpr, 0.0f);
1425}
1426}
1427} // namespace Rosen
1428} // namespace OHOS