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 "window_impl_test.h"
17
18 using namespace testing;
19 using namespace testing::ext;
20
21 namespace OHOS {
22 namespace Rosen {
SetUpTestCase()23 void WindowImplTest::SetUpTestCase()
24 {
25 option_ = new WindowOption();
26 option_->SetWindowName("WindowImplTest");
27 window_ = new WindowImpl(option_);
28 abilityContext_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
29
30 m_ = std::make_unique<Mocker>();
31 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
32 window_->Create("");
33 }
34
TearDownTestCase()35 void WindowImplTest::TearDownTestCase()
36 {
37 EXPECT_CALL(m_->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
38 window_->Destroy();
39 }
40
SetUp()41 void WindowImplTest::SetUp()
42 {
43 }
44
TearDown()45 void WindowImplTest::TearDown()
46 {
47 }
48
49 namespace {
50 /**
51 * @tc.name: CreateWindow01
52 * @tc.desc: Create window with no parentName
53 * @tc.type: FUNC
54 */
55 HWTEST_F(WindowImplTest, CreateWindow01, Function | SmallTest | Level2)
56 {
57 sptr<WindowOption> option = new WindowOption();
58 option->SetWindowName("CreateWindow01");
59 sptr<WindowImpl> window = new WindowImpl(option);
60
61 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
62 ASSERT_EQ(WMError::WM_OK, window->Create(""));
63
64 EXPECT_CALL(m_->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
65 ASSERT_EQ(WMError::WM_OK, window->Destroy());
66 }
67
68 /**
69 * @tc.name: CreateWindow02
70 * @tc.desc: Create window with no parentName and no abilityContext
71 * @tc.type: FUNC
72 */
73 HWTEST_F(WindowImplTest, CreateWindow02, Function | SmallTest | Level2)
74 {
75 sptr<WindowOption> option = new WindowOption();
76 option->SetWindowName("CreateWindow02");
77 sptr<WindowImpl> window = new WindowImpl(option);
78
79 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
80 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Create(""));
81 }
82
83 /**
84 * @tc.name: CreateWindow03
85 * @tc.desc: Create window with illegal parentName
86 * @tc.type: FUNC
87 */
88 HWTEST_F(WindowImplTest, CreateWindow03, Function | SmallTest | Level2)
89 {
90 sptr<WindowOption> option = new WindowOption();
91 option->SetWindowName("CreateWindow03");
92 sptr<WindowImpl> window = new WindowImpl(option);
93 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->Create("illegal"));
94 }
95
96 /**
97 * @tc.name: CreateWindow04
98 * @tc.desc: Create window with repeated windowName
99 * @tc.type: FUNC
100 */
101 HWTEST_F(WindowImplTest, CreateWindow04, Function | SmallTest | Level2)
102 {
103 sptr<WindowOption> option = new WindowOption();
104 option->SetWindowName("WindowImplTest");
105 sptr<WindowImpl> window = new WindowImpl(option);
106
107 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->Create(""));
108 }
109
110 /**
111 * @tc.name: CreateWindow05
112 * @tc.desc: Create window with exist parentName
113 * @tc.type: FUNC
114 */
115 HWTEST_F(WindowImplTest, CreateWindow05, Function | SmallTest | Level2)
116 {
117 sptr<WindowOption> option = new WindowOption();
118 option->SetWindowName("CreateWindow05");
119 sptr<WindowImpl> window = new WindowImpl(option);
120
121 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
122 ASSERT_EQ(WMError::WM_OK, window->Create("WindowImplTest"));
123
124 EXPECT_CALL(m_->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
125 ASSERT_EQ(WMError::WM_OK, window->Destroy());
126 }
127
128 /**
129 * @tc.name: CreateWindow06
130 * @tc.desc: Create window with no default option, get and check Property
131 * @tc.type: FUNC
132 */
133 HWTEST_F(WindowImplTest, CreateWindow06, Function | SmallTest | Level2)
134 {
135 sptr<WindowOption> option = new WindowOption();
136 option->SetWindowName("CreateWindow06");
137 struct Rect rect = {1, 2, 3u, 4u};
138 option->SetWindowRect(rect);
139 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
140 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
141 sptr<WindowImpl> window = new WindowImpl(option);
142
143 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
144 ASSERT_EQ(WMError::WM_OK, window->Create(""));
145
146 ASSERT_EQ(1, window->GetRect().posX_);
147 ASSERT_EQ(2, window->GetRect().posY_);
148 ASSERT_EQ(3u, window->GetRect().width_);
149 ASSERT_EQ(4u, window->GetRect().height_);
150 ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType());
151 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
152 ASSERT_EQ("CreateWindow06", window->GetWindowName());
153
154 EXPECT_CALL(m_->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
155 ASSERT_EQ(WMError::WM_OK, window->Destroy());
156 }
157
158 /**
159 * @tc.name: CreateWindow07
160 * @tc.desc: Create window with no parentName and abilityContext
161 * @tc.type: FUNC
162 */
163 HWTEST_F(WindowImplTest, CreateWindow07, Function | SmallTest | Level2)
164 {
165 sptr<WindowOption> option = new WindowOption();
166 option->SetWindowName("CreateWindow07");
167 sptr<WindowImpl> window = new WindowImpl(option);
168
169 EXPECT_CALL(m_->Mock(), SaveAbilityToken(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
170 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
171 ASSERT_EQ(WMError::WM_OK, window->Create("", abilityContext_));
172 }
173
174 /**
175 * @tc.name: CreateWindow08
176 * @tc.desc: Mock SaveAbilityToken return WM_ERROR_NULLPTR, create window with no parentName and abilityContext
177 * @tc.type: FUNC
178 */
179 HWTEST_F(WindowImplTest, CreateWindow08, Function | SmallTest | Level2)
180 {
181 sptr<WindowOption> option = new WindowOption();
182 option->SetWindowName("CreateWindow08");
183 sptr<WindowImpl> window = new WindowImpl(option);
184
185 EXPECT_CALL(m_->Mock(), SaveAbilityToken(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_NULLPTR));
186 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
187 ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->Create("", abilityContext_));
188 }
189
190 /**
191 * @tc.name: FindWindow01
192 * @tc.desc: Find one exit window
193 * @tc.type: FUNC
194 */
195 HWTEST_F(WindowImplTest, FindWindow01, Function | SmallTest | Level2)
196 {
197 ASSERT_NE(nullptr, WindowImpl::Find("WindowImplTest"));
198 }
199
200 /**
201 * @tc.name: FindWindow02
202 * @tc.desc: Add another window, find both two windows
203 * @tc.type: FUNC
204 */
205 HWTEST_F(WindowImplTest, FindWindow02, Function | SmallTest | Level2)
206 {
207 sptr<WindowOption> option = new WindowOption();
208 option->SetWindowName("FindWindow02");
209 sptr<WindowImpl> window = new WindowImpl(option);
210
211 EXPECT_CALL(m_->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
212
213 ASSERT_EQ(WMError::WM_OK, window->Create(""));
214
215 ASSERT_NE(nullptr, WindowImpl::Find("WindowImplTest"));
216 ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02"));
217
218 EXPECT_CALL(m_->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
219 ASSERT_EQ(WMError::WM_OK, window->Destroy());
220 }
221
222 /**
223 * @tc.name: FindWindow03
224 * @tc.desc: Find one no exit window
225 * @tc.type: FUNC
226 */
227 HWTEST_F(WindowImplTest, FindWindow03, Function | SmallTest | Level2)
228 {
229 ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow03"));
230 }
231
232 /**
233 * @tc.name: FindWindow04
234 * @tc.desc: Find window with empty name
235 * @tc.type: FUNC
236 */
237 HWTEST_F(WindowImplTest, FindWindow04, Function | SmallTest | Level2)
238 {
239 ASSERT_EQ(nullptr, WindowImpl::Find(""));
240 }
241
242 /**
243 * @tc.name: FindWindow05
244 * @tc.desc: Find one destroyed window
245 * @tc.type: FUNC
246 */
247 HWTEST_F(WindowImplTest, FindWindow05, Function | SmallTest | Level2)
248 {
249 ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow02"));
250 }
251
252 /**
253 * @tc.name: SetWindowType01
254 * @tc.desc: SetWindowType
255 * @tc.type: FUNC
256 */
257 HWTEST_F(WindowImplTest, SetWindowType01, Function | SmallTest | Level2)
258 {
259 ASSERT_EQ(WMError::WM_OK, window_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
260 }
261
262 /**
263 * @tc.name: SetWindowMode01
264 * @tc.desc: SetWindowMode
265 * @tc.type: FUNC
266 */
267 HWTEST_F(WindowImplTest, SetWindowMode01, Function | SmallTest | Level2)
268 {
269 ASSERT_EQ(WMError::WM_OK, window_->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
270 }
271
272 /**
273 * @tc.name: SetWindowMode02
274 * @tc.desc: Set window mode to split primary
275 * @tc.type: FUNC
276 */
277 HWTEST_F(WindowImplTest, SetWindowMode02, Function | SmallTest | Level3)
278 {
279 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
280 sptr<WindowOption> option = new WindowOption();
281 option->SetWindowName("");
282 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
283 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
284 sptr<WindowImpl> window = new WindowImpl(option);
285 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
286 ASSERT_EQ(WMError::WM_OK, window->Create(""));
287 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
288 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
289 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, window->GetMode());
290 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
291 ASSERT_EQ(WMError::WM_OK, window->Destroy());
292 }
293
294 /**
295 * @tc.name: SetWindowMode03
296 * @tc.desc: Set window mode to split secondary
297 * @tc.type: FUNC
298 */
299 HWTEST_F(WindowImplTest, SetWindowMode03, Function | SmallTest | Level3)
300 {
301 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
302 sptr<WindowOption> option = new WindowOption();
303 option->SetWindowName("");
304 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
305 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
306 sptr<WindowImpl> window = new WindowImpl(option);
307 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
308 ASSERT_EQ(WMError::WM_OK, window->Create(""));
309 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
310 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
311 ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, window->GetMode());
312 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
313 ASSERT_EQ(WMError::WM_OK, window->Destroy());
314 }
315
316 /**
317 * @tc.name: SetWindowMode04
318 * @tc.desc: Set window mode to floating
319 * @tc.type: FUNC
320 */
321 HWTEST_F(WindowImplTest, SetWindowMode04, Function | SmallTest | Level3)
322 {
323 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
324 sptr<WindowOption> option = new WindowOption();
325 option->SetWindowName("");
326 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
327 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
328 sptr<WindowImpl> window = new WindowImpl(option);
329 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
330 ASSERT_EQ(WMError::WM_OK, window->Create(""));
331 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
332 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING));
333 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
334 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
335 ASSERT_EQ(WMError::WM_OK, window->Destroy());
336 }
337
338 /**
339 * @tc.name: SetWindowMode05
340 * @tc.desc: Set window mode to pip
341 * @tc.type: FUNC
342 */
343 HWTEST_F(WindowImplTest, SetWindowMode05, Function | SmallTest | Level3)
344 {
345 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
346 sptr<WindowOption> option = new WindowOption();
347 option->SetWindowName("");
348 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
349 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
350 sptr<WindowImpl> window = new WindowImpl(option);
351 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
352 ASSERT_EQ(WMError::WM_OK, window->Create(""));
353 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
354 ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_PIP));
355 ASSERT_EQ(WindowMode::WINDOW_MODE_PIP, window->GetMode());
356 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
357 ASSERT_EQ(WMError::WM_OK, window->Destroy());
358 }
359 /**
360 * @tc.name: ShowHideWindow01
361 * @tc.desc: Show and hide window with add and remove window ok
362 * @tc.type: FUNC
363 */
364 HWTEST_F(WindowImplTest, ShowHideWindow01, Function | SmallTest | Level2)
365 {
366 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
367 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
368 ASSERT_EQ(WMError::WM_OK, window_->Show());
369 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
370 ASSERT_EQ(WMError::WM_OK, window_->Hide());
371 }
372
373 /**
374 * @tc.name: ShowHideWindow02
375 * @tc.desc: Show window with add window WM_ERROR_SAMGR
376 * @tc.type: FUNC
377 */
378 HWTEST_F(WindowImplTest, ShowHideWindow02, Function | SmallTest | Level2)
379 {
380 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
381 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
382 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window_->Show());
383 }
384
385 /**
386 * @tc.name: ShowHideWindow03
387 * @tc.desc: Show window with add window WM_ERROR_IPC_FAILED
388 * @tc.type: FUNC
389 */
390 HWTEST_F(WindowImplTest, ShowHideWindow03, Function | SmallTest | Level3)
391 {
392 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
393 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
394 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window_->Show());
395 }
396
397 /**
398 * @tc.name: ShowHideWindow04
399 * @tc.desc: Show window with add window OK & Hide window with remove window WM_ERROR_SAMGR
400 * @tc.type: FUNC
401 */
402 HWTEST_F(WindowImplTest, ShowHideWindow04, Function | SmallTest | Level3)
403 {
404 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
405 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
406 ASSERT_EQ(WMError::WM_OK, window_->Show());
407 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
408 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window_->Hide());
409 }
410
411 /**
412 * @tc.name: ShowHideWindow05
413 * @tc.desc: Hide window with remove window WM_ERROR_IPC_FAILED
414 * @tc.type: FUNC
415 */
416 HWTEST_F(WindowImplTest, ShowHideWindow05, Function | SmallTest | Level3)
417 {
418 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
419 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
420 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window_->Hide());
421 }
422
423 /**
424 * @tc.name: ShowHideWindow06
425 * @tc.desc: Hide window with remove window OK
426 * @tc.type: FUNC
427 */
428 HWTEST_F(WindowImplTest, ShowHideWindow06, Function | SmallTest | Level3)
429 {
430 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
431 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
432 ASSERT_EQ(WMError::WM_OK, window_->Hide());
433 }
434
435 /**
436 * @tc.name: SetSystemBarProperty01
437 * @tc.desc: SetSystemBarProperty with default param
438 * @tc.type: FUNC
439 */
440 HWTEST_F(WindowImplTest, SetSystemBarProperty01, Function | SmallTest | Level3)
441 {
442 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
443 SystemBarProperty prop;
444 ASSERT_EQ(WMError::WM_OK, window_->SetSystemBarProperty(type, prop));
445 }
446
447 /**
448 * @tc.name: SetSystemBarProperty02
449 * @tc.desc: SetSystemBarProperty with adapter return WM_ERROR_SAMGR
450 * @tc.type: FUNC
451 */
452 HWTEST_F(WindowImplTest, SetSystemBarProperty02, Function | SmallTest | Level3)
453 {
454 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
455 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
456 window_->Show();
457 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
458 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
459 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
460 ASSERT_EQ(WMError::WM_ERROR_SAMGR, window_->SetSystemBarProperty(type, SYS_BAR_PROP));
461 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
462 window_->Hide();
463 }
464
465 /**
466 * @tc.name: SetSystemBarProperty03
467 * @tc.desc: SetSystemBarProperty to invalid window
468 * @tc.type: FUNC
469 */
470 HWTEST_F(WindowImplTest, SetSystemBarProperty03, Function | SmallTest | Level3)
471 {
472 sptr<WindowOption> option = new WindowOption();
473 option->SetWindowName("SetSystemBarPropertyWin03");
474 sptr<WindowImpl> window = new WindowImpl(option);
475 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
476 SystemBarProperty prop;
477 ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSystemBarProperty(type, prop));
478 }
479
480 /**
481 * @tc.name: GetSystemBarPropertyByType01
482 * @tc.desc: GetSystemBarPropertyByType with exist key
483 * @tc.type: FUNC
484 */
485 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType01, Function | SmallTest | Level3)
486 {
487 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
488 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
489 ASSERT_EQ(WMError::WM_OK, window_->Show());
490 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
491 WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
492 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333344);
493 ASSERT_EQ(WMError::WM_OK, window_->SetSystemBarProperty(type, SYS_BAR_PROP));
494 ASSERT_EQ(SYS_BAR_PROP, window_->GetSystemBarPropertyByType(type));
495 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
496 window_->Hide();
497 }
498
499 /**
500 * @tc.name: GetSystemBarPropertyByType02
501 * @tc.desc: GetSystemBarPropertyByType with nonexist key
502 * @tc.type: FUNC
503 */
504 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType02, Function | SmallTest | Level3)
505 {
506 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
507 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
508 window_->Show();
509 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
510 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
511 const SystemBarProperty DEFAULT_PROP;
512 ASSERT_EQ(WMError::WM_OK, window_->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
513 ASSERT_EQ(DEFAULT_PROP, window_->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR));
514 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
515 window_->Hide();
516 }
517
518 /**
519 * @tc.name: GetSystemBarPropertyByType03
520 * @tc.desc: GetSystemBarPropertyByType with not systemBar type
521 * @tc.type: FUNC
522 */
523 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType03, Function | SmallTest | Level3)
524 {
525 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
526 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
527 window_->Show();
528 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
529 const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333366);
530 const SystemBarProperty DEFAULT_PROP;
531 ASSERT_EQ(WMError::WM_OK, window_->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
532 ASSERT_EQ(DEFAULT_PROP, window_->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
533 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
534 window_->Hide();
535 }
536
537 /**
538 * @tc.name: IsDecorEnable01
539 * @tc.desc: IsDecorEnable default value is false
540 * @tc.type: FUNC
541 */
542 HWTEST_F(WindowImplTest, IsDecorEnable01, Function | SmallTest | Level3)
543 {
544 ASSERT_FALSE(window_->IsDecorEnable());
545 }
546
547 /**
548 * @tc.name: Maximize02
549 * @tc.desc: Maximize the sub window
550 * @tc.type: FUNC
551 */
552 HWTEST_F(WindowImplTest, Maximize02, Function | SmallTest | Level3)
553 {
554 auto option = new WindowOption();
555 option->SetWindowName("WindowImplTest_Maximize02");
556 auto window = new WindowImpl(option);
557 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
558 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
559 window->Create("");
560 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
561 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
562 window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
563 window->Show();
564 window->Maximize();
565 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
566 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
567 window->Hide();
568 }
569
570 /**
571 * @tc.name: Recover01
572 * @tc.desc: Recover the main window
573 * @tc.type: FUNC
574 */
575 HWTEST_F(WindowImplTest, Recover01, Function | SmallTest | Level3)
576 {
577 auto option = new WindowOption();
578 option->SetWindowName("WindowImplTest_Recover01");
579 auto window = new WindowImpl(option);
580 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
581 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
582 window->Create("");
583 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
584 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
585 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
586 window->Show();
587 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
588 window->Recover();
589 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
590 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
591 window->Hide();
592 }
593
594 /**
595 * @tc.name: Recover02
596 * @tc.desc: Recover the sub window
597 * @tc.type: FUNC
598 */
599 HWTEST_F(WindowImplTest, Recover02, Function | SmallTest | Level3)
600 {
601 auto option = new WindowOption();
602 option->SetWindowName("WindowImplTest_Recover02");
603 auto window = new WindowImpl(option);
604 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
605 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
606 window->Create("");
607 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
608 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
609 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
610 window->Show();
611 window->Recover();
612 ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetMode());
613 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
614 window->Hide();
615 }
616
617 /**
618 * @tc.name: Minimize01
619 * @tc.desc: Minimize the main window
620 * @tc.type: FUNC
621 */
622 HWTEST_F(WindowImplTest, Minimize01, Function | SmallTest | Level3)
623 {
624 auto option = new WindowOption();
625 option->SetWindowName("WindowImplTest_Minimize01");
626 auto window = new WindowImpl(option);
627 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
628 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
629 window->Create("");
630 window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
631 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
632 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
633 window->Show();
634 ASSERT_TRUE(window->GetShowState());
635 EXPECT_CALL(m->Mock(), RemoveWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
636 window->Minimize();
637 ASSERT_FALSE(window->GetShowState());
638 }
639
640 /**
641 * @tc.name: Minimize02
642 * @tc.desc: Minimize the sub window
643 * @tc.type: FUNC
644 */
645 HWTEST_F(WindowImplTest, Minimize02, Function | SmallTest | Level3)
646 {
647 auto option = new WindowOption();
648 option->SetWindowName("WindowImplTest_Minimize02");
649 auto window = new WindowImpl(option);
650 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
651 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
652 window->Create("");
653 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
654 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
655 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
656 window->Show();
657 ASSERT_TRUE(window->GetShowState());
658 window->Minimize();
659 ASSERT_TRUE(window->GetShowState());
660 }
661
662 /**
663 * @tc.name: IsSupportWideGamut01
664 * @tc.desc: IsSupportWideGamut
665 * @tc.type: FUNC
666 */
667 HWTEST_F(WindowImplTest, IsSupportWideGamut01, Function | SmallTest | Level3)
668 {
669 auto option = new WindowOption();
670 option->SetWindowName("WindowImplTest_IsSupportWideGamut01");
671 auto window = new WindowImpl(option);
672 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
673 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
674 window->Create("");
675 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
676 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
677 ASSERT_TRUE(window->IsSupportWideGamut());
678 }
679
680 /**
681 * @tc.name: SetColorSpace01
682 * @tc.desc: SetColorSpace
683 * @tc.type: FUNC
684 */
685 HWTEST_F(WindowImplTest, SetColorSpace01, Function | SmallTest | Level3)
686 {
687 auto option = new WindowOption();
688 option->SetWindowName("WindowImplTest_SetColorSpace01");
689 auto window = new WindowImpl(option);
690 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
691 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
692 window->Create("");
693 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
694 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
695 window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
696 }
697
698 /**
699 * @tc.name: GetColorSpace01
700 * @tc.desc: GetColorSpace
701 * @tc.type: FUNC
702 */
703 HWTEST_F(WindowImplTest, GetColorSpace01, Function | SmallTest | Level3)
704 {
705 auto option = new WindowOption();
706 option->SetWindowName("WindowImplTest_GetColorSpace01");
707 auto window = new WindowImpl(option);
708 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
709 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
710 window->Create("");
711 window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
712 window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
713 window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT);
714 ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
715 window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
716 ASSERT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace());
717 }
718
719 /**
720 * @tc.name: MoveTo01
721 * @tc.desc: create window but not show, move window, test rect
722 * @tc.type: FUNC
723 */
724 HWTEST_F(WindowImplTest, MoveTo01, Function | SmallTest | Level3)
725 {
726 sptr<WindowOption> option = new WindowOption();
727 option->SetWindowName("WindowImplTest_MoveTo01");
728 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
729 Rect winRect = {10, 20, 30u, 40u}; // set window rect: 10, 20, 30, 40
730 option->SetWindowRect(winRect);
731 sptr<WindowImpl> window = new WindowImpl(option);
732 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
733
734 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
735 ASSERT_EQ(WMError::WM_OK, window->Create(""));
736 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
737 ASSERT_FALSE(window->GetShowState());
738 const float moveRatio = 0.5;
739 Rect newRect = {winRect.posX_ * moveRatio, winRect.posY_ * moveRatio, winRect.width_, winRect.height_};
740 window->MoveTo(newRect.posX_, newRect.posY_);
741 ASSERT_EQ(newRect, window->GetRect());
742 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
743 ASSERT_EQ(WMError::WM_OK, window->Destroy());
744 }
745
746 /**
747 * @tc.name: Resize01
748 * @tc.desc: create window but not show, resize window, test rect
749 * @tc.type: FUNC
750 */
751 HWTEST_F(WindowImplTest, Resize01, Function | SmallTest | Level3)
752 {
753 sptr<WindowOption> option = new WindowOption();
754 option->SetWindowName("WindowImplTest_Resize01");
755 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
756 Rect winRect = {10, 20, 30u, 40u}; // set window rect: 10, 20, 30, 40
757 option->SetWindowRect(winRect);
758 sptr<WindowImpl> window = new WindowImpl(option);
759 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
760
761 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
762 ASSERT_EQ(WMError::WM_OK, window->Create(""));
763 ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetMode());
764 ASSERT_FALSE(window->GetShowState());
765 const float resizeRatio = 0.5;
766 Rect newRect = {winRect.posX_, winRect.posY_, winRect.width_ * resizeRatio, winRect.height_ * resizeRatio};
767 window->Resize(newRect.width_, newRect.height_);
768 ASSERT_EQ(newRect, window->GetRect());
769 EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
770 ASSERT_EQ(WMError::WM_OK, window->Destroy());
771 }
772
773 /**
774 * @tc.name: StartMove01
775 * @tc.desc: start move main fullscreen window, test startMoveFlag
776 * @tc.type: FUNC
777 */
778 HWTEST_F(WindowImplTest, StartMove01, Function | SmallTest | Level3)
779 {
780 sptr<WindowOption> option = new WindowOption();
781 option->SetWindowName("WindowImplTest_StartMove01");
782 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
783 sptr<WindowImpl> window = new WindowImpl(option);
784 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
785
786 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
787 ASSERT_EQ(WMError::WM_OK, window->Create(""));
788 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
789 window->Show();
790 window->StartMove();
791 ASSERT_FALSE(window->startMoveFlag_);
792 }
793
794 /**
795 * @tc.name: StartMove02
796 * @tc.desc: start move main fullscreen window, test startMoveFlag
797 * @tc.type: FUNC
798 */
799 HWTEST_F(WindowImplTest, StartMove02, Function | SmallTest | Level3)
800 {
801 sptr<WindowOption> option = new WindowOption();
802 option->SetWindowName("WindowImplTest_StartMove02");
803 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
804 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
805 sptr<WindowImpl> window = new WindowImpl(option);
806 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
807
808 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
809 ASSERT_EQ(WMError::WM_OK, window->Create(""));
810 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
811 window->Show();
812
813 window->StartMove();
814 ASSERT_TRUE(window->startMoveFlag_);
815 }
816
817 /**
818 * @tc.name: StartMove03
819 * @tc.desc: start move divider, test startMoveFlag
820 * @tc.type: FUNC
821 */
822 HWTEST_F(WindowImplTest, StartMove03, Function | SmallTest | Level3)
823 {
824 sptr<WindowOption> option = new WindowOption();
825 option->SetWindowName("WindowImplTest_StartMove03");
826 option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
827 option->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
828 sptr<WindowImpl> window = new WindowImpl(option);
829 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
830
831 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
832 ASSERT_EQ(WMError::WM_OK, window->Create(""));
833 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
834 window->Show();
835 window->StartMove();
836 ASSERT_FALSE(window->startMoveFlag_);
837 }
838
839 /**
840 * @tc.name: SetBackgroundColor01
841 * @tc.desc: test SetBackgroundColor withow uiContent
842 * @tc.type: FUNC
843 */
844 HWTEST_F(WindowImplTest, SetBackgroundColor01, Function | SmallTest | Level3)
845 {
846 sptr<WindowOption> option = new WindowOption();
847 option->SetWindowName("SetBackgroundColor01");
848 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
849 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
850 sptr<WindowImpl> window = new WindowImpl(option);
851 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
852
853 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
854 ASSERT_EQ(WMError::WM_OK, window->Create(""));
855 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
856 window->Show();
857 ASSERT_FALSE(window->IsTransparent());
858 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackgroundColor("#000"));
859 ASSERT_FALSE(window->IsTransparent());
860 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#00FF00"));
861 ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#FF00FF00"));
862 }
863
864 /**
865 * @tc.name: SetTurnScreenOn01
866 * @tc.desc: create window but not show, test SetTurnScreenOn
867 * @tc.type: FUNC
868 */
869 HWTEST_F(WindowImplTest, SetTurnScreenOn01, Function | SmallTest | Level3)
870 {
871 sptr<WindowOption> option = new WindowOption();
872 option->SetWindowName("WindowImplTest_SetTurnScreenOn01");
873 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
874 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
875 sptr<WindowImpl> window = new WindowImpl(option);
876 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
877
878 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
879 ASSERT_EQ(WMError::WM_OK, window->Create(""));
880 ASSERT_FALSE(window->IsTurnScreenOn());
881 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
882 ASSERT_TRUE(window->IsTurnScreenOn());
883 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
884 ASSERT_FALSE(window->IsTurnScreenOn());
885 }
886
887
888 /**
889 * @tc.name: SetTurnScreenOn02
890 * @tc.desc: create window with show, test SetTurnScreenOn
891 * @tc.type: FUNC
892 */
893 HWTEST_F(WindowImplTest, SetTurnScreenOn02, Function | SmallTest | Level3)
894 {
895 sptr<WindowOption> option = new WindowOption();
896 option->SetWindowName("WindowImplTest_SetTurnScreenOn02");
897 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
898 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
899 sptr<WindowImpl> window = new WindowImpl(option);
900 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
901
902 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
903 ASSERT_EQ(WMError::WM_OK, window->Create(""));
904 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
905 ASSERT_EQ(WMError::WM_OK, window->Show());
906 ASSERT_FALSE(window->IsTurnScreenOn());
907 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
908 .WillOnce(Return(WMError::WM_OK));
909 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
910 ASSERT_TRUE(window->IsTurnScreenOn());
911 ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
912 ASSERT_FALSE(window->IsTurnScreenOn());
913 }
914
915 /**
916 * @tc.name: SetKeepScreenOn01
917 * @tc.desc: create window but not show, test SetKeepScreenOn
918 * @tc.type: FUNC
919 */
920 HWTEST_F(WindowImplTest, SetKeepScreenOn01, Function | SmallTest | Level3)
921 {
922 sptr<WindowOption> option = new WindowOption();
923 option->SetWindowName("WindowImplTest_SetKeepScreenOn01");
924 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
925 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
926 sptr<WindowImpl> window = new WindowImpl(option);
927 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
928
929 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
930 ASSERT_EQ(WMError::WM_OK, window->Create(""));
931 ASSERT_FALSE(window->IsKeepScreenOn());
932 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
933 ASSERT_TRUE(window->IsKeepScreenOn());
934 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
935 ASSERT_FALSE(window->IsKeepScreenOn());
936 }
937
938 /**
939 * @tc.name: SetKeepScreenOn02
940 * @tc.desc: create window with show, test SetKeepScreenOn
941 * @tc.type: FUNC
942 */
943 HWTEST_F(WindowImplTest, SetKeepScreenOn02, Function | SmallTest | Level3)
944 {
945 sptr<WindowOption> option = new WindowOption();
946 option->SetWindowName("WindowImplTest_SetKeepScreenOn02");
947 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
948 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
949 sptr<WindowImpl> window = new WindowImpl(option);
950 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
951
952 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
953 ASSERT_EQ(WMError::WM_OK, window->Create(""));
954 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
955 ASSERT_EQ(WMError::WM_OK, window->Show());
956 ASSERT_FALSE(window->IsKeepScreenOn());
957 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
958 .WillOnce(Return(WMError::WM_OK));;
959 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
960 ASSERT_TRUE(window->IsKeepScreenOn());
961 ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
962 ASSERT_FALSE(window->IsKeepScreenOn());
963 }
964
965 /**
966 * @tc.name: SetBrightness01
967 * @tc.desc: test SetBrightness with invalid brightness
968 * @tc.type: FUNC
969 */
970 HWTEST_F(WindowImplTest, SetBrightness01, Function | SmallTest | Level3)
971 {
972 sptr<WindowOption> option = new WindowOption();
973 option->SetWindowName("WindowImplTest_SetBrightness01");
974 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
975 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
976 sptr<WindowImpl> window = new WindowImpl(option);
977 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
978
979 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
980 ASSERT_EQ(WMError::WM_OK, window->Create(""));
981 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
982 ASSERT_EQ(WMError::WM_OK, window->Show());
983 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
984 ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(2.0f)); // 2.0f: brightness
985 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
986 }
987
988 /**
989 * @tc.name: SetBrightness02
990 * @tc.desc: test SetBrightness with valid brightness
991 * @tc.type: FUNC
992 */
993 HWTEST_F(WindowImplTest, SetBrightness02, Function | SmallTest | Level3)
994 {
995 sptr<WindowOption> option = new WindowOption();
996 option->SetWindowName("WindowImplTest_SetBrightness02");
997 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
998 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
999 sptr<WindowImpl> window = new WindowImpl(option);
1000 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1001
1002 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1003 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1004 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1005 ASSERT_EQ(WMError::WM_OK, window->Show());
1006 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1007 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1008 .WillOnce(Return(WMError::WM_OK));
1009 ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1010 ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1011 ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MINIMUM_BRIGHTNESS));
1012 ASSERT_EQ(MINIMUM_BRIGHTNESS, window->GetBrightness());
1013 }
1014
1015 /**
1016 * @tc.name: SetBrightness03
1017 * @tc.desc: test SetBrightness with invalid type window
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(WindowImplTest, SetBrightness03, Function | SmallTest | Level3)
1021 {
1022 sptr<WindowOption> option = new WindowOption();
1023 option->SetWindowName("WindowImplTest_SetBrightness03");
1024 option->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
1025 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1026 sptr<WindowImpl> window = new WindowImpl(option);
1027 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1028
1029 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1030 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1031 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1032 ASSERT_EQ(WMError::WM_OK, window->Show());
1033 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1034 ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1035 ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1036 }
1037
1038 /**
1039 * @tc.name: SetFocusable01
1040 * @tc.desc: create window but not show, test SetFocusable
1041 * @tc.type: FUNC
1042 */
1043 HWTEST_F(WindowImplTest, SetFocusable01, Function | SmallTest | Level3)
1044 {
1045 sptr<WindowOption> option = new WindowOption();
1046 option->SetWindowName("WindowImplTest_SetFocusable01");
1047 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1048 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1049 sptr<WindowImpl> window = new WindowImpl(option);
1050 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1051
1052 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1053 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1054 ASSERT_TRUE(window->GetFocusable());
1055 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
1056 ASSERT_FALSE(window->GetFocusable());
1057 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
1058 ASSERT_TRUE(window->GetFocusable());
1059 }
1060
1061 /**
1062 * @tc.name: SetFocusable02
1063 * @tc.desc: create window with show, test SetFocusable
1064 * @tc.type: FUNC
1065 */
1066 HWTEST_F(WindowImplTest, SetFocusable02, Function | SmallTest | Level3)
1067 {
1068 sptr<WindowOption> option = new WindowOption();
1069 option->SetWindowName("WindowImplTest_SetFocusable02");
1070 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1071 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1072 sptr<WindowImpl> window = new WindowImpl(option);
1073 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1074
1075 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1076 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1077 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1078 ASSERT_EQ(WMError::WM_OK, window->Show());
1079 ASSERT_TRUE(window->GetFocusable());
1080 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1081 .WillOnce(Return(WMError::WM_OK));
1082 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
1083 ASSERT_FALSE(window->GetFocusable());
1084 ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
1085 ASSERT_TRUE(window->GetFocusable());
1086 }
1087
1088 /**
1089 * @tc.name: SetTouchable01
1090 * @tc.desc: create window but not show, test SetTouchable
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(WindowImplTest, SetTouchable01, Function | SmallTest | Level3)
1094 {
1095 sptr<WindowOption> option = new WindowOption();
1096 option->SetWindowName("WindowImplTest_SetTouchable01");
1097 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1098 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1099 sptr<WindowImpl> window = new WindowImpl(option);
1100 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1101
1102 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1103 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1104 ASSERT_TRUE(window->GetTouchable());
1105 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
1106 ASSERT_FALSE(window->GetTouchable());
1107 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
1108 ASSERT_TRUE(window->GetTouchable());
1109 }
1110
1111 /**
1112 * @tc.name: SetTouchable02
1113 * @tc.desc: create window with show, test SetTouchable
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(WindowImplTest, SetTouchable02, Function | SmallTest | Level3)
1117 {
1118 sptr<WindowOption> option = new WindowOption();
1119 option->SetWindowName("WindowImplTest_SetTouchable02");
1120 option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1121 option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1122 sptr<WindowImpl> window = new WindowImpl(option);
1123 std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1124
1125 EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1126 ASSERT_EQ(WMError::WM_OK, window->Create(""));
1127 EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1128 ASSERT_EQ(WMError::WM_OK, window->Show());
1129 ASSERT_TRUE(window->GetTouchable());
1130 EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2).WillOnce(Return(WMError::WM_OK))
1131 .WillOnce(Return(WMError::WM_OK));
1132 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
1133 ASSERT_FALSE(window->GetTouchable());
1134 ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
1135 ASSERT_TRUE(window->GetTouchable());
1136 }
1137 }
1138 } // namespace Rosen
1139 } // namespace OHOS
1140