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