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
18 #include "session_manager/include/screen_session_manager.h"
19 #include "display_manager_agent_default.h"
20 #include "iconsumer_surface.h"
21 #include "connection/screen_cast_connection.h"
22 #include "screen_scene_config.h"
23 #include <surface.h>
24 #include "scene_board_judgement.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31 namespace {
32 const int32_t CV_WAIT_SCREENOFF_MS = 1500;
33 const int32_t CV_WAIT_SCREENOFF_MS_MAX = 3000;
34 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
35 constexpr int32_t CAST_WIRED_PROJECTION_START = 1005;
36 constexpr int32_t CAST_WIRED_PROJECTION_STOP = 1007;
37 }
38 class ScreenSessionManagerTest : public testing::Test {
39 public:
40 static void SetUpTestCase();
41 static void TearDownTestCase();
42 void SetUp() override;
43 void TearDown() override;
44
45 static sptr<ScreenSessionManager> ssm_;
46
47 ScreenId DEFAULT_SCREEN_ID {0};
48 ScreenId VIRTUAL_SCREEN_ID {2};
49 ScreenId VIRTUAL_SCREEN_RS_ID {100};
50 };
51
52 sptr<ScreenSessionManager> ScreenSessionManagerTest::ssm_ = nullptr;
53
SetUpTestCase()54 void ScreenSessionManagerTest::SetUpTestCase()
55 {
56 ssm_ = new ScreenSessionManager();
57 }
58
TearDownTestCase()59 void ScreenSessionManagerTest::TearDownTestCase()
60 {
61 ssm_ = nullptr;
62 }
63
SetUp()64 void ScreenSessionManagerTest::SetUp()
65 {
66 }
67
TearDown()68 void ScreenSessionManagerTest::TearDown()
69 {
70 usleep(SLEEP_TIME_IN_US);
71 }
72
73 namespace {
74 /**
75 * @tc.name: RegisterDisplayManagerAgent
76 * @tc.desc: RegisterDisplayManagerAgent test
77 * @tc.type: FUNC
78 */
79 HWTEST_F(ScreenSessionManagerTest, RegisterDisplayManagerAgent, Function | SmallTest | Level3)
80 {
81 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
82 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
83 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
84 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
85
86 type = DisplayManagerAgentType::PRIVATE_WINDOW_LISTENER;
87 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->RegisterDisplayManagerAgent(nullptr, type));
88 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->UnregisterDisplayManagerAgent(nullptr, type));
89
90 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
91 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
92 }
93
94 /**
95 * @tc.name: WakeupBegin
96 * @tc.desc: WakeupBegin test
97 * @tc.type: FUNC
98 */
99 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin, Function | SmallTest | Level3)
100 {
101 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
102 EXPECT_NE(displayManagerAgent, nullptr);
103
104 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
105 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
106
107 VirtualScreenOption virtualOption;
108 virtualOption.name_ = "createVirtualOption";
109 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
110 if (screenId != VIRTUAL_SCREEN_ID) {
111 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
112 }
113
114 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
115 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
116
117 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
118 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
119
120 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
121 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
122
123 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
124 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
125
126 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
127 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
128
129 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
130 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
131 }
132
133 /**
134 * @tc.name: SuspendBegin
135 * @tc.desc: SuspendBegin test
136 * @tc.type: FUNC
137 */
138 HWTEST_F(ScreenSessionManagerTest, SuspendBegin, Function | SmallTest | Level3)
139 {
140 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
141 EXPECT_NE(displayManagerAgent, nullptr);
142
143 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
144 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
145
146 VirtualScreenOption virtualOption;
147 virtualOption.name_ = "createVirtualOption";
148 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
149 if (screenId != VIRTUAL_SCREEN_ID) {
150 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
151 }
152
153 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
154 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
155
156 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
157 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
158
159 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
160 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
161 }
162
163 /**
164 * @tc.name: SetScreenPowerForAll
165 * @tc.desc: SetScreenPowerForAll test
166 * @tc.type: FUNC
167 */
168 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
169 {
170 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
171 EXPECT_NE(displayManagerAgent, nullptr);
172
173 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
174 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
175
176 VirtualScreenOption virtualOption;
177 virtualOption.name_ = "createVirtualOption";
178 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
179 if (screenId != VIRTUAL_SCREEN_ID) {
180 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
181 }
182
183 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
184 ScreenPowerState state = ScreenPowerState::POWER_ON;
185 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
186
187 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
188 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
189
190 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
191 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
192
193 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
194 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
195
196 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
197 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
198
199 reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
200 state = ScreenPowerState::POWER_OFF;
201 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
202
203 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
204 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
205
206 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
207 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
208 }
209
210 /**
211 * @tc.name: ScreenChange
212 * @tc.desc: ScreenChange test
213 * @tc.type: FUNC
214 */
215 HWTEST_F(ScreenSessionManagerTest, ScreenChange, Function | SmallTest | Level3)
216 {
217 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
218 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
219 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
220 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
221 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
222 EXPECT_TRUE(1);
223
224 screenEvent = ScreenEvent::DISCONNECTED;
225 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
226 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
227 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
228 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
229 EXPECT_TRUE(1);
230 }
231
232 /**
233 * @tc.name: ScreenPower
234 * @tc.desc: ScreenSesionManager screen power
235 * @tc.type: FUNC
236 */
237 HWTEST_F(ScreenSessionManagerTest, ScreenPower, Function | SmallTest | Level3)
238 {
239 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
240 ScreenPowerState state = ScreenPowerState::POWER_ON;
241 DisplayState displayState = DisplayState::ON;
242
243 ASSERT_EQ(false, ssm_->WakeUpBegin(reason));
244 ASSERT_EQ(false, ssm_->WakeUpEnd());
245
246 ASSERT_EQ(false, ssm_->SuspendBegin(reason));
247 ASSERT_EQ(false, ssm_->SuspendEnd());
248
249 ASSERT_EQ(false, ssm_->SetScreenPowerForAll(state, reason));
250
251 DisplayId id = 0;
252 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
253 ssm_->screenSessionMap_[id] = screenSession;
254 ASSERT_EQ(true, ssm_->SetDisplayState(displayState));
255 ASSERT_EQ(DisplayState::ON, ssm_->GetDisplayState(0));
256 }
257
258 /**
259 * @tc.name: GetScreenPower
260 * @tc.desc: GetScreenPower screen power
261 * @tc.type: FUNC
262 */
263 HWTEST_F(ScreenSessionManagerTest, GetScreenPower, Function | SmallTest | Level3)
264 {
265 DisplayId id = 0;
266 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
267 ssm_->screenSessionMap_[id] = screenSession;
268 ssm_->GetScreenPower(0);
269 EXPECT_TRUE(1);
270 }
271
272 /**
273 * @tc.name: IsScreenRotationLocked
274 * @tc.desc: IsScreenRotationLocked test
275 * @tc.type: FUNC
276 */
277 HWTEST_F(ScreenSessionManagerTest, IsScreenRotationLocked, Function | SmallTest | Level3)
278 {
279 bool isLocked = false;
280 DisplayId id = 0;
281 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
282 ssm_->screenSessionMap_[id] = screenSession;
283 ASSERT_EQ(DMError::DM_OK, ssm_->IsScreenRotationLocked(isLocked));
284 }
285
286 /**
287 * @tc.name: SetOrientation
288 * @tc.desc: SetOrientation test
289 * @tc.type: FUNC
290 */
291 HWTEST_F(ScreenSessionManagerTest, SetOrientation, Function | SmallTest | Level3)
292 {
293 Orientation orientation = Orientation::HORIZONTAL;
294 ScreenId id = 0;
295 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
296 ssm_->screenSessionMap_[id] = screenSession;
297 ASSERT_EQ(DMError::DM_OK, ssm_->SetOrientation(id, orientation));
298 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetOrientation(SCREEN_ID_INVALID, orientation));
299 Orientation invalidOrientation = Orientation{20};
300 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetOrientation(id, invalidOrientation));
301 }
302
303 /**
304 * @tc.name: SetRotationFromWindow
305 * @tc.desc: SetRotationFromWindow test
306 * @tc.type: FUNC
307 */
308 HWTEST_F(ScreenSessionManagerTest, SetRotationFromWindow, Function | SmallTest | Level3)
309 {
310 Rotation targetRotation = Rotation::ROTATION_0;
311 ScreenId id = 0;
312 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
313 ssm_->screenSessionMap_[id] = screenSession;
314 ASSERT_EQ(ssm_->SetRotationFromWindow(targetRotation), ssm_->SetRotation(id, targetRotation, true));
315 }
316
317 /**
318 * @tc.name: GetDisplaySnapshot
319 * @tc.desc: ScreenSesionManager screen shot
320 * @tc.type: FUNC
321 */
322 HWTEST_F(ScreenSessionManagerTest, GetDisplaySnapshot, Function | SmallTest | Level3)
323 {
324 DisplayId displayId(0);
325 DmErrorCode* errorCode = nullptr;
326 ssm_->GetDisplaySnapshot(displayId, errorCode, false);
327 EXPECT_TRUE(1);
328 }
329
330 /**
331 * @tc.name: VirtualScreen
332 * @tc.desc: ScreenSesionManager virtual screen
333 * @tc.type: FUNC
334 */
335 HWTEST_F(ScreenSessionManagerTest, VirtualScreen, Function | SmallTest | Level3)
336 {
337 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
338 VirtualScreenOption virtualOption;
339 virtualOption.name_ = "testVirtualOption";
340 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
341
342 std::vector<ScreenId> mirrorScreenIds;
343 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
344 ScreenId screenGroupId{1};
345 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
346 mirrorScreenIds.push_back(VIRTUAL_SCREEN_ID);
347 ASSERT_NE(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
348
349 mirrorScreenIds.push_back(screenId);
350 ASSERT_EQ(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
351
352 auto result1 = ssm_->SetVirtualScreenSurface(screenId, nullptr);
353 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result1);
354 sptr<IConsumerSurface> surface = OHOS::IConsumerSurface::Create();
355 auto result2 = ssm_->SetVirtualScreenSurface(screenId, surface->GetProducer());
356 ASSERT_EQ(DMError::DM_OK, result2);
357 ASSERT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
358 }
359
360 /**
361 * @tc.name: AutoRotate
362 * @tc.desc: ScreenSesionManager SetVirtualMirrorScreenCanvasRotation test
363 * @tc.type: FUNC
364 */
365 HWTEST_F(ScreenSessionManagerTest, AutoRotate, Function | SmallTest | Level3)
366 {
367 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
368 VirtualScreenOption virtualOption;
369 virtualOption.name_ = "testAutoRotate";
370 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
371 if (screenId != VIRTUAL_SCREEN_ID) {
372 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
373 }
374
375 auto result1 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, true);
376 ASSERT_EQ(DMError::DM_OK, result1);
377 auto result2 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, false);
378 ASSERT_EQ(DMError::DM_OK, result2);
379 ssm_->DestroyVirtualScreen(screenId);
380 }
381
382 /**
383 * @tc.name: GetScreenSession
384 * @tc.desc: GetScreenSession virtual screen
385 * @tc.type: FUNC
386 */
387 HWTEST_F(ScreenSessionManagerTest, GetScreenSession, Function | SmallTest | Level3)
388 {
389 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
390 VirtualScreenOption virtualOption;
391 virtualOption.name_ = "GetScreenSession";
392 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
393 if (screenId != VIRTUAL_SCREEN_ID) {
394 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
395 }
396 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
397 sptr<ScreenSession> screenSession =
398 new (std::nothrow) ScreenSession("GetScreenSession", screenId, rsid, 0);
399 ASSERT_NE(ssm_->GetScreenSession(screenId), screenSession);
400 ssm_->DestroyVirtualScreen(screenId);
401 }
402
403
404 /**
405 * @tc.name: GetDefaultScreenSession
406 * @tc.desc: GetDefaultScreenSession virtual screen
407 * @tc.type: FUNC
408 */
409 HWTEST_F(ScreenSessionManagerTest, GetDefaultScreenSession, Function | SmallTest | Level3)
410 {
411 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
412 VirtualScreenOption virtualOption;
413 virtualOption.name_ = "GetDefaultScreenSession";
414 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
415 if (screenId != VIRTUAL_SCREEN_ID) {
416 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
417 }
418 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
419 sptr<ScreenSession> screenSession =
420 new (std::nothrow) ScreenSession("GetDefaultScreenSession", screenId, rsid, 0);
421 ASSERT_NE(ssm_->GetDefaultScreenSession(), screenSession);
422 ssm_->DestroyVirtualScreen(screenId);
423 }
424
425 /**
426 * @tc.name: GetDefaultDisplayInfo
427 * @tc.desc: GetDefaultDisplayInfo virtual screen
428 * @tc.type: FUNC
429 */
430 HWTEST_F(ScreenSessionManagerTest, GetDefaultDisplayInfo, Function | SmallTest | Level3)
431 {
432 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
433 VirtualScreenOption virtualOption;
434 virtualOption.name_ = "GetDefaultScreenSession";
435 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
436 if (screenId != VIRTUAL_SCREEN_ID) {
437 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
438 }
439 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
440 sptr<ScreenSession> screenSession =
441 new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
442 sptr<DisplayInfo> displayInfo = new DisplayInfo();
443 if (ssm_->GetScreenSession(screenId) == nullptr) {
444 ASSERT_EQ(ssm_->GetDefaultDisplayInfo(), nullptr);
445 }
446 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
447 ASSERT_NE(ssm_->GetDefaultDisplayInfo(), displayInfo);
448 ssm_->DestroyVirtualScreen(screenId);
449 }
450
451 /**
452 * @tc.name: HookDisplayInfoByUid
453 * @tc.desc: HookDisplayInfo by uid
454 * @tc.type: FUNC
455 */
456 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid, Function | SmallTest | Level3)
457 {
458 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
459 VirtualScreenOption virtualOption;
460 virtualOption.name_ = "GetDefaultScreenSession";
461 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
462 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
463 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
464 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
465 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
466 ASSERT_NE(displayInfo, nullptr);
467 uint32_t uid = 20020001;
468 DMHookInfo dmHookInfo;
469 std::map<uint32_t, DMHookInfo> displayHookMap = {};
470 displayHookMap[uid] = dmHookInfo;
471 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
472 displayInfo->SetWidth(100);
473 ASSERT_EQ(displayInfo->GetWidth(), 100);
474 displayInfo->SetHeight(100);
475 ASSERT_EQ(displayInfo->GetHeight(), 100);
476 displayInfo->SetVirtualPixelRatio(1.0);
477 ASSERT_EQ(displayInfo->GetVirtualPixelRatio(), 1.0);
478 displayInfo->SetRotation(Rotation::ROTATION_0);
479 ASSERT_EQ(displayInfo->GetRotation(), Rotation::ROTATION_0);
480 displayInfo->SetDisplayOrientation(DisplayOrientation::PORTRAIT);
481 ASSERT_EQ(displayInfo->GetDisplayOrientation(), DisplayOrientation::PORTRAIT);
482 ssm_->DestroyVirtualScreen(screenId);
483 }
484
485 /**
486 * @tc.name: GetDisplayInfoById
487 * @tc.desc: GetDisplayInfoById virtual screen
488 * @tc.type: FUNC
489 */
490 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoById, Function | SmallTest | Level3)
491 {
492 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
493 VirtualScreenOption virtualOption;
494 virtualOption.name_ = "GetDefaultScreenSession";
495 ASSERT_EQ(ssm_->GetDisplayInfoById(1), nullptr);
496 }
497
498 /**
499 * @tc.name: GetDisplayInfoByScreen
500 * @tc.desc: GetDisplayInfoByScreen virtual screen
501 * @tc.type: FUNC
502 */
503 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoByScreen, Function | SmallTest | Level3)
504 {
505 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
506 VirtualScreenOption virtualOption;
507 virtualOption.name_ = "GetDefaultScreenSession";
508 ASSERT_EQ(ssm_->GetDisplayInfoByScreen(1), nullptr);
509 }
510
511 /**
512 * @tc.name: GetScreenInfoById
513 * @tc.desc: GetScreenInfoById virtual screen
514 * @tc.type: FUNC
515 */
516 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoById, Function | SmallTest | Level3)
517 {
518 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
519 VirtualScreenOption virtualOption;
520 virtualOption.name_ = "GetDefaultScreenSession";
521 ASSERT_EQ(ssm_->GetScreenInfoById(1), nullptr);
522 }
523
524 /**
525 * @tc.name: SetScreenActiveMode
526 * @tc.desc: SetScreenActiveMode virtual screen
527 * @tc.type: FUNC
528 */
529 HWTEST_F(ScreenSessionManagerTest, SetScreenActiveMode, Function | SmallTest | Level3)
530 {
531 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
532 VirtualScreenOption virtualOption;
533 virtualOption.name_ = "SetScreenActiveMode";
534 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
535 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
536 ssm_->DestroyVirtualScreen(screenId);
537 }
538
539
540 /**
541 * @tc.name: NotifyScreenChanged
542 * @tc.desc: NotifyScreenChanged virtual screen
543 * @tc.type: FUNC
544 */
545 HWTEST_F(ScreenSessionManagerTest, NotifyScreenChanged, Function | SmallTest | Level3)
546 {
547 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
548 VirtualScreenOption virtualOption;
549 virtualOption.name_ = "NotifyScreenChanged";
550 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
551 sptr<ScreenInfo> screenInfo;
552 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
553 screenInfo = new ScreenInfo();
554 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
555 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
556 ssm_->DestroyVirtualScreen(screenId);
557 }
558
559 /**
560 * @tc.name: NotifyDisplayEvent
561 * @tc.desc: NotifyDisplayEvent virtual screen
562 * @tc.type: FUNC
563 */
564 HWTEST_F(ScreenSessionManagerTest, NotifyDisplayEvent, Function | SmallTest | Level3)
565 {
566 DisplayEvent event = DisplayEvent::KEYGUARD_DRAWN;
567 ssm_->NotifyDisplayEvent(event);
568 ASSERT_EQ(ssm_->keyguardDrawnDone_, true);
569
570 event = DisplayEvent::SCREEN_LOCK_SUSPEND;
571 ssm_->NotifyDisplayEvent(event);
572 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
573
574 event = DisplayEvent::SCREEN_LOCK_OFF;
575 ssm_->NotifyDisplayEvent(event);
576 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
577
578 event = DisplayEvent::SCREEN_LOCK_FINGERPRINT;
579 ssm_->NotifyDisplayEvent(event);
580 ASSERT_EQ(ssm_->gotScreenlockFingerprint_, true);
581 }
582
583
584 /**
585 * @tc.name: GetScreenInfoByDisplayId
586 * @tc.desc: GetScreenInfoByDisplayId virtual screen
587 * @tc.type: FUNC
588 */
589 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoByDisplayId, Function | SmallTest | Level3)
590 {
591 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
592 VirtualScreenOption virtualOption;
593 virtualOption.name_ = "GetScreenInfoByDisplayId";
594 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
595 sptr<ScreenInfo> screenInfo;
596 screenInfo = ssm_->GetScreenInfoByDisplayId(screenId);
597 ASSERT_NE(screenInfo, nullptr);
598 ssm_->DestroyVirtualScreen(screenId);
599 }
600
601 /**
602 * @tc.name: GetScreenModesByDisplayId
603 * @tc.desc: GetScreenModesByDisplayId virtual screen
604 * @tc.type: FUNC
605 */
606 HWTEST_F(ScreenSessionManagerTest, GetScreenModesByDisplayId, Function | SmallTest | Level3)
607 {
608 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
609 VirtualScreenOption virtualOption;
610 virtualOption.name_ = "GetScreenModesByDisplayId";
611 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
612 sptr<SupportedScreenModes> screenModes;
613 screenModes = ssm_->GetScreenModesByDisplayId(screenId);
614 ASSERT_NE(screenModes, nullptr);
615 ssm_->DestroyVirtualScreen(screenId);
616 }
617
618 /**
619 * @tc.name: UpdateDisplayHookInfo001
620 * @tc.desc: UpdateDisplayHookInfo by uid
621 * @tc.type: FUNC
622 */
623 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo001, Function | SmallTest | Level3)
624 {
625 uint32_t uid = 20020001;
626 DMHookInfo dmHookInfo;
627 dmHookInfo.width_ = 100;
628 dmHookInfo.height_ = 100;
629 dmHookInfo.density_ = 1.0;
630 std::map<uint32_t, DMHookInfo> displayHookMap = {};
631 displayHookMap[uid] = dmHookInfo;
632 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
633 auto info = displayHookMap[uid];
634 ASSERT_EQ(info.width_, 100);
635 ASSERT_EQ(info.height_, 100);
636 ASSERT_EQ(info.density_, 1.0);
637 }
638
639 /**
640 * @tc.name: UpdateDisplayHookInfo002
641 * @tc.desc: UpdateDisplayHookInfo by uid
642 * @tc.type: FUNC
643 */
644 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo002, Function | SmallTest | Level3)
645 {
646 uint32_t uid = 20020001;
647 DMHookInfo dmHookInfo;
648 dmHookInfo.width_ = 100;
649 dmHookInfo.height_ = 100;
650 dmHookInfo.density_ = 1.0;
651 std::map<uint32_t, DMHookInfo> displayHookMap = {};
652 displayHookMap[uid] = dmHookInfo;
653 displayHookMap.erase(uid);
654 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), false);
655 }
656
657 /**
658 * @tc.name: SetVirtualPixelRatio
659 * @tc.desc: SetVirtualPixelRatio virtual screen
660 * @tc.type: FUNC
661 */
662 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatio, Function | SmallTest | Level3)
663 {
664 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
665 VirtualScreenOption virtualOption;
666 virtualOption.name_ = "SetVirtualPixelRatio";
667 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
668 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatio(screenId, 0.1));
669 ssm_->DestroyVirtualScreen(screenId);
670 }
671
672 /**
673 * @tc.name: SetVirtualPixelRatioSystem
674 * @tc.desc: SetVirtualPixelRatioSystem virtual screen
675 * @tc.type: FUNC
676 */
677 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatioSystem, Function | SmallTest | Level3)
678 {
679 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
680 VirtualScreenOption virtualOption;
681 virtualOption.name_ = "SetVirtualPixelRatioSystem";
682 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
683 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatioSystem(screenId, 0.1));
684 ssm_->DestroyVirtualScreen(screenId);
685 }
686
687 /**
688 * @tc.name: SetResolution
689 * @tc.desc: SetResolution virtual screen
690 * @tc.type: FUNC
691 */
692 HWTEST_F(ScreenSessionManagerTest, SetResolution, Function | SmallTest | Level3)
693 {
694 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
695 VirtualScreenOption virtualOption;
696 virtualOption.name_ = "SetResolution";
697 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
698 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
699 ssm_->screenSessionMap_[screenId] = screenSession;
700 sptr<SupportedScreenModes> mode = new SupportedScreenModes();
701 mode->width_ = 1;
702 mode->height_ = 1;
703 screenSession->modes_ = {mode};
704 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetResolution(screenId, 100, 100, 0.5));
705 ssm_->DestroyVirtualScreen(screenId);
706 }
707
708 /**
709 * @tc.name: GetScreenColorGamut
710 * @tc.desc: GetScreenColorGamut virtual screen
711 * @tc.type: FUNC
712 */
713 HWTEST_F(ScreenSessionManagerTest, GetScreenColorGamut, Function | SmallTest | Level3)
714 {
715 ScreenColorGamut colorGamut = ScreenColorGamut::COLOR_GAMUT_SRGB;
716 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorGamut(1, colorGamut));
717 DisplayId id = 0;
718 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
719 ssm_->screenSessionMap_[id] = screenSession;
720 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
721 ASSERT_EQ(DMError::DM_OK, ssm_->GetScreenColorGamut(id, colorGamut));
722 } else {
723 ASSERT_NE(DMError::DM_OK, ssm_->GetScreenColorGamut(id, colorGamut));
724 }
725 }
726
727 /**
728 * @tc.name: LoadScreenSceneXml
729 * @tc.desc: LoadScreenSceneXml virtual screen
730 * @tc.type: FUNC
731 */
732 HWTEST_F(ScreenSessionManagerTest, LoadScreenSceneXml, Function | SmallTest | Level3)
733 {
734 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
735 VirtualScreenOption virtualOption;
736 virtualOption.name_ = "LoadScreenSceneXml";
737 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
738 ssm_->LoadScreenSceneXml();
739 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
740 ssm_->DestroyVirtualScreen(screenId);
741 }
742
743 /**
744 * @tc.name: GetScreenGamutMap
745 * @tc.desc: GetScreenGamutMap virtual screen
746 * @tc.type: FUNC
747 */
748 HWTEST_F(ScreenSessionManagerTest, GetScreenGamutMap, Function | SmallTest | Level3)
749 {
750 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
751 VirtualScreenOption virtualOption;
752 virtualOption.name_ = "GetScreenGamutMap";
753 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
754 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
755 sptr<ScreenSession> screenSession =
756 new (std::nothrow) ScreenSession("GetScreenGamutMap", screenId, rsid, 0);
757 ScreenGamutMap gamutMap;
758 ASSERT_EQ(DMError::DM_OK, ssm_->GetScreenGamutMap(screenId, gamutMap));
759 ssm_->DestroyVirtualScreen(screenId);
760 }
761
762 /**
763 * @tc.name: MakeExpand
764 * @tc.desc: MakeExpand virtual screen
765 * @tc.type: FUNC
766 */
767 HWTEST_F(ScreenSessionManagerTest, MakeExpand, Function | SmallTest | Level3)
768 {
769 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
770 VirtualScreenOption virtualOption;
771 virtualOption.name_ = "MakeExpand";
772 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
773 if (screenId != VIRTUAL_SCREEN_ID) {
774 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
775 }
776 std::vector<ScreenId> mirrorScreenIds;
777 std::vector<Point> startPoints;
778 ScreenId screenGroupId2 = DISPLAY_ID_INVALID;
779 ASSERT_NE(DMError::DM_ERROR_RENDER_SERVICE_FAILED, ssm_->MakeExpand(mirrorScreenIds, startPoints, screenGroupId2));
780 ssm_->DestroyVirtualScreen(screenId);
781 }
782
783 /**
784 * @tc.name: DeleteScreenId
785 * @tc.desc: DeleteScreenId virtual screen
786 * @tc.type: FUNC
787 */
788 HWTEST_F(ScreenSessionManagerTest, DeleteScreenId, Function | SmallTest | Level3)
789 {
790 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
791 VirtualScreenOption virtualOption;
792 virtualOption.name_ = "DeleteScreenId";
793 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
794 if (screenId != VIRTUAL_SCREEN_ID) {
795 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
796 }
797 ScreenSessionManager::ScreenIdManager sim;
798 ASSERT_EQ(false, sim.DeleteScreenId(99));
799 ssm_->DestroyVirtualScreen(screenId);
800 }
801
802 /**
803 * @tc.name: HasRsScreenId
804 * @tc.desc: HasRsScreenId virtual screen
805 * @tc.type: FUNC
806 */
807 HWTEST_F(ScreenSessionManagerTest, HasRsScreenId, Function | SmallTest | Level3)
808 {
809 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
810 VirtualScreenOption virtualOption;
811 virtualOption.name_ = "DeleteScreenId";
812
813 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
814 if (screenId != VIRTUAL_SCREEN_ID) {
815 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
816 }
817 ScreenSessionManager::ScreenIdManager sim;
818 ASSERT_EQ(false, sim.HasRsScreenId(99));
819 ssm_->DestroyVirtualScreen(screenId);
820 }
821
822 /**
823 * @tc.name: AddAsFirstScreenLocked
824 * @tc.desc: AddAsFirstScreenLocked virtual screen
825 * @tc.type: FUNC
826 */
827 HWTEST_F(ScreenSessionManagerTest, AddAsFirstScreenLocked, Function | SmallTest | Level3)
828 {
829 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
830 VirtualScreenOption virtualOption;
831 virtualOption.name_ = "DeleteScreenId";
832
833 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
834 if (screenId != VIRTUAL_SCREEN_ID) {
835 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
836 }
837 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
838 sptr<ScreenSessionGroup> sessiongroup=nullptr;
839 ASSERT_NE(sessiongroup, ssm_->AddAsFirstScreenLocked(newScreen));
840 ssm_->DestroyVirtualScreen(screenId);
841 }
842
843 /**
844 * @tc.name: AddAsSuccedentScreenLocked
845 * @tc.desc: AddAsSuccedentScreenLocked virtual screen
846 * @tc.type: FUNC
847 */
848 HWTEST_F(ScreenSessionManagerTest, AddAsSuccedentScreenLocked, Function | SmallTest | Level3)
849 {
850 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
851 VirtualScreenOption virtualOption;
852 virtualOption.name_ = "DeleteScreenId";
853
854 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
855 if (screenId != VIRTUAL_SCREEN_ID) {
856 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
857 }
858 sptr<ScreenSession> newScreen;
859 sptr<ScreenSessionGroup> sessiongroup=nullptr;
860 ASSERT_EQ(sessiongroup, ssm_->AddAsSuccedentScreenLocked(newScreen));
861 ssm_->DestroyVirtualScreen(screenId);
862 }
863
864 /**
865 * @tc.name: SetMirror
866 * @tc.desc: SetMirror virtual screen
867 * @tc.type: FUNC
868 */
869 HWTEST_F(ScreenSessionManagerTest, SetMirror, Function | SmallTest | Level3)
870 {
871 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
872 VirtualScreenOption virtualOption;
873 virtualOption.name_ = "SetMirror";
874 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
875
876 std::vector<ScreenId> screens{0, 1, 2, 3, 4, 5, 6, 7};
877 sptr<ScreenSession> screenSession = nullptr;
878 screenSession = new (std::nothrow) ScreenSession("GetScreenGamutMap", 2, 2, 3);
879 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_{
880 {2, screenSession},
881 };
882 ssm_->screenSessionMap_ = screenSessionMap_;
883 auto screen = ssm_->GetScreenSession(2);
884 screen->GetScreenProperty().SetScreenType(ScreenType::REAL);
885 ASSERT_EQ(DMError::DM_OK, ssm_->SetMirror(2, screens));
886 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetMirror(9, screens));
887 ssm_->DestroyVirtualScreen(screenId);
888 }
889
890 /**
891 * @tc.name: GetAbstractScreenGroup
892 * @tc.desc: GetAbstractScreenGroup virtual screen
893 * @tc.type: FUNC
894 */
895 HWTEST_F(ScreenSessionManagerTest, GetAbstractScreenGroup, Function | SmallTest | Level3)
896 {
897 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
898 VirtualScreenOption virtualOption;
899 virtualOption.name_ = "DeleteScreenId";
900
901 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
902 if (screenId != VIRTUAL_SCREEN_ID) {
903 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
904 }
905 sptr<ScreenSessionGroup> sreengroup=nullptr;
906 ASSERT_EQ(sreengroup, ssm_->GetAbstractScreenGroup(2));
907 ssm_->DestroyVirtualScreen(screenId);
908 }
909
910 /**
911 * @tc.name: InitAbstractScreenModesInfo
912 * @tc.desc: InitAbstractScreenModesInfo virtual screen
913 * @tc.type: FUNC
914 */
915 HWTEST_F(ScreenSessionManagerTest, InitAbstractScreenModesInfo, Function | SmallTest | Level3)
916 {
917 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
918 VirtualScreenOption virtualOption;
919 virtualOption.name_ = "DeleteScreenId";
920
921 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
922 if (screenId != VIRTUAL_SCREEN_ID) {
923 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
924 }
925 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
926 ASSERT_EQ(true, ssm_->InitAbstractScreenModesInfo(screenSession));
927 ssm_->DestroyVirtualScreen(screenId);
928 }
929
930 /**
931 * @tc.name: AddToGroupLocked
932 * @tc.desc: AddToGroupLocked virtual screen
933 * @tc.type: FUNC
934 */
935 HWTEST_F(ScreenSessionManagerTest, AddToGroupLocked, Function | SmallTest | Level3)
936 {
937 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
938 VirtualScreenOption virtualOption;
939 virtualOption.name_ = "DeleteScreenId";
940
941 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
942 if (screenId != VIRTUAL_SCREEN_ID) {
943 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
944 }
945 sptr<ScreenSession> newScreen=nullptr;
946 sptr<ScreenSessionGroup> sessiongroup=nullptr;
947 ASSERT_EQ(sessiongroup, ssm_->AddToGroupLocked(newScreen));
948 ssm_->DestroyVirtualScreen(screenId);
949 }
950
951 /**
952 * @tc.name: InitVirtualScreen
953 * @tc.desc: InitVirtualScreen virtual screen
954 * @tc.type: FUNC
955 */
956 HWTEST_F(ScreenSessionManagerTest, InitVirtualScreen, Function | SmallTest | Level3)
957 {
958 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
959 VirtualScreenOption virtualOption;
960 virtualOption.name_ = "DeleteScreenId";
961 sptr<ScreenSession> screenSession;
962 VirtualScreenOption option;
963 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
964 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
965 if (screenId != VIRTUAL_SCREEN_ID) {
966 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
967 }
968 screenSession =new (std::nothrow) ScreenSession();
969 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
970 ssm_->DestroyVirtualScreen(screenId);
971 }
972
973 /**
974 * @tc.name: InitAndGetScreen
975 * @tc.desc: InitAndGetScreen virtual screen
976 * @tc.type: FUNC
977 */
978 HWTEST_F(ScreenSessionManagerTest, InitAndGetScreen, Function | SmallTest | Level3)
979 {
980 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
981 VirtualScreenOption virtualOption;
982 virtualOption.name_ = "DeleteScreenId";
983
984 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
985 if (screenId != VIRTUAL_SCREEN_ID) {
986 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
987 }
988 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
989 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
990 ssm_->DestroyVirtualScreen(screenId);
991 }
992
993 /**
994 * @tc.name: RemoveFromGroupLocked
995 * @tc.desc: RemoveFromGroupLocked virtual screen
996 * @tc.type: FUNC
997 */
998 HWTEST_F(ScreenSessionManagerTest, RemoveFromGroupLocked, Function | SmallTest | Level3)
999 {
1000 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1001 VirtualScreenOption virtualOption;
1002 virtualOption.name_ = "DeleteScreenId";
1003
1004 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1005 if (screenId != VIRTUAL_SCREEN_ID) {
1006 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1007 }
1008 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
1009 sptr<ScreenSessionGroup> sessiongroup;
1010 // sptr<ScreenSessionGroup>
1011 ASSERT_EQ(sessiongroup, ssm_->RemoveFromGroupLocked(newScreen));
1012 ssm_->DestroyVirtualScreen(screenId);
1013 }
1014
1015 /**
1016 * @tc.name: CreateAndGetNewScreenId
1017 * @tc.desc: CreateAndGetNewScreenId virtual screen
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(ScreenSessionManagerTest, CreateAndGetNewScreenId, Function | SmallTest | Level3)
1021 {
1022 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1023 VirtualScreenOption virtualOption;
1024 virtualOption.name_ = "CreateAndGetNewScreenId";
1025 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1026 ScreenSessionManager::ScreenIdManager sim;
1027 ASSERT_EQ(1000, sim.CreateAndGetNewScreenId(screenId));
1028 ssm_->DestroyVirtualScreen(screenId);
1029 }
1030
1031 /**
1032 * @tc.name: AddScreenToGroup
1033 * @tc.desc: AddScreenToGroup virtual screen
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(ScreenSessionManagerTest, AddScreenToGroup, Function | SmallTest | Level3)
1037 {
1038 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1039 VirtualScreenOption virtualOption;
1040 virtualOption.name_ = "DeleteScreenId";
1041 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1042 if (screenId != VIRTUAL_SCREEN_ID) {
1043 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1044 }
1045 const std::vector<ScreenId> addScreens;
1046 const std::vector<Point> addChildPos;
1047 std::map<ScreenId, bool> removeChildResMap;
1048 sptr<ScreenSessionGroup> group;
1049 ssm_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
1050 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1051 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1052 ssm_->DestroyVirtualScreen(screenId);
1053 }
1054
1055 /**
1056 * @tc.name: GetRSDisplayNodeByScreenId
1057 * @tc.desc: GetRSDisplayNodeByScreenId virtual screen
1058 * @tc.type: FUNC
1059 */
1060 HWTEST_F(ScreenSessionManagerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
1061 {
1062 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1063 VirtualScreenOption virtualOption;
1064 virtualOption.name_ = "DeleteScreenId";
1065 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1066 if (screenId != VIRTUAL_SCREEN_ID) {
1067 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1068 }
1069 ssm_->GetRSDisplayNodeByScreenId(2);
1070 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1071 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1072 ssm_->DestroyVirtualScreen(screenId);
1073 }
1074
1075 /**
1076 * @tc.name: GetAllDisplayIds
1077 * @tc.desc: GetAllDisplayIds virtual screen
1078 * @tc.type: FUNC
1079 */
1080 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayIds, Function | SmallTest | Level3)
1081 {
1082 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1083 VirtualScreenOption virtualOption;
1084 virtualOption.name_ = "DeleteScreenId";
1085 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1086 if (screenId != VIRTUAL_SCREEN_ID) {
1087 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1088 }
1089 ssm_->GetRSDisplayNodeByScreenId(2);
1090 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1091 std::vector<DisplayId> displays(2);
1092 ASSERT_NE(displays, ssm_->GetAllDisplayIds());
1093 ssm_->DestroyVirtualScreen(screenId);
1094 }
1095
1096 /**
1097 * @tc.name: SetScreenGamutMap
1098 * @tc.desc: SetScreenGamutMap virtual screen
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(ScreenSessionManagerTest, SetScreenGamutMap, Function | SmallTest | Level3)
1102 {
1103 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1104 VirtualScreenOption virtualOption;
1105 virtualOption.name_ = "SetScreenGamutMap";
1106 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1107 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1108 sptr<ScreenSession> screenSession =
1109 new (std::nothrow) ScreenSession("SetScreenGamutMap", screenId, rsid, 0);
1110 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM,
1111 ssm_->SetScreenGamutMap(SCREEN_ID_INVALID, ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION));
1112 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenGamutMap(screenId, ScreenGamutMap::GAMUT_MAP_EXTENSION));
1113 ssm_->DestroyVirtualScreen(screenId);
1114 }
1115
1116 /**
1117 * @tc.name: StopExpand
1118 * @tc.desc: StopExpand virtual screen
1119 * @tc.type: FUNC
1120 */
1121 HWTEST_F(ScreenSessionManagerTest, StopExpand, Function | SmallTest | Level3)
1122 {
1123 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1124 VirtualScreenOption virtualOption;
1125 virtualOption.name_ = "DeleteScreenId";
1126 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1127 if (screenId != VIRTUAL_SCREEN_ID) {
1128 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1129 }
1130 std::vector<ScreenId> expandScreenIds {0, 1, 2, 3, 4, 5};
1131 ASSERT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->StopExpand(expandScreenIds));
1132 ssm_->DestroyVirtualScreen(screenId);
1133 }
1134
1135 /**
1136 * @tc.name: OnScreenDisconnect
1137 * @tc.desc: OnScreenDisconnect virtual screen
1138 * @tc.type: FUNC
1139 */
1140 HWTEST_F(ScreenSessionManagerTest, OnScreenDisconnect, Function | SmallTest | Level3)
1141 {
1142 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1143 VirtualScreenOption virtualOption;
1144 virtualOption.name_ = "DeleteScreenId";
1145 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1146 if (screenId != VIRTUAL_SCREEN_ID) {
1147 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1148 }
1149 ssm_->GetRSDisplayNodeByScreenId(2);
1150 ssm_->OnScreenDisconnect(1);
1151 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1152 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1153 ssm_->DestroyVirtualScreen(screenId);
1154 }
1155
1156 /**
1157 * @tc.name: SetScreenColorGamut
1158 * @tc.desc: SetScreenColorGamut virtual screen
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(ScreenSessionManagerTest, SetScreenColorGamut, Function | SmallTest | Level3)
1162 {
1163 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1164 VirtualScreenOption virtualOption;
1165 virtualOption.name_ = "SetScreenColorGamut";
1166 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1167 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1168 sptr<ScreenSession> screenSession =
1169 new (std::nothrow) ScreenSession("SetScreenColorGamut", screenId, rsid, 0);
1170 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorGamut(screenId, 2));
1171 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorGamut(SCREEN_ID_INVALID, 2));
1172 ssm_->DestroyVirtualScreen(screenId);
1173 }
1174
1175 /**
1176 * @tc.name: SetScreenColorTransform
1177 * @tc.desc: SetScreenColorTransform virtual screen
1178 * @tc.type: FUNC
1179 */
1180 HWTEST_F(ScreenSessionManagerTest, SetScreenColorTransform, Function | SmallTest | Level3)
1181 {
1182 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1183 VirtualScreenOption virtualOption;
1184 virtualOption.name_ = "SetScreenColorTransform";
1185 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1186 if (screenId != VIRTUAL_SCREEN_ID) {
1187 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1188 }
1189 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1190 sptr<ScreenSession> screenSession =
1191 new (std::nothrow) ScreenSession("SetScreenColorTransform", screenId, rsid, 0);
1192 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorTransform(screenId));
1193 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorTransform(SCREEN_ID_INVALID));
1194 ssm_->DestroyVirtualScreen(screenId);
1195 }
1196
1197 /**
1198 * @tc.name: SetScreenRotationLocked
1199 * @tc.desc: SetScreenRotationLocked virtual screen
1200 * @tc.type: FUNC
1201 */
1202 HWTEST_F(ScreenSessionManagerTest, SetScreenRotationLocked, Function | SmallTest | Level3)
1203 {
1204 ScreenId id = 0;
1205 ssm_->screenSessionMap_[id] = nullptr;
1206 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenRotationLocked(false));
1207 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1208 ssm_->screenSessionMap_[id] = screenSession;
1209 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenRotationLocked(false));
1210 }
1211
1212 /**
1213 * @tc.name: UpdateScreenRotationProperty
1214 * @tc.desc: UpdateScreenRotationProperty virtual screen
1215 * @tc.type: FUNC
1216 */
1217 HWTEST_F(ScreenSessionManagerTest, UpdateScreenRotationProperty, Function | SmallTest | Level3)
1218 {
1219 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1220 VirtualScreenOption virtualOption;
1221 virtualOption.name_ = "DeleteScreenId";
1222 RRect bounds;
1223 bounds.rect_.width_ = 1344;
1224 bounds.rect_.height_ = 2772;
1225 int rotation = 1;
1226 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
1227 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(1, bounds, 1, screenPropertyChangeType);
1228 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(virtualOption,
1229 displayManagerAgent->AsObject());
1230 if (screenId != VIRTUAL_SCREEN_ID) {
1231 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1232 }
1233 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(1, bounds, rotation,
1234 screenPropertyChangeType);
1235 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession();
1236 ASSERT_NE(screenSession, ScreenSessionManager::GetInstance().InitAndGetScreen(2));
1237 ssm_->DestroyVirtualScreen(screenId);
1238 }
1239
1240 /**
1241 * @tc.name: MakeUniqueScreen
1242 * @tc.desc: Make unique screen
1243 * @tc.type: FUNC
1244 */
1245 HWTEST_F(ScreenSessionManagerTest, MakeUniqueScreen, Function | SmallTest | Level3)
1246 {
1247 vector<ScreenId> screenIds;
1248 screenIds.clear();
1249 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->MakeUniqueScreen(screenIds));
1250 }
1251
1252 /**
1253 * @tc.name: ConvertScreenIdToRsScreenId
1254 * @tc.desc: convert screen id to RS screen id
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(ScreenSessionManagerTest, ConvertScreenIdToRsScreenId, Function | SmallTest | Level3)
1258 {
1259 ScreenId rsScreenId = VIRTUAL_SCREEN_RS_ID;
1260 ssm_->screenIdManager_.rs2SmsScreenIdMap_.erase(rsScreenId);
1261 ScreenId screenId = ssm_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId);
1262 ASSERT_EQ(true, ssm_->screenIdManager_.HasRsScreenId(rsScreenId));
1263 ScreenId tmpRsScreenId = SCREEN_ID_INVALID;
1264 ASSERT_EQ(true, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
1265 ASSERT_EQ(tmpRsScreenId, rsScreenId);
1266 ssm_->screenIdManager_.DeleteScreenId(screenId);
1267 ASSERT_EQ(false, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
1268 }
1269
1270 /**
1271 * @tc.name: DisableMirror
1272 * @tc.desc: DisableMirror test
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(ScreenSessionManagerTest, DisableMirror, Function | SmallTest | Level3)
1276 {
1277 ASSERT_EQ(DMError::DM_OK, ssm_->DisableMirror(false));
1278 }
1279
1280 /**
1281 * @tc.name: HasImmersiveWindow
1282 * @tc.desc: HasImmersiveWindow test
1283 * @tc.type: FUNC
1284 */
1285 HWTEST_F(ScreenSessionManagerTest, HasImmersiveWindow, Function | SmallTest | Level3)
1286 {
1287 bool immersive = false;
1288 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(immersive));
1289 immersive = true;
1290 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(immersive));
1291 }
1292
1293 /**
1294 * @tc.name: SetSpecifiedScreenPower
1295 * @tc.desc: ScreenSessionManager screen power
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(ScreenSessionManagerTest, SetSpecifiedScreenPower, Function | SmallTest | Level3)
1299 {
1300 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
1301 ScreenPowerState state = ScreenPowerState::POWER_ON;
1302 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
1303 ASSERT_EQ(false, ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
1304 reason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
1305 EXPECT_TRUE(ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
1306 }
1307
1308 /**
1309 * @tc.name: NotifyFoldStatusChanged
1310 * @tc.desc: ScreenSessionManager notify foldStatus changed
1311 * @tc.type: FUNC
1312 */
1313 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged, Function | SmallTest | Level3)
1314 {
1315 const std::string& dumpParam = "-p";
1316 if (ssm_ != nullptr)
1317 {
1318 int errCode = ssm_->NotifyFoldStatusChanged(dumpParam);
1319 ASSERT_EQ(errCode, 0);
1320 } else {
1321 ASSERT_EQ(1, 0);
1322 }
1323 }
1324
1325 /**
1326 * @tc.name: NotifyPrivateWindowListChanged
1327 * @tc.desc: ScreenSessionManager notify PrivateWindowList changed
1328 * @tc.type: FUNC
1329 */
1330 HWTEST_F(ScreenSessionManagerTest, NotifyPrivateWindowListChanged, Function | SmallTest | Level3)
1331 {
1332 DisplayId id = 0;
1333 std::vector<std::string> privacyWindowList{"win0", "win1"};
1334 if (ssm_ != nullptr)
1335 {
1336 ssm_->NotifyPrivateWindowListChanged(id, privacyWindowList);
1337 ASSERT_EQ(0, 0);
1338 } else {
1339 ASSERT_EQ(1, 0);
1340 }
1341 }
1342
1343 /**
1344 * @tc.name: SetPrivacyStateByDisplayId01
1345 * @tc.desc: SetPrivacyStateByDisplayId true test
1346 * @tc.type: FUNC
1347 */
1348 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId01, Function | SmallTest | Level3)
1349 {
1350 DisplayId id = 0;
1351 bool hasPrivate = true;
1352 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
1353 ssm_->screenSessionMap_[id] = screenSession;
1354 ASSERT_NE(nullptr, screenSession);
1355 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
1356 bool result = screenSession->HasPrivateSessionForeground();
1357 EXPECT_EQ(result, true);
1358 }
1359
1360 /**
1361 * @tc.name: SetPrivacyStateByDisplayId02
1362 * @tc.desc: SetPrivacyStateByDisplayId false test
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId02, Function | SmallTest | Level3)
1366 {
1367 DisplayId id = 0;
1368 bool hasPrivate = false;
1369 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
1370 ssm_->screenSessionMap_[id] = screenSession;
1371 ASSERT_NE(nullptr, screenSession);
1372 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
1373 bool result = screenSession->HasPrivateSessionForeground();
1374 EXPECT_EQ(result, false);
1375 }
1376
1377 /**
1378 * @tc.name: SetScreenPrivacyWindowList
1379 * @tc.desc: SetScreenPrivacyWindowList test
1380 * @tc.type: FUNC
1381 */
1382 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyWindowList, Function | SmallTest | Level3)
1383 {
1384 DisplayId id = 0;
1385 std::vector<std::string> privacyWindowList{"win0", "win1"};
1386 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
1387 ASSERT_NE(nullptr, screenSession);
1388 ssm_->SetScreenPrivacyWindowList(id, privacyWindowList);
1389 ASSERT_EQ(0, 0);
1390 }
1391
1392 /**
1393 * @tc.name: GetAllScreenIds
1394 * @tc.desc: GetAllScreenIds screen power
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(ScreenSessionManagerTest, GetAllScreenIds, Function | SmallTest | Level3)
1398 {
1399 sptr<ScreenSession> screenSession = new ScreenSession();
1400 ASSERT_NE(nullptr, screenSession);
1401 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
1402 ssm_->GetAllScreenIds();
1403 EXPECT_TRUE(1);
1404 }
1405
1406 /**
1407 * @tc.name: GetAllScreenInfos
1408 * @tc.desc: GetAllScreenInfos test
1409 * @tc.type: FUNC
1410 */
1411 HWTEST_F(ScreenSessionManagerTest, GetAllScreenInfos, Function | SmallTest | Level3)
1412 {
1413 ScreenId id = 0;
1414 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1415 ssm_->screenSessionMap_[id] = screenSession;
1416 ASSERT_NE(nullptr, screenSession);
1417 std::vector<sptr<ScreenInfo>> screenInfos;
1418 EXPECT_EQ(DMError::DM_OK, ssm_->GetAllScreenInfos(screenInfos));
1419 }
1420
1421 /**
1422 * @tc.name: GetScreenSupportedColorGamuts
1423 * @tc.desc: GetScreenSupportedColorGamuts test
1424 * @tc.type: FUNC
1425 */
1426 HWTEST_F(ScreenSessionManagerTest, GetScreenSupportedColorGamuts, Function | SmallTest | Level3)
1427 {
1428 std::vector<ScreenColorGamut> colorGamuts;
1429 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenSupportedColorGamuts(SCREEN_ID_INVALID, colorGamuts));
1430 ScreenId id = 0;
1431 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1432 ssm_->screenSessionMap_[id] = screenSession;
1433 ASSERT_NE(nullptr, screenSession);
1434 EXPECT_EQ(ssm_->GetScreenSupportedColorGamuts(id, colorGamuts),
1435 screenSession->GetScreenSupportedColorGamuts(colorGamuts));
1436 }
1437
1438 /**
1439 * @tc.name: GetPixelFormat
1440 * @tc.desc: GetPixelFormat test
1441 * @tc.type: FUNC
1442 */
1443 HWTEST_F(ScreenSessionManagerTest, GetPixelFormat, Function | SmallTest | Level3)
1444 {
1445 GraphicPixelFormat pixelFormat;
1446 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
1447 ScreenId id = 0;
1448 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1449 ssm_->screenSessionMap_[id] = screenSession;
1450 ASSERT_NE(nullptr, screenSession);
1451 EXPECT_EQ(ssm_->GetPixelFormat(id, pixelFormat), screenSession->GetPixelFormat(pixelFormat));
1452 }
1453
1454 /**
1455 * @tc.name: SetPixelFormat
1456 * @tc.desc: SetPixelFormat test
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(ScreenSessionManagerTest, SetPixelFormat, Function | SmallTest | Level3)
1460 {
1461 GraphicPixelFormat pixelFormat = GraphicPixelFormat{GRAPHIC_PIXEL_FMT_CLUT8};
1462 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
1463 ScreenId id = 0;
1464 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1465 ssm_->screenSessionMap_[id] = screenSession;
1466 ASSERT_NE(nullptr, screenSession);
1467 EXPECT_EQ(ssm_->SetPixelFormat(id, pixelFormat), screenSession->SetPixelFormat(pixelFormat));
1468 }
1469
1470 /**
1471 * @tc.name: GetSupportedHDRFormats
1472 * @tc.desc: GetSupportedHDRFormats test
1473 * @tc.type: FUNC
1474 */
1475 HWTEST_F(ScreenSessionManagerTest, GetSupportedHDRFormats, Function | SmallTest | Level3)
1476 {
1477 std::vector<ScreenHDRFormat> hdrFormats;
1478 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedHDRFormats(SCREEN_ID_INVALID, hdrFormats));
1479 ScreenId id = 0;
1480 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1481 ssm_->screenSessionMap_[id] = screenSession;
1482 ASSERT_NE(nullptr, screenSession);
1483 EXPECT_EQ(ssm_->GetSupportedHDRFormats(id, hdrFormats), screenSession->GetSupportedHDRFormats(hdrFormats));
1484 }
1485
1486 /**
1487 * @tc.name: GetScreenHDRFormat
1488 * @tc.desc: GetScreenHDRFormat test
1489 * @tc.type: FUNC
1490 */
1491 HWTEST_F(ScreenSessionManagerTest, GetScreenHDRFormat, Function | SmallTest | Level3)
1492 {
1493 ScreenHDRFormat hdrFormat;
1494 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenHDRFormat(SCREEN_ID_INVALID, hdrFormat));
1495 ScreenId id = 0;
1496 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1497 ssm_->screenSessionMap_[id] = screenSession;
1498 ASSERT_NE(nullptr, screenSession);
1499 EXPECT_EQ(ssm_->GetScreenHDRFormat(id, hdrFormat), screenSession->GetScreenHDRFormat(hdrFormat));
1500 }
1501
1502 /**
1503 * @tc.name: SetScreenHDRFormat
1504 * @tc.desc: SetScreenHDRFormat test
1505 * @tc.type: FUNC
1506 */
1507 HWTEST_F(ScreenSessionManagerTest, SetScreenHDRFormat, Function | SmallTest | Level3)
1508 {
1509 int32_t modeIdx {0};
1510 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenHDRFormat(SCREEN_ID_INVALID, modeIdx));
1511 ScreenId id = 0;
1512 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1513 ssm_->screenSessionMap_[id] = screenSession;
1514 ASSERT_NE(nullptr, screenSession);
1515 EXPECT_EQ(ssm_->SetScreenHDRFormat(id, modeIdx), screenSession->SetScreenHDRFormat(modeIdx));
1516 }
1517
1518 /**
1519 * @tc.name: GetSupportedColorSpaces
1520 * @tc.desc: GetSupportedColorSpaces test
1521 * @tc.type: FUNC
1522 */
1523 HWTEST_F(ScreenSessionManagerTest, GetSupportedColorSpaces, Function | SmallTest | Level3)
1524 {
1525 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
1526 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedColorSpaces(SCREEN_ID_INVALID, colorSpaces));
1527 ScreenId id = 0;
1528 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1529 ssm_->screenSessionMap_[id] = screenSession;
1530 ASSERT_NE(nullptr, screenSession);
1531 EXPECT_EQ(ssm_->GetSupportedColorSpaces(id, colorSpaces), screenSession->GetSupportedColorSpaces(colorSpaces));
1532 }
1533
1534 /**
1535 * @tc.name: GetScreenColorSpace
1536 * @tc.desc: GetScreenColorSpace test
1537 * @tc.type: FUNC
1538 */
1539 HWTEST_F(ScreenSessionManagerTest, GetScreenColorSpace, Function | SmallTest | Level3)
1540 {
1541 GraphicCM_ColorSpaceType colorSpace;
1542 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
1543 ScreenId id = 0;
1544 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1545 ssm_->screenSessionMap_[id] = screenSession;
1546 ASSERT_NE(nullptr, screenSession);
1547 EXPECT_EQ(ssm_->GetScreenColorSpace(id, colorSpace), screenSession->GetScreenColorSpace(colorSpace));
1548 }
1549
1550 /**
1551 * @tc.name: SetScreenColorSpace
1552 * @tc.desc: SetScreenColorSpace test
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(ScreenSessionManagerTest, SetScreenColorSpace, Function | SmallTest | Level3)
1556 {
1557 GraphicCM_ColorSpaceType colorSpace = GraphicCM_ColorSpaceType{GRAPHIC_CM_COLORSPACE_NONE};
1558 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
1559 ScreenId id = 0;
1560 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1561 ssm_->screenSessionMap_[id] = screenSession;
1562 ASSERT_NE(nullptr, screenSession);
1563 EXPECT_EQ(ssm_->SetScreenColorSpace(id, colorSpace), screenSession->SetScreenColorSpace(colorSpace));
1564 }
1565
1566 /**
1567 * @tc.name: HasPrivateWindow
1568 * @tc.desc: HasPrivateWindow test
1569 * @tc.type: FUNC
1570 */
1571 HWTEST_F(ScreenSessionManagerTest, HasPrivateWindow, Function | SmallTest | Level3)
1572 {
1573 bool hasPrivateWindow;
1574 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->HasPrivateWindow(SCREEN_ID_INVALID, hasPrivateWindow));
1575 DisplayId id = 0;
1576 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1577 ssm_->screenSessionMap_[id] = screenSession;
1578 ASSERT_NE(nullptr, screenSession);
1579 EXPECT_EQ(DMError::DM_OK, ssm_->HasPrivateWindow(id, hasPrivateWindow));
1580 }
1581
1582 /**
1583 * @tc.name: GetAvailableArea
1584 * @tc.desc: GetAvailableArea test
1585 * @tc.type: FUNC
1586 */
1587 HWTEST_F(ScreenSessionManagerTest, GetAvailableArea, Function | SmallTest | Level3)
1588 {
1589 DMRect area;
1590 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetAvailableArea(SCREEN_ID_INVALID, area));
1591 DisplayId id = 0;
1592 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1593 ssm_->screenSessionMap_[id] = screenSession;
1594 ASSERT_NE(nullptr, screenSession);
1595 EXPECT_EQ(DMError::DM_OK, ssm_->GetAvailableArea(id, area));
1596 }
1597
1598 /**
1599 * @tc.name: ResetAllFreezeStatus
1600 * @tc.desc: ResetAllFreezeStatus test
1601 * @tc.type: FUNC
1602 */
1603 HWTEST_F(ScreenSessionManagerTest, ResetAllFreezeStatus, Function | SmallTest | Level3)
1604 {
1605 EXPECT_EQ(DMError::DM_OK, ssm_->ResetAllFreezeStatus());
1606 }
1607
1608 /**
1609 * @tc.name: SetVirtualScreenRefreshRate
1610 * @tc.desc: SetVirtualScreenRefreshRate test
1611 * @tc.type: FUNC
1612 */
1613 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenRefreshRate, Function | SmallTest | Level3)
1614 {
1615 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1616 ScreenId id = 0;
1617 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1618 ssm_->screenSessionMap_[id] = screenSession;
1619 uint32_t refreshInterval {2};
1620 VirtualScreenOption virtualOption;
1621 virtualOption.name_ = "createVirtualOption";
1622 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1623 if (screenId != VIRTUAL_SCREEN_ID) {
1624 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1625 }
1626 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(id, refreshInterval));
1627 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenRefreshRate(screenId, refreshInterval));
1628 uint32_t invalidRefreshInterval {0};
1629 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(screenId, invalidRefreshInterval));
1630 ssm_->DestroyVirtualScreen(screenId);
1631 }
1632
1633 /**
1634 * @tc.name: SetVirtualScreenFlag
1635 * @tc.desc: SetVirtualScreenFlag test
1636 * @tc.type: FUNC
1637 */
1638 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenFlag, Function | SmallTest | Level3)
1639 {
1640 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1641 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
1642 VirtualScreenOption virtualOption;
1643 virtualOption.name_ = "createVirtualOption";
1644 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1645 if (screenId != VIRTUAL_SCREEN_ID) {
1646 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1647 }
1648 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
1649 ssm_->DestroyVirtualScreen(screenId);
1650 }
1651
1652 /**
1653 * @tc.name: GetVirtualScreenFlag
1654 * @tc.desc: GetVirtualScreenFlag test
1655 * @tc.type: FUNC
1656 */
1657 HWTEST_F(ScreenSessionManagerTest, GetVirtualScreenFlag, Function | SmallTest | Level3)
1658 {
1659 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1660 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
1661 VirtualScreenOption virtualOption;
1662 virtualOption.name_ = "createVirtualOption";
1663 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1664 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
1665 EXPECT_EQ(screenFlag, ssm_->GetVirtualScreenFlag(screenId));
1666 ssm_->DestroyVirtualScreen(screenId);
1667 }
1668
1669 /**
1670 * @tc.name: ResizeVirtualScreen
1671 * @tc.desc: ResizeVirtualScreen test
1672 * @tc.type: FUNC
1673 */
1674 HWTEST_F(ScreenSessionManagerTest, ResizeVirtualScreen, Function | SmallTest | Level3)
1675 {
1676 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1677 VirtualScreenOption virtualOption;
1678 virtualOption.name_ = "createVirtualOption";
1679 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1680 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1681
1682 uint32_t width {100};
1683 uint32_t height {100};
1684 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
1685 if (screenSession->GetDisplayNode() != nullptr) {
1686 EXPECT_EQ(DMError::DM_OK, ssm_->ResizeVirtualScreen(screenId, width, height));
1687 }
1688 ssm_->DestroyVirtualScreen(screenId);
1689 }
1690
1691 /**
1692 * @tc.name: SetVirtualMirrorScreenScaleMode
1693 * @tc.desc: SetVirtualMirrorScreenScaleMode test
1694 * @tc.type: FUNC
1695 */
1696 HWTEST_F(ScreenSessionManagerTest, SetVirtualMirrorScreenScaleMode, Function | SmallTest | Level3)
1697 {
1698 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1699 VirtualScreenOption virtualOption;
1700 virtualOption.name_ = "createVirtualOption";
1701 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1702 if (screenId != VIRTUAL_SCREEN_ID) {
1703 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1704 }
1705 ScreenScaleMode scaleMode = ScreenScaleMode::FILL_MODE;
1706 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualMirrorScreenScaleMode(screenId, scaleMode));
1707 ssm_->DestroyVirtualScreen(screenId);
1708 }
1709
1710 /**
1711 * @tc.name: StopMirror
1712 * @tc.desc: StopMirror test
1713 * @tc.type: FUNC
1714 */
1715 HWTEST_F(ScreenSessionManagerTest, StopMirror, Function | SmallTest | Level3)
1716 {
1717 std::vector<ScreenId> mirrorScreenIds {0, 1, 2, 3, 4, 5};
1718 EXPECT_EQ(DMError::DM_OK, ssm_->StopMirror(mirrorScreenIds));
1719 }
1720
1721 /**
1722 * @tc.name: GetDensityInCurResolution
1723 * @tc.desc: GetDensityInCurResolution screen power
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(ScreenSessionManagerTest, GetDensityInCurResolution, Function | SmallTest | Level3)
1727 {
1728 sptr<ScreenSession> screenSession = new ScreenSession();
1729 ASSERT_NE(nullptr, screenSession);
1730 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
1731 ScreenId screenId = 100;
1732 float x = 3.14;
1733 auto res = ssm_->GetDensityInCurResolution(screenId, x);
1734 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, res);
1735 screenId = 1;
1736 res = ssm_->GetDensityInCurResolution(screenId, x);
1737 EXPECT_EQ(DMError::DM_OK, res);
1738 }
1739
1740 /**
1741 * @tc.name: SetScreenOffDelayTime
1742 * @tc.desc: SetScreenOffDelayTime test
1743 * @tc.type: FUNC
1744 */
1745 HWTEST_F(ScreenSessionManagerTest, SetScreenOffDelayTime, Function | SmallTest | Level3)
1746 {
1747 int32_t delay = CV_WAIT_SCREENOFF_MS - 1;
1748 int32_t ret = ssm_->SetScreenOffDelayTime(delay);
1749 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS);
1750
1751 delay = CV_WAIT_SCREENOFF_MS + 1;
1752 ret = ssm_->SetScreenOffDelayTime(delay);
1753 EXPECT_EQ(ret, delay);
1754
1755 delay = CV_WAIT_SCREENOFF_MS_MAX - 1;
1756 ret = ssm_->SetScreenOffDelayTime(delay);
1757 EXPECT_EQ(ret, delay);
1758
1759 delay = CV_WAIT_SCREENOFF_MS_MAX + 1;
1760 ret = ssm_->SetScreenOffDelayTime(delay);
1761 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS_MAX);
1762 }
1763
1764 /**
1765 * @tc.name: GetDeviceScreenConfig
1766 * @tc.desc: GetDeviceScreenConfig test
1767 * @tc.type: FUNC
1768 */
1769 HWTEST_F(ScreenSessionManagerTest, GetDeviceScreenConfig, Function | SmallTest | Level3)
1770 {
1771 DeviceScreenConfig deviceScreenConfig = ssm_->GetDeviceScreenConfig();
1772 EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
1773 }
1774
1775 /**
1776 * @tc.name: SetVirtualScreenBlackList
1777 * @tc.desc: SetVirtualScreenBlackList test
1778 * @tc.type: FUNC
1779 */
1780 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList01, Function | SmallTest | Level3)
1781 {
1782 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
1783 EXPECT_NE(displayManagerAgent, nullptr);
1784
1785 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
1786 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
1787
1788 VirtualScreenOption virtualOption;
1789 virtualOption.name_ = "createVirtualOption";
1790 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1791 if (screenId != VIRTUAL_SCREEN_ID) {
1792 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1793 }
1794 std::vector<uint64_t> windowId = {10, 20, 30};
1795 ssm_->SetVirtualScreenBlackList(screenId, windowId);
1796 ssm_->DestroyVirtualScreen(screenId);
1797 }
1798
1799 /**
1800 * @tc.name: SetVirtualScreenBlackList
1801 * @tc.desc: ConvertScreenIdToRsScreenId = false
1802 * @tc.type: FUNC
1803 */
1804 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList02, Function | SmallTest | Level3)
1805 {
1806 ScreenId screenId = 1010;
1807 ScreenId rsScreenId = SCREEN_ID_INVALID;
1808 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
1809 std::vector<uint64_t> windowId = {10, 20, 30};
1810 ssm_->SetVirtualScreenBlackList(screenId, windowId);
1811 }
1812
1813 /**
1814 * @tc.name: GetAllDisplayPhysicalResolution
1815 * @tc.desc: GetAllDisplayPhysicalResolution test
1816 * @tc.type: FUNC
1817 */
1818 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution, Function | SmallTest | Level3)
1819 {
1820 std::vector<DisplayPhysicalResolution> allSize {};
1821 if (ssm_ != nullptr) {
1822 allSize = ssm_->GetAllDisplayPhysicalResolution();
1823 ASSERT_TRUE(!allSize.empty());
1824 } else {
1825 ASSERT_TRUE(allSize.empty());
1826 }
1827 }
1828
1829 /**
1830 * @tc.name: SetDisplayScale
1831 * @tc.desc: SetDisplayScale test
1832 * @tc.type: FUNC
1833 */
1834 HWTEST_F(ScreenSessionManagerTest, SetDisplayScale, Function | SmallTest | Level3)
1835 {
1836 ASSERT_NE(ssm_, nullptr);
1837 ScreenId fakeScreenId = static_cast<ScreenId>(-1);
1838 float scaleX = 1.0f;
1839 float scaleY = 1.0f;
1840 float pivotX = 0.5f;
1841 float pivotY = 0.5f;
1842 ssm_->SetDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY);
1843 ssm_->SetDisplayScale(ssm_->GetDefaultScreenId(), scaleX, scaleY, pivotX, pivotY);
1844 }
1845
1846 /**
1847 * @tc.name: ScreenCastConnection
1848 * @tc.desc: ScreenCastConnection test
1849 * @tc.type: FUNC
1850 */
1851 HWTEST_F(ScreenSessionManagerTest, ScreenCastConnection, Function | SmallTest | Level3)
1852 {
1853 std::string castBundleName = "testCastBundleName";
1854 std::string castAbilityName = "testCastAbilityName";
1855
1856 ScreenCastConnection::GetInstance().SetBundleName("");
1857 ScreenCastConnection::GetInstance().SetAbilityName("");
1858 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), "");
1859 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), "");
1860
1861 EXPECT_EQ(ScreenCastConnection::GetInstance().CastConnectExtension(1), false);
1862
1863 ScreenCastConnection::GetInstance().SetBundleName(castBundleName);
1864 ScreenCastConnection::GetInstance().SetAbilityName(castAbilityName);
1865 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), castBundleName);
1866 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), castAbilityName);
1867
1868 MessageParcel data;
1869 MessageParcel reply;
1870 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_START, data, reply);
1871 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_STOP, data, reply);
1872 ScreenCastConnection::GetInstance().CastDisconnectExtension();
1873 EXPECT_EQ(ScreenCastConnection::GetInstance().IsConnectedSync(), false);
1874 }
1875
1876 /**
1877 * @tc.name: ReportFoldStatusToScb
1878 * @tc.desc: clientProxy_ = nullptr
1879 * @tc.type: FUNC
1880 */
1881 HWTEST_F(ScreenSessionManagerTest, ReportFoldStatusToScb, Function | SmallTest | Level3)
1882 {
1883 ssm_->clientProxy_ = nullptr;
1884 FoldStatus currentStatus = FoldStatus::FOLDED;
1885 FoldStatus nextStatus = FoldStatus::HALF_FOLD;
1886 int32_t duration = 1;
1887 float postureAngle = 1.2;
1888 std::vector<std::string> screenFoldInfo {std::to_string(static_cast<int32_t>(currentStatus)),
1889 std::to_string(static_cast<int32_t>(nextStatus)), std::to_string(duration), std::to_string(postureAngle)};
1890 ssm_->ReportFoldStatusToScb(screenFoldInfo);
1891 ASSERT_NE(ssm_, nullptr);
1892 }
1893
1894 /**
1895 * @tc.name: DisablePowerOffRenderControl
1896 * @tc.desc: ConvertScreenIdToRsScreenId = true
1897 * @tc.type: FUNC
1898 */
1899 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl01, Function | SmallTest | Level3)
1900 {
1901 ScreenId screenId = 1050;
1902 ScreenId rsScreenId = SCREEN_ID_INVALID;
1903 ScreenId rsScreenId1 = 1060;
1904 ssm_->screenIdManager_.sms2RsScreenIdMap_[screenId] = rsScreenId1;
1905 ASSERT_TRUE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
1906 ssm_->DisablePowerOffRenderControl(screenId);
1907 }
1908
1909 /**
1910 * @tc.name: DisablePowerOffRenderControl
1911 * @tc.desc: ConvertScreenIdToRsScreenId = false
1912 * @tc.type: FUNC
1913 */
1914 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl02, Function | SmallTest | Level3)
1915 {
1916 ScreenId screenId = 1010;
1917 ScreenId rsScreenId = SCREEN_ID_INVALID;
1918 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
1919 ssm_->DisablePowerOffRenderControl(screenId);
1920 }
1921
1922 /**
1923 * @tc.name: CheckAndSendHiSysEvent
1924 * @tc.desc: eventName != "CREATE_VIRTUAL_SCREEN"
1925 * @tc.type: FUNC
1926 */
1927 HWTEST_F(ScreenSessionManagerTest, CheckAndSendHiSysEvent, Function | SmallTest | Level3)
1928 {
1929 std::string eventName = "GET_DISPLAY_SNAPSHOT";
1930 std::string bundleName = "hmos.screenshot";
1931 ssm_->CheckAndSendHiSysEvent(eventName, bundleName);
1932 ASSERT_NE(ssm_, nullptr);
1933 }
1934
1935 /**
1936 * @tc.name: NotifyFoldToExpandCompletion
1937 * @tc.desc: NotifyFoldToExpandCompletion
1938 * @tc.type: FUNC
1939 */
1940 HWTEST_F(ScreenSessionManagerTest, NotifyFoldToExpandCompletion, Function | SmallTest | Level3)
1941 {
1942 bool foldToExpand = false;
1943 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
1944
1945 foldToExpand = true;
1946 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
1947 ASSERT_NE(ssm_, nullptr);
1948 }
1949
1950 /**
1951 * @tc.name: UpdateAvailableArea
1952 * @tc.desc: screenSession == nullptr
1953 * @tc.type: FUNC
1954 */
1955 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea01, Function | SmallTest | Level3)
1956 {
1957 ScreenId screenId = 1050;
1958 DMRect area = DMRect{};
1959 ssm_->UpdateAvailableArea(screenId, area);
1960 ASSERT_NE(ssm_, nullptr);
1961 }
1962
1963 /**
1964 * @tc.name: UpdateAvailableArea
1965 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is true
1966 * @tc.type: FUNC
1967 */
1968 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, Function | SmallTest | Level3)
1969 {
1970 ScreenId screenId = 1050;
1971 DMRect area{0, 0, 600, 900};
1972 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1973 ASSERT_NE(screenSession, nullptr);
1974 ssm_->screenSessionMap_[screenId] = screenSession;
1975 auto screenSession1 = ssm_->GetScreenSession(screenId);
1976 ASSERT_EQ(screenSession1, screenSession);
1977 ASSERT_TRUE(screenSession->UpdateAvailableArea(area));
1978 ssm_->UpdateAvailableArea(screenId, area);
1979 }
1980
1981 /**
1982 * @tc.name: UpdateAvailableArea
1983 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is false
1984 * @tc.type: FUNC
1985 */
1986 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea03, Function | SmallTest | Level3)
1987 {
1988 ScreenId screenId = 1050;
1989 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1990 ASSERT_NE(screenSession, nullptr);
1991 DMRect area = screenSession->GetAvailableArea();
1992 ssm_->screenSessionMap_[screenId] = screenSession;
1993 ASSERT_FALSE(screenSession->UpdateAvailableArea(area));
1994 ssm_->UpdateAvailableArea(screenId, area);
1995 }
1996
1997 /**
1998 * @tc.name: NotifyAvailableAreaChanged
1999 * @tc.desc: agents.empty()
2000 * @tc.type: FUNC
2001 */
2002 HWTEST_F(ScreenSessionManagerTest, NotifyAvailableAreaChanged01, Function | SmallTest | Level3)
2003 {
2004 DMRect area = DMRect{};
2005 ASSERT_NE(ssm_, nullptr);
2006 ssm_->NotifyAvailableAreaChanged(area);
2007 }
2008
2009 /**
2010 * @tc.name: NotifyFoldStatusChanged
2011 * @tc.desc: NotifyFoldStatusChanged
2012 * @tc.type: FUNC
2013 */
2014 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged02, Function | SmallTest | Level3)
2015 {
2016 std::string statusParam;
2017 auto ret = ssm_->NotifyFoldStatusChanged(statusParam);
2018 ASSERT_EQ(ret, -1);
2019
2020 statusParam = "-z"; // STATUS_FOLD_HALF
2021 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2022 ASSERT_EQ(ret, 0);
2023
2024 statusParam = "-y"; // STATUS_EXPAND
2025 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2026 ASSERT_EQ(ret, 0);
2027
2028 statusParam = "-coor"; // ARG_FOLD_DISPLAY_COOR
2029 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2030
2031 if (!(ssm_->IsFoldable())) {
2032 ssm_->foldScreenController_ = new FoldScreenController(
2033 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
2034 }
2035 ASSERT_NE(ssm_->foldScreenController_, nullptr);
2036 statusParam = "-y";
2037 ssm_->HandleFoldScreenPowerInit();
2038 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2039 ASSERT_EQ(ret, 0);
2040 }
2041
2042 /**
2043 * @tc.name: Dump
2044 * @tc.desc: Dump
2045 * @tc.type: FUNC
2046 */
2047 HWTEST_F(ScreenSessionManagerTest, Dump, Function | SmallTest | Level3)
2048 {
2049 int fd = 2;
2050 std::vector<std::u16string> args;
2051 int ret = ssm_->Dump(fd, args);
2052 ASSERT_EQ(ret, 0);
2053 }
2054
2055 /**
2056 * @tc.name: GetDisplayNode
2057 * @tc.desc: GetDisplayNode
2058 * @tc.type: FUNC
2059 */
2060 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode01, Function | SmallTest | Level3)
2061 {
2062 ScreenId screenId = 1051;
2063 auto ret = ssm_->GetDisplayNode(screenId);
2064 ASSERT_EQ(ret, nullptr);
2065 }
2066
2067 /**
2068 * @tc.name: GetDisplayNode
2069 * @tc.desc: !screenSession = false
2070 * @tc.type: FUNC
2071 */
2072 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode02, Function | SmallTest | Level3)
2073 {
2074 ScreenId screenId = 1050;
2075 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2076 ASSERT_NE(screenSession, nullptr);
2077 ssm_->screenSessionMap_[screenId] = screenSession;
2078 auto ret = ssm_->GetDisplayNode(screenId);
2079 ASSERT_NE(ret, nullptr);
2080 }
2081
2082 /**
2083 * @tc.name: GetScreenProperty
2084 * @tc.desc: GetScreenProperty
2085 * @tc.type: FUNC
2086 */
2087 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty01, Function | SmallTest | Level3)
2088 {
2089 ScreenId screenId = 2000;
2090 ASSERT_EQ(ssm_->GetScreenSession(screenId), nullptr);
2091 auto ret = ssm_->GetScreenProperty(screenId);
2092 ASSERT_EQ(sizeof(ret), sizeof(ScreenProperty));
2093 }
2094
2095 /**
2096 * @tc.name: GetScreenProperty
2097 * @tc.desc: !screenSession = false
2098 * @tc.type: FUNC
2099 */
2100 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty02, Function | SmallTest | Level3)
2101 {
2102 ScreenId screenId = 1050;
2103 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2104 ASSERT_NE(screenSession, nullptr);
2105 ScreenProperty property = ssm_->GetScreenProperty(screenId);
2106 ASSERT_EQ(sizeof(property), sizeof(screenSession->property_));
2107 }
2108
2109 /**
2110 * @tc.name: GetCurrentScreenPhyBounds
2111 * @tc.desc: GetCurrentScreenPhyBounds
2112 * @tc.type: FUNC
2113 */
2114 HWTEST_F(ScreenSessionManagerTest, GetCurrentScreenPhyBounds01, Function | SmallTest | Level3)
2115 {
2116 float phyWidth = 0.0f;
2117 float phyHeight = 0.0f;
2118 bool isReset = true;
2119 ScreenId screenId = 1050;
2120 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
2121 if (!(ssm_->IsFoldable())) {
2122 ssm_->foldScreenController_ = new FoldScreenController(
2123 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
2124 }
2125
2126 ASSERT_NE(ssm_->foldScreenController_, nullptr);
2127 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
2128 ASSERT_FALSE(isReset);
2129 }
2130
2131 /**
2132 * @tc.name: PhyMirrorConnectWakeupScreen
2133 * @tc.desc: PhyMirrorConnectWakeupScreen test
2134 * @tc.type: FUNC
2135 */
2136 HWTEST_F(ScreenSessionManagerTest, PhyMirrorConnectWakeupScreen, Function | SmallTest | Level3)
2137 {
2138 ASSERT_NE(ssm_, nullptr);
2139 ssm_->PhyMirrorConnectWakeupScreen();
2140 ScreenSceneConfig::stringConfig_["externalScreenDefaultMode"] = "mirror";
2141 ssm_->PhyMirrorConnectWakeupScreen();
2142 }
2143
2144 /**
2145 * @tc.name: SetCoordinationFlag
2146 * @tc.desc: SetCoordinationFlag
2147 * @tc.type: FUNC
2148 */
2149 HWTEST_F(ScreenSessionManagerTest, SetCoordinationFlag, Function | SmallTest | Level3)
2150 {
2151 ScreenSessionManager* ssm = new ScreenSessionManager();
2152 ASSERT_NE(ssm, nullptr);
2153 ASSERT_EQ(ssm->isCoordinationFlag_, false);
2154 ssm->SetCoordinationFlag(true);
2155 ASSERT_EQ(ssm->isCoordinationFlag_, true);
2156 }
2157
2158 /**
2159 * @tc.name: GetTentMode
2160 * @tc.desc: Test get tent mode
2161 * @tc.type: FUNC
2162 */
2163 HWTEST_F(ScreenSessionManagerTest, GetTentMode, Function | SmallTest | Level1)
2164 {
2165 auto tentMode = ssm_->GetTentMode();
2166 ASSERT_EQ(tentMode, false);
2167 }
2168
2169 /**
2170 * @tc.name: OnTentModeChanged
2171 * @tc.desc: Test change tent mode
2172 * @tc.type: FUNC
2173 */
2174 HWTEST_F(ScreenSessionManagerTest, OnTentModeChanged, Function | SmallTest | Level1)
2175 {
2176 bool isTentMode = false;
2177 ssm_->OnTentModeChanged(isTentMode);
2178 ASSERT_EQ(ssm_->GetTentMode(), false);
2179 }
2180
2181 /**
2182 * @tc.name: GetScreenCapture
2183 * @tc.desc: GetScreenCapture
2184 * @tc.type: FUNC
2185 */
2186 HWTEST_F(ScreenSessionManagerTest, GetScreenCapture, Function | SmallTest | Level3)
2187 {
2188 ScreenSessionManager* ssm = new ScreenSessionManager();
2189 ASSERT_NE(ssm, nullptr);
2190 CaptureOption option;
2191 option.displayId_ = 0;
2192 DmErrorCode errCode;
2193 std::shared_ptr<Media::PixelMap> bitMap = ssm->GetScreenCapture(option, &errCode);
2194 ASSERT_EQ(bitMap, nullptr);
2195 }
2196
2197 /**
2198 * @tc.name: OnScreenCaptureNotify
2199 * @tc.desc: OnScreenCaptureNotify
2200 * @tc.type: FUNC
2201 */
2202 HWTEST_F(ScreenSessionManagerTest, OnScreenCaptureNotify, Function | SmallTest | Level3)
2203 {
2204 ScreenSessionManager* ssm = new ScreenSessionManager();
2205 ASSERT_NE(ssm, nullptr);
2206 ScreenId screenId = 0;
2207 int32_t uid = 0;
2208 std::string clientName = "test";
2209 ssm->OnScreenCaptureNotify(screenId, uid, clientName);
2210 }
2211 }
2212 } // namespace Rosen
2213 } // namespace OHOS
2214