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
24using namespace testing;
25using namespace testing::ext;
26
27namespace OHOS {
28namespace Rosen {
29using Mocker = SingletonMocker<WindowAdapter, MockWindowAdapter>;
30class MockAceAbilityHandler : public IAceAbilityHandler {
31public:
32    MOCK_METHOD1(SetBackgroundColor, void(uint32_t color));
33    MOCK_METHOD0(GetBackgroundColor, uint32_t());
34};
35
36class WindowImplTest2 : public testing::Test {
37public:
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>();
46private:
47    static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
48};
49void WindowImplTest2::SetUpTestCase()
50{
51}
52
53void WindowImplTest2::TearDownTestCase()
54{
55}
56
57void WindowImplTest2::SetUp()
58{
59}
60
61void WindowImplTest2::TearDown()
62{
63    usleep(WAIT_SYNC_IN_NS);
64}
65
66void 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
88namespace {
89/**
90 * @tc.name: SetFocusable01
91 * @tc.desc: create window but not show, test SetFocusable
92 * @tc.type: FUNC
93 */
94HWTEST_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 */
128HWTEST_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 */
159HWTEST_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 */
191HWTEST_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 */
222HWTEST_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 */
251HWTEST_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 */
297HWTEST_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 */
327HWTEST_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 */
355HWTEST_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 */
383HWTEST_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 */
412HWTEST_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 */
433HWTEST_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 */
455HWTEST_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 */
474HWTEST_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 */
496HWTEST_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 */
514HWTEST_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 */
532HWTEST_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 */
550HWTEST_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 */
568HWTEST_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 */
589HWTEST_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 */
622HWTEST_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 */
641HWTEST_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 */
666HWTEST_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 */
697HWTEST_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 */
715HWTEST_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 */
736HWTEST_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 */
757HWTEST_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 */
783HWTEST_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 */
821HWTEST_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 */
849HWTEST_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 */
876HWTEST_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 */
902HWTEST_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 */
928HWTEST_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 */
960HWTEST_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 */
1018HWTEST_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 */
1079HWTEST_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 */
1141HWTEST_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 */
1168HWTEST_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 */
1184HWTEST_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 */
1214HWTEST_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 */
1240HWTEST_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 */
1276HWTEST_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 */
1337HWTEST_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 */
1360HWTEST_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 */
1374HWTEST_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 */
1390HWTEST_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 */
1417HWTEST_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 */
1442HWTEST_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 */
1456HWTEST_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