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 <gtest/gtest.h>
17 #include <regex>
18 #include <bundle_mgr_interface.h>
19 #include <bundlemgr/launcher_service.h>
20 #include "interfaces/include/ws_common.h"
21 #include "screen_fold_data.h"
22 #include "session_manager/include/scene_session_manager.h"
23 #include "session_info.h"
24 #include "session/host/include/scene_session.h"
25 #include "session/host/include/main_session.h"
26 #include "window_manager_agent.h"
27 #include "session_manager.h"
28 #include "zidl/window_manager_agent_interface.h"
29 #include "mock/mock_session_stage.h"
30 #include "mock/mock_window_event_channel.h"
31 #include "application_info.h"
32 #include "context.h"
33 
34 using namespace testing;
35 using namespace testing::ext;
36 
37 namespace OHOS {
38 namespace Rosen {
39 namespace {
40 const std::string EMPTY_DEVICE_ID = "";
41 }
42 class SceneSessionManagerLifecycleTest : public testing::Test {
43 public:
44     static void SetUpTestCase();
45 
46     static void TearDownTestCase();
47 
48     void SetUp() override;
49 
50     void TearDown() override;
51 
52     static void SetVisibleForAccessibility(sptr<SceneSession>& sceneSession);
53     int32_t GetTaskCount(sptr<SceneSession>& session);
54     static sptr<SceneSessionManager> ssm_;
55 private:
56     static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
57 };
58 
59 sptr<SceneSessionManager> SceneSessionManagerLifecycleTest::ssm_ = nullptr;
60 
WindowChangedFuncTest(int32_t persistentId,WindowUpdateType type)61 void WindowChangedFuncTest(int32_t persistentId, WindowUpdateType type)
62 {
63 }
64 
ProcessStatusBarEnabledChangeFuncTest(bool enable)65 void ProcessStatusBarEnabledChangeFuncTest(bool enable)
66 {
67 }
68 
DumpRootSceneElementInfoFuncTest(const std::vector<std::string> & params,std::vector<std::string> & infos)69 void DumpRootSceneElementInfoFuncTest(const std::vector<std::string>& params, std::vector<std::string>& infos)
70 {
71 }
72 
SetUpTestCase()73 void SceneSessionManagerLifecycleTest::SetUpTestCase()
74 {
75     ssm_ = &SceneSessionManager::GetInstance();
76 }
77 
TearDownTestCase()78 void SceneSessionManagerLifecycleTest::TearDownTestCase()
79 {
80     ssm_ = nullptr;
81 }
82 
SetUp()83 void SceneSessionManagerLifecycleTest::SetUp()
84 {
85     ssm_->sceneSessionMap_.clear();
86 }
87 
TearDown()88 void SceneSessionManagerLifecycleTest::TearDown()
89 {
90     usleep(WAIT_SYNC_IN_NS);
91     ssm_->sceneSessionMap_.clear();
92 }
93 
SetVisibleForAccessibility(sptr<SceneSession> & sceneSession)94 void SceneSessionManagerLifecycleTest::SetVisibleForAccessibility(sptr<SceneSession>& sceneSession)
95 {
96     sceneSession->SetTouchable(true);
97     sceneSession->forceTouchable_ = true;
98     sceneSession->systemTouchable_ = true;
99     sceneSession->state_ = SessionState::STATE_FOREGROUND;
100     sceneSession->foregroundInteractiveStatus_.store(true);
101 }
102 
GetTaskCount(sptr<SceneSession> & session)103 int32_t SceneSessionManagerLifecycleTest::GetTaskCount(sptr<SceneSession>& session)
104 {
105     std::string dumpInfo = session->handler_->GetEventRunner()->GetEventQueue()->DumpCurrentQueueSize();
106     std::regex pattern("\\d+");
107     std::smatch matches;
108     int32_t taskNum = 0;
109     while (std::regex_search(dumpInfo, matches, pattern)) {
110         taskNum += std::stoi(matches.str());
111         dumpInfo = matches.suffix();
112     }
113     return taskNum;
114 }
115 
116 namespace {
117 /**
118  * @tc.name: NotifySessionForeground
119  * @tc.desc: SceneSesionManager NotifySessionForeground
120  * @tc.type: FUNC
121 */
122 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionForeground, Function | SmallTest | Level3)
123 {
124     sptr<SceneSession> scensession = nullptr;
125     SessionInfo info;
126     info.bundleName_ = "bundleName";
127     scensession = new (std::nothrow) SceneSession(info, nullptr);
128     ASSERT_NE(nullptr, scensession);
129     uint32_t reason = 1;
130     bool withAnimation = true;
131     scensession->NotifySessionForeground(reason, withAnimation);
132 }
133 
134 /**
135  * @tc.name: NotifySessionForeground
136  * @tc.desc: SceneSesionManager NotifySessionForeground
137  * @tc.type: FUNC
138 */
139 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionBackground, Function | SmallTest | Level3)
140 {
141     sptr<SceneSession> scensession = nullptr;
142     SessionInfo info;
143     info.bundleName_ = "bundleName";
144     scensession = new (std::nothrow) SceneSession(info, nullptr);
145     ASSERT_NE(nullptr, scensession);
146     uint32_t reason = 1;
147     bool withAnimation = true;
148     bool isFromInnerkits = true;
149     scensession->NotifySessionBackground(reason, withAnimation, isFromInnerkits);
150 }
151 
152 /**
153  * @tc.name: ClearUnrecoveredSessions
154  * @tc.desc: test func ClearUnrecoveredSessions
155  * @tc.type: FUNC
156  */
157 HWTEST_F(SceneSessionManagerLifecycleTest, ClearUnrecoveredSessions, Function | SmallTest | Level1)
158 {
159     ssm_->alivePersistentIds_.push_back(23);
160     ssm_->alivePersistentIds_.push_back(24);
161     ssm_->alivePersistentIds_.push_back(25);
162     EXPECT_FALSE(ssm_->alivePersistentIds_.empty());
163     std::vector<int32_t> recoveredPersistentIds;
164     recoveredPersistentIds.push_back(23);
165     recoveredPersistentIds.push_back(24);
166     ssm_->ClearUnrecoveredSessions(recoveredPersistentIds);
167 }
168 
169 /**
170  * @tc.name: RecoverSessionInfo
171  * @tc.desc: test func RecoverSessionInfo
172  * @tc.type: FUNC
173  */
174 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverSessionInfo, Function | SmallTest | Level1)
175 {
176     SessionInfo info = ssm_->RecoverSessionInfo(nullptr);
177 
178     sptr<WindowSessionProperty> property = new WindowSessionProperty();
179     ASSERT_NE(nullptr, property);
180     info = ssm_->RecoverSessionInfo(property);
181 }
182 
183 /**
184  * @tc.name: NotifySessionMovedToFront
185  * @tc.desc: Test if pip window can be created;
186  * @tc.type: FUNC
187 */
188 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionMovedToFront, Function | SmallTest | Level3)
189 {
190     ASSERT_NE(nullptr, ssm_);
191     ssm_->NotifySessionMovedToFront(0);
192 
193     SessionInfo info;
194     info.abilityName_ = "BackgroundTask02";
195     info.bundleName_ = "BackgroundTask02";
196     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
197     ssm_->sceneSessionMap_.insert({100, sceneSession});
198     ssm_->NotifySessionMovedToFront(100);
199 }
200 
201 /**
202  * @tc.name: PendingSessionToBackgroundForDelegator
203  * @tc.desc: Test if pip window can be created;
204  * @tc.type: FUNC
205 */
206 HWTEST_F(SceneSessionManagerLifecycleTest, PendingSessionToBackgroundForDelegator, Function | SmallTest | Level3)
207 {
208     WSError ret;
209     ret = ssm_->PendingSessionToBackgroundForDelegator(nullptr, true);
210     ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
211 
212     SessionInfo info;
213     info.abilityName_ = "BackgroundTask02";
214     info.bundleName_ = "BackgroundTask02";
215     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
216     ssm_->sceneSessionMap_.insert({100, sceneSession});
217     ret = ssm_->PendingSessionToBackgroundForDelegator(nullptr, true);
218     ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, ret);
219 }
220 
221 /**
222  * @tc.name: OnSessionStateChange
223  * @tc.desc: Test if pip window can be created;
224  * @tc.type: FUNC
225 */
226 HWTEST_F(SceneSessionManagerLifecycleTest, OnSessionStateChange, Function | SmallTest | Level3)
227 {
228     ssm_->sceneSessionMap_.clear();
229     ssm_->OnSessionStateChange(100, SessionState::STATE_END);
230     SessionInfo info;
231     info.abilityName_ = "BackgroundTask02";
232     info.bundleName_ = "BackgroundTask02";
233     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
234     ASSERT_NE(nullptr, sceneSession);
235     ssm_->sceneSessionMap_.insert({100, sceneSession});
236     ssm_->OnSessionStateChange(100, SessionState::STATE_END);
237     ssm_->OnSessionStateChange(100, SessionState::STATE_FOREGROUND);
238     ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
239     sceneSession->focusedOnShow_ = false;
240     ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
241     ssm_->OnSessionStateChange(100, SessionState::STATE_BACKGROUND);
242     ssm_->OnSessionStateChange(0, SessionState::STATE_BACKGROUND);
243 
244     sptr<WindowSessionProperty> property_ = new WindowSessionProperty();
245     ASSERT_NE(nullptr, property_);
246     property_->type_ = WindowType::APP_MAIN_WINDOW_END;
247     sceneSession->property_ = property_;
248     ssm_->OnSessionStateChange(100, SessionState::STATE_END);
249     ssm_->OnSessionStateChange(100, SessionState::STATE_FOREGROUND);
250     ssm_->OnSessionStateChange(0, SessionState::STATE_FOREGROUND);
251     ssm_->OnSessionStateChange(100, SessionState::STATE_BACKGROUND);
252     ssm_->OnSessionStateChange(0, SessionState::STATE_BACKGROUND);
253     ASSERT_NE(nullptr, ssm_);
254 }
255 
256 /**
257  * @tc.name: RecoverAndReconnectSceneSession
258  * @tc.desc: check func RecoverAndReconnectSceneSession
259  * @tc.type: FUNC
260  */
261 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
262 {
263     sptr<ISession> session;
264     auto result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, nullptr, nullptr);
265     ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
266 
267     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
268     ASSERT_NE(nullptr, property);
269     std::vector<int32_t> recoveredPersistentIds = { 0, 1, 2 };
270     ssm_->SetAlivePersistentIds(recoveredPersistentIds);
271     property->SetPersistentId(1);
272     result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
273     ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
274 }
275 
276 /**
277  * @tc.name: RecoverAndReconnectSceneSession
278  * @tc.desc: check func RecoverAndReconnectSceneSession
279  * @tc.type: FUNC
280  */
281 HWTEST_F(SceneSessionManagerLifecycleTest, RecoverAndReconnectSceneSession02, Function | SmallTest | Level2)
282 {
283     sptr<ISession> session;
284     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
285     ASSERT_NE(nullptr, property);
286     std::vector<int32_t> recoveredPersistentIds = {0, 1, 2};
287     ssm_->SetAlivePersistentIds(recoveredPersistentIds);
288     property->SetPersistentId(1);
289     ProcessShiftFocusFunc shiftFocusFunc_;
290     auto result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
291     property->SetWindowType(WindowType::APP_MAIN_WINDOW_BASE);
292     result = ssm_->RecoverAndReconnectSceneSession(nullptr, nullptr, nullptr, session, property, nullptr);
293     ASSERT_EQ(result, WSError::WS_ERROR_NULLPTR);
294 }
295 
296 /**
297  * @tc.name: CreateSceneSession
298  * @tc.desc: CreateSceneSession
299  * @tc.type: FUNC
300 */
301 HWTEST_F(SceneSessionManagerLifecycleTest, CreateSceneSession, Function | SmallTest | Level3)
302 {
303     int ret = 0;
304     SessionInfo info;
305     ssm_->CreateSceneSession(info, nullptr);
306     info.isSystem_ = true;
307     info.windowType_ = 3000;
308     ssm_->CreateSceneSession(info, nullptr);
309     info.windowType_ = 3;
310     ssm_->CreateSceneSession(info, nullptr);
311     sptr<WindowSessionProperty> property = new (std::nothrow) WindowSessionProperty();
312     ASSERT_NE(nullptr, property);
313     ssm_->CreateSceneSession(info, property);
314     property->SetWindowType(WindowType::WINDOW_TYPE_APP_SUB_WINDOW);
315     ssm_->CreateSceneSession(info, property);
316     property->SetWindowType(WindowType::WINDOW_TYPE_INPUT_METHOD_FLOAT);
317     ssm_->CreateSceneSession(info, property);
318     property->SetWindowType(WindowType::SYSTEM_SUB_WINDOW_BASE);
319     ssm_->CreateSceneSession(info, property);
320     ssm_->NotifySessionUpdate(info, ActionType::SINGLE_START, 0);
321     info.persistentId_ = 0;
322     ssm_->UpdateSceneSessionWant(info);
323     info.persistentId_ = 1;
324     ssm_->UpdateSceneSessionWant(info);
325     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, nullptr);
326     ASSERT_NE(nullptr, sceneSession);
327     ssm_->sceneSessionMap_.insert({1, sceneSession});
328     ssm_->UpdateSceneSessionWant(info);
329     std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
330     ASSERT_NE(nullptr, want);
331     info.want = want;
332     ssm_->UpdateSceneSessionWant(info);
333     sceneSession->SetCollaboratorType(0);
334     ssm_->UpdateSceneSessionWant(info);
335     sceneSession->SetCollaboratorType(1);
336     ssm_->UpdateSceneSessionWant(info);
337     ssm_->sceneSessionMap_.erase(1);
338     sptr<SceneSession> sceneSession1;
339     ssm_->UpdateCollaboratorSessionWant(sceneSession1, 1);
340     ssm_->UpdateCollaboratorSessionWant(sceneSession, 1);
341     SessionInfo info1;
342     info1.ancoSceneState = 0;
343     sceneSession1 = new (std::nothrow) SceneSession(info1, nullptr);
344     ASSERT_NE(nullptr, sceneSession1);
345     ssm_->UpdateCollaboratorSessionWant(sceneSession1, 1);
346     ASSERT_EQ(ret, 0);
347 }
348 
349 /**
350  * @tc.name: RequestSceneSessionBackground
351  * @tc.desc: RequestSceneSessionBackground
352  * @tc.type: FUNC
353 */
354 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground, Function | SmallTest | Level3)
355 {
356     int ret = 0;
357     sptr<SceneSession> sceneSession;
358     ssm_->RequestSceneSessionActivation(sceneSession, true);
359     SessionInfo info;
360     ret++;
361     sptr<AAFwk::SessionInfo> abilitySessionInfo;
362     ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
363     ssm_->RequestSceneSessionBackground(sceneSession, true, false);
364     ssm_->RequestSceneSessionBackground(sceneSession, true, true);
365     ssm_->RequestSceneSessionBackground(sceneSession, false, true);
366     ssm_->RequestSceneSessionBackground(sceneSession, false, false);
367     ssm_->NotifyForegroundInteractiveStatus(sceneSession, true);
368     ssm_->NotifyForegroundInteractiveStatus(sceneSession, false);
369     ssm_->DestroyDialogWithMainWindow(sceneSession);
370     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
371     ASSERT_NE(nullptr, sceneSession);
372     ssm_->RequestSceneSessionBackground(sceneSession, true, false);
373     ssm_->RequestSceneSessionBackground(sceneSession, true, true);
374     ssm_->RequestSceneSessionBackground(sceneSession, false, true);
375     ssm_->RequestSceneSessionBackground(sceneSession, false, false);
376     ssm_->NotifyForegroundInteractiveStatus(sceneSession, true);
377     ssm_->NotifyForegroundInteractiveStatus(sceneSession, false);
378     ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
379     ssm_->DestroyDialogWithMainWindow(sceneSession);
380     ssm_->DestroySubSession(sceneSession);
381     ssm_->SetAbilitySessionInfo(sceneSession);
382     ssm_->RequestSceneSessionActivation(sceneSession, true);
383     ssm_->RequestInputMethodCloseKeyboard(1);
384     ssm_->sceneSessionMap_.insert({1, nullptr});
385     ssm_->RequestInputMethodCloseKeyboard(1);
386     ssm_->RequestSceneSessionActivation(sceneSession, true);
387     ssm_->RequestSceneSessionActivation(sceneSession, false);
388     ssm_->StartUIAbilityBySCB(sceneSession);
389     ssm_->RequestSceneSessionActivation(sceneSession, true);
390     abilitySessionInfo = new (std::nothrow) AAFwk::SessionInfo();
391     ASSERT_NE(nullptr, abilitySessionInfo);
392     ssm_->NotifyCollaboratorAfterStart(sceneSession, abilitySessionInfo);
393     ssm_->DestroySubSession(sceneSession);
394     ssm_->EraseSceneSessionMapById(2);
395     ASSERT_EQ(ret, 1);
396 }
397 
398 /**
399  * @tc.name: RequestSceneSessionDestruction
400  * @tc.desc: RequestSceneSessionDestruction
401  * @tc.type: FUNC
402 */
403 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction, Function | SmallTest | Level3)
404 {
405     int ret = 0;
406     SessionInfo info;
407     info.abilityName_ = "111";
408     info.bundleName_ = "222";
409     sptr<SceneSession> sceneSession;
410     sptr<ISessionStage> sessionStage;
411     ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
412     ssm_->RequestSceneSessionDestruction(sceneSession, true);
413     ssm_->RequestSceneSessionDestruction(sceneSession, false);
414     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
415     ASSERT_NE(nullptr, sceneSession);
416     ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
417     ssm_->RequestSceneSessionDestruction(sceneSession, true);
418     ssm_->RequestSceneSessionDestruction(sceneSession, false);
419     ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
420     ssm_->RequestSceneSessionDestruction(sceneSession, true);
421     ssm_->RequestSceneSessionDestruction(sceneSession, false);
422     ssm_->sceneSessionMap_.erase(sceneSession->GetPersistentId());
423     sptr<AAFwk::SessionInfo> scnSessionInfo = new (std::nothrow) AAFwk::SessionInfo();
424     ASSERT_NE(nullptr, scnSessionInfo);
425     ssm_->RequestSceneSessionDestructionInner(sceneSession, scnSessionInfo, true);
426     ssm_->RequestSceneSessionDestructionInner(sceneSession, scnSessionInfo, false);
427     std::shared_ptr<SessionListenerController> listenerController =
428         std::make_shared<SessionListenerController>();
429     ASSERT_NE(nullptr, listenerController);
430     ssm_->listenerController_ = listenerController;
431     ssm_->RequestSceneSessionDestructionInner(sceneSession, scnSessionInfo, true);
432     ssm_->RequestSceneSessionDestructionInner(sceneSession, scnSessionInfo, false);
433     ssm_->AddClientDeathRecipient(sessionStage, sceneSession);
434     ASSERT_EQ(ret, 0);
435 }
436 
437 /**
438  * @tc.name: RequestSceneSessionBackground002
439  * @tc.desc: SceneSesionManager request scene session background
440  * @tc.type: FUNC
441 */
442 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground002, Function | SmallTest | Level3)
443 {
444     bool isDelegator = false;
445     SessionInfo info;
446     info.abilityName_ = "RequestSceneSessionBackground002";
447     info.bundleName_ = "RequestSceneSessionBackground002";
448     sptr<SceneSession> sceneSession;
449     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
450     ASSERT_NE(nullptr, sceneSession);
451     ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionBackground(sceneSession, isDelegator));
452 }
453 
454 /**
455  * @tc.name: RequestSceneSessionDestruction002
456  * @tc.desc: SceneSesionManager request scene session destruction
457  * @tc.type: FUNC
458 */
459 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction002, Function | SmallTest | Level3)
460 {
461     bool needRemoveSession = false;
462     SessionInfo info;
463     info.abilityName_ = "RequestSceneSessionDestruction002";
464     info.bundleName_ = "RequestSceneSessionDestruction002";
465     sptr<SceneSession> sceneSession;
466     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
467     ASSERT_NE(nullptr, sceneSession);
468     ASSERT_EQ(WSError::WS_OK, ssm_->RequestSceneSessionDestruction(sceneSession, needRemoveSession));
469 }
470 
471 /**
472  * @tc.name: NotifyForegroundInteractiveStatus
473  * @tc.desc: SceneSesionManager notify scene session interactive status
474  * @tc.type: FUNC
475 */
476 HWTEST_F(SceneSessionManagerLifecycleTest, NotifyForegroundInteractiveStatus, Function | SmallTest | Level3)
477 {
478     bool interactive = false;
479     SessionInfo info;
480     info.abilityName_ = "NotifyForegroundInteractiveStatus";
481     info.bundleName_ = "NotifyForegroundInteractiveStatus";
482     sptr<SceneSession> sceneSession;
483     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
484     ASSERT_NE(nullptr, sceneSession);
485     int ret = 0;
486     ssm_->NotifyForegroundInteractiveStatus(sceneSession, interactive);
487     ASSERT_EQ(ret, 0);
488 }
489 
490 /**
491  * @tc.name: NotifySessionCreate
492  * @tc.desc: SceneSesionManager notify session create
493  * @tc.type: FUNC
494 */
495 HWTEST_F(SceneSessionManagerLifecycleTest, NotifySessionCreate, Function | SmallTest | Level3)
496 {
497     SessionInfo info;
498     info.abilityName_ = "NotifySessionCreate";
499     info.bundleName_ = "NotifySessionCreate";
500     sptr<SceneSession> sceneSession;
501     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
502     ASSERT_NE(nullptr, sceneSession);
503     ssm_->NotifySessionCreate(nullptr, info);
504     EXPECT_EQ(info.want, nullptr);
505     ssm_->NotifySessionCreate(sceneSession, info);
506     info.want = std::make_shared<AAFwk::Want>();
507     sceneSession = nullptr;
508     sceneSession = new (std::nothrow) SceneSession(info, nullptr);
509     ASSERT_NE(nullptr, sceneSession);
510     ssm_->NotifySessionCreate(sceneSession, info);
511     EXPECT_NE(info.want, nullptr);
512     AppExecFwk::AbilityInfo aInfo;
513     sptr<AAFwk::SessionInfo> abilitySessionInfo = new AAFwk::SessionInfo();
514     std::shared_ptr<AppExecFwk::AbilityInfo> abilityInfo =
515         std::make_shared<AppExecFwk::AbilityInfo>(aInfo);
516     ASSERT_NE(nullptr, abilityInfo);
517     int32_t collaboratorType = CollaboratorType::RESERVE_TYPE;
518     ssm_->NotifyLoadAbility(collaboratorType, abilitySessionInfo, abilityInfo);
519 }
520 
521 /**
522  * @tc.name: UpdateRecoveredSessionInfo
523  * @tc.desc: SceneSessionManager load window scene xml
524  * @tc.type: FUNC
525  */
526 HWTEST_F(SceneSessionManagerLifecycleTest, UpdateRecoveredSessionInfo02, Function | SmallTest | Level3)
527 {
528     std::vector<int32_t> recoveredPersistentIds;
529     ASSERT_NE(ssm_, nullptr);
530     ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
531     recoveredPersistentIds.push_back(0);
532     ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
533     SessionInfo info;
534     info.abilityName_ = "test1";
535     info.bundleName_ = "test1";
536     sptr<KeyboardSession::SpecificSessionCallback> specificCallback;
537     sptr<SceneSession> sceneSession = new (std::nothrow) SceneSession(info, specificCallback);
538     ASSERT_NE(sceneSession, nullptr);
539     ssm_->sceneSessionMap_.insert({0, sceneSession});
540     ssm_->UpdateRecoveredSessionInfo(recoveredPersistentIds);
541     constexpr uint32_t WAIT_SYNC_IN_NS = 50000;
542     usleep(WAIT_SYNC_IN_NS);
543 }
544 /**
545  * @tc.name: RequestSceneSession01
546  * @tc.desc: SceneSesionManager test RequestSceneSession
547  * @tc.type: FUNC
548 */
549 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession01, Function | SmallTest | Level3)
550 {
551     SessionInfo info;
552     info.abilityName_ = "RequestSceneSession01";
553     info.bundleName_ = "RequestSceneSession01";
554     info.persistentId_ = 0;
555     auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
556 
557     sptr<SceneSession> sceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
558     ASSERT_EQ(sceneSession, nullptr);
559 }
560 
561 /**
562  * @tc.name: RequestSceneSession02
563  * @tc.desc: SceneSesionManager test RequestSceneSession
564  * @tc.type: FUNC
565 */
566 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession02, Function | SmallTest | Level3)
567 {
568     SessionInfo info;
569     info.abilityName_ = "RequestSceneSession";
570     info.bundleName_ = "RequestSceneSession";
571     info.persistentId_ = 1;
572     info.isPersistentRecover_ = false;
573     auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
574 
575     sptr<SceneSession> sceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
576     ASSERT_EQ(sceneSession, nullptr);
577 }
578 /**
579  * @tc.name: RequestSceneSession03
580  * @tc.desc: SceneSesionManager test RequestSceneSession
581  * @tc.type: FUNC
582 */
583 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession03, Function | SmallTest | Level3)
584 {
585     SessionInfo info;
586     info.abilityName_ = "RequestSceneSession";
587     info.bundleName_ = "RequestSceneSession";
588     info.persistentId_ = 1;
589     info.isPersistentRecover_ = true;
590     auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
591     auto sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
592     ASSERT_NE(sceneSession, nullptr);
593     ssm_->sceneSessionMap_.insert({1, sceneSession});
594 
595     sptr<SceneSession> getSceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
596     ASSERT_EQ(getSceneSession, nullptr);
597 }
598 
599 /**
600  * @tc.name: RequestSceneSession04
601  * @tc.desc: SceneSesionManager test RequestSceneSession
602  * @tc.type: FUNC
603 */
604 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSession04, Function | SmallTest | Level3)
605 {
606     SessionInfo info;
607     info.abilityName_ = "RequestSceneSession";
608     info.bundleName_ = "RequestSceneSession";
609     info.persistentId_ = 1;
610     info.isPersistentRecover_ = true;
611     auto windowSessionProperty = sptr<WindowSessionProperty>::MakeSptr();
612 
613     sptr<SceneSession> sceneSession = ssm_->RequestSceneSession(info, windowSessionProperty);
614     ASSERT_EQ(sceneSession, nullptr);
615 }
616 
617 /**
618  * @tc.name: RequestSceneSessionBackground01
619  * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
620  * @tc.type: FUNC
621 */
622 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground01, Function | SmallTest | Level3)
623 {
624     bool isDelegator = false;
625     bool isToDesktop = false;
626     bool isSaveSnapshot = true;
627     SessionInfo info;
628     info.abilityName_ = "RequestSceneSessionBackground";
629     info.bundleName_ = "RequestSceneSessionBackground";
630     info.persistentId_ = 1;
631     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
632     ASSERT_NE(sceneSession, nullptr);
633     ASSERT_EQ(ssm_->RequestSceneSessionBackground(
634         sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
635 }
636 
637 /**
638  * @tc.name: RequestSceneSessionBackground02
639  * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
640  * @tc.type: FUNC
641 */
642 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground02, Function | SmallTest | Level3)
643 {
644     bool isDelegator = false;
645     bool isToDesktop = true;
646     bool isSaveSnapshot = true;
647     SessionInfo info;
648     info.abilityName_ = "RequestSceneSessionBackground";
649     info.bundleName_ = "RequestSceneSessionBackground";
650     info.persistentId_ = 1;
651     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
652     ASSERT_NE(sceneSession, nullptr);
653     ssm_->sceneSessionMap_.insert({1, sceneSession});
654     ASSERT_EQ(ssm_->RequestSceneSessionBackground(
655         sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
656 }
657 
658 /**
659  * @tc.name: RequestSceneSessionBackground03
660  * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
661  * @tc.type: FUNC
662 */
663 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground03, Function | SmallTest | Level3)
664 {
665     bool isDelegator = false;
666     bool isToDesktop = true;
667     bool isSaveSnapshot = true;
668     SessionInfo info;
669     info.abilityName_ = "RequestSceneSessionBackground";
670     info.bundleName_ = "RequestSceneSessionBackground";
671     info.persistentId_ = 1;
672     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
673     ASSERT_NE(sceneSession, nullptr);
674     ssm_->sceneSessionMap_.insert({1, sceneSession});
675     ssm_->SetBrightness(sceneSession, 0.5);
676     ASSERT_EQ(ssm_->RequestSceneSessionBackground(
677         sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
678 }
679 
680 /**
681  * @tc.name: RequestSceneSessionBackground04
682  * @tc.desc: SceneSesionManager test RequestSceneSessionBackground
683  * @tc.type: FUNC
684 */
685 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionBackground04, Function | SmallTest | Level3)
686 {
687     bool isDelegator = true;
688     bool isToDesktop = true;
689     bool isSaveSnapshot = true;
690     SessionInfo info;
691     info.abilityName_ = "RequestSceneSessionBackground";
692     info.bundleName_ = "RequestSceneSessionBackground";
693     info.persistentId_ = 1;
694     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
695     ASSERT_NE(sceneSession, nullptr);
696     ssm_->sceneSessionMap_.insert({1, sceneSession});
697     ASSERT_EQ(ssm_->RequestSceneSessionBackground(
698         sceneSession, isDelegator, isToDesktop, isSaveSnapshot), WSError::WS_OK);
699 }
700 
701 /**
702  * @tc.name: RequestSceneSessionDestruction01
703  * @tc.desc: SceneSesionManager test RequestSceneSessionDestruction
704  * @tc.type: FUNC
705 */
706 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction01, Function | SmallTest | Level3)
707 {
708     bool needRemoveSession = false;
709     SessionInfo info;
710     info.abilityName_ = "RequestSceneSessionDestruction";
711     info.bundleName_ = "RequestSceneSessionDestruction";
712     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
713     ASSERT_NE(sceneSession, nullptr);
714     ASSERT_EQ(ssm_->RequestSceneSessionDestruction(
715         sceneSession, needRemoveSession), WSError::WS_OK);
716 }
717 /**
718  * @tc.name: RequestSceneSessionDestruction02
719  * @tc.desc: SceneSesionManager test RequestSceneSessionDestruction
720  * @tc.type: FUNC
721 */
722 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionDestruction02, Function | SmallTest | Level3)
723 {
724     bool needRemoveSession = false;
725     SessionInfo info;
726     info.abilityName_ = "RequestSceneSessionDestruction";
727     info.bundleName_ = "RequestSceneSessionDestruction";
728     info.persistentId_ = 1;
729     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
730     ASSERT_NE(sceneSession, nullptr);
731     ssm_->sceneSessionMap_.insert({1, sceneSession});
732     ASSERT_EQ(ssm_->RequestSceneSessionDestruction(
733         sceneSession, needRemoveSession), WSError::WS_OK);
734 }
735 
736 /**
737  * @tc.name: RequestSceneSessionByCall01
738  * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
739  * @tc.type: FUNC
740 */
741 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall01, Function | SmallTest | Level3)
742 {
743     SessionInfo info;
744     info.abilityName_ = "RequestSceneSessionByCall";
745     info.bundleName_ = "RequestSceneSessionByCall";
746     info.persistentId_ = 1;
747     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
748     ASSERT_NE(sceneSession, nullptr);
749     ssm_->sceneSessionMap_.insert({1, sceneSession});
750     ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
751 }
752 /**
753  * @tc.name: RequestSceneSessionByCall02
754  * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
755  * @tc.type: FUNC
756 */
757 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall02, Function | SmallTest | Level3)
758 {
759     SessionInfo info;
760     info.abilityName_ = "RequestSceneSessionByCall";
761     info.bundleName_ = "RequestSceneSessionByCall";
762     info.persistentId_ = 1;
763     info.callState_ = static_cast<uint32_t>(AAFwk::CallToState::BACKGROUND);
764     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
765     ASSERT_NE(sceneSession, nullptr);
766     ssm_->sceneSessionMap_.insert({1, sceneSession});
767     ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
768 }
769 
770 /**
771  * @tc.name: RequestSceneSessionByCall03
772  * @tc.desc: SceneSesionManager test RequestSceneSessionByCall
773  * @tc.type: FUNC
774 */
775 HWTEST_F(SceneSessionManagerLifecycleTest, RequestSceneSessionByCall03, Function | SmallTest | Level3)
776 {
777     SessionInfo info;
778     info.abilityName_ = "RequestSceneSessionByCall";
779     info.bundleName_ = "RequestSceneSessionByCall";
780     info.persistentId_ = 1;
781     info.callState_ = static_cast<uint32_t>(AAFwk::CallToState::FOREGROUND);
782     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
783     ASSERT_NE(sceneSession, nullptr);
784     ssm_->sceneSessionMap_.insert({1, sceneSession});
785     ASSERT_EQ(ssm_->RequestSceneSessionByCall(sceneSession), WSError::WS_OK);
786 }
787 
788 /**
789  * @tc.name: removeFailRecoveredSession
790  * @tc.desc: removeFailRecoveredSession
791  * @tc.type: FUNC
792 */
793 HWTEST_F(SceneSessionManagerLifecycleTest, removeFailRecoveredSession, Function | SmallTest | Level3)
794 {
795     ASSERT_NE(nullptr, ssm_);
796     SessionInfo info;
797     info.abilityName_ = "SetBrightness";
798     sptr<SceneSession> sceneSession01 = sptr<SceneSession>::MakeSptr(info, nullptr);
799     sptr<SceneSession> sceneSession02 = sptr<SceneSession>::MakeSptr(info, nullptr);
800     ASSERT_NE(sceneSession01, nullptr);
801     ASSERT_NE(sceneSession02, nullptr);
802     ssm_->sceneSessionMap_.insert(std::make_pair(1, sceneSession01));
803     ssm_->sceneSessionMap_.insert(std::make_pair(2, nullptr));
804     ssm_->sceneSessionMap_.insert(std::make_pair(3, sceneSession02));
805     ssm_->failRecoveredPersistentIdSet_.insert(1);
806     ssm_->failRecoveredPersistentIdSet_.insert(2);
807     ssm_->failRecoveredPersistentIdSet_.insert(3);
808     ssm_->removeFailRecoveredSession();
809     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->HandleSecureSessionShouldHide(nullptr));
810 }
811 
812 /**
813  * @tc.name: ClearSession
814  * @tc.desc: ClearSession
815  * @tc.type: FUNC
816 */
817 HWTEST_F(SceneSessionManagerLifecycleTest, ClearSession, Function | SmallTest | Level3)
818 {
819     ASSERT_NE(nullptr, ssm_);
820     SessionInfo info;
821     info.abilityName_ = "SetBrightness";
822     sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
823     ASSERT_NE(sceneSession, nullptr);
824 
825     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->ClearSession(nullptr));
826     EXPECT_EQ(WSError::WS_ERROR_INVALID_SESSION, ssm_->ClearSession(sceneSession));
827 }
828 }
829 } // namespace Rosen
830 } // namespace OHOS
831