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  */
HWTEST_F(WindowImplTest2, SetFocusable01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetFocusable02, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTouchable01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTouchable02, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, DisableAppWindowDecor01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTouchHotAreas01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTransform01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTransform02, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTransform03, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetTransform04, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetAPPWindowLabel, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetAPPWindowIcon, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, NotifyMemoryLevel01, Function | SmallTest | Level2)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectDragStartTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectDragTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectDragEndTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectRecoverTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectMoveTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, StretchableUpdateRectResizeTest, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, PrivacyMode01, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, CalculatePointerDirection, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, FindWindowById, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, GetSubWindow, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, UpdateConfigurationForAll, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetAlpha, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, GetAvoidAreaByType, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetWindowType, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetWindowMode, Function | SmallTest | Level3)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->UpdateModeSupportInfo(0);
804     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE,
805         window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
806     window->UpdateModeSupportInfo(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  */
HWTEST_F(WindowImplTest2, WindowFlag, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, OnNewWant, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, GetContentInfo, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, Snapshot, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, DumpInfo, Function | SmallTest | Level3)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  */
HWTEST_F(WindowImplTest2, SetLayoutFullScreen, Function | SmallTest | Level3)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->UpdateModeSupportInfo(0);
972     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetLayoutFullScreen(true));
973     window->UpdateModeSupportInfo(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  */
HWTEST_F(WindowImplTest2, SetImmersiveModeEnabledState, Function | SmallTest | Level3)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->UpdateModeSupportInfo(0);
1030     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetImmersiveModeEnabledState(true));
1031     window->UpdateModeSupportInfo(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 /*
1075  * @tc.name: SetFullScreen
1076  * @tc.desc: SetFullScreen test
1077  * @tc.type: FUNC
1078  */
HWTEST_F(WindowImplTest2, SetFullScreen, Function | SmallTest | Level3)1079 HWTEST_F(WindowImplTest2, SetFullScreen, Function | SmallTest | Level3)
1080 {
1081     sptr<WindowOption> option = new WindowOption();
1082     option->SetWindowName("SetFullScreen");
1083     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1084     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1085     sptr<WindowImpl> window = new WindowImpl(option);
1086     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1087     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1088     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1089     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1090 
1091     window->UpdateModeSupportInfo(0);
1092     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetFullScreen(true));
1093     window->UpdateModeSupportInfo(WindowModeSupport::WINDOW_MODE_SUPPORT_ALL);
1094 
1095     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1096     ASSERT_EQ(WMError::WM_OK, window->Show());
1097 
1098     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1099     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1100     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1101         (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1102     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3).WillRepeatedly(Return(WMError::WM_OK));
1103     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
1104 
1105     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = false;
1106     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = false;
1107     window->property_->SetWindowFlags(window->property_->GetWindowFlags() &
1108         (~static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1109     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
1110         .WillRepeatedly(Return(WMError::WM_OK));
1111     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(false));
1112 
1113     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1114     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1115     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1116         (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1117     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(2)
1118         .WillOnce(Return(WMError::WM_OK))
1119         .WillOnce(Return(WMError::WM_DO_NOTHING));
1120     ASSERT_EQ(WMError::WM_DO_NOTHING, window->SetFullScreen(true));
1121 
1122     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_STATUS_BAR].enable_ = true;
1123     window->property_->sysBarPropMap_[WindowType::WINDOW_TYPE_NAVIGATION_BAR].enable_ = true;
1124     window->property_->SetWindowFlags(window->property_->GetWindowFlags() |
1125         (static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_NEED_AVOID)));
1126     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).Times(3)
1127         .WillOnce(Return(WMError::WM_DO_NOTHING))
1128         .WillOnce(Return(WMError::WM_OK))
1129         .WillOnce(Return(WMError::WM_OK));
1130     ASSERT_EQ(WMError::WM_OK, window->SetFullScreen(true));
1131 
1132     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1133     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1134 }
1135 
1136 /*
1137  * @tc.name: UpdateTitleButtonVisibility
1138  * @tc.desc: UpdateTitleButtonVisibility test
1139  * @tc.type: FUNC
1140  */
HWTEST_F(WindowImplTest2, UpdateTitleButtonVisibility, Function | SmallTest | Level3)1141 HWTEST_F(WindowImplTest2, UpdateTitleButtonVisibility, Function | SmallTest | Level3)
1142 {
1143     sptr<WindowOption> option = new WindowOption();
1144     option->SetWindowName("BindDialogTarget");
1145     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1146     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1147     sptr<WindowImpl> window = new WindowImpl(option);
1148     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowFlags(0));
1149     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1150     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1151     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1152 
1153     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1154     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1155     EXPECT_CALL(*content, HideWindowTitleButton(_, _, _, _));
1156     window->UpdateTitleButtonVisibility();
1157 
1158     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1159     EXPECT_CALL(*content, Destroy());
1160     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1161 }
1162 
1163 /*
1164  * @tc.name: WindowCreateCheck
1165  * @tc.desc: WindowCreateCheck test
1166  * @tc.type: FUNC
1167  */
HWTEST_F(WindowImplTest2, WindowCreateCheck, Function | SmallTest | Level3)1168 HWTEST_F(WindowImplTest2, WindowCreateCheck, Function | SmallTest | Level3)
1169 {
1170     sptr<WindowOption> option = new WindowOption();
1171     option->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW);
1172     sptr<WindowImpl> window = new WindowImpl(option);
1173 
1174     ASSERT_EQ(WindowType::WINDOW_TYPE_SYSTEM_SUB_WINDOW, window->GetType());
1175     ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(INVALID_WINDOW_ID));
1176     ASSERT_NE(WMError::WM_OK, window->WindowCreateCheck(static_cast<uint32_t>(-1)));
1177 }
1178 
1179 /*
1180  * @tc.name: BindDialogTarget
1181  * @tc.desc: BindDialogTarget test
1182  * @tc.type: FUNC
1183  */
HWTEST_F(WindowImplTest2, BindDialogTarget, Function | SmallTest | Level3)1184 HWTEST_F(WindowImplTest2, BindDialogTarget, Function | SmallTest | Level3)
1185 {
1186     sptr<WindowOption> option = new WindowOption();
1187     option->SetWindowName("BindDialogTarget");
1188     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1189     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1190     sptr<WindowImpl> window = new WindowImpl(option);
1191 
1192     window->SetWindowState(WindowState::STATE_DESTROYED);
1193     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN));
1194     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1195     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1196     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1197 
1198     EXPECT_CALL(m->Mock(), BindDialogTarget(_, _)).Times(2)
1199         .WillOnce(Return(WMError::WM_OK))
1200         .WillOnce(Return(WMError::WM_DO_NOTHING));
1201     sptr<IRemoteObject> targetToken;
1202     ASSERT_EQ(WMError::WM_OK, window->BindDialogTarget(targetToken));
1203     ASSERT_EQ(WMError::WM_DO_NOTHING, window->BindDialogTarget(targetToken));
1204 
1205     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1206     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1207 }
1208 
1209 /*
1210  * @tc.name: Destroy
1211  * @tc.desc: Destroy test
1212  * @tc.type: FUNC
1213  */
HWTEST_F(WindowImplTest2, Destroy, Function | SmallTest | Level3)1214 HWTEST_F(WindowImplTest2, Destroy, Function | SmallTest | Level3)
1215 {
1216     sptr<WindowOption> option = new WindowOption();
1217     option->SetWindowName("Destroy");
1218     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1219     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1220     sptr<WindowImpl> window = new WindowImpl(option);
1221 
1222     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1223     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1224     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1225 
1226     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1227     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
1228 
1229     window->SetWindowType(WindowType::WINDOW_TYPE_DIALOG);
1230     ASSERT_EQ(WindowType::WINDOW_TYPE_DIALOG, window->GetType());
1231     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1232     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Destroy());
1233 }
1234 
1235 /*
1236  * @tc.name: UpdateSurfaceNodeAfterCustomAnimation
1237  * @tc.desc: UpdateSurfaceNodeAfterCustomAnimation test
1238  * @tc.type: FUNC
1239  */
HWTEST_F(WindowImplTest2, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)1240 HWTEST_F(WindowImplTest2, UpdateSurfaceNodeAfterCustomAnimation, Function | SmallTest | Level3)
1241 {
1242     sptr<WindowOption> option = new WindowOption();
1243     option->SetWindowName("UpdateSurfaceNodeAfterCustomAnimation");
1244     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1245     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1246     sptr<WindowImpl> window = new WindowImpl(option);
1247     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1248 
1249     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1250     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).WillOnce(Return(WMError::WM_OK));
1251     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1252     window->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1253     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1254 
1255     window->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
1256     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1257     ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1258 
1259     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
1260     EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1261     ASSERT_EQ(WMError::WM_DO_NOTHING, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1262 
1263     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_OK));
1264     EXPECT_CALL(m->Mock(), UpdateRsTree(_, _)).WillOnce(Return(WMError::WM_OK));
1265     ASSERT_EQ(WMError::WM_OK, window->UpdateSurfaceNodeAfterCustomAnimation(true));
1266 
1267     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1268     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1269 }
1270 
1271 /**
1272  * @tc.name: ShowHide
1273  * @tc.desc: Show and Hide test
1274  * @tc.type: FUNC
1275  */
HWTEST_F(WindowImplTest2, ShowHide, Function | SmallTest | Level3)1276 HWTEST_F(WindowImplTest2, ShowHide, Function | SmallTest | Level3)
1277 {
1278     sptr<WindowOption> option = new WindowOption();
1279     option->SetWindowName("ShowHide");
1280     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1281     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1282     sptr<WindowImpl> window = new WindowImpl(option);
1283     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1284 
1285     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Show());
1286     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Hide());
1287     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1288     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1289     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1290 
1291     auto state = window->GetWindowState();
1292     window->SetWindowState(WindowState::STATE_FROZEN);
1293     ASSERT_EQ(WindowState::STATE_FROZEN, window->GetWindowState());
1294     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->PreProcessShow(0, false));
1295     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->Show());
1296 
1297     window->SetWindowState(state);
1298     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1299     ASSERT_EQ(WMError::WM_OK, window->Show());
1300     ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
1301 
1302     ASSERT_EQ(WMError::WM_OK, window->Show(static_cast<uint32_t>(WindowStateChangeReason::KEYGUARD)));
1303     EXPECT_CALL(m->Mock(), ProcessPointDown(_, _));
1304     ASSERT_EQ(WMError::WM_OK, window->Show());
1305 
1306     window->property_->SetWindowType(WindowType::WINDOW_TYPE_DESKTOP);
1307     ASSERT_EQ(WindowType::WINDOW_TYPE_DESKTOP, window->GetType());
1308     EXPECT_CALL(m->Mock(), MinimizeAllAppWindows(_));
1309     ASSERT_EQ(WMError::WM_OK, window->Show());
1310 
1311     EXPECT_CALL(m->Mock(), UpdateProperty(_, _)).WillOnce(Return(WMError::WM_DO_NOTHING));
1312     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Hide());
1313     ASSERT_EQ(WindowState::STATE_SHOWN, window->GetWindowState());
1314 
1315     window->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1316 
1317     ASSERT_EQ(WMError::WM_OK, window->Hide(static_cast<uint32_t>(WindowStateChangeReason::TOGGLING)));
1318     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1319 
1320     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE));
1321     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW_MODE_OR_SIZE, window->Show());
1322     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1323 
1324     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_DO_NOTHING));
1325     ASSERT_EQ(WMError::WM_DO_NOTHING, window->Show());
1326     ASSERT_EQ(WindowState::STATE_HIDDEN, window->GetWindowState());
1327 
1328     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1329     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1330 }
1331 
1332 /*
1333  * @tc.name: CloseWindow
1334  * @tc.desc: CloseWindow test
1335  * @tc.type: FUNC
1336  */
HWTEST_F(WindowImplTest2, CloseWindow, Function | SmallTest | Level3)1337 HWTEST_F(WindowImplTest2, CloseWindow, Function | SmallTest | Level3)
1338 {
1339     sptr<WindowOption> option = new WindowOption();
1340     option->SetWindowName("CloseWindow");
1341     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1342     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1343     sptr<WindowImpl> window = new WindowImpl(option);
1344     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1345     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1346     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1347     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1348 
1349     EXPECT_CALL(m->Mock(), AddWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1350     ASSERT_EQ(WMError::WM_OK, window->Show());
1351     ASSERT_EQ(WMError::WM_OK, window->Close());
1352     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1353 }
1354 
1355 /*
1356  * @tc.name: PendingCloseWindow
1357  * @tc.desc: PendingCloseWindow test
1358  * @tc.type: FUNC
1359  */
HWTEST_F(WindowImplTest2, PendingCloseWindow, Function | SmallTest | Level3)1360 HWTEST_F(WindowImplTest2, PendingCloseWindow, Function | SmallTest | Level3)
1361 {
1362     sptr<WindowOption> option = new WindowOption();
1363     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1364     sptr<WindowImpl> window = new WindowImpl(option);
1365     window->PendingClose();
1366     ASSERT_EQ(nullptr, window->context_);
1367 }
1368 
1369 /*
1370  * @tc.name: InvalidWindow
1371  * @tc.desc: InvalidWindow test
1372  * @tc.type: FUNC
1373  */
HWTEST_F(WindowImplTest2, InvalidWindow, Function | SmallTest | Level3)1374 HWTEST_F(WindowImplTest2, InvalidWindow, Function | SmallTest | Level3)
1375 {
1376     sptr<WindowOption> option = new WindowOption();
1377     sptr<WindowImpl> window = new WindowImpl(option);
1378     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->MoveTo(0, 0));
1379     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Resize(0, 0));
1380     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetCallingWindow(INVALID_WINDOW_ID));
1381     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetBackgroundColor(std::string("???")));
1382     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->Close());
1383 }
1384 
1385 /*
1386  * @tc.name: BackgroundColor
1387  * @tc.desc: GetBackgroundColor | SetBackGroundColor test
1388  * @tc.type: FUNC
1389  */
HWTEST_F(WindowImplTest2, BackgroundColor, Function | SmallTest | Level3)1390 HWTEST_F(WindowImplTest2, BackgroundColor, Function | SmallTest | Level3)
1391 {
1392     sptr<WindowOption> option = new WindowOption();
1393     sptr<WindowImpl> window = new WindowImpl(option);
1394 
1395     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetBackgroundColor(0));
1396 
1397     MockAceAbilityHandler* aceAbilityHandler = new MockAceAbilityHandler();
1398     window->aceAbilityHandler_ = aceAbilityHandler;
1399     EXPECT_CALL(*aceAbilityHandler, SetBackgroundColor(_));
1400     ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
1401     EXPECT_CALL(*aceAbilityHandler, GetBackgroundColor()).WillOnce(Return(0));
1402     ASSERT_EQ(0, window->GetBackgroundColor());
1403 
1404     window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1405     Ace::UIContentMocker* content = reinterpret_cast<Ace::UIContentMocker*>(window->uiContent_.get());
1406     EXPECT_CALL(*content, SetBackgroundColor(_));
1407     ASSERT_EQ(WMError::WM_OK, window->SetBackgroundColor(0));
1408     EXPECT_CALL(*content, GetBackgroundColor()).WillOnce(Return(0));
1409     ASSERT_EQ(0, window->GetBackgroundColor());
1410 }
1411 
1412 /*
1413  * @tc.name: SetTransparent
1414  * @tc.desc: SetTransparent test
1415  * @tc.type: FUNC
1416  */
HWTEST_F(WindowImplTest2, SetTransparent, Function | SmallTest | Level3)1417 HWTEST_F(WindowImplTest2, SetTransparent, Function | SmallTest | Level3)
1418 {
1419     sptr<WindowOption> option = new WindowOption();
1420     option->SetWindowName("SetTransparent");
1421     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1422     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1423     sptr<WindowImpl> window = new WindowImpl(option);
1424     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1425     ASSERT_EQ(WMError::WM_ERROR_INVALID_WINDOW, window->SetTransparent(true));
1426     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1427     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1428     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1429 
1430     ASSERT_EQ(WMError::WM_ERROR_INVALID_OPERATION, window->SetTransparent(true));
1431     ASSERT_EQ(WMError::WM_OK, window->SetTransparent(false));
1432 
1433     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1434     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1435 }
1436 
1437 /*
1438  * @tc.name: TransferLifeCycleEventToString
1439  * @tc.desc: TransferLifeCycleEventToString test
1440  * @tc.type: FUNC
1441  */
HWTEST_F(WindowImplTest2, TransferLifeCycleEventToString, Function | SmallTest | Level3)1442 HWTEST_F(WindowImplTest2, TransferLifeCycleEventToString, Function | SmallTest | Level3)
1443 {
1444     sptr<WindowOption> option = new WindowOption();
1445     sptr<WindowImpl> window = new WindowImpl(option);
1446     ASSERT_EQ(std::string("DESTROY"), window->TransferLifeCycleEventToString(LifeCycleEvent::DESTROY_EVENT));
1447     ASSERT_EQ(std::string("UNDEFINE"), window->TransferLifeCycleEventToString(
1448         static_cast<LifeCycleEvent>(uint32_t(-1))));
1449 }
1450 
1451 /*
1452  * @tc.name: NotifyWindowTransition
1453  * @tc.desc: NotifyWindowTransition test
1454  * @tc.type: FUNC
1455  */
HWTEST_F(WindowImplTest2, NotifyWindowTransition, Function | SmallTest | Level3)1456 HWTEST_F(WindowImplTest2, NotifyWindowTransition, Function | SmallTest | Level3)
1457 {
1458     NotifyNativeWinDestroyFunc func = [](std::string) {};
1459     sptr<WindowOption> option = new WindowOption();
1460     option->SetWindowName("MoveDrag");
1461     option->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
1462     option->SetWindowMode(WindowMode::WINDOW_MODE_FULLSCREEN);
1463     sptr<WindowImpl> window = new WindowImpl(option);
1464     std::unique_ptr<Mocker> m = std::make_unique<Mocker>();
1465     window->RegisterWindowDestroyedListener(func);
1466     window->RestoreSplitWindowMode(0u);
1467 
1468     ASSERT_EQ(WMError::WM_ERROR_NO_MEM, window->NotifyWindowTransition(TransitionReason::ABILITY_TRANSITION));
1469     EXPECT_CALL(m->Mock(), GetSystemConfig(_)).WillOnce(Return(WMError::WM_OK));
1470     EXPECT_CALL(m->Mock(), CreateWindow(_, _, _, _, _)).Times(1).WillOnce(Return(WMError::WM_OK));
1471     ASSERT_EQ(WMError::WM_OK, window->Create(INVALID_WINDOW_ID));
1472     EXPECT_CALL(m->Mock(), DestroyWindow(_)).Times(1).WillOnce(Return(WMError::WM_OK));
1473     ASSERT_EQ(WMError::WM_OK, window->Close());
1474     ASSERT_EQ(WMError::WM_OK, window->Destroy());
1475 }
1476 }
1477 } // namespace Rosen
1478 } // namespace OHOS
1479