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_info.h"
19 #include "mock_session.h"
20 #include "mock_uicontent.h"
21 #include "mock_window.h"
22 #include "parameters.h"
23 #include "scene_board_judgement.h"
24 #include "window_manager_hilog.h"
25 #include "window_session_impl.h"
26 #include "wm_common.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace {
32 std::string logMsg;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)33 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
34 const char* msg)
35 {
36 logMsg = msg;
37 }
38 }
39
40 namespace OHOS {
41 namespace Rosen {
42 class WindowSessionImplTest3 : public testing::Test {
43 public:
44 static void SetUpTestCase();
45 static void TearDownTestCase();
46 void SetUp() override;
47 void TearDown() override;
48 sptr<WindowSessionImpl> window_;
49 };
50
SetUpTestCase()51 void WindowSessionImplTest3::SetUpTestCase() {}
52
TearDownTestCase()53 void WindowSessionImplTest3::TearDownTestCase() {}
54
SetUp()55 void WindowSessionImplTest3::SetUp() {}
56
TearDown()57 void WindowSessionImplTest3::TearDown()
58 {
59 if (window_ != nullptr) {
60 window_->Destroy();
61 }
62 }
63
64 namespace {
GetTestWindowImpl(const std::string & name)65 sptr<WindowSessionImpl> GetTestWindowImpl(const std::string& name)
66 {
67 sptr<WindowOption> option = new (std::nothrow) WindowOption();
68 if (option == nullptr) {
69 return nullptr;
70 }
71 option->SetWindowName(name);
72 sptr<WindowSessionImpl> window = new (std::nothrow) WindowSessionImpl(option);
73 if (window == nullptr) {
74 return nullptr;
75 }
76 SessionInfo sessionInfo = { name, name, name };
77 sptr<SessionMocker> session = new (std::nothrow) SessionMocker(sessionInfo);
78 if (session == nullptr) {
79 return nullptr;
80 }
81 window->hostSession_ = session;
82 return window;
83 }
84
85 /**
86 * @tc.name: SetInputEventConsumer
87 * @tc.desc: SetInputEventConsumer01
88 * @tc.type: FUNC
89 */
90 HWTEST_F(WindowSessionImplTest3, SetInputEventConsumer01, TestSize.Level1)
91 {
92 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetInputEventConsumer01 start";
93 window_ = GetTestWindowImpl("SetInputEventConsumer01");
94 ASSERT_NE(window_, nullptr);
95 window_->inputEventConsumer_ = nullptr;
96 std::shared_ptr<IInputEventConsumer> inputEventConsumer = std::make_shared<MockInputEventConsumer>();
97 window_->SetInputEventConsumer(inputEventConsumer);
98 ASSERT_NE(window_->inputEventConsumer_, nullptr);
99 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetInputEventConsumer01 end";
100 }
101
102 /**
103 * @tc.name: SetContinueState
104 * @tc.desc: SetContinueState test
105 * @tc.type: FUNC
106 */
107 HWTEST_F(WindowSessionImplTest3, SetContinueState, TestSize.Level1)
108 {
109 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetContinueState start";
110 window_ = GetTestWindowImpl("SetContinueState");
111 ASSERT_NE(window_, nullptr);
112 WMError ret = window_->SetContinueState(static_cast<int32_t>(ContinueState::CONTINUESTATE_INACTIVE));
113 ASSERT_EQ(ret, WMError::WM_OK);
114 ret = window_->SetContinueState(-100);
115 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PARAM);
116 ret = window_->SetContinueState(3);
117 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PARAM);
118 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetContinueState end";
119 }
120
121 /**
122 * @tc.name: GetListeners
123 * @tc.desc: GetListeners01 IDisplayMoveListener
124 * @tc.type: FUNC
125 */
126 HWTEST_F(WindowSessionImplTest3, GetListeners01, TestSize.Level1)
127 {
128 GTEST_LOG_(INFO) << "WindowSessionImplTest3: GetListeners01 start";
129 window_ = GetTestWindowImpl("GetListeners01");
130 ASSERT_NE(window_, nullptr);
131 window_->displayMoveListeners_.clear();
132 window_->NotifyDisplayMove(0, 100);
133 ASSERT_TRUE(window_->displayMoveListeners_[window_->GetPersistentId()].empty());
134
135 sptr<IDisplayMoveListener> displayMoveListener = new (std::nothrow) MockIDisplayMoveListener();
136 ASSERT_EQ(window_->RegisterDisplayMoveListener(displayMoveListener), WMError::WM_OK);
137 window_->NotifyDisplayMove(0, 100);
138 ASSERT_FALSE(window_->displayMoveListeners_[window_->GetPersistentId()].empty());
139 GTEST_LOG_(INFO) << "WindowSessionImplTest3: GetListeners01 end";
140 }
141
142 /**
143 * @tc.name: RegisterWindowNoInteractionListener
144 * @tc.desc: RegisterWindowNoInteractionListener01
145 * @tc.type: FUNC
146 */
147 HWTEST_F(WindowSessionImplTest3, RegisterWindowNoInteractionListener01, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "WindowSessionImplTest3: RegisterWindowNoInteractionListener01 start";
150 window_ = GetTestWindowImpl("RegisterWindowNoInteractionListener01");
151 ASSERT_NE(window_, nullptr);
152 ASSERT_EQ(window_->RegisterWindowNoInteractionListener(nullptr), WMError::WM_ERROR_NULLPTR);
153 ASSERT_EQ(window_->UnregisterWindowNoInteractionListener(nullptr), WMError::WM_ERROR_NULLPTR);
154
155 sptr<IWindowNoInteractionListener> windowNoInteractionListenerSptr =
156 new (std::nothrow) MockIWindowNoInteractionListener();
157 ASSERT_EQ(window_->RegisterWindowNoInteractionListener(windowNoInteractionListenerSptr), WMError::WM_OK);
158 ASSERT_EQ(window_->UnregisterWindowNoInteractionListener(windowNoInteractionListenerSptr), WMError::WM_OK);
159 GTEST_LOG_(INFO) << "WindowSessionImplTest3: RegisterWindowNoInteractionListener01 end";
160 }
161
162 /**
163 * @tc.name: SetForceSplitEnable
164 * @tc.desc: SetForceSplitEnable
165 * @tc.type: FUNC
166 */
167 HWTEST_F(WindowSessionImplTest3, SetForceSplitEnable, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetForceSplitEnable start";
170 logMsg.clear();
171 LOG_SetCallback(MyLogCallback);
172 window_ = GetTestWindowImpl("SetForceSplitEnable");
173 ASSERT_NE(window_, nullptr);
174
175 int32_t FORCE_SPLIT_MODE = 5;
176 int32_t NAV_FORCE_SPLIT_MODE = 6;
177 AppForceLandscapeConfig config = { FORCE_SPLIT_MODE, "MainPage", true, "ArkuiOptions" };
178 window_->SetForceSplitEnable(config);
179
180 config = { FORCE_SPLIT_MODE, "MainPage", false, "ArkuiOptions" };
181 window_->SetForceSplitEnable(config);
182
183 config = { NAV_FORCE_SPLIT_MODE, "MainPage", true, "ArkuiOptions" };
184 window_->SetForceSplitEnable(config);
185
186 config = { NAV_FORCE_SPLIT_MODE, "MainPage", false, "ArkuiOptions" };
187 window_->SetForceSplitEnable(config);
188 EXPECT_TRUE(logMsg.find("uiContent is null!") != std::string::npos);
189 LOG_SetCallback(nullptr);
190 GTEST_LOG_(INFO) << "WindowSessionImplTest3: SetForceSplitEnable end";
191 }
192
193 /**
194 * @tc.name: GetAppForceLandscapeConfig
195 * @tc.desc: GetAppForceLandscapeConfig
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowSessionImplTest3, GetAppForceLandscapeConfig, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetAppForceLandscapeConfig start";
201 window_ = GetTestWindowImpl("GetAppForceLandscapeConfig");
202 ASSERT_NE(window_, nullptr);
203
204 AppForceLandscapeConfig config = {};
205 window_->hostSession_ = nullptr;
206 auto res = window_->GetAppForceLandscapeConfig(config);
207 ASSERT_EQ(res, WMError::WM_OK);
208 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetAppForceLandscapeConfig end";
209 }
210
211 /**
212 * @tc.name: IsSceneBoardEnabled
213 * @tc.desc: IsSceneBoardEnabled
214 * @tc.type: FUNC
215 */
216 HWTEST_F(WindowSessionImplTest3, IsSceneBoardEnabled, TestSize.Level1)
217 {
218 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsSceneBoardEnabled start";
219 window_ = GetTestWindowImpl("IsSceneBoardEnabled");
220 ASSERT_NE(window_, nullptr);
221
222 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
223 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
224 window_->hostSession_ = session;
225 window_->property_->SetPersistentId(1);
226 window_->state_ = WindowState::STATE_CREATED;
227 bool result = SceneBoardJudgement::IsSceneBoardEnabled();
228 ASSERT_EQ(result, window_->IsSceneBoardEnabled());
229 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsSceneBoardEnabled end";
230 }
231
232 /**
233 * @tc.name: IsFocused
234 * @tc.desc: IsFocused
235 * @tc.type: FUNC
236 */
237 HWTEST_F(WindowSessionImplTest3, IsFocused, TestSize.Level1)
238 {
239 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsFocused start";
240 window_ = GetTestWindowImpl("IsFocused");
241 ASSERT_NE(window_, nullptr);
242 window_->property_->SetPersistentId(INVALID_SESSION_ID);
243 auto ret = window_->IsFocused();
244 ASSERT_EQ(ret, false);
245
246 window_->property_->SetPersistentId(1);
247 window_->state_ = WindowState::STATE_CREATED;
248 window_->UpdateFocus(true);
249 ret = window_->IsFocused();
250 ASSERT_EQ(ret, true);
251 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsFocused end";
252 }
253
254 /**
255 * @tc.name: IsNotifyInteractiveDuplicative
256 * @tc.desc: IsNotifyInteractiveDuplicative
257 * @tc.type: FUNC
258 */
259 HWTEST_F(WindowSessionImplTest3, IsNotifyInteractiveDuplicative, TestSize.Level1)
260 {
261 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsNotifyInteractiveDuplicative start";
262 window_ = GetTestWindowImpl("IsNotifyInteractiveDuplicative");
263 ASSERT_NE(window_, nullptr);
264 window_->hasFirstNotifyInteractive_ = true;
265 window_->interactive_ = true;
266 window_->NotifyForegroundInteractiveStatus(true);
267 auto ret = window_->IsNotifyInteractiveDuplicative(true);
268 ASSERT_EQ(ret, true);
269 GTEST_LOG_(INFO) << "IsNotifyInteractiveDuplicative: IsNotifyInteractiveDuplicative end";
270 }
271
272 /**
273 * @tc.name: SetMainWindowTopmost
274 * @tc.desc: SetMainWindowTopmost
275 * @tc.type: FUNC
276 */
277 HWTEST_F(WindowSessionImplTest3, SetMainWindowTopmost, TestSize.Level1)
278 {
279 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetMainWindowTopmost start";
280 window_ = GetTestWindowImpl("SetMainWindowTopmost");
281 ASSERT_NE(window_, nullptr);
282 window_->property_->SetPersistentId(INVALID_SESSION_ID);
283 auto ret = window_->SetMainWindowTopmost(true);
284 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
285 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetMainWindowTopmost end";
286 }
287
288 /**
289 * @tc.name: SetDecorVisible
290 * @tc.desc: SetDecorVisible
291 * @tc.type: FUNC
292 */
293 HWTEST_F(WindowSessionImplTest3, SetDecorVisible, TestSize.Level1)
294 {
295 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetDecorVisible start";
296 window_ = GetTestWindowImpl("SetDecorVisible");
297 ASSERT_NE(window_, nullptr);
298 window_->property_->SetPersistentId(INVALID_SESSION_ID);
299 auto ret = window_->SetDecorVisible(true);
300 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
301 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetDecorVisible end";
302 }
303
304 /**
305 * @tc.name: SetWindowModal
306 * @tc.desc: SetWindowModal
307 * @tc.type: FUNC
308 */
309 HWTEST_F(WindowSessionImplTest3, SetWindowModal, TestSize.Level1)
310 {
311 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetWindowModal start";
312 window_ = GetTestWindowImpl("SetWindowModal");
313 ASSERT_NE(window_, nullptr);
314 window_->property_->SetPersistentId(INVALID_SESSION_ID);
315 auto ret = window_->SetWindowModal(true);
316 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
317 ret = window_->SetWindowModal(false);
318 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
319
320 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
321 window_->property_->SetPersistentId(1);
322 window_->state_ = WindowState::STATE_CREATED;
323 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
324 ret = window_->SetWindowModal(true);
325 ASSERT_EQ(WMError::WM_OK, ret);
326 ret = window_->SetWindowModal(false);
327 ASSERT_EQ(WMError::WM_OK, ret);
328
329 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
330 ret = window_->SetWindowModal(true);
331 ASSERT_EQ(WMError::WM_OK, ret);
332 ret = window_->SetWindowModal(false);
333 ASSERT_EQ(WMError::WM_OK, ret);
334
335 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
336 ret = window_->SetWindowModal(true);
337 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
338 ret = window_->SetWindowModal(false);
339 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
340
341 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
342 ret = window_->SetWindowModal(false);
343 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
344 ret = window_->SetWindowModal(true);
345 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
346 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetWindowModal end";
347 }
348
349 /**
350 * @tc.name: SetDecorButtonStyle
351 * @tc.desc: SetDecorButtonStyle
352 * @tc.type: FUNC
353 */
354 HWTEST_F(WindowSessionImplTest3, SetDecorButtonStyle, TestSize.Level1)
355 {
356 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetDecorButtonStyle start";
357 window_ = GetTestWindowImpl("SetDecorButtonStyle");
358 ASSERT_NE(window_, nullptr);
359 window_->property_->SetPersistentId(INVALID_SESSION_ID);
360 DecorButtonStyle decorButtonStyle;
361 auto ret = window_->SetDecorButtonStyle(decorButtonStyle);
362 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
363 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetDecorButtonStyle end";
364 }
365
366 /**
367 * @tc.name: GetDecorButtonStyle
368 * @tc.desc: GetDecorButtonStyle
369 * @tc.type: FUNC
370 */
371 HWTEST_F(WindowSessionImplTest3, GetDecorButtonStyle, TestSize.Level1)
372 {
373 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetDecorButtonStyle start";
374 window_ = GetTestWindowImpl("GetDecorButtonStyle");
375 ASSERT_NE(window_, nullptr);
376 window_->property_->SetPersistentId(INVALID_SESSION_ID);
377 DecorButtonStyle decorButtonStyle;
378 auto ret = window_->GetDecorButtonStyle(decorButtonStyle);
379 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
380 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetDecorButtonStyle end";
381 }
382
383 /**
384 * @tc.name: RegisterMainWindowCloseListeners
385 * @tc.desc: RegisterMainWindowCloseListeners
386 * @tc.type: FUNC
387 */
388 HWTEST_F(WindowSessionImplTest3, RegisterMainWindowCloseListeners, TestSize.Level1)
389 {
390 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterMainWindowCloseListeners start";
391 window_ = GetTestWindowImpl("RegisterMainWindowCloseListeners");
392 ASSERT_NE(window_, nullptr);
393 window_->property_->SetPersistentId(INVALID_SESSION_ID);
394 sptr<IMainWindowCloseListener> listener = sptr<IMainWindowCloseListener>::MakeSptr();
395 ASSERT_NE(listener, nullptr);
396 auto ret = window_->RegisterMainWindowCloseListeners(listener);
397 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
398
399 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
400 window_->property_->SetPersistentId(1);
401 window_->state_ = WindowState::STATE_CREATED;
402 ret = window_->RegisterMainWindowCloseListeners(listener);
403 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
404
405 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
406 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
407 ret = window_->RegisterMainWindowCloseListeners(listener);
408 ASSERT_EQ(ret, WMError::WM_OK);
409
410 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
411 ret = window_->RegisterMainWindowCloseListeners(listener);
412 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
413 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterMainWindowCloseListeners end";
414 }
415
416 /**
417 * @tc.name: UnregisterMainWindowCloseListeners
418 * @tc.desc: UnregisterMainWindowCloseListeners
419 * @tc.type: FUNC
420 */
421 HWTEST_F(WindowSessionImplTest3, UnregisterMainWindowCloseListeners, TestSize.Level1)
422 {
423 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterMainWindowCloseListeners start";
424 window_ = GetTestWindowImpl("UnregisterMainWindowCloseListeners");
425 ASSERT_NE(window_, nullptr);
426 window_->property_->SetPersistentId(INVALID_SESSION_ID);
427 sptr<IMainWindowCloseListener> listener = sptr<IMainWindowCloseListener>::MakeSptr();
428 ASSERT_NE(listener, nullptr);
429 auto ret = window_->UnregisterMainWindowCloseListeners(listener);
430 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
431
432 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
433 window_->property_->SetPersistentId(1);
434 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
435 window_->state_ = WindowState::STATE_CREATED;
436 ret = window_->UnregisterMainWindowCloseListeners(listener);
437 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
438
439 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
440 ret = window_->UnregisterMainWindowCloseListeners(listener);
441 ASSERT_EQ(ret, WMError::WM_OK);
442
443 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
444 ret = window_->UnregisterMainWindowCloseListeners(listener);
445 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
446 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterMainWindowCloseListeners end";
447 }
448
449 /**
450 * @tc.name: RegisterWindowWillCloseListeners
451 * @tc.desc: RegisterWindowWillCloseListeners
452 * @tc.type: FUNC
453 */
454 HWTEST_F(WindowSessionImplTest3, RegisterWindowWillCloseListeners, TestSize.Level1)
455 {
456 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterWindowWillCloseListeners start";
457 window_ = GetTestWindowImpl("RegisterWindowWillCloseListeners");
458 ASSERT_NE(window_, nullptr);
459 window_->property_->SetPersistentId(INVALID_SESSION_ID);
460 sptr<IWindowWillCloseListener> listener = sptr<IWindowWillCloseListener>::MakeSptr();
461 auto ret = window_->RegisterWindowWillCloseListeners(listener);
462 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
463
464 window_->property_->SetPersistentId(1);
465 window_->state_ = WindowState::STATE_CREATED;
466 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
467 ret = window_->RegisterWindowWillCloseListeners(listener);
468 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
469
470 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
471 window_->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
472 ret = window_->RegisterWindowWillCloseListeners(listener);
473 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
474
475 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
476 ret = window_->RegisterWindowWillCloseListeners(listener);
477 ASSERT_EQ(ret, WMError::WM_OK);
478 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterWindowWillCloseListeners end";
479 }
480
481 /**
482 * @tc.name: UnRegisterWindowWillCloseListeners
483 * @tc.desc: UnRegisterWindowWillCloseListeners
484 * @tc.type: FUNC
485 */
486 HWTEST_F(WindowSessionImplTest3, UnRegisterWindowWillCloseListeners, TestSize.Level1)
487 {
488 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnRegisterWindowWillCloseListeners start";
489 window_ = GetTestWindowImpl("UnRegisterWindowWillCloseListeners");
490 ASSERT_NE(window_, nullptr);
491 window_->property_->SetPersistentId(INVALID_SESSION_ID);
492 sptr<IWindowWillCloseListener> listener = sptr<IWindowWillCloseListener>::MakeSptr();
493 auto ret = window_->UnRegisterWindowWillCloseListeners(listener);
494 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
495
496 window_->property_->SetPersistentId(1);
497 window_->state_ = WindowState::STATE_CREATED;
498 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
499 ret = window_->UnRegisterWindowWillCloseListeners(listener);
500 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
501
502 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
503 window_->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
504 ret = window_->UnRegisterWindowWillCloseListeners(listener);
505 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
506
507 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
508 ret = window_->UnRegisterWindowWillCloseListeners(listener);
509 ASSERT_EQ(ret, WMError::WM_OK);
510 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnRegisterWindowWillCloseListeners end";
511 }
512
513 /**
514 * @tc.name: RegisterSwitchFreeMultiWindowListener
515 * @tc.desc: RegisterSwitchFreeMultiWindowListener
516 * @tc.type: FUNC
517 */
518 HWTEST_F(WindowSessionImplTest3, RegisterSwitchFreeMultiWindowListener, TestSize.Level1)
519 {
520 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterSwitchFreeMultiWindowListener start";
521 window_ = GetTestWindowImpl("RegisterSwitchFreeMultiWindowListener");
522 ASSERT_NE(window_, nullptr);
523 sptr<ISwitchFreeMultiWindowListener> listener = sptr<ISwitchFreeMultiWindowListener>::MakeSptr();
524 ASSERT_NE(listener, nullptr);
525 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
526 auto ret = window_->RegisterSwitchFreeMultiWindowListener(listener);
527 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
528 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterSwitchFreeMultiWindowListener end";
529 }
530
531 /**
532 * @tc.name: UnregisterSwitchFreeMultiWindowListener
533 * @tc.desc: UnregisterSwitchFreeMultiWindowListener
534 * @tc.type: FUNC
535 */
536 HWTEST_F(WindowSessionImplTest3, UnregisterSwitchFreeMultiWindowListener, TestSize.Level1)
537 {
538 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterSwitchFreeMultiWindowListener start";
539 window_ = GetTestWindowImpl("UnregisterSwitchFreeMultiWindowListener");
540 ASSERT_NE(window_, nullptr);
541 sptr<ISwitchFreeMultiWindowListener> listener = sptr<ISwitchFreeMultiWindowListener>::MakeSptr();
542 ASSERT_NE(listener, nullptr);
543 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
544 auto ret = window_->UnregisterSwitchFreeMultiWindowListener(listener);
545 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_CALLING);
546 window_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
547 ret = window_->UnregisterSwitchFreeMultiWindowListener(listener);
548 ASSERT_EQ(ret, WMError::WM_OK);
549 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterSwitchFreeMultiWindowListener end";
550 }
551
552 /**
553 * @tc.name: SetSplitButtonVisible
554 * @tc.desc: SetSplitButtonVisible
555 * @tc.type: FUNC
556 */
557 HWTEST_F(WindowSessionImplTest3, SetSplitButtonVisible, TestSize.Level1)
558 {
559 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetSplitButtonVisible start";
560 window_ = GetTestWindowImpl("SetSplitButtonVisible");
561 ASSERT_NE(window_, nullptr);
562 auto ret = window_->SetSplitButtonVisible(true);
563 ASSERT_EQ(ret, WSError::WS_OK);
564 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetSplitButtonVisible end";
565 }
566
567 /**
568 * @tc.name: NotifyNoInteractionTimeout
569 * @tc.desc: NotifyNoInteractionTimeout
570 * @tc.type: FUNC
571 */
572 HWTEST_F(WindowSessionImplTest3, NotifyNoInteractionTimeout, TestSize.Level1)
573 {
574 GTEST_LOG_(INFO) << "WindowSessionImplTest: NotifyNoInteractionTimeout start";
575 window_ = GetTestWindowImpl("NotifyNoInteractionTimeout");
576 ASSERT_NE(window_, nullptr);
577 IWindowNoInteractionListenerSptr listener = nullptr;
578 auto ret = window_->NotifyNoInteractionTimeout(listener);
579 ASSERT_EQ(ret, WSError::WS_ERROR_NULLPTR);
580 GTEST_LOG_(INFO) << "WindowSessionImplTest: NotifyNoInteractionTimeout end";
581 }
582
583 /**
584 * @tc.name: IsVerticalOrientation
585 * @tc.desc: IsVerticalOrientation
586 * @tc.type: FUNC
587 */
588 HWTEST_F(WindowSessionImplTest3, IsVerticalOrientation, TestSize.Level1)
589 {
590 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsVerticalOrientation start";
591 window_ = GetTestWindowImpl("IsVerticalOrientation");
592 ASSERT_NE(window_, nullptr);
593 Orientation orientation = Orientation::VERTICAL;
594 auto ret = window_->IsVerticalOrientation(orientation);
595 ASSERT_EQ(ret, true);
596 orientation = Orientation::REVERSE_VERTICAL;
597 ret = window_->IsVerticalOrientation(orientation);
598 ASSERT_EQ(ret, true);
599 orientation = Orientation::SENSOR_VERTICAL;
600 ret = window_->IsVerticalOrientation(orientation);
601 ASSERT_EQ(ret, true);
602 orientation = Orientation::AUTO_ROTATION_PORTRAIT_RESTRICTED;
603 ret = window_->IsVerticalOrientation(orientation);
604 ASSERT_EQ(ret, true);
605 orientation = Orientation::USER_ROTATION_PORTRAIT;
606 ret = window_->IsVerticalOrientation(orientation);
607 ASSERT_EQ(ret, true);
608 orientation = Orientation::USER_ROTATION_PORTRAIT_INVERTED;
609 ret = window_->IsVerticalOrientation(orientation);
610 ASSERT_EQ(ret, true);
611 orientation = Orientation::UNSPECIFIED;
612 ret = window_->IsVerticalOrientation(orientation);
613 ASSERT_EQ(ret, false);
614 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsVerticalOrientation end";
615 }
616
617 /**
618 * @tc.name: IsHorizontalOrientation
619 * @tc.desc: IsHorizontalOrientation
620 * @tc.type: FUNC
621 */
622 HWTEST_F(WindowSessionImplTest3, IsHorizontalOrientation, TestSize.Level1)
623 {
624 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsHorizontalOrientation start";
625 window_ = GetTestWindowImpl("IsHorizontalOrientation");
626 ASSERT_NE(window_, nullptr);
627 Orientation orientation = Orientation::HORIZONTAL;
628 auto ret = window_->IsHorizontalOrientation(orientation);
629 ASSERT_EQ(ret, true);
630 orientation = Orientation::REVERSE_HORIZONTAL;
631 ret = window_->IsHorizontalOrientation(orientation);
632 ASSERT_EQ(ret, true);
633 orientation = Orientation::SENSOR_HORIZONTAL;
634 ret = window_->IsHorizontalOrientation(orientation);
635 ASSERT_EQ(ret, true);
636 orientation = Orientation::AUTO_ROTATION_LANDSCAPE_RESTRICTED;
637 ret = window_->IsHorizontalOrientation(orientation);
638 ASSERT_EQ(ret, true);
639 orientation = Orientation::USER_ROTATION_LANDSCAPE;
640 ret = window_->IsHorizontalOrientation(orientation);
641 ASSERT_EQ(ret, true);
642 orientation = Orientation::USER_ROTATION_LANDSCAPE_INVERTED;
643 ret = window_->IsHorizontalOrientation(orientation);
644 ASSERT_EQ(ret, true);
645 orientation = Orientation::UNSPECIFIED;
646 ret = window_->IsHorizontalOrientation(orientation);
647 ASSERT_EQ(ret, false);
648 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsHorizontalOrientation end";
649 }
650
651 /**
652 * @tc.name: MarkProcessed
653 * @tc.desc: MarkProcessed
654 * @tc.type: FUNC
655 */
656 HWTEST_F(WindowSessionImplTest3, MarkProcessed, TestSize.Level1)
657 {
658 GTEST_LOG_(INFO) << "WindowSessionImplTest: MarkProcessed start";
659 window_ = GetTestWindowImpl("MarkProcessed");
660 ASSERT_NE(window_, nullptr);
661 window_->property_->SetPersistentId(1);
662 window_->state_ = WindowState::STATE_CREATED;
663 auto ret = window_->MarkProcessed(1);
664 ASSERT_EQ(ret, WSError::WS_OK);
665 GTEST_LOG_(INFO) << "WindowSessionImplTest: MarkProcessed end";
666 }
667
668 /**
669 * @tc.name: UpdateRectForOtherReasonTask
670 * @tc.desc: UpdateRectForOtherReasonTask
671 * @tc.type: FUNC
672 */
673 HWTEST_F(WindowSessionImplTest3, UpdateRectForOtherReasonTask, TestSize.Level1)
674 {
675 GTEST_LOG_(INFO) << "WindowSessionImplTest: UpdateRectForOtherReasonTask start";
676 window_ = GetTestWindowImpl("UpdateRectForOtherReasonTask");
677 ASSERT_NE(window_, nullptr);
678 Rect wmRect = { 0, 0, 0, 0 };
679 Rect preRect = { 0, 0, 0, 0 };
680 WindowSizeChangeReason wmReason = WindowSizeChangeReason::UNDEFINED;
681 std::shared_ptr<RSTransaction> rsTransaction = nullptr;
682 window_->lastSizeChangeReason_ = WindowSizeChangeReason::UNDEFINED;
683 window_->postTaskDone_ = false;
684 window_->UpdateRectForOtherReasonTask(wmRect, preRect, wmReason, rsTransaction);
685 ASSERT_EQ(window_->postTaskDone_, true);
686 window_->UpdateRectForOtherReasonTask(wmRect, preRect, wmReason, rsTransaction);
687 window_->postTaskDone_ = false;
688 wmRect.posX_ = 1;
689 window_->UpdateRectForOtherReasonTask(wmRect, preRect, wmReason, rsTransaction);
690 ASSERT_EQ(window_->postTaskDone_, true);
691 WindowType windowType = window_->GetType();
692 window_->postTaskDone_ = true;
693 window_->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT_NAVIGATION);
694 window_->SetNotifySizeChangeFlag(true);
695 window_->UpdateRectForOtherReasonTask(wmRect, preRect, wmReason, rsTransaction);
696 ASSERT_EQ(window_->postTaskDone_, true);
697 window_->property_->SetWindowType(windowType);
698 window_->handler_ = nullptr;
699 window_->UpdateRectForOtherReason(wmRect, preRect, wmReason, rsTransaction);
700 GTEST_LOG_(INFO) << "WindowSessionImplTest: UpdateRectForOtherReasonTask end";
701 }
702
703 /**
704 * @tc.name: CopyUniqueDensityParameter
705 * @tc.desc: CopyUniqueDensityParameter
706 * @tc.type: FUNC
707 */
708 HWTEST_F(WindowSessionImplTest3, CopyUniqueDensityParameter, TestSize.Level1)
709 {
710 GTEST_LOG_(INFO) << "WindowSessionImplTest: CopyUniqueDensityParameter start";
711 window_ = GetTestWindowImpl("CopyUniqueDensityParameter");
712 ASSERT_NE(window_, nullptr);
713 sptr<WindowSessionImpl> parentWindow = GetTestWindowImpl("CopyUniqueDensityParameter01");
714 ASSERT_NE(parentWindow, nullptr);
715 window_->useUniqueDensity_ = false;
716 window_->virtualPixelRatio_ = 1.0f;
717 parentWindow->useUniqueDensity_ = true;
718 parentWindow->virtualPixelRatio_ = 1.0f;
719 window_->CopyUniqueDensityParameter(parentWindow);
720 ASSERT_EQ(window_->useUniqueDensity_, true);
721 parentWindow = nullptr;
722 window_->CopyUniqueDensityParameter(parentWindow);
723 GTEST_LOG_(INFO) << "WindowSessionImplTest: CopyUniqueDensityParameter end";
724 }
725
726 /**
727 * @tc.name: RaiseToAppTopOnDrag
728 * @tc.desc: RaiseToAppTopOnDrag
729 * @tc.type: FUNC
730 */
731 HWTEST_F(WindowSessionImplTest3, RaiseToAppTopOnDrag, TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "WindowSessionImplTest: RaiseToAppTopOnDrag start";
734 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
735 option->SetWindowName("RaiseToAppTop");
736 sptr<WindowSessionImpl> windowSessionImpl = sptr<WindowSessionImpl>::MakeSptr(option);
737 windowSessionImpl->property_->SetPersistentId(1);
738 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_FLOAT);
739 auto ret = windowSessionImpl->RaiseToAppTopOnDrag();
740 EXPECT_EQ(WMError::WM_ERROR_INVALID_WINDOW, ret);
741
742 SessionInfo sessionInfo = { "CreateTestBundle0", "CreateTestModule0", "CreateTestAbility0" };
743 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
744 windowSessionImpl->hostSession_ = session;
745 ret = windowSessionImpl->RaiseToAppTopOnDrag();
746 EXPECT_EQ(WMError::WM_ERROR_INVALID_CALLING, ret);
747
748 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
749 ret = windowSessionImpl->RaiseToAppTopOnDrag();
750 EXPECT_EQ(WMError::WM_OK, ret);
751 windowSessionImpl->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
752 ret = windowSessionImpl->RaiseToAppTopOnDrag();
753 EXPECT_EQ(WMError::WM_OK, ret);
754 GTEST_LOG_(INFO) << "WindowSessionImplTest: RaiseToAppTopOnDrag end";
755 }
756
757 /**
758 * @tc.name: SetRaiseByClickEnabled
759 * @tc.desc: SetRaiseByClickEnabled
760 * @tc.type: FUNC
761 */
762 HWTEST_F(WindowSessionImplTest3, SetRaiseByClickEnabled, TestSize.Level1)
763 {
764 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetRaiseByClickEnabled start";
765 window_ = GetTestWindowImpl("SetRaiseByClickEnabled");
766 ASSERT_NE(window_, nullptr);
767 window_->property_->parentPersistentId_ = 2;
768 window_->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
769 window_->state_ = WindowState::STATE_SHOWN;
770 window_->property_->SetPersistentId(1);
771 auto ret = window_->SetRaiseByClickEnabled(true);
772 ASSERT_EQ(ret, WMError::WM_OK);
773 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetRaiseByClickEnabled end";
774 }
775
776 /**
777 * @tc.name: SetSubWindowModal
778 * @tc.desc: SetSubWindowModal
779 * @tc.type: FUNC
780 */
781 HWTEST_F(WindowSessionImplTest3, SetSubWindowModal, TestSize.Level1)
782 {
783 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetSubWindowModal start";
784 window_ = GetTestWindowImpl("SetSubWindowModal");
785 ASSERT_NE(window_, nullptr);
786 window_->property_->SetPersistentId(1);
787 window_->state_ = WindowState::STATE_CREATED;
788 window_->property_->SetWindowType(WindowType::APP_SUB_WINDOW_BASE);
789 ModalityType modalityType = ModalityType::APPLICATION_MODALITY;
790 window_->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
791 window_->windowSystemConfig_.freeMultiWindowEnable_ = false;
792 window_->windowSystemConfig_.freeMultiWindowSupport_ = false;
793 auto ret = window_->SetSubWindowModal(true, modalityType);
794 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
795
796 window_->vsyncStation_ = nullptr;
797 window_->ClearVsyncStation();
798 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetSubWindowModal end";
799 }
800
801 /**
802 * @tc.name: UpdateFrameLayoutCallbackIfNeeded
803 * @tc.desc: UpdateFrameLayoutCallbackIfNeeded
804 * @tc.type: FUNC
805 */
806 HWTEST_F(WindowSessionImplTest3, UpdateFrameLayoutCallbackIfNeeded, TestSize.Level1)
807 {
808 GTEST_LOG_(INFO) << "WindowSessionImplTest: UpdateFrameLayoutCallbackIfNeeded start";
809 window_ = GetTestWindowImpl("UpdateFrameLayoutCallbackIfNeeded");
810 ASSERT_NE(window_, nullptr);
811 window_->enableFrameLayoutFinishCb_ = false;
812 WindowSizeChangeReason wmReason = WindowSizeChangeReason::FULL_TO_SPLIT;
813 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
814 ASSERT_EQ(window_->enableFrameLayoutFinishCb_, true);
815
816 window_->enableFrameLayoutFinishCb_ = false;
817 wmReason = WindowSizeChangeReason::SPLIT_TO_FULL;
818 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
819 ASSERT_EQ(window_->enableFrameLayoutFinishCb_, true);
820
821 window_->enableFrameLayoutFinishCb_ = false;
822 wmReason = WindowSizeChangeReason::FULL_TO_FLOATING;
823 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
824 ASSERT_EQ(window_->enableFrameLayoutFinishCb_, true);
825
826 window_->enableFrameLayoutFinishCb_ = false;
827 wmReason = WindowSizeChangeReason::FLOATING_TO_FULL;
828 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
829 ASSERT_EQ(window_->enableFrameLayoutFinishCb_, true);
830
831 window_->enableFrameLayoutFinishCb_ = false;
832 wmReason = WindowSizeChangeReason::DRAG_END;
833 window_->windowSystemConfig_.freeMultiWindowEnable_ = true;
834 window_->windowSystemConfig_.freeMultiWindowSupport_ = true;
835 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
836 ASSERT_EQ(window_->enableFrameLayoutFinishCb_, true);
837
838 window_->windowSystemConfig_.freeMultiWindowSupport_ = false;
839 window_->UpdateFrameLayoutCallbackIfNeeded(wmReason);
840 GTEST_LOG_(INFO) << "WindowSessionImplTest: UpdateFrameLayoutCallbackIfNeeded end";
841 }
842
843 /**
844 * @tc.name: SetTargetAPIVersion
845 * @tc.desc: SetTargetAPIVersion
846 * @tc.type: FUNC
847 */
848 HWTEST_F(WindowSessionImplTest3, SetTargetAPIVersion, TestSize.Level1)
849 {
850 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetTargetAPIVersion start";
851 window_ = GetTestWindowImpl("SetAPPWindowIcon");
852 ASSERT_NE(window_, nullptr);
853 uint32_t version = 14;
854 window_->SetTargetAPIVersion(version);
855 EXPECT_EQ(version, window_->GetTargetAPIVersion());
856 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetTargetAPIVersion end";
857 }
858
859 /**
860 * @tc.name: SetAPPWindowIcon
861 * @tc.desc: SetAPPWindowIcon
862 * @tc.type: FUNC
863 */
864 HWTEST_F(WindowSessionImplTest3, GetTargetAPIVersion, TestSize.Level1)
865 {
866 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetTargetAPIVersion start";
867 window_ = GetTestWindowImpl("GetTargetAPIVersion");
868 ASSERT_NE(window_, nullptr);
869 EXPECT_EQ(0, window_->GetTargetAPIVersion());
870 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetTargetAPIVersion end";
871 }
872
873 /**
874 * @tc.name: SetAPPWindowIcon
875 * @tc.desc: SetAPPWindowIcon
876 * @tc.type: FUNC
877 */
878 HWTEST_F(WindowSessionImplTest3, SetAPPWindowIcon, TestSize.Level1)
879 {
880 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetAPPWindowIcon start";
881 window_ = GetTestWindowImpl("SetAPPWindowIcon");
882 ASSERT_NE(window_, nullptr);
883 window_->uiContent_ = nullptr;
884 std::shared_ptr<Media::PixelMap> icon = std::make_shared<Media::PixelMap>();
885 ASSERT_NE(icon, nullptr);
886 auto ret = window_->SetAPPWindowIcon(icon);
887 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
888 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetAPPWindowIcon end";
889 }
890
891 /**
892 * @tc.name: SetBackgroundColor
893 * @tc.desc: SetBackgroundColor
894 * @tc.type: FUNC
895 */
896 HWTEST_F(WindowSessionImplTest3, SetBackgroundColor, TestSize.Level1)
897 {
898 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetBackgroundColor start";
899 window_ = GetTestWindowImpl("SetBackgroundColor");
900 ASSERT_NE(window_, nullptr);
901 window_->property_->SetPersistentId(1);
902 window_->state_ = WindowState::STATE_CREATED;
903 std::string color = "";
904 auto ret = window_->SetBackgroundColor(color);
905 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PARAM);
906
907 color = "#FF0000";
908 ret = window_->SetBackgroundColor(color);
909 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_OPERATION);
910 GTEST_LOG_(INFO) << "WindowSessionImplTest: SetBackgroundColor end";
911 }
912
913 /**
914 * @tc.name: Find
915 * @tc.desc: Find
916 * @tc.type: FUNC
917 */
918 HWTEST_F(WindowSessionImplTest3, Find, TestSize.Level1)
919 {
920 GTEST_LOG_(INFO) << "WindowSessionImplTest: Find start";
921 window_ = GetTestWindowImpl("Find");
922 ASSERT_NE(window_, nullptr);
923 window_->windowSessionMap_.clear();
924 std::string name = "Find";
925 sptr<WindowSessionImpl> window1 = GetTestWindowImpl("Find1");
926 ASSERT_NE(window1, nullptr);
927 window_->windowSessionMap_.insert(std::make_pair(name, std::make_pair(1, window1)));
928 auto ret = window_->Find(name);
929 ASSERT_NE(ret, nullptr);
930 GTEST_LOG_(INFO) << "WindowSessionImplTest: Find end";
931 }
932
933 /**
934 * @tc.name: RegisterWindowTitleButtonRectChangeListener
935 * @tc.desc: RegisterWindowTitleButtonRectChangeListener
936 * @tc.type: FUNC
937 */
938 HWTEST_F(WindowSessionImplTest3, RegisterWindowTitleButtonRectChangeListener, TestSize.Level1)
939 {
940 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterWindowTitleButtonRectChangeListener start";
941 window_ = GetTestWindowImpl("RegisterWindowTitleButtonRectChangeListener");
942 ASSERT_NE(window_, nullptr);
943 window_->property_->SetPersistentId(1);
944 window_->state_ = WindowState::STATE_SHOWN;
945 window_->interactive_ = true;
946 window_->hasFirstNotifyInteractive_ = true;
947 window_->NotifyForegroundInteractiveStatus(true);
948
949 sptr<IWindowTitleButtonRectChangedListener> listener = nullptr;
950 auto ret = window_->RegisterWindowTitleButtonRectChangeListener(listener);
951 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
952 GTEST_LOG_(INFO) << "WindowSessionImplTest: RegisterWindowTitleButtonRectChangeListener end";
953 }
954
955 /**
956 * @tc.name: GetUIContentWithId
957 * @tc.desc: GetUIContentWithId
958 * @tc.type: FUNC
959 */
960 HWTEST_F(WindowSessionImplTest3, GetUIContentWithId, TestSize.Level1)
961 {
962 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetUIContentWithId start";
963 window_ = GetTestWindowImpl("GetUIContentWithId");
964 ASSERT_NE(window_, nullptr);
965 window_->windowSessionMap_.clear();
966 std::string name = "GetUIContentWithId";
967 sptr<WindowSessionImpl> window1 = GetTestWindowImpl("GetUIContentWithId1");
968 ASSERT_NE(window1, nullptr);
969 window_->windowSessionMap_.insert(std::make_pair(name, std::make_pair(1, window1)));
970 auto ret = window_->GetUIContentWithId(1);
971 ASSERT_EQ(ret, nullptr);
972 GTEST_LOG_(INFO) << "WindowSessionImplTest: GetUIContentWithId end";
973 }
974
975 /**
976 * @tc.name: UnregisterWindowRectChangeListener
977 * @tc.desc: UnregisterWindowRectChangeListener
978 * @tc.type: FUNC
979 */
980 HWTEST_F(WindowSessionImplTest3, UnregisterWindowRectChangeListener, TestSize.Level1)
981 {
982 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterWindowRectChangeListener start";
983 window_ = GetTestWindowImpl("UnregisterWindowRectChangeListener");
984 ASSERT_NE(window_, nullptr);
985 window_->property_->SetPersistentId(1);
986 window_->state_ = WindowState::STATE_SHOWN;
987 window_->windowRectChangeListeners_.clear();
988 sptr<IWindowRectChangeListener> listener = nullptr;
989 auto ret = window_->UnregisterWindowRectChangeListener(listener);
990 ASSERT_EQ(ret, WMError::WM_ERROR_NULLPTR);
991 GTEST_LOG_(INFO) << "WindowSessionImplTest: UnregisterWindowRectChangeListener end";
992 }
993
994 /**
995 * @tc.name: IsFloatingWindowAppType
996 * @tc.desc: IsFloatingWindowAppType
997 * @tc.type: FUNC
998 */
999 HWTEST_F(WindowSessionImplTest3, IsFloatingWindowAppType, TestSize.Level1)
1000 {
1001 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsFloatingWindowAppType start";
1002 window_ = GetTestWindowImpl("IsFloatingWindowAppType");
1003 ASSERT_NE(window_, nullptr);
1004 window_->property_->SetPersistentId(1);
1005 window_->property_->isFloatingWindowAppType_ = true;
1006 window_->state_ = WindowState::STATE_CREATED;
1007 auto ret = window_->IsFloatingWindowAppType();
1008 ASSERT_EQ(ret, true);
1009 GTEST_LOG_(INFO) << "WindowSessionImplTest: IsFloatingWindowAppType end";
1010 }
1011
1012 /**
1013 * @tc.name: IsAdaptToCompatibleImmersive
1014 * @tc.desc: IsAdaptToCompatibleImmersive
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(WindowSessionImplTest3, IsAdaptToCompatibleImmersive, TestSize.Level1)
1018 {
1019 GTEST_LOG_(INFO) << "WindowSessionImplTest3: IsAdaptToCompatibleImmersive start";
1020 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1021 option->SetWindowName("IsAdaptToCompatibleImmersive");
1022 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1023 sptr<CompatibleModeProperty> compatibleModeProperty = sptr<CompatibleModeProperty>::MakeSptr();
1024 compatibleModeProperty->SetIsAdaptToImmersive(true);
1025 window->property_->SetCompatibleModeProperty(compatibleModeProperty);
1026 EXPECT_EQ(true, window->IsAdaptToCompatibleImmersive());
1027 GTEST_LOG_(INFO) << "WindowSessionImplTest3: IsAdaptToCompatibleImmersive end";
1028 }
1029
1030 /**
1031 * @tc.name: SetAvoidAreaOption
1032 * @tc.desc: SetAvoidAreaOption
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(WindowSessionImplTest3, SetAvoidAreaOption, TestSize.Level1)
1036 {
1037 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1038 option->SetWindowName("SetAvoidAreaOption");
1039 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1040 window->property_->SetPersistentId(1);
1041 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1042 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1043
1044 window->hostSession_ = session;
1045 window->state_ = WindowState::STATE_CREATED;
1046 WMError res = window->SetAvoidAreaOption(3);
1047 ASSERT_EQ(res, WMError::WM_OK);
1048 }
1049
1050 /**
1051 * @tc.name: GetAvoidAreaOption
1052 * @tc.desc: GetAvoidAreaOption
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(WindowSessionImplTest3, GetAvoidAreaOption, TestSize.Level1)
1056 {
1057 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1058 option->SetWindowName("GetAvoidAreaOption");
1059 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1060 window->property_->SetPersistentId(1);
1061 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1062 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1063
1064 window->hostSession_ = session;
1065 window->state_ = WindowState::STATE_CREATED;
1066 uint32_t avoidAreaOption = 0;
1067 WMError res = window->GetAvoidAreaOption(avoidAreaOption);
1068 ASSERT_EQ(res, WMError::WM_OK);
1069 }
1070
1071 /**
1072 * @tc.name: SetWatchGestureConsumed
1073 * @tc.desc: SetWatchGestureConsumed test
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(WindowSessionImplTest3, SetWatchGestureConsumed, TestSize.Level1)
1077 {
1078 window_ = GetTestWindowImpl("SetWatchGestureConsumed");
1079 ASSERT_NE(window_, nullptr);
1080 bool isWatchGestureConsumed = false;
1081 window_->SetWatchGestureConsumed(isWatchGestureConsumed);
1082 ASSERT_EQ(window_->GetWatchGestureConsumed(), false);
1083 }
1084
1085 /**
1086 * @tc.name: NotifyConsumeResultToFloatWindow
1087 * @tc.desc: NotifyConsumeResultToFloatWindow test
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(WindowSessionImplTest3, NotifyConsumeResultToFloatWindow, TestSize.Level1)
1091 {
1092 window_ = GetTestWindowImpl("NotifyConsumeResultToFloatWindow");
1093 ASSERT_NE(window_, nullptr);
1094 std::shared_ptr<MMI::KeyEvent> keyEvent = MMI::KeyEvent::Create();
1095 keyEvent->SetKeyCode(MMI::KeyEvent::KEYCODE_TAB);
1096 keyEvent->SetKeyAction(MMI::KeyEvent::KEY_ACTION_DOWN);
1097 window_->SetWatchGestureConsumed(false);
1098 bool isConsumed = false;
1099 window_->NotifyConsumeResultToFloatWindow(keyEvent, isConsumed);
1100 ASSERT_EQ(window_->GetWatchGestureConsumed(), false);
1101 }
1102
1103 /**
1104 * @tc.name: IsSystemWindow
1105 * @tc.desc: IsSystemWindow
1106 * @tc.type: FUNC
1107 */
1108 HWTEST_F(WindowSessionImplTest3, IsSystemWindow, TestSize.Level1)
1109 {
1110 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1111 option->SetWindowName("IsSystemWindow");
1112 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1113 window->property_->SetPersistentId(1);
1114 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1115 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1116
1117 window->hostSession_ = session;
1118 window->state_ = WindowState::STATE_CREATED;
1119 window->property_->SetWindowType(WindowType::WINDOW_TYPE_SYSTEM_FLOAT);
1120 bool res = window->IsSystemWindow();
1121 ASSERT_EQ(res, true);
1122 }
1123
1124 /**
1125 * @tc.name: IsAppWindow
1126 * @tc.desc: IsAppWindow
1127 * @tc.type: FUNC
1128 */
1129 HWTEST_F(WindowSessionImplTest3, IsAppWindow, TestSize.Level1)
1130 {
1131 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1132 option->SetWindowName("IsAppWindow");
1133 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1134 window->property_->SetPersistentId(1);
1135 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1136 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1137
1138 window->hostSession_ = session;
1139 window->state_ = WindowState::STATE_CREATED;
1140 window->property_->SetWindowType(WindowType::APP_WINDOW_BASE);
1141 bool res = window->IsAppWindow();
1142 ASSERT_EQ(res, true);
1143 }
1144
1145 /**
1146 * @tc.name: SetMouseEventFilter
1147 * @tc.desc: SetMouseEventFilter
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(WindowSessionImplTest3, SetMouseEventFilter, TestSize.Level1)
1151 {
1152 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1153 option->SetWindowName("SetMouseEventFilter");
1154 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1155 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1156 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1157 ASSERT_EQ(WMError::WM_OK, window->Create(nullptr, session));
1158 window->hostSession_ = session;
1159 window->property_->SetPersistentId(1);
__anon2dcde3f90302(const OHOS::MMI::PointerEvent& event) 1160 WMError res = window->SetMouseEventFilter([](const OHOS::MMI::PointerEvent& event) {
1161 return true;
1162 });
1163 ASSERT_EQ(res, WMError::WM_OK);
1164 }
1165
1166 /**
1167 * @tc.name: ClearMouseEventFilter
1168 * @tc.desc: ClearMouseEventFilter
1169 * @tc.type: FUNC
1170 */
1171 HWTEST_F(WindowSessionImplTest3, ClearMouseEventFilter, TestSize.Level1)
1172 {
1173 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1174 option->SetWindowName("ClearMouseEventFilter");
1175 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1176 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1177 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1178 ASSERT_EQ(WMError::WM_OK, window->Create(nullptr, session));
1179 window->hostSession_ = session;
1180 window->property_->SetPersistentId(1);
1181 WMError res = window->ClearMouseEventFilter();
1182 ASSERT_EQ(res, WMError::WM_OK);
1183 }
1184
1185 /**
1186 * @tc.name: SetTouchEventFilter
1187 * @tc.desc: SetTouchEventFilter
1188 * @tc.type: FUNC
1189 */
1190 HWTEST_F(WindowSessionImplTest3, SetTouchEventFilter, TestSize.Level1)
1191 {
1192 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1193 option->SetWindowName("SetTouchEventFilter");
1194 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1195 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1196 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1197 ASSERT_EQ(WMError::WM_OK, window->Create(nullptr, session));
1198 window->hostSession_ = session;
1199 window->property_->SetPersistentId(1);
__anon2dcde3f90402(const OHOS::MMI::PointerEvent& event) 1200 WMError res = window->SetTouchEventFilter([](const OHOS::MMI::PointerEvent& event) {
1201 return true;
1202 });
1203 ASSERT_EQ(res, WMError::WM_OK);
1204 }
1205
1206 /**
1207 * @tc.name: ClearTouchEventFilter
1208 * @tc.desc: ClearTouchEventFilter
1209 * @tc.type: FUNC
1210 */
1211 HWTEST_F(WindowSessionImplTest3, ClearTouchEventFilter, TestSize.Level1)
1212 {
1213 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1214 option->SetWindowName("ClearTouchEventFilter");
1215 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1216 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1217 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1218 ASSERT_EQ(WMError::WM_OK, window->Create(nullptr, session));
1219 window->hostSession_ = session;
1220 window->property_->SetPersistentId(1);
1221 WMError res = window->ClearTouchEventFilter();
1222 ASSERT_EQ(res, WMError::WM_OK);
1223 }
1224
1225 /**
1226 * @tc.name: FilterPointerEvent
1227 * @tc.desc: FilterPointerEvent
1228 * @tc.type: FUNC
1229 */
1230 HWTEST_F(WindowSessionImplTest3, FilterPointerEvent, TestSize.Level1)
1231 {
1232 logMsg.clear();
1233 LOG_SetCallback(MyLogCallback);
1234 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1235 option->SetWindowName("FilterPointerEvent");
1236 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1237
1238 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1239 pointerEvent->SetSourceType(OHOS::MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1240 pointerEvent->SetPointerAction(OHOS::MMI::PointerEvent::POINTER_ACTION_MOVE);
1241 window->touchEventFilter_ = nullptr;
1242 auto ret = window->FilterPointerEvent(pointerEvent);
1243 ASSERT_EQ(false, ret);
1244
__anon2dcde3f90502(const OHOS::MMI::PointerEvent& event) 1245 window->SetTouchEventFilter([](const OHOS::MMI::PointerEvent& event) {
1246 return true;
1247 });
1248 ret = window->FilterPointerEvent(pointerEvent);
1249 ASSERT_EQ(true, ret);
1250
1251 pointerEvent->SetPointerAction(OHOS::MMI::PointerEvent::POINTER_ACTION_MOVE);
1252 EXPECT_TRUE(logMsg.find("id") != std::string::npos);
1253 logMsg.clear();
1254 LOG_SetCallback(nullptr);
1255 }
1256
1257 /**
1258 * @tc.name: FilterPointerEvent01
1259 * @tc.desc: FilterPointerEvent
1260 * @tc.type: FUNC
1261 */
1262 HWTEST_F(WindowSessionImplTest3, FilterPointerEvent01, TestSize.Level1)
1263 {
1264 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1265 option->SetWindowName("FilterPointerEvent01");
1266 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1267
1268 std::shared_ptr<MMI::PointerEvent> pointerEvent = MMI::PointerEvent::Create();
1269 pointerEvent->SetSourceType(OHOS::MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1270 pointerEvent->SetPointerAction(OHOS::MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
1271 window->mouseEventFilter_ = nullptr;
1272 auto ret = window->FilterPointerEvent(pointerEvent);
1273 ASSERT_EQ(false, ret);
1274
__anon2dcde3f90602(const OHOS::MMI::PointerEvent& event) 1275 window->SetMouseEventFilter([](const OHOS::MMI::PointerEvent& event) {
1276 return true;
1277 });
1278 ret = window->FilterPointerEvent(pointerEvent);
1279 ASSERT_EQ(true, ret);
1280 }
1281
1282 /**
1283 * @tc.name: NotifyPointerEvent
1284 * @tc.desc: NotifyPointerEvent
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(WindowSessionImplTest3, NotifyPointerEvent, TestSize.Level1)
1288 {
1289 logMsg.clear();
1290 LOG_SetCallback(MyLogCallback);
1291 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1292 option->SetWindowName("NotifyPointerEvent");
1293 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1294 std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
1295 window->NotifyPointerEvent(pointerEvent);
1296
1297 pointerEvent = MMI::PointerEvent::Create();
1298
1299 window->inputEventConsumer_ = nullptr;
1300 window->NotifyPointerEvent(pointerEvent);
1301
1302 window->state_ = WindowState::STATE_CREATED;
1303 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
1304 SessionInfo info;
1305 window->hostSession_ = sptr<SessionMocker>::MakeSptr(info);
1306 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1307 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1308 window->SetWindowDelayRaiseEnabled(true);
1309 ASSERT_EQ(true, window->IsWindowDelayRaiseEnabled());
1310 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1311 window->NotifyPointerEvent(pointerEvent);
1312 EXPECT_TRUE(logMsg.find("Delay,id") == std::string::npos);
1313 logMsg.clear();
1314
1315 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_BUTTON_UP);
1316 window->NotifyPointerEvent(pointerEvent);
1317 EXPECT_TRUE(logMsg.find("Delay,id") != std::string::npos);
1318 logMsg.clear();
1319
1320 window->SetWindowDelayRaiseEnabled(false);
1321 window->NotifyPointerEvent(pointerEvent);
1322 EXPECT_TRUE(logMsg.find("UI content does not consume") != std::string::npos);
1323 logMsg.clear();
1324
1325 window->inputEventConsumer_ = std::make_shared<MockInputEventConsumer>();
1326 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UNKNOWN);
1327 ASSERT_EQ(pointerEvent->GetPointerAction(), MMI::PointerEvent::POINTER_ACTION_UNKNOWN);
1328 window->NotifyPointerEvent(pointerEvent);
1329
1330 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1331 window->NotifyPointerEvent(pointerEvent);
1332 }
1333
1334 /**
1335 * @tc.name: InjectTouchEvent
1336 * @tc.desc: InjectTouchEvent
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(WindowSessionImplTest3, InjectTouchEvent, TestSize.Level1)
1340 {
1341 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1342 option->SetWindowName("InjectTouchEvent");
1343 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1344 std::shared_ptr<MMI::PointerEvent> pointerEvent = nullptr;
1345 auto ret = window->InjectTouchEvent(pointerEvent);
1346 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_PARAM);
1347
1348 pointerEvent = MMI::PointerEvent::Create();
1349 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1350 window->uiContent_ = nullptr;
1351 ret = window->InjectTouchEvent(pointerEvent);
1352 ASSERT_EQ(ret, WMError::WM_ERROR_SYSTEM_ABNORMALLY);
1353
1354 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UNKNOWN);
1355 ret = window->InjectTouchEvent(pointerEvent);
1356 ASSERT_EQ(ret, WMError::WM_ERROR_SYSTEM_ABNORMALLY);
1357
1358 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1359 ret = window->InjectTouchEvent(pointerEvent);
1360 ASSERT_EQ(ret, WMError::WM_OK);
1361
1362 pointerEvent->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1363 ret = window->InjectTouchEvent(pointerEvent);
1364 ASSERT_EQ(ret, WMError::WM_OK);
1365 }
1366
1367 /**
1368 * @tc.name: SetAvoidAreaOption01
1369 * @tc.desc: SetAvoidAreaOption
1370 * @tc.type: FUNC
1371 */
1372 HWTEST_F(WindowSessionImplTest3, SetAvoidAreaOption01, TestSize.Level1)
1373 {
1374 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1375 option->SetWindowName("SetAvoidAreaOption01");
1376 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1377
1378 window->state_ = WindowState::STATE_DESTROYED;
1379 auto ret = window->SetAvoidAreaOption(0);
1380 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1381 }
1382
1383 /**
1384 * @tc.name: GetAvoidAreaOption01
1385 * @tc.desc: GetAvoidAreaOption
1386 * @tc.type: FUNC
1387 */
1388 HWTEST_F(WindowSessionImplTest3, GetAvoidAreaOption01, TestSize.Level1)
1389 {
1390 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1391 option->SetWindowName("GetAvoidAreaOption01");
1392 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1393
1394 window->state_ = WindowState::STATE_DESTROYED;
1395 uint32_t avoidAreaOption = 1;
1396 auto ret = window->SetAvoidAreaOption(avoidAreaOption);
1397 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1398 }
1399
1400 /**
1401 * @tc.name: SetWindowDelayRaiseEnabled
1402 * @tc.desc: SetWindowDelayRaiseEnabled
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(WindowSessionImplTest3, SetWindowDelayRaiseEnabled, TestSize.Level1)
1406 {
1407 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1408 option->SetWindowName("SetWindowDelayRaiseEnabled");
1409 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1410
1411 window->state_ = WindowState::STATE_DESTROYED;
1412 auto ret = window->SetWindowDelayRaiseEnabled(true);
1413 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1414
1415 window->state_ = WindowState::STATE_CREATED;
1416 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
1417 SessionInfo info;
1418 window->hostSession_ = sptr<SessionMocker>::MakeSptr(info);
1419 window->windowSystemConfig_.windowUIType_ = WindowUIType::PHONE_WINDOW;
1420 window->windowSystemConfig_.freeMultiWindowSupport_ = true;
1421 ret = window->SetWindowDelayRaiseEnabled(true);
1422 ASSERT_EQ(ret, WMError::WM_ERROR_DEVICE_NOT_SUPPORT);
1423
1424 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1425 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1426 ret = window->SetWindowDelayRaiseEnabled(true);
1427 ASSERT_EQ(ret, WMError::WM_OK);
1428
1429 window->windowSystemConfig_.windowUIType_ = WindowUIType::PAD_WINDOW;
1430 window->property_->SetPcAppInpadCompatibleMode(true);
1431 window->windowSystemConfig_.freeMultiWindowEnable_ = false;
1432 window->uiContent_ = std::make_unique<Ace::UIContentMocker>();
1433 ret = window->SetWindowDelayRaiseEnabled(true);
1434 EXPECT_EQ(WMError::WM_OK, ret);
1435 }
1436
1437 /**
1438 * @tc.name: NotifyWatchFocusActiveChange
1439 * @tc.desc: NotifyWatchFocusActiveChange
1440 * @tc.type: FUNC
1441 */
1442 HWTEST_F(WindowSessionImplTest3, NotifyWatchFocusActiveChange, TestSize.Level1)
1443 {
1444 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1445 option->SetWindowName("NotifyWatchFocusActiveChange");
1446 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1447
1448 window->state_ = WindowState::STATE_DESTROYED;
1449 auto ret = window->NotifyWatchFocusActiveChange(true);
1450 ASSERT_EQ(ret, WMError::WM_ERROR_INVALID_WINDOW);
1451
1452 window->state_ = WindowState::STATE_CREATED;
1453 SessionInfo info;
1454 window->hostSession_ = sptr<SessionMocker>::MakeSptr(info);
1455 window->property_->persistentId_ = ROTATE_ANIMATION_DURATION;
1456 ret = window->SetWindowDelayRaiseEnabled(true);
1457 }
1458
1459 /**
1460 * @tc.name: UpdateSubWindowInfo
1461 * @tc.desc: UpdateSubWindowInfo
1462 * @tc.type: FUNC
1463 */
1464 HWTEST_F(WindowSessionImplTest3, UpdateSubWindowInfo, TestSize.Level1)
1465 {
1466 sptr<WindowOption> option = sptr<WindowOption>::MakeSptr();
1467 option->SetWindowName("UpdateSubWindowInfo");
1468 sptr<WindowSessionImpl> window = sptr<WindowSessionImpl>::MakeSptr(option);
1469 SessionInfo sessionInfo = { "CreateTestBundle", "CreateTestModule", "CreateTestAbility" };
1470 sptr<SessionMocker> session = sptr<SessionMocker>::MakeSptr(sessionInfo);
1471 window->hostSession_ = session;
1472 window->property_->SetPersistentId(1);
1473 window->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1474
1475 sptr<WindowOption> subWindowOption = sptr<WindowOption>::MakeSptr();
1476 subWindowOption->SetWindowName("UpdateSubWindowInfo_subWindow");
1477 sptr<WindowSessionImpl> subWindow = sptr<WindowSessionImpl>::MakeSptr(subWindowOption);
1478 subWindow->property_->SetPersistentId(2);
1479 subWindow->property_->SetParentPersistentId(1);
1480 subWindow->hostSession_ = session;
1481 subWindow->windowSystemConfig_.windowUIType_ = WindowUIType::PC_WINDOW;
1482 subWindow->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
1483 subWindow->context_ = std::make_shared<AbilityRuntime::AbilityContextImpl>();
1484 WindowSessionImpl::subWindowSessionMap_.insert(std::pair<int32_t,
1485 std::vector<sptr<WindowSessionImpl>>>(1, { subWindow }));
1486
1487 EXPECT_NE(subWindow->context_, nullptr);
1488 EXPECT_EQ(subWindow->property_->GetSubWindowLevel(), 0);
1489 int subWindowLevel = 5;
1490 window->UpdateSubWindowInfo(subWindowLevel, nullptr);
1491 EXPECT_EQ(subWindow->property_->GetSubWindowLevel(), 6);
1492 EXPECT_EQ(subWindow->context_, nullptr);
1493 EXPECT_EQ(WMError::WM_OK, subWindow->Destroy(true));
1494 EXPECT_EQ(WMError::WM_OK, window->Destroy(true));
1495 }
1496 } // namespace
1497 } // namespace Rosen
1498 } // namespace OHOS