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
18 #include "interfaces/include/ws_common.h"
19 #include "iremote_object_mocker.h"
20 #include "mock/mock_session_stage.h"
21 #include "mock/mock_window_event_channel.h"
22 #include "session_info.h"
23 #include "session_manager.h"
24 #include "session_manager/include/scene_session_manager.h"
25 #include "session/host/include/scene_session.h"
26 #include "session/host/include/main_session.h"
27 #include "window_manager_agent.h"
28 #include "zidl/window_manager_agent_interface.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35
36 class SessionSpecificWindowTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp() override;
41 void TearDown() override;
42 sptr<SceneSessionManager> ssm_;
43
44 private:
45 sptr<Session> session_ = nullptr;
46 static constexpr uint32_t WAIT_SYNC_IN_NS = 500000;
47
48 sptr<SessionStageMocker> mockSessionStage_ = nullptr;
49 sptr<WindowEventChannelMocker> mockEventChannel_ = nullptr;
50 };
51
SetUpTestCase()52 void SessionSpecificWindowTest::SetUpTestCase() {}
53
TearDownTestCase()54 void SessionSpecificWindowTest::TearDownTestCase() {}
55
SetUp()56 void SessionSpecificWindowTest::SetUp()
57 {
58 SessionInfo info;
59 info.abilityName_ = "testSession1";
60 info.moduleName_ = "testSession2";
61 info.bundleName_ = "testSession3";
62 session_ = sptr<Session>::MakeSptr(info);
63 ssm_ = sptr<SceneSessionManager>::MakeSptr();
64
65 mockSessionStage_ = sptr<SessionStageMocker>::MakeSptr();
66 ASSERT_NE(mockSessionStage_, nullptr);
67
68 mockEventChannel_ = sptr<WindowEventChannelMocker>::MakeSptr(mockSessionStage_);
69 ASSERT_NE(mockEventChannel_, nullptr);
70 }
71
TearDown()72 void SessionSpecificWindowTest::TearDown()
73 {
74 session_ = nullptr;
75 usleep(WAIT_SYNC_IN_NS);
76 }
77
78 namespace {
79 /**
80 * @tc.name: BindDialogSessionTarget
81 * @tc.desc: normal function
82 * @tc.type: FUNC
83 */
84 HWTEST_F(SessionSpecificWindowTest, BindDialogSessionTarget, TestSize.Level1)
85 {
86 SessionInfo info;
87 info.abilityName_ = "BindDialogSessionTarget";
88 info.bundleName_ = "BindDialogSessionTarget";
89 sptr<Rosen::ISession> session_;
90 sptr<SceneSession::SpecificSessionCallback> specificCallback_ =
91 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
92 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
93 sceneSession->isActive_ = true;
94
95 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
96 property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
97 property->keyboardLayoutParams_.gravity_ = WindowGravity::WINDOW_GRAVITY_BOTTOM;
98 sceneSession->SetSessionProperty(property);
99
100 sptr<SceneSession> sceneSession1 = nullptr;
101 WSError result = sceneSession->BindDialogSessionTarget(sceneSession1);
102 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
103
104 sptr<SceneSession> sceneSession2 = sceneSession;
105 result = sceneSession->BindDialogSessionTarget(sceneSession2);
106 ASSERT_EQ(result, WSError::WS_OK);
107 }
108
109 /**
110 * @tc.name: AddSubSession
111 * @tc.desc: AddSubSession Test
112 * @tc.type: FUNC
113 */
114 HWTEST_F(SessionSpecificWindowTest, AddSubSession, TestSize.Level1)
115 {
116 SessionInfo info;
117 info.abilityName_ = "NotifySessionException";
118 info.bundleName_ = "NotifySessionException";
119
120 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
121 sptr<SceneSession> subSession = nullptr;
122 bool res = session->AddSubSession(subSession);
123 ASSERT_EQ(res, false);
124
125 subSession = sptr<SceneSession>::MakeSptr(info, nullptr);
126 res = session->AddSubSession(subSession);
127 ASSERT_EQ(res, true);
128
129 res = session->AddSubSession(subSession);
130 ASSERT_EQ(res, false);
131 }
132
133 /**
134 * @tc.name: RemoveSubSession
135 * @tc.desc: RemoveSubSession Test
136 * @tc.type: FUNC
137 */
138 HWTEST_F(SessionSpecificWindowTest, RemoveSubSession, TestSize.Level1)
139 {
140 SessionInfo info;
141 info.abilityName_ = "NotifySessionException";
142 info.bundleName_ = "NotifySessionException";
143
144 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
145 bool res = session->RemoveSubSession(0);
146 ASSERT_EQ(res, false);
147
148 sptr<SceneSession> subSession = sptr<SceneSession>::MakeSptr(info, nullptr);
149 res = session->AddSubSession(subSession);
150 ASSERT_EQ(res, true);
151
152 res = session->RemoveSubSession(subSession->GetPersistentId());
153 ASSERT_EQ(res, true);
154 }
155
156 /**
157 * @tc.name: ClearSpecificSessionCbMap
158 * @tc.desc: ClearSpecificSessionCbMap
159 * @tc.type: FUNC
160 */
161 HWTEST_F(SessionSpecificWindowTest, ClearSpecificSessionCbMap, TestSize.Level1)
162 {
163 SessionInfo info;
164 info.abilityName_ = "ClearSpecificSessionCbMap";
165 info.bundleName_ = "ClearSpecificSessionCbMap";
166 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
167 auto result = false;
__anonee758edb0202(bool needRemove) 168 sceneSession->clearCallbackMapFunc_ = [&result](bool needRemove) { result = needRemove; };
169 sceneSession->ClearSpecificSessionCbMap();
170 usleep(WAIT_SYNC_IN_NS);
171 ASSERT_EQ(result, true);
172 }
173
174 /**
175 * @tc.name: ClearSpecificSessionCbMap
176 * @tc.desc: ClearSpecificSessionCbMap
177 * @tc.type: FUNC
178 */
179 HWTEST_F(SessionSpecificWindowTest, ClearSpecificSessionCbMap01, TestSize.Level1)
180 {
181 SessionInfo info;
182 info.abilityName_ = "ClearSpecificSessionCbMap01";
183 info.bundleName_ = "ClearSpecificSessionCbMap01";
184 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
185 sptr<Session> session = sptr<Session>::MakeSptr(info);
186 auto result = false;
187 sceneSession->clearCallbackMapFunc_ = nullptr;
188 sceneSession->ClearSpecificSessionCbMap();
189 usleep(WAIT_SYNC_IN_NS);
190 ASSERT_EQ(result, false);
191 ASSERT_NE(sceneSession, nullptr);
192 }
193
194 /**
195 * @tc.name: ClearSpecificSessionCbMap
196 * @tc.desc: ClearSpecificSessionCbMap
197 * @tc.type: FUNC
198 */
199 HWTEST_F(SessionSpecificWindowTest, SpecificCallback01, TestSize.Level1)
200 {
201 SessionInfo info;
202 info.abilityName_ = "ClearSpecificSessionCbMap01";
203 info.bundleName_ = "ClearSpecificSessionCbMap01";
204 info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_FLOAT);
205 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
206
207 bool isFromClient = true;
208 sceneSession->needSnapshot_ = true;
209 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
210 bool result = false;
211 auto specificCallback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
__anonee758edb0302(const sptr<SceneSession>& sceneSession) 212 specificCallback->onHandleSecureSessionShouldHide_ = [&result](const sptr<SceneSession>& sceneSession) {
213 result = sceneSession->needSnapshot_;
214 return WSError::WS_OK;
215 };
216 sceneSession->specificCallback_ = specificCallback;
217 sceneSession->Disconnect(isFromClient);
218 usleep(WAIT_SYNC_IN_NS);
219 ASSERT_EQ(result, false);
220 ASSERT_EQ(SessionState::STATE_DISCONNECT, sceneSession->state_);
221 }
222
223 /**
224 * @tc.name: ClearSpecificSessionCbMap
225 * @tc.desc: ClearSpecificSessionCbMap
226 * @tc.type: FUNC
227 */
228 HWTEST_F(SessionSpecificWindowTest, SpecificCallback02, TestSize.Level1)
229 {
230 SessionInfo info;
231 info.abilityName_ = "ClearSpecificSessionCbMap01";
232 info.bundleName_ = "ClearSpecificSessionCbMap01";
233 info.windowType_ = static_cast<uint32_t>(WindowType::WINDOW_TYPE_FLOAT);
234 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
235
236 bool isFromClient = false;
237 sceneSession->needSnapshot_ = true;
238 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
239 bool result = false;
240 auto specificCallback = sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
__anonee758edb0402(const sptr<SceneSession>& sceneSession) 241 specificCallback->onHandleSecureSessionShouldHide_ = [&result](const sptr<SceneSession>& sceneSession) {
242 result = sceneSession->needSnapshot_;
243 return WSError::WS_OK;
244 };
245 sceneSession->specificCallback_ = specificCallback;
246 sceneSession->Disconnect(isFromClient);
247 usleep(WAIT_SYNC_IN_NS);
248 ASSERT_EQ(result, true);
249 ASSERT_EQ(SessionState::STATE_DISCONNECT, sceneSession->state_);
250 }
251
252 /**
253 * @tc.name: GetKeyboardAvoidArea
254 * @tc.desc: GetKeyboardAvoidArea01
255 * @tc.type: FUNC
256 */
257 HWTEST_F(SessionSpecificWindowTest, GetKeyboardAvoidArea01, TestSize.Level1)
258 {
259 SessionInfo info;
260 info.abilityName_ = "GetKeyboardAvoidArea";
261 info.bundleName_ = "GetKeyboardAvoidArea";
262
263 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
264 WSRect rect{ 100, 100, 100, 100 };
265 AvoidArea avoidArea;
266 GTEST_LOG_(INFO) << "1";
267 sceneSession->GetKeyboardAvoidArea(rect, avoidArea);
268 Rect result{ 0, 0, 0, 0 };
269 ASSERT_EQ(avoidArea.topRect_, result);
270 }
271
272 /**
273 * @tc.name: IsSystemSpecificSession
274 * @tc.desc: IsSystemSpecificSession
275 * @tc.type: FUNC
276 */
277 HWTEST_F(SessionSpecificWindowTest, IsSystemSpecificSession, TestSize.Level1)
278 {
279 SessionInfo info;
280 info.abilityName_ = "IsSystemSpecificSession";
281 info.bundleName_ = "IsSystemSpecificSession";
282
283 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
284 ASSERT_FALSE(sceneSession->IsSystemSpecificSession());
285 sceneSession->SetIsSystemSpecificSession(true);
286 ASSERT_TRUE(sceneSession->IsSystemSpecificSession());
287 }
288
289 /**
290 * @tc.name: SetAndIsSystemKeyboard
291 * @tc.desc: test SetIsSystemKeyboard and IsSystemKeyboard func
292 * @tc.type: FUNC
293 */
294 HWTEST_F(SessionSpecificWindowTest, SetAndIsSystemKeyboard, TestSize.Level1)
295 {
296 SessionInfo info;
297 info.abilityName_ = "SetAndIsSystemKeyboard";
298 info.bundleName_ = "SetAndIsSystemKeyboard";
299 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
300
301 ASSERT_EQ(false, session->IsSystemKeyboard());
302 session->SetIsSystemKeyboard(true);
303 ASSERT_EQ(true, session->IsSystemKeyboard());
304 }
305
306 /**
307 * @tc.name: CheckDialogOnForeground
308 * @tc.desc: check func CheckDialogOnForeground
309 * @tc.type: FUNC
310 */
311 HWTEST_F(SessionSpecificWindowTest, CheckDialogOnForeground, TestSize.Level1)
312 {
313 ASSERT_NE(session_, nullptr);
314 session_->dialogVec_.clear();
315 ASSERT_EQ(false, session_->CheckDialogOnForeground());
316 SessionInfo info;
317 info.abilityName_ = "dialogAbilityName";
318 info.moduleName_ = "dialogModuleName";
319 info.bundleName_ = "dialogBundleName";
320 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info);
321 dialogSession->state_ = SessionState::STATE_INACTIVE;
322 session_->dialogVec_.push_back(dialogSession);
323 ASSERT_EQ(false, session_->CheckDialogOnForeground());
324 session_->dialogVec_.clear();
325 }
326
327 /**
328 * @tc.name: IsTopDialog
329 * @tc.desc: check func IsTopDialog
330 * @tc.type: FUNC
331 */
332 HWTEST_F(SessionSpecificWindowTest, IsTopDialog, TestSize.Level1)
333 {
334 ASSERT_NE(session_, nullptr);
335 session_->dialogVec_.clear();
336 SessionInfo info;
337 info.abilityName_ = "testSession1";
338 info.moduleName_ = "testSession2";
339 info.bundleName_ = "testSession3";
340
341 sptr<Session> dialogSession1 = sptr<Session>::MakeSptr(info);
342 dialogSession1->persistentId_ = 33;
343 dialogSession1->SetParentSession(session_);
344 dialogSession1->state_ = SessionState::STATE_ACTIVE;
345 session_->dialogVec_.push_back(dialogSession1);
346
347 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info);
348 dialogSession2->persistentId_ = 34;
349 dialogSession2->SetParentSession(session_);
350 dialogSession2->state_ = SessionState::STATE_ACTIVE;
351 session_->dialogVec_.push_back(dialogSession2);
352
353 sptr<Session> dialogSession3 = sptr<Session>::MakeSptr(info);
354 dialogSession3->persistentId_ = 35;
355 dialogSession3->SetParentSession(session_);
356 dialogSession3->state_ = SessionState::STATE_INACTIVE;
357 session_->dialogVec_.push_back(dialogSession3);
358
359 ASSERT_EQ(false, dialogSession3->IsTopDialog());
360 ASSERT_EQ(true, dialogSession2->IsTopDialog());
361 ASSERT_EQ(false, dialogSession1->IsTopDialog());
362 session_->dialogVec_.clear();
363 }
364
365 /**
366 * @tc.name: IsTopDialog02
367 * @tc.desc: IsTopDialog Test
368 * @tc.type: FUNC
369 */
370 HWTEST_F(SessionSpecificWindowTest, IsTopDialog02, TestSize.Level1)
371 {
372 ASSERT_NE(session_, nullptr);
373 session_->SetParentSession(nullptr);
374 EXPECT_EQ(false, session_->IsTopDialog());
375
376 SessionInfo info;
377 info.abilityName_ = "testSession1";
378 info.moduleName_ = "testSession2";
379 info.bundleName_ = "testSession3";
380 sptr<Session> parentSession = sptr<Session>::MakeSptr(info);
381 parentSession->dialogVec_.clear();
382 session_->SetParentSession(parentSession);
383 auto result = session_->IsTopDialog();
384 EXPECT_EQ(result, true);
385 }
386
387 /**
388 * @tc.name: IsTopDialog03
389 * @tc.desc: IsTopDialog Test
390 * @tc.type: FUNC
391 */
392 HWTEST_F(SessionSpecificWindowTest, IsTopDialog03, TestSize.Level1)
393 {
394 ASSERT_NE(session_, nullptr);
395 session_->dialogVec_.clear();
396 SessionInfo info;
397 info.abilityName_ = "testSession1";
398 info.moduleName_ = "testSession2";
399 info.bundleName_ = "testSession3";
400 sptr<Session> dialogSession1 = sptr<Session>::MakeSptr(info);
401 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info);
402 dialogSession1->SetParentSession(session_);
403 dialogSession2->SetParentSession(session_);
404 session_->dialogVec_.push_back(dialogSession1);
405 session_->dialogVec_.push_back(dialogSession2);
406 dialogSession1->SetSessionState(SessionState::STATE_INACTIVE);
407 dialogSession2->SetSessionState(SessionState::STATE_INACTIVE);
408 EXPECT_EQ(false, dialogSession1->IsTopDialog());
409 }
410
411 /**
412 * @tc.name: BindDialogToParentSession
413 * @tc.desc: BindDialogToParentSession Test
414 * @tc.type: FUNC
415 */
416 HWTEST_F(SessionSpecificWindowTest, BindDialogToParentSession, TestSize.Level1)
417 {
418 ASSERT_NE(session_, nullptr);
419 SessionInfo info;
420 info.abilityName_ = "testSession1";
421 info.moduleName_ = "testSession2";
422 info.bundleName_ = "testSession3";
423 sptr<Session> session = sptr<Session>::MakeSptr(info);
424 session_->BindDialogToParentSession(session);
425
426 sptr<Session> session1 = sptr<Session>::MakeSptr(info);
427 session1->persistentId_ = 33;
428 session1->SetParentSession(session_);
429 session1->state_ = SessionState::STATE_ACTIVE;
430 session_->dialogVec_.push_back(session1);
431
432 sptr<Session> session2 = sptr<Session>::MakeSptr(info);
433 session2->persistentId_ = 34;
434 session2->SetParentSession(session_);
435 session2->state_ = SessionState::STATE_ACTIVE;
436 session_->dialogVec_.push_back(session2);
437 session_->BindDialogToParentSession(session1);
438
439 ASSERT_EQ(WSError::WS_OK, session_->SetFocusable(false));
440 }
441
442 /**
443 * @tc.name: HandlePointDownDialog
444 * @tc.desc: HandlePointDownDialog Test
445 * @tc.type: FUNC
446 */
447 HWTEST_F(SessionSpecificWindowTest, HandlePointDownDialog, TestSize.Level1)
448 {
449 ASSERT_NE(session_, nullptr);
450 SessionInfo info;
451 info.abilityName_ = "testSession1";
452 info.moduleName_ = "testSession2";
453 info.bundleName_ = "testSession3";
454 sptr<Session> dialogSession1 = sptr<Session>::MakeSptr(info);
455 sptr<Session> dialogSession2 = sptr<Session>::MakeSptr(info);
456 sptr<Session> dialogSession3 = sptr<Session>::MakeSptr(info);
457 sptr<Session> dialogSession4 = nullptr;
458 dialogSession1->SetSessionState(SessionState::STATE_FOREGROUND);
459 dialogSession2->SetSessionState(SessionState::STATE_ACTIVE);
460 dialogSession2->SetSessionState(SessionState::STATE_INACTIVE);
461 session_->dialogVec_.push_back(dialogSession1);
462 session_->dialogVec_.push_back(dialogSession2);
463 session_->dialogVec_.push_back(dialogSession3);
464 session_->dialogVec_.push_back(dialogSession4);
465 session_->HandlePointDownDialog();
466 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr);
467 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true));
468 }
469
470 /**
471 * @tc.name: RemoveDialogToParentSession
472 * @tc.desc: RemoveDialogToParentSession Test
473 * @tc.type: FUNC
474 */
475 HWTEST_F(SessionSpecificWindowTest, RemoveDialogToParentSession, TestSize.Level1)
476 {
477 ASSERT_NE(session_, nullptr);
478 SessionInfo info;
479 info.abilityName_ = "testSession1";
480 info.moduleName_ = "testSession2";
481 info.bundleName_ = "testSession3";
482 sptr<Session> session = sptr<Session>::MakeSptr(info);
483 session_->RemoveDialogToParentSession(session);
484
485 sptr<Session> session1 = sptr<Session>::MakeSptr(info);
486 session1->persistentId_ = 33;
487 session1->SetParentSession(session_);
488 session1->state_ = SessionState::STATE_ACTIVE;
489 session_->dialogVec_.push_back(session1);
490
491 sptr<Session> session2 = sptr<Session>::MakeSptr(info);
492 session2->persistentId_ = 34;
493 session2->SetParentSession(session_);
494 session2->state_ = SessionState::STATE_ACTIVE;
495 session_->dialogVec_.push_back(session2);
496 session_->RemoveDialogToParentSession(session1);
497
498 ASSERT_EQ(WSError::WS_OK, session_->SetFocusable(false));
499 }
500
501 /**
502 * @tc.name: IsSystemSession
503 * @tc.desc: IsSystemSession
504 * @tc.type: FUNC
505 */
506 HWTEST_F(SessionSpecificWindowTest, IsSystemSession, TestSize.Level1)
507 {
508 ASSERT_NE(session_, nullptr);
509 bool res = session_->IsSystemSession();
510 ASSERT_EQ(res, false);
511 }
512
513 /**
514 * @tc.name: HandleDialogBackground
515 * @tc.desc: HandleDialogBackground Test
516 * @tc.type: FUNC
517 */
518 HWTEST_F(SessionSpecificWindowTest, HandleDialogBackground, TestSize.Level1)
519 {
520 ASSERT_NE(session_, nullptr);
521 session_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
522 session_->HandleDialogBackground();
523
524 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
525 sptr<Session> session01 = nullptr;
526
527 SessionInfo info;
528 info.abilityName_ = "testSession1";
529 info.moduleName_ = "testSession2";
530 info.bundleName_ = "testSession3";
531 sptr<Session> session02 = sptr<Session>::MakeSptr(info);
532 sptr<Session> session03 = sptr<Session>::MakeSptr(info);
533
534 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
535 EXPECT_NE(nullptr, mockSessionStage);
536 session02->sessionStage_ = mockSessionStage;
537 session03->sessionStage_ = nullptr;
538
539 session_->dialogVec_.push_back(session01);
540 session_->dialogVec_.push_back(session02);
541 session_->dialogVec_.push_back(session03);
542 session_->HandleDialogBackground();
543 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr);
544 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true));
545 }
546
547 /**
548 * @tc.name: HandleDialogForeground
549 * @tc.desc: HandleDialogForeground Test
550 * @tc.type: FUNC
551 */
552 HWTEST_F(SessionSpecificWindowTest, HandleDialogForeground, TestSize.Level1)
553 {
554 ASSERT_NE(session_, nullptr);
555 session_->property_->SetWindowType(WindowType::APP_MAIN_WINDOW_END);
556 session_->HandleDialogForeground();
557
558 session_->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
559 sptr<Session> session01 = nullptr;
560
561 SessionInfo info;
562 info.abilityName_ = "testSession1";
563 info.moduleName_ = "testSession2";
564 info.bundleName_ = "testSession3";
565 sptr<Session> session02 = sptr<Session>::MakeSptr(info);
566 sptr<Session> session03 = sptr<Session>::MakeSptr(info);
567
568 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
569 EXPECT_NE(nullptr, mockSessionStage);
570 session02->sessionStage_ = mockSessionStage;
571 session03->sessionStage_ = nullptr;
572
573 session_->dialogVec_.push_back(session01);
574 session_->dialogVec_.push_back(session02);
575 session_->dialogVec_.push_back(session03);
576 session_->HandleDialogForeground();
577 session_->SetPendingSessionToBackgroundForDelegatorListener(nullptr);
578 EXPECT_EQ(WSError::WS_OK, session_->PendingSessionToBackgroundForDelegator(true));
579 }
580
581 /**
582 * @tc.name: HandleSubWindowClick01
583 * @tc.desc: parentSession and property is nullptr
584 * @tc.type: FUNC
585 */
586 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick01, TestSize.Level1)
587 {
588 ASSERT_NE(session_, nullptr);
589 auto result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN, 0);
590 EXPECT_EQ(result, WSError::WS_OK);
591 }
592
593 /**
594 * @tc.name: HandleSubWindowClick03
595 * @tc.desc: parentSession->dialogVec_ is nullptr
596 * @tc.type: FUNC
597 */
598 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick03, TestSize.Level1)
599 {
600 ASSERT_NE(session_, nullptr);
601 SessionInfo info;
602 info.abilityName_ = "testSession1";
603 info.moduleName_ = "testSession2";
604 info.bundleName_ = "testSession3";
605 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info);
606 session_->SetParentSession(dialogSession);
607
608 auto result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN, 0);
609 EXPECT_EQ(result, WSError::WS_OK);
610
611 result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_MOVE, 0);
612 EXPECT_EQ(result, WSError::WS_OK);
613 }
614
615 /**
616 * @tc.name: HandleSubWindowClick03
617 * @tc.desc: isExecuteDelayRaise is true
618 * @tc.type: FUNC
619 */
620 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick04, TestSize.Level1)
621 {
622 ASSERT_NE(session_, nullptr);
623 SessionInfo info;
624 info.abilityName_ = "testSession1";
625 info.moduleName_ = "testSession2";
626 info.bundleName_ = "testSession3";
627 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info);
628 session_->SetParentSession(dialogSession);
629
630 session_->property_->SetRaiseEnabled(true);
631 int32_t action = MMI::PointerEvent::POINTER_ACTION_BUTTON_UP;
632 bool isExecuteDelayRaise = true;
633 auto result = session_->HandleSubWindowClick(action, 0, isExecuteDelayRaise);
634 EXPECT_EQ(result, WSError::WS_OK);
635
636 session_->property_->SetRaiseEnabled(false);
637 result = session_->HandleSubWindowClick(action, 0, isExecuteDelayRaise);
638 EXPECT_EQ(result, WSError::WS_OK);
639 }
640
641 /**
642 * @tc.name: HandleSubWindowClick05
643 * @tc.desc: HandleSubWindowClick
644 * @tc.type: FUNC
645 */
646 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick05, Function | SmallTest | Level2)
647 {
648 SessionInfo info1;
649 info1.abilityName_ = "testSession1";
650 info1.moduleName_ = "testSession1";
651 info1.bundleName_ = "testSession1";
652 sptr<Session> dialogSession = sptr<Session>::MakeSptr(info1);
653
654 SessionInfo info2;
655 info2.abilityName_ = "testSession2";
656 info2.moduleName_ = "testSession2";
657 info2.bundleName_ = "testSession2";
658 auto session = sptr<Session>::MakeSptr(info2);
659 session->SetParentSession(dialogSession);
660
661 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
662 property->SetRaiseEnabled(false);
663 session->SetSessionProperty(property);
664
665 auto result = session->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN, 0, false);
666 EXPECT_EQ(result, WSError::WS_OK);
667
668 result = session->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_DOWN, 0, true);
669 EXPECT_EQ(result, WSError::WS_OK);
670 }
671
672 /**
673 * @tc.name: HandleSubWindowClick06
674 * @tc.desc: HandleSubWindowClick
675 * @tc.type: FUNC
676 */
677 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick06, Function | SmallTest | Level2)
678 {
679 ASSERT_NE(session_, nullptr);
680 SessionInfo info;
681 info.abilityName_ = "testSession1";
682 info.moduleName_ = "testSession2";
683 info.bundleName_ = "testSession3";
684 sptr<Session> subSession = sptr<Session>::MakeSptr(info);
685 subSession->SetParentSession(session_);
686 auto property = sptr<WindowSessionProperty>::MakeSptr();
687 property->SetWindowFlags(static_cast<uint32_t>(WindowFlag::WINDOW_FLAG_IS_MODAL));
688 subSession->SetSessionProperty(property);
689 bool isExecuteDelayRaise = false;
690 auto result = session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_BUTTON_DOWN, 0, isExecuteDelayRaise);
691 EXPECT_EQ(result, WSError::WS_OK);
692 }
693
694 /**
695 * @tc.name: HandleSubWindowClick07
696 * @tc.desc: HandleSubWindowClick
697 * @tc.type: FUNC
698 */
699 HWTEST_F(SessionSpecificWindowTest, HandleSubWindowClick07, Function | SmallTest | Level2)
700 {
701 ASSERT_NE(session_, nullptr);
702 bool hasNotifyManagerToRequestFocus = false;
__anonee758edb0502() 703 session_->SetRaiseToAppTopForPointDownFunc([&hasNotifyManagerToRequestFocus]() {
704 hasNotifyManagerToRequestFocus = true;
705 });
706 SessionInfo info;
707 info.abilityName_ = "testSession1";
708 info.moduleName_ = "testSession2";
709 info.bundleName_ = "testSession3";
710 sptr<Session> subSession = sptr<Session>::MakeSptr(info);
711 subSession->SetParentSession(session_);
712 session_->property_->SetRaiseEnabled(true);
713 hasNotifyManagerToRequestFocus = false;
714 session_->HandleSubWindowClick(MMI::PointerEvent::POINTER_ACTION_HOVER_ENTER,
715 MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN, false);
716 EXPECT_EQ(hasNotifyManagerToRequestFocus, true);
717 }
718 } // namespace
719 } // namespace Rosen
720 } // namespace OHOS
721