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