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  */
HWTEST_F(WindowImplTest5, IsAllowHaveSystemSubWindow, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, NotifyMemoryLevel, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, SetRequestedOrientation, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, GetSystemAlarmWindowDefaultSize, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, CheckCameraFloatingWindowMultiCreated, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, SetDefaultOption01, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, SetDefaultOption02, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, UpdateActiveStatus, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, NotifyForegroundInteractiveStatus, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, UpdateWindowState02, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, UpdateWindowStateUnfrozen, Function | SmallTest | Level1)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  */
HWTEST_F(WindowImplTest5, UpdateFocusStatus, Function | SmallTest | Level1)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: RegisterListener01
461  * @tc.desc: Run successfully
462  * @tc.type: FUNC
463  */
HWTEST_F(WindowImplTest5, RegisterListener01, Function | SmallTest | Level1)464 HWTEST_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  */
HWTEST_F(WindowImplTest5, RegisterListener02, Function | SmallTest | Level1)485 HWTEST_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  */
HWTEST_F(WindowImplTest5, UnregisterListener01, Function | SmallTest | Level1)506 HWTEST_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  */
HWTEST_F(WindowImplTest5, UnregisterListener02, Function | SmallTest | Level1)528 HWTEST_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  */
HWTEST_F(WindowImplTest5, Close, Function | SmallTest | Level1)549 HWTEST_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  */
HWTEST_F(WindowImplTest5, GetVSyncPeriod, Function | SmallTest | Level1)573 HWTEST_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  */
HWTEST_F(WindowImplTest5, RequestVsync02, Function | SmallTest | Level1)599 HWTEST_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  */
HWTEST_F(WindowImplTest5, ConsumePointerEvent02, Function | SmallTest | Level1)627 HWTEST_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  */
HWTEST_F(WindowImplTest5, PerfLauncherHotAreaIfNeed, Function | SmallTest | Level1)679 HWTEST_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  */
HWTEST_F(WindowImplTest5, NotifyOccupiedAreaChange, Function | SmallTest | Level1)703 HWTEST_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  */
HWTEST_F(WindowImplTest5, NotifyDragEvent, Function | SmallTest | Level1)729 HWTEST_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  */
HWTEST_F(WindowImplTest5, TransferPointerEvent02, Function | SmallTest | Level1)753 HWTEST_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  */
HWTEST_F(WindowImplTest5, ReadyToMoveOrDragWindow, Function | SmallTest | Level1)775 HWTEST_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  */
HWTEST_F(WindowImplTest5, StartMove04, Function | SmallTest | Level1)805 HWTEST_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  */
HWTEST_F(WindowImplTest5, IsPointInDragHotZone, Function | SmallTest | Level1)834 HWTEST_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  */
HWTEST_F(WindowImplTest5, CalculateStartRectExceptHotZone, Function | SmallTest | Level1)863 HWTEST_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  */
HWTEST_F(WindowImplTest5, PendingClose02, Function | SmallTest | Level1)890 HWTEST_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  */
HWTEST_F(WindowImplTest5, Recover03, Function | SmallTest | Level1)908 HWTEST_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  */
HWTEST_F(WindowImplTest5, Minimize03, Function | SmallTest | Level1)937 HWTEST_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  */
HWTEST_F(WindowImplTest5, RegisterListener, Function | SmallTest | Level1)958 HWTEST_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  */
HWTEST_F(WindowImplTest5, SetImmersiveModeEnabledState02, Function | SmallTest | Level1)981 HWTEST_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  */
HWTEST_F(WindowImplTest5, SetGlobalMaximizeMode, Function | SmallTest | Level1)1009 HWTEST_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  */
HWTEST_F(WindowImplTest5, MaximizeFloating02, Function | SmallTest | Level1)1034 HWTEST_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  */
HWTEST_F(WindowImplTest5, SetCallingWindow, Function | SmallTest | Level1)1053 HWTEST_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  */
HWTEST_F(WindowImplTest5, Resize, Function | SmallTest | Level1)1070 HWTEST_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  */
HWTEST_F(WindowImplTest5, MoveTo, Function | SmallTest | Level1)1103 HWTEST_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  */
HWTEST_F(WindowImplTest5, AdjustWindowAnimationFlag, Function | SmallTest | Level1)1132 HWTEST_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  */
HWTEST_F(WindowImplTest5, NeedToStopShowing, Function | SmallTest | Level1)1165 HWTEST_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  */
HWTEST_F(WindowImplTest5, DestroyFloatingWindow, Function | SmallTest | Level1)1191 HWTEST_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  */
HWTEST_F(WindowImplTest5, DestroyDialogWindow, Function | SmallTest | Level1)1221 HWTEST_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  */
HWTEST_F(WindowImplTest5, GetOriginalAbilityInfo, Function | SmallTest | Level1)1251 HWTEST_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  */
HWTEST_F(WindowImplTest5, WindowCreateCheck05, Function | SmallTest | Level1)1269 HWTEST_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  */
HWTEST_F(WindowImplTest5, IsAppMainOrSubOrFloatingWindow, Function | SmallTest | Level1)1309 HWTEST_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  */
HWTEST_F(WindowImplTest5, UpdateTitleButtonVisibility02, Function | SmallTest | Level1)1351 HWTEST_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  */
HWTEST_F(WindowImplTest5, GetConfigurationFromAbilityInfo02, Function | SmallTest | Level1)1378 HWTEST_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  */
HWTEST_F(WindowImplTest5, GetVirtualPixelRatio01, Function | SmallTest | Level1)1408 HWTEST_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