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