1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "ability_context_impl.h"
18 #include "display_manager_proxy.h"
19 #include "mock_window_adapter.h"
20 #include "singleton_mocker.h"
21 #include "window_impl.h"
22 #include "mock_uicontent.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace Rosen {
29 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
30 class MockAceAbilityHandler : public IAceAbilityHandler {
31 public:
32 MOCK_METHOD1(SetBackgroundColor, void(uint32_t color));
33 MOCK_METHOD0(GetBackgroundColor, uint32_t());
34 };
35
36 class MockAnimationTransitionController : public IAnimationTransitionController {
37 public:
38 MOCK_METHOD0(AnimationForShown, void());
39 MOCK_METHOD0(AnimationForHidden, void());
40 };
41
42 class MockDialogDeathRecipientListener : public IDialogDeathRecipientListener {
43 public:
44 MOCK_CONST_METHOD0(OnDialogDeathRecipient, void());
45 };
46
47 class MockScreenshotListener : public IScreenshotListener {
48 public:
49 MOCK_METHOD0(OnScreenshot, void());
50 };
51
52 class MockDialogTargetTouchListener : public IDialogTargetTouchListener {
53 public:
54 MOCK_CONST_METHOD0(OnDialogTargetTouch, void());
55 };
56
57 class MockWindowChangeListener : public IWindowChangeListener {
58 public:
59 MOCK_METHOD3(OnSizeChange, void(Rect rect, WindowSizeChangeReason reason,
60 const std::shared_ptr<RSTransaction>& rsTransaction));
61 MOCK_METHOD2(OnModeChange, void(WindowMode mode, bool hasDeco));
62 };
63
64 class MockAvoidAreaChangedListener : public IAvoidAreaChangedListener {
65 public:
66 MOCK_METHOD2(OnAvoidAreaChanged, void(const AvoidArea avoidArea, AvoidAreaType type));
67 };
68
69 class MockDisplayMoveListener : public IDisplayMoveListener {
70 public:
71 MOCK_METHOD2(OnDisplayMove, void(DisplayId from, DisplayId to));
72 };
73
74 class MockInputEventConsumer : public IInputEventConsumer {
75 public:
76 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::KeyEvent>&));
77 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::PointerEvent>&));
78 MOCK_CONST_METHOD1(OnInputEvent, bool(const std::shared_ptr<MMI::AxisEvent>&));
79 };
80
81 class MockKeyEvent : public MMI::KeyEvent {
82 public:
MockKeyEvent()83 MockKeyEvent() : MMI::KeyEvent(0) {}
84 };
85
86 class MockPointerEvent : public MMI::PointerEvent {
87 public:
MockPointerEvent()88 MockPointerEvent() : MMI::PointerEvent(0) {}
89 };
90
91 class WindowImplTest : public testing::Test {
92 public:
93 static void SetUpTestCase();
94 static void TearDownTestCase();
95 virtual void SetUp() override;
96 virtual void TearDown() override;
97 void CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect);
98
99 static inline std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
100 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
101 };
SetUpTestCase()102 void WindowImplTest::SetUpTestCase()
103 {
104 }
105
TearDownTestCase()106 void WindowImplTest::TearDownTestCase()
107 {
108 }
109
SetUp()110 void WindowImplTest::SetUp()
111 {
112 }
113
TearDown()114 void WindowImplTest::TearDown()
115 {
116 }
117
CreateStretchableWindow(sptr<WindowImpl> & window,const Rect & rect)118 void WindowImplTest::CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect)
119 {
120 sptr<WindowOption> option = new WindowOption();
121 option->SetWindowName("StretchableWindowTest");
122 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
123 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
124 option->SetWindowRect({ 1, 1, 1, 1 });
125 if (option == nullptr) {
126 window = nullptr;
127 return;
128 }
129 window = new WindowImpl(option);
130 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
131 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
132 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
133 window->windowSystemConfig_.isStretchable_ = true;
134 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
135 ASSERT_EQ(WMError::WM_OK, window->Show());
136 window->UpdateRect(rect, true, WindowSizeChangeReason::UNDEFINED);
137 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect);
138 }
139
140 namespace {
141 /**
142 * @tc.name: CreateWindow01
143 * @tc.desc: Create window with no parentId
144 * @tc.type: FUNC
145 */
146 HWTEST_F(WindowImplTest, CreateWindow01, Function | SmallTest | Level2)
147 {
148 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
149 sptr<WindowOption> option = new WindowOption();
150 option->SetWindowName("CreateWindow01");
151 sptr<WindowImpl> window = new WindowImpl(option);
152
153 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
154 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
155 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
156
157 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
158 ASSERT_EQ(WMError::WM_OK, window->Destroy());
159 }
160
161 /**
162 * @tc.name: CreateWindow02
163 * @tc.desc: Create window with no parentId and no abilityContext
164 * @tc.type: FUNC
165 */
166 HWTEST_F(WindowImplTest, CreateWindow02, Function | SmallTest | Level2)
167 {
168 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
169 sptr<WindowOption> option = new WindowOption();
170 option->SetWindowName("CreateWindow02");
171 sptr<WindowImpl> window = new WindowImpl(option);
172
173 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
174 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
175 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Create(INVALID_WINDOW_ID));
176 }
177
178 /**
179 * @tc.name: CreateWindow03
180 * @tc.desc: Create window with illegal parentId
181 * @tc.type: FUNC
182 */
183 HWTEST_F(WindowImplTest, CreateWindow03, Function | SmallTest | Level2)
184 {
185 sptr<WindowOption> option = new WindowOption();
186 option->SetWindowName("CreateWindow03");
187 sptr<WindowImpl> window = new WindowImpl(option);
188 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARENT, window->Create(1234));
189 }
190
191 /**
192 * @tc.name: CreateWindow04
193 * @tc.desc: Create window with repeated windowName
194 * @tc.type: FUNC
195 */
196 HWTEST_F(WindowImplTest, CreateWindow04, Function | SmallTest | Level2)
197 {
198 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
199 sptr<WindowOption> option = new WindowOption();
200 option->SetWindowName("CreateWindow04");
201 sptr<WindowImpl> window = new WindowImpl(option);
202 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
203 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
204 window->Create(INVALID_WINDOW_ID);
205
206 sptr<WindowOption> option_other = new WindowOption();
207 option_other->SetWindowName("CreateWindow04");
208 sptr<WindowImpl> window_other = new WindowImpl(option_other);
209
210 ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window_other->Create(INVALID_WINDOW_ID));
211 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
212 ASSERT_EQ(WMError::WM_OK, window->Destroy());
213 ASSERT_EQ(WMError::WM_OK, window_other->Destroy());
214 }
215
216 /**
217 * @tc.name: CreateWindow05
218 * @tc.desc: Create window with exist parentId
219 * @tc.type: FUNC
220 */
221 HWTEST_F(WindowImplTest, CreateWindow05, Function | SmallTest | Level2)
222 {
223 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
224 sptr<WindowOption> option = new WindowOption();
225 option->SetWindowName("CreateWindow05_parent");
226 sptr<WindowImpl> window = new WindowImpl(option);
227
228 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
229 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
230 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
231
232 sptr<WindowOption> option2 = new WindowOption();
233 option2->SetWindowName("CreateWindow05");
234 sptr<WindowImpl> window2 = new WindowImpl(option2);
235
236 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
237 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
238 ASSERT_EQ(WMError::WM_OK, window2->Create(window->GetWindowId()));
239
240 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
241 ASSERT_EQ(WMError::WM_OK, window->Destroy());
242 ASSERT_EQ(WMError::WM_OK, window2->Destroy());
243 }
244
245 /**
246 * @tc.name: CreateWindow06
247 * @tc.desc: Create window with no default option, get and check Property
248 * @tc.type: FUNC
249 */
250 HWTEST_F(WindowImplTest, CreateWindow06, Function | SmallTest | Level2)
251 {
252 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
253 sptr<WindowOption> option = new WindowOption();
254 option->SetWindowName("CreateWindow06");
255 struct Rect rect = {1, 2, 3u, 4u};
256 option->SetWindowRect(rect);
257 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
258 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
259 sptr<WindowImpl> window = new WindowImpl(option);
260
261 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
262 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
263 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
264
265 ASSERT_EQ(1, window->GetRequestRect().posX_);
266 ASSERT_EQ(2, window->GetRequestRect().posY_);
267 ASSERT_EQ(3u, window->GetRequestRect().width_);
268 ASSERT_EQ(4u, window->GetRequestRect().height_);
269 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType());
270 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
271 ASSERT_EQ("CreateWindow06", window->GetWindowName());
272
273 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
274 ASSERT_EQ(WMError::WM_OK, window->Destroy());
275 }
276
277 /**
278 * @tc.name: FindWindow01
279 * @tc.desc: Find one exit window
280 * @tc.type: FUNC
281 */
282 HWTEST_F(WindowImplTest, FindWindow01, Function | SmallTest | Level2)
283 {
284 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
285 sptr<WindowOption> option = new WindowOption();
286 option->SetWindowName("FindWindow01");
287 sptr<WindowImpl> window = new WindowImpl(option);
288 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
289 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
290 window->Create(INVALID_WINDOW_ID);
291 ASSERT_NE(nullptr, WindowImpl::Find("FindWindow01"));
292 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
293 ASSERT_EQ(WMError::WM_OK, window->Destroy());
294 }
295
296 /**
297 * @tc.name: FindWindow02
298 * @tc.desc: Add another window, find both two windows
299 * @tc.type: FUNC
300 */
301 HWTEST_F(WindowImplTest, FindWindow02, Function | SmallTest | Level2)
302 {
303 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
304 sptr<WindowOption> option = new WindowOption();
305 option->SetWindowName("FindWindow02");
306 sptr<WindowImpl> window = new WindowImpl(option);
307 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
308 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
309 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
310
311 option->SetWindowName("FindWindow02_other");
312 sptr<WindowImpl> window2 = new WindowImpl(option);
313 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
314 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
315 ASSERT_EQ(WMError::WM_OK, window2->Create(INVALID_WINDOW_ID));
316
317 ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02_other"));
318 ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02"));
319
320 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
321 ASSERT_EQ(WMError::WM_OK, window->Destroy());
322 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
323 ASSERT_EQ(WMError::WM_OK, window2->Destroy());
324 }
325
326 /**
327 * @tc.name: FindWindow03
328 * @tc.desc: Find one no exit window
329 * @tc.type: FUNC
330 */
331 HWTEST_F(WindowImplTest, FindWindow03, Function | SmallTest | Level2)
332 {
333 ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow03"));
334 }
335
336 /**
337 * @tc.name: FindWindow04
338 * @tc.desc: Find window with empty name
339 * @tc.type: FUNC
340 */
341 HWTEST_F(WindowImplTest, FindWindow04, Function | SmallTest | Level2)
342 {
343 ASSERT_EQ(nullptr, WindowImpl::Find(""));
344 }
345
346 /**
347 * @tc.name: FindWindow05
348 * @tc.desc: Find one destroyed window
349 * @tc.type: FUNC
350 */
351 HWTEST_F(WindowImplTest, FindWindow05, Function | SmallTest | Level2)
352 {
353 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
354 sptr<WindowOption> option = new WindowOption();
355 option->SetWindowName("FindWindow05");
356 sptr<WindowImpl> window = new WindowImpl(option);
357 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
358 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
359 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
360
361 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
362 ASSERT_EQ(WMError::WM_OK, window->Destroy());
363 ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow05"));
364 }
365
366 /**
367 * @tc.name: FindWindowById01
368 * @tc.desc: Find one top window
369 * @tc.type: FUNC
370 */
371 HWTEST_F(WindowImplTest, FindWindowById01, Function | SmallTest | Level2)
372 {
373 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
374 sptr<WindowOption> option = new WindowOption();
375 option->SetWindowName("FindWindowById01");
376 sptr<WindowImpl> window = new WindowImpl(option);
377 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
378 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
379 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
380
381 ASSERT_NE(nullptr, window->FindWindowById(window->property_->GetWindowId()));
382
383 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
384 ASSERT_EQ(WMError::WM_OK, window->Destroy());
385 }
386
387 /**
388 * @tc.name: SetWindowType01
389 * @tc.desc: SetWindowType
390 * @tc.type: FUNC
391 */
392 HWTEST_F(WindowImplTest, SetWindowType01, Function | SmallTest | Level2)
393 {
394 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
395 sptr<WindowOption> option = new WindowOption();
396 option->SetWindowName("SetWindowType01");
397 sptr<WindowImpl> window = new WindowImpl(option);
398 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
399 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
400 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
401 ASSERT_EQ(WMError::WM_OK, window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
402 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
403 ASSERT_EQ(WMError::WM_OK, window->Destroy());
404 }
405
406 /**
407 * @tc.name: SetWindowMode01
408 * @tc.desc: SetWindowMode
409 * @tc.type: FUNC
410 */
411 HWTEST_F(WindowImplTest, SetWindowMode01, Function | SmallTest | Level2)
412 {
413 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
414 sptr<WindowOption> option = new WindowOption();
415 option->SetWindowName("SetWindowType01");
416 sptr<WindowImpl> window = new WindowImpl(option);
417 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
418 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
419 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
420 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
421 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
422 ASSERT_EQ(WMError::WM_OK, window->Destroy());
423 }
424
425 /**
426 * @tc.name: SetWindowMode02
427 * @tc.desc: Set window mode to split primary
428 * @tc.type: FUNC
429 */
430 HWTEST_F(WindowImplTest, SetWindowMode02, Function | SmallTest | Level3)
431 {
432 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
433 sptr<WindowOption> option = new WindowOption();
434 option->SetWindowName("");
435 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
436 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
437 sptr<WindowImpl> window = new WindowImpl(option);
438 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
439 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
440 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
441 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
442 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
443 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, window->GetMode());
444 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
445 ASSERT_EQ(WMError::WM_OK, window->Destroy());
446 }
447
448 /**
449 * @tc.name: SetWindowMode03
450 * @tc.desc: Set window mode to split secondary
451 * @tc.type: FUNC
452 */
453 HWTEST_F(WindowImplTest, SetWindowMode03, Function | SmallTest | Level3)
454 {
455 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
456 sptr<WindowOption> option = new WindowOption();
457 option->SetWindowName("");
458 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
459 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
460 sptr<WindowImpl> window = new WindowImpl(option);
461 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
462 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
463 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
464 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
465 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
466 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, window->GetMode());
467 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
468 ASSERT_EQ(WMError::WM_OK, window->Destroy());
469 }
470
471 /**
472 * @tc.name: SetWindowMode04
473 * @tc.desc: Set window mode to floating
474 * @tc.type: FUNC
475 */
476 HWTEST_F(WindowImplTest, SetWindowMode04, Function | SmallTest | Level3)
477 {
478 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
479 sptr<WindowOption> option = new WindowOption();
480 option->SetWindowName("");
481 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
482 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
483 sptr<WindowImpl> window = new WindowImpl(option);
484 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
485 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
486 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
487 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
488 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING));
489 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
490 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
491 ASSERT_EQ(WMError::WM_OK, window->Destroy());
492 }
493
494 /**
495 * @tc.name: SetWindowMode05
496 * @tc.desc: Set window mode to pip
497 * @tc.type: FUNC
498 */
499 HWTEST_F(WindowImplTest, SetWindowMode05, Function | SmallTest | Level3)
500 {
501 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
502 sptr<WindowOption> option = new WindowOption();
503 option->SetWindowName("");
504 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
505 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
506 sptr<WindowImpl> window = new WindowImpl(option);
507 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
508 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
509 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
510 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
511 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_PIP));
512 ASSERT_EQ(WindowMode::WINDOW_MODE_PIP, window->GetMode());
513 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
514 ASSERT_EQ(WMError::WM_OK, window->Destroy());
515 }
516
517 /**
518 * @tc.name: ShowHideWindow01
519 * @tc.desc: Show and hide window with add and remove window ok
520 * @tc.type: FUNC
521 */
522 HWTEST_F(WindowImplTest, ShowHideWindow01, Function | SmallTest | Level2)
523 {
524 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
525 sptr<WindowOption> option = new WindowOption();
526 option->SetWindowName("ShowHideWindow01");
527 sptr<WindowImpl> window = new WindowImpl(option);
528 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
529 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
530 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
531 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
532 ASSERT_EQ(WMError::WM_OK, window->Show());
533 window->NotifyForeground();
534 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
535 ASSERT_EQ(WMError::WM_OK, window->Hide());
536 window->NotifyBackground();
537 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
538 ASSERT_EQ(WMError::WM_OK, window->Destroy());
539 }
540
541 /**
542 * @tc.name: ShowHideWindow02
543 * @tc.desc: Show window with add window WM_ERROR_SAMGR
544 * @tc.type: FUNC
545 */
546 HWTEST_F(WindowImplTest, ShowHideWindow02, Function | SmallTest | Level2)
547 {
548 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
549 sptr<WindowOption> option = new WindowOption();
550 option->SetWindowName("ShowHideWindow02");
551 sptr<WindowImpl> window = new WindowImpl(option);
552 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
553 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
554 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
555 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
556 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Show());
557 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
558 ASSERT_EQ(WMError::WM_OK, window->Destroy());
559 }
560
561 /**
562 * @tc.name: ShowHideWindow03
563 * @tc.desc: Show window with add window WM_ERROR_IPC_FAILED
564 * @tc.type: FUNC
565 */
566 HWTEST_F(WindowImplTest, ShowHideWindow03, Function | SmallTest | Level3)
567 {
568 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
569 sptr<WindowOption> option = new WindowOption();
570 option->SetWindowName("ShowHideWindow03");
571 sptr<WindowImpl> window = new WindowImpl(option);
572 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
573 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
574 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
575 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
576 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Show());
577 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
578 ASSERT_EQ(WMError::WM_OK, window->Destroy());
579 }
580
581 /**
582 * @tc.name: ShowHideWindow04
583 * @tc.desc: Show window with add window OK & Hide window with remove window WM_ERROR_SAMGR
584 * @tc.type: FUNC
585 */
586 HWTEST_F(WindowImplTest, ShowHideWindow04, Function | SmallTest | Level3)
587 {
588 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
589 sptr<WindowOption> option = new WindowOption();
590 option->SetWindowName("ShowHideWindow04");
591 sptr<WindowImpl> window = new WindowImpl(option);
592 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
593 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
594 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
595 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
596 ASSERT_EQ(WMError::WM_OK, window->Show());
597 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
598 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Hide());
599 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
600 ASSERT_EQ(WMError::WM_OK, window->Destroy());
601 }
602
603 /**
604 * @tc.name: ShowHideWindow05
605 * @tc.desc: Hide window with remove window WM_ERROR_IPC_FAILED
606 * @tc.type: FUNC
607 */
608 HWTEST_F(WindowImplTest, ShowHideWindow05, Function | SmallTest | Level3)
609 {
610 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
611 sptr<WindowOption> option = new WindowOption();
612 option->SetWindowName("ShowHideWindow05");
613 sptr<WindowImpl> window = new WindowImpl(option);
614 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
615 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
616 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
617 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
618 ASSERT_EQ(WMError::WM_OK, window->Show());
619 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
620 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Hide());
621 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
622 ASSERT_EQ(WMError::WM_OK, window->Destroy());
623 }
624
625 /**
626 * @tc.name: ShowHideWindow06
627 * @tc.desc: Hide window with remove window OK
628 * @tc.type: FUNC
629 */
630 HWTEST_F(WindowImplTest, ShowHideWindow06, Function | SmallTest | Level3)
631 {
632 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
633 sptr<WindowOption> option = new WindowOption();
634 option->SetWindowName("ShowHideWindow06");
635 sptr<WindowImpl> window = new WindowImpl(option);
636 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
637 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
638 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
639 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
640 ASSERT_EQ(WMError::WM_OK, window->Show());
641 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
642 ASSERT_EQ(WMError::WM_OK, window->Hide());
643 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
644 ASSERT_EQ(WMError::WM_OK, window->Destroy());
645 }
646
647 /**
648 * @tc.name: SetSystemBarProperty01
649 * @tc.desc: SetSystemBarProperty with default param
650 * @tc.type: FUNC
651 */
652 HWTEST_F(WindowImplTest, SetSystemBarProperty01, Function | SmallTest | Level3)
653 {
654 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
655 sptr<WindowOption> option = new WindowOption();
656 option->SetWindowName("SetSystemBarProperty01");
657 sptr<WindowImpl> window = new WindowImpl(option);
658 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
659 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
660 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
661
662 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
663 SystemBarProperty prop;
664 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, prop));
665 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
666 ASSERT_EQ(WMError::WM_OK, window->Destroy());
667 }
668
669 /**
670 * @tc.name: SetSystemBarProperty02
671 * @tc.desc: SetSystemBarProperty with adapter return WM_ERROR_SAMGR
672 * @tc.type: FUNC
673 */
674 HWTEST_F(WindowImplTest, SetSystemBarProperty02, Function | SmallTest | Level3)
675 {
676 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
677 sptr<WindowOption> option = new WindowOption();
678 option->SetWindowName("SetSystemBarProperty02");
679 sptr<WindowImpl> window = new WindowImpl(option);
680 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
681 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
682 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
683
684 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
685 window->Show();
686 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
687 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
688 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
689 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->SetSystemBarProperty(type, SYS_BAR_PROP));
690 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
691 window->Hide();
692 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
693 ASSERT_EQ(WMError::WM_OK, window->Destroy());
694 }
695
696 /**
697 * @tc.name: SetSystemBarProperty03
698 * @tc.desc: SetSystemBarProperty to invalid window
699 * @tc.type: FUNC
700 */
701 HWTEST_F(WindowImplTest, SetSystemBarProperty03, Function | SmallTest | Level3)
702 {
703 sptr<WindowOption> option = new WindowOption();
704 option->SetWindowName("SetSystemBarProperty03");
705 sptr<WindowImpl> window = new WindowImpl(option);
706 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
707 SystemBarProperty prop;
708 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSystemBarProperty(type, prop));
709 }
710
711 /**
712 * @tc.name: GetSystemBarPropertyByType01
713 * @tc.desc: GetSystemBarPropertyByType with exist key
714 * @tc.type: FUNC
715 */
716 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType01, Function | SmallTest | Level3)
717 {
718 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
719 sptr<WindowOption> option = new WindowOption();
720 option->SetWindowName("GetSystemBarPropertyByType01");
721 sptr<WindowImpl> window = new WindowImpl(option);
722 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
723 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
724 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
725
726 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
727 ASSERT_EQ(WMError::WM_OK, window->Show());
728 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
729 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
730 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333344);
731 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, SYS_BAR_PROP));
732 ASSERT_EQ(SYS_BAR_PROP, window->GetSystemBarPropertyByType(type));
733 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
734 window->Hide();
735 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
736 ASSERT_EQ(WMError::WM_OK, window->Destroy());
737 }
738
739 /**
740 * @tc.name: GetSystemBarPropertyByType02
741 * @tc.desc: GetSystemBarPropertyByType with nonexist key
742 * @tc.type: FUNC
743 */
744 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType02, Function | SmallTest | Level3)
745 {
746 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
747 sptr<WindowOption> option = new WindowOption();
748 option->SetWindowName("GetSystemBarPropertyByType02");
749 sptr<WindowImpl> window = new WindowImpl(option);
750 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
751 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
752 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
753
754 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
755 window->Show();
756 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
757 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
758 const SystemBarProperty DEFAULT_PROP;
759 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
760 ASSERT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR));
761 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
762 window->Hide();
763 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
764 ASSERT_EQ(WMError::WM_OK, window->Destroy());
765 }
766
767 /**
768 * @tc.name: GetSystemBarPropertyByType03
769 * @tc.desc: GetSystemBarPropertyByType with not systemBar type
770 * @tc.type: FUNC
771 */
772 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType03, Function | SmallTest | Level3)
773 {
774 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
775 sptr<WindowOption> option = new WindowOption();
776 option->SetWindowName("GetSystemBarPropertyByType03");
777 sptr<WindowImpl> window = new WindowImpl(option);
778 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
779 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
780 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
781
782 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
783 window->Show();
784 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
785 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333366);
786 const SystemBarProperty DEFAULT_PROP;
787 ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
788 ASSERT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
789 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
790 window->Hide();
791 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
792 ASSERT_EQ(WMError::WM_OK, window->Destroy());
793 }
794
795 /**
796 * @tc.name: Maximize02
797 * @tc.desc: Maximize the sub window
798 * @tc.type: FUNC
799 */
800 HWTEST_F(WindowImplTest, Maximize02, Function | SmallTest | Level3)
801 {
802 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
803 sptr<WindowOption> option = new WindowOption();
804 option->SetWindowName("Maximize02");
805 sptr<WindowImpl> window = new WindowImpl(option);
806 window->Maximize();
807 ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->GetMode());
808 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
809 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
810 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
811 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
812 window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
813 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
814 window->Show();
815 window->Maximize();
816 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
817
818 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
819 window->Hide();
820 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
821 ASSERT_EQ(WMError::WM_OK, window->Destroy());
822 }
823
824 /**
825 * @tc.name: Recover01
826 * @tc.desc: Recover the main window
827 * @tc.type: FUNC
828 */
829 HWTEST_F(WindowImplTest, Recover01, Function | SmallTest | Level3)
830 {
831 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
832 sptr<WindowOption> option = new WindowOption();
833 option->SetWindowName("Recover01");
834 sptr<WindowImpl> window = new WindowImpl(option);
835 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Recover());
836 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
837 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
838 window->Create(INVALID_WINDOW_ID);
839 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
840 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
841 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
842 window->Show();
843 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
844 window->Recover();
845 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
846 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
847 window->Hide();
848 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
849 ASSERT_EQ(WMError::WM_OK, window->Destroy());
850 }
851
852 /**
853 * @tc.name: Recover02
854 * @tc.desc: Recover the sub window
855 * @tc.type: FUNC
856 */
857 HWTEST_F(WindowImplTest, Recover02, Function | SmallTest | Level3)
858 {
859 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
860 sptr<WindowOption> option = new WindowOption();
861 option->SetWindowName("Recover02");
862 sptr<WindowImpl> window = new WindowImpl(option);
863 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
864 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
865 window->Create(INVALID_WINDOW_ID);
866 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
867 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
868 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
869 window->Show();
870 window->Recover();
871 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
872 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
873 window->Hide();
874 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
875 ASSERT_EQ(WMError::WM_OK, window->Destroy());
876 }
877
878 /**
879 * @tc.name: Minimize01
880 * @tc.desc: Minimize the main window
881 * @tc.type: FUNC
882 */
883 HWTEST_F(WindowImplTest, Minimize01, Function | SmallTest | Level3)
884 {
885 auto option = new WindowOption();
886 option->SetWindowName("Minimize01");
887 sptr<WindowImpl> window = new WindowImpl(option);
888 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Minimize());
889 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
890 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
891 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
892 window->Create(INVALID_WINDOW_ID);
893 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
894 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
895 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
896 window->Show();
897 ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
898 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
899 window->Minimize();
900 ASSERT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN));
901 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
902 ASSERT_EQ(WMError::WM_OK, window->Minimize());
903 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
904 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
905 EXPECT_CALL(*content, Destroy());
906 ASSERT_EQ(WMError::WM_OK, window->Destroy());
907 }
908
909 /**
910 * @tc.name: Minimize02
911 * @tc.desc: Minimize the sub window
912 * @tc.type: FUNC
913 */
914 HWTEST_F(WindowImplTest, Minimize02, Function | SmallTest | Level3)
915 {
916 auto option = new WindowOption();
917 option->SetWindowName("Minimize02");
918 sptr<WindowImpl> window = new WindowImpl(option);
919 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
920 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
921 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
922 window->Create(INVALID_WINDOW_ID);
923 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
924 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
925 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
926 window->Show();
927 ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
928 window->Minimize();
929 ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
930 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
931 ASSERT_EQ(WMError::WM_OK, window->Destroy());
932 }
933
934 /**
935 * @tc.name: IsSupportWideGamut01
936 * @tc.desc: IsSupportWideGamut
937 * @tc.type: FUNC
938 */
939 HWTEST_F(WindowImplTest, IsSupportWideGamut01, Function | SmallTest | Level3)
940 {
941 auto option = new WindowOption();
942 option->SetWindowName("IsSupportWideGamut01");
943 sptr<WindowImpl> window = new WindowImpl(option);
944 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
945 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
946 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
947 window->Create(INVALID_WINDOW_ID);
948 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
949 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
950 ASSERT_TRUE(window->IsSupportWideGamut());
951 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
952 ASSERT_EQ(WMError::WM_OK, window->Destroy());
953 }
954
955 /**
956 * @tc.name: SetColorSpace01
957 * @tc.desc: SetColorSpace
958 * @tc.type: FUNC
959 */
960 HWTEST_F(WindowImplTest, SetColorSpace01, Function | SmallTest | Level3)
961 {
962 auto option = new WindowOption();
963 option->SetWindowName("SetColorSpace01");
964 sptr<WindowImpl> window = new WindowImpl(option);
965 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
966 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
967 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
968 window->Create(INVALID_WINDOW_ID);
969 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
970 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
971 window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
972 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
973 ASSERT_EQ(WMError::WM_OK, window->Destroy());
974 }
975
976 /**
977 * @tc.name: GetColorSpace01
978 * @tc.desc: GetColorSpace
979 * @tc.type: FUNC
980 */
981 HWTEST_F(WindowImplTest, GetColorSpace01, Function | SmallTest | Level3)
982 {
983 auto option = new WindowOption();
984 option->SetWindowName("GetColorSpace01");
985 sptr<WindowImpl> window = new WindowImpl(option);
986 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
987 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
988 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
989 window->Create(INVALID_WINDOW_ID);
990 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
991 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
992 window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT);
993 ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
994 window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
995 ASSERT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace());
996 uint32_t invalidColorSpace = 54321u;
997 window->SetColorSpace(static_cast<ColorSpace>(invalidColorSpace));
998 ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
999 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1000 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1001 }
1002
1003 /**
1004 * @tc.name: StartMove01
1005 * @tc.desc: start move main fullscreen window, test startMoveFlag
1006 * @tc.type: FUNC
1007 * @tc.require: issueI5J8IB
1008 */
1009 HWTEST_F(WindowImplTest, StartMove01, Function | SmallTest | Level3)
1010 {
1011 sptr<WindowOption> option = new WindowOption();
1012 option->SetWindowName("StartMove01");
1013 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1014 sptr<WindowImpl> window = new WindowImpl(option);
1015 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1016
1017 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1018 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1019 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1020 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1021 window->Show();
1022 window->StartMove();
1023 ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1024 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1025 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1026 }
1027
1028 /**
1029 * @tc.name: StartMove02
1030 * @tc.desc: start move main fullscreen window, test startMoveFlag
1031 * @tc.type: FUNC
1032 * @tc.require: issueI5J8IB
1033 */
1034 HWTEST_F(WindowImplTest, StartMove02, Function | SmallTest | Level3)
1035 {
1036 sptr<WindowOption> option = new WindowOption();
1037 option->SetWindowName("StartMove02");
1038 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1039 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1040 sptr<WindowImpl> window = new WindowImpl(option);
1041 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1042
1043 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1044 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1045 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1046 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1047 window->Show();
1048
1049 window->StartMove();
1050 ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1051 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1052 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1053 }
1054
1055 /**
1056 * @tc.name: StartMove03
1057 * @tc.desc: start move divider, test startMoveFlag
1058 * @tc.type: FUNC
1059 * @tc.require: issueI5J8IB
1060 */
1061 HWTEST_F(WindowImplTest, StartMove03, Function | SmallTest | Level3)
1062 {
1063 sptr<WindowOption> option = new WindowOption();
1064 option->SetWindowName("StartMove03");
1065 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1066 option->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
1067 sptr<WindowImpl> window = new WindowImpl(option);
1068 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1069
1070 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1071 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1072 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1073 window->Show();
1074 window->StartMove();
1075 ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1076 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1077 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1078 }
1079
1080 /**
1081 * @tc.name: SetBackgroundColor01
1082 * @tc.desc: test SetBackgroundColor withow uiContent
1083 * @tc.type: FUNC
1084 */
1085 HWTEST_F(WindowImplTest, SetBackgroundColor01, Function | SmallTest | Level3)
1086 {
1087 sptr<WindowOption> option = new WindowOption();
1088 option->SetWindowName("SetBackgroundColor01");
1089 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1090 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1091 sptr<WindowImpl> window = new WindowImpl(option);
1092 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1093
1094 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1095 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1096 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1097 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1098 window->Show();
1099 ASSERT_FALSE(window->IsTransparent());
1100 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackgroundColor("#000"));
1101 ASSERT_FALSE(window->IsTransparent());
1102 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#00FF00"));
1103 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#FF00FF00"));
1104 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1105 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1106 }
1107
1108 /**
1109 * @tc.name: SetTurnScreenOn01
1110 * @tc.desc: create window but not show, test SetTurnScreenOn
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(WindowImplTest, SetTurnScreenOn01, Function | SmallTest | Level3)
1114 {
1115 sptr<WindowOption> option = new WindowOption();
1116 option->SetWindowName("SetTurnScreenOn01");
1117 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1118 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1119 sptr<WindowImpl> window = new WindowImpl(option);
1120 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(true));
1121 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1122
1123 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1124 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1125 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1126 ASSERT_FALSE(window->IsTurnScreenOn());
1127 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
1128 ASSERT_TRUE(window->IsTurnScreenOn());
1129 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
1130 ASSERT_FALSE(window->IsTurnScreenOn());
1131 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1132 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1133 }
1134
1135
1136 /**
1137 * @tc.name: SetTurnScreenOn02
1138 * @tc.desc: create window with show, test SetTurnScreenOn
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(WindowImplTest, SetTurnScreenOn02, Function | SmallTest | Level3)
1142 {
1143 sptr<WindowOption> option = new WindowOption();
1144 option->SetWindowName("SetTurnScreenOn02");
1145 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1146 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1147 sptr<WindowImpl> window = new WindowImpl(option);
1148 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1149
1150 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1151 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1152 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1153 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1154 ASSERT_EQ(WMError::WM_OK, window->Show());
1155 ASSERT_FALSE(window->IsTurnScreenOn());
1156 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1157 .WillOnce(Return(WMError::WM_OK));
1158 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
1159 ASSERT_TRUE(window->IsTurnScreenOn());
1160 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
1161 ASSERT_FALSE(window->IsTurnScreenOn());
1162 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1163 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1164 }
1165
1166 /**
1167 * @tc.name: SetKeepScreenOn01
1168 * @tc.desc: create window but not show, test SetKeepScreenOn
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(WindowImplTest, SetKeepScreenOn01, Function | SmallTest | Level3)
1172 {
1173 sptr<WindowOption> option = new WindowOption();
1174 option->SetWindowName("SetKeepScreenOn01");
1175 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1176 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1177 sptr<WindowImpl> window = new WindowImpl(option);
1178 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(true));
1179 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1180
1181 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1182 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1183 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1184 ASSERT_FALSE(window->IsKeepScreenOn());
1185 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
1186 ASSERT_TRUE(window->IsKeepScreenOn());
1187 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
1188 ASSERT_FALSE(window->IsKeepScreenOn());
1189 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1190 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1191 }
1192
1193 /**
1194 * @tc.name: SetKeepScreenOn02
1195 * @tc.desc: create window with show, test SetKeepScreenOn
1196 * @tc.type: FUNC
1197 */
1198 HWTEST_F(WindowImplTest, SetKeepScreenOn02, Function | SmallTest | Level3)
1199 {
1200 sptr<WindowOption> option = new WindowOption();
1201 option->SetWindowName("SetKeepScreenOn02");
1202 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1203 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1204 sptr<WindowImpl> window = new WindowImpl(option);
1205 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1206
1207 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1208 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1209 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1210 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1211 ASSERT_EQ(WMError::WM_OK, window->Show());
1212 ASSERT_FALSE(window->IsKeepScreenOn());
1213 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1214 .WillOnce(Return(WMError::WM_OK));;
1215 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
1216 ASSERT_TRUE(window->IsKeepScreenOn());
1217 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
1218 ASSERT_FALSE(window->IsKeepScreenOn());
1219
1220 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1221 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1222 }
1223
1224 /**
1225 * @tc.name: SetBrightness01
1226 * @tc.desc: test SetBrightness with invalid brightness
1227 * @tc.type: FUNC
1228 */
1229 HWTEST_F(WindowImplTest, SetBrightness01, Function | SmallTest | Level3)
1230 {
1231 sptr<WindowOption> option = new WindowOption();
1232 option->SetWindowName("SetBrightness01");
1233 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1234 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1235 sptr<WindowImpl> window = new WindowImpl(option);
1236 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBrightness(0.f));
1237 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1238
1239 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1240 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1241 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1242 ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1243
1244 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1245 ASSERT_EQ(WMError::WM_OK, window->Show());
1246 ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1247 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(2.0f)); // 2.0f: brightness
1248 ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1249
1250 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1251 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1252 }
1253
1254 /**
1255 * @tc.name: SetBrightness02
1256 * @tc.desc: test SetBrightness with valid brightness
1257 * @tc.type: FUNC
1258 */
1259 HWTEST_F(WindowImplTest, SetBrightness02, Function | SmallTest | Level3)
1260 {
1261 sptr<WindowOption> option = new WindowOption();
1262 option->SetWindowName("SetBrightness02");
1263 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1264 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1265 sptr<WindowImpl> window = new WindowImpl(option);
1266 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1267
1268 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1269 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1270 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1271 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1272 ASSERT_EQ(WMError::WM_OK, window->Show());
1273 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1274 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1275 .WillOnce(Return(WMError::WM_OK));
1276 ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1277 ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1278 ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MINIMUM_BRIGHTNESS));
1279 ASSERT_EQ(MINIMUM_BRIGHTNESS, window->GetBrightness());
1280
1281 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1282 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1283 }
1284
1285 /**
1286 * @tc.name: SetBrightness03
1287 * @tc.desc: test SetBrightness with invalid type window
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(WindowImplTest, SetBrightness03, Function | SmallTest | Level3)
1291 {
1292 sptr<WindowOption> option = new WindowOption();
1293 option->SetWindowName("SetBrightness03");
1294 option->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
1295 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1296 sptr<WindowImpl> window = new WindowImpl(option);
1297 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1298
1299 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1300 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1301 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1302 ASSERT_EQ(WMError::WM_OK, window->Show());
1303 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1304 ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1305 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1306
1307 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1308 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1309 }
1310
1311 /**
1312 * @tc.name: SetFocusable01
1313 * @tc.desc: create window but not show, test SetFocusable
1314 * @tc.type: FUNC
1315 */
1316 HWTEST_F(WindowImplTest, SetFocusable01, Function | SmallTest | Level3)
1317 {
1318 sptr<WindowOption> option = new WindowOption();
1319 option->SetWindowName("SetFocusable01");
1320 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1321 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1322 sptr<WindowImpl> window = new WindowImpl(option);
1323 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RequestFocus());
1324 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1325
1326 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1327 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1328 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1329 ASSERT_TRUE(window->GetFocusable());
1330 EXPECT_CALL(m->Mock(), RequestFocus(_)).WillOnce(Return(WMError::WM_OK));
1331 ASSERT_EQ(WMError::WM_OK, window->RequestFocus());
1332 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
1333 ASSERT_FALSE(window->GetFocusable());
1334 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
1335 ASSERT_TRUE(window->GetFocusable());
1336 WindowState state = window->GetWindowState();
1337 window->SetWindowState(WindowState::STATE_DESTROYED);
1338 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFocusable(false));
1339 ASSERT_TRUE(window->GetFocusable());
1340 window->SetWindowState(state);
1341 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1342 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1343 }
1344
1345 /**
1346 * @tc.name: SetFocusable02
1347 * @tc.desc: create window with show, test SetFocusable
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(WindowImplTest, SetFocusable02, Function | SmallTest | Level3)
1351 {
1352 sptr<WindowOption> option = new WindowOption();
1353 option->SetWindowName("SetFocusable02");
1354 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1355 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1356 sptr<WindowImpl> window = new WindowImpl(option);
1357 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1358
1359 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1360 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1361 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1362 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1363 ASSERT_EQ(WMError::WM_OK, window->Show());
1364 ASSERT_TRUE(window->GetFocusable());
1365 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1366 .WillOnce(Return(WMError::WM_OK));
1367 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
1368 ASSERT_FALSE(window->GetFocusable());
1369 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
1370 ASSERT_TRUE(window->GetFocusable());
1371
1372 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1373 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1374 }
1375
1376 /**
1377 * @tc.name: SetTouchable01
1378 * @tc.desc: create window but not show, test SetTouchable
1379 * @tc.type: FUNC
1380 */
1381 HWTEST_F(WindowImplTest, SetTouchable01, Function | SmallTest | Level3)
1382 {
1383 sptr<WindowOption> option = new WindowOption();
1384 option->SetWindowName("SetTouchable01");
1385 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1386 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1387 sptr<WindowImpl> window = new WindowImpl(option);
1388 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1389
1390 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1391 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1392 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1393 ASSERT_TRUE(window->GetTouchable());
1394 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
1395 ASSERT_FALSE(window->GetTouchable());
1396 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
1397 ASSERT_TRUE(window->GetTouchable());
1398 WindowState state = window->GetWindowState();
1399 window->SetWindowState(WindowState::STATE_DESTROYED);
1400 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTouchable(false));
1401 ASSERT_TRUE(window->GetTouchable());
1402 window->SetWindowState(state);
1403
1404 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1405 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1406 }
1407
1408 /**
1409 * @tc.name: SetTouchable02
1410 * @tc.desc: create window with show, test SetTouchable
1411 * @tc.type: FUNC
1412 */
1413 HWTEST_F(WindowImplTest, SetTouchable02, Function | SmallTest | Level3)
1414 {
1415 sptr<WindowOption> option = new WindowOption();
1416 option->SetWindowName("SetTouchable02");
1417 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1418 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1419 sptr<WindowImpl> window = new WindowImpl(option);
1420 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1421
1422 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1423 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1424 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1425 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1426 ASSERT_EQ(WMError::WM_OK, window->Show());
1427 ASSERT_TRUE(window->GetTouchable());
1428 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1429 .WillOnce(Return(WMError::WM_OK));
1430 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
1431 ASSERT_FALSE(window->GetTouchable());
1432 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
1433 ASSERT_TRUE(window->GetTouchable());
1434
1435 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1436 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1437 }
1438
1439 /**
1440 * @tc.name: DisableAppWindowDecor01
1441 * @tc.desc: disable app window decor
1442 * @tc.type: FUNC
1443 */
1444 HWTEST_F(WindowImplTest, DisableAppWindowDecor01, Function | SmallTest | Level3)
1445 {
1446 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1447 sptr<WindowOption> option = new WindowOption();
1448 option->SetWindowName("DisableAppWindowDecor01");
1449 sptr<WindowImpl> window = new WindowImpl(option);
1450
1451 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1452 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1453 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1454 window->property_->isDecorEnable_ = true;
1455 window->windowSystemConfig_.isSystemDecorEnable_ = false;
1456 window->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1457 window->DisableAppWindowDecor();
1458 ASSERT_FALSE(window->IsDecorEnable());
1459 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1460 window->DisableAppWindowDecor();
1461 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1462 ASSERT_EQ(WMError::WM_OK, window->Show());
1463 ASSERT_FALSE(window->IsDecorEnable());
1464 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1465 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1466 }
1467
1468 /**
1469 * @tc.name: SetTouchHotAreas01
1470 * @tc.desc: create window with show, test SetTouchHotAreas
1471 * @tc.type: FUNC
1472 */
1473 HWTEST_F(WindowImplTest, SetTouchHotAreas01, Function | SmallTest | Level3)
1474 {
1475 sptr<WindowOption> option = new WindowOption();
1476 option->SetWindowName("SetTouchHotAreas01");
1477 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1478 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1479 sptr<WindowImpl> window = new WindowImpl(option);
1480 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1481
1482 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1483 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1484 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1485 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1486 ASSERT_EQ(WMError::WM_OK, window->Show());
1487
1488 std::vector<Rect> requestedTouchHotAreas;
1489 window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
1490 ASSERT_TRUE(requestedTouchHotAreas.empty());
1491
1492 std::vector<Rect> rects;
1493 rects.emplace_back(Rect{ 0, 0, 720, 400 });
1494 rects.emplace_back(Rect{ 0, 800, 720, 300 });
1495 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1496 ASSERT_EQ(WMError::WM_OK, window->SetTouchHotAreas(rects));
1497 window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
1498 ASSERT_EQ(rects.size(), requestedTouchHotAreas.size());
1499 for (uint32_t i = 0; i < rects.size(); ++i) {
1500 ASSERT_TRUE(rects[i] == requestedTouchHotAreas[i]);
1501 }
1502
1503 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1504 rects.clear();
1505 ASSERT_EQ(WMError::WM_OK, window->SetTouchHotAreas(rects));
1506 window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
1507 ASSERT_TRUE(requestedTouchHotAreas.empty());
1508
1509 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1510 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1511 }
1512
1513 /**
1514 * @tc.name: SetTransform01
1515 * @tc.desc: set transform
1516 * @tc.type: FUNC
1517 * @tc.require: issueI5NDLK
1518 */
1519 HWTEST_F(WindowImplTest, SetTransform01, Function | SmallTest | Level3)
1520 {
1521 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1522 sptr<WindowOption> option = new WindowOption();
1523 option->SetWindowName("SetTransform01");
1524 sptr<WindowImpl> window = new WindowImpl(option);
1525 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1526 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1527 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1528 window->DisableAppWindowDecor();
1529 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1530 ASSERT_EQ(WMError::WM_OK, window->Show());
1531 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
1532 Transform trans_;
1533 window->UpdateZoomTransform(trans_, true);
1534 ASSERT_TRUE(window->GetZoomTransform() == trans_);
1535 window->SetTransform(trans_);
1536 window->UpdateZoomTransform(trans_, false);
1537 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
1538 window->SetTransform(trans_);
1539 ASSERT_TRUE(trans_ == window->GetTransform());
1540 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1541 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1542 }
1543
1544 /**
1545 * @tc.name: SetTransform02
1546 * @tc.desc: set transform and getTransform
1547 * @tc.type: FUNC
1548 * @tc.require: issueI5NDLK
1549 */
1550 HWTEST_F(WindowImplTest, SetTransform02, Function | SmallTest | Level3)
1551 {
1552 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1553 sptr<WindowOption> option = new WindowOption();
1554 option->SetWindowName("SetTransform01");
1555 sptr<WindowImpl> window = new WindowImpl(option);
1556 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1557 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1558 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1559 window->DisableAppWindowDecor();
1560 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1561 ASSERT_EQ(WMError::WM_OK, window->Show());
1562 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
1563 Transform trans_;
1564 trans_.pivotX_ = 1.0f;
1565 trans_.pivotY_ = 0.6f;
1566 window->SetTransform(trans_);
1567 ASSERT_TRUE(trans_ != window->GetTransform());
1568 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1569 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1570 }
1571
1572 /**
1573 * @tc.name: SetTransform03
1574 * @tc.desc: set transform and getTransform
1575 * @tc.type: FUNC
1576 * @tc.require: issueI5NDLK
1577 */
1578 HWTEST_F(WindowImplTest, SetTransform03, Function | SmallTest | Level3)
1579 {
1580 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1581 sptr<WindowOption> option = new WindowOption();
1582 option->SetWindowName("SetTransform01");
1583 sptr<WindowImpl> window = new WindowImpl(option);
1584 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1585 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1586 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1587 window->DisableAppWindowDecor();
1588 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1589 ASSERT_EQ(WMError::WM_OK, window->Show());
1590 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1591 Transform trans_;
1592 trans_.pivotX_ = 1.0f;
1593 trans_.pivotY_ = 0.6f;
1594 window->SetTransform(trans_);
1595 ASSERT_TRUE(trans_ == window->GetTransform());
1596 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1597 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1598 }
1599
1600 /**
1601 * @tc.name: SetTransform04
1602 * @tc.desc: set transform and getTransform
1603 * @tc.type: FUNC
1604 * @tc.require: issueI5NDLK
1605 */
1606 HWTEST_F(WindowImplTest, SetTransform04, Function | SmallTest | Level3)
1607 {
1608 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1609 sptr<WindowOption> option = new WindowOption();
1610 option->SetWindowName("SetTransform01");
1611 sptr<WindowImpl> window = new WindowImpl(option);
1612 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1613 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1614 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1615 window->DisableAppWindowDecor();
1616 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1617 ASSERT_EQ(WMError::WM_OK, window->Show());
1618 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1619 Transform trans_;
1620 trans_.pivotX_ = 1.0f;
1621 trans_.pivotY_ = 0.6f;
1622 Transform defaultTrans_;
1623 window->SetTransform(trans_);
1624 ASSERT_TRUE(defaultTrans_ != window->GetTransform());
1625 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1626 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1627 }
1628
1629 /**
1630 * @tc.name: SetAPPWindowLabel
1631 * @tc.desc: set window label to ace
1632 * @tc.type: FUNC
1633 * @tc.require: issueI5Q2KW
1634 */
1635 HWTEST_F(WindowImplTest, SetAPPWindowLabel, Function | SmallTest | Level3)
1636 {
1637 sptr<WindowOption> option = new WindowOption();
1638 option->SetWindowName("SetAPPWindowLabel");
1639 sptr<WindowImpl> window = new WindowImpl(option);
1640 std::string label = "openharmony";
1641
1642 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1643 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1644 EXPECT_CALL(*content, SetAppWindowTitle(_));
1645 ASSERT_EQ(WMError::WM_OK, window->SetAPPWindowLabel(label));
1646 window->uiContent_ = nullptr;
1647 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowLabel(label));
1648 }
1649
1650 /**
1651 * @tc.name: SetAPPWindowIcon
1652 * @tc.desc: set window Icon to ace
1653 * @tc.type: FUNC
1654 * @tc.require: issueI5Q2KW
1655 */
1656 HWTEST_F(WindowImplTest, SetAPPWindowIcon, Function | SmallTest | Level3)
1657 {
1658 sptr<WindowOption> option = new WindowOption();
1659 option->SetWindowName("SetAPPWindowIcon");
1660 sptr<WindowImpl> window = new WindowImpl(option);
1661
1662 std::shared_ptr<Media::PixelMap> icon1(nullptr);
1663 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowIcon(icon1));
1664 std::shared_ptr<Media::PixelMap> icon2 = std::make_shared<Media::PixelMap>();
1665 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowIcon(icon2));
1666 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1667 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1668 EXPECT_CALL(*content, SetAppWindowIcon(_));
1669 ASSERT_EQ(WMError::WM_OK, window->SetAPPWindowIcon(icon2));
1670 }
1671
1672 /**
1673 * @tc.name: NotifyMemoryLevel01
1674 * @tc.desc: NotifyMemoryLevel without mainWindow
1675 * @tc.type: FUNC
1676 * @tc.require: issueI5JQ04
1677 */
1678 HWTEST_F(WindowImplTest, NotifyMemoryLevel01, Function | SmallTest | Level2)
1679 {
1680 sptr<WindowOption> option = new WindowOption();
1681 option->SetWindowName("NotifyMemoryLevel01");
1682 int32_t level = 0;
1683 sptr<WindowImpl> window = new WindowImpl(option);
1684
1685 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->NotifyMemoryLevel(level));
1686 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1687 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1688 EXPECT_CALL(*content, NotifyMemoryLevel(_));
1689 ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(level));
1690 }
1691
1692 /**
1693 * @tc.name: StretchableUpdateRectDragStartTest
1694 * @tc.desc: UpdateRect test for stretchable window when drag start.
1695 * @tc.type: FUNC
1696 */
1697 HWTEST_F(WindowImplTest, StretchableUpdateRectDragStartTest, Function | SmallTest | Level3)
1698 {
1699 Rect rect1 { 10, 10, 10, 10 };
1700 sptr<WindowImpl> window;
1701 CreateStretchableWindow(window, rect1);
1702 ASSERT_NE(window, nullptr);
1703 Rect rect2 { 100, 100, 100, 100 };
1704 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1705 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1706 EXPECT_CALL(*content, UpdateViewportConfig(_, _, _));
1707 window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG_START);
1708 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
1709 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1710 EXPECT_CALL(*content, Destroy());
1711 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1712 }
1713
1714 /**
1715 * @tc.name: StretchableUpdateRectDragTest
1716 * @tc.desc: UpdateRect test for stretchable window when drag.
1717 * @tc.type: FUNC
1718 */
1719 HWTEST_F(WindowImplTest, StretchableUpdateRectDragTest, Function | SmallTest | Level3)
1720 {
1721 Rect rect1 { 10, 10, 10, 10 };
1722 sptr<WindowImpl> window;
1723 CreateStretchableWindow(window, rect1);
1724 ASSERT_NE(window, nullptr);
1725 Rect rect2 { 100, 100, 100, 100 };
1726 window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG);
1727 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
1728 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1729 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1730 }
1731
1732 /**
1733 * @tc.name: StretchableUpdateRectDragEndTest
1734 * @tc.desc: UpdateRect test for stretchable window when drag end.
1735 * @tc.type: FUNC
1736 */
1737 HWTEST_F(WindowImplTest, StretchableUpdateRectDragEndTest, Function | SmallTest | Level3)
1738 {
1739 Rect rect1 { 10, 10, 10, 10 };
1740 sptr<WindowImpl> window;
1741 CreateStretchableWindow(window, rect1);
1742 ASSERT_NE(window, nullptr);
1743 Rect rect2 { 100, 100, 100, 100 };
1744 window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG_END);
1745 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
1746 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1747 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1748 }
1749
1750 /**
1751 * @tc.name: StretchableUpdateRectRecoverTest
1752 * @tc.desc: UpdateRect test for stretchable window when recover.
1753 * @tc.type: FUNC
1754 */
1755 HWTEST_F(WindowImplTest, StretchableUpdateRectRecoverTest, Function | SmallTest | Level3)
1756 {
1757 Rect rect1 { 10, 10, 10, 10 };
1758 sptr<WindowImpl> window;
1759 CreateStretchableWindow(window, rect1);
1760 ASSERT_NE(window, nullptr);
1761 Rect rect2 { 100, 100, 100, 100 };
1762 window->UpdateRect(rect2, true, WindowSizeChangeReason::RECOVER);
1763 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
1764 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1765 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1766 }
1767
1768 /**
1769 * @tc.name: StretchableUpdateRectRecoverTest
1770 * @tc.desc: UpdateRect test for stretchable window when move.
1771 * @tc.type: FUNC
1772 */
1773 HWTEST_F(WindowImplTest, StretchableUpdateRectMoveTest, Function | SmallTest | Level3)
1774 {
1775 Rect rect1 { 10, 10, 10, 10 };
1776 sptr<WindowImpl> window;
1777 CreateStretchableWindow(window, rect1);
1778 ASSERT_NE(window, nullptr);
1779 Rect rect2 { 100, 100, 100, 100 };
1780 window->UpdateRect(rect2, true, WindowSizeChangeReason::MOVE);
1781 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
1782 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1783 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1784 }
1785
1786 /**
1787 * @tc.name: StretchableUpdateRectResizeTest
1788 * @tc.desc: UpdateRect test for stretchable window when resize.
1789 * @tc.type: FUNC
1790 */
1791 HWTEST_F(WindowImplTest, StretchableUpdateRectResizeTest, Function | SmallTest | Level3)
1792 {
1793 Rect rect1 { 110, 110, 10, 10 };
1794 sptr<WindowImpl> window;
1795 CreateStretchableWindow(window, rect1);
1796 ASSERT_NE(window, nullptr);
1797 Rect rect2 { 100, 100, 100, 100 };
1798 ASSERT_EQ(true, rect1.IsInsideOf(rect2));
1799 ASSERT_EQ(true, rect1 != rect2);
1800 window->UpdateRect(rect2, true, WindowSizeChangeReason::RESIZE);
1801 ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect2);
1802 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1803 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1804 }
1805
1806 /**
1807 * @tc.name: PrivacyMode01
1808 * @tc.desc: Set window privacy mode
1809 * @tc.type: FUNC
1810 * @tc.require: issueI5MYNX
1811 */
1812 HWTEST_F(WindowImplTest, PrivacyMode01, Function | SmallTest | Level3)
1813 {
1814 sptr<WindowOption> option = new WindowOption();
1815 option->SetWindowName("PrivacyMode01");
1816 sptr<WindowImpl> window = new WindowImpl(option);
1817 ASSERT_NE(nullptr, window);
1818
1819 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1820 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(8).WillRepeatedly(Return(WMError::WM_OK));
1821
1822 window->SetPrivacyMode(true);
1823 window->SetSystemPrivacyMode(true);
1824 ASSERT_EQ(true, window->IsPrivacyMode());
1825
1826 window->SetPrivacyMode(true);
1827 window->SetSystemPrivacyMode(false);
1828 ASSERT_EQ(true, window->IsPrivacyMode());
1829
1830 window->SetPrivacyMode(false);
1831 window->SetSystemPrivacyMode(true);
1832 ASSERT_EQ(false, window->IsPrivacyMode());
1833
1834 window->SetPrivacyMode(false);
1835 window->SetSystemPrivacyMode(false);
1836 ASSERT_EQ(false, window->IsPrivacyMode());
1837 }
1838
1839 /**
1840 * @tc.name: CalculatePointerDirection
1841 * @tc.desc: calculate mouse style id
1842 * @tc.type: FUNC
1843 */
1844 HWTEST_F(WindowImplTest, CalculatePointerDirection, Function | SmallTest | Level3)
1845 {
1846 Rect rect1 { 1, 1, 100, 100 };
1847 sptr<WindowOption> option = new WindowOption();
1848 option->SetWindowName("CalculatePointerDirection");
1849 sptr<WindowImpl> window = new WindowImpl(option);
1850
1851 window->moveDragProperty_->startRectExceptCorner_ = rect1;
1852 ASSERT_EQ(12, window->CalculatePointerDirection(0, 0));
1853 ASSERT_EQ(6, window->CalculatePointerDirection(50, 0));
1854 ASSERT_EQ(11, window->CalculatePointerDirection(102, 0));
1855 ASSERT_EQ(5, window->CalculatePointerDirection(102, 50));
1856 }
1857
1858 /*
1859 * @tc.name: FindWindowById
1860 * @tc.desc: FindWindowById Test
1861 * @tc.type: FUNC
1862 */
1863 HWTEST_F(WindowImplTest, FindWindowById, Function | SmallTest | Level3)
1864 {
1865 sptr<WindowOption> option = new WindowOption();
1866 option->SetWindowName("FindWindowById");
1867 sptr<WindowImpl> window = new WindowImpl(option);
1868 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1869 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1870 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1871 ASSERT_EQ(nullptr, window->FindWindowById(INVALID_WINDOW_ID));
1872 ASSERT_EQ(sptr<Window>(window), window->FindWindowById(window->GetWindowId()));
1873 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1874 ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithId(INVALID_WINDOW_ID));
1875 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1876 ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithId(INVALID_WINDOW_ID));
1877 std::shared_ptr<AbilityRuntime::Context> context;
1878 EXPECT_CALL(m->Mock(), GetTopWindowId(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1879 ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithContext(context));
1880 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1881 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1882 }
1883
1884 /*
1885 * @tc.name: GetSubWindow
1886 * @tc.desc: GetSubWindow Test
1887 * @tc.type: FUNC
1888 */
1889 HWTEST_F(WindowImplTest, GetSubWindow, Function | SmallTest | Level3)
1890 {
1891 sptr<WindowOption> option = new WindowOption();
1892 option->SetWindowName("main");
1893 sptr<WindowImpl> window = new WindowImpl(option);
1894 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1895 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1896 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1897
1898 option = new WindowOption();
1899 option->SetWindowName("sub");
1900 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1901 sptr<WindowImpl> subWindow = new WindowImpl(option);
1902 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1903 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1904 ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId()));
1905
1906 auto subWindowVec = sptr<Window>(window)->GetSubWindow(window->GetWindowId());
1907 ASSERT_EQ(1, subWindowVec.size());
1908 ASSERT_EQ(sptr<Window>(subWindow), subWindowVec[0]);
1909 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1910 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1911 }
1912
1913 /*
1914 * @tc.name: UpdateConfigurationForAll
1915 * @tc.desc: UpdateConfigurationForAll Test
1916 * @tc.type: FUNC
1917 */
1918 HWTEST_F(WindowImplTest, UpdateConfigurationForAll, Function | SmallTest | Level3)
1919 {
1920 sptr<WindowOption> option = new WindowOption();
1921 sptr<WindowImpl> window = new WindowImpl(option);
1922 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1923 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1924 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1925 std::shared_ptr<AppExecFwk::Configuration> configuration;
1926 sptr<Window>(window)->UpdateConfigurationForAll(configuration);
1927 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1928 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1929 }
1930
1931 /*
1932 * @tc.name: SetAlpha
1933 * @tc.desc: SetAlpha | GetAlpha
1934 * @tc.type: FUNC
1935 */
1936 HWTEST_F(WindowImplTest, SetAlpha, Function | SmallTest | Level3)
1937 {
1938 sptr<WindowOption> option = new WindowOption();
1939 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1940 sptr<WindowImpl> window = new WindowImpl(option);
1941
1942 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1943 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1944 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1945 float alpha = 0.5f;
1946 window->SetAlpha(alpha);
1947 ASSERT_EQ(alpha, window->GetAlpha());
1948 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1949 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1950 }
1951
1952 /*
1953 * @tc.name: GetAvoidAreaByType
1954 * @tc.desc: Test GetAvoidAreaByType when ret is not ok
1955 * @tc.type: FUNC
1956 */
1957 HWTEST_F(WindowImplTest, GetAvoidAreaByType, Function | SmallTest | Level3)
1958 {
1959 sptr<WindowOption> option = new WindowOption();
1960 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1961 sptr<WindowImpl> window = new WindowImpl(option);
1962
1963 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1964 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1965 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1966 EXPECT_CALL(m->Mock(), GetAvoidAreaByType(_, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1967 AvoidArea avoidarea;
1968 ASSERT_EQ(WMError::WM_DO_NOTHING, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
1969 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1970 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1971 }
1972
1973 /*
1974 * @tc.name: SetWindowType
1975 * @tc.desc: SetWindowType Test
1976 * @tc.type: FUNC
1977 */
1978 HWTEST_F(WindowImplTest, SetWindowType, Function | SmallTest | Level3)
1979 {
1980 sptr<WindowOption> option = new WindowOption();
1981 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1982 sptr<WindowImpl> window = new WindowImpl(option);
1983
1984 window->SetWindowState(WindowState::STATE_DESTROYED);
1985 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
1986
1987 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1988 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1989 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1990 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowType(WindowType::SYSTEM_WINDOW_END));
1991
1992 window->SetWindowState(WindowState::STATE_FROZEN);
1993 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
1994
1995 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1996 ASSERT_EQ(WMError::WM_OK, window->Destroy());
1997 }
1998
1999 /*
2000 * @tc.name: SetWindowMode
2001 * @tc.desc: SetWindowMode Test
2002 * @tc.type: FUNC
2003 */
2004 HWTEST_F(WindowImplTest, SetWindowMode, Function | SmallTest | Level3)
2005 {
2006 sptr<WindowOption> option = new WindowOption();
2007 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
2008 sptr<WindowImpl> window = new WindowImpl(option);
2009
2010 window->SetWindowState(WindowState::STATE_DESTROYED);
2011 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
2012 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2013 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2014 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2015 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2016 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2017 EXPECT_CALL(*content, HideWindowTitleButton(_, _, _));
2018 EXPECT_CALL(*content, UpdateWindowMode(_, _));
2019 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
2020 window->uiContent_ = nullptr;
2021
2022 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2023 ASSERT_EQ(WMError::WM_OK, window->Show());
2024 window->UpdateModeSupportInfo(0);
2025 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE,
2026 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
2027 window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
2028 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2029 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
2030 window->SetWindowState(WindowState::STATE_FROZEN);
2031 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
2032
2033 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2034 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2035 }
2036
2037 /*
2038 * @tc.name: WindowFlag
2039 * @tc.desc: GetWindowFlags | SetWindowFlags | AddWindowFlag | RemoveWindowFlag
2040 * @tc.type: FUNC
2041 */
2042 HWTEST_F(WindowImplTest, WindowFlag, Function | SmallTest | Level3)
2043 {
2044 sptr<WindowOption> option = new WindowOption();
2045 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2046 sptr<WindowImpl> window = new WindowImpl(option);
2047 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
2048 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2049 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2050 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2051 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2052 ASSERT_EQ(WMError::WM_OK, window->Show());
2053 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
2054 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
2055 ASSERT_EQ(static_cast<uint32_t>(1), window->GetWindowFlags());
2056 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
2057 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2058 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetWindowFlags(static_cast<uint32_t>(0)));
2059 ASSERT_EQ(static_cast<uint32_t>(1), window->GetWindowFlags());
2060 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2061 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2062 }
2063
2064 /*
2065 * @tc.name: OnNewWant
2066 * @tc.desc: OnNewWant test
2067 * @tc.type: FUNC
2068 */
2069 HWTEST_F(WindowImplTest, OnNewWant, Function | SmallTest | Level3)
2070 {
2071 sptr<WindowOption> option = new WindowOption();
2072 sptr<WindowImpl> window = new WindowImpl(option);
2073
2074 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2075 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2076 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2077 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2078 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2079 AAFwk::Want want;
2080 EXPECT_CALL(*content, OnNewWant(_)).Times(1).WillOnce(Return());
2081 window->OnNewWant(want);
2082 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2083 EXPECT_CALL(*content, Destroy());
2084 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2085 }
2086
2087 /*
2088 * @tc.name: GetContentInfo
2089 * @tc.desc: GetContentInfo test
2090 * @tc.type: FUNC
2091 */
2092 HWTEST_F(WindowImplTest, GetContentInfo, Function | SmallTest | Level3)
2093 {
2094 sptr<WindowOption> option = new WindowOption();
2095 sptr<WindowImpl> window = new WindowImpl(option);
2096 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2097 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2098 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2099 ASSERT_EQ(std::string(""), window->GetContentInfo());
2100 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2101 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2102 EXPECT_CALL(*content, GetContentInfo()).Times(1).WillOnce(Return("info"));
2103 ASSERT_EQ(std::string("info"), window->GetContentInfo());
2104 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2105 EXPECT_CALL(*content, Destroy());
2106 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2107 }
2108
2109 /*
2110 * @tc.name: Snapshot
2111 * @tc.desc: Snapshot test
2112 * @tc.type: FUNC
2113 */
2114 HWTEST_F(WindowImplTest, Snapshot, Function | SmallTest | Level3)
2115 {
2116 sptr<WindowOption> option = new WindowOption();
2117 sptr<WindowImpl> window = new WindowImpl(option);
2118
2119 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2120 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2121 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2122
2123 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2124 ASSERT_EQ(WMError::WM_OK, window->Show());
2125
2126 ASSERT_EQ(nullptr, window->Snapshot());
2127
2128 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2129 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2130 }
2131
2132 /*
2133 * @tc.name: DumpInfo
2134 * @tc.desc: DumpInfo test
2135 * @tc.type: FUNC
2136 */
2137 HWTEST_F(WindowImplTest, DumpInfo, Function | SmallTest | Level3)
2138 {
2139 sptr<WindowOption> option = new WindowOption();
2140 sptr<WindowImpl> window = new WindowImpl(option);
2141
2142 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2143 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2144 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2145
2146 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2147 ASSERT_EQ(WMError::WM_OK, window->Show());
2148 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2149 std::vector<std::string> params{"-h"};
2150 std::vector<std::string> info{""};
2151 window->DumpInfo(params, info);
2152 params.push_back("");
2153 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2154 EXPECT_CALL(*content, DumpInfo(_, _)).Times(1).WillOnce(Return());
2155 window->DumpInfo(params, info);
2156 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2157 EXPECT_CALL(*content, Destroy());
2158 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2159 }
2160
2161 /*
2162 * @tc.name: SetLayoutFullScreen
2163 * @tc.desc: SetLayoutFullScreen test
2164 * @tc.type: FUNC
2165 */
2166 HWTEST_F(WindowImplTest, SetLayoutFullScreen, Function | SmallTest | Level3)
2167 {
2168 sptr<WindowOption> option = new WindowOption();
2169 sptr<WindowImpl> window = new WindowImpl(option);
2170
2171 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(true));
2172
2173 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2174 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2175 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2176
2177 window->UpdateModeSupportInfo(0);
2178 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(true));
2179 window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
2180
2181 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2182 ASSERT_EQ(WMError::WM_OK, window->Show());
2183
2184 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2185 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
2186
2187 window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
2188 (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2189 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
2190 .WillOnce(Return(WMError::WM_OK))
2191 .WillOnce(Return(WMError::WM_OK));
2192 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
2193
2194 window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
2195 (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2196 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
2197 .WillOnce(Return(WMError::WM_OK))
2198 .WillOnce(Return(WMError::WM_DO_NOTHING));
2199 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
2200
2201 window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
2202 (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2203 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
2204 .WillOnce(Return(WMError::WM_OK))
2205 .WillOnce(Return(WMError::WM_OK));
2206 ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
2207
2208 window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
2209 (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2210 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
2211 .WillOnce(Return(WMError::WM_OK))
2212 .WillOnce(Return(WMError::WM_DO_NOTHING));
2213 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(false));
2214
2215 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2216 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2217 }
2218
2219 /*
2220 * @tc.name: SetFullScreen
2221 * @tc.desc: SetFullScreen test
2222 * @tc.type: FUNC
2223 */
2224 HWTEST_F(WindowImplTest, SetFullScreen, Function | SmallTest | Level3)
2225 {
2226 sptr<WindowOption> option = new WindowOption();
2227 sptr<WindowImpl> window = new WindowImpl(option);
2228
2229 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(true));
2230
2231 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2232 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2233 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2234
2235 window->UpdateModeSupportInfo(0);
2236 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(true));
2237 window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
2238
2239 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2240 ASSERT_EQ(WMError::WM_OK, window->Show());
2241
2242 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
2243 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
2244 window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
2245 (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2246 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3).WillRepeatedly(Return(WMError::WM_OK));
2247 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
2248
2249 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
2250 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
2251 window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
2252 (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2253 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
2254 .WillRepeatedly(Return(WMError::WM_OK));
2255 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
2256
2257 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
2258 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
2259 window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
2260 (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2261 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
2262 .WillOnce(Return(WMError::WM_OK))
2263 .WillOnce(Return(WMError::WM_DO_NOTHING));
2264 ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetFullScreen(true));
2265
2266 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
2267 window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
2268 window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
2269 (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
2270 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
2271 .WillOnce(Return(WMError::WM_DO_NOTHING))
2272 .WillOnce(Return(WMError::WM_OK))
2273 .WillOnce(Return(WMError::WM_OK));
2274 ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
2275
2276 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2277 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2278 }
2279
2280 /*
2281 * @tc.name: UpdateTitleButtonVisibility
2282 * @tc.desc: UpdateTitleButtonVisibility test
2283 * @tc.type: FUNC
2284 */
2285 HWTEST_F(WindowImplTest, UpdateTitleButtonVisibility, Function | SmallTest | Level3)
2286 {
2287 sptr<WindowOption> option = new WindowOption();
2288 sptr<WindowImpl> window = new WindowImpl(option);
2289
2290 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2291 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2292 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2293
2294 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2295 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2296 EXPECT_CALL(*content, HideWindowTitleButton(_, _, _));
2297 window->UpdateTitleButtonVisibility();
2298
2299 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2300 EXPECT_CALL(*content, Destroy());
2301 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2302 }
2303
2304 /*
2305 * @tc.name: WindowCreateCheck
2306 * @tc.desc: WindowCreateCheck test
2307 * @tc.type: FUNC
2308 */
2309 HWTEST_F(WindowImplTest, WindowCreateCheck, Function | SmallTest | Level3)
2310 {
2311 sptr<WindowOption> option = new WindowOption();
2312 option->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW);
2313 sptr<WindowImpl> window = new WindowImpl(option);
2314
2315 ASSERT_EQ(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, window->GetType());
2316 ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(INVALID_WINDOW_ID));
2317 ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(static_cast<uint32_t>(-1)));
2318 }
2319
2320 /*
2321 * @tc.name: BindDialogTarget
2322 * @tc.desc: BindDialogTarget test
2323 * @tc.type: FUNC
2324 */
2325 HWTEST_F(WindowImplTest, BindDialogTarget, Function | SmallTest | Level3)
2326 {
2327 sptr<WindowOption> option = new WindowOption();
2328 sptr<WindowImpl> window = new WindowImpl(option);
2329
2330 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2331 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2332 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2333
2334 EXPECT_CALL(m->Mock(), BindDialogTarget(_, _)).Times(2)
2335 .WillOnce(Return(WMError::WM_OK))
2336 .WillOnce(Return(WMError::WM_DO_NOTHING));
2337 sptr<IRemoteObject> targetToken;
2338 ASSERT_EQ(WMError::WM_OK, window->BindDialogTarget(targetToken));
2339 ASSERT_EQ(WMError::WM_DO_NOTHING, window->BindDialogTarget(targetToken));
2340
2341 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2342 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2343 }
2344
2345 /*
2346 * @tc.name: Destroy
2347 * @tc.desc: Destroy test
2348 * @tc.type: FUNC
2349 */
2350 HWTEST_F(WindowImplTest, Destroy, Function | SmallTest | Level3)
2351 {
2352 sptr<WindowOption> option = new WindowOption();
2353 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2354 sptr<WindowImpl> window = new WindowImpl(option);
2355
2356 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2357 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2358 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2359
2360 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2361 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
2362
2363 window->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
2364 ASSERT_EQ(WindowType::WINDOW_TYPE_DIALOG, window->GetType());
2365 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2366 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
2367 }
2368
2369 /*
2370 * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
2371 * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation test
2372 * @tc.type: FUNC
2373 */
2374 HWTEST_F(WindowImplTest, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)
2375 {
2376 sptr<WindowOption> option = new WindowOption();
2377 sptr<WindowImpl> window = new WindowImpl(option);
2378 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->UpdateSurfaceNodeAfterCustomAnimation(true));
2379
2380 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2381 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).WillOnce(Return(WMError::WM_OK));
2382 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2383 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2384 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->UpdateSurfaceNodeAfterCustomAnimation(true));
2385
2386 window->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
2387 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
2388 ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
2389
2390 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
2391 EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
2392 ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
2393
2394 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
2395 EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_OK));
2396 ASSERT_EQ(WMError::WM_OK, window->UpdateSurfaceNodeAfterCustomAnimation(true));
2397
2398 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2399 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2400 }
2401
2402 /**
2403 * @tc.name: ShowHide
2404 * @tc.desc: Show and Hide test
2405 * @tc.type: FUNC
2406 */
2407 HWTEST_F(WindowImplTest, ShowHide, Function | SmallTest | Level3)
2408 {
2409 sptr<WindowOption> option = new WindowOption();
2410 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2411 sptr<WindowImpl> window = new WindowImpl(option);
2412 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Show());
2413 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Hide());
2414 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2415 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2416 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2417
2418 auto state = window->GetWindowState();
2419 window->SetWindowState(WindowState::STATE_FROZEN);
2420 ASSERT_EQ(WindowState::STATE_FROZEN, window->GetWindowState());
2421 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->PreProcessShow(0, false));
2422 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Show());
2423
2424 window->SetWindowState(state);
2425 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2426 ASSERT_EQ(WMError::WM_OK, window->Show());
2427 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
2428
2429 ASSERT_EQ(WMError::WM_OK, window->Show(static_cast<uint32_t>(WindowStateChangeReason::KEYGUARD)));
2430 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
2431 ASSERT_EQ(WMError::WM_OK, window->Show());
2432
2433 window->property_->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
2434 ASSERT_EQ(WindowType::WINDOW_TYPE_DESKTOP, window->GetType());
2435 EXPECT_CALL(m->Mock(), MinimizeAllAppWindows(_));
2436 ASSERT_EQ(WMError::WM_OK, window->Show());
2437
2438 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
2439 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Hide());
2440 ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
2441
2442 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2443
2444 ASSERT_EQ(WMError::WM_OK, window->Hide(static_cast<uint32_t>(WindowStateChangeReason::TOGGLING)));
2445 ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
2446
2447 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE));
2448 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, window->Show());
2449 ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
2450
2451 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2452 ASSERT_EQ(WMError::WM_DO_NOTHING, window->Show());
2453 ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
2454
2455 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2456 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2457 }
2458
2459 /*
2460 * @tc.name: CloseWindow
2461 * @tc.desc: CloseWindow test
2462 * @tc.type: FUNC
2463 */
2464 HWTEST_F(WindowImplTest, CloseWindow, Function | SmallTest | Level3)
2465 {
2466 sptr<WindowOption> option = new WindowOption();
2467 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2468 sptr<WindowImpl> window = new WindowImpl(option);
2469 std::shared_ptr<AbilityRuntime::AbilityContext> context =
2470 std::make_shared<AbilityRuntime::AbilityContextImpl>();
2471 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2472 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2473 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID, context));
2474 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2475 ASSERT_EQ(WMError::WM_OK, window->Show());
2476 ASSERT_EQ(WMError::WM_OK, window->Close());
2477 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2478 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2479 }
2480
2481 /*
2482 * @tc.name: PendingCloseWindow
2483 * @tc.desc: PendingCloseWindow test
2484 * @tc.type: FUNC
2485 */
2486 HWTEST_F(WindowImplTest, PendingCloseWindow, Function | SmallTest | Level3)
2487 {
2488 sptr<WindowOption> option = new WindowOption();
2489 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2490 sptr<WindowImpl> window = new WindowImpl(option);
2491 window->PendingClose();
2492 ASSERT_EQ(nullptr, window->context_);
2493 }
2494
2495 /*
2496 * @tc.name: InvalidWindow
2497 * @tc.desc: InvalidWindow test
2498 * @tc.type: FUNC
2499 */
2500 HWTEST_F(WindowImplTest, InvalidWindow, Function | SmallTest | Level3)
2501 {
2502 sptr<WindowOption> option = new WindowOption();
2503 sptr<WindowImpl> window = new WindowImpl(option);
2504 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveTo(0, 0));
2505 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(0, 0));
2506 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetCallingWindow(INVALID_WINDOW_ID));
2507 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBackgroundColor(std::string("???")));
2508 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Close());
2509 }
2510
2511 /*
2512 * @tc.name: BackgroundColor
2513 * @tc.desc: GetBackgroundColor | SetBackGroundColor test
2514 * @tc.type: FUNC
2515 */
2516 HWTEST_F(WindowImplTest, BackgroundColor, Function | SmallTest | Level3)
2517 {
2518 sptr<WindowOption> option = new WindowOption();
2519 sptr<WindowImpl> window = new WindowImpl(option);
2520
2521 MockAceAbilityHandler* aceAbilityHandler = new MockAceAbilityHandler();
2522 window->aceAbilityHandler_ = aceAbilityHandler;
2523 EXPECT_CALL(*aceAbilityHandler, SetBackgroundColor(_));
2524 ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
2525 EXPECT_CALL(*aceAbilityHandler, GetBackgroundColor()).WillOnce(Return(0));
2526 ASSERT_EQ(0, window->GetBackgroundColor());
2527
2528 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2529 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2530 EXPECT_CALL(*content, SetBackgroundColor(_));
2531 ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
2532 EXPECT_CALL(*content, GetBackgroundColor()).WillOnce(Return(0));
2533 ASSERT_EQ(0, window->GetBackgroundColor());
2534 }
2535
2536 /*
2537 * @tc.name: SetTransparent
2538 * @tc.desc: SetTransparent test
2539 * @tc.type: FUNC
2540 */
2541 HWTEST_F(WindowImplTest, SetTransparent, Function | SmallTest | Level3)
2542 {
2543 sptr<WindowOption> option = new WindowOption();
2544 sptr<WindowImpl> window = new WindowImpl(option);
2545
2546 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
2547
2548 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2549 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2550 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2551
2552 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetTransparent(true));
2553 ASSERT_EQ(WMError::WM_OK, window->SetTransparent(false));
2554
2555 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2556 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2557 }
2558
2559 /*
2560 * @tc.name: TransferLifeCycleEventToString
2561 * @tc.desc: TransferLifeCycleEventToString test
2562 * @tc.type: FUNC
2563 */
2564 HWTEST_F(WindowImplTest, TransferLifeCycleEventToString, Function | SmallTest | Level3)
2565 {
2566 sptr<WindowOption> option = new WindowOption();
2567 sptr<WindowImpl> window = new WindowImpl(option);
2568 ASSERT_EQ(std::string("DESTROY"), window->TransferLifeCycleEventToString(LifeCycleEvent::DESTROY_EVENT));
2569 ASSERT_EQ(std::string("UNDEFINE"), window->TransferLifeCycleEventToString(
2570 static_cast<LifeCycleEvent>(uint32_t(-1))));
2571 }
2572
2573 /*
2574 * @tc.name: NotifyWindowTransition
2575 * @tc.desc: NotifyWindowTransition test
2576 * @tc.type: FUNC
2577 */
2578 HWTEST_F(WindowImplTest, NotifyWindowTransition, Function | SmallTest | Level3)
2579 {
2580 sptr<WindowOption> option = new WindowOption();
2581 sptr<WindowImpl> window = new WindowImpl(option);
__anon5faf42c00202(std::string) 2582 NotifyNativeWinDestroyFunc func = [](std::string) {};
2583 window->RegisterWindowDestroyedListener(func);
2584 ASSERT_EQ(WMError::WM_ERROR_NO_MEM, window->NotifyWindowTransition(TransitionReason::ABILITY_TRANSITION));
2585 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2586 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2587 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2588 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2589 ASSERT_EQ(WMError::WM_OK, window->Close());
2590 }
2591
2592 /*
2593 * @tc.name: RegisterAnimationTransitionController
2594 * @tc.desc: RegisterAnimationTransitionController test
2595 * @tc.type: FUNC
2596 */
2597 HWTEST_F(WindowImplTest, RegisterAnimationTransitionController, Function | SmallTest | Level3)
2598 {
2599 sptr<WindowOption> option = new WindowOption();
2600 sptr<WindowImpl> window = new WindowImpl(option);
2601 sptr<IAnimationTransitionController> listener;
2602 ASSERT_EQ(nullptr, listener);
2603 window->RegisterAnimationTransitionController(listener);
2604 listener = new MockAnimationTransitionController();
2605 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2606 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2607 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
2608 window->RegisterAnimationTransitionController(listener);
2609 window->property_ = new WindowProperty();
2610 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
2611 window->RegisterAnimationTransitionController(listener);
2612 window->property_->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
2613 EXPECT_CALL(*content, SetNextFrameLayoutCallback(_));
2614 window->RegisterAnimationTransitionController(listener);
2615 }
2616
2617 /*
2618 * @tc.name: RegisterDialogDeathRecipientListener
2619 * @tc.desc: RegisterDialogDeathRecipientListener | NotifyDestroy test
2620 * @tc.type: FUNC
2621 */
2622 HWTEST_F(WindowImplTest, RegisterDialogDeathRecipientListener, Function | SmallTest | Level3)
2623 {
2624 sptr<WindowOption> option = new WindowOption();
2625 sptr<WindowImpl> window = new WindowImpl(option);
2626
2627 sptr<MockDialogDeathRecipientListener> listener;
2628 ASSERT_EQ(nullptr, listener);
2629 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
2630 listener = new MockDialogDeathRecipientListener();
2631 ASSERT_NE(nullptr, listener);
2632 window->RegisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
2633 EXPECT_CALL(*listener, OnDialogDeathRecipient());
2634 window->NotifyDestroy();
2635 window->UnregisterDialogDeathRecipientListener(sptr<IDialogDeathRecipientListener>(listener));
2636 window->NotifyDestroy();
2637 }
2638
2639 /*
2640 * @tc.name: NotifyScreenshot
2641 * @tc.desc: NotifyScreenshot test
2642 * @tc.type: FUNC
2643 */
2644 HWTEST_F(WindowImplTest, NotifyScreenshot, Function | SmallTest | Level3)
2645 {
2646 sptr<WindowOption> option = new WindowOption();
2647 sptr<WindowImpl> window = new WindowImpl(option);
2648
2649 sptr<MockScreenshotListener> listener;
2650 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener));
2651 listener = new MockScreenshotListener;
2652 window->screenshotListeners_[window->GetWindowId()].push_back(sptr<IScreenshotListener>(listener));
2653 EXPECT_CALL(*listener, OnScreenshot()).Times(1);
2654 window->NotifyScreenshot();
2655 window->screenshotListeners_[window->GetWindowId()].clear();
2656 }
2657
2658 /*
2659 * @tc.name: NotifyTouchDialogTarget
2660 * @tc.desc: NotifyTouchDialogTarget test
2661 * @tc.type: FUNC
2662 */
2663 HWTEST_F(WindowImplTest, NotifyTouchDialogTarget, Function | SmallTest | Level3)
2664 {
2665 sptr<WindowOption> option = new WindowOption();
2666 sptr<WindowImpl> window = new WindowImpl(option);
2667
2668 sptr<MockDialogTargetTouchListener> listener;
2669 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener));
2670 listener = new MockDialogTargetTouchListener;
2671 window->dialogTargetTouchListeners_[window->GetWindowId()].push_back(sptr<IDialogTargetTouchListener>(listener));
2672 EXPECT_CALL(*listener, OnDialogTargetTouch());
2673 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
2674 window->NotifyTouchDialogTarget();
2675 window->dialogTargetTouchListeners_[window->GetWindowId()].clear();
2676 }
2677
2678 /*
2679 * @tc.name: NotifySizeChange
2680 * @tc.desc: NotifySizeChange test
2681 * @tc.type: FUNC
2682 */
2683 HWTEST_F(WindowImplTest, NotifySizeChange, Function | SmallTest | Level3)
2684 {
2685 sptr<WindowOption> option = new WindowOption();
2686 sptr<WindowImpl> window = new WindowImpl(option);
2687
2688 sptr<MockWindowChangeListener> listener;
2689 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
2690 listener = new MockWindowChangeListener;
2691 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
2692 EXPECT_CALL(*listener, OnSizeChange(_, _, _));
2693 Rect rect;
2694 window->NotifySizeChange(rect, WindowSizeChangeReason::UNDEFINED);
2695 window->windowChangeListeners_[window->GetWindowId()].clear();
2696 }
2697
2698 /*
2699 * @tc.name: NotifyModeChange
2700 * @tc.desc: NotifyModeChange test
2701 * @tc.type: FUNC
2702 */
2703 HWTEST_F(WindowImplTest, NotifyModeChange, Function | SmallTest | Level3)
2704 {
2705 sptr<WindowOption> option = new WindowOption();
2706 sptr<WindowImpl> window = new WindowImpl(option);
2707
2708 sptr<MockWindowChangeListener> listener;
2709 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
2710 listener = new MockWindowChangeListener;
2711 window->windowChangeListeners_[window->GetWindowId()].push_back(sptr<IWindowChangeListener>(listener));
2712 EXPECT_CALL(*listener, OnModeChange(_, _));
2713 window->NotifyModeChange(WindowMode::WINDOW_MODE_UNDEFINED);
2714 window->windowChangeListeners_[window->GetWindowId()].clear();
2715 }
2716
2717 /*
2718 * @tc.name: NotifyAvoidAreaChange
2719 * @tc.desc: NotifyAvoidAreaChange test
2720 * @tc.type: FUNC
2721 */
2722 HWTEST_F(WindowImplTest, NotifyAvoidAreaChange, Function | SmallTest | Level3)
2723 {
2724 sptr<WindowOption> option = new WindowOption();
2725 sptr<WindowImpl> window = new WindowImpl(option);
2726
2727 sptr<MockAvoidAreaChangedListener> listener;
2728 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener));
2729 listener = new MockAvoidAreaChangedListener;
2730 window->avoidAreaChangeListeners_[window->GetWindowId()].push_back(sptr<IAvoidAreaChangedListener>(listener));
2731 EXPECT_CALL(*listener, OnAvoidAreaChanged(_, _));
2732 sptr<AvoidArea> avoidArea = new AvoidArea;
2733 window->NotifyAvoidAreaChange(avoidArea, AvoidAreaType::TYPE_CUTOUT);
2734 window->avoidAreaChangeListeners_[window->GetWindowId()].clear();
2735 }
2736
2737 /*
2738 * @tc.name: NotifyDisplayMoveChange
2739 * @tc.desc: NotifyDisplayMoveChange test
2740 * @tc.type: FUNC
2741 */
2742 HWTEST_F(WindowImplTest, NotifyDisplayMoveChange, Function | SmallTest | Level3)
2743 {
2744 sptr<WindowOption> option = new WindowOption();
2745 sptr<WindowImpl> window = new WindowImpl(option);
2746
2747 sptr<MockDisplayMoveListener> listener;
2748 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener));
2749 listener = new MockDisplayMoveListener;
2750 window->displayMoveListeners_.push_back(sptr<IDisplayMoveListener>(listener));
2751 EXPECT_CALL(*listener, OnDisplayMove(_, _));
2752 window->NotifyDisplayMoveChange(DisplayId{}, DisplayId{});
2753 }
2754
2755 /*
2756 * @tc.name: SetAceAbilityHandler
2757 * @tc.desc: SetAceAbilityHandler test
2758 * @tc.type: FUNC
2759 */
2760 HWTEST_F(WindowImplTest, SetAceAbilityHandler, Function | SmallTest | Level3)
2761 {
2762 sptr<WindowOption> option = new WindowOption();
2763 sptr<WindowImpl> window = new WindowImpl(option);
2764
2765 sptr<IAceAbilityHandler> handler;
2766 ASSERT_EQ(nullptr, handler);
2767 window->SetAceAbilityHandler(handler);
2768 handler = new MockAceAbilityHandler();
2769 ASSERT_NE(nullptr, handler);
2770 window->SetAceAbilityHandler(handler);
2771 }
2772
2773 /*
2774 * @tc.name: HandleBackKeyPressedEvent
2775 * @tc.desc: HandleBackKeyPressedEvent test
2776 * @tc.type: FUNC
2777 */
2778 HWTEST_F(WindowImplTest, HandleBackKeyPressedEvent, Function | SmallTest | Level3)
2779 {
2780 sptr<WindowOption> option = new WindowOption();
2781 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2782 sptr<WindowImpl> window = new WindowImpl(option);
2783 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType());
2784 std::shared_ptr<MMI::KeyEvent> keyEvent;
2785 window->HandleBackKeyPressedEvent(keyEvent);
2786
2787 window->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
2788 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2789 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2790 EXPECT_CALL(*content, ProcessBackPressed()).WillOnce(Return(false));
2791 window->HandleBackKeyPressedEvent(keyEvent);
2792
2793 window->inputEventConsumer_.reset(new MockInputEventConsumer);
2794 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()),
2795 OnInputEvent(keyEvent)).WillOnce(Return(true));
2796 window->HandleBackKeyPressedEvent(keyEvent);
2797 }
2798
2799 /*
2800 * @tc.name: ConsumeKeyEvent
2801 * @tc.desc: ConsumeKeyEvent test
2802 * @tc.type: FUNC
2803 */
2804 HWTEST_F(WindowImplTest, ConsumeKeyEvent, Function | SmallTest | Level3)
2805 {
2806 sptr<WindowOption> option = new WindowOption();
2807 option->SetWindowType(WindowType::WINDOW_TYPE_APP_COMPONENT);
2808 sptr<WindowImpl> window = new WindowImpl(option);
2809 std::shared_ptr<MMI::KeyEvent> keyEvent = std::make_shared<MockKeyEvent>();
2810 EXPECT_CALL(m->Mock(), DispatchKeyEvent(_, _));
2811 window->ConsumeKeyEvent(keyEvent);
2812 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
2813 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2814 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2815 EXPECT_CALL(*content, ProcessKeyEvent(_));
2816 window->ConsumeKeyEvent(keyEvent);
2817
2818 window->inputEventConsumer_.reset(new MockInputEventConsumer);
2819 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()),
2820 OnInputEvent(keyEvent));
2821 window->ConsumeKeyEvent(keyEvent);
2822
2823 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_BACK);
2824 keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_UP);
2825 window->inputEventConsumer_ = nullptr;
2826 EXPECT_CALL(*content, ProcessBackPressed());
2827 window->ConsumeKeyEvent(keyEvent);
2828 }
2829
2830 /*
2831 * @tc.name: ConsumePointerEvent
2832 * @tc.desc: ConsumePointerEvent test
2833 * @tc.type: FUNC
2834 */
2835 HWTEST_F(WindowImplTest, ConsumePointerEvent, Function | SmallTest | Level3)
2836 {
2837 sptr<WindowOption> option = new WindowOption();
2838 option->SetWindowType(WindowType::WINDOW_TYPE_LAUNCHER_RECENT);
2839 sptr<WindowImpl> window = new WindowImpl(option);
2840 Rect rect{ 0, 0, 10u, 10u };
2841 window->property_->SetWindowRect(rect);
2842 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
2843 MMI::PointerEvent::PointerItem item;
2844 pointerEvent->SetPointerId(0);
2845 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
2846 window->ConsumePointerEvent(pointerEvent);
2847
2848 item.SetPointerId(0);
2849 item.SetDisplayX(15); // 15 : position x
2850 item.SetDisplayY(15); // 15 : position y
2851 pointerEvent->AddPointerItem(item);
2852 window->ConsumePointerEvent(pointerEvent);
2853
2854 item.SetDisplayX(5); // 5 : position x
2855 item.SetDisplayY(5); // 5 : position y
2856 pointerEvent->UpdatePointerItem(0, item);
2857 EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
2858 window->ConsumePointerEvent(pointerEvent);
2859 }
2860
2861 /*
2862 * @tc.name: HandleModeChangeHotZones
2863 * @tc.desc: HandleModeChangeHotZones test
2864 * @tc.type: FUNC
2865 */
2866 HWTEST_F(WindowImplTest, HandleModeChangeHotZones, Function | SmallTest | Level3)
2867 {
2868 sptr<WindowOption> option = new WindowOption();
2869 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2870 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
2871 sptr<WindowImpl> window = new WindowImpl(option);
2872 window->HandleModeChangeHotZones(0, 0);
2873 window->property_->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2874 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
2875 window->HandleModeChangeHotZones(0, 0);
2876 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2877 window->HandleModeChangeHotZones(0, 0);
2878 }
2879
2880 /*
2881 * @tc.name: UpdatePointerEventForStretchableWindow
2882 * @tc.desc: UpdatePointerEventForStretchableWindow test
2883 * @tc.type: FUNC
2884 */
2885 HWTEST_F(WindowImplTest, UpdatePointerEventForStretchableWindow, Function | SmallTest | Level3)
2886 {
2887 sptr<WindowOption> option = new WindowOption();
2888 sptr<WindowImpl> window = new WindowImpl(option);
2889 window->property_->SetWindowRect(Rect{ 0, 0, 10, 10 });
2890 window->property_->SetOriginRect(Rect{ 0, 0, 100, 100 });
2891 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
2892 MMI::PointerEvent::PointerItem item;
2893 ASSERT_FALSE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item));
2894 window->UpdatePointerEventForStretchableWindow(pointerEvent);
2895 pointerEvent->SetPointerId(0);
2896 item.SetPointerId(0);
2897 item.SetDisplayX(5); // 5 : position x
2898 item.SetDisplayY(5); // 5 : position y
2899 pointerEvent->AddPointerItem(item);
2900 window->UpdatePointerEventForStretchableWindow(pointerEvent);
2901 ASSERT_TRUE(pointerEvent->GetPointerItem(pointerEvent->GetPointerId(), item));
2902 ASSERT_EQ(50, item.GetDisplayX());
2903 ASSERT_EQ(50, item.GetDisplayY());
2904 }
2905
2906 /**
2907 * @tc.name: MoveDrag
2908 * @tc.desc: StartMove | ReadyToMoveOrDragWindow | EndMoveOrDragWindow test
2909 * @tc.type: FUNC
2910 */
2911 HWTEST_F(WindowImplTest, MoveDrag, Function | SmallTest | Level3)
2912 {
2913 sptr<WindowOption> option = new WindowOption();
2914 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2915 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2916 sptr<WindowImpl> window = new WindowImpl(option);
2917
2918 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2919 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2920 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2921 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2922 window->Show();
2923 window->moveDragProperty_->startDragFlag_ = false;
2924 window->moveDragProperty_->pointEventStarted_ = true;
2925 EXPECT_CALL(m->Mock(), NotifyServerReadyToMoveOrDrag(_, _, _));
2926 window->StartMove();
2927 window->moveDragProperty_->pointEventStarted_ = false;
2928 window->StartMove();
2929
2930 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
2931 MMI::PointerEvent::PointerItem item;
2932 pointerEvent->SetTargetDisplayId(0);
2933 item.SetDisplayX(10000);
2934 item.SetDisplayY(10000);
2935
2936 window->moveDragProperty_->pointEventStarted_ = true;
2937 window->ReadyToMoveOrDragWindow(pointerEvent, item);
2938 window->moveDragProperty_->startMoveFlag_ = true;
2939 window->moveDragProperty_->startDragFlag_ = true;
2940 EXPECT_CALL(m->Mock(), ProcessPointUp(_)).Times(2);
2941 EXPECT_CALL(m->Mock(), GetModeChangeHotZones(_, _));
2942 window->EndMoveOrDragWindow(uint32_t(), uint32_t(),
2943 window->moveDragProperty_->startPointerId_, window->moveDragProperty_->sourceType_);
2944
2945 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2946 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2947 }
2948
2949 /*
2950 * @tc.name: TransferPointerEvent
2951 * @tc.desc: TransferPointerEvent test
2952 * @tc.type: FUNC
2953 */
2954 HWTEST_F(WindowImplTest, TransferPointerEvent, Function | SmallTest | Level3)
2955 {
2956 sptr<WindowOption> option = new WindowOption();
2957 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
2958 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
2959 sptr<WindowImpl> window = new WindowImpl(option);
2960 std::shared_ptr<MMI::PointerEvent> pointerEvent = std::make_shared<MockPointerEvent>();
2961 window->windowSystemConfig_.isStretchable_ = true;
2962 window->TransferPointerEvent(pointerEvent);
2963 window->windowSystemConfig_.isStretchable_ = false;
2964 window->TransferPointerEvent(pointerEvent);
2965 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
2966 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
2967 EXPECT_CALL(*content, ProcessPointerEvent(_));
2968 window->TransferPointerEvent(pointerEvent);
2969
2970 window->inputEventConsumer_.reset(new MockInputEventConsumer);
2971 EXPECT_CALL(*reinterpret_cast<MockInputEventConsumer*>(window->inputEventConsumer_.get()),
2972 OnInputEvent(pointerEvent));
2973 window->TransferPointerEvent(pointerEvent);
2974 }
2975
2976 /*
2977 * @tc.name: RequestVsync
2978 * @tc.desc: RequestVsync test
2979 * @tc.type: FUNC
2980 */
2981 HWTEST_F(WindowImplTest, RequestVsync, Function | SmallTest | Level3)
2982 {
2983 sptr<WindowOption> option = new WindowOption();
2984 sptr<WindowImpl> window = new WindowImpl(option);
2985
2986 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
2987 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
2988 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
2989
2990 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2991 ASSERT_EQ(WMError::WM_OK, window->Show());
2992 std::shared_ptr<VsyncCallback> callback;
2993 window->RequestVsync(callback);
2994
2995 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
2996 ASSERT_EQ(WMError::WM_OK, window->Destroy());
2997 ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
2998 window->RequestVsync(callback);
2999 }
3000
3001 /*
3002 * @tc.name: UpdateConfiguration
3003 * @tc.desc: UpdateConfiguration test
3004 * @tc.type: FUNC
3005 */
3006 HWTEST_F(WindowImplTest, UpdateConfiguration, Function | SmallTest | Level3)
3007 {
3008 sptr<WindowOption> option = new WindowOption();
3009 sptr<WindowImpl> window = new WindowImpl(option);
3010 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3011 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3012 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
3013
3014 option = new WindowOption();
3015 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
3016 option->SetWindowName("subwindow");
3017 sptr<WindowImpl> subWindow = new WindowImpl(option);
3018 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3019 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3020 ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId()));
3021 std::shared_ptr<AppExecFwk::Configuration> configuration;
3022 window->UpdateConfiguration(configuration);
3023
3024 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
3025 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
3026 subWindow->uiContent_ = std::make_unique<Ace::UIContentMocker>();
3027 Ace::UIContentMocker* subContent = reinterpret_cast<Ace::UIContentMocker*>(subWindow->uiContent_.get());
3028 EXPECT_CALL(*content, UpdateConfiguration(_));
3029 EXPECT_CALL(*subContent, UpdateConfiguration(_));
3030 window->UpdateConfiguration(configuration);
3031 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3032 EXPECT_CALL(*content, Destroy());
3033 EXPECT_CALL(*subContent, Destroy());
3034 ASSERT_EQ(WMError::WM_OK, window->Destroy());
3035 }
3036
3037 /*
3038 * @tc.name: UpdateWindowState
3039 * @tc.desc: UpdateWindowState test
3040 * @tc.type: FUNC
3041 */
3042 HWTEST_F(WindowImplTest, UpdateWindowState, Function | SmallTest | Level3)
3043 {
3044 sptr<WindowOption> option = new WindowOption();
3045 sptr<WindowImpl> window = new WindowImpl(option);
3046
3047 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3048 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3049 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
3050 window->UpdateWindowState(WindowState::STATE_FROZEN);
3051 window->UpdateWindowState(WindowState::STATE_UNFROZEN);
3052 window->UpdateWindowState(WindowState::STATE_SHOWN);
3053 EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3054 window->UpdateWindowState(WindowState::STATE_HIDDEN);
3055 window->UpdateWindowState(WindowState::STATE_INITIAL);
3056 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3057 ASSERT_EQ(WMError::WM_OK, window->Destroy());
3058 }
3059
3060 /*
3061 * @tc.name: RestoreSplitWindowMode
3062 * @tc.desc: RestoreSplitWindowMode test
3063 * @tc.type: FUNC
3064 */
3065 HWTEST_F(WindowImplTest, RestoreSplitWindowMode, Function | SmallTest | Level3)
3066 {
3067 sptr<WindowOption> option = new WindowOption();
3068 sptr<WindowImpl> window = new WindowImpl(option);
3069 window->RestoreSplitWindowMode(0u);
3070 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3071 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3072 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
3073 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
3074 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
3075 window->RestoreSplitWindowMode(static_cast<uint32_t>(WindowMode::WINDOW_MODE_UNDEFINED));
3076 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3077 ASSERT_EQ(WMError::WM_OK, window->Destroy());
3078 }
3079
3080 /*
3081 * @tc.name: IsFocused
3082 * @tc.desc: IsFocused test
3083 * @tc.type: FUNC
3084 */
3085 HWTEST_F(WindowImplTest, IsFocused, Function | SmallTest | Level3)
3086 {
3087 sptr<WindowOption> option = new WindowOption();
3088 sptr<WindowImpl> window = new WindowImpl(option);
3089 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3090 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3091 ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
3092 window->UpdateFocusStatus(false);
3093 ASSERT_FALSE(window->IsFocused());
3094 window->UpdateFocusStatus(true);
3095 ASSERT_TRUE(window->IsFocused());
3096 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3097 ASSERT_EQ(WMError::WM_OK, window->Destroy());
3098 }
3099
3100 /*
3101 * @tc.name: UpdateSubWindowStateAndNotify
3102 * @tc.desc: update subwindow state
3103 * @tc.type: FUNC
3104 */
3105 HWTEST_F(WindowImplTest, UpdateSubWindowStateAndNotify, Function | SmallTest | Level3)
3106 {
3107 sptr<WindowOption> option = new WindowOption();
3108 option->SetWindowName("main");
3109 sptr<WindowImpl> mainWindow = new WindowImpl(option);
3110 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3111 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3112 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
3113 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId()));
3114
3115 option = new WindowOption();
3116 option->SetWindowName("sub");
3117 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
3118 sptr<WindowImpl> subWindow = new WindowImpl(option);
3119 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3120 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3121 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
3122
3123 // main window hide
3124 mainWindow->state_ = WindowState::STATE_HIDDEN;
3125 subWindow->state_ = WindowState::STATE_SHOWN;
3126 subWindow->subWindowState_ = WindowState::STATE_SHOWN;
3127 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
3128 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
3129
3130 // main window show
3131 mainWindow->state_ = WindowState::STATE_SHOWN;
3132 subWindow->state_ = WindowState::STATE_SHOWN;
3133 subWindow->subWindowState_ = WindowState::STATE_HIDDEN;
3134 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
3135 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_SHOWN);
3136
3137 subWindow->state_ = WindowState::STATE_HIDDEN;
3138 mainWindow->UpdateSubWindowStateAndNotify(mainWindow->GetWindowId());
3139 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
3140
3141 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3142 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
3143 }
3144
3145 /*
3146 * @tc.name: UpdateWindowStateWhenHide
3147 * @tc.desc: UpdateWindowStateWhenHide test
3148 * @tc.type: FUNC
3149 */
3150 HWTEST_F(WindowImplTest, UpdateWindowStateWhenHide, Function | SmallTest | Level3)
3151 {
3152 sptr<WindowOption> option = new WindowOption();
3153 option->SetWindowName("main");
3154 sptr<WindowImpl> mainWindow = new WindowImpl(option);
3155 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3156 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3157 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
3158 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenHide());
3159
3160 option = new WindowOption();
3161 option->SetWindowName("sub");
3162 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
3163 sptr<WindowImpl> subWindow = new WindowImpl(option);
3164 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3165 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3166 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
3167 subWindow->subWindowState_ = WindowState::STATE_SHOWN;
3168 subWindow->UpdateWindowStateWhenHide();
3169 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
3170 subWindow->subWindowState_ = WindowState::STATE_HIDDEN;
3171 subWindow->UpdateWindowStateWhenHide();
3172 ASSERT_EQ(subWindow->subWindowState_, WindowState::STATE_HIDDEN);
3173
3174 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3175 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
3176 }
3177
3178 /*
3179 * @tc.name: UpdateWindowStateWhenShow
3180 * @tc.desc: UpdateWindowStateWhenShow test
3181 * @tc.type: FUNC
3182 */
3183 HWTEST_F(WindowImplTest, UpdateWindowStateWhenShow, Function | SmallTest | Level3)
3184 {
3185 sptr<WindowOption> option = new WindowOption();
3186 option->SetWindowName("main");
3187 sptr<WindowImpl> mainWindow = new WindowImpl(option);
3188 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3189 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3190 ASSERT_EQ(WMError::WM_OK, mainWindow->Create(INVALID_WINDOW_ID));
3191 ASSERT_EQ(WmErrorCode::WM_OK, mainWindow->UpdateWindowStateWhenShow());
3192
3193 option = new WindowOption();
3194 option->SetWindowName("sub");
3195 option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
3196 sptr<WindowImpl> subWindow = new WindowImpl(option);
3197 EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
3198 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
3199 ASSERT_EQ(WMError::WM_OK, subWindow->Create(mainWindow->GetWindowId()));
3200 ASSERT_EQ(WmErrorCode::WM_OK, subWindow->UpdateWindowStateWhenShow());
3201
3202 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3203 ASSERT_EQ(WMError::WM_OK, mainWindow->Destroy());
3204 }
3205
3206 /*
3207 * @tc.name: RaiseToAppTop
3208 * @tc.desc: RaiseToAppTop test
3209 * @tc.type: FUNC
3210 */
3211 HWTEST_F(WindowImplTest, RaiseToAppTop, Function | SmallTest | Level3)
3212 {
3213 sptr<WindowOption> option = new WindowOption();
3214 option->parentId_ = INVALID_WINDOW_ID;
3215 sptr<WindowImpl> window = new WindowImpl(option);
3216 ASSERT_EQ(WmErrorCode::WM_ERROR_INVALID_PARENT, window->RaiseToAppTop());
3217
3218 window->property_->parentId_ = 100000;
3219 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
3220 ASSERT_EQ(WmErrorCode::WM_ERROR_INVALID_CALLING, window->RaiseToAppTop());
3221
3222 window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
3223 window->state_ = WindowState::STATE_HIDDEN;
3224 ASSERT_EQ(WmErrorCode::WM_ERROR_STATE_ABNORMALLY, window->RaiseToAppTop());
3225
3226 window->state_ = WindowState::STATE_SHOWN;
3227 EXPECT_CALL(m->Mock(), RaiseToAppTop(_)).Times(1).WillOnce(Return(WmErrorCode::WM_OK));
3228 ASSERT_EQ(WmErrorCode::WM_OK, window->RaiseToAppTop());
3229
3230 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
3231 ASSERT_EQ(WMError::WM_OK, window->Destroy());
3232 }
3233
3234 /*
3235 * @tc.name: UpdateDecorEnable
3236 * @tc.desc: UpdateDecorEnable test
3237 * @tc.type: FUNC
3238 */
3239 HWTEST_F(WindowImplTest, UpdateDecorEnable, Function | SmallTest | Level3)
3240 {
3241 sptr<WindowOption> option = new WindowOption();
3242 sptr<WindowImpl> window = new WindowImpl(option);
3243 window->property_->mode_ = WindowMode::WINDOW_MODE_FULLSCREEN;
3244 window->property_->type_ = WindowType::WINDOW_TYPE_APP_MAIN_WINDOW;
3245 window->windowSystemConfig_.isSystemDecorEnable_ = true;
3246 window->windowSystemConfig_.decorModeSupportInfo_ = WINDOW_MODE_SUPPORT_FLOATING;
3247 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
3248 Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
3249 sptr<MockWindowChangeListener> listener = new MockWindowChangeListener;
3250 window->RegisterWindowChangeListener(sptr<IWindowChangeListener>(listener));
3251
3252 EXPECT_CALL(*content, UpdateWindowMode(_, _));
3253 EXPECT_CALL(*listener, OnModeChange(_, _));
3254 window->UpdateDecorEnable(true);
3255 ASSERT_TRUE(window->IsDecorEnable());
3256 ASSERT_FALSE(window->property_->GetDecorEnable());
3257 window->windowSystemConfig_.decorModeSupportInfo_ = WINDOW_MODE_SUPPORT_ALL;
3258 window->UpdateDecorEnable();
3259 ASSERT_TRUE(window->IsDecorEnable());
3260 ASSERT_TRUE(window->property_->GetDecorEnable());
3261 window->property_->type_ = WindowType::WINDOW_TYPE_FLOAT;
3262 window->UpdateDecorEnable();
3263 ASSERT_FALSE(window->IsDecorEnable());
3264 ASSERT_FALSE(window->property_->GetDecorEnable());
3265 window->UnregisterWindowChangeListener(sptr<IWindowChangeListener>(listener));
3266 }
3267 }
3268 } // namespace Rosen
3269 } // namespace OHOS
3270