• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_uicontent.h"
20 #include "mock_window_adapter.h"
21 #include "singleton_mocker.h"
22 #include "window_impl.h"
23 
24 using namespace testing;
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace Rosen {
29 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
30 
31 class WindowImplTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     virtual void SetUp() override;
36     virtual void TearDown() override;
37     void CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect);
38 
39     static inline std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
40     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
41 
42 private:
43     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
44 };
SetUpTestCase()45 void WindowImplTest::SetUpTestCase() {}
46 
TearDownTestCase()47 void WindowImplTest::TearDownTestCase() {}
48 
SetUp()49 void WindowImplTest::SetUp() {}
50 
TearDown()51 void WindowImplTest::TearDown()
52 {
53     usleep(WAIT_SYNC_IN_NS);
54 }
55 
CreateStretchableWindow(sptr<WindowImpl> & window,const Rect & rect)56 void WindowImplTest::CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect)
57 {
58     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
59     option->SetWindowName("StretchableWindowTest");
60     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
61     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
62     option->SetWindowRect({ 1, 1, 1, 1 });
63     window = sptr<WindowImpl>::MakeSptr(option);
64     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
65     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
66     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
67     window->windowSystemConfig_.isStretchable_ = true;
68     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
69     ASSERT_EQ(WMError::WM_OK, window->Show());
70     window->UpdateRect(rect, true, WindowSizeChangeReason::UNDEFINED);
71     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect);
72 }
73 
74 namespace {
75 /**
76  * @tc.name: CreateWindow01
77  * @tc.desc: Create window with no parentId
78  * @tc.type: FUNC
79  */
80 HWTEST_F(WindowImplTest, CreateWindow01, Function | SmallTest | Level2)
81 {
82     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
83     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
84     option->SetWindowName("CreateWindow01");
85     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
86 
87     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
88     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
89     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
90 
91     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
92     ASSERT_EQ(WMError::WM_OK, window->Destroy());
93 }
94 
95 /**
96  * @tc.name: CreateWindow02
97  * @tc.desc: Create window with no parentId and no abilityContext
98  * @tc.type: FUNC
99  */
100 HWTEST_F(WindowImplTest, CreateWindow02, Function | SmallTest | Level2)
101 {
102     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
103     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
104     option->SetWindowName("CreateWindow02");
105     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
106 
107     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
108     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
109     ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Create(INVALID_WINDOW_ID));
110     ASSERT_EQ(WMError::WM_OK, window->Destroy());
111 }
112 
113 /**
114  * @tc.name: CreateWindow03
115  * @tc.desc: Create window with illegal parentId
116  * @tc.type: FUNC
117  */
118 HWTEST_F(WindowImplTest, CreateWindow03, Function | SmallTest | Level2)
119 {
120     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
121     option->SetWindowName("CreateWindow03");
122     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
123     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARENT, window->Create(1234));
124     ASSERT_EQ(WMError::WM_OK, window->Destroy());
125 }
126 
127 /**
128  * @tc.name: CreateWindow04
129  * @tc.desc: Create window with repeated windowName
130  * @tc.type: FUNC
131  */
132 HWTEST_F(WindowImplTest, CreateWindow04, Function | SmallTest | Level2)
133 {
134     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
135     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
136     option->SetWindowName("CreateWindow04");
137     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
138     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
139     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
140     window->Create(INVALID_WINDOW_ID);
141 
142     sptr<WindowOption> option_other = sptr<WindowOption>::MakeSptr();
143     option_other->SetWindowName("CreateWindow04");
144     sptr<WindowImpl> window_other = sptr<WindowImpl>::MakeSptr(option_other);
145 
146     ASSERT_EQ(WMError::WM_ERROR_REPEAT_OPERATION, window_other->Create(INVALID_WINDOW_ID));
147     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
148     ASSERT_EQ(WMError::WM_OK, window->Destroy());
149     ASSERT_EQ(WMError::WM_OK, window_other->Destroy());
150 }
151 
152 /**
153  * @tc.name: CreateWindow05
154  * @tc.desc: Create window with exist parentId
155  * @tc.type: FUNC
156  */
157 HWTEST_F(WindowImplTest, CreateWindow05, Function | SmallTest | Level2)
158 {
159     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
160     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
161     option->SetWindowName("CreateWindow05_parent");
162     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
163 
164     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
165     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
166     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
167 
168     sptr<WindowOption> option2 = sptr<WindowOption>::MakeSptr();
169     option2->SetWindowName("CreateWindow05");
170     sptr<WindowImpl> window2 = sptr<WindowImpl>::MakeSptr(option2);
171 
172     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
173     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
174     ASSERT_EQ(WMError::WM_OK, window2->Create(window->GetWindowId()));
175 
176     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
177     ASSERT_EQ(WMError::WM_OK, window->Destroy());
178     ASSERT_EQ(WMError::WM_OK, window2->Destroy());
179 }
180 
181 /**
182  * @tc.name: CreateWindow06
183  * @tc.desc: Create window with no default option, get and check Property
184  * @tc.type: FUNC
185  */
186 HWTEST_F(WindowImplTest, CreateWindow06, Function | SmallTest | Level2)
187 {
188     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
189     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
190     option->SetWindowName("CreateWindow06");
191     struct Rect rect = { 1, 2, 3u, 4u };
192     option->SetWindowRect(rect);
193     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
194     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
195     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
196 
197     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
198     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
199     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
200 
201     ASSERT_EQ(1, window->GetRequestRect().posX_);
202     ASSERT_EQ(2, window->GetRequestRect().posY_);
203     ASSERT_EQ(3u, window->GetRequestRect().width_);
204     ASSERT_EQ(4u, window->GetRequestRect().height_);
205     ASSERT_EQ(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW, window->GetType());
206     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
207     ASSERT_EQ("CreateWindow06", window->GetWindowName());
208 
209     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
210     ASSERT_EQ(WMError::WM_OK, window->Destroy());
211 }
212 
213 /**
214  * @tc.name: FindWindow01
215  * @tc.desc: Find one exit window
216  * @tc.type: FUNC
217  */
218 HWTEST_F(WindowImplTest, FindWindow01, Function | SmallTest | Level2)
219 {
220     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
221     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
222     option->SetWindowName("FindWindow01");
223     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
224     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
225     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
226     window->Create(INVALID_WINDOW_ID);
227     ASSERT_NE(nullptr, WindowImpl::Find("FindWindow01"));
228     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
229     ASSERT_EQ(WMError::WM_OK, window->Destroy());
230 }
231 
232 /**
233  * @tc.name: FindWindow02
234  * @tc.desc: Add another window, find both two windows
235  * @tc.type: FUNC
236  */
237 HWTEST_F(WindowImplTest, FindWindow02, Function | SmallTest | Level2)
238 {
239     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
240     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
241     option->SetWindowName("FindWindow02");
242     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
243     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
244     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
245     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
246 
247     option->SetWindowName("FindWindow02_other");
248     sptr<WindowImpl> window2 = sptr<WindowImpl>::MakeSptr(option);
249     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
250     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
251     ASSERT_EQ(WMError::WM_OK, window2->Create(INVALID_WINDOW_ID));
252 
253     ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02_other"));
254     ASSERT_NE(nullptr, WindowImpl::Find("FindWindow02"));
255 
256     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
257     ASSERT_EQ(WMError::WM_OK, window->Destroy());
258     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
259     ASSERT_EQ(WMError::WM_OK, window2->Destroy());
260 }
261 
262 /**
263  * @tc.name: FindWindow03
264  * @tc.desc: Find one no exit window
265  * @tc.type: FUNC
266  */
267 HWTEST_F(WindowImplTest, FindWindow03, Function | SmallTest | Level2)
268 {
269     ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow03"));
270 }
271 
272 /**
273  * @tc.name: FindWindow04
274  * @tc.desc: Find window with empty name
275  * @tc.type: FUNC
276  */
277 HWTEST_F(WindowImplTest, FindWindow04, Function | SmallTest | Level2)
278 {
279     ASSERT_EQ(nullptr, WindowImpl::Find(""));
280 }
281 
282 /**
283  * @tc.name: FindWindow05
284  * @tc.desc: Find one destroyed window
285  * @tc.type: FUNC
286  */
287 HWTEST_F(WindowImplTest, FindWindow05, Function | SmallTest | Level2)
288 {
289     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
290     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
291     option->SetWindowName("FindWindow05");
292     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
293     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
294     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
295     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
296 
297     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
298     ASSERT_EQ(WMError::WM_OK, window->Destroy());
299     ASSERT_EQ(nullptr, WindowImpl::Find("FindWindow05"));
300 }
301 
302 /**
303  * @tc.name: RequestVsyncSucc
304  * @tc.desc: RequestVsync Test Succ
305  * @tc.type: FUNC
306  */
307 HWTEST_F(WindowImplTest, RequestVsyncSucc, Function | SmallTest | Level2)
308 {
309     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
310     option->SetWindowName("RequestVsyncSucc");
311     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
312     std::shared_ptr<VsyncCallback> vsyncCallback = std::make_shared<VsyncCallback>();
313     window->SetWindowState(WindowState::STATE_DESTROYED);
314     ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
315     window->RequestVsync(vsyncCallback);
316     ASSERT_EQ(WMError::WM_OK, window->Destroy());
317 }
318 
319 /**
320  * @tc.name: RequestVsyncErr
321  * @tc.desc: RequestVsync Test Err
322  * @tc.type: FUNC
323  */
324 HWTEST_F(WindowImplTest, RequestVsyncErr, Function | SmallTest | Level2)
325 {
326     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
327     option->SetWindowName("RequestVsyncErr");
328     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
329     std::shared_ptr<VsyncCallback> vsyncCallback = std::make_shared<VsyncCallback>();
330     window->SetWindowState(WindowState::STATE_DESTROYED);
331     ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
332     window->vsyncStation_ = nullptr;
333     window->RequestVsync(vsyncCallback);
334     ASSERT_EQ(WMError::WM_OK, window->Destroy());
335 }
336 
337 /**
338  * @tc.name: ClearVsync
339  * @tc.desc: Clear vsync test
340  * @tc.type: FUNC
341  */
342 HWTEST_F(WindowImplTest, ClearVsync, Function | SmallTest | Level2)
343 {
344     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
345     option->SetWindowName("ClearVsync");
346     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
347     window->ClearVsyncStation();
348     ASSERT_NE(window, nullptr);
349 }
350 
351 /**
352  * @tc.name: InitWindowProperty
353  * @tc.desc: InitWindowProperty Test
354  * @tc.type: FUNC
355  */
356 HWTEST_F(WindowImplTest, InitWindowProperty, Function | SmallTest | Level2)
357 {
358     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
359     option->SetWindowName("InitWindowProperty");
360     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
361     window->InitWindowProperty(option);
362     ASSERT_EQ(WMError::WM_OK, window->Destroy());
363 }
364 
365 /**
366  * @tc.name: FindWindowById01
367  * @tc.desc: Find one top window
368  * @tc.type: FUNC
369  */
370 HWTEST_F(WindowImplTest, FindWindowById01, Function | SmallTest | Level2)
371 {
372     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
373     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
374     option->SetWindowName("FindWindowById01");
375     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
376     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
377     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
378     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
379 
380     ASSERT_NE(nullptr, window->FindWindowById(window->property_->GetWindowId()));
381 
382     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
383     ASSERT_EQ(WMError::WM_OK, window->Destroy());
384 }
385 
386 /**
387  * @tc.name: SetWindowType01
388  * @tc.desc: SetWindowType
389  * @tc.type: FUNC
390  */
391 HWTEST_F(WindowImplTest, SetWindowType01, Function | SmallTest | Level2)
392 {
393     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
394     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
395     option->SetWindowName("SetWindowType01");
396     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
397     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
398     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
399     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
400     ASSERT_EQ(WMError::WM_OK, window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
401     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
402     ASSERT_EQ(WMError::WM_OK, window->Destroy());
403 }
404 
405 /**
406  * @tc.name: SetWindowMode01
407  * @tc.desc: SetWindowMode
408  * @tc.type: FUNC
409  */
410 HWTEST_F(WindowImplTest, SetWindowMode01, Function | SmallTest | Level2)
411 {
412     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
413     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
414     option->SetWindowName("SetWindowType01");
415     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
416     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
417     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
418     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
419     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
420     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
421     ASSERT_EQ(WMError::WM_OK, window->Destroy());
422 }
423 
424 /**
425  * @tc.name: SetWindowMode02
426  * @tc.desc: Set window mode to split primary
427  * @tc.type: FUNC
428  */
429 HWTEST_F(WindowImplTest, SetWindowMode02, Function | SmallTest | Level3)
430 {
431     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
432     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
433     option->SetWindowName("");
434     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
435     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
436     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
437     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
438     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
439     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
440     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
441     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
442     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_PRIMARY, window->GetWindowMode());
443     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
444     ASSERT_EQ(WMError::WM_OK, window->Destroy());
445 }
446 
447 /**
448  * @tc.name: SetWindowMode03
449  * @tc.desc: Set window mode to split secondary
450  * @tc.type: FUNC
451  */
452 HWTEST_F(WindowImplTest, SetWindowMode03, Function | SmallTest | Level3)
453 {
454     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
455     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
456     option->SetWindowName("");
457     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
458     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
459     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
460     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
461     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
462     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
463     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
464     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_SECONDARY));
465     ASSERT_EQ(WindowMode::WINDOW_MODE_SPLIT_SECONDARY, window->GetWindowMode());
466     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
467     ASSERT_EQ(WMError::WM_OK, window->Destroy());
468 }
469 
470 /**
471  * @tc.name: SetWindowMode04
472  * @tc.desc: Set window mode to floating
473  * @tc.type: FUNC
474  */
475 HWTEST_F(WindowImplTest, SetWindowMode04, Function | SmallTest | Level3)
476 {
477     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
478     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
479     option->SetWindowName("");
480     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
481     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
482     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
483     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
484     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
485     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
486     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
487     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING));
488     ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
489     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
490     ASSERT_EQ(WMError::WM_OK, window->Destroy());
491 }
492 
493 /**
494  * @tc.name: SetWindowMode05
495  * @tc.desc: Set window mode to pip
496  * @tc.type: FUNC
497  */
498 HWTEST_F(WindowImplTest, SetWindowMode05, Function | SmallTest | Level3)
499 {
500     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
501     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
502     option->SetWindowName("");
503     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
504     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
505     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
506     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
507     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
508     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
509     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
510     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_PIP));
511     ASSERT_EQ(WindowMode::WINDOW_MODE_PIP, window->GetWindowMode());
512     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
513     ASSERT_EQ(WMError::WM_OK, window->Destroy());
514 }
515 
516 /**
517  * @tc.name: ShowHideWindow01
518  * @tc.desc: Show and hide window with add and remove window ok
519  * @tc.type: FUNC
520  */
521 HWTEST_F(WindowImplTest, ShowHideWindow01, Function | SmallTest | Level2)
522 {
523     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
524     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
525     option->SetWindowName("ShowHideWindow01");
526     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
527     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
528     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
529     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
530     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
531     ASSERT_EQ(WMError::WM_OK, window->Show());
532     window->NotifyForeground();
533     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
534     ASSERT_EQ(WMError::WM_OK, window->Hide());
535     window->NotifyBackground();
536     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
537     ASSERT_EQ(WMError::WM_OK, window->Destroy());
538 }
539 
540 /**
541  * @tc.name: ShowHideWindow02
542  * @tc.desc: Show window with add window WM_ERROR_SAMGR
543  * @tc.type: FUNC
544  */
545 HWTEST_F(WindowImplTest, ShowHideWindow02, Function | SmallTest | Level2)
546 {
547     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
548     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
549     option->SetWindowName("ShowHideWindow02");
550     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
551     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
552     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
553     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
554     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
555     ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Show());
556     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
557     ASSERT_EQ(WMError::WM_OK, window->Destroy());
558 }
559 
560 /**
561  * @tc.name: ShowHideWindow03
562  * @tc.desc: Show window with add window WM_ERROR_IPC_FAILED
563  * @tc.type: FUNC
564  */
565 HWTEST_F(WindowImplTest, ShowHideWindow03, Function | SmallTest | Level3)
566 {
567     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
568     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
569     option->SetWindowName("ShowHideWindow03");
570     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
571     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
572     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
573     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
574     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
575     ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Show());
576     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
577     ASSERT_EQ(WMError::WM_OK, window->Destroy());
578 }
579 
580 /**
581  * @tc.name: ShowHideWindow04
582  * @tc.desc: Show window with add window OK & Hide window with remove window WM_ERROR_SAMGR
583  * @tc.type: FUNC
584  */
585 HWTEST_F(WindowImplTest, ShowHideWindow04, Function | SmallTest | Level3)
586 {
587     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
588     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
589     option->SetWindowName("ShowHideWindow04");
590     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
591     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
592     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
593     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
594     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
595     ASSERT_EQ(WMError::WM_OK, window->Show());
596     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
597     ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->Hide());
598     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
599     ASSERT_EQ(WMError::WM_OK, window->Destroy());
600 }
601 
602 /**
603  * @tc.name: ShowHideWindow05
604  * @tc.desc: Hide window with remove window WM_ERROR_IPC_FAILED
605  * @tc.type: FUNC
606  */
607 HWTEST_F(WindowImplTest, ShowHideWindow05, Function | SmallTest | Level3)
608 {
609     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
610     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
611     option->SetWindowName("ShowHideWindow05");
612     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
613     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
614     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
615     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
616     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
617     ASSERT_EQ(WMError::WM_OK, window->Show());
618     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_IPC_FAILED));
619     ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, window->Hide());
620     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
621     ASSERT_EQ(WMError::WM_OK, window->Destroy());
622 }
623 
624 /**
625  * @tc.name: ShowHideWindow06
626  * @tc.desc: Hide window with remove window OK
627  * @tc.type: FUNC
628  */
629 HWTEST_F(WindowImplTest, ShowHideWindow06, Function | SmallTest | Level3)
630 {
631     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
632     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
633     option->SetWindowName("ShowHideWindow06");
634     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
635     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
636     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
637     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
638     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
639     ASSERT_EQ(WMError::WM_OK, window->Show());
640     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
641     ASSERT_EQ(WMError::WM_OK, window->Hide());
642     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
643     ASSERT_EQ(WMError::WM_OK, window->Destroy());
644 }
645 
646 /**
647  * @tc.name: SetSystemBarProperty01
648  * @tc.desc: SetSystemBarProperty with default param
649  * @tc.type: FUNC
650  */
651 HWTEST_F(WindowImplTest, SetSystemBarProperty01, Function | SmallTest | Level3)
652 {
653     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
654     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
655     option->SetWindowName("SetSystemBarProperty01");
656     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
657     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
658     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
659     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
660 
661     WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
662     SystemBarProperty prop;
663     ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, prop));
664     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
665     ASSERT_EQ(WMError::WM_OK, window->Destroy());
666 }
667 
668 /**
669  * @tc.name: SetSystemBarProperty02
670  * @tc.desc: SetSystemBarProperty with adapter return WM_ERROR_SAMGR
671  * @tc.type: FUNC
672  */
673 HWTEST_F(WindowImplTest, SetSystemBarProperty02, Function | SmallTest | Level3)
674 {
675     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
676     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
677     option->SetWindowName("SetSystemBarProperty02");
678     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
679     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
680     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
681     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
682 
683     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
684     window->Show();
685     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
686     WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
687     const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
688     ASSERT_EQ(WMError::WM_ERROR_SAMGR, window->SetSystemBarProperty(type, SYS_BAR_PROP));
689     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
690     window->Hide();
691     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
692     ASSERT_EQ(WMError::WM_OK, window->Destroy());
693 }
694 
695 /**
696  * @tc.name: SetSystemBarProperty03
697  * @tc.desc: SetSystemBarProperty to invalid window
698  * @tc.type: FUNC
699  */
700 HWTEST_F(WindowImplTest, SetSystemBarProperty03, Function | SmallTest | Level3)
701 {
702     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
703     option->SetWindowName("SetSystemBarProperty03");
704     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
705     WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
706     SystemBarProperty prop;
707     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetSystemBarProperty(type, prop));
708 }
709 
710 /**
711  * @tc.name: GetSystemBarPropertyByType01
712  * @tc.desc: GetSystemBarPropertyByType with exist key
713  * @tc.type: FUNC
714  */
715 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType01, Function | SmallTest | Level3)
716 {
717     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
718     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
719     option->SetWindowName("GetSystemBarPropertyByType01");
720     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
721     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
722     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
723     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
724 
725     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
726     ASSERT_EQ(WMError::WM_OK, window->Show());
727     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
728     WindowType type = WindowType::WINDOW_TYPE_STATUS_BAR;
729     const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333344);
730     ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(type, SYS_BAR_PROP));
731     ASSERT_EQ(SYS_BAR_PROP, window->GetSystemBarPropertyByType(type));
732     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
733     window->Hide();
734     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
735     ASSERT_EQ(WMError::WM_OK, window->Destroy());
736 }
737 
738 /**
739  * @tc.name: GetSystemBarPropertyByType02
740  * @tc.desc: GetSystemBarPropertyByType with nonexist key
741  * @tc.type: FUNC
742  */
743 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType02, Function | SmallTest | Level3)
744 {
745     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
746     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
747     option->SetWindowName("GetSystemBarPropertyByType02");
748     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
749     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
750     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
751     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
752 
753     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
754     window->Show();
755     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
756     const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333333);
757     const SystemBarProperty DEFAULT_PROP;
758     ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
759     ASSERT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_NAVIGATION_BAR));
760     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
761     window->Hide();
762     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
763     ASSERT_EQ(WMError::WM_OK, window->Destroy());
764 }
765 
766 /**
767  * @tc.name: GetSystemBarPropertyByType03
768  * @tc.desc: GetSystemBarPropertyByType with not systemBar type
769  * @tc.type: FUNC
770  */
771 HWTEST_F(WindowImplTest, GetSystemBarPropertyByType03, Function | SmallTest | Level3)
772 {
773     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
774     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
775     option->SetWindowName("GetSystemBarPropertyByType03");
776     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
777     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
778     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
779     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
780 
781     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
782     window->Show();
783     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
784     const SystemBarProperty SYS_BAR_PROP(false, 0xE5222222, 0xE5333366);
785     const SystemBarProperty DEFAULT_PROP;
786     ASSERT_EQ(WMError::WM_OK, window->SetSystemBarProperty(WindowType::WINDOW_TYPE_STATUS_BAR, SYS_BAR_PROP));
787     ASSERT_EQ(DEFAULT_PROP, window->GetSystemBarPropertyByType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
788     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
789     window->Hide();
790     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
791     ASSERT_EQ(WMError::WM_OK, window->Destroy());
792 }
793 
794 /**
795  * @tc.name: Maximize02
796  * @tc.desc: Maximize the sub window
797  * @tc.type: FUNC
798  */
799 HWTEST_F(WindowImplTest, Maximize02, Function | SmallTest | Level3)
800 {
801     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
802     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
803     option->SetWindowName("Maximize02");
804     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
805     window->Maximize();
806     ASSERT_EQ(WindowMode::WINDOW_MODE_UNDEFINED, window->GetWindowMode());
807     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
808     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
809     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
810     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
811     window->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
812     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
813     window->Show();
814     window->Maximize();
815     ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
816 
817     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
818     window->Hide();
819     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
820     ASSERT_EQ(WMError::WM_OK, window->Destroy());
821 }
822 
823 /**
824  * @tc.name: Recover01
825  * @tc.desc: Recover the main window
826  * @tc.type: FUNC
827  */
828 HWTEST_F(WindowImplTest, Recover01, Function | SmallTest | Level3)
829 {
830     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
831     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
832     option->SetWindowName("Recover01");
833     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
834     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Recover());
835     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
836     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
837     window->Create(INVALID_WINDOW_ID);
838     window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
839     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
840     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
841     window->Show();
842     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
843     window->Recover();
844     ASSERT_EQ(WindowMode::WINDOW_MODE_FLOATING, window->GetWindowMode());
845     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
846     window->Hide();
847     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
848     ASSERT_EQ(WMError::WM_OK, window->Destroy());
849 }
850 
851 /**
852  * @tc.name: Recover02
853  * @tc.desc: Recover the sub window
854  * @tc.type: FUNC
855  */
856 HWTEST_F(WindowImplTest, Recover02, Function | SmallTest | Level3)
857 {
858     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
859     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
860     option->SetWindowName("Recover02");
861     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
862     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
863     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
864     window->Create(INVALID_WINDOW_ID);
865     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
866     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
867     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
868     window->Show();
869     window->Recover();
870     ASSERT_EQ(WindowMode::WINDOW_MODE_FULLSCREEN, window->GetWindowMode());
871     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
872     window->Hide();
873     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
874     ASSERT_EQ(WMError::WM_OK, window->Destroy());
875 }
876 
877 /**
878  * @tc.name: Minimize01
879  * @tc.desc: Minimize the main window
880  * @tc.type: FUNC
881  */
882 HWTEST_F(WindowImplTest, Minimize01, Function | SmallTest | Level3)
883 {
884     auto option = sptr<WindowOption>::MakeSptr();
885     option->SetWindowName("Minimize01");
886     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
887     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Minimize());
888     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
889     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
890     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
891     window->Create(INVALID_WINDOW_ID);
892     window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
893     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
894     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
895     window->Show();
896     ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
897     EXPECT_CALL(m->Mock(), RemoveWindow(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
898     window->Minimize();
899     ASSERT_FALSE((window->GetWindowState() == WindowState::STATE_SHOWN));
900     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
901     ASSERT_EQ(WMError::WM_OK, window->Minimize());
902     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
903     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
904     EXPECT_CALL(*content, Destroy());
905     ASSERT_EQ(WMError::WM_OK, window->Destroy());
906 }
907 
908 /**
909  * @tc.name: Minimize02
910  * @tc.desc: Minimize the sub window
911  * @tc.type: FUNC
912  */
913 HWTEST_F(WindowImplTest, Minimize02, Function | SmallTest | Level3)
914 {
915     auto option = sptr<WindowOption>::MakeSptr();
916     option->SetWindowName("Minimize02");
917     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
918     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
919     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
920     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
921     window->Create(INVALID_WINDOW_ID);
922     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
923     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
924     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
925     window->Show();
926     ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
927     window->Minimize();
928     ASSERT_TRUE((window->GetWindowState() == WindowState::STATE_SHOWN));
929     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
930     ASSERT_EQ(WMError::WM_OK, window->Destroy());
931 }
932 
933 /**
934  * @tc.name: Minimize03
935  * @tc.desc: Minimize
936  * @tc.type: FUNC
937  */
938 HWTEST_F(WindowImplTest, Minimize03, Function | SmallTest | Level3)
939 {
940     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
941     option->SetWindowName("Minimize03");
942     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
943     WMError res = window->Minimize();
944     EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, res);
945 }
946 
947 /**
948  * @tc.name: IsSupportWideGamut01
949  * @tc.desc: IsSupportWideGamut
950  * @tc.type: FUNC
951  */
952 HWTEST_F(WindowImplTest, IsSupportWideGamut01, Function | SmallTest | Level3)
953 {
954     auto option = sptr<WindowOption>::MakeSptr();
955     option->SetWindowName("IsSupportWideGamut01");
956     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
957     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
958     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
959     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
960     window->Create(INVALID_WINDOW_ID);
961     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
962     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
963     ASSERT_TRUE(window->IsSupportWideGamut());
964     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
965     ASSERT_EQ(WMError::WM_OK, window->Destroy());
966 }
967 
968 /**
969  * @tc.name: SetColorSpace01
970  * @tc.desc: SetColorSpace
971  * @tc.type: FUNC
972  */
973 HWTEST_F(WindowImplTest, SetColorSpace01, Function | SmallTest | Level3)
974 {
975     auto option = sptr<WindowOption>::MakeSptr();
976     option->SetWindowName("SetColorSpace01");
977     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
978     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
979     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
980     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
981     window->Create(INVALID_WINDOW_ID);
982     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
983     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
984     window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
985     ASSERT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace());
986     window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT);
987     ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
988     uint32_t invalidColorSpace = 1234u;
989     window->SetColorSpace(static_cast<ColorSpace>(invalidColorSpace));
990     ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
991     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
992     ASSERT_EQ(WMError::WM_OK, window->Destroy());
993 }
994 
995 /**
996  * @tc.name: GetColorSpace01
997  * @tc.desc: GetColorSpace
998  * @tc.type: FUNC
999  */
1000 HWTEST_F(WindowImplTest, GetColorSpace01, Function | SmallTest | Level3)
1001 {
1002     auto option = sptr<WindowOption>::MakeSptr();
1003     option->SetWindowName("GetColorSpace01");
1004     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1005     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1006     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1007     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1008     window->Create(INVALID_WINDOW_ID);
1009     window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1010     window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1011     window->SetColorSpace(ColorSpace::COLOR_SPACE_DEFAULT);
1012     ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
1013     window->SetColorSpace(ColorSpace::COLOR_SPACE_WIDE_GAMUT);
1014     ASSERT_EQ(ColorSpace::COLOR_SPACE_WIDE_GAMUT, window->GetColorSpace());
1015     uint32_t invalidColorSpace = 54321u;
1016     window->SetColorSpace(static_cast<ColorSpace>(invalidColorSpace));
1017     ASSERT_EQ(ColorSpace::COLOR_SPACE_DEFAULT, window->GetColorSpace());
1018     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1019     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1020 }
1021 
1022 /**
1023  * @tc.name: StartMove01
1024  * @tc.desc: start move main fullscreen window, test startMoveFlag
1025  * @tc.type: FUNC
1026  * @tc.require: issueI5J8IB
1027  */
1028 HWTEST_F(WindowImplTest, StartMove01, Function | SmallTest | Level3)
1029 {
1030     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1031     option->SetWindowName("StartMove01");
1032     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1033     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1034     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1035 
1036     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1037     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1038     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1039     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1040     window->Show();
1041     window->StartMove();
1042     ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1043     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1044     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1045 }
1046 
1047 /**
1048  * @tc.name: StartMove02
1049  * @tc.desc: start move main fullscreen window, test startMoveFlag
1050  * @tc.type: FUNC
1051  * @tc.require: issueI5J8IB
1052  */
1053 HWTEST_F(WindowImplTest, StartMove02, Function | SmallTest | Level3)
1054 {
1055     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1056     option->SetWindowName("StartMove02");
1057     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1058     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1059     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1060     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1061 
1062     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1063     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1064     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1065     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1066     window->Show();
1067 
1068     window->StartMove();
1069     ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1070     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1071     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1072 }
1073 
1074 /**
1075  * @tc.name: StartMove03
1076  * @tc.desc: start move divider, test startMoveFlag
1077  * @tc.type: FUNC
1078  * @tc.require: issueI5J8IB
1079  */
1080 HWTEST_F(WindowImplTest, StartMove03, Function | SmallTest | Level3)
1081 {
1082     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1083     option->SetWindowName("StartMove03");
1084     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
1085     option->SetWindowType(WindowType::WINDOW_TYPE_DOCK_SLICE);
1086     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1087     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1088 
1089     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1090     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1091     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1092     window->Show();
1093     window->StartMove();
1094     ASSERT_FALSE(window->moveDragProperty_->startMoveFlag_);
1095     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1096     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1097 }
1098 
1099 /**
1100  * @tc.name: SetBackgroundColor01
1101  * @tc.desc: test SetBackgroundColor withow uiContent
1102  * @tc.type: FUNC
1103  */
1104 HWTEST_F(WindowImplTest, SetBackgroundColor01, Function | SmallTest | Level3)
1105 {
1106     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1107     option->SetWindowName("SetBackgroundColor01");
1108     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1109     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1110     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1111     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1112 
1113     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1114     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1115     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1116     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1117     window->Show();
1118     ASSERT_FALSE(window->IsTransparent());
1119     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBackgroundColor("#000"));
1120     ASSERT_FALSE(window->IsTransparent());
1121     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#00FF00"));
1122     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor("#FF00FF00"));
1123     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1124     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1125 }
1126 
1127 /**
1128  * @tc.name: SetTurnScreenOn01
1129  * @tc.desc: create window but not show, test SetTurnScreenOn
1130  * @tc.type: FUNC
1131  */
1132 HWTEST_F(WindowImplTest, SetTurnScreenOn01, Function | SmallTest | Level3)
1133 {
1134     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1135     option->SetWindowName("SetTurnScreenOn01");
1136     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1137     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1138     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1139     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTurnScreenOn(true));
1140     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1141 
1142     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1143     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1144     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1145     ASSERT_FALSE(window->IsTurnScreenOn());
1146     ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
1147     ASSERT_TRUE(window->IsTurnScreenOn());
1148     ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
1149     ASSERT_FALSE(window->IsTurnScreenOn());
1150     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1151     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1152 }
1153 
1154 /**
1155  * @tc.name: SetTurnScreenOn02
1156  * @tc.desc: create window with show, test SetTurnScreenOn
1157  * @tc.type: FUNC
1158  */
1159 HWTEST_F(WindowImplTest, SetTurnScreenOn02, Function | SmallTest | Level3)
1160 {
1161     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1162     option->SetWindowName("SetTurnScreenOn02");
1163     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1164     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1165     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1166     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1167 
1168     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1169     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1170     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1171     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1172     ASSERT_EQ(WMError::WM_OK, window->Show());
1173     ASSERT_FALSE(window->IsTurnScreenOn());
1174     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1175         .Times(2)
1176         .WillOnce(Return(WMError::WM_OK))
1177         .WillOnce(Return(WMError::WM_OK));
1178     ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(true));
1179     ASSERT_TRUE(window->IsTurnScreenOn());
1180     ASSERT_EQ(WMError::WM_OK, window->SetTurnScreenOn(false));
1181     ASSERT_FALSE(window->IsTurnScreenOn());
1182     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1183     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1184 }
1185 
1186 /**
1187  * @tc.name: SetKeepScreenOn01
1188  * @tc.desc: create window but not show, test SetKeepScreenOn
1189  * @tc.type: FUNC
1190  */
1191 HWTEST_F(WindowImplTest, SetKeepScreenOn01, Function | SmallTest | Level3)
1192 {
1193     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1194     option->SetWindowName("SetKeepScreenOn01");
1195     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1196     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1197     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1198     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetKeepScreenOn(true));
1199     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1200 
1201     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1202     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1203     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1204     ASSERT_FALSE(window->IsKeepScreenOn());
1205     ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
1206     ASSERT_TRUE(window->IsKeepScreenOn());
1207     ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
1208     ASSERT_FALSE(window->IsKeepScreenOn());
1209     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1210     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1211 }
1212 
1213 /**
1214  * @tc.name: SetKeepScreenOn02
1215  * @tc.desc: create window with show, test SetKeepScreenOn
1216  * @tc.type: FUNC
1217  */
1218 HWTEST_F(WindowImplTest, SetKeepScreenOn02, Function | SmallTest | Level3)
1219 {
1220     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1221     option->SetWindowName("SetKeepScreenOn02");
1222     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1223     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1224     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1225     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1226 
1227     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1228     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1229     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1230     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1231     ASSERT_EQ(WMError::WM_OK, window->Show());
1232     ASSERT_FALSE(window->IsKeepScreenOn());
1233     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1234         .Times(2)
1235         .WillOnce(Return(WMError::WM_OK))
1236         .WillOnce(Return(WMError::WM_OK));
1237     ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(true));
1238     ASSERT_TRUE(window->IsKeepScreenOn());
1239     ASSERT_EQ(WMError::WM_OK, window->SetKeepScreenOn(false));
1240     ASSERT_FALSE(window->IsKeepScreenOn());
1241 
1242     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1243     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1244 }
1245 
1246 /**
1247  * @tc.name: SetBrightness01
1248  * @tc.desc: test SetBrightness with invalid brightness
1249  * @tc.type: FUNC
1250  */
1251 HWTEST_F(WindowImplTest, SetBrightness01, Function | SmallTest | Level3)
1252 {
1253     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1254     option->SetWindowName("SetBrightness01");
1255     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1256     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1257     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1258     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBrightness(0.f));
1259     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1260 
1261     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1262     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1263     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1264     ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1265 
1266     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1267     ASSERT_EQ(WMError::WM_OK, window->Show());
1268     ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1269     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(2.0f)); // 2.0f: brightness
1270     ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1271     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetBrightness(-0.5f)); // -0.5f: brightness
1272     ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1273 
1274     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1275     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1276 }
1277 
1278 /**
1279  * @tc.name: SetBrightness02
1280  * @tc.desc: test SetBrightness with valid brightness
1281  * @tc.type: FUNC
1282  */
1283 HWTEST_F(WindowImplTest, SetBrightness02, Function | SmallTest | Level3)
1284 {
1285     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1286     option->SetWindowName("SetBrightness02");
1287     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1288     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1289     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1290     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1291 
1292     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1293     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1294     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1295     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1296     ASSERT_EQ(WMError::WM_OK, window->Show());
1297     ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1298     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1299         .Times(2)
1300         .WillOnce(Return(WMError::WM_OK))
1301         .WillOnce(Return(WMError::WM_OK));
1302     ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1303     ASSERT_EQ(MAXIMUM_BRIGHTNESS, window->GetBrightness());
1304     ASSERT_EQ(WMError::WM_OK, window->SetBrightness(MINIMUM_BRIGHTNESS));
1305     ASSERT_EQ(MINIMUM_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: SetBrightness03
1313  * @tc.desc: test SetBrightness with invalid type window
1314  * @tc.type: FUNC
1315  */
1316 HWTEST_F(WindowImplTest, SetBrightness03, Function | SmallTest | Level3)
1317 {
1318     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1319     option->SetWindowName("SetBrightness03");
1320     option->SetWindowType(WindowType::WINDOW_TYPE_STATUS_BAR);
1321     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1322     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1323     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1324 
1325     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1326     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1327     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1328     ASSERT_EQ(WMError::WM_OK, window->Show());
1329     ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1330     ASSERT_EQ(WMError::WM_ERROR_INVALID_TYPE, window->SetBrightness(MAXIMUM_BRIGHTNESS));
1331     ASSERT_EQ(UNDEFINED_BRIGHTNESS, window->GetBrightness());
1332 
1333     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1334     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1335 }
1336 
1337 /**
1338  * @tc.name: RequestVsync
1339  * @tc.desc: RequestVsync test
1340  * @tc.type: FUNC
1341  */
1342 HWTEST_F(WindowImplTest, RequestVsync, Function | SmallTest | Level3)
1343 {
1344     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1345     option->SetWindowName("RequestVsync");
1346     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1347     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1348     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1349     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1350     window->RestoreSplitWindowMode(0u);
1351     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1352     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1353     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1354 
1355     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1356     ASSERT_EQ(WMError::WM_OK, window->Show());
1357     std::shared_ptr<VsyncCallback> callback = std::make_shared<VsyncCallback>();
1358     window->SetWindowState(WindowState::STATE_DESTROYED);
1359     ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
1360     window->RequestVsync(callback);
1361 
1362     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1363     window->SetWindowState(WindowState::STATE_DESTROYED);
1364     ASSERT_EQ(WindowState::STATE_DESTROYED, window->GetWindowState());
1365     window->RequestVsync(callback);
1366 }
1367 
1368 /**
1369  * @tc.name: Create3
1370  * @tc.desc: Create3 WindowCreateCheck
1371  * @tc.type: FUNC
1372  */
1373 HWTEST_F(WindowImplTest, Create3, Function | SmallTest | Level3)
1374 {
1375     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1376     option->SetWindowName("WindowCreateCheck2");
1377     option->SetWindowMode(WindowMode::WINDOW_MODE_UNDEFINED);
1378     option->SetWindowType(WindowType::WINDOW_TYPE_VOLUME_OVERLAY);
1379     option->SetWindowRect({ 1, 1, 1, 1 });
1380     option->SetBundleName("OK");
1381     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1382 
1383     std::shared_ptr<AbilityRuntime::AbilityContext> context = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1384     WMError res = window->Create(1, context);
1385     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARENT, res);
1386     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1387 }
1388 
1389 /**
1390  * @tc.name: SetRestoredRouterStack_0100
1391  * @tc.desc: basic function test of set or get restored router stack.
1392  * @tc.type: FUNC
1393  * @tc.require: issue
1394  */
1395 HWTEST_F(WindowImplTest, SetRestoredRouterStack_0100, Function | SmallTest | Level3)
1396 {
1397     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1398     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1399     std::string routerStack = "stackInfo:{}";
1400     EXPECT_EQ(window->SetRestoredRouterStack(routerStack), WMError::WM_OK);
1401     std::string gettedStack = window->GetRestoredRouterStack();
1402     EXPECT_EQ(gettedStack, routerStack);
1403     EXPECT_TRUE(window->GetRestoredRouterStack().empty());
1404 }
1405 } // namespace
1406 } // namespace Rosen
1407 } // namespace OHOS
1408