• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "ability_context_impl.h"
18 #include "display_manager_proxy.h"
19 #include "mock_uicontent.h"
20 #include "mock_window_adapter.h"
21 #include "scene_board_judgement.h"
22 #include "singleton_mocker.h"
23 #include "window_impl.h"
24 
25 using namespace testing;
26 using namespace testing::ext;
27 
28 namespace OHOS {
29 namespace Rosen {
30 using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
31 class MockAceAbilityHandler : public IAceAbilityHandler {
32 public:
33     MOCK_METHOD1(SetBackgroundColor, void(uint32_t color));
34     MOCK_METHOD0(GetBackgroundColor, uint32_t());
35 };
36 
37 class WindowImplTest2 : public testing::Test {
38 public:
39     static void SetUpTestCase();
40     static void TearDownTestCase();
41     void SetUp() override;
42     void TearDown() override;
43     void CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect);
44 
45     static inline std::shared_ptr<AbilityRuntime::AbilityContext> abilityContext_;
46     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
47 
48 private:
49     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
50 };
SetUpTestCase()51 void WindowImplTest2::SetUpTestCase() {}
52 
TearDownTestCase()53 void WindowImplTest2::TearDownTestCase() {}
54 
SetUp()55 void WindowImplTest2::SetUp() {}
56 
TearDown()57 void WindowImplTest2::TearDown()
58 {
59     usleep(WAIT_SYNC_IN_NS);
60 }
61 
CreateStretchableWindow(sptr<WindowImpl> & window,const Rect & rect)62 void WindowImplTest2::CreateStretchableWindow(sptr<WindowImpl>& window, const Rect& rect)
63 {
64     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
65     option->SetWindowName("StretchableWindowTest");
66     option->SetWindowMode(WindowMode::WINDOW_MODE_FLOATING);
67     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
68     option->SetWindowRect({ 1, 1, 1, 1 });
69     window = sptr<WindowImpl>::MakeSptr(option);
70     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
71     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
72     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
73     window->windowSystemConfig_.isStretchable_ = true;
74     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
75     ASSERT_EQ(WMError::WM_OK, window->Show());
76     window->UpdateRect(rect, true, WindowSizeChangeReason::UNDEFINED);
77     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect);
78 }
79 
80 namespace {
81 /**
82  * @tc.name: SetFocusable01
83  * @tc.desc: create window but not show, test SetFocusable
84  * @tc.type: FUNC
85  */
86 HWTEST_F(WindowImplTest2, SetFocusable01, Function | SmallTest | Level3)
87 {
88     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
89     option->SetWindowName("SetFocusable01");
90     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
91     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
92     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
93     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RequestFocus());
94     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
95 
96     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
97     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
98     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
99     ASSERT_TRUE(window->GetFocusable());
100     EXPECT_CALL(m->Mock(), RequestFocus(_)).WillOnce(Return(WMError::WM_OK));
101     ASSERT_EQ(WMError::WM_OK, window->RequestFocus());
102     ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
103     ASSERT_FALSE(window->GetFocusable());
104     ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
105     ASSERT_TRUE(window->GetFocusable());
106     WindowState state = window->GetWindowState();
107     window->SetWindowState(WindowState::STATE_DESTROYED);
108     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFocusable(false));
109     ASSERT_TRUE(window->GetFocusable());
110     window->SetWindowState(state);
111     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
112     ASSERT_EQ(WMError::WM_OK, window->Destroy());
113 }
114 
115 /**
116  * @tc.name: SetFocusable02
117  * @tc.desc: create window with show, test SetFocusable
118  * @tc.type: FUNC
119  */
120 HWTEST_F(WindowImplTest2, SetFocusable02, Function | SmallTest | Level3)
121 {
122     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
123     option->SetWindowName("SetFocusable02");
124     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
125     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
126     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
127     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
128 
129     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
130     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
131     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
132     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
133     ASSERT_EQ(WMError::WM_OK, window->Show());
134     ASSERT_TRUE(window->GetFocusable());
135     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
136         .Times(2)
137         .WillOnce(Return(WMError::WM_OK))
138         .WillOnce(Return(WMError::WM_OK));
139     ASSERT_EQ(WMError::WM_OK, window->SetFocusable(false));
140     ASSERT_FALSE(window->GetFocusable());
141     ASSERT_EQ(WMError::WM_OK, window->SetFocusable(true));
142     ASSERT_TRUE(window->GetFocusable());
143 
144     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
145     ASSERT_EQ(WMError::WM_OK, window->Destroy());
146 }
147 
148 /**
149  * @tc.name: SetTouchable01
150  * @tc.desc: create window but not show, test SetTouchable
151  * @tc.type: FUNC
152  */
153 HWTEST_F(WindowImplTest2, SetTouchable01, Function | SmallTest | Level3)
154 {
155     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
156     option->SetWindowName("SetTouchable01");
157     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
158     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
159     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
160     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
161 
162     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
163     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
164     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
165     ASSERT_TRUE(window->GetTouchable());
166     ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
167     ASSERT_FALSE(window->GetTouchable());
168     ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
169     ASSERT_TRUE(window->GetTouchable());
170     WindowState state = window->GetWindowState();
171     window->SetWindowState(WindowState::STATE_DESTROYED);
172     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTouchable(false));
173     ASSERT_TRUE(window->GetTouchable());
174     window->SetWindowState(state);
175 
176     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
177     ASSERT_EQ(WMError::WM_OK, window->Destroy());
178 }
179 
180 /**
181  * @tc.name: SetTouchable02
182  * @tc.desc: create window with show, test SetTouchable
183  * @tc.type: FUNC
184  */
185 HWTEST_F(WindowImplTest2, SetTouchable02, Function | SmallTest | Level3)
186 {
187     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
188     option->SetWindowName("SetTouchable02");
189     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
190     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
191     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
192     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
193 
194     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
195     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
196     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
197     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
198     ASSERT_EQ(WMError::WM_OK, window->Show());
199     ASSERT_TRUE(window->GetTouchable());
200     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
201         .Times(2)
202         .WillOnce(Return(WMError::WM_OK))
203         .WillOnce(Return(WMError::WM_OK));
204     ASSERT_EQ(WMError::WM_OK, window->SetTouchable(false));
205     ASSERT_FALSE(window->GetTouchable());
206     ASSERT_EQ(WMError::WM_OK, window->SetTouchable(true));
207     ASSERT_TRUE(window->GetTouchable());
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: DisableAppWindowDecor01
215  * @tc.desc: disable app window decor
216  * @tc.type: FUNC
217  */
218 HWTEST_F(WindowImplTest2, DisableAppWindowDecor01, Function | SmallTest | Level3)
219 {
220     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
221     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
222     option->SetWindowName("DisableAppWindowDecor01");
223     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
224 
225     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
226     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
227     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
228     window->property_->isDecorEnable_ = true;
229     window->windowSystemConfig_.isSystemDecorEnable_ = false;
230     window->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
231     window->DisableAppWindowDecor();
232     ASSERT_FALSE(window->IsDecorEnable());
233     window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
234     window->DisableAppWindowDecor();
235     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
236     ASSERT_EQ(WMError::WM_OK, window->Show());
237     ASSERT_FALSE(window->IsDecorEnable());
238     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
239     ASSERT_EQ(WMError::WM_OK, window->Destroy());
240 }
241 
242 /**
243  * @tc.name: SetTouchHotAreas01
244  * @tc.desc: create window with show, test SetTouchHotAreas
245  * @tc.type: FUNC
246  */
247 HWTEST_F(WindowImplTest2, SetTouchHotAreas01, Function | SmallTest | Level3)
248 {
249     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
250     option->SetWindowName("SetTouchHotAreas01");
251     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
252     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
253     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
254     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
255 
256     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
257     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
258     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
259     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
260     ASSERT_EQ(WMError::WM_OK, window->Show());
261 
262     std::vector<Rect> requestedTouchHotAreas;
263     window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
264     ASSERT_TRUE(requestedTouchHotAreas.empty());
265 
266     std::vector<Rect> rects;
267     rects.emplace_back(Rect{ 0, 0, 720, 400 });
268     rects.emplace_back(Rect{ 0, 800, 720, 300 });
269     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
270     ASSERT_EQ(WMError::WM_OK, window->SetTouchHotAreas(rects));
271     window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
272     ASSERT_EQ(rects.size(), requestedTouchHotAreas.size());
273     for (uint32_t i = 0; i < rects.size(); ++i) {
274         ASSERT_TRUE(rects[i] == requestedTouchHotAreas[i]);
275     }
276 
277     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
278     rects.clear();
279     ASSERT_EQ(WMError::WM_OK, window->SetTouchHotAreas(rects));
280     window->GetRequestedTouchHotAreas(requestedTouchHotAreas);
281     ASSERT_TRUE(requestedTouchHotAreas.empty());
282 
283     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
284     ASSERT_EQ(WMError::WM_OK, window->Destroy());
285 }
286 
287 /**
288  * @tc.name: SetTransform01
289  * @tc.desc: set transform
290  * @tc.type: FUNC
291  * @tc.require: issueI5NDLK
292  */
293 HWTEST_F(WindowImplTest2, SetTransform01, Function | SmallTest | Level3)
294 {
295     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
296     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
297     option->SetWindowName("SetTransform01");
298     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
299     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
300     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
301     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
302     window->DisableAppWindowDecor();
303     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
304     ASSERT_EQ(WMError::WM_OK, window->Show());
305     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
306     Transform trans_;
307     window->UpdateZoomTransform(trans_, true);
308     window->SetTransform(trans_);
309     window->UpdateZoomTransform(trans_, false);
310     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
311     window->SetTransform(trans_);
312     ASSERT_TRUE(trans_ == window->GetTransform());
313     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
314     ASSERT_EQ(WMError::WM_OK, window->Destroy());
315 }
316 
317 /**
318  * @tc.name: SetTransform02
319  * @tc.desc: set transform and getTransform
320  * @tc.type: FUNC
321  * @tc.require: issueI5NDLK
322  */
323 HWTEST_F(WindowImplTest2, SetTransform02, Function | SmallTest | Level3)
324 {
325     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
326     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
327     option->SetWindowName("SetTransform02");
328     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
329     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
330     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
331     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
332     window->DisableAppWindowDecor();
333     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
334     ASSERT_EQ(WMError::WM_OK, window->Show());
335     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_ERROR_SAMGR));
336     Transform trans_;
337     trans_.pivotX_ = 1.0f;
338     trans_.pivotY_ = 0.6f;
339     window->SetTransform(trans_);
340     ASSERT_TRUE(trans_ != window->GetTransform());
341     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
342     ASSERT_EQ(WMError::WM_OK, window->Destroy());
343 }
344 
345 /**
346  * @tc.name: SetTransform03
347  * @tc.desc: set transform and getTransform
348  * @tc.type: FUNC
349  * @tc.require: issueI5NDLK
350  */
351 HWTEST_F(WindowImplTest2, SetTransform03, Function | SmallTest | Level3)
352 {
353     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
354     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
355     option->SetWindowName("SetTransform03");
356     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
357     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
358     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
359     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
360     window->DisableAppWindowDecor();
361     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
362     ASSERT_EQ(WMError::WM_OK, window->Show());
363     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
364     Transform trans_;
365     trans_.pivotX_ = 1.0f;
366     trans_.pivotY_ = 0.6f;
367     window->SetTransform(trans_);
368     ASSERT_TRUE(trans_ == window->GetTransform());
369     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
370     ASSERT_EQ(WMError::WM_OK, window->Destroy());
371 }
372 
373 /**
374  * @tc.name: SetTransform04
375  * @tc.desc: set transform and getTransform
376  * @tc.type: FUNC
377  * @tc.require: issueI5NDLK
378  */
379 HWTEST_F(WindowImplTest2, SetTransform04, Function | SmallTest | Level3)
380 {
381     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
382     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
383     option->SetWindowName("SetTransform04");
384     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
385     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
386     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
387     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
388     window->DisableAppWindowDecor();
389     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
390     ASSERT_EQ(WMError::WM_OK, window->Show());
391     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_OK));
392     Transform trans_;
393     trans_.pivotX_ = 1.0f;
394     trans_.pivotY_ = 0.6f;
395     Transform defaultTrans_;
396     window->SetTransform(trans_);
397     ASSERT_TRUE(defaultTrans_ != window->GetTransform());
398     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
399     ASSERT_EQ(WMError::WM_OK, window->Destroy());
400 }
401 
402 /**
403  * @tc.name: SetAPPWindowLabel
404  * @tc.desc: set window label to ace
405  * @tc.type: FUNC
406  * @tc.require: issueI5Q2KW
407  */
408 HWTEST_F(WindowImplTest2, SetAPPWindowLabel, Function | SmallTest | Level3)
409 {
410     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
411     option->SetWindowName("SetAPPWindowLabel");
412     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
413     std::string label = "openharmony";
414 
415     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
416     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
417     EXPECT_CALL(*content, SetAppWindowTitle(_));
418     ASSERT_EQ(WMError::WM_OK, window->SetAPPWindowLabel(label));
419     window->uiContent_ = nullptr;
420     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowLabel(label));
421 }
422 
423 /**
424  * @tc.name: SetAPPWindowIcon
425  * @tc.desc: set window Icon to ace
426  * @tc.type: FUNC
427  * @tc.require: issueI5Q2KW
428  */
429 HWTEST_F(WindowImplTest2, SetAPPWindowIcon, Function | SmallTest | Level3)
430 {
431     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
432     option->SetWindowName("SetAPPWindowIcon");
433     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
434 
435     std::shared_ptr<Media::PixelMap> icon1(nullptr);
436     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowIcon(icon1));
437     std::shared_ptr<Media::PixelMap> icon2 = std::make_shared<Media::PixelMap>();
438     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->SetAPPWindowIcon(icon2));
439     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
440     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
441     EXPECT_CALL(*content, SetAppWindowIcon(_));
442     ASSERT_EQ(WMError::WM_OK, window->SetAPPWindowIcon(icon2));
443 }
444 
445 /**
446  * @tc.name: NotifyMemoryLevel01
447  * @tc.desc: NotifyMemoryLevel without mainWindow
448  * @tc.type: FUNC
449  * @tc.require: issueI5JQ04
450  */
451 HWTEST_F(WindowImplTest2, NotifyMemoryLevel01, Function | SmallTest | Level2)
452 {
453     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
454     option->SetWindowName("NotifyMemoryLevel01");
455     int32_t level = 0;
456     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
457 
458     ASSERT_EQ(WMError::WM_ERROR_NULLPTR, window->NotifyMemoryLevel(level));
459     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
460     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
461     EXPECT_CALL(*content, NotifyMemoryLevel(_));
462     ASSERT_EQ(WMError::WM_OK, window->NotifyMemoryLevel(level));
463 }
464 
465 /**
466  * @tc.name: StretchableUpdateRectDragStartTest
467  * @tc.desc: UpdateRect test for stretchable window when drag start.
468  * @tc.type: FUNC
469  */
470 HWTEST_F(WindowImplTest2, StretchableUpdateRectDragStartTest, Function | SmallTest | Level3)
471 {
472     Rect rect1{ 10, 10, 10, 10 };
473     sptr<WindowImpl> window;
474     CreateStretchableWindow(window, rect1);
475     ASSERT_NE(window, nullptr);
476     Rect rect2{ 100, 100, 100, 100 };
477     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
478     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
479     EXPECT_CALL(*content, UpdateViewportConfig(_, _, _, _));
480     window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG_START);
481     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
482     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
483     EXPECT_CALL(*content, Destroy());
484     ASSERT_EQ(WMError::WM_OK, window->Destroy());
485 }
486 
487 /**
488  * @tc.name: StretchableUpdateRectDragTest
489  * @tc.desc: UpdateRect test for stretchable window when drag.
490  * @tc.type: FUNC
491  */
492 HWTEST_F(WindowImplTest2, StretchableUpdateRectDragTest, Function | SmallTest | Level3)
493 {
494     Rect rect1{ 10, 10, 10, 10 };
495     sptr<WindowImpl> window;
496     CreateStretchableWindow(window, rect1);
497     ASSERT_NE(window, nullptr);
498     Rect rect2{ 100, 100, 100, 100 };
499     window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG);
500     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
501     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
502     ASSERT_EQ(WMError::WM_OK, window->Destroy());
503 }
504 
505 /**
506  * @tc.name: StretchableUpdateRectDragEndTest
507  * @tc.desc: UpdateRect test for stretchable window when drag end.
508  * @tc.type: FUNC
509  */
510 HWTEST_F(WindowImplTest2, StretchableUpdateRectDragEndTest, Function | SmallTest | Level3)
511 {
512     Rect rect1{ 10, 10, 10, 10 };
513     sptr<WindowImpl> window;
514     CreateStretchableWindow(window, rect1);
515     ASSERT_NE(window, nullptr);
516     Rect rect2{ 100, 100, 100, 100 };
517     window->UpdateRect(rect2, true, WindowSizeChangeReason::DRAG_END);
518     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
519     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
520     ASSERT_EQ(WMError::WM_OK, window->Destroy());
521 }
522 
523 /**
524  * @tc.name: StretchableUpdateRectRecoverTest
525  * @tc.desc: UpdateRect test for stretchable window when recover.
526  * @tc.type: FUNC
527  */
528 HWTEST_F(WindowImplTest2, StretchableUpdateRectRecoverTest, Function | SmallTest | Level3)
529 {
530     Rect rect1{ 10, 10, 10, 10 };
531     sptr<WindowImpl> window;
532     CreateStretchableWindow(window, rect1);
533     ASSERT_NE(window, nullptr);
534     Rect rect2{ 100, 100, 100, 100 };
535     window->UpdateRect(rect2, true, WindowSizeChangeReason::RECOVER);
536     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
537     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
538     ASSERT_EQ(WMError::WM_OK, window->Destroy());
539 }
540 
541 /**
542  * @tc.name: StretchableUpdateRectRecoverTest
543  * @tc.desc: UpdateRect test for stretchable window when move.
544  * @tc.type: FUNC
545  */
546 HWTEST_F(WindowImplTest2, StretchableUpdateRectMoveTest, Function | SmallTest | Level3)
547 {
548     Rect rect1{ 10, 10, 10, 10 };
549     sptr<WindowImpl> window;
550     CreateStretchableWindow(window, rect1);
551     ASSERT_NE(window, nullptr);
552     Rect rect2{ 100, 100, 100, 100 };
553     window->UpdateRect(rect2, true, WindowSizeChangeReason::MOVE);
554     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect1);
555     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
556     ASSERT_EQ(WMError::WM_OK, window->Destroy());
557 }
558 
559 /**
560  * @tc.name: StretchableUpdateRectResizeTest
561  * @tc.desc: UpdateRect test for stretchable window when resize.
562  * @tc.type: FUNC
563  */
564 HWTEST_F(WindowImplTest2, StretchableUpdateRectResizeTest, Function | SmallTest | Level3)
565 {
566     Rect rect1{ 110, 110, 10, 10 };
567     sptr<WindowImpl> window;
568     CreateStretchableWindow(window, rect1);
569     ASSERT_NE(window, nullptr);
570     Rect rect2{ 100, 100, 100, 100 };
571     ASSERT_EQ(true, rect1.IsInsideOf(rect2));
572     ASSERT_EQ(true, rect1 != rect2);
573     window->UpdateRect(rect2, true, WindowSizeChangeReason::RESIZE);
574     ASSERT_EQ(window->GetWindowProperty()->GetOriginRect(), rect2);
575     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
576     ASSERT_EQ(WMError::WM_OK, window->Destroy());
577 }
578 
579 /**
580  * @tc.name: PrivacyMode01
581  * @tc.desc: Set window privacy mode
582  * @tc.type: FUNC
583  * @tc.require: issueI5MYNX
584  */
585 HWTEST_F(WindowImplTest2, PrivacyMode01, Function | SmallTest | Level3)
586 {
587     sptr<WindowOption> option = new WindowOption();
588     option->SetWindowName("PrivacyMode01");
589     sptr<WindowImpl> window = new WindowImpl(option);
590     ASSERT_NE(nullptr, window);
591 
592     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
593         window->SetPrivacyMode(true);
594         window->SetSystemPrivacyMode(true);
595         ASSERT_EQ(true, window->IsPrivacyMode());
596 
597         window->SetPrivacyMode(true);
598         window->SetSystemPrivacyMode(false);
599         ASSERT_EQ(true, window->IsPrivacyMode());
600 
601         window->SetPrivacyMode(false);
602         window->SetSystemPrivacyMode(true);
603         ASSERT_EQ(false, window->IsPrivacyMode());
604 
605         window->SetPrivacyMode(false);
606         window->SetSystemPrivacyMode(false);
607         ASSERT_EQ(false, window->IsPrivacyMode());
608     } else {
609         window->SetPrivacyMode(true);
610         window->SetSystemPrivacyMode(true);
611         ASSERT_EQ(false, window->IsPrivacyMode());
612 
613         window->SetPrivacyMode(true);
614         window->SetSystemPrivacyMode(false);
615         ASSERT_EQ(false, window->IsPrivacyMode());
616 
617         window->SetPrivacyMode(false);
618         window->SetSystemPrivacyMode(true);
619         ASSERT_EQ(false, window->IsPrivacyMode());
620 
621         window->SetPrivacyMode(false);
622         window->SetSystemPrivacyMode(false);
623         ASSERT_EQ(false, window->IsPrivacyMode());
624     }
625 }
626 
627 /**
628  * @tc.name: CalculatePointerDirection
629  * @tc.desc: calculate mouse style id
630  * @tc.type: FUNC
631  */
632 HWTEST_F(WindowImplTest2, CalculatePointerDirection, Function | SmallTest | Level3)
633 {
634     Rect rect1{ 1, 1, 100, 100 };
635     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
636     option->SetWindowName("CalculatePointerDirection");
637     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
638 
639     window->moveDragProperty_->startRectExceptCorner_ = rect1;
640     ASSERT_EQ(12, window->CalculatePointerDirection(0, 0));
641     ASSERT_EQ(6, window->CalculatePointerDirection(50, 0));
642     ASSERT_EQ(11, window->CalculatePointerDirection(102, 0));
643     ASSERT_EQ(5, window->CalculatePointerDirection(102, 50));
644 }
645 
646 /**
647  * @tc.name: FindWindowById
648  * @tc.desc: FindWindowById Test
649  * @tc.type: FUNC
650  */
651 HWTEST_F(WindowImplTest2, FindWindowById, Function | SmallTest | Level3)
652 {
653     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
654     option->SetWindowName("FindWindowById");
655     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
656     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
657     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
658     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
659     ASSERT_EQ(nullptr, window->FindWindowById(INVALID_WINDOW_ID));
660     ASSERT_EQ(sptr<Window>(window), window->FindWindowById(window->GetWindowId()));
661 
662     ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithId(INVALID_WINDOW_ID));
663 
664     ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithId(INVALID_WINDOW_ID));
665     std::shared_ptr<AbilityRuntime::Context> context;
666     ASSERT_EQ(nullptr, sptr<Window>(window)->GetTopWindowWithContext(context));
667     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
668     ASSERT_EQ(WMError::WM_OK, window->Destroy());
669 }
670 
671 /**
672  * @tc.name: GetSubWindow
673  * @tc.desc: GetSubWindow Test
674  * @tc.type: FUNC
675  */
676 HWTEST_F(WindowImplTest2, GetSubWindow, Function | SmallTest | Level3)
677 {
678     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
679     option->SetWindowName("main");
680     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
681     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
682     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
683     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
684 
685     option = new WindowOption();
686     option->SetWindowName("sub");
687     option->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
688     sptr<WindowImpl> subWindow = new WindowImpl(option);
689     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
690     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
691     ASSERT_EQ(WMError::WM_OK, subWindow->Create(window->GetWindowId()));
692 
693     auto subWindowVec = sptr<Window>(window)->GetSubWindow(window->GetWindowId());
694     if (subWindowVec.size() == 1) {
695         ASSERT_EQ(1, subWindowVec.size());
696         ASSERT_EQ(sptr<Window>(subWindow), subWindowVec[0]);
697     }
698     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
699     ASSERT_EQ(WMError::WM_OK, window->Destroy());
700 }
701 
702 /**
703  * @tc.name: UpdateConfigurationForAll
704  * @tc.desc: UpdateConfigurationForAll Test
705  * @tc.type: FUNC
706  */
707 HWTEST_F(WindowImplTest2, UpdateConfigurationForAll, Function | SmallTest | Level3)
708 {
709     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
710     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
711     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
712     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
713     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
714     std::shared_ptr<AppExecFwk::Configuration> configuration;
715     sptr<Window>(window)->UpdateConfigurationForAll(configuration);
716     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
717     ASSERT_EQ(WMError::WM_OK, window->Destroy());
718 }
719 
720 /**
721  * @tc.name: SetAlpha
722  * @tc.desc: SetAlpha | GetAlpha
723  * @tc.type: FUNC
724  */
725 HWTEST_F(WindowImplTest2, SetAlpha, Function | SmallTest | Level3)
726 {
727     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
728     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
729     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
730 
731     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
732     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
733     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
734     float alpha = 0.5f;
735     window->SetAlpha(alpha);
736     ASSERT_EQ(alpha, window->GetAlpha());
737     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
738     ASSERT_EQ(WMError::WM_OK, window->Destroy());
739 }
740 
741 /**
742  * @tc.name: GetAvoidAreaByType
743  * @tc.desc: Test GetAvoidAreaByType when ret is not ok
744  * @tc.type: FUNC
745  */
746 HWTEST_F(WindowImplTest2, GetAvoidAreaByType, Function | SmallTest | Level3)
747 {
748     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
749     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
750     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
751 
752     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
753     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
754     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
755     EXPECT_CALL(m->Mock(), GetAvoidAreaByType(_, _, _, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
756     AvoidArea avoidarea;
757     ASSERT_EQ(WMError::WM_DO_NOTHING, window->GetAvoidAreaByType(AvoidAreaType::TYPE_CUTOUT, avoidarea));
758     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
759     ASSERT_EQ(WMError::WM_OK, window->Destroy());
760 }
761 
762 /**
763  * @tc.name: SetWindowType
764  * @tc.desc: SetWindowType Test
765  * @tc.type: FUNC
766  */
767 HWTEST_F(WindowImplTest2, SetWindowType, Function | SmallTest | Level3)
768 {
769     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
770     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
771     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
772 
773     window->SetWindowState(WindowState::STATE_DESTROYED);
774     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW));
775 
776     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
777     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
778     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
779     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowType(WindowType::SYSTEM_WINDOW_END));
780 
781     window->SetWindowState(WindowState::STATE_FROZEN);
782     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW));
783 
784     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
785     ASSERT_EQ(WMError::WM_OK, window->Destroy());
786 }
787 
788 /**
789  * @tc.name: SetWindowMode
790  * @tc.desc: SetWindowMode Test
791  * @tc.type: FUNC
792  */
793 HWTEST_F(WindowImplTest2, SetWindowMode, Function | SmallTest | Level3)
794 {
795     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
796     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
797     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
798 
799     window->SetWindowState(WindowState::STATE_DESTROYED);
800     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
801     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
802     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
803     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
804     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
805     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
806     EXPECT_CALL(*content, HideWindowTitleButton(_, _, _, _));
807     EXPECT_CALL(*content, UpdateWindowMode(_, _));
808     ASSERT_EQ(WMError::WM_OK, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
809     window->uiContent_ = nullptr;
810 
811     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
812     ASSERT_EQ(WMError::WM_OK, window->Show());
813     window->UpdateWindowModeSupportType(0);
814     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
815     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
816     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
817     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
818     window->SetWindowState(WindowState::STATE_FROZEN);
819     ASSERT_EQ(WMError::WM_ERROR_INVALID_PARAM, window->SetWindowMode(WindowMode::WINDOW_MODE_SPLIT_PRIMARY));
820 
821     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
822     ASSERT_EQ(WMError::WM_OK, window->Destroy());
823 }
824 
825 /**
826  * @tc.name: WindowFlag
827  * @tc.desc: GetWindowFlags | SetWindowFlags | AddWindowFlag | RemoveWindowFlag
828  * @tc.type: FUNC
829  */
830 HWTEST_F(WindowImplTest2, WindowFlag, Function | SmallTest | Level3)
831 {
832     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
833     option->SetWindowName("WindowFlag");
834     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
835     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
836     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
837     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
838     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
839     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
840     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
841     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
842     ASSERT_EQ(WMError::WM_OK, window->Show());
843     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->AddWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
844     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->RemoveWindowFlag(WindowFlag::WINDOW_FLAG_SHOW_WHEN_LOCKED));
845     ASSERT_EQ(static_cast<uint32_t>(0), window->GetWindowFlags());
846     ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
847     ASSERT_EQ(WMError::WM_OK, window->SetWindowFlags(static_cast<uint32_t>(0)));
848     ASSERT_EQ(static_cast<uint32_t>(0), window->GetWindowFlags());
849     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
850     ASSERT_EQ(WMError::WM_OK, window->Destroy());
851 }
852 
853 /**
854  * @tc.name: OnNewWant
855  * @tc.desc: OnNewWant test
856  * @tc.type: FUNC
857  */
858 HWTEST_F(WindowImplTest2, OnNewWant, Function | SmallTest | Level3)
859 {
860     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
861     option->SetWindowName("OnNewWant");
862     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
863     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
864     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
865     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
866     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
867     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
868     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
869 
870     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
871     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
872     AAFwk::Want want;
873     EXPECT_CALL(*content, OnNewWant(_)).Times(1).WillOnce(Return());
874     window->OnNewWant(want);
875     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
876     EXPECT_CALL(*content, Destroy());
877     ASSERT_EQ(WMError::WM_OK, window->Destroy());
878 }
879 
880 /**
881  * @tc.name: GetContentInfo
882  * @tc.desc: GetContentInfo test
883  * @tc.type: FUNC
884  */
885 HWTEST_F(WindowImplTest2, GetContentInfo, Function | SmallTest | Level3)
886 {
887     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
888     option->SetWindowName("GetContentInfo");
889     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
890     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
891     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
892     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
893     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
894     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
895     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
896     ASSERT_EQ(std::string(""), window->GetContentInfo());
897     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
898     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
899     EXPECT_CALL(*content, GetContentInfo(_)).Times(1).WillOnce(Return("info"));
900     ASSERT_EQ(std::string("info"), window->GetContentInfo());
901     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
902     EXPECT_CALL(*content, Destroy());
903     ASSERT_EQ(WMError::WM_OK, window->Destroy());
904 }
905 
906 /**
907  * @tc.name: Snapshot
908  * @tc.desc: Snapshot test
909  * @tc.type: FUNC
910  */
911 HWTEST_F(WindowImplTest2, Snapshot, Function | SmallTest | Level3)
912 {
913     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
914     option->SetWindowName("Snapshot");
915     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
916     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
917     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
918     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
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     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
922 
923     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
924     ASSERT_EQ(WMError::WM_OK, window->Show());
925 
926     ASSERT_EQ(nullptr, window->Snapshot());
927 
928     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
929     ASSERT_EQ(WMError::WM_OK, window->Destroy());
930 }
931 
932 /**
933  * @tc.name: SnapshotIgnorePrivacy
934  * @tc.desc: SnapshotIgnorePrivacy test
935  * @tc.type: FUNC
936  */
937 HWTEST_F(WindowImplTest2, SnapshotIgnorePrivacy, Function | SmallTest | Level3)
938 {
939     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
940     option->SetWindowName("SnapshotIgnorePrivacy");
941     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
942     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
943     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
944     std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
945     ASSERT_EQ(WMError::WM_ERROR_DEVICE_NOT_SUPPORT, window->SnapshotIgnorePrivacy(pixelMap));
946 }
947 
948 /**
949  * @tc.name: DumpInfo
950  * @tc.desc: DumpInfo test
951  * @tc.type: FUNC
952  */
953 HWTEST_F(WindowImplTest2, DumpInfo, Function | SmallTest | Level3)
954 {
955     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
956     option->SetWindowName("DumpInfo");
957     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
958     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
959     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
960     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
961     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
962     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
963     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
964 
965     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
966     ASSERT_EQ(WMError::WM_OK, window->Show());
967     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
968     std::vector<std::string> params{ "-h" };
969     std::vector<std::string> info{ "" };
970     window->DumpInfo(params, info);
971     params.push_back("");
972     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
973     EXPECT_CALL(*content, DumpInfo(_, _)).Times(1).WillOnce(Return());
974     window->DumpInfo(params, info);
975     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
976     EXPECT_CALL(*content, Destroy());
977     ASSERT_EQ(WMError::WM_OK, window->Destroy());
978 }
979 
980 /**
981  * @tc.name: SetLayoutFullScreen
982  * @tc.desc: SetLayoutFullScreen test
983  * @tc.type: FUNC
984  */
985 HWTEST_F(WindowImplTest2, SetLayoutFullScreen, Function | SmallTest | Level3)
986 {
987     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
988     option->SetWindowName("SetLayoutFullScreen");
989     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
990     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
991     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
992     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
993     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
994     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
995     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
996     window->UpdateWindowModeSupportType(0);
997     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(true));
998     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
999 
1000     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1001     ASSERT_EQ(WMError::WM_OK, window->Show());
1002 
1003     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1004     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
1005 
1006     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1007                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1008     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1009         .Times(2)
1010         .WillOnce(Return(WMError::WM_OK))
1011         .WillOnce(Return(WMError::WM_OK));
1012     ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(true));
1013 
1014     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1015                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1016     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1017         .Times(2)
1018         .WillOnce(Return(WMError::WM_OK))
1019         .WillOnce(Return(WMError::WM_DO_NOTHING));
1020     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(true));
1021 
1022     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1023                                       (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1024     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1025         .Times(2)
1026         .WillOnce(Return(WMError::WM_OK))
1027         .WillOnce(Return(WMError::WM_OK));
1028     ASSERT_EQ(WMError::WM_OK, window->SetLayoutFullScreen(false));
1029 
1030     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1031                                       (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1032     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1033         .Times(2)
1034         .WillOnce(Return(WMError::WM_OK))
1035         .WillOnce(Return(WMError::WM_DO_NOTHING));
1036     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetLayoutFullScreen(false));
1037 
1038     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1039     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1040 }
1041 
1042 /**
1043  * @tc.name: SetImmersiveModeEnabledState
1044  * @tc.desc: SetImmersiveModeEnabledState test
1045  * @tc.type: FUNC
1046  */
1047 HWTEST_F(WindowImplTest2, SetImmersiveModeEnabledState, Function | SmallTest | Level3)
1048 {
1049     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1050     option->SetWindowName("SetImmersiveModeEnabledState");
1051     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1052     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1053     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1054     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1055     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1056     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1057     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1058     window->UpdateWindowModeSupportType(0);
1059     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(true));
1060     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
1061 
1062     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1063     ASSERT_EQ(WMError::WM_OK, window->Show());
1064 
1065     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1066     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetImmersiveModeEnabledState(true));
1067 
1068     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1069                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1070     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1071         .Times(2)
1072         .WillOnce(Return(WMError::WM_OK))
1073         .WillOnce(Return(WMError::WM_OK));
1074     ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(true));
1075     ASSERT_EQ(true, window->GetImmersiveModeEnabledState());
1076 
1077     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1078                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1079     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1080         .Times(2)
1081         .WillOnce(Return(WMError::WM_OK))
1082         .WillOnce(Return(WMError::WM_DO_NOTHING));
1083     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetImmersiveModeEnabledState(true));
1084 
1085     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1086                                       (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1087     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1088         .Times(2)
1089         .WillOnce(Return(WMError::WM_OK))
1090         .WillOnce(Return(WMError::WM_OK));
1091     ASSERT_EQ(WMError::WM_OK, window->SetImmersiveModeEnabledState(false));
1092     ASSERT_EQ(false, window->GetImmersiveModeEnabledState());
1093 
1094     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1095                                       (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1096     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1097         .Times(2)
1098         .WillOnce(Return(WMError::WM_OK))
1099         .WillOnce(Return(WMError::WM_DO_NOTHING));
1100     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetImmersiveModeEnabledState(false));
1101 
1102     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1103     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1104 }
1105 
1106 /**
1107  * @tc.name: SetFullScreen
1108  * @tc.desc: SetFullScreen test
1109  * @tc.type: FUNC
1110  */
1111 HWTEST_F(WindowImplTest2, SetFullScreen, Function | SmallTest | Level3)
1112 {
1113     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1114     option->SetWindowName("SetFullScreen");
1115     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1116     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1117     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1118     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1119     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1120     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1121     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1122 
1123     window->UpdateWindowModeSupportType(0);
1124     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(true));
1125     window->UpdateWindowModeSupportType(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
1126 
1127     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1128     ASSERT_EQ(WMError::WM_OK, window->Show());
1129 
1130     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1131     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1132     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1133                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1134     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3).WillRepeatedly(Return(WMError::WM_OK));
1135     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
1136 
1137     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
1138     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
1139     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1140                                       (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1141     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3).WillRepeatedly(Return(WMError::WM_OK));
1142     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
1143 
1144     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1145     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1146     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1147                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1148     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1149         .Times(2)
1150         .WillOnce(Return(WMError::WM_OK))
1151         .WillOnce(Return(WMError::WM_DO_NOTHING));
1152     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetFullScreen(true));
1153 
1154     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1155     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1156     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1157                                       (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1158     EXPECT_CALL(m->Mock(), UpdateProperty(_, _))
1159         .Times(3)
1160         .WillOnce(Return(WMError::WM_DO_NOTHING))
1161         .WillOnce(Return(WMError::WM_OK))
1162         .WillOnce(Return(WMError::WM_OK));
1163     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
1164 
1165     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1166     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1167 }
1168 
1169 /**
1170  * @tc.name: UpdateTitleButtonVisibility
1171  * @tc.desc: UpdateTitleButtonVisibility test
1172  * @tc.type: FUNC
1173  */
1174 HWTEST_F(WindowImplTest2, UpdateTitleButtonVisibility, Function | SmallTest | Level3)
1175 {
1176     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1177     option->SetWindowName("BindDialogTarget");
1178     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1179     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1180     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1181     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1182     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1183     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1184     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1185 
1186     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1187     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1188     EXPECT_CALL(*content, HideWindowTitleButton(_, _, _, _));
1189     window->UpdateTitleButtonVisibility();
1190 
1191     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1192     EXPECT_CALL(*content, Destroy());
1193     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1194 }
1195 
1196 /**
1197  * @tc.name: WindowCreateCheck
1198  * @tc.desc: WindowCreateCheck test
1199  * @tc.type: FUNC
1200  */
1201 HWTEST_F(WindowImplTest2, WindowCreateCheck, Function | SmallTest | Level3)
1202 {
1203     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1204     option->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW);
1205     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1206 
1207     ASSERT_EQ(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, window->GetType());
1208     ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(INVALID_WINDOW_ID));
1209     ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(static_cast<uint32_t>(-1)));
1210 }
1211 
1212 /**
1213  * @tc.name: BindDialogTarget
1214  * @tc.desc: BindDialogTarget test
1215  * @tc.type: FUNC
1216  */
1217 HWTEST_F(WindowImplTest2, BindDialogTarget, Function | SmallTest | Level3)
1218 {
1219     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1220     option->SetWindowName("BindDialogTarget");
1221     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1222     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1223     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1224 
1225     window->SetWindowState(WindowState::STATE_DESTROYED);
1226     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
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 
1231     EXPECT_CALL(m->Mock(), BindDialogTarget(_, _))
1232         .Times(2)
1233         .WillOnce(Return(WMError::WM_OK))
1234         .WillOnce(Return(WMError::WM_DO_NOTHING));
1235     sptr<IRemoteObject> targetToken;
1236     ASSERT_EQ(WMError::WM_OK, window->BindDialogTarget(targetToken));
1237     ASSERT_EQ(WMError::WM_DO_NOTHING, window->BindDialogTarget(targetToken));
1238 
1239     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1240     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1241 }
1242 
1243 /**
1244  * @tc.name: Destroy
1245  * @tc.desc: Destroy test
1246  * @tc.type: FUNC
1247  */
1248 HWTEST_F(WindowImplTest2, Destroy, Function | SmallTest | Level3)
1249 {
1250     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1251     option->SetWindowName("Destroy");
1252     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1253     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1254     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1255 
1256     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1257     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1258     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1259 
1260     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1261     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
1262 
1263     window->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1264     ASSERT_EQ(WindowType::WINDOW_TYPE_DIALOG, window->GetType());
1265     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1266     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
1267 }
1268 
1269 /**
1270  * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
1271  * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation test
1272  * @tc.type: FUNC
1273  */
1274 HWTEST_F(WindowImplTest2, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)
1275 {
1276     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1277     option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
1278     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1279     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1280     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1281     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1282 
1283     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1284     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).WillOnce(Return(WMError::WM_OK));
1285     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1286     window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1287     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1288 
1289     window->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1290     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1291     ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1292 
1293     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
1294     EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1295     ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1296 
1297     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
1298     EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_OK));
1299     ASSERT_EQ(WMError::WM_OK, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1300 
1301     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1302     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1303 }
1304 
1305 /**
1306  * @tc.name: ShowHide
1307  * @tc.desc: Show and Hide test
1308  * @tc.type: FUNC
1309  */
1310 HWTEST_F(WindowImplTest2, ShowHide, Function | SmallTest | Level3)
1311 {
1312     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1313     option->SetWindowName("ShowHide");
1314     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1315     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1316     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1317     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1318 
1319     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Show());
1320     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Hide());
1321     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1322     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1323     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1324 
1325     auto state = window->GetWindowState();
1326     window->SetWindowState(WindowState::STATE_FROZEN);
1327     ASSERT_EQ(WindowState::STATE_FROZEN, window->GetWindowState());
1328     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->PreProcessShow(0, false));
1329     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Show());
1330 
1331     window->SetWindowState(state);
1332     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1333     ASSERT_EQ(WMError::WM_OK, window->Show());
1334     ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
1335 
1336     ASSERT_EQ(WMError::WM_OK, window->Show(static_cast<uint32_t>(WindowStateChangeReason::KEYGUARD)));
1337     EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
1338     ASSERT_EQ(WMError::WM_OK, window->Show());
1339 
1340     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
1341     ASSERT_EQ(WindowType::WINDOW_TYPE_DESKTOP, window->GetType());
1342     EXPECT_CALL(m->Mock(), MinimizeAllAppWindows(_));
1343     ASSERT_EQ(WMError::WM_OK, window->Show());
1344 
1345     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1346     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Hide());
1347     ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
1348 
1349     window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1350 
1351     ASSERT_EQ(WMError::WM_OK, window->Hide(static_cast<uint32_t>(WindowStateChangeReason::TOGGLING)));
1352     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1353 
1354     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE));
1355     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, window->Show());
1356     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1357 
1358     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1359     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Show());
1360     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1361 
1362     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1363     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1364 }
1365 
1366 /**
1367  * @tc.name: CloseWindow
1368  * @tc.desc: CloseWindow test
1369  * @tc.type: FUNC
1370  */
1371 HWTEST_F(WindowImplTest2, CloseWindow, Function | SmallTest | Level3)
1372 {
1373     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1374     option->SetWindowName("CloseWindow");
1375     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1376     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1377     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1378     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1379     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1380     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1381     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1382 
1383     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1384     ASSERT_EQ(WMError::WM_OK, window->Show());
1385     ASSERT_EQ(WMError::WM_OK, window->Close());
1386     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1387 }
1388 
1389 /**
1390  * @tc.name: PendingCloseWindow
1391  * @tc.desc: PendingCloseWindow test
1392  * @tc.type: FUNC
1393  */
1394 HWTEST_F(WindowImplTest2, PendingCloseWindow, Function | SmallTest | Level3)
1395 {
1396     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1397     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1398     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1399     window->PendingClose();
1400     ASSERT_EQ(nullptr, window->context_);
1401 }
1402 
1403 /**
1404  * @tc.name: InvalidWindow
1405  * @tc.desc: InvalidWindow test
1406  * @tc.type: FUNC
1407  */
1408 HWTEST_F(WindowImplTest2, InvalidWindow, Function | SmallTest | Level3)
1409 {
1410     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1411     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1412     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveTo(0, 0));
1413     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(0, 0));
1414     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetCallingWindow(INVALID_WINDOW_ID));
1415     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBackgroundColor(std::string("???")));
1416     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Close());
1417 }
1418 
1419 /**
1420  * @tc.name: BackgroundColor
1421  * @tc.desc: GetBackgroundColor | SetBackGroundColor test
1422  * @tc.type: FUNC
1423  */
1424 HWTEST_F(WindowImplTest2, BackgroundColor, Function | SmallTest | Level3)
1425 {
1426     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1427     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1428 
1429     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor(0));
1430 
1431     MockAceAbilityHandler* aceAbilityHandler = new MockAceAbilityHandler();
1432     window->aceAbilityHandler_ = aceAbilityHandler;
1433     EXPECT_CALL(*aceAbilityHandler, SetBackgroundColor(_));
1434     ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
1435     EXPECT_CALL(*aceAbilityHandler, GetBackgroundColor()).WillOnce(Return(0));
1436     ASSERT_EQ(0, window->GetBackgroundColor());
1437 
1438     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1439     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1440     EXPECT_CALL(*content, SetBackgroundColor(_));
1441     ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
1442     EXPECT_CALL(*content, GetBackgroundColor()).WillOnce(Return(0));
1443     ASSERT_EQ(0, window->GetBackgroundColor());
1444 }
1445 
1446 /**
1447  * @tc.name: SetTransparent
1448  * @tc.desc: SetTransparent test
1449  * @tc.type: FUNC
1450  */
1451 HWTEST_F(WindowImplTest2, SetTransparent, Function | SmallTest | Level3)
1452 {
1453     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1454     option->SetWindowName("SetTransparent");
1455     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1456     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1457     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1458     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1459     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
1460     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1461     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1462     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1463 
1464     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetTransparent(true));
1465     ASSERT_EQ(WMError::WM_OK, window->SetTransparent(false));
1466 
1467     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1468     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1469 }
1470 
1471 /**
1472  * @tc.name: TransferLifeCycleEventToString
1473  * @tc.desc: TransferLifeCycleEventToString test
1474  * @tc.type: FUNC
1475  */
1476 HWTEST_F(WindowImplTest2, TransferLifeCycleEventToString, Function | SmallTest | Level3)
1477 {
1478     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1479     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1480     ASSERT_EQ(std::string("DESTROY"), window->TransferLifeCycleEventToString(LifeCycleEvent::DESTROY_EVENT));
1481     ASSERT_EQ(std::string("UNDEFINE"),
1482               window->TransferLifeCycleEventToString(static_cast<LifeCycleEvent>(uint32_t(-1))));
1483 }
1484 
1485 /**
1486  * @tc.name: NotifyWindowTransition
1487  * @tc.desc: NotifyWindowTransition test
1488  * @tc.type: FUNC
1489  */
1490 HWTEST_F(WindowImplTest2, NotifyWindowTransition, Function | SmallTest | Level3)
1491 {
__anonc1e5bc930202(std::string) 1492     NotifyNativeWinDestroyFunc func = [](std::string) {};
1493     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1494     option->SetWindowName("MoveDrag");
1495     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1496     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1497     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1498     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1499     window->RegisterWindowDestroyedListener(func);
1500     window->RestoreSplitWindowMode(0u);
1501 
1502     ASSERT_EQ(WMError::WM_ERROR_NO_MEM, window->NotifyWindowTransition(TransitionReason::ABILITY_TRANSITION));
1503     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1504     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1505     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1506     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1507     ASSERT_EQ(WMError::WM_OK, window->Close());
1508     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1509 }
1510 
1511 /**
1512  * @tc.name: UpdateConfigurationSyncForAll
1513  * @tc.desc: UpdateConfigurationSyncForAll Test
1514  * @tc.type: FUNC
1515  */
1516 HWTEST_F(WindowImplTest2, UpdateConfigurationSyncForAll, Function | SmallTest | Level3)
1517 {
1518     sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1519     sptr<WindowImpl> window = sptr<WindowImpl>::MakeSptr(option);
1520     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1521     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1522     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1523     std::shared_ptr<AppExecFwk::Configuration> configuration;
1524     WindowImpl::UpdateConfigurationSyncForAll(configuration);
1525     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1526     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1527 }
1528 } // namespace
1529 } // namespace Rosen
1530 } // namespace OHOS
1531