1 /*
2 * Copyright (c) 2023 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 "window_helper.h"
17 #include "display_manager.h"
18 #include "pointer_event.h"
19
20 #include <gtest/gtest.h>
21 #include "key_event.h"
22 #include "session/host/include/scene_session.h"
23 #include "session/host/include/sub_session.h"
24 #include "session/host/include/system_session.h"
25 #include "session/host/include/main_session.h"
26 #include "wm_common.h"
27 #include "mock/mock_session_stage.h"
28 #include "input_event.h"
29 #include <pointer_event.h>
30 #include "ui/rs_surface_node.h"
31 #include "session/container/include/window_event_channel.h"
32 #include "window_event_channel_base.h"
33
34 using namespace testing;
35 using namespace testing::ext;
36 namespace OHOS {
37 namespace Rosen {
38 class SceneSessionLifecycleTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44 sptr<SceneSession> sceneSession;
45 SessionInfo info;
46 };
47
SetUpTestCase()48 void SceneSessionLifecycleTest::SetUpTestCase() {}
49
TearDownTestCase()50 void SceneSessionLifecycleTest::TearDownTestCase() {}
51
SetUp()52 void SceneSessionLifecycleTest::SetUp()
53 {
54 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
55 }
56
TearDown()57 void SceneSessionLifecycleTest::TearDown() {}
58
59 namespace {
60
61 /**
62 * @tc.name: Foreground01
63 * @tc.desc: normal function
64 * @tc.type: FUNC
65 */
66 HWTEST_F(SceneSessionLifecycleTest, Foreground01, TestSize.Level0)
67 {
68 SessionInfo info;
69 info.abilityName_ = "Foreground01";
70 info.bundleName_ = "Foreground01";
71 sptr<Rosen::ISession> session_;
72 sptr<SceneSession::SpecificSessionCallback> specificCallback =
73 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
74 EXPECT_NE(specificCallback, nullptr);
75 int resultValue = 0;
76 sptr<SceneSession> sceneSession;
77
78 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
79 EXPECT_NE(sceneSession, nullptr);
80 sceneSession->isActive_ = true;
81 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
82 ASSERT_NE(nullptr, property);
83
84 auto result = sceneSession->Foreground(property);
85 ASSERT_EQ(result, WSError::WS_OK);
86 specificCallback->onCreate_ = [&resultValue,
87 specificCallback](const SessionInfo& info,
__anon9a8c955b0202(const SessionInfo& info, sptr<WindowSessionProperty> property) 88 sptr<WindowSessionProperty> property) -> sptr<SceneSession> {
89 sptr<SceneSession> sceneSessionReturn = sptr<SceneSession>::MakeSptr(info, specificCallback);
90 EXPECT_NE(sceneSessionReturn, nullptr);
91 resultValue = 1;
92 return sceneSessionReturn;
93 };
94 sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
95 EXPECT_NE(sceneSession, nullptr);
96 sceneSession->UpdateSessionState(SessionState::STATE_DISCONNECT);
97 sceneSession->isActive_ = true;
98 result = sceneSession->Foreground(property);
99 ASSERT_EQ(result, WSError::WS_OK);
100 }
101
102 /**
103 * @tc.name: Foreground02
104 * @tc.desc: normal function
105 * @tc.type: FUNC
106 */
107 HWTEST_F(SceneSessionLifecycleTest, Foreground02, TestSize.Level1)
108 {
109 SessionInfo info;
110 info.abilityName_ = "Foreground02";
111 info.bundleName_ = "Foreground02";
112 sptr<Rosen::ISession> session_;
113 sptr<SceneSession::SpecificSessionCallback> specificCallback =
114 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
115 EXPECT_NE(specificCallback, nullptr);
116 sptr<SceneSession> sceneSession;
117
118 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
119 EXPECT_NE(sceneSession, nullptr);
120 sceneSession->isActive_ = true;
121 sptr<WindowSessionProperty> property = nullptr;
122 auto result = sceneSession->Foreground(property);
123 ASSERT_EQ(result, WSError::WS_OK);
124 }
125
126 /**
127 * @tc.name: ForegroundAndBackground03
128 * @tc.desc: normal function
129 * @tc.type: FUNC
130 */
131 HWTEST_F(SceneSessionLifecycleTest, Foreground03, TestSize.Level1)
132 {
133 SessionInfo info;
134 info.abilityName_ = "Foreground03";
135 info.bundleName_ = "Foreground03";
136 sptr<Rosen::ISession> session_;
137 sptr<SceneSession::SpecificSessionCallback> specificCallback =
138 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
139 EXPECT_NE(specificCallback, nullptr);
140 sptr<SceneSession> sceneSession;
141
142 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
143 EXPECT_NE(sceneSession, nullptr);
144 sceneSession->isActive_ = true;
145 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
146 property->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
147 auto result = sceneSession->Foreground(property);
148 ASSERT_EQ(result, WSError::WS_OK);
149 }
150
151 /**
152 * @tc.name: Foreground04
153 * @tc.desc: Foreground04 function
154 * @tc.type: FUNC
155 */
156 HWTEST_F(SceneSessionLifecycleTest, Foreground04, TestSize.Level1)
157 {
158 SessionInfo info;
159 info.abilityName_ = "Foreground04";
160 info.bundleName_ = "Foreground04";
161
162 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
163 EXPECT_NE(session, nullptr);
164 sptr<WindowSessionProperty> property = nullptr;
165 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
166
167 info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
168 sptr<SceneSession> session1 = sptr<SceneSession>::MakeSptr(info, nullptr);
169 EXPECT_EQ(WSError::WS_OK, session1->Foreground(property, true));
170 EXPECT_EQ(WSError::WS_OK, session1->Foreground(property, false));
171 }
172
173 /**
174 * @tc.name: Foreground05
175 * @tc.desc: Foreground05 function
176 * @tc.type: FUNC
177 */
178 HWTEST_F(SceneSessionLifecycleTest, Foreground05, TestSize.Level1)
179 {
180 SessionInfo info;
181 info.abilityName_ = "Foreground05";
182 info.bundleName_ = "Foreground05";
183
184 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
185 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
186 session->Session::SetSessionState(SessionState::STATE_CONNECT);
187 session->Session::isActive_ = true;
188 session->SetLeashWinSurfaceNode(nullptr);
189 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
190
191 sptr<SceneSession::SpecificSessionCallback> specificCallback =
192 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
193 session->specificCallback_ = specificCallback;
194 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
195
196 struct RSSurfaceNodeConfig config;
197 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
198 session->SetLeashWinSurfaceNode(surfaceNode);
199 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
200
201 session->SetSessionProperty(property);
202 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
203 }
204
205 /**
206 * @tc.name: Foreground06
207 * @tc.desc: Foreground06 function
208 * @tc.type: FUNC
209 */
210 HWTEST_F(SceneSessionLifecycleTest, Foreground06, TestSize.Level0)
211 {
212 SessionInfo info;
213 info.abilityName_ = "Foreground06";
214 info.bundleName_ = "Foreground06";
215
216 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
217 EXPECT_NE(session, nullptr);
218 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
219 session->property_ = property;
220 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
221
222 session->SetLeashWinSurfaceNode(nullptr);
223 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
224
225 sptr<WindowSessionProperty> property2 = sptr<WindowSessionProperty>::MakeSptr();
226 EXPECT_NE(property2, nullptr);
227 property2->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
228 EXPECT_EQ(WSError::WS_OK, session->Foreground(property2, false));
229
230 struct RSSurfaceNodeConfig config;
231 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
232 session->SetLeashWinSurfaceNode(surfaceNode);
233 EXPECT_EQ(WSError::WS_OK, session->Foreground(property2, false));
234
235 sptr<WindowSessionProperty> property3 = sptr<WindowSessionProperty>::MakeSptr();
236 EXPECT_NE(property3, nullptr);
237 property3->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
238 session->SetSessionProperty(property3);
239 EXPECT_EQ(WSError::WS_OK, session->Foreground(property, false));
240 }
241
242 /**
243 * @tc.name: ForegroundTask01
244 * @tc.desc: ForegroundTask function
245 * @tc.type: FUNC
246 */
247 HWTEST_F(SceneSessionLifecycleTest, ForegroundTask01, TestSize.Level0)
248 {
249 SessionInfo info;
250 info.abilityName_ = "ForegroundTask01";
251 info.bundleName_ = "ForegroundTask01";
252 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
253 session->SetSessionState(SessionState::STATE_CONNECT);
254 EXPECT_EQ(SessionState::STATE_CONNECT, session->GetSessionState());
255
256 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
257 EXPECT_EQ(false, session->isUIFirstEnabled_);
258 EXPECT_EQ(WSError::WS_OK, session->ForegroundTask(property));
259
260 session->isUIFirstEnabled_ = true;
261 EXPECT_EQ(true, session->isUIFirstEnabled_);
262 session->SetSessionState(SessionState::STATE_CONNECT);
263 EXPECT_EQ(WSError::WS_OK, session->ForegroundTask(property));
264 }
265
266 /**
267 * @tc.name: Background01
268 * @tc.desc: normal function
269 * @tc.type: FUNC
270 */
271 HWTEST_F(SceneSessionLifecycleTest, Background01, TestSize.Level0)
272 {
273 SessionInfo info;
274 info.abilityName_ = "Background01";
275 info.bundleName_ = "Background01";
276 sptr<Rosen::ISession> session_;
277 sptr<SceneSession::SpecificSessionCallback> specificCallback =
278 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
279 EXPECT_NE(specificCallback, nullptr);
280 int resultValue = 0;
281 sptr<SceneSession> sceneSession;
282
283 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
284 EXPECT_NE(sceneSession, nullptr);
285 sceneSession->isActive_ = true;
286 auto result = sceneSession->Background();
287 ASSERT_EQ(result, WSError::WS_OK);
288 specificCallback->onCreate_ = [&resultValue,
289 specificCallback](const SessionInfo& info,
__anon9a8c955b0302(const SessionInfo& info, sptr<WindowSessionProperty> property) 290 sptr<WindowSessionProperty> property) -> sptr<SceneSession> {
291 sptr<SceneSession> sceneSessionReturn = sptr<SceneSession>::MakeSptr(info, specificCallback);
292 EXPECT_NE(sceneSessionReturn, nullptr);
293 resultValue = 1;
294 return sceneSessionReturn;
295 };
296 sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
297 EXPECT_NE(sceneSession, nullptr);
298 sceneSession->UpdateSessionState(SessionState::STATE_CONNECT);
299 sceneSession->isActive_ = true;
300 result = sceneSession->Background();
301 ASSERT_EQ(result, WSError::WS_OK);
302 }
303
304 /**
305 * @tc.name: Background02
306 * @tc.desc: normal function
307 * @tc.type: FUNC
308 */
309 HWTEST_F(SceneSessionLifecycleTest, Background02, TestSize.Level1)
310 {
311 SessionInfo info;
312 info.abilityName_ = "Background02";
313 info.bundleName_ = "Background02";
314 sptr<Rosen::ISession> session_;
315 sptr<SceneSession::SpecificSessionCallback> specificCallback =
316 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
317 EXPECT_NE(specificCallback, nullptr);
318 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
319 EXPECT_NE(sceneSession, nullptr);
320
321 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
322 property->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
323 sceneSession->SetSessionProperty(property);
324 sceneSession->isActive_ = true;
325 auto result = sceneSession->Background();
326 ASSERT_EQ(result, WSError::WS_OK);
327 }
328
329 /**
330 * @tc.name: Background04
331 * @tc.desc: normal function
332 * @tc.type: FUNC
333 */
334 HWTEST_F(SceneSessionLifecycleTest, Background04, TestSize.Level1)
335 {
336 SessionInfo info;
337 info.abilityName_ = "Background04";
338 info.bundleName_ = "Background04";
339 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
340 EXPECT_NE(nullptr, sceneSession);
341
342 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
343 EXPECT_NE(property, nullptr);
344 property->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
345 sceneSession->SetSessionProperty(property);
346 EXPECT_EQ(WSError::WS_OK, sceneSession->Background(true));
347
348 sptr<WindowSessionProperty> property2 = sptr<WindowSessionProperty>::MakeSptr();
349 EXPECT_NE(property2, nullptr);
350 property2->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
351 sceneSession->SetSessionProperty(property2);
352 EXPECT_EQ(WSError::WS_OK, sceneSession->Background(false));
353 EXPECT_EQ(WSError::WS_OK, sceneSession->Background(true));
354 }
355
356 /**
357 * @tc.name: BackgroundTask01
358 * @tc.desc: normal function
359 * @tc.type: FUNC
360 */
361 HWTEST_F(SceneSessionLifecycleTest, BackgroundTask01, TestSize.Level0)
362 {
363 SessionInfo info;
364 info.abilityName_ = "BackgroundTask01";
365 info.bundleName_ = "BackgroundTask01";
366 sptr<SceneSession::SpecificSessionCallback> specificCallback =
367 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
368 EXPECT_NE(specificCallback, nullptr);
369 int resultValue = 0;
370 sptr<SceneSession> sceneSession;
371 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
372 EXPECT_NE(sceneSession, nullptr);
373 sceneSession->isActive_ = true;
374 auto result = sceneSession->BackgroundTask();
375 ASSERT_EQ(result, WSError::WS_OK);
376 sceneSession->isActive_ = true;
377 result = sceneSession->BackgroundTask(false);
378 ASSERT_EQ(result, WSError::WS_OK);
379 specificCallback->onCreate_ = [&resultValue,
380 specificCallback](const SessionInfo& info,
__anon9a8c955b0402(const SessionInfo& info, sptr<WindowSessionProperty> property) 381 sptr<WindowSessionProperty> property) -> sptr<SceneSession> {
382 sptr<SceneSession> sceneSessionReturn = sptr<SceneSession>::MakeSptr(info, specificCallback);
383 EXPECT_NE(sceneSessionReturn, nullptr);
384 resultValue = 1;
385 return sceneSessionReturn;
386 };
387 sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
388 EXPECT_NE(sceneSession, nullptr);
389 sceneSession->UpdateSessionState(SessionState::STATE_CONNECT);
390 sceneSession->isActive_ = true;
391 result = sceneSession->BackgroundTask();
392 ASSERT_EQ(result, WSError::WS_OK);
393 sceneSession->UpdateSessionState(SessionState::STATE_CONNECT);
394 sceneSession->isActive_ = true;
395 result = sceneSession->BackgroundTask(false);
396 ASSERT_EQ(result, WSError::WS_OK);
397 }
398
399 /**
400 * @tc.name: BackgroundTask02
401 * @tc.desc: normal function
402 * @tc.type: FUNC
403 */
404 HWTEST_F(SceneSessionLifecycleTest, BackgroundTask02, TestSize.Level1)
405 {
406 SessionInfo info;
407 info.abilityName_ = "BackgroundTask02";
408 info.bundleName_ = "BackgroundTask02";
409 sptr<SceneSession::SpecificSessionCallback> specificCallback =
410 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
411 EXPECT_NE(specificCallback, nullptr);
412 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
413 EXPECT_NE(sceneSession, nullptr);
414 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
415 property->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
416 sceneSession->SetSessionProperty(property);
417 sceneSession->isActive_ = true;
418 auto result = sceneSession->BackgroundTask();
419 ASSERT_EQ(result, WSError::WS_OK);
420 sceneSession->isActive_ = true;
421 result = sceneSession->BackgroundTask(false);
422 ASSERT_EQ(result, WSError::WS_OK);
423 }
424
425 /**
426 * @tc.name: BackgroundTask03
427 * @tc.desc: BackgroundTask03 function
428 * @tc.type: FUNC
429 */
430 HWTEST_F(SceneSessionLifecycleTest, BackgroundTask03, TestSize.Level0)
431 {
432 SessionInfo info;
433 info.abilityName_ = "BackgroundTask03";
434 info.bundleName_ = "BackgroundTask03";
435
436 sptr<SceneSession> session = sptr<SceneSession>::MakeSptr(info, nullptr);
437 EXPECT_NE(session, nullptr);
438 sptr<WindowSessionProperty> property = nullptr;
439 session->SetSessionState(SessionState::STATE_BACKGROUND);
440 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(false));
441
442 session->SetSessionState(SessionState::STATE_CONNECT);
443 session->Session::SetSessionState(SessionState::STATE_CONNECT);
444 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(false));
445
446 session->Session::SetSessionState(SessionState::STATE_INACTIVE);
447 info.windowType_ = static_cast<uint32_t>(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
448 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(false));
449
450 info.windowType_ = static_cast<uint32_t>(WindowType::APP_MAIN_WINDOW_BASE);
451 sptr<SceneSession::SpecificSessionCallback> specificCallback =
452 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
453 session->specificCallback_ = specificCallback;
454 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(false));
455
456 session->scenePersistence_ = nullptr;
457 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(true));
458
459 session->scenePersistence_ = sptr<ScenePersistence>::MakeSptr("Foreground02", 1);
460 struct RSSurfaceNodeConfig config;
461 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
462 session->surfaceNode_ = surfaceNode;
463 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(true));
464
465 sptr<WindowSessionProperty> property2 = sptr<WindowSessionProperty>::MakeSptr();
466 EXPECT_NE(property2, nullptr);
467 property2->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
468 session->SetSessionProperty(property2);
469 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(false));
470 EXPECT_EQ(WSError::WS_OK, session->BackgroundTask(true));
471 }
472
473 /**
474 * @tc.name: BackgroundTask04
475 * @tc.desc: BackgroundTask04 function
476 * @tc.type: FUNC
477 */
478 HWTEST_F(SceneSessionLifecycleTest, BackgroundTask04, TestSize.Level0)
479 {
480 SessionInfo info;
481 info.abilityName_ = "BackgroundTask04";
482 info.bundleName_ = "BackgroundTask04";
483 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
484 EXPECT_NE(sceneSession, nullptr);
485 sceneSession->isActive_ = true;
486 sceneSession->state_ = SessionState::STATE_INACTIVE;
487 sceneSession->property_ = sptr<WindowSessionProperty>::MakeSptr();
488 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
489 EXPECT_EQ(sceneSession->BackgroundTask(), WSError::WS_OK);
490 sceneSession->property_->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
491 EXPECT_EQ(sceneSession->BackgroundTask(), WSError::WS_OK);
492 }
493
494 /**
495 * @tc.name: DisconnectTask01
496 * @tc.desc: normal function
497 * @tc.type: FUNC
498 */
499 HWTEST_F(SceneSessionLifecycleTest, DisconnectTask01, TestSize.Level0)
500 {
501 SessionInfo info;
502 info.abilityName_ = "DisconnectTask01";
503 info.bundleName_ = "DisconnectTask01";
504 sptr<SceneSession::SpecificSessionCallback> specificCallback =
505 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
506 EXPECT_NE(specificCallback, nullptr);
507
508 int resultValue = 0;
509 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
510 EXPECT_NE(sceneSession, nullptr);
511 sceneSession->isActive_ = true;
512 auto result = sceneSession->DisconnectTask(true, true);
513 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
514 ASSERT_EQ(result, WSError::WS_OK);
515 sceneSession->isActive_ = true;
516 result = sceneSession->DisconnectTask(false, true);
517 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
518 ASSERT_EQ(result, WSError::WS_OK);
519 specificCallback->onCreate_ = [&resultValue,
520 specificCallback](const SessionInfo& info,
__anon9a8c955b0502(const SessionInfo& info, sptr<WindowSessionProperty> property) 521 sptr<WindowSessionProperty> property) -> sptr<SceneSession> {
522 sptr<SceneSession> sceneSessionReturn = sptr<SceneSession>::MakeSptr(info, specificCallback);
523 EXPECT_NE(sceneSessionReturn, nullptr);
524 resultValue = 1;
525 return sceneSessionReturn;
526 };
527 sceneSession = sptr<SceneSession>::MakeSptr(info, specificCallback);
528 EXPECT_NE(sceneSession, nullptr);
529 sceneSession->UpdateSessionState(SessionState::STATE_CONNECT);
530 sceneSession->isActive_ = true;
531 result = sceneSession->DisconnectTask(true, true);
532 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
533 ASSERT_EQ(result, WSError::WS_OK);
534 sceneSession->UpdateSessionState(SessionState::STATE_CONNECT);
535 sceneSession->isActive_ = true;
536 result = sceneSession->DisconnectTask(false, true);
537 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
538 ASSERT_EQ(result, WSError::WS_OK);
539 }
540
541 /**
542 * @tc.name: DisconnectTask02
543 * @tc.desc: normal function
544 * @tc.type: FUNC
545 */
546 HWTEST_F(SceneSessionLifecycleTest, DisconnectTask02, TestSize.Level0)
547 {
548 SessionInfo info;
549 info.abilityName_ = "DisconnectTask02";
550 info.bundleName_ = "DisconnectTask02";
551 sptr<SceneSession::SpecificSessionCallback> specificCallback =
552 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
553 EXPECT_NE(specificCallback, nullptr);
554 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
555 EXPECT_NE(sceneSession, nullptr);
556 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
557 EXPECT_NE(property, nullptr);
558 property->SetAnimationFlag(static_cast<uint32_t>(WindowAnimation::CUSTOM));
559 sceneSession->SetSessionProperty(property);
560 sceneSession->isActive_ = true;
561 auto result = sceneSession->DisconnectTask(true, true);
562 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
563 ASSERT_EQ(result, WSError::WS_OK);
564 sceneSession->isActive_ = true;
565 result = sceneSession->DisconnectTask(false, true);
566 ASSERT_EQ(result, WSError::WS_OK);
567 }
568
569 /**
570 * @tc.name: Disconnect
571 * @tc.desc: normal function
572 * @tc.type: FUNC
573 */
574 HWTEST_F(SceneSessionLifecycleTest, Disconnect, TestSize.Level0)
575 {
576 SessionInfo info;
577 info.abilityName_ = "Disconnect";
578 info.bundleName_ = "Disconnect";
579 sptr<Rosen::ISession> session_;
580 sptr<SceneSession::SpecificSessionCallback> specificCallback =
581 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
582 EXPECT_NE(specificCallback, nullptr);
583 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
584 EXPECT_NE(sceneSession, nullptr);
585
586 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
587 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
588 sceneSession->SetSessionProperty(property);
589 sceneSession->isActive_ = true;
590 auto result = sceneSession->Disconnect();
591 ASSERT_EQ(result, WSError::WS_OK);
592 }
593
594 /**
595 * @tc.name: Disconnect2
596 * @tc.desc: normal function
597 * @tc.type: FUNC
598 */
599 HWTEST_F(SceneSessionLifecycleTest, Disconnect2, TestSize.Level1)
600 {
601 SessionInfo info;
602 info.abilityName_ = "Disconnect2";
603 info.bundleName_ = "Disconnect2";
604 sptr<Rosen::ISession> session_;
605 sptr<SceneSession::SpecificSessionCallback> specificCallback =
606 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
607 EXPECT_NE(specificCallback, nullptr);
608 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
609 EXPECT_NE(sceneSession, nullptr);
610
611 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
612 EXPECT_NE(property, nullptr);
613 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
614 sceneSession->SetSessionProperty(property);
615 sceneSession->isActive_ = true;
616
617 auto result = sceneSession->Disconnect(true);
618 ASSERT_EQ(result, WSError::WS_OK);
619 }
620
621 /**
622 * @tc.name: Disconnect3
623 * @tc.desc: normal function
624 * @tc.type: FUNC
625 */
626 HWTEST_F(SceneSessionLifecycleTest, Disconnect3, TestSize.Level0)
627 {
628 SessionInfo info;
629 info.abilityName_ = "Disconnect3";
630 info.bundleName_ = "Disconnect3";
631 sptr<Rosen::ISession> session_;
632 sptr<SceneSession::SpecificSessionCallback> specificCallback =
633 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
634 EXPECT_NE(specificCallback, nullptr);
635 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
636 EXPECT_NE(sceneSession, nullptr);
637
638 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
639 EXPECT_NE(property, nullptr);
640 property->SetWindowType(WindowType::ABOVE_APP_SYSTEM_WINDOW_BASE);
641 sceneSession->SetSessionProperty(property);
642 sceneSession->isActive_ = true;
643
644 auto result = sceneSession->Disconnect(true);
645 ASSERT_EQ(result, WSError::WS_OK);
646
647 sceneSession->specificCallback_ = nullptr;
648 result = sceneSession->Disconnect(false);
649 ASSERT_EQ(result, WSError::WS_OK);
650
651 sceneSession->needSnapshot_ = true;
652 sceneSession->SetSessionState(SessionState::STATE_ACTIVE);
653 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
654 sceneSession->SetSessionProperty(property);
655
656 result = sceneSession->Disconnect(false);
657 ASSERT_EQ(result, WSError::WS_OK);
658 }
659
660 /**
661 * @tc.name: UpdateActiveStatus01
662 * @tc.desc: normal function
663 * @tc.type: FUNC
664 */
665 HWTEST_F(SceneSessionLifecycleTest, UpdateActiveStatus01, TestSize.Level0)
666 {
667 SessionInfo info;
668 info.abilityName_ = "UpdateActiveStatus01";
669 info.bundleName_ = "UpdateActiveStatus01";
670 sptr<Rosen::ISession> session_;
671 sptr<SceneSession::SpecificSessionCallback> specificCallback =
672 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
673 EXPECT_NE(specificCallback, nullptr);
674 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
675 EXPECT_NE(sceneSession, nullptr);
676
677 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
678 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
679 sceneSession->SetSessionProperty(property);
680 sceneSession->isActive_ = true;
681 auto result = sceneSession->UpdateActiveStatus(true);
682 ASSERT_EQ(result, WSError::WS_OK);
683
684 result = sceneSession->UpdateActiveStatus(false);
685 ASSERT_EQ(result, WSError::WS_OK);
686 }
687
688 /**
689 * @tc.name: UpdateActiveStatus02
690 * @tc.desc: normal function
691 * @tc.type: FUNC
692 */
693 HWTEST_F(SceneSessionLifecycleTest, UpdateActiveStatus02, TestSize.Level1)
694 {
695 SessionInfo info;
696 info.abilityName_ = "UpdateActiveStatus02";
697 info.bundleName_ = "UpdateActiveStatus02";
698 sptr<Rosen::ISession> session_;
699 sptr<SceneSession::SpecificSessionCallback> specificCallback =
700 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
701 EXPECT_NE(specificCallback, nullptr);
702 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
703 EXPECT_NE(sceneSession, nullptr);
704
705 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
706 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
707 sceneSession->SetSessionProperty(property);
708 sceneSession->isActive_ = false;
709 auto result = sceneSession->UpdateActiveStatus(true);
710 ASSERT_EQ(result, WSError::WS_OK);
711 }
712
713 /**
714 * @tc.name: UpdateActiveStatus03
715 * @tc.desc: normal function
716 * @tc.type: FUNC
717 */
718 HWTEST_F(SceneSessionLifecycleTest, UpdateActiveStatus03, TestSize.Level0)
719 {
720 SessionInfo info;
721 info.abilityName_ = "UpdateActiveStatus03";
722 info.bundleName_ = "UpdateActiveStatus03";
723 sptr<Rosen::ISession> session_;
724 sptr<SceneSession::SpecificSessionCallback> specificCallback =
725 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
726 EXPECT_NE(specificCallback, nullptr);
727 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
728 EXPECT_NE(sceneSession, nullptr);
729
730 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
731 EXPECT_NE(property, nullptr);
732 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
733 sceneSession->SetSessionProperty(property);
734 sceneSession->isActive_ = true;
735 sceneSession->state_ = SessionState::STATE_DISCONNECT;
736
737 auto result = sceneSession->UpdateActiveStatus(false);
738 ASSERT_EQ(result, WSError::WS_OK);
739
740 result = sceneSession->UpdateActiveStatus(true);
741 ASSERT_EQ(result, WSError::WS_OK);
742
743 sceneSession->isActive_ = false;
744 result = sceneSession->UpdateActiveStatus(false);
745 ASSERT_EQ(result, WSError::WS_OK);
746
747 sceneSession->isActive_ = true;
748 sceneSession->state_ = SessionState::STATE_FOREGROUND;
749 result = sceneSession->UpdateActiveStatus(true);
750 ASSERT_EQ(result, WSError::WS_OK);
751
752 sceneSession->isActive_ = true;
753 sceneSession->state_ = SessionState::STATE_ACTIVE;
754 result = sceneSession->UpdateActiveStatus(false);
755 ASSERT_EQ(result, WSError::WS_OK);
756
757 sceneSession->isActive_ = false;
758 result = sceneSession->UpdateActiveStatus(true);
759 ASSERT_EQ(result, WSError::WS_OK);
760 }
761
762 /**
763 * @tc.name: UpdateActiveStatus04
764 * @tc.desc: normal function
765 * @tc.type: FUNC
766 */
767 HWTEST_F(SceneSessionLifecycleTest, UpdateActiveStatus04, TestSize.Level1)
768 {
769 SessionInfo info;
770 info.abilityName_ = "UpdateActiveStatus04";
771 info.bundleName_ = "UpdateActiveStatus04";
772 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
773 EXPECT_NE(sceneSession, nullptr);
774
775 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
776 EXPECT_NE(property, nullptr);
777 property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
778 sceneSession->SetSessionProperty(property);
779 sceneSession->isActive_ = true;
780 sceneSession->state_ = SessionState::STATE_ACTIVE;
781
782 auto result = sceneSession->UpdateActiveStatus(true);
783 ASSERT_EQ(result, WSError::WS_OK);
784 }
785
786 /**
787 * @tc.name: Connect
788 * @tc.desc: Connect
789 * @tc.type: FUNC
790 */
791 HWTEST_F(SceneSessionLifecycleTest, Connect, TestSize.Level0)
792 {
793 SessionInfo info;
794 info.bundleName_ = "Connect";
795 info.abilityName_ = "Connect1";
796 info.windowType_ = 1;
797 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
798 EXPECT_NE(sceneSession, nullptr);
799
800 sptr<ISessionStage> sessionStage = nullptr;
801 sptr<IWindowEventChannel> eventChannel = nullptr;
802 std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
803 SystemSessionConfig systemConfig;
804 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
805 sptr<IRemoteObject> token;
806 WSError res = sceneSession->Connect(sessionStage, eventChannel, surfaceNode, systemConfig, property, token);
807 ASSERT_EQ(res, WSError::WS_ERROR_NULLPTR);
808 }
809
810 /**
811 * @tc.name: ConnectInner01
812 * @tc.desc: ConnectInner01
813 * @tc.type: FUNC
814 */
815 HWTEST_F(SceneSessionLifecycleTest, ConnectInner01, TestSize.Level0)
816 {
817 SessionInfo info;
818 info.bundleName_ = "ConnectInner01";
819 info.abilityName_ = "ConnectInner01";
820 info.windowType_ = 1;
821 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
822 EXPECT_NE(sceneSession, nullptr);
823 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
824 ASSERT_NE(mockSessionStage, nullptr);
825 SystemSessionConfig systemConfig;
826 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
827 ASSERT_NE(property, nullptr);
828 sceneSession->clientIdentityToken_ = "session1";
829 sceneSession->SetCollaboratorType(static_cast<int32_t>(CollaboratorType::RESERVE_TYPE));
830 auto result = sceneSession->ConnectInner(
831 mockSessionStage, nullptr, nullptr, systemConfig, property, nullptr, -1, -1, "session2");
832 ASSERT_EQ(result, WSError::WS_OK);
833
834 result = sceneSession->ConnectInner(
835 mockSessionStage, nullptr, nullptr, systemConfig, property, nullptr, -1, -1, "session1");
836 ASSERT_EQ(result, WSError::WS_OK);
837
838 result = sceneSession->ConnectInner(mockSessionStage, nullptr, nullptr, systemConfig, property, nullptr, -1, -1);
839 ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
840 EXPECT_EQ(property->GetAncoRealBundleName(), "ConnectInner01");
841 }
842
843 /**
844 * @tc.name: ConnectInner02
845 * @tc.desc: ConnectInner02
846 * @tc.type: FUNC
847 */
848 HWTEST_F(SceneSessionLifecycleTest, ConnectInner02, TestSize.Level0)
849 {
850 SessionInfo info;
851 info.bundleName_ = "ConnectInner02";
852 info.abilityName_ = "ConnectInner02";
853
854 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
855 EXPECT_NE(sceneSession, nullptr);
856 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
857 ASSERT_NE(mockSessionStage, nullptr);
858 SystemSessionConfig systemConfig;
859 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
860 ASSERT_NE(property, nullptr);
861 sceneSession->SetSessionState(SessionState::STATE_CONNECT);
862 sceneSession->Session::isTerminating_ = false;
863 auto result = sceneSession->ConnectInner(mockSessionStage, nullptr, nullptr, systemConfig, property, nullptr);
864 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_SESSION);
865
866 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(mockSessionStage);
867 ASSERT_NE(eventChannel, nullptr);
868 sceneSession->SetSessionState(SessionState::STATE_DISCONNECT);
869 result = sceneSession->ConnectInner(mockSessionStage, eventChannel, nullptr, systemConfig, property, nullptr);
870 ASSERT_EQ(result, WSError::WS_OK);
871 }
872
873 /**
874 * @tc.name: Reconnect
875 * @tc.desc: Reconnect
876 * @tc.type: FUNC
877 */
878 HWTEST_F(SceneSessionLifecycleTest, Reconnect, TestSize.Level0)
879 {
880 SessionInfo info;
881 info.bundleName_ = "Reconnect";
882 info.abilityName_ = "Reconnect1";
883 info.windowType_ = 1;
884 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
885 EXPECT_NE(sceneSession, nullptr);
886
887 sptr<ISessionStage> sessionStage = nullptr;
888 sptr<IWindowEventChannel> eventChannel = nullptr;
889 std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
890 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
891 sptr<IRemoteObject> token;
892 int32_t pid = -1;
893 int32_t uid = -1;
894 WSError res = sceneSession->Reconnect(sessionStage, eventChannel, surfaceNode, property, token, pid, uid);
895 ASSERT_EQ(res, WSError::WS_ERROR_NULLPTR);
896
897 property->windowState_ = WindowState::STATE_SHOWN;
898 sessionStage = sptr<SessionStageMocker>::MakeSptr();
899 eventChannel = sptr<TestWindowEventChannel>::MakeSptr();
900 res = sceneSession->Reconnect(sessionStage, eventChannel, surfaceNode, property);
901 ASSERT_EQ(res, WSError::WS_OK);
902 }
903
904 /**
905 * @tc.name: ReconnectInner
906 * @tc.desc: ReconnectInner
907 * @tc.type: FUNC
908 */
909 HWTEST_F(SceneSessionLifecycleTest, ReconnectInner, TestSize.Level0)
910 {
911 SessionInfo info;
912 info.bundleName_ = "ReconnectInner";
913 info.abilityName_ = "ReconnectInner1";
914 info.windowType_ = 1;
915 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
916 EXPECT_NE(sceneSession, nullptr);
917
918 sptr<WindowSessionProperty> property = nullptr;
919 WSError res = sceneSession->ReconnectInner(property);
920 ASSERT_EQ(res, WSError::WS_ERROR_NULLPTR);
921
922 property = sptr<WindowSessionProperty>::MakeSptr();
923 property->windowState_ = WindowState::STATE_INITIAL;
924 res = sceneSession->ReconnectInner(property);
925 ASSERT_EQ(res, WSError::WS_ERROR_INVALID_PARAM);
926
927 property->windowState_ = WindowState::STATE_CREATED;
928 res = sceneSession->ReconnectInner(property);
929 ASSERT_EQ(res, WSError::WS_OK);
930
931 property->windowState_ = WindowState::STATE_SHOWN;
932 res = sceneSession->ReconnectInner(property);
933 ASSERT_EQ(res, WSError::WS_OK);
934
935 property->windowState_ = WindowState::STATE_HIDDEN;
936 res = sceneSession->ReconnectInner(property);
937 ASSERT_EQ(res, WSError::WS_OK);
938
939 property->windowState_ = WindowState::STATE_DESTROYED;
940 res = sceneSession->ReconnectInner(property);
941 ASSERT_EQ(res, WSError::WS_ERROR_INVALID_PARAM);
942
943 property->windowState_ = WindowState::STATE_SHOWN;
944 sceneSession->pcFoldScreenController_ = nullptr;
945 res = sceneSession->ReconnectInner(property);
946 ASSERT_EQ(res, WSError::WS_OK);
947 }
948
949 /**
950 * @tc.name: PendingSessionActivation
951 * @tc.desc: normal function
952 * @tc.type: FUNC
953 */
954 HWTEST_F(SceneSessionLifecycleTest, PendingSessionActivation, TestSize.Level0)
955 {
956 SessionInfo info;
957 info.abilityName_ = "PendingSessionActivation";
958 info.bundleName_ = "PendingSessionActivation";
959 sptr<Rosen::ISession> session_;
960 sptr<SceneSession::SpecificSessionCallback> specificCallback =
961 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
962 EXPECT_NE(specificCallback, nullptr);
963 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
964 EXPECT_NE(sceneSession, nullptr);
965 sceneSession->isActive_ = true;
966
967 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
968 property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
969 property->keyboardLayoutParams_.gravity_ = WindowGravity::WINDOW_GRAVITY_BOTTOM;
970 sceneSession->SetSessionProperty(property);
971
972 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
973
974 sptr<AAFwk::SessionInfo> info1 = nullptr;
975 WSError result = sceneSession->PendingSessionActivation(info1);
976 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
977
978 result = sceneSession->PendingSessionActivation(abilitySessionInfo);
979 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
980
981 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
982 sceneSession->SetSessionState(SessionState::STATE_FOREGROUND);
983 sceneSession->SetForegroundInteractiveStatus(false);
984 result = sceneSession->PendingSessionActivation(abilitySessionInfo);
985 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
986
987 property->SetWindowType(WindowType::WINDOW_TYPE_APP_MAIN_WINDOW);
988 sceneSession->SetSessionState(SessionState::STATE_BACKGROUND);
989 abilitySessionInfo->canStartAbilityFromBackground = false;
990 result = sceneSession->PendingSessionActivation(abilitySessionInfo);
991 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
992 }
993
994 /**
995 * @tc.name: PendingSessionActivation02
996 * @tc.desc: normal function
997 * @tc.type: FUNC
998 */
999 HWTEST_F(SceneSessionLifecycleTest, PendingSessionActivation02, TestSize.Level1)
1000 {
1001 SessionInfo info;
1002 info.abilityName_ = "PendingSessionActivation";
1003 info.bundleName_ = "PendingSessionActivation";
1004 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1005 EXPECT_NE(sceneSession, nullptr);
1006 sceneSession->isActive_ = true;
1007 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
1008 abilitySessionInfo->reuseDelegatorWindow = true;
1009 auto result = sceneSession->PendingSessionActivation(abilitySessionInfo);
1010 ASSERT_EQ(result, WSError::WS_ERROR_INVALID_PERMISSION);
1011 }
1012
1013 /**
1014 * @tc.name: TerminateSession
1015 * @tc.desc: normal function
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(SceneSessionLifecycleTest, TerminateSession, TestSize.Level0)
1019 {
1020 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
1021 ASSERT_NE(nullptr, abilitySessionInfo);
1022 OHOS::Rosen::Session session(info);
1023 session.isTerminating_ = true;
1024 sceneSession->TerminateSession(abilitySessionInfo);
1025
1026 ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1027
1028 NotifyTerminateSessionFuncNew callback = [](const SessionInfo& info, bool needStartCaller,
__anon9a8c955b0602(const SessionInfo& info, bool needStartCaller, bool isFromBroker, bool isForceClean) 1029 bool isFromBroker, bool isForceClean) {};
1030 session.isTerminating_ = false;
1031 ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1032
1033 sptr<AAFwk::SessionInfo> info1 = nullptr;
1034 ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(info1));
1035 sceneSession->isTerminating_ = true;
1036 ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1037 sceneSession->isTerminating_ = false;
1038 ASSERT_EQ(WSError::WS_OK, sceneSession->TerminateSession(abilitySessionInfo));
1039 }
1040
1041 /**
1042 * @tc.name: NotifySessionException01
1043 * @tc.desc: normal function
1044 * @tc.type: FUNC
1045 */
1046 HWTEST_F(SceneSessionLifecycleTest, NotifySessionException01, TestSize.Level0)
1047 {
1048 sptr<AAFwk::SessionInfo> abilitySessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
1049 ASSERT_NE(nullptr, abilitySessionInfo);
1050 OHOS::Rosen::Session session(info);
1051 session.isTerminating_ = true;
1052 ExceptionInfo exceptionInfo;
1053 WSError ret = sceneSession->NotifySessionException(abilitySessionInfo, exceptionInfo);
1054 ASSERT_EQ(WSError::WS_ERROR_INVALID_PERMISSION, ret);
1055 }
1056
1057 /**
1058 * @tc.name: NotifySessionForeground01
1059 * @tc.desc: NotifySessionForeground
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(SceneSessionLifecycleTest, NotifySessionForeground, TestSize.Level0)
1063 {
1064 SessionInfo info;
1065 info.abilityName_ = "Foreground01";
1066 info.bundleName_ = "IsFloatingWindowAppType";
1067 info.windowType_ = 1;
1068 sptr<Rosen::ISession> session_;
1069 sptr<SceneSession::SpecificSessionCallback> specificCallback =
1070 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1071 EXPECT_NE(specificCallback, nullptr);
1072 sptr<SceneSession> sceneSession;
1073 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1074 EXPECT_NE(sceneSession, nullptr);
1075 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
1076 ASSERT_NE(mockSessionStage, nullptr);
1077 uint32_t reason = 1;
1078 bool withAnimation = true;
1079 int ret = 1;
1080
1081 sceneSession->sessionStage_ = mockSessionStage;
1082 sceneSession->NotifySessionForeground(reason, withAnimation);
1083 ASSERT_EQ(ret, 1);
1084 }
1085
1086 /**
1087 * @tc.name: NotifySessionFullScreen01
1088 * @tc.desc: NotifySessionFullScreen
1089 * @tc.type: FUNC
1090 */
1091 HWTEST_F(SceneSessionLifecycleTest, NotifySessionFullScreen, TestSize.Level0)
1092 {
1093 SessionInfo info;
1094 info.abilityName_ = "FullScreen01";
1095 info.bundleName_ = "IsFloatingWindowAppType";
1096 info.windowType_ = 1;
1097 sptr<SceneSession::SpecificSessionCallback> specificCallback =
1098 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1099 EXPECT_NE(specificCallback, nullptr);
1100 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1101 EXPECT_NE(sceneSession, nullptr);
1102 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
1103 ASSERT_NE(mockSessionStage, nullptr);
1104 bool fullScreen = true;
1105 int ret = 1;
1106 sceneSession->sessionStage_ = mockSessionStage;
1107 sceneSession->NotifySessionFullScreen(fullScreen);
1108 ASSERT_EQ(ret, 1);
1109 sceneSession->sessionStage_ = nullptr;
1110 sceneSession->NotifySessionFullScreen(fullScreen);
1111 }
1112
1113 /**
1114 * @tc.name: NotifySessionBackground01
1115 * @tc.desc: NotifySessionBackground
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(SceneSessionLifecycleTest, NotifySessionBackground, TestSize.Level0)
1119 {
1120 SessionInfo info;
1121 info.abilityName_ = "Background01";
1122 info.bundleName_ = "IsFloatingWindowAppType";
1123 info.windowType_ = 1;
1124 sptr<Rosen::ISession> session_;
1125 sptr<SceneSession::SpecificSessionCallback> specificCallback =
1126 sptr<SceneSession::SpecificSessionCallback>::MakeSptr();
1127 EXPECT_NE(specificCallback, nullptr);
1128 sptr<SceneSession> sceneSession;
1129 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1130 EXPECT_NE(sceneSession, nullptr);
1131 sptr<SessionStageMocker> mockSessionStage = sptr<SessionStageMocker>::MakeSptr();
1132 ASSERT_NE(mockSessionStage, nullptr);
1133 uint32_t reason = 1;
1134 bool withAnimation = true;
1135 bool isFromInnerkits = true;
1136 int ret = 1;
1137
1138 sceneSession->sessionStage_ = mockSessionStage;
1139 sceneSession->NotifySessionBackground(reason, withAnimation, isFromInnerkits);
1140 ASSERT_EQ(ret, 1);
1141 }
1142
1143 /**
1144 * @tc.name: BatchPendingSessionsActivation
1145 * @tc.desc: BatchPendingSessionsActivation, with atomicService
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(SceneSessionLifecycleTest, BatchPendingSessionsActivation, TestSize.Level0)
1149 {
1150 SessionInfo info;
1151 info.abilityName_ = "BatchPendingSessionsActivation";
1152 info.bundleName_ = "BatchPendingSessionsActivation";
1153 sptr<SceneSession> sceneSession;
1154 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1155 ASSERT_NE(sceneSession, nullptr);
1156 sceneSession->isActive_ = true;
1157 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1158 property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
1159 sceneSession->SetSessionProperty(property);
1160
1161 sptr<AAFwk::SessionInfo> sessionInfo = sptr<AAFwk::SessionInfo>::MakeSptr();
1162 std::vector<sptr<AAFwk::SessionInfo>> abilitySessionInfos;
1163 unsigned int flags = 11111111;
1164 AAFwk::Want want;
1165 sessionInfo->want = want;
1166 sessionInfo->want.SetFlags(flags);
1167 sessionInfo->isAtomicService = true;
1168 abilitySessionInfos.emplace_back(sessionInfo);
1169 WSError result = sceneSession->BatchPendingSessionsActivation(abilitySessionInfos);
1170
1171 EXPECT_EQ(result, WSError::WS_OK);
1172 }
1173
1174 /**
1175 * @tc.name: CalculatedStartWindowType01
1176 * @tc.desc: CalculatedStartWindowType when getStartWindowConfigFunc_ is null.
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(SceneSessionLifecycleTest, CalculatedStartWindowType01, TestSize.Level0)
1180 {
1181 SessionInfo info;
1182 info.abilityName_ = "CalculatedStartWindowType01";
1183 info.bundleName_ = "CalculatedStartWindowType01";
1184 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1185 ASSERT_NE(sceneSession, nullptr);
1186 SessionInfo info2;
1187
1188 sceneSession->CalculatedStartWindowType(info2, false);
1189 EXPECT_EQ(info2.startWindowType_, StartWindowType::DEFAULT);
1190 }
1191
1192 /**
1193 * @tc.name: CalculatedStartWindowType02
1194 * @tc.desc: CalculatedStartWindowType when hideStartWindow is true
1195 * @tc.type: FUNC
1196 */
1197 HWTEST_F(SceneSessionLifecycleTest, CalculatedStartWindowType02, TestSize.Level0)
1198 {
1199 SessionInfo info;
1200 info.abilityName_ = "CalculatedStartWindowType02";
1201 info.bundleName_ = "CalculatedStartWindowType02";
1202 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1203 ASSERT_NE(sceneSession, nullptr);
__anon9a8c955b0702(SessionInfo sessionInfo, std::string& startWindowType) 1204 sceneSession->getStartWindowConfigFunc_ = [](SessionInfo sessionInfo, std::string& startWindowType) {
1205 startWindowType = "OPTIONAL_SHOW";
1206 };
1207 SessionInfo info2;
1208
1209 sceneSession->CalculatedStartWindowType(info2, true);
1210 EXPECT_EQ(info2.startWindowType_, StartWindowType::RETAIN_AND_INVISIBLE);
1211 }
1212
1213 /**
1214 * @tc.name: CalculatedStartWindowType03
1215 * @tc.desc: CalculatedStartWindowType when hideStartWindow is false
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(SceneSessionLifecycleTest, CalculatedStartWindowType03, TestSize.Level0)
1219 {
1220 SessionInfo info;
1221 info.abilityName_ = "CalculatedStartWindowType03";
1222 info.bundleName_ = "CalculatedStartWindowType03";
1223 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1224 ASSERT_NE(sceneSession, nullptr);
__anon9a8c955b0802(SessionInfo sessionInfo, std::string& startWindowType) 1225 sceneSession->getStartWindowConfigFunc_ = [](SessionInfo sessionInfo, std::string& startWindowType) {
1226 startWindowType = "OPTIONAL_SHOW";
1227 };
1228 SessionInfo info2;
1229
1230 sceneSession->CalculatedStartWindowType(info2, false);
1231 EXPECT_EQ(info2.startWindowType_, StartWindowType::DEFAULT);
1232 }
1233
1234 /**
1235 * @tc.name: CalculatedStartWindowType04
1236 * @tc.desc: CalculatedStartWindowType when startWindowType is not optional
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(SceneSessionLifecycleTest, CalculatedStartWindowType04, TestSize.Level0)
1240 {
1241 SessionInfo info;
1242 info.abilityName_ = "CalculatedStartWindowType04";
1243 info.bundleName_ = "CalculatedStartWindowType04";
1244 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1245 ASSERT_NE(sceneSession, nullptr);
__anon9a8c955b0902(SessionInfo sessionInfo, std::string& startWindowType) 1246 sceneSession->getStartWindowConfigFunc_ = [](SessionInfo sessionInfo, std::string& startWindowType) {
1247 startWindowType = "REQUIRED_HIDE";
1248 };
1249 SessionInfo info2;
1250
1251 sceneSession->CalculatedStartWindowType(info2, false);
1252 EXPECT_EQ(info2.startWindowType_, StartWindowType::DEFAULT);
1253 }
1254 } // namespace
1255 } // namespace Rosen
1256 } // namespace OHOS