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 "screen_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 #include "fold_screen_state_internel.h"
26 #include "common_test_utils.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Rosen {
33 namespace {
34 const int32_t CV_WAIT_SCREENOFF_MS = 1500;
35 const int32_t CV_WAIT_SCREENOFF_MS_MAX = 3000;
36 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
37 constexpr int32_t CAST_WIRED_PROJECTION_START = 1005;
38 constexpr int32_t CAST_WIRED_PROJECTION_STOP = 1007;
39 bool g_isPcDevice = ScreenSceneConfig::GetExternalScreenDefaultMode() == "none";
40 }
41 class ScreenSessionManagerTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47
48 static sptr<ScreenSessionManager> ssm_;
49
50 ScreenId DEFAULT_SCREEN_ID {0};
51 ScreenId VIRTUAL_SCREEN_ID {2};
52 ScreenId VIRTUAL_SCREEN_RS_ID {100};
53 void SetAceessTokenPermission(const std::string processName);
54 };
55
56 sptr<ScreenSessionManager> ScreenSessionManagerTest::ssm_ = nullptr;
57
SetUpTestCase()58 void ScreenSessionManagerTest::SetUpTestCase()
59 {
60 ssm_ = new ScreenSessionManager();
61 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
62 const char** perms = new const char *[1];
63 perms[0] = "ohos.permission.CAPTURE_SCREEN";
64 CommonTestUtils::SetAceessTokenPermission("foundation", perms, 1);
65 }
66
TearDownTestCase()67 void ScreenSessionManagerTest::TearDownTestCase()
68 {
69 ssm_ = nullptr;
70 }
71
SetUp()72 void ScreenSessionManagerTest::SetUp()
73 {
74 }
75
TearDown()76 void ScreenSessionManagerTest::TearDown()
77 {
78 usleep(SLEEP_TIME_IN_US);
79 }
80
81 namespace {
82 /**
83 * @tc.name: RegisterDisplayManagerAgent
84 * @tc.desc: RegisterDisplayManagerAgent test
85 * @tc.type: FUNC
86 */
87 HWTEST_F(ScreenSessionManagerTest, RegisterDisplayManagerAgent, Function | SmallTest | Level3)
88 {
89 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
90 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
91 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
92 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
93
94 type = DisplayManagerAgentType::PRIVATE_WINDOW_LISTENER;
95 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->RegisterDisplayManagerAgent(nullptr, type));
96 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->UnregisterDisplayManagerAgent(nullptr, type));
97
98 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
99 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
100 }
101
102 /**
103 * @tc.name: WakeupBegin
104 * @tc.desc: WakeupBegin test
105 * @tc.type: FUNC
106 */
107 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin, Function | SmallTest | Level3)
108 {
109 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
110 EXPECT_NE(displayManagerAgent, nullptr);
111
112 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
113 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
114
115 VirtualScreenOption virtualOption;
116 virtualOption.name_ = "createVirtualOption";
117 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
118 if (screenId != VIRTUAL_SCREEN_ID) {
119 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
120 }
121
122 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
123 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
124
125 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
126 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
127
128 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
129 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
130
131 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
132 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
133
134 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
135 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
136
137 reason = PowerStateChangeReason::STATE_CHANGE_REASON_START_DREAM;
138 ASSERT_EQ(false, ssm_->WakeUpBegin(reason));
139
140 reason = PowerStateChangeReason::STATE_CHANGE_REASON_END_DREAM;
141 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
142
143 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
144 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
145 }
146
147 /**
148 * @tc.name: WakeupBegin01
149 * @tc.desc: WakeupBegin01 test
150 * @tc.type: FUNC
151 */
152 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin01, Function | SmallTest | Level3)
153 {
154 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
155 EXPECT_NE(displayManagerAgent, nullptr);
156
157 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
158 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
159
160 VirtualScreenOption virtualOption;
161 virtualOption.name_ = "createVirtualOption";
162 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
163 if (screenId != VIRTUAL_SCREEN_ID) {
164 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
165 }
166
167 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
168 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
169
170 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
171 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
172 }
173
174 /**
175 * @tc.name: WakeupBegin02
176 * @tc.desc: WakeupBegin02 test
177 * @tc.type: FUNC
178 */
179 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin02, Function | SmallTest | Level3)
180 {
181 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
182 EXPECT_NE(displayManagerAgent, nullptr);
183
184 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
185 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
186
187 VirtualScreenOption virtualOption;
188 virtualOption.name_ = "createVirtualOption";
189 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
190 if (screenId != VIRTUAL_SCREEN_ID) {
191 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
192 }
193
194 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_INIT;
195 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
196
197 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
198 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
199 }
200
201 /**
202 * @tc.name: WakeupBegin03
203 * @tc.desc: WakeupBegin03 test
204 * @tc.type: FUNC
205 */
206 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin03, Function | SmallTest | Level3)
207 {
208 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
209 EXPECT_NE(displayManagerAgent, nullptr);
210
211 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
212 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
213
214 VirtualScreenOption virtualOption;
215 virtualOption.name_ = "createVirtualOption";
216 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
217 if (screenId != VIRTUAL_SCREEN_ID) {
218 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
219 }
220
221 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_TIMEOUT;
222 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
223
224 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
225 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
226 }
227
228 /**
229 * @tc.name: WakeupBegin04
230 * @tc.desc: WakeupBegin04 test
231 * @tc.type: FUNC
232 */
233 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin04, Function | SmallTest | Level3)
234 {
235 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
236 EXPECT_NE(displayManagerAgent, nullptr);
237
238 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
239 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
240
241 VirtualScreenOption virtualOption;
242 virtualOption.name_ = "createVirtualOption";
243 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
244 if (screenId != VIRTUAL_SCREEN_ID) {
245 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
246 }
247
248 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK;
249 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
250
251 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
252 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
253 }
254
255 /**
256 * @tc.name: WakeupBegin05
257 * @tc.desc: WakeupBegin05 test
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin05, Function | SmallTest | Level3)
261 {
262 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
263 EXPECT_NE(displayManagerAgent, nullptr);
264
265 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
266 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
267
268 VirtualScreenOption virtualOption;
269 virtualOption.name_ = "createVirtualOption";
270 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
271 if (screenId != VIRTUAL_SCREEN_ID) {
272 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
273 }
274
275 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_BATTERY;
276 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
277
278 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
279 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
280 }
281
282 /**
283 * @tc.name: WakeupBegin06
284 * @tc.desc: WakeupBegin06 test
285 * @tc.type: FUNC
286 */
287 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin06, Function | SmallTest | Level3)
288 {
289 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
290 EXPECT_NE(displayManagerAgent, nullptr);
291
292 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
293 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
294
295 VirtualScreenOption virtualOption;
296 virtualOption.name_ = "createVirtualOption";
297 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
298 if (screenId != VIRTUAL_SCREEN_ID) {
299 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
300 }
301
302 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_THERMAL;
303 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
304
305 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
306 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
307 }
308
309 /**
310 * @tc.name: WakeupBegin07
311 * @tc.desc: WakeupBegin07 test
312 * @tc.type: FUNC
313 */
314 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin07, Function | SmallTest | Level3)
315 {
316 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
317 EXPECT_NE(displayManagerAgent, nullptr);
318
319 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
320 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
321
322 VirtualScreenOption virtualOption;
323 virtualOption.name_ = "createVirtualOption";
324 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
325 if (screenId != VIRTUAL_SCREEN_ID) {
326 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
327 }
328
329 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_WORK;
330 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
331
332 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
333 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
334 }
335
336 /**
337 * @tc.name: WakeupBegin08
338 * @tc.desc: WakeupBegin08 test
339 * @tc.type: FUNC
340 */
341 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin08, Function | SmallTest | Level3)
342 {
343 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
344 EXPECT_NE(displayManagerAgent, nullptr);
345
346 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
347 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
348
349 VirtualScreenOption virtualOption;
350 virtualOption.name_ = "createVirtualOption";
351 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
352 if (screenId != VIRTUAL_SCREEN_ID) {
353 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
354 }
355
356 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SYSTEM;
357 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
358
359 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
360 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
361 }
362
363 /**
364 * @tc.name: WakeupBegin09
365 * @tc.desc: WakeupBegin09 test
366 * @tc.type: FUNC
367 */
368 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin09, Function | SmallTest | Level3)
369 {
370 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
371 EXPECT_NE(displayManagerAgent, nullptr);
372
373 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
374 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
375
376 VirtualScreenOption virtualOption;
377 virtualOption.name_ = "createVirtualOption";
378 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
379 if (screenId != VIRTUAL_SCREEN_ID) {
380 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
381 }
382
383 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_APPLICATION;
384 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
385
386 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
387 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
388 }
389
390 /**
391 * @tc.name: WakeupBegin10
392 * @tc.desc: WakeupBegin10 test
393 * @tc.type: FUNC
394 */
395 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin10, Function | SmallTest | Level3)
396 {
397 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
398 EXPECT_NE(displayManagerAgent, nullptr);
399
400 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
401 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
402
403 VirtualScreenOption virtualOption;
404 virtualOption.name_ = "createVirtualOption";
405 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
406 if (screenId != VIRTUAL_SCREEN_ID) {
407 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
408 }
409
410 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SETTINGS;
411 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
412
413 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
414 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
415 }
416
417 /**
418 * @tc.name: SuspendBegin
419 * @tc.desc: SuspendBegin test
420 * @tc.type: FUNC
421 */
422 HWTEST_F(ScreenSessionManagerTest, SuspendBegin, Function | SmallTest | Level3)
423 {
424 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
425 EXPECT_NE(displayManagerAgent, nullptr);
426
427 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
428 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
429
430 VirtualScreenOption virtualOption;
431 virtualOption.name_ = "createVirtualOption";
432 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
433 if (screenId != VIRTUAL_SCREEN_ID) {
434 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
435 }
436
437 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
438 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
439
440 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
441 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
442
443 reason = PowerStateChangeReason::STATE_CHANGE_REASON_START_DREAM;
444 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
445
446 reason = PowerStateChangeReason::STATE_CHANGE_REASON_END_DREAM;
447 ASSERT_EQ(false, ssm_->SuspendBegin(reason));
448
449 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
450 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
451 }
452
453 /**
454 * @tc.name: GetInternalScreenId
455 * @tc.desc: GetInternalScreenId test
456 * @tc.type: FUNC
457 */
458 HWTEST_F(ScreenSessionManagerTest, GetInternalScreenId, Function | SmallTest | Level3)
459 {
460 ASSERT_EQ(SCREEN_ID_INVALID, ssm_->GetInternalScreenId());
461
462 ScreenSessionConfig config;
463 sptr<ScreenSession> session = new ScreenSession(config,
464 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
465 session->SetIsInternal(true);
466 ScreenId id = 0;
467 ssm_->screenSessionMap_.insert(std::make_pair(id, session));
468 ASSERT_EQ(0, ssm_->GetInternalScreenId());
469
470 ssm_->screenSessionMap_.erase(0);
471 }
472
473 /**
474 * @tc.name: SetScreenPowerById01
475 * @tc.desc: SetScreenPowerById test POWER_ON
476 * @tc.type: FUNC
477 */
478 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById01, Function | SmallTest | Level3)
479 {
480 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
481 EXPECT_NE(displayManagerAgent, nullptr);
482
483 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
484 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
485
486 VirtualScreenOption virtualOption;
487 virtualOption.name_ = "createVirtualOption";
488 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
489 if (screenId != VIRTUAL_SCREEN_ID) {
490 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
491 }
492
493 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
494 ScreenPowerState state = ScreenPowerState::POWER_ON;
495 ASSERT_EQ(true, ssm_->SetScreenPowerById(screenId, state, reason));
496
497 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
498 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
499 }
500
501 /**
502 * @tc.name: SetScreenPowerById02
503 * @tc.desc: SetScreenPowerById test POWER_OFF
504 * @tc.type: FUNC
505 */
506 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById02, Function | SmallTest | Level3)
507 {
508 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
509 EXPECT_NE(displayManagerAgent, nullptr);
510
511 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
512 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
513
514 VirtualScreenOption virtualOption;
515 virtualOption.name_ = "createVirtualOption";
516 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
517 if (screenId != VIRTUAL_SCREEN_ID) {
518 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
519 }
520
521 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
522 ScreenPowerState state = ScreenPowerState::POWER_OFF;
523 ASSERT_EQ(true, ssm_->SetScreenPowerById(screenId, state, reason));
524
525 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
526 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
527 }
528
529 /**
530 * @tc.name: SetScreenPowerById03
531 * @tc.desc: SetScreenPowerById test INVALID_STATE
532 * @tc.type: FUNC
533 */
534 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById03, Function | SmallTest | Level3)
535 {
536 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
537 EXPECT_NE(displayManagerAgent, nullptr);
538
539 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
540 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
541
542 VirtualScreenOption virtualOption;
543 virtualOption.name_ = "createVirtualOption";
544 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
545 if (screenId != VIRTUAL_SCREEN_ID) {
546 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
547 }
548
549 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
550 ScreenPowerState state = ScreenPowerState::INVALID_STATE;
551 ASSERT_EQ(false, ssm_->SetScreenPowerById(screenId, state, reason));
552
553 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
554 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
555 }
556
557 /**
558 * @tc.name: SetScreenPowerForAll
559 * @tc.desc: SetScreenPowerForAll test
560 * @tc.type: FUNC
561 */
562 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
563 {
564 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
565 EXPECT_NE(displayManagerAgent, nullptr);
566
567 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
568 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
569
570 VirtualScreenOption virtualOption;
571 virtualOption.name_ = "createVirtualOption";
572 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
573 if (screenId != VIRTUAL_SCREEN_ID) {
574 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
575 }
576
577 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
578 ScreenPowerState state = ScreenPowerState::POWER_ON;
579 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
580
581 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
582 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
583
584 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
585 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
586
587 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
588 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
589
590 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
591 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
592
593 reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
594 state = ScreenPowerState::POWER_OFF;
595 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
596
597 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
598 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
599
600 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
601 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
602 }
603
604 /**
605 * @tc.name: SetScreenPowerForAll01
606 * @tc.desc: SetScreenPowerForAll01 test
607 * @tc.type: FUNC
608 */
609 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll01, Function | SmallTest | Level3)
610 {
611 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
612 EXPECT_NE(displayManagerAgent, nullptr);
613
614 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
615 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
616
617 VirtualScreenOption virtualOption;
618 virtualOption.name_ = "createVirtualOption";
619 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
620 if (screenId != VIRTUAL_SCREEN_ID) {
621 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
622 }
623
624 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_INIT;
625 ScreenPowerState state = ScreenPowerState::POWER_ON;
626 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
627
628 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
629 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
630 }
631
632 /**
633 * @tc.name: SetScreenPowerForAll02
634 * @tc.desc: SetScreenPowerForAll02 test
635 * @tc.type: FUNC
636 */
637 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll02, Function | SmallTest | Level3)
638 {
639 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
640 EXPECT_NE(displayManagerAgent, nullptr);
641
642 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
643 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
644
645 VirtualScreenOption virtualOption;
646 virtualOption.name_ = "createVirtualOption";
647 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
648 if (screenId != VIRTUAL_SCREEN_ID) {
649 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
650 }
651
652 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK;
653 ScreenPowerState state = ScreenPowerState::POWER_ON;
654 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
655
656 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
657 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
658 }
659
660 /**
661 * @tc.name: SetScreenPowerForAll03
662 * @tc.desc: SetScreenPowerForAll03 test
663 * @tc.type: FUNC
664 */
665 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll03, Function | SmallTest | Level3)
666 {
667 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
668 EXPECT_NE(displayManagerAgent, nullptr);
669
670 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
671 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
672
673 VirtualScreenOption virtualOption;
674 virtualOption.name_ = "createVirtualOption";
675 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
676 if (screenId != VIRTUAL_SCREEN_ID) {
677 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
678 }
679
680 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_BATTERY;
681 ScreenPowerState state = ScreenPowerState::POWER_ON;
682 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
683
684 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
685 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
686 }
687
688 /**
689 * @tc.name: SetScreenPowerForAll04
690 * @tc.desc: SetScreenPowerForAll04 test
691 * @tc.type: FUNC
692 */
693 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll04, Function | SmallTest | Level3)
694 {
695 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
696 EXPECT_NE(displayManagerAgent, nullptr);
697
698 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
699 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
700
701 VirtualScreenOption virtualOption;
702 virtualOption.name_ = "createVirtualOption";
703 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
704 if (screenId != VIRTUAL_SCREEN_ID) {
705 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
706 }
707
708 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_THERMAL;
709 ScreenPowerState state = ScreenPowerState::POWER_ON;
710 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
711
712 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
713 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
714 }
715
716 /**
717 * @tc.name: SetScreenPowerForAll05
718 * @tc.desc: SetScreenPowerForAll05 test
719 * @tc.type: FUNC
720 */
721 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll05, Function | SmallTest | Level3)
722 {
723 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
724 EXPECT_NE(displayManagerAgent, nullptr);
725
726 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
727 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
728
729 VirtualScreenOption virtualOption;
730 virtualOption.name_ = "createVirtualOption";
731 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
732 if (screenId != VIRTUAL_SCREEN_ID) {
733 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
734 }
735
736 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_WORK;
737 ScreenPowerState state = ScreenPowerState::POWER_ON;
738 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
739
740 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
741 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
742 }
743
744 /**
745 * @tc.name: SetScreenPowerForAll06
746 * @tc.desc: SetScreenPowerForAll06 test
747 * @tc.type: FUNC
748 */
749 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll06, Function | SmallTest | Level3)
750 {
751 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
752 EXPECT_NE(displayManagerAgent, nullptr);
753
754 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
755 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
756
757 VirtualScreenOption virtualOption;
758 virtualOption.name_ = "createVirtualOption";
759 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
760 if (screenId != VIRTUAL_SCREEN_ID) {
761 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
762 }
763
764 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SYSTEM;
765 ScreenPowerState state = ScreenPowerState::POWER_ON;
766 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
767
768 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
769 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
770 }
771
772 /**
773 * @tc.name: SetScreenPowerForAll07
774 * @tc.desc: SetScreenPowerForAll07 test
775 * @tc.type: FUNC
776 */
777 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll07, Function | SmallTest | Level3)
778 {
779 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
780 EXPECT_NE(displayManagerAgent, nullptr);
781
782 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
783 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
784
785 VirtualScreenOption virtualOption;
786 virtualOption.name_ = "createVirtualOption";
787 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
788 if (screenId != VIRTUAL_SCREEN_ID) {
789 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
790 }
791
792 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_APPLICATION;
793 ScreenPowerState state = ScreenPowerState::POWER_ON;
794 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
795
796 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
797 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
798 }
799
800 /**
801 * @tc.name: SetScreenPowerForAll08
802 * @tc.desc: SetScreenPowerForAll08 test
803 * @tc.type: FUNC
804 */
805 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll08, Function | SmallTest | Level3)
806 {
807 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
808 EXPECT_NE(displayManagerAgent, nullptr);
809
810 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
811 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
812
813 VirtualScreenOption virtualOption;
814 virtualOption.name_ = "createVirtualOption";
815 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
816 if (screenId != VIRTUAL_SCREEN_ID) {
817 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
818 }
819
820 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SETTINGS;
821 ScreenPowerState state = ScreenPowerState::POWER_ON;
822 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
823
824 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
825 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
826 }
827
828 /**
829 * @tc.name: SetScreenPowerForAll09
830 * @tc.desc: SetScreenPowerForAll09 test
831 * @tc.type: FUNC
832 */
833 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll09, Function | SmallTest | Level3)
834 {
835 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
836 EXPECT_NE(displayManagerAgent, nullptr);
837
838 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
839 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
840
841 VirtualScreenOption virtualOption;
842 virtualOption.name_ = "createVirtualOption";
843 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
844 if (screenId != VIRTUAL_SCREEN_ID) {
845 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
846 }
847
848 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
849 ScreenPowerState state = ScreenPowerState::POWER_ON;
850 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
851
852 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
853 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
854 }
855
856 /**
857 * @tc.name: SetScreenPowerForAll10
858 * @tc.desc: SetScreenPowerForAll10 test
859 * @tc.type: FUNC
860 */
861 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll10, Function | SmallTest | Level3)
862 {
863 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
864 EXPECT_NE(displayManagerAgent, nullptr);
865
866 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
867 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
868
869 VirtualScreenOption virtualOption;
870 virtualOption.name_ = "createVirtualOption";
871 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
872 if (screenId != VIRTUAL_SCREEN_ID) {
873 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
874 }
875
876 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_TOUCH;
877 ScreenPowerState state = ScreenPowerState::POWER_ON;
878 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
879
880 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
881 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
882 }
883
884 /**
885 * @tc.name: ScreenChange
886 * @tc.desc: ScreenChange test
887 * @tc.type: FUNC
888 */
889 HWTEST_F(ScreenSessionManagerTest, ScreenChange, Function | SmallTest | Level3)
890 {
891 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
892 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
893 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
894 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
895 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
896 EXPECT_TRUE(1);
897
898 screenEvent = ScreenEvent::DISCONNECTED;
899 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
900 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
901 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
902 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
903 EXPECT_TRUE(1);
904 }
905
906 /**
907 * @tc.name: ScreenPower
908 * @tc.desc: ScreenSesionManager screen power
909 * @tc.type: FUNC
910 */
911 HWTEST_F(ScreenSessionManagerTest, ScreenPower, Function | SmallTest | Level3)
912 {
913 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
914 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
915 }
916 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
917 ScreenPowerState state = ScreenPowerState::POWER_ON;
918 DisplayState displayState = DisplayState::ON;
919
920 ASSERT_EQ(false, ssm_->WakeUpBegin(reason));
921 ASSERT_EQ(false, ssm_->WakeUpEnd());
922
923 ASSERT_EQ(false, ssm_->SuspendBegin(reason));
924 ASSERT_EQ(false, ssm_->SuspendEnd());
925
926 ASSERT_EQ(false, ssm_->SetScreenPowerForAll(state, reason));
927
928 DisplayId id = 0;
929 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
930 ssm_->screenSessionMap_[id] = screenSession;
931 ASSERT_EQ(true, ssm_->SetDisplayState(displayState));
932 ASSERT_EQ(DisplayState::ON, ssm_->GetDisplayState(0));
933 }
934
935 /**
936 * @tc.name: GetScreenPower
937 * @tc.desc: GetScreenPower screen power
938 * @tc.type: FUNC
939 */
940 HWTEST_F(ScreenSessionManagerTest, GetScreenPower, Function | SmallTest | Level3)
941 {
942 DisplayId id = 0;
943 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
944 ssm_->screenSessionMap_[id] = screenSession;
945 ssm_->GetScreenPower(0);
946 EXPECT_TRUE(1);
947 }
948
949 /**
950 * @tc.name: IsScreenRotationLocked
951 * @tc.desc: IsScreenRotationLocked test
952 * @tc.type: FUNC
953 */
954 HWTEST_F(ScreenSessionManagerTest, IsScreenRotationLocked, Function | SmallTest | Level3)
955 {
956 bool isLocked = false;
957 DisplayId id = 0;
958 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
959 ssm_->screenSessionMap_[id] = screenSession;
960 ASSERT_EQ(DMError::DM_OK, ssm_->IsScreenRotationLocked(isLocked));
961 }
962
963 /**
964 * @tc.name: SetOrientation
965 * @tc.desc: SetOrientation test
966 * @tc.type: FUNC
967 */
968 HWTEST_F(ScreenSessionManagerTest, SetOrientation, Function | SmallTest | Level3)
969 {
970 Orientation orientation = Orientation::HORIZONTAL;
971 ScreenId id = 0;
972 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
973 ssm_->screenSessionMap_[id] = screenSession;
974 ASSERT_EQ(DMError::DM_OK, ssm_->SetOrientation(id, orientation));
975 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetOrientation(SCREEN_ID_INVALID, orientation));
976 Orientation invalidOrientation = Orientation{20};
977 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetOrientation(id, invalidOrientation));
978 }
979
980 /**
981 * @tc.name: SetRotationFromWindow
982 * @tc.desc: SetRotationFromWindow test
983 * @tc.type: FUNC
984 */
985 HWTEST_F(ScreenSessionManagerTest, SetRotationFromWindow, Function | SmallTest | Level3)
986 {
987 Rotation targetRotation = Rotation::ROTATION_0;
988 ScreenId id = 0;
989 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
990 ssm_->screenSessionMap_[id] = screenSession;
991 ASSERT_EQ(ssm_->SetRotationFromWindow(targetRotation), ssm_->SetRotation(id, targetRotation, true));
992 }
993
994 /**
995 * @tc.name: GetDisplaySnapshot
996 * @tc.desc: ScreenSesionManager screen shot
997 * @tc.type: FUNC
998 */
999 HWTEST_F(ScreenSessionManagerTest, GetDisplaySnapshot, Function | SmallTest | Level3)
1000 {
1001 DisplayId displayId(0);
1002 DmErrorCode* errorCode = nullptr;
1003 ssm_->GetDisplaySnapshot(displayId, errorCode, false);
1004 EXPECT_TRUE(1);
1005 }
1006
1007 /**
1008 * @tc.name: VirtualScreen
1009 * @tc.desc: ScreenSesionManager virtual screen
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(ScreenSessionManagerTest, VirtualScreen, Function | SmallTest | Level3)
1013 {
1014 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
1015 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
1016 }
1017 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1018 VirtualScreenOption virtualOption;
1019 virtualOption.name_ = "testVirtualOption";
1020 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1021
1022 std::vector<ScreenId> mirrorScreenIds;
1023 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
1024 ScreenId screenGroupId{1};
1025 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1026 mirrorScreenIds.push_back(VIRTUAL_SCREEN_ID);
1027 ASSERT_NE(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1028
1029 mirrorScreenIds.push_back(screenId);
1030 ASSERT_EQ(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1031
1032 auto result1 = ssm_->SetVirtualScreenSurface(screenId, nullptr);
1033 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result1);
1034 sptr<IConsumerSurface> surface = OHOS::IConsumerSurface::Create();
1035 auto result2 = ssm_->SetVirtualScreenSurface(screenId, surface->GetProducer());
1036 ASSERT_EQ(DMError::DM_OK, result2);
1037 ASSERT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
1038 }
1039
1040 /**
1041 * @tc.name: AutoRotate
1042 * @tc.desc: ScreenSesionManager SetVirtualMirrorScreenCanvasRotation test
1043 * @tc.type: FUNC
1044 */
1045 HWTEST_F(ScreenSessionManagerTest, AutoRotate, Function | SmallTest | Level3)
1046 {
1047 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1048 VirtualScreenOption virtualOption;
1049 virtualOption.name_ = "testAutoRotate";
1050 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1051 if (screenId != VIRTUAL_SCREEN_ID) {
1052 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1053 }
1054
1055 auto result1 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, true);
1056 ASSERT_EQ(DMError::DM_OK, result1);
1057 auto result2 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, false);
1058 ASSERT_EQ(DMError::DM_OK, result2);
1059 ssm_->DestroyVirtualScreen(screenId);
1060 }
1061
1062 /**
1063 * @tc.name: GetScreenSession
1064 * @tc.desc: GetScreenSession virtual screen
1065 * @tc.type: FUNC
1066 */
1067 HWTEST_F(ScreenSessionManagerTest, GetScreenSession, Function | SmallTest | Level3)
1068 {
1069 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1070 VirtualScreenOption virtualOption;
1071 virtualOption.name_ = "GetScreenSession";
1072 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1073 if (screenId != VIRTUAL_SCREEN_ID) {
1074 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1075 }
1076 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1077 sptr<ScreenSession> screenSession =
1078 new (std::nothrow) ScreenSession("GetScreenSession", screenId, rsid, 0);
1079 ASSERT_NE(ssm_->GetScreenSession(screenId), screenSession);
1080 ssm_->DestroyVirtualScreen(screenId);
1081 }
1082
1083 /**
1084 * @tc.name: GetDefaultScreenSession
1085 * @tc.desc: GetDefaultScreenSession virtual screen
1086 * @tc.type: FUNC
1087 */
1088 HWTEST_F(ScreenSessionManagerTest, GetDefaultScreenSession, Function | SmallTest | Level3)
1089 {
1090 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1091 VirtualScreenOption virtualOption;
1092 virtualOption.name_ = "GetDefaultScreenSession";
1093 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1094 if (screenId != VIRTUAL_SCREEN_ID) {
1095 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1096 }
1097 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1098 sptr<ScreenSession> screenSession =
1099 new (std::nothrow) ScreenSession("GetDefaultScreenSession", screenId, rsid, 0);
1100 ASSERT_NE(ssm_->GetDefaultScreenSession(), screenSession);
1101 ssm_->DestroyVirtualScreen(screenId);
1102 }
1103
1104 /**
1105 * @tc.name: GetDefaultDisplayInfo
1106 * @tc.desc: GetDefaultDisplayInfo virtual screen
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F(ScreenSessionManagerTest, GetDefaultDisplayInfo, Function | SmallTest | Level3)
1110 {
1111 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1112 VirtualScreenOption virtualOption;
1113 virtualOption.name_ = "GetDefaultDisplayInfo";
1114 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1115 if (screenId != VIRTUAL_SCREEN_ID) {
1116 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1117 }
1118 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1119 sptr<ScreenSession> screenSession =
1120 new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
1121 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1122 if (ssm_->GetScreenSession(screenId) == nullptr) {
1123 ASSERT_EQ(ssm_->GetDefaultDisplayInfo(), nullptr);
1124 }
1125 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1126 ASSERT_NE(ssm_->GetDefaultDisplayInfo(), displayInfo);
1127 ssm_->DestroyVirtualScreen(screenId);
1128 }
1129
1130 /**
1131 * @tc.name: HookDisplayInfoByUid
1132 * @tc.desc: HookDisplayInfo by uid
1133 * @tc.type: FUNC
1134 */
1135 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid, Function | SmallTest | Level3)
1136 {
1137 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1138 VirtualScreenOption virtualOption;
1139 virtualOption.name_ = "GetDefaultScreenSession";
1140 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1141 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1142 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
1143 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
1144 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1145 ASSERT_NE(displayInfo, nullptr);
1146 uint32_t uid = 20020001;
1147 DMHookInfo dmHookInfo;
1148 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1149 displayHookMap[uid] = dmHookInfo;
1150 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
1151 displayInfo->SetWidth(100);
1152 ASSERT_EQ(displayInfo->GetWidth(), 100);
1153 displayInfo->SetHeight(100);
1154 ASSERT_EQ(displayInfo->GetHeight(), 100);
1155 displayInfo->SetVirtualPixelRatio(1.0);
1156 ASSERT_EQ(displayInfo->GetVirtualPixelRatio(), 1.0);
1157 displayInfo->SetRotation(Rotation::ROTATION_0);
1158 ASSERT_EQ(displayInfo->GetRotation(), Rotation::ROTATION_0);
1159 displayInfo->SetDisplayOrientation(DisplayOrientation::PORTRAIT);
1160 ASSERT_EQ(displayInfo->GetDisplayOrientation(), DisplayOrientation::PORTRAIT);
1161 ssm_->DestroyVirtualScreen(screenId);
1162 }
1163
1164 /**
1165 * @tc.name: GetDisplayInfoById
1166 * @tc.desc: GetDisplayInfoById virtual screen
1167 * @tc.type: FUNC
1168 */
1169 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoById, Function | SmallTest | Level3)
1170 {
1171 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1172 VirtualScreenOption virtualOption;
1173 virtualOption.name_ = "GetDisplayInfoById";
1174 ASSERT_EQ(ssm_->GetDisplayInfoById(1), nullptr);
1175 }
1176
1177 /**
1178 * @tc.name: GetDisplayInfoByScreen
1179 * @tc.desc: GetDisplayInfoByScreen virtual screen
1180 * @tc.type: FUNC
1181 */
1182 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoByScreen, Function | SmallTest | Level3)
1183 {
1184 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1185 VirtualScreenOption virtualOption;
1186 virtualOption.name_ = "GetDisplayInfoByScreen";
1187 ASSERT_EQ(ssm_->GetDisplayInfoByScreen(1), nullptr);
1188 }
1189
1190 /**
1191 * @tc.name: GetScreenInfoById
1192 * @tc.desc: GetScreenInfoById virtual screen
1193 * @tc.type: FUNC
1194 */
1195 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoById, Function | SmallTest | Level3)
1196 {
1197 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1198 VirtualScreenOption virtualOption;
1199 virtualOption.name_ = "GetScreenInfoById";
1200 ASSERT_EQ(ssm_->GetScreenInfoById(1), nullptr);
1201 }
1202
1203 /**
1204 * @tc.name: SetScreenActiveMode
1205 * @tc.desc: SetScreenActiveMode virtual screen
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(ScreenSessionManagerTest, SetScreenActiveMode, Function | SmallTest | Level3)
1209 {
1210 #ifdef WM_SCREEN_ACTIVE_MODE_ENABLE
1211 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1212 VirtualScreenOption virtualOption;
1213 virtualOption.name_ = "SetScreenActiveMode";
1214 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1215 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1216 ssm_->DestroyVirtualScreen(screenId);
1217 #endif
1218 }
1219
1220 /**
1221 * @tc.name: NotifyScreenChanged
1222 * @tc.desc: NotifyScreenChanged virtual screen
1223 * @tc.type: FUNC
1224 */
1225 HWTEST_F(ScreenSessionManagerTest, NotifyScreenChanged, Function | SmallTest | Level3)
1226 {
1227 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1228 VirtualScreenOption virtualOption;
1229 virtualOption.name_ = "NotifyScreenChanged";
1230 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1231 sptr<ScreenInfo> screenInfo;
1232 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
1233 screenInfo = new ScreenInfo();
1234 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
1235 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1236 ssm_->DestroyVirtualScreen(screenId);
1237 }
1238
1239 /**
1240 * @tc.name: NotifyDisplayEvent
1241 * @tc.desc: NotifyDisplayEvent virtual screen
1242 * @tc.type: FUNC
1243 */
1244 HWTEST_F(ScreenSessionManagerTest, NotifyDisplayEvent, Function | SmallTest | Level3)
1245 {
1246 DisplayEvent event = DisplayEvent::KEYGUARD_DRAWN;
1247 ssm_->NotifyDisplayEvent(event);
1248 ASSERT_EQ(ssm_->keyguardDrawnDone_, true);
1249
1250 event = DisplayEvent::SCREEN_LOCK_SUSPEND;
1251 ssm_->NotifyDisplayEvent(event);
1252 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1253
1254 event = DisplayEvent::SCREEN_LOCK_OFF;
1255 ssm_->NotifyDisplayEvent(event);
1256 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1257
1258 event = DisplayEvent::SCREEN_LOCK_FINGERPRINT;
1259 ssm_->NotifyDisplayEvent(event);
1260 ASSERT_EQ(ssm_->gotScreenlockFingerprint_, true);
1261
1262 ssm_->gotScreenOffNotify_ = false;
1263 event = DisplayEvent::SCREEN_LOCK_DOZE_FINISH;
1264 ssm_->NotifyDisplayEvent(event);
1265 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1266 }
1267
1268 /**
1269 * @tc.name: GetScreenInfoByDisplayId
1270 * @tc.desc: GetScreenInfoByDisplayId virtual screen
1271 * @tc.type: FUNC
1272 */
1273 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoByDisplayId, Function | SmallTest | Level3)
1274 {
1275 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1276 VirtualScreenOption virtualOption;
1277 virtualOption.name_ = "GetScreenInfoByDisplayId";
1278 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1279 sptr<ScreenInfo> screenInfo;
1280 screenInfo = ssm_->GetScreenInfoByDisplayId(screenId);
1281 ASSERT_NE(screenInfo, nullptr);
1282 ssm_->DestroyVirtualScreen(screenId);
1283 }
1284
1285 /**
1286 * @tc.name: GetScreenModesByDisplayId
1287 * @tc.desc: GetScreenModesByDisplayId virtual screen
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(ScreenSessionManagerTest, GetScreenModesByDisplayId, Function | SmallTest | Level3)
1291 {
1292 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1293 VirtualScreenOption virtualOption;
1294 virtualOption.name_ = "GetScreenModesByDisplayId";
1295 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1296 sptr<SupportedScreenModes> screenModes;
1297 screenModes = ssm_->GetScreenModesByDisplayId(screenId);
1298 ASSERT_NE(screenModes, nullptr);
1299 ssm_->DestroyVirtualScreen(screenId);
1300 }
1301
1302 /**
1303 * @tc.name: UpdateDisplayHookInfo001
1304 * @tc.desc: UpdateDisplayHookInfo by uid
1305 * @tc.type: FUNC
1306 */
1307 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo001, Function | SmallTest | Level3)
1308 {
1309 uint32_t uid = 20020001;
1310 DMHookInfo dmHookInfo;
1311 dmHookInfo.width_ = 100;
1312 dmHookInfo.height_ = 100;
1313 dmHookInfo.density_ = 1.0;
1314 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1315 displayHookMap[uid] = dmHookInfo;
1316 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
1317 auto info = displayHookMap[uid];
1318 ASSERT_EQ(info.width_, 100);
1319 ASSERT_EQ(info.height_, 100);
1320 ASSERT_EQ(info.density_, 1.0);
1321 }
1322
1323 /**
1324 * @tc.name: UpdateDisplayHookInfo002
1325 * @tc.desc: UpdateDisplayHookInfo by uid
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo002, Function | SmallTest | Level3)
1329 {
1330 uint32_t uid = 20020001;
1331 DMHookInfo dmHookInfo;
1332 dmHookInfo.width_ = 100;
1333 dmHookInfo.height_ = 100;
1334 dmHookInfo.density_ = 1.0;
1335 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1336 displayHookMap[uid] = dmHookInfo;
1337 displayHookMap.erase(uid);
1338 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), false);
1339 }
1340
1341 /**
1342 * @tc.name: SetVirtualPixelRatio
1343 * @tc.desc: SetVirtualPixelRatio virtual screen
1344 * @tc.type: FUNC
1345 */
1346 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatio, Function | SmallTest | Level3)
1347 {
1348 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1349 VirtualScreenOption virtualOption;
1350 virtualOption.name_ = "SetVirtualPixelRatio";
1351 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1352 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatio(screenId, 0.1));
1353 ssm_->DestroyVirtualScreen(screenId);
1354 }
1355
1356 /**
1357 * @tc.name: SetVirtualPixelRatioSystem
1358 * @tc.desc: SetVirtualPixelRatioSystem virtual screen
1359 * @tc.type: FUNC
1360 */
1361 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatioSystem, Function | SmallTest | Level3)
1362 {
1363 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1364 VirtualScreenOption virtualOption;
1365 virtualOption.name_ = "SetVirtualPixelRatioSystem";
1366 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1367 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatioSystem(screenId, 0.1));
1368 ssm_->DestroyVirtualScreen(screenId);
1369 }
1370
1371 /**
1372 * @tc.name: SetDefaultDensityDpi
1373 * @tc.desc: SetDefaultDensityDpi virtual screen
1374 * @tc.type: FUNC
1375 */
1376 HWTEST_F(ScreenSessionManagerTest, SetDefaultDensityDpi, Function | SmallTest | Level3)
1377 {
1378 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1379 VirtualScreenOption virtualOption;
1380 virtualOption.name_ = "SetDefaultDensityDpi";
1381 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1382 ASSERT_EQ(DMError::DM_OK, ssm_->SetDefaultDensityDpi(screenId, 0.1));
1383 ssm_->DestroyVirtualScreen(screenId);
1384 }
1385
1386 /**
1387 * @tc.name: SetResolution
1388 * @tc.desc: SetResolution virtual screen
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(ScreenSessionManagerTest, SetResolution, Function | SmallTest | Level3)
1392 {
1393 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1394 VirtualScreenOption virtualOption;
1395 virtualOption.name_ = "SetResolution";
1396 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1397 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1398 ssm_->screenSessionMap_[screenId] = screenSession;
1399 sptr<SupportedScreenModes> mode = new SupportedScreenModes();
1400 mode->width_ = 1;
1401 mode->height_ = 1;
1402 screenSession->modes_ = {mode};
1403 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetResolution(screenId, 100, 100, 0.5));
1404 ssm_->DestroyVirtualScreen(screenId);
1405 }
1406
1407 /**
1408 * @tc.name: GetScreenColorGamut
1409 * @tc.desc: GetScreenColorGamut virtual screen
1410 * @tc.type: FUNC
1411 */
1412 HWTEST_F(ScreenSessionManagerTest, GetScreenColorGamut, Function | SmallTest | Level3)
1413 {
1414 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1415 ScreenColorGamut colorGamut = ScreenColorGamut::COLOR_GAMUT_SRGB;
1416 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorGamut(1, colorGamut));
1417 DisplayId id = 0;
1418 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1419 ssm_->screenSessionMap_[id] = screenSession;
1420 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1421 ASSERT_EQ(DMError::DM_OK, ssm_->GetScreenColorGamut(id, colorGamut));
1422 } else {
1423 ASSERT_NE(DMError::DM_OK, ssm_->GetScreenColorGamut(id, colorGamut));
1424 }
1425 #endif
1426 }
1427
1428 /**
1429 * @tc.name: LoadScreenSceneXml
1430 * @tc.desc: LoadScreenSceneXml virtual screen
1431 * @tc.type: FUNC
1432 */
1433 HWTEST_F(ScreenSessionManagerTest, LoadScreenSceneXml, Function | SmallTest | Level3)
1434 {
1435 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1436 VirtualScreenOption virtualOption;
1437 virtualOption.name_ = "LoadScreenSceneXml";
1438 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1439 ssm_->LoadScreenSceneXml();
1440 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1441 ssm_->DestroyVirtualScreen(screenId);
1442 }
1443
1444 /**
1445 * @tc.name: GetScreenGamutMap
1446 * @tc.desc: GetScreenGamutMap virtual screen
1447 * @tc.type: FUNC
1448 */
1449 HWTEST_F(ScreenSessionManagerTest, GetScreenGamutMap, Function | SmallTest | Level3)
1450 {
1451 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1452 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1453 VirtualScreenOption virtualOption;
1454 virtualOption.name_ = "GetScreenGamutMap";
1455 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1456 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1457 sptr<ScreenSession> screenSession =
1458 new (std::nothrow) ScreenSession("GetScreenGamutMap", screenId, rsid, 0);
1459 ScreenGamutMap gamutMap;
1460 ASSERT_EQ(DMError::DM_OK, ssm_->GetScreenGamutMap(screenId, gamutMap));
1461 ssm_->DestroyVirtualScreen(screenId);
1462 #endif
1463 }
1464
1465 /**
1466 * @tc.name: MakeExpand
1467 * @tc.desc: MakeExpand virtual screen
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(ScreenSessionManagerTest, MakeExpand, Function | SmallTest | Level3)
1471 {
1472 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1473 VirtualScreenOption virtualOption;
1474 virtualOption.name_ = "MakeExpand";
1475 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1476 if (screenId != VIRTUAL_SCREEN_ID) {
1477 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1478 }
1479 std::vector<ScreenId> mirrorScreenIds;
1480 std::vector<Point> startPoints;
1481 ScreenId screenGroupId2 = DISPLAY_ID_INVALID;
1482 ASSERT_NE(DMError::DM_ERROR_RENDER_SERVICE_FAILED, ssm_->MakeExpand(mirrorScreenIds, startPoints, screenGroupId2));
1483 ssm_->DestroyVirtualScreen(screenId);
1484 }
1485
1486 /**
1487 * @tc.name: DeleteScreenId
1488 * @tc.desc: DeleteScreenId virtual screen
1489 * @tc.type: FUNC
1490 */
1491 HWTEST_F(ScreenSessionManagerTest, DeleteScreenId, Function | SmallTest | Level3)
1492 {
1493 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1494 VirtualScreenOption virtualOption;
1495 virtualOption.name_ = "DeleteScreenId";
1496 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1497 if (screenId != VIRTUAL_SCREEN_ID) {
1498 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1499 }
1500 ScreenSessionManager::ScreenIdManager sim;
1501 ASSERT_EQ(false, sim.DeleteScreenId(99));
1502 ssm_->DestroyVirtualScreen(screenId);
1503 }
1504
1505 /**
1506 * @tc.name: HasRsScreenId
1507 * @tc.desc: HasRsScreenId virtual screen
1508 * @tc.type: FUNC
1509 */
1510 HWTEST_F(ScreenSessionManagerTest, HasRsScreenId, Function | SmallTest | Level3)
1511 {
1512 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1513 VirtualScreenOption virtualOption;
1514 virtualOption.name_ = "HasRsScreenId";
1515
1516 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1517 if (screenId != VIRTUAL_SCREEN_ID) {
1518 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1519 }
1520 ScreenSessionManager::ScreenIdManager sim;
1521 ASSERT_EQ(false, sim.HasRsScreenId(99));
1522 ssm_->DestroyVirtualScreen(screenId);
1523 }
1524
1525 /**
1526 * @tc.name: AddAsFirstScreenLocked
1527 * @tc.desc: AddAsFirstScreenLocked virtual screen
1528 * @tc.type: FUNC
1529 */
1530 HWTEST_F(ScreenSessionManagerTest, AddAsFirstScreenLocked, Function | SmallTest | Level3)
1531 {
1532 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1533 VirtualScreenOption virtualOption;
1534 virtualOption.name_ = "AddAsFirstScreenLocked";
1535
1536 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1537 if (screenId != VIRTUAL_SCREEN_ID) {
1538 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1539 }
1540 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
1541 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1542 ASSERT_NE(sessiongroup, ssm_->AddAsFirstScreenLocked(newScreen));
1543 ssm_->DestroyVirtualScreen(screenId);
1544 }
1545
1546 /**
1547 * @tc.name: AddAsSuccedentScreenLocked
1548 * @tc.desc: AddAsSuccedentScreenLocked virtual screen
1549 * @tc.type: FUNC
1550 */
1551 HWTEST_F(ScreenSessionManagerTest, AddAsSuccedentScreenLocked, Function | SmallTest | Level3)
1552 {
1553 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1554 VirtualScreenOption virtualOption;
1555 virtualOption.name_ = "AddAsSuccedentScreenLocked";
1556
1557 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1558 if (screenId != VIRTUAL_SCREEN_ID) {
1559 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1560 }
1561 sptr<ScreenSession> newScreen;
1562 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1563 ASSERT_EQ(sessiongroup, ssm_->AddAsSuccedentScreenLocked(newScreen));
1564 ssm_->DestroyVirtualScreen(screenId);
1565 }
1566
1567 /**
1568 * @tc.name: SetMirror
1569 * @tc.desc: SetMirror virtual screen
1570 * @tc.type: FUNC
1571 */
1572 HWTEST_F(ScreenSessionManagerTest, SetMirror, Function | SmallTest | Level3)
1573 {
1574 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1575 VirtualScreenOption virtualOption;
1576 virtualOption.name_ = "SetMirror";
1577
1578 std::vector<ScreenId> screens{0, 1, 2, 3, 4, 5, 6, 7};
1579 sptr<ScreenSession> screenSession = nullptr;
1580 screenSession = new (std::nothrow) ScreenSession("GetScreenGamutMap", 2, 2, 3);
1581 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_{
1582 {2, screenSession},
1583 };
1584 ssm_->screenSessionMap_ = screenSessionMap_;
1585 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1586 auto screen = ssm_->GetScreenSession(2);
1587 screen->GetScreenProperty().SetScreenType(ScreenType::REAL);
1588 ASSERT_EQ(DMError::DM_OK, ssm_->SetMirror(2, screens, DMRect::NONE()));
1589 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetMirror(9, screens, DMRect::NONE()));
1590 ASSERT_EQ(DMError::DM_OK, ssm_->SetMirror(screenId, screens, DMRect::NONE()));
1591 auto mirrorscreen = ssm_->GetScreenSession(screenId);
1592 ASSERT_TRUE(mirrorscreen != nullptr);
1593 mirrorscreen->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1594 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetMirror(screenId, screens, DMRect::NONE()));
1595 ssm_->DestroyVirtualScreen(screenId);
1596 }
1597
1598 /**
1599 * @tc.name: GetAbstractScreenGroup
1600 * @tc.desc: GetAbstractScreenGroup virtual screen
1601 * @tc.type: FUNC
1602 */
1603 HWTEST_F(ScreenSessionManagerTest, GetAbstractScreenGroup, Function | SmallTest | Level3)
1604 {
1605 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1606 VirtualScreenOption virtualOption;
1607 virtualOption.name_ = "GetAbstractScreenGroup";
1608
1609 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1610 if (screenId != VIRTUAL_SCREEN_ID) {
1611 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1612 }
1613 sptr<ScreenSessionGroup> sreengroup=nullptr;
1614 ASSERT_EQ(sreengroup, ssm_->GetAbstractScreenGroup(2));
1615 ssm_->DestroyVirtualScreen(screenId);
1616 }
1617
1618 /**
1619 * @tc.name: InitAbstractScreenModesInfo
1620 * @tc.desc: InitAbstractScreenModesInfo virtual screen
1621 * @tc.type: FUNC
1622 */
1623 HWTEST_F(ScreenSessionManagerTest, InitAbstractScreenModesInfo, Function | SmallTest | Level3)
1624 {
1625 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1626 VirtualScreenOption virtualOption;
1627 virtualOption.name_ = "InitAbstractScreenModesInfo";
1628
1629 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1630 if (screenId != VIRTUAL_SCREEN_ID) {
1631 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1632 }
1633 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1634 ASSERT_EQ(true, ssm_->InitAbstractScreenModesInfo(screenSession));
1635 ssm_->DestroyVirtualScreen(screenId);
1636 }
1637
1638 /**
1639 * @tc.name: AddToGroupLocked
1640 * @tc.desc: AddToGroupLocked virtual screen
1641 * @tc.type: FUNC
1642 */
1643 HWTEST_F(ScreenSessionManagerTest, AddToGroupLocked, Function | SmallTest | Level3)
1644 {
1645 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1646 VirtualScreenOption virtualOption;
1647 virtualOption.name_ = "AddToGroupLocked";
1648
1649 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1650 if (screenId != VIRTUAL_SCREEN_ID) {
1651 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1652 }
1653 sptr<ScreenSession> newScreen=nullptr;
1654 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1655 ASSERT_EQ(sessiongroup, ssm_->AddToGroupLocked(newScreen));
1656 ssm_->DestroyVirtualScreen(screenId);
1657 }
1658
1659 /**
1660 * @tc.name: InitVirtualScreen
1661 * @tc.desc: InitVirtualScreen virtual screen
1662 * @tc.type: FUNC
1663 */
1664 HWTEST_F(ScreenSessionManagerTest, InitVirtualScreen, Function | SmallTest | Level3)
1665 {
1666 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1667 VirtualScreenOption virtualOption;
1668 virtualOption.name_ = "InitVirtualScreen";
1669 sptr<ScreenSession> screenSession;
1670 VirtualScreenOption option;
1671 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
1672 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1673 if (screenId != VIRTUAL_SCREEN_ID) {
1674 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1675 }
1676 screenSession =new (std::nothrow) ScreenSession();
1677 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
1678 ssm_->DestroyVirtualScreen(screenId);
1679 }
1680
1681 /**
1682 * @tc.name: InitAndGetScreen
1683 * @tc.desc: InitAndGetScreen virtual screen
1684 * @tc.type: FUNC
1685 */
1686 HWTEST_F(ScreenSessionManagerTest, InitAndGetScreen, Function | SmallTest | Level3)
1687 {
1688 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1689 VirtualScreenOption virtualOption;
1690 virtualOption.name_ = "InitAndGetScreen";
1691
1692 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1693 if (screenId != VIRTUAL_SCREEN_ID) {
1694 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1695 }
1696 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1697 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1698 ssm_->DestroyVirtualScreen(screenId);
1699 }
1700
1701 /**
1702 * @tc.name: RemoveFromGroupLocked
1703 * @tc.desc: RemoveFromGroupLocked virtual screen
1704 * @tc.type: FUNC
1705 */
1706 HWTEST_F(ScreenSessionManagerTest, RemoveFromGroupLocked, Function | SmallTest | Level3)
1707 {
1708 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1709 VirtualScreenOption virtualOption;
1710 virtualOption.name_ = "RemoveFromGroupLocked";
1711
1712 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1713 if (screenId != VIRTUAL_SCREEN_ID) {
1714 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1715 }
1716 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
1717 sptr<ScreenSessionGroup> sessiongroup;
1718 ASSERT_EQ(sessiongroup, ssm_->RemoveFromGroupLocked(newScreen));
1719 ssm_->DestroyVirtualScreen(screenId);
1720 }
1721
1722 /**
1723 * @tc.name: CreateAndGetNewScreenId
1724 * @tc.desc: CreateAndGetNewScreenId virtual screen
1725 * @tc.type: FUNC
1726 */
1727 HWTEST_F(ScreenSessionManagerTest, CreateAndGetNewScreenId, Function | SmallTest | Level3)
1728 {
1729 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1730 VirtualScreenOption virtualOption;
1731 virtualOption.name_ = "CreateAndGetNewScreenId";
1732 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1733 ScreenSessionManager::ScreenIdManager sim;
1734 ASSERT_EQ(1000, sim.CreateAndGetNewScreenId(screenId));
1735 ssm_->DestroyVirtualScreen(screenId);
1736 }
1737
1738 /**
1739 * @tc.name: AddScreenToGroup
1740 * @tc.desc: AddScreenToGroup virtual screen
1741 * @tc.type: FUNC
1742 */
1743 HWTEST_F(ScreenSessionManagerTest, AddScreenToGroup, Function | SmallTest | Level3)
1744 {
1745 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1746 VirtualScreenOption virtualOption;
1747 virtualOption.name_ = "AddScreenToGroup";
1748 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1749 if (screenId != VIRTUAL_SCREEN_ID) {
1750 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1751 }
1752 const std::vector<ScreenId> addScreens;
1753 const std::vector<Point> addChildPos;
1754 std::map<ScreenId, bool> removeChildResMap;
1755 sptr<ScreenSessionGroup> group;
1756 ssm_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
1757 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1758 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1759 ssm_->DestroyVirtualScreen(screenId);
1760 }
1761
1762 /**
1763 * @tc.name: GetRSDisplayNodeByScreenId
1764 * @tc.desc: GetRSDisplayNodeByScreenId virtual screen
1765 * @tc.type: FUNC
1766 */
1767 HWTEST_F(ScreenSessionManagerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
1768 {
1769 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1770 VirtualScreenOption virtualOption;
1771 virtualOption.name_ = "GetRSDisplayNodeByScreenId";
1772 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1773 if (screenId != VIRTUAL_SCREEN_ID) {
1774 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1775 }
1776 ssm_->GetRSDisplayNodeByScreenId(2);
1777 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1778 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1779 ssm_->DestroyVirtualScreen(screenId);
1780 }
1781
1782 /**
1783 * @tc.name: GetAllDisplayIds
1784 * @tc.desc: GetAllDisplayIds virtual screen
1785 * @tc.type: FUNC
1786 */
1787 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayIds, Function | SmallTest | Level3)
1788 {
1789 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1790 VirtualScreenOption virtualOption;
1791 virtualOption.name_ = "GetAllDisplayIds";
1792 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1793 if (screenId != VIRTUAL_SCREEN_ID) {
1794 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1795 }
1796 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1797 std::vector<DisplayId> displays(2);
1798 ASSERT_NE(displays, ssm_->GetAllDisplayIds());
1799 ssm_->DestroyVirtualScreen(screenId);
1800 }
1801
1802 /**
1803 * @tc.name: SetScreenGamutMap
1804 * @tc.desc: SetScreenGamutMap virtual screen
1805 * @tc.type: FUNC
1806 */
1807 HWTEST_F(ScreenSessionManagerTest, SetScreenGamutMap, Function | SmallTest | Level3)
1808 {
1809 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1810 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1811 VirtualScreenOption virtualOption;
1812 virtualOption.name_ = "SetScreenGamutMap";
1813 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1814 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1815 sptr<ScreenSession> screenSession =
1816 new (std::nothrow) ScreenSession("SetScreenGamutMap", screenId, rsid, 0);
1817 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM,
1818 ssm_->SetScreenGamutMap(SCREEN_ID_INVALID, ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION));
1819 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenGamutMap(screenId, ScreenGamutMap::GAMUT_MAP_EXTENSION));
1820 ssm_->DestroyVirtualScreen(screenId);
1821 #endif
1822 }
1823
1824 /**
1825 * @tc.name: StopExpand
1826 * @tc.desc: StopExpand virtual screen
1827 * @tc.type: FUNC
1828 */
1829 HWTEST_F(ScreenSessionManagerTest, StopExpand, Function | SmallTest | Level3)
1830 {
1831 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1832 VirtualScreenOption virtualOption;
1833 virtualOption.name_ = "StopExpand";
1834 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1835 if (screenId != VIRTUAL_SCREEN_ID) {
1836 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1837 }
1838 std::vector<ScreenId> expandScreenIds {0, 1, 2, 3, 4, 5};
1839 ASSERT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->StopExpand(expandScreenIds));
1840 ssm_->DestroyVirtualScreen(screenId);
1841 }
1842
1843 /**
1844 * @tc.name: OnScreenDisconnect
1845 * @tc.desc: OnScreenDisconnect virtual screen
1846 * @tc.type: FUNC
1847 */
1848 HWTEST_F(ScreenSessionManagerTest, OnScreenDisconnect, Function | SmallTest | Level3)
1849 {
1850 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1851 VirtualScreenOption virtualOption;
1852 virtualOption.name_ = "OnScreenDisconnect";
1853 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1854 if (screenId != VIRTUAL_SCREEN_ID) {
1855 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1856 }
1857 ssm_->OnScreenDisconnect(1);
1858 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1859 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1860 ssm_->DestroyVirtualScreen(screenId);
1861 }
1862
1863 /**
1864 * @tc.name: SetScreenColorGamut
1865 * @tc.desc: SetScreenColorGamut virtual screen
1866 * @tc.type: FUNC
1867 */
1868 HWTEST_F(ScreenSessionManagerTest, SetScreenColorGamut, Function | SmallTest | Level3)
1869 {
1870 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1871 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1872 VirtualScreenOption virtualOption;
1873 virtualOption.name_ = "SetScreenColorGamut";
1874 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1875 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1876 sptr<ScreenSession> screenSession =
1877 new (std::nothrow) ScreenSession("SetScreenColorGamut", screenId, rsid, 0);
1878 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorGamut(screenId, 2));
1879 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorGamut(SCREEN_ID_INVALID, 2));
1880 ssm_->DestroyVirtualScreen(screenId);
1881 #endif
1882 }
1883
1884 /**
1885 * @tc.name: SetScreenColorTransform
1886 * @tc.desc: SetScreenColorTransform virtual screen
1887 * @tc.type: FUNC
1888 */
1889 HWTEST_F(ScreenSessionManagerTest, SetScreenColorTransform, Function | SmallTest | Level3)
1890 {
1891 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1892 VirtualScreenOption virtualOption;
1893 virtualOption.name_ = "SetScreenColorTransform";
1894 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1895 if (screenId != VIRTUAL_SCREEN_ID) {
1896 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1897 }
1898 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1899 sptr<ScreenSession> screenSession =
1900 new (std::nothrow) ScreenSession("SetScreenColorTransform", screenId, rsid, 0);
1901 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorTransform(screenId));
1902 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorTransform(SCREEN_ID_INVALID));
1903 ssm_->DestroyVirtualScreen(screenId);
1904 }
1905
1906 /**
1907 * @tc.name: SetScreenRotationLocked
1908 * @tc.desc: SetScreenRotationLocked virtual screen
1909 * @tc.type: FUNC
1910 */
1911 HWTEST_F(ScreenSessionManagerTest, SetScreenRotationLocked, Function | SmallTest | Level3)
1912 {
1913 ScreenId id = 0;
1914 ssm_->screenSessionMap_[id] = nullptr;
1915 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenRotationLocked(false));
1916 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1917 ssm_->screenSessionMap_[id] = screenSession;
1918 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenRotationLocked(false));
1919 }
1920
1921 /**
1922 * @tc.name: UpdateScreenRotationProperty
1923 * @tc.desc: UpdateScreenRotationProperty virtual screen
1924 * @tc.type: FUNC
1925 */
1926 HWTEST_F(ScreenSessionManagerTest, UpdateScreenRotationProperty, Function | SmallTest | Level3)
1927 {
1928 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
1929 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
1930 }
1931 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1932 VirtualScreenOption virtualOption;
1933 virtualOption.name_ = "UpdateScreenRotationProperty";
1934 RRect bounds;
1935 bounds.rect_.width_ = 1344;
1936 bounds.rect_.height_ = 2772;
1937 int rotation = 1;
1938 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
1939 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(1, bounds, 1, screenPropertyChangeType);
1940 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(virtualOption,
1941 displayManagerAgent->AsObject());
1942 if (screenId != VIRTUAL_SCREEN_ID) {
1943 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1944 }
1945 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(1, bounds, rotation,
1946 screenPropertyChangeType);
1947 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession();
1948 ASSERT_NE(screenSession, ScreenSessionManager::GetInstance().InitAndGetScreen(2));
1949 ssm_->DestroyVirtualScreen(screenId);
1950 }
1951
1952 /**
1953 * @tc.name: MakeUniqueScreen
1954 * @tc.desc: Make unique screen
1955 * @tc.type: FUNC
1956 */
1957 HWTEST_F(ScreenSessionManagerTest, MakeUniqueScreen, Function | SmallTest | Level3)
1958 {
1959 #ifdef WM_MULTI_SCREEN_ENABLE
1960 vector<ScreenId> screenIds;
1961 screenIds.clear();
1962 std::vector<DisplayId> displayIds;
1963 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->MakeUniqueScreen(screenIds, displayIds));
1964 #endif
1965 }
1966
1967 /**
1968 * @tc.name: ConvertScreenIdToRsScreenId
1969 * @tc.desc: convert screen id to RS screen id
1970 * @tc.type: FUNC
1971 */
1972 HWTEST_F(ScreenSessionManagerTest, ConvertScreenIdToRsScreenId, Function | SmallTest | Level3)
1973 {
1974 ScreenId rsScreenId = VIRTUAL_SCREEN_RS_ID;
1975 ssm_->screenIdManager_.rs2SmsScreenIdMap_.erase(rsScreenId);
1976 ScreenId screenId = ssm_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId);
1977 ASSERT_EQ(true, ssm_->screenIdManager_.HasRsScreenId(rsScreenId));
1978 ScreenId tmpRsScreenId = SCREEN_ID_INVALID;
1979 ASSERT_EQ(true, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
1980 ASSERT_EQ(tmpRsScreenId, rsScreenId);
1981 ssm_->screenIdManager_.DeleteScreenId(screenId);
1982 ASSERT_EQ(false, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
1983 }
1984
1985 /**
1986 * @tc.name: DisableMirror
1987 * @tc.desc: DisableMirror test
1988 * @tc.type: FUNC
1989 */
1990 HWTEST_F(ScreenSessionManagerTest, DisableMirror, Function | SmallTest | Level3)
1991 {
1992 ASSERT_EQ(DMError::DM_OK, ssm_->DisableMirror(false));
1993 }
1994
1995 /**
1996 * @tc.name: HasImmersiveWindow
1997 * @tc.desc: HasImmersiveWindow test
1998 * @tc.type: FUNC
1999 */
2000 HWTEST_F(ScreenSessionManagerTest, HasImmersiveWindow, Function | SmallTest | Level3)
2001 {
2002 bool immersive = false;
2003 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(0u, immersive));
2004 immersive = true;
2005 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(0u, immersive));
2006 }
2007
2008 /**
2009 * @tc.name: SetSpecifiedScreenPower
2010 * @tc.desc: ScreenSessionManager screen power
2011 * @tc.type: FUNC
2012 */
2013 HWTEST_F(ScreenSessionManagerTest, SetSpecifiedScreenPower, Function | SmallTest | Level3)
2014 {
2015 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
2016 ScreenPowerState state = ScreenPowerState::POWER_ON;
2017 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
2018 ASSERT_EQ(false, ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
2019
2020 reason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
2021 EXPECT_TRUE(ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
2022 }
2023
2024 /**
2025 * @tc.name: NotifyFoldStatusChanged
2026 * @tc.desc: ScreenSessionManager notify foldStatus changed
2027 * @tc.type: FUNC
2028 */
2029 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged, Function | SmallTest | Level3)
2030 {
2031 const std::string& dumpParam = "-p";
2032 if (ssm_ != nullptr)
2033 {
2034 int errCode = ssm_->NotifyFoldStatusChanged(dumpParam);
2035 ASSERT_EQ(errCode, 0);
2036 } else {
2037 ASSERT_EQ(1, 0);
2038 }
2039 }
2040
2041 /**
2042 * @tc.name: NotifyPrivateWindowListChanged
2043 * @tc.desc: ScreenSessionManager notify PrivateWindowList changed
2044 * @tc.type: FUNC
2045 */
2046 HWTEST_F(ScreenSessionManagerTest, NotifyPrivateWindowListChanged, Function | SmallTest | Level3)
2047 {
2048 DisplayId id = 0;
2049 std::vector<std::string> privacyWindowList{"win0", "win1"};
2050 if (ssm_ != nullptr)
2051 {
2052 ssm_->NotifyPrivateWindowListChanged(id, privacyWindowList);
2053 ASSERT_EQ(0, 0);
2054 } else {
2055 ASSERT_EQ(1, 0);
2056 }
2057 }
2058
2059 /**
2060 * @tc.name: SetPrivacyStateByDisplayId01
2061 * @tc.desc: SetPrivacyStateByDisplayId true test
2062 * @tc.type: FUNC
2063 */
2064 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId01, Function | SmallTest | Level3)
2065 {
2066 DisplayId id = 0;
2067 bool hasPrivate = true;
2068 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2069 ssm_->screenSessionMap_[id] = screenSession;
2070 ASSERT_NE(nullptr, screenSession);
2071 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
2072 bool result = screenSession->HasPrivateSessionForeground();
2073 EXPECT_EQ(result, true);
2074 }
2075
2076 /**
2077 * @tc.name: SetPrivacyStateByDisplayId02
2078 * @tc.desc: SetPrivacyStateByDisplayId false test
2079 * @tc.type: FUNC
2080 */
2081 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId02, Function | SmallTest | Level3)
2082 {
2083 DisplayId id = 0;
2084 bool hasPrivate = false;
2085 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2086 ssm_->screenSessionMap_[id] = screenSession;
2087 ASSERT_NE(nullptr, screenSession);
2088 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
2089 bool result = screenSession->HasPrivateSessionForeground();
2090 EXPECT_EQ(result, false);
2091 }
2092
2093 /**
2094 * @tc.name: SetScreenPrivacyWindowList
2095 * @tc.desc: SetScreenPrivacyWindowList test
2096 * @tc.type: FUNC
2097 */
2098 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyWindowList, Function | SmallTest | Level3)
2099 {
2100 DisplayId id = 0;
2101 std::vector<std::string> privacyWindowList{"win0", "win1"};
2102 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2103 ASSERT_NE(nullptr, screenSession);
2104 ssm_->SetScreenPrivacyWindowList(id, privacyWindowList);
2105 ASSERT_EQ(0, 0);
2106 }
2107
2108 /**
2109 * @tc.name: GetAllScreenIds
2110 * @tc.desc: GetAllScreenIds screen power
2111 * @tc.type: FUNC
2112 */
2113 HWTEST_F(ScreenSessionManagerTest, GetAllScreenIds, Function | SmallTest | Level3)
2114 {
2115 sptr<ScreenSession> screenSession = new ScreenSession();
2116 ASSERT_NE(nullptr, screenSession);
2117 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
2118 ssm_->GetAllScreenIds();
2119 EXPECT_TRUE(1);
2120 }
2121
2122 /**
2123 * @tc.name: GetAllScreenInfos
2124 * @tc.desc: GetAllScreenInfos test
2125 * @tc.type: FUNC
2126 */
2127 HWTEST_F(ScreenSessionManagerTest, GetAllScreenInfos, Function | SmallTest | Level3)
2128 {
2129 ScreenId id = 0;
2130 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2131 ssm_->screenSessionMap_[id] = screenSession;
2132 ASSERT_NE(nullptr, screenSession);
2133 std::vector<sptr<ScreenInfo>> screenInfos;
2134 EXPECT_EQ(DMError::DM_OK, ssm_->GetAllScreenInfos(screenInfos));
2135 }
2136
2137 /**
2138 * @tc.name: GetScreenSupportedColorGamuts
2139 * @tc.desc: GetScreenSupportedColorGamuts test
2140 * @tc.type: FUNC
2141 */
2142 HWTEST_F(ScreenSessionManagerTest, GetScreenSupportedColorGamuts, Function | SmallTest | Level3)
2143 {
2144 std::vector<ScreenColorGamut> colorGamuts;
2145 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenSupportedColorGamuts(SCREEN_ID_INVALID, colorGamuts));
2146 ScreenId id = 0;
2147 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2148 ssm_->screenSessionMap_[id] = screenSession;
2149 ASSERT_NE(nullptr, screenSession);
2150 EXPECT_EQ(ssm_->GetScreenSupportedColorGamuts(id, colorGamuts),
2151 screenSession->GetScreenSupportedColorGamuts(colorGamuts));
2152 }
2153
2154 /**
2155 * @tc.name: GetPixelFormat
2156 * @tc.desc: GetPixelFormat test
2157 * @tc.type: FUNC
2158 */
2159 HWTEST_F(ScreenSessionManagerTest, GetPixelFormat, Function | SmallTest | Level3)
2160 {
2161 GraphicPixelFormat pixelFormat;
2162 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
2163 ScreenId id = 0;
2164 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2165 ssm_->screenSessionMap_[id] = screenSession;
2166 ASSERT_NE(nullptr, screenSession);
2167 EXPECT_EQ(ssm_->GetPixelFormat(id, pixelFormat), screenSession->GetPixelFormat(pixelFormat));
2168 }
2169
2170 /**
2171 * @tc.name: SetPixelFormat
2172 * @tc.desc: SetPixelFormat test
2173 * @tc.type: FUNC
2174 */
2175 HWTEST_F(ScreenSessionManagerTest, SetPixelFormat, Function | SmallTest | Level3)
2176 {
2177 GraphicPixelFormat pixelFormat = GraphicPixelFormat{GRAPHIC_PIXEL_FMT_CLUT8};
2178 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
2179 ScreenId id = 0;
2180 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2181 ssm_->screenSessionMap_[id] = screenSession;
2182 ASSERT_NE(nullptr, screenSession);
2183 EXPECT_EQ(ssm_->SetPixelFormat(id, pixelFormat), screenSession->SetPixelFormat(pixelFormat));
2184 }
2185
2186 /**
2187 * @tc.name: GetSupportedHDRFormats
2188 * @tc.desc: GetSupportedHDRFormats test
2189 * @tc.type: FUNC
2190 */
2191 HWTEST_F(ScreenSessionManagerTest, GetSupportedHDRFormats, Function | SmallTest | Level3)
2192 {
2193 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2194 std::vector<ScreenHDRFormat> hdrFormats;
2195 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedHDRFormats(SCREEN_ID_INVALID, hdrFormats));
2196 ScreenId id = 0;
2197 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2198 ssm_->screenSessionMap_[id] = screenSession;
2199 ASSERT_NE(nullptr, screenSession);
2200 EXPECT_EQ(ssm_->GetSupportedHDRFormats(id, hdrFormats), screenSession->GetSupportedHDRFormats(hdrFormats));
2201 #endif
2202 }
2203
2204 /**
2205 * @tc.name: GetScreenHDRFormat
2206 * @tc.desc: GetScreenHDRFormat test
2207 * @tc.type: FUNC
2208 */
2209 HWTEST_F(ScreenSessionManagerTest, GetScreenHDRFormat, Function | SmallTest | Level3)
2210 {
2211 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2212 ScreenHDRFormat hdrFormat;
2213 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenHDRFormat(SCREEN_ID_INVALID, hdrFormat));
2214 ScreenId id = 0;
2215 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2216 ssm_->screenSessionMap_[id] = screenSession;
2217 ASSERT_NE(nullptr, screenSession);
2218 EXPECT_EQ(ssm_->GetScreenHDRFormat(id, hdrFormat), screenSession->GetScreenHDRFormat(hdrFormat));
2219 #endif
2220 }
2221
2222 /**
2223 * @tc.name: SetScreenHDRFormat
2224 * @tc.desc: SetScreenHDRFormat test
2225 * @tc.type: FUNC
2226 */
2227 HWTEST_F(ScreenSessionManagerTest, SetScreenHDRFormat, Function | SmallTest | Level3)
2228 {
2229 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2230 int32_t modeIdx {0};
2231 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenHDRFormat(SCREEN_ID_INVALID, modeIdx));
2232 ScreenId id = 0;
2233 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2234 ssm_->screenSessionMap_[id] = screenSession;
2235 ASSERT_NE(nullptr, screenSession);
2236 EXPECT_EQ(ssm_->SetScreenHDRFormat(id, modeIdx), screenSession->SetScreenHDRFormat(modeIdx));
2237 #endif
2238 }
2239
2240 /**
2241 * @tc.name: GetSupportedColorSpaces
2242 * @tc.desc: GetSupportedColorSpaces test
2243 * @tc.type: FUNC
2244 */
2245 HWTEST_F(ScreenSessionManagerTest, GetSupportedColorSpaces, Function | SmallTest | Level3)
2246 {
2247 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2248 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
2249 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedColorSpaces(SCREEN_ID_INVALID, colorSpaces));
2250 ScreenId id = 0;
2251 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2252 ssm_->screenSessionMap_[id] = screenSession;
2253 ASSERT_NE(nullptr, screenSession);
2254 EXPECT_EQ(ssm_->GetSupportedColorSpaces(id, colorSpaces), screenSession->GetSupportedColorSpaces(colorSpaces));
2255 #endif
2256 }
2257
2258 /**
2259 * @tc.name: GetScreenColorSpace
2260 * @tc.desc: GetScreenColorSpace test
2261 * @tc.type: FUNC
2262 */
2263 HWTEST_F(ScreenSessionManagerTest, GetScreenColorSpace, Function | SmallTest | Level3)
2264 {
2265 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2266 GraphicCM_ColorSpaceType colorSpace;
2267 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
2268 ScreenId id = 0;
2269 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2270 ssm_->screenSessionMap_[id] = screenSession;
2271 ASSERT_NE(nullptr, screenSession);
2272 EXPECT_EQ(ssm_->GetScreenColorSpace(id, colorSpace), screenSession->GetScreenColorSpace(colorSpace));
2273 #endif
2274 }
2275
2276 /**
2277 * @tc.name: SetScreenColorSpace
2278 * @tc.desc: SetScreenColorSpace test
2279 * @tc.type: FUNC
2280 */
2281 HWTEST_F(ScreenSessionManagerTest, SetScreenColorSpace, Function | SmallTest | Level3)
2282 {
2283 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2284 GraphicCM_ColorSpaceType colorSpace = GraphicCM_ColorSpaceType{GRAPHIC_CM_COLORSPACE_NONE};
2285 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
2286 ScreenId id = 0;
2287 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2288 ssm_->screenSessionMap_[id] = screenSession;
2289 ASSERT_NE(nullptr, screenSession);
2290 EXPECT_EQ(ssm_->SetScreenColorSpace(id, colorSpace), screenSession->SetScreenColorSpace(colorSpace));
2291 #endif
2292 }
2293
2294 /**
2295 * @tc.name: HasPrivateWindow
2296 * @tc.desc: HasPrivateWindow test
2297 * @tc.type: FUNC
2298 */
2299 HWTEST_F(ScreenSessionManagerTest, HasPrivateWindow, Function | SmallTest | Level3)
2300 {
2301 bool hasPrivateWindow;
2302 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->HasPrivateWindow(SCREEN_ID_INVALID, hasPrivateWindow));
2303 DisplayId id = 0;
2304 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2305 ssm_->screenSessionMap_[id] = screenSession;
2306 ASSERT_NE(nullptr, screenSession);
2307 EXPECT_EQ(DMError::DM_OK, ssm_->HasPrivateWindow(id, hasPrivateWindow));
2308 }
2309
2310 /**
2311 * @tc.name: GetAvailableArea
2312 * @tc.desc: GetAvailableArea test
2313 * @tc.type: FUNC
2314 */
2315 HWTEST_F(ScreenSessionManagerTest, GetAvailableArea, Function | SmallTest | Level3)
2316 {
2317 DMRect area;
2318 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetAvailableArea(SCREEN_ID_INVALID, area));
2319 DisplayId id = 0;
2320 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2321 ssm_->screenSessionMap_[id] = screenSession;
2322 ASSERT_NE(nullptr, screenSession);
2323 EXPECT_EQ(DMError::DM_OK, ssm_->GetAvailableArea(id, area));
2324 }
2325
2326 /**
2327 * @tc.name: ResetAllFreezeStatus
2328 * @tc.desc: ResetAllFreezeStatus test
2329 * @tc.type: FUNC
2330 */
2331 HWTEST_F(ScreenSessionManagerTest, ResetAllFreezeStatus, Function | SmallTest | Level3)
2332 {
2333 EXPECT_EQ(DMError::DM_OK, ssm_->ResetAllFreezeStatus());
2334 }
2335
2336 /**
2337 * @tc.name: SetVirtualScreenRefreshRate
2338 * @tc.desc: SetVirtualScreenRefreshRate test
2339 * @tc.type: FUNC
2340 */
2341 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenRefreshRate, Function | SmallTest | Level3)
2342 {
2343 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2344 ScreenId id = 0;
2345 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2346 ssm_->screenSessionMap_[id] = screenSession;
2347 uint32_t refreshInterval {2};
2348 VirtualScreenOption virtualOption;
2349 virtualOption.name_ = "createVirtualOption";
2350 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2351 if (screenId != VIRTUAL_SCREEN_ID) {
2352 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2353 }
2354 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(id, refreshInterval));
2355 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenRefreshRate(screenId, refreshInterval));
2356 uint32_t invalidRefreshInterval {0};
2357 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(screenId, invalidRefreshInterval));
2358 ssm_->DestroyVirtualScreen(screenId);
2359 }
2360
2361 /**
2362 * @tc.name: SetVirtualScreenFlag
2363 * @tc.desc: SetVirtualScreenFlag test
2364 * @tc.type: FUNC
2365 */
2366 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenFlag, Function | SmallTest | Level3)
2367 {
2368 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2369 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
2370 VirtualScreenOption virtualOption;
2371 virtualOption.name_ = "createVirtualOption";
2372 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2373 if (screenId != VIRTUAL_SCREEN_ID) {
2374 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2375 }
2376 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
2377 ssm_->DestroyVirtualScreen(screenId);
2378 }
2379
2380 /**
2381 * @tc.name: GetVirtualScreenFlag
2382 * @tc.desc: GetVirtualScreenFlag test
2383 * @tc.type: FUNC
2384 */
2385 HWTEST_F(ScreenSessionManagerTest, GetVirtualScreenFlag, Function | SmallTest | Level3)
2386 {
2387 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2388 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
2389 VirtualScreenOption virtualOption;
2390 virtualOption.name_ = "createVirtualOption";
2391 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2392 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2393
2394 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
2395 EXPECT_EQ(screenFlag, ssm_->GetVirtualScreenFlag(screenId));
2396 ssm_->DestroyVirtualScreen(screenId);
2397 }
2398
2399 /**
2400 * @tc.name: ResizeVirtualScreen
2401 * @tc.desc: ResizeVirtualScreen test
2402 * @tc.type: FUNC
2403 */
2404 HWTEST_F(ScreenSessionManagerTest, ResizeVirtualScreen, Function | SmallTest | Level3)
2405 {
2406 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2407 VirtualScreenOption virtualOption;
2408 virtualOption.name_ = "createVirtualOption";
2409 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2410 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2411
2412 uint32_t width {100};
2413 uint32_t height {100};
2414 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
2415 if (screenSession->GetDisplayNode() != nullptr) {
2416 EXPECT_EQ(DMError::DM_OK, ssm_->ResizeVirtualScreen(screenId, width, height));
2417 }
2418 ssm_->DestroyVirtualScreen(screenId);
2419 }
2420
2421 /**
2422 * @tc.name: SetVirtualMirrorScreenScaleMode
2423 * @tc.desc: SetVirtualMirrorScreenScaleMode test
2424 * @tc.type: FUNC
2425 */
2426 HWTEST_F(ScreenSessionManagerTest, SetVirtualMirrorScreenScaleMode, Function | SmallTest | Level3)
2427 {
2428 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2429 VirtualScreenOption virtualOption;
2430 virtualOption.name_ = "createVirtualOption";
2431 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2432 if (screenId != VIRTUAL_SCREEN_ID) {
2433 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2434 }
2435 ScreenScaleMode scaleMode = ScreenScaleMode::FILL_MODE;
2436 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualMirrorScreenScaleMode(screenId, scaleMode));
2437 ssm_->DestroyVirtualScreen(screenId);
2438 }
2439
2440 /**
2441 * @tc.name: StopMirror
2442 * @tc.desc: StopMirror test
2443 * @tc.type: FUNC
2444 */
2445 HWTEST_F(ScreenSessionManagerTest, StopMirror, Function | SmallTest | Level3)
2446 {
2447 std::vector<ScreenId> mirrorScreenIds {0, 1, 2, 3, 4, 5};
2448 EXPECT_EQ(DMError::DM_OK, ssm_->StopMirror(mirrorScreenIds));
2449 }
2450
2451 /**
2452 * @tc.name: GetDensityInCurResolution
2453 * @tc.desc: GetDensityInCurResolution screen power
2454 * @tc.type: FUNC
2455 */
2456 HWTEST_F(ScreenSessionManagerTest, GetDensityInCurResolution, Function | SmallTest | Level3)
2457 {
2458 sptr<ScreenSession> screenSession = new ScreenSession();
2459 ASSERT_NE(nullptr, screenSession);
2460 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
2461 ScreenId screenId = 100;
2462 float x = 3.14;
2463 auto res = ssm_->GetDensityInCurResolution(screenId, x);
2464 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, res);
2465 screenId = 1;
2466 res = ssm_->GetDensityInCurResolution(screenId, x);
2467 EXPECT_EQ(DMError::DM_OK, res);
2468 }
2469
2470 /**
2471 * @tc.name: SetScreenOffDelayTime
2472 * @tc.desc: SetScreenOffDelayTime test
2473 * @tc.type: FUNC
2474 */
2475 HWTEST_F(ScreenSessionManagerTest, SetScreenOffDelayTime, Function | SmallTest | Level3)
2476 {
2477 int32_t delay = CV_WAIT_SCREENOFF_MS - 1;
2478 int32_t ret = ssm_->SetScreenOffDelayTime(delay);
2479 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS);
2480
2481 delay = CV_WAIT_SCREENOFF_MS + 1;
2482 ret = ssm_->SetScreenOffDelayTime(delay);
2483 EXPECT_EQ(ret, delay);
2484
2485 delay = CV_WAIT_SCREENOFF_MS_MAX - 1;
2486 ret = ssm_->SetScreenOffDelayTime(delay);
2487 EXPECT_EQ(ret, delay);
2488
2489 delay = CV_WAIT_SCREENOFF_MS_MAX + 1;
2490 ret = ssm_->SetScreenOffDelayTime(delay);
2491 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS_MAX);
2492 }
2493
2494 /**
2495 * @tc.name: GetDeviceScreenConfig
2496 * @tc.desc: GetDeviceScreenConfig test
2497 * @tc.type: FUNC
2498 */
2499 HWTEST_F(ScreenSessionManagerTest, GetDeviceScreenConfig, Function | SmallTest | Level3)
2500 {
2501 DeviceScreenConfig deviceScreenConfig = ssm_->GetDeviceScreenConfig();
2502 EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
2503 }
2504
2505 /**
2506 * @tc.name: SetVirtualScreenBlackList
2507 * @tc.desc: SetVirtualScreenBlackList test
2508 * @tc.type: FUNC
2509 */
2510 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList01, Function | SmallTest | Level3)
2511 {
2512 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
2513 EXPECT_NE(displayManagerAgent, nullptr);
2514
2515 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
2516 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
2517
2518 VirtualScreenOption virtualOption;
2519 virtualOption.name_ = "createVirtualOption";
2520 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2521 if (screenId != VIRTUAL_SCREEN_ID) {
2522 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2523 }
2524 std::vector<uint64_t> windowId = {10, 20, 30};
2525 ssm_->SetVirtualScreenBlackList(screenId, windowId);
2526 ssm_->DestroyVirtualScreen(screenId);
2527 }
2528
2529 /**
2530 * @tc.name: SetVirtualScreenBlackList
2531 * @tc.desc: ConvertScreenIdToRsScreenId = false
2532 * @tc.type: FUNC
2533 */
2534 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList02, Function | SmallTest | Level3)
2535 {
2536 ScreenId screenId = 1010;
2537 ScreenId rsScreenId = SCREEN_ID_INVALID;
2538 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2539 std::vector<uint64_t> windowId = {10, 20, 30};
2540 ssm_->SetVirtualScreenBlackList(screenId, windowId);
2541 }
2542
2543 /**
2544 * @tc.name: SetVirtualDisplayMuteFlag
2545 * @tc.desc: SetVirtualDisplayMuteFlag test
2546 * @tc.type: FUNC
2547 */
2548 HWTEST_F(ScreenSessionManagerTest, SetVirtualDisplayMuteFlag01, Function | SmallTest | Level3)
2549 {
2550 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
2551 EXPECT_NE(displayManagerAgent, nullptr);
2552
2553 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
2554 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
2555
2556 VirtualScreenOption virtualOption;
2557 virtualOption.name_ = "createVirtualOption";
2558 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2559 if (screenId != VIRTUAL_SCREEN_ID) {
2560 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2561 }
2562 bool muteFlag = false;
2563 ssm_->SetVirtualDisplayMuteFlag(screenId, muteFlag);
2564 ssm_->DestroyVirtualScreen(screenId);
2565 }
2566
2567 /**
2568 * @tc.name: SetVirtualDisplayMuteFlag
2569 * @tc.desc: ConvertScreenIdToRsScreenId = false
2570 * @tc.type: FUNC
2571 */
2572 HWTEST_F(ScreenSessionManagerTest, SetVirtualDisplayMuteFlag02, Function | SmallTest | Level3)
2573 {
2574 ScreenId screenId = 1010;
2575 ScreenId rsScreenId = SCREEN_ID_INVALID;
2576 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2577 bool muteFlag = false;
2578 ssm_->SetVirtualDisplayMuteFlag(screenId, muteFlag);
2579 }
2580
2581 /**
2582 * @tc.name: GetAllDisplayPhysicalResolution
2583 * @tc.desc: GetAllDisplayPhysicalResolution test
2584 * @tc.type: FUNC
2585 */
2586 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution, Function | SmallTest | Level3)
2587 {
2588 std::vector<DisplayPhysicalResolution> allSize {};
2589 if (ssm_ != nullptr) {
2590 allSize = ssm_->GetAllDisplayPhysicalResolution();
2591 ASSERT_TRUE(!allSize.empty());
2592 } else {
2593 ASSERT_TRUE(allSize.empty());
2594 }
2595 }
2596
2597 /**
2598 * @tc.name: SetDisplayScale
2599 * @tc.desc: SetDisplayScale test
2600 * @tc.type: FUNC
2601 */
2602 HWTEST_F(ScreenSessionManagerTest, SetDisplayScale, Function | SmallTest | Level3)
2603 {
2604 ASSERT_NE(ssm_, nullptr);
2605 ScreenId fakeScreenId = static_cast<ScreenId>(-1);
2606 float scaleX = 1.0f;
2607 float scaleY = 1.0f;
2608 float pivotX = 0.5f;
2609 float pivotY = 0.5f;
2610 ssm_->SetDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY);
2611 ssm_->SetDisplayScale(ssm_->GetDefaultScreenId(), scaleX, scaleY, pivotX, pivotY);
2612 }
2613
2614 /**
2615 * @tc.name: ScreenCastConnection
2616 * @tc.desc: ScreenCastConnection test
2617 * @tc.type: FUNC
2618 */
2619 HWTEST_F(ScreenSessionManagerTest, ScreenCastConnection, Function | SmallTest | Level3)
2620 {
2621 std::string castBundleName = "testCastBundleName";
2622 std::string castAbilityName = "testCastAbilityName";
2623
2624 ScreenCastConnection::GetInstance().SetBundleName("");
2625 ScreenCastConnection::GetInstance().SetAbilityName("");
2626 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), "");
2627 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), "");
2628
2629 EXPECT_EQ(ScreenCastConnection::GetInstance().CastConnectExtension(1), false);
2630
2631 ScreenCastConnection::GetInstance().SetBundleName(castBundleName);
2632 ScreenCastConnection::GetInstance().SetAbilityName(castAbilityName);
2633 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), castBundleName);
2634 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), castAbilityName);
2635
2636 MessageParcel data;
2637 MessageParcel reply;
2638 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_START, data, reply);
2639 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_STOP, data, reply);
2640 ScreenCastConnection::GetInstance().CastDisconnectExtension();
2641 EXPECT_EQ(ScreenCastConnection::GetInstance().IsConnectedSync(), false);
2642 }
2643
2644 /**
2645 * @tc.name: ReportFoldStatusToScb
2646 * @tc.desc: clientProxy_ = nullptr
2647 * @tc.type: FUNC
2648 */
2649 HWTEST_F(ScreenSessionManagerTest, ReportFoldStatusToScb, Function | SmallTest | Level3)
2650 {
2651 ssm_->clientProxy_ = nullptr;
2652 FoldStatus currentStatus = FoldStatus::FOLDED;
2653 FoldStatus nextStatus = FoldStatus::HALF_FOLD;
2654 int32_t duration = 1;
2655 float postureAngle = 1.2;
2656 std::vector<std::string> screenFoldInfo {std::to_string(static_cast<int32_t>(currentStatus)),
2657 std::to_string(static_cast<int32_t>(nextStatus)), std::to_string(duration), std::to_string(postureAngle)};
2658 ssm_->ReportFoldStatusToScb(screenFoldInfo);
2659 ASSERT_NE(ssm_, nullptr);
2660 }
2661
2662 /**
2663 * @tc.name: DisablePowerOffRenderControl
2664 * @tc.desc: ConvertScreenIdToRsScreenId = true
2665 * @tc.type: FUNC
2666 */
2667 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl01, Function | SmallTest | Level3)
2668 {
2669 ScreenId screenId = 1050;
2670 ScreenId rsScreenId = SCREEN_ID_INVALID;
2671 ScreenId rsScreenId1 = 1060;
2672 ssm_->screenIdManager_.sms2RsScreenIdMap_[screenId] = rsScreenId1;
2673 ASSERT_TRUE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2674 ssm_->DisablePowerOffRenderControl(screenId);
2675 }
2676
2677 /**
2678 * @tc.name: DisablePowerOffRenderControl
2679 * @tc.desc: ConvertScreenIdToRsScreenId = false
2680 * @tc.type: FUNC
2681 */
2682 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl02, Function | SmallTest | Level3)
2683 {
2684 ScreenId screenId = 1010;
2685 ScreenId rsScreenId = SCREEN_ID_INVALID;
2686 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2687 ssm_->DisablePowerOffRenderControl(screenId);
2688 }
2689
2690 /**
2691 * @tc.name: CheckAndSendHiSysEvent
2692 * @tc.desc: eventName != "CREATE_VIRTUAL_SCREEN"
2693 * @tc.type: FUNC
2694 */
2695 HWTEST_F(ScreenSessionManagerTest, CheckAndSendHiSysEvent, Function | SmallTest | Level3)
2696 {
2697 std::string eventName = "GET_DISPLAY_SNAPSHOT";
2698 std::string bundleName = "hmos.screenshot";
2699 ssm_->CheckAndSendHiSysEvent(eventName, bundleName);
2700 ASSERT_NE(ssm_, nullptr);
2701 }
2702
2703 /**
2704 * @tc.name: NotifyFoldToExpandCompletion
2705 * @tc.desc: NotifyFoldToExpandCompletion
2706 * @tc.type: FUNC
2707 */
2708 HWTEST_F(ScreenSessionManagerTest, NotifyFoldToExpandCompletion, Function | SmallTest | Level3)
2709 {
2710 bool foldToExpand = false;
2711 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
2712
2713 foldToExpand = true;
2714 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
2715 ASSERT_NE(ssm_, nullptr);
2716 }
2717
2718 /**
2719 * @tc.name: UpdateAvailableArea
2720 * @tc.desc: screenSession == nullptr
2721 * @tc.type: FUNC
2722 */
2723 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea01, Function | SmallTest | Level3)
2724 {
2725 ScreenId screenId = 1050;
2726 DMRect area = DMRect{};
2727 ssm_->UpdateAvailableArea(screenId, area);
2728 ASSERT_NE(ssm_, nullptr);
2729 }
2730
2731 /**
2732 * @tc.name: UpdateAvailableArea
2733 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is true
2734 * @tc.type: FUNC
2735 */
2736 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, Function | SmallTest | Level3)
2737 {
2738 ScreenId screenId = 1050;
2739 DMRect area{0, 0, 600, 900};
2740 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2741 ASSERT_NE(screenSession, nullptr);
2742 ssm_->screenSessionMap_[screenId] = screenSession;
2743 auto screenSession1 = ssm_->GetScreenSession(screenId);
2744 ASSERT_EQ(screenSession1, screenSession);
2745 ASSERT_TRUE(screenSession->UpdateAvailableArea(area));
2746 ssm_->UpdateAvailableArea(screenId, area);
2747 }
2748
2749 /**
2750 * @tc.name: UpdateAvailableArea
2751 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is false
2752 * @tc.type: FUNC
2753 */
2754 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea03, Function | SmallTest | Level3)
2755 {
2756 ScreenId screenId = 1050;
2757 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2758 ASSERT_NE(screenSession, nullptr);
2759 DMRect area = screenSession->GetAvailableArea();
2760 ssm_->screenSessionMap_[screenId] = screenSession;
2761 ASSERT_FALSE(screenSession->UpdateAvailableArea(area));
2762 ssm_->UpdateAvailableArea(screenId, area);
2763 }
2764
2765 /**
2766 * @tc.name: NotifyAvailableAreaChanged
2767 * @tc.desc: agents.empty()
2768 * @tc.type: FUNC
2769 */
2770 HWTEST_F(ScreenSessionManagerTest, NotifyAvailableAreaChanged01, Function | SmallTest | Level3)
2771 {
2772 DMRect area = DMRect{};
2773 DisplayId displayId = 0;
2774 ASSERT_NE(ssm_, nullptr);
2775 ssm_->NotifyAvailableAreaChanged(area, displayId);
2776 }
2777
2778 /**
2779 * @tc.name: TriggerFoldStatusChange01
2780 * @tc.desc: test interface TriggerFoldStatusChange
2781 * @tc.type: FUNC
2782 */
2783 HWTEST_F(ScreenSessionManagerTest, TriggerFoldStatusChange01, Function | SmallTest | Level3)
2784 {
2785 #ifdef FOLD_ABILITY_ENABLE
2786 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
2787 return;
2788 }
2789 ASSERT_NE(ssm_, nullptr);
2790 FoldStatus foldStatus = FoldStatus::EXPAND;
2791 ssm_->TriggerFoldStatusChange(foldStatus);
2792 FoldStatus res = ssm_->GetFoldStatus();
2793 EXPECT_EQ(res, foldStatus);
2794
2795 foldStatus = FoldStatus::FOLDED;
2796 ssm_->TriggerFoldStatusChange(foldStatus);
2797 res = ssm_->GetFoldStatus();
2798 EXPECT_EQ(res, foldStatus);
2799
2800 foldStatus = FoldStatus::HALF_FOLD;
2801 ssm_->TriggerFoldStatusChange(foldStatus);
2802 res = ssm_->GetFoldStatus();
2803 EXPECT_EQ(res, foldStatus);
2804
2805 foldStatus = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
2806 ssm_->TriggerFoldStatusChange(foldStatus);
2807 res = ssm_->GetFoldStatus();
2808 EXPECT_EQ(res, foldStatus);
2809
2810 foldStatus = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_HALF_FOLDED;
2811 ssm_->TriggerFoldStatusChange(foldStatus);
2812 res = ssm_->GetFoldStatus();
2813 EXPECT_EQ(res, foldStatus);
2814
2815 foldStatus = FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND;
2816 ssm_->TriggerFoldStatusChange(foldStatus);
2817 res = ssm_->GetFoldStatus();
2818 EXPECT_EQ(res, foldStatus);
2819
2820 foldStatus = FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_HALF_FOLDED;
2821 ssm_->TriggerFoldStatusChange(foldStatus);
2822 res = ssm_->GetFoldStatus();
2823 EXPECT_EQ(res, foldStatus);
2824
2825 foldStatus = FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_EXPAND;
2826 ssm_->TriggerFoldStatusChange(foldStatus);
2827 res = ssm_->GetFoldStatus();
2828 EXPECT_EQ(res, foldStatus);
2829
2830 foldStatus = FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_HALF_FOLDED;
2831 ssm_->TriggerFoldStatusChange(foldStatus);
2832 res = ssm_->GetFoldStatus();
2833 EXPECT_EQ(res, foldStatus);
2834 #endif
2835 }
2836
2837 /**
2838 * @tc.name: NotifyFoldStatusChanged
2839 * @tc.desc: NotifyFoldStatusChanged
2840 * @tc.type: FUNC
2841 */
2842 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged02, Function | SmallTest | Level3)
2843 {
2844 #ifdef FOLD_ABILITY_ENABLE
2845 std::string statusParam;
2846 auto ret = ssm_->NotifyFoldStatusChanged(statusParam);
2847 ASSERT_EQ(ret, -1);
2848
2849 statusParam = "-z"; // STATUS_FOLD_HALF
2850 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2851 ASSERT_EQ(ret, 0);
2852
2853 statusParam = "-y"; // STATUS_EXPAND
2854 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2855 ASSERT_EQ(ret, 0);
2856
2857 statusParam = "-coor"; // ARG_FOLD_DISPLAY_COOR
2858 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2859
2860 if (!(ssm_->IsFoldable())) {
2861 ssm_->foldScreenController_ = new FoldScreenController(
2862 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
2863 }
2864 ASSERT_NE(ssm_->foldScreenController_, nullptr);
2865 statusParam = "-y";
2866 ssm_->HandleFoldScreenPowerInit();
2867 ret = ssm_->NotifyFoldStatusChanged(statusParam);
2868 ASSERT_EQ(ret, 0);
2869 #endif
2870 }
2871
2872 /**
2873 * @tc.name: Dump
2874 * @tc.desc: Dump
2875 * @tc.type: FUNC
2876 */
2877 HWTEST_F(ScreenSessionManagerTest, Dump, Function | SmallTest | Level3)
2878 {
2879 int fd = 2;
2880 std::vector<std::u16string> args;
2881 int ret = ssm_->Dump(fd, args);
2882 ASSERT_EQ(ret, 0);
2883 }
2884
2885 /**
2886 * @tc.name: GetDisplayNode
2887 * @tc.desc: GetDisplayNode
2888 * @tc.type: FUNC
2889 */
2890 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode01, Function | SmallTest | Level3)
2891 {
2892 ScreenId screenId = 1051;
2893 auto ret = ssm_->GetDisplayNode(screenId);
2894 ASSERT_EQ(ret, nullptr);
2895 }
2896
2897 /**
2898 * @tc.name: GetDisplayNode
2899 * @tc.desc: !screenSession = false
2900 * @tc.type: FUNC
2901 */
2902 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode02, Function | SmallTest | Level3)
2903 {
2904 ScreenId screenId = 1050;
2905 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2906 ASSERT_NE(screenSession, nullptr);
2907 ssm_->screenSessionMap_[screenId] = screenSession;
2908 auto ret = ssm_->GetDisplayNode(screenId);
2909 ASSERT_NE(ret, nullptr);
2910 }
2911
2912 /**
2913 * @tc.name: GetScreenProperty
2914 * @tc.desc: GetScreenProperty
2915 * @tc.type: FUNC
2916 */
2917 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty01, Function | SmallTest | Level3)
2918 {
2919 ScreenId screenId = 2000;
2920 ASSERT_EQ(ssm_->GetScreenSession(screenId), nullptr);
2921 auto ret = ssm_->GetScreenProperty(screenId);
2922 ASSERT_EQ(sizeof(ret), sizeof(ScreenProperty));
2923 }
2924
2925 /**
2926 * @tc.name: GetScreenProperty
2927 * @tc.desc: !screenSession = false
2928 * @tc.type: FUNC
2929 */
2930 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty02, Function | SmallTest | Level3)
2931 {
2932 ScreenId screenId = 1050;
2933 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2934 ASSERT_NE(screenSession, nullptr);
2935 ssm_->screenSessionMap_[screenId] = screenSession;
2936 ScreenProperty property = ssm_->GetScreenProperty(screenId);
2937 ASSERT_EQ(sizeof(property), sizeof(screenSession->property_));
2938 }
2939
2940 /**
2941 * @tc.name: GetCurrentScreenPhyBounds
2942 * @tc.desc: GetCurrentScreenPhyBounds
2943 * @tc.type: FUNC
2944 */
2945 HWTEST_F(ScreenSessionManagerTest, GetCurrentScreenPhyBounds01, Function | SmallTest | Level3)
2946 {
2947 #ifdef FOLD_ABILITY_ENABLE
2948 float phyWidth = 0.0f;
2949 float phyHeight = 0.0f;
2950 bool isReset = true;
2951 ScreenId screenId = 1050;
2952 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
2953 ASSERT_NE(isReset, true);
2954 if (!(ssm_->IsFoldable())) {
2955 ssm_->foldScreenController_ = new FoldScreenController(
2956 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
2957 }
2958
2959 ASSERT_NE(ssm_->foldScreenController_, nullptr);
2960 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
2961 ASSERT_FALSE(isReset);
2962 #endif
2963 }
2964
2965 /**
2966 * @tc.name: PhyMirrorConnectWakeupScreen
2967 * @tc.desc: PhyMirrorConnectWakeupScreen test
2968 * @tc.type: FUNC
2969 */
2970 HWTEST_F(ScreenSessionManagerTest, PhyMirrorConnectWakeupScreen, Function | SmallTest | Level3)
2971 {
2972 #ifdef WM_MULTI_SCREEN_ENABLE
2973 ASSERT_NE(ssm_, nullptr);
2974 ssm_->PhyMirrorConnectWakeupScreen();
2975 ScreenSceneConfig::stringConfig_["externalScreenDefaultMode"] = "mirror";
2976 ssm_->PhyMirrorConnectWakeupScreen();
2977 #endif
2978 }
2979
2980 /**
2981 * @tc.name: SetVirtualScreenStatus
2982 * @tc.desc: SetVirtualScreenStatus test
2983 * @tc.type: FUNC
2984 */
2985 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenStatus, Function | SmallTest | Level3)
2986 {
2987 ASSERT_NE(ssm_, nullptr);
2988 ASSERT_FALSE(ssm_->SetVirtualScreenStatus(SCREEN_ID_INVALID, VirtualScreenStatus::VIRTUAL_SCREEN_PAUSE));
2989
2990 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2991 VirtualScreenOption virtualOption;
2992 virtualOption.name_ = "createVirtualOption";
2993 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2994
2995 ASSERT_TRUE(ssm_->SetVirtualScreenStatus(screenId, VirtualScreenStatus::VIRTUAL_SCREEN_PAUSE));
2996 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
2997 }
2998
2999 /**
3000 * @tc.name: SetClient
3001 * @tc.desc: SetClient
3002 * @tc.type: FUNC
3003 */
3004 HWTEST_F(ScreenSessionManagerTest, SetClient, Function | SmallTest | Level3)
3005 {
3006 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3007 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3008 }
3009 ScreenSessionManager* ssm = new ScreenSessionManager();
3010 ASSERT_NE(ssm, nullptr);
3011 sptr<IScreenSessionManagerClient> client = nullptr;
3012 ssm->SetClient(client);
3013 }
3014
3015 /**
3016 * @tc.name: SwitchUser
3017 * @tc.desc: SwitchUser
3018 * @tc.type: FUNC
3019 */
3020 HWTEST_F(ScreenSessionManagerTest, SwitchUser, Function | SmallTest | Level3)
3021 {
3022 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3023 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3024 }
3025 ScreenSessionManager* ssm = new ScreenSessionManager();
3026 ASSERT_NE(ssm, nullptr);
3027 ssm->SwitchUser();
3028 }
3029
3030 /**
3031 * @tc.name: SetScreenPrivacyMaskImage001
3032 * @tc.desc: SetScreenPrivacyMaskImage001
3033 * @tc.type: FUNC
3034 */
3035 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyMaskImage001, Function | SmallTest | Level3)
3036 {
3037 ScreenId screenId = DEFAULT_SCREEN_ID;
3038 auto ret = ssm_->SetScreenPrivacyMaskImage(screenId, nullptr);
3039 ASSERT_EQ(ret, DMError::DM_OK);
3040 }
3041
3042 /**
3043 * @tc.name: ScbClientDeathCallback
3044 * @tc.desc: ScbClientDeathCallback
3045 * @tc.type: FUNC
3046 */
3047 HWTEST_F(ScreenSessionManagerTest, ScbClientDeathCallback, Function | SmallTest | Level3)
3048 {
3049 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3050 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3051 }
3052 ScreenSessionManager* ssm = new ScreenSessionManager();
3053 ASSERT_NE(ssm, nullptr);
3054 int32_t deathScbPid = ssm->currentScbPId_;
3055 ssm->currentScbPId_ = -1; // INVALID_SCB_PID
3056 ssm->ScbClientDeathCallback(deathScbPid);
3057 ASSERT_EQ(ssm->clientProxy_, nullptr);
3058
3059 deathScbPid = ssm->currentScbPId_;
3060 ssm->currentScbPId_ = 0;
3061 ssm->ScbClientDeathCallback(deathScbPid);
3062 ASSERT_EQ(ssm->clientProxy_, nullptr);
3063
3064 deathScbPid = 0;
3065 ssm->currentScbPId_ = -1; // INVALID_SCB_PID
3066 ssm->ScbClientDeathCallback(deathScbPid);
3067 ASSERT_EQ(ssm->clientProxy_, nullptr);
3068
3069 deathScbPid = 0;
3070 ssm->currentScbPId_ = 0;
3071 ssm->ScbClientDeathCallback(deathScbPid);
3072 ASSERT_EQ(ssm->clientProxy_, nullptr);
3073 }
3074
3075 /**
3076 * @tc.name: NotifyClientProxyUpdateFoldDisplayMode?
3077 * @tc.desc: NotifyClientProxyUpdateFoldDisplayMode
3078 * @tc.type: FUNC
3079 */
3080 HWTEST_F(ScreenSessionManagerTest, NotifyClientProxyUpdateFoldDisplayMode, Function | SmallTest | Level3)
3081 {
3082 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3083 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3084 }
3085 ScreenSessionManager* ssm = new ScreenSessionManager();
3086 ASSERT_NE(ssm, nullptr);
3087 FoldDisplayMode displayMode = FoldDisplayMode::FULL;
3088 ASSERT_EQ(ssm->clientProxy_, nullptr);
3089 ssm->NotifyClientProxyUpdateFoldDisplayMode(displayMode);
3090 }
3091
3092 /**
3093 * @tc.name: OnScreenRotationLockedChange
3094 * @tc.desc: OnScreenRotationLockedChange
3095 * @tc.type: FUNC
3096 */
3097 HWTEST_F(ScreenSessionManagerTest, OnScreenRotationLockedChange, Function | SmallTest | Level3)
3098 {
3099 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3100 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3101 }
3102 ScreenSessionManager* ssm = new ScreenSessionManager();
3103 ASSERT_NE(ssm, nullptr);
3104 bool isLocked = false;
3105 ScreenId screenId = 1050;
3106 ASSERT_EQ(ssm->clientProxy_, nullptr);
3107 ssm->OnScreenRotationLockedChange(isLocked, screenId);
3108 }
3109
3110 /**
3111 * @tc.name: OnScreenOrientationChange
3112 * @tc.desc: OnScreenOrientationChange
3113 * @tc.type: FUNC
3114 */
3115 HWTEST_F(ScreenSessionManagerTest, OnScreenOrientationChange, Function | SmallTest | Level3)
3116 {
3117 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3118 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3119 }
3120 ScreenSessionManager* ssm = new ScreenSessionManager();
3121 ASSERT_NE(ssm, nullptr);
3122 float screenOrientation = 75.2f;
3123 ScreenId screenId = 1050;
3124 ASSERT_EQ(ssm->clientProxy_, nullptr);
3125 ssm->OnScreenOrientationChange(screenOrientation, screenId);
3126 }
3127
3128 /**
3129 * @tc.name: NotifyDisplayModeChanged
3130 * @tc.desc: NotifyDisplayModeChanged
3131 * @tc.type: FUNC
3132 */
3133 HWTEST_F(ScreenSessionManagerTest, NotifyDisplayModeChanged, Function | SmallTest | Level3)
3134 {
3135 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3136 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3137 }
3138 ScreenSessionManager* ssm = new ScreenSessionManager();
3139 ASSERT_NE(ssm, nullptr);
3140 ssm->NotifyDisplayModeChanged(FoldDisplayMode::MAIN);
3141 }
3142
3143 /**
3144 * @tc.name: SetMultiScreenMode
3145 * @tc.desc: MultiScreenMode::SCREEN_EXTEND
3146 * @tc.type: FUNC
3147 */
3148 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode01, Function | SmallTest | Level3)
3149 {
3150 #ifdef WM_MULTI_SCREEN_ENABLE
3151 ASSERT_NE(ssm_, nullptr);
3152 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3153 EXPECT_NE(displayManagerAgent, nullptr);
3154 VirtualScreenOption virtualOption;
3155 virtualOption.name_ = "createVirtualOption";
3156 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3157 MultiScreenMode screenMode = MultiScreenMode::SCREEN_EXTEND;
3158
3159 auto ret = ssm_->SetMultiScreenMode(0, screenId, screenMode);
3160 ASSERT_EQ(ret, DMError::DM_OK);
3161 ssm_->DestroyVirtualScreen(screenId);
3162 #endif
3163 }
3164
3165 /**
3166 * @tc.name: SetMultiScreenMode
3167 * @tc.desc: MultiScreenMode::SCREEN_MIRROR
3168 * @tc.type: FUNC
3169 */
3170 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode02, Function | SmallTest | Level3)
3171 {
3172 #ifdef WM_MULTI_SCREEN_ENABLE
3173 ASSERT_NE(ssm_, nullptr);
3174 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3175 EXPECT_NE(displayManagerAgent, nullptr);
3176 VirtualScreenOption virtualOption;
3177 virtualOption.name_ = "createVirtualOption";
3178 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3179 MultiScreenMode screenMode = MultiScreenMode::SCREEN_MIRROR;
3180
3181 auto ret = ssm_->SetMultiScreenMode(0, screenId, screenMode);
3182 ASSERT_EQ(ret, DMError::DM_OK);
3183 ssm_->DestroyVirtualScreen(screenId);
3184 #endif
3185 }
3186
3187 /**
3188 * @tc.name: SetMultiScreenMode
3189 * @tc.desc: operate mode error
3190 * @tc.type: FUNC
3191 */
3192 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode03, Function | SmallTest | Level3)
3193 {
3194 #ifdef WM_MULTI_SCREEN_ENABLE
3195 ASSERT_NE(ssm_, nullptr);
3196 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3197 EXPECT_NE(displayManagerAgent, nullptr);
3198 VirtualScreenOption virtualOption;
3199 virtualOption.name_ = "createVirtualOption";
3200 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3201
3202 uint32_t testNum = 2;
3203 auto ret = ssm_->SetMultiScreenMode(0, screenId, static_cast<MultiScreenMode>(testNum));
3204 ASSERT_EQ(ret, DMError::DM_OK);
3205 ssm_->DestroyVirtualScreen(screenId);
3206 #endif
3207 }
3208
3209 /**
3210 * @tc.name: SetMultiScreenRelativePosition
3211 * @tc.desc: ScreenSession is null
3212 * @tc.type: FUNC
3213 */
3214 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition01, Function | SmallTest | Level3)
3215 {
3216 #ifdef WM_MULTI_SCREEN_ENABLE
3217 ASSERT_NE(ssm_, nullptr);
3218 ScreenId testId = 2060;
3219 ScreenId testId1 = 3060;
3220 MultiScreenPositionOptions mainScreenOptions = {testId, 100, 100};
3221 MultiScreenPositionOptions secondScreenOption = {testId1, 100, 100};
3222 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3223 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
3224 #endif
3225 }
3226
3227 /**
3228 * @tc.name: SetMultiScreenRelativePosition
3229 * @tc.desc: B is located on the right side of A
3230 * @tc.type: FUNC
3231 */
3232 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition02, Function | SmallTest | Level3)
3233 {
3234 #ifdef WM_MULTI_SCREEN_ENABLE
3235 ASSERT_NE(ssm_, nullptr);
3236 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3237 EXPECT_NE(displayManagerAgent, nullptr);
3238 VirtualScreenOption virtualOption;
3239 virtualOption.name_ = "createVirtualOption";
3240 virtualOption.width_ = 200;
3241 virtualOption.height_ = 100;
3242 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3243
3244 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
3245 EXPECT_NE(displayManagerAgent1, nullptr);
3246 VirtualScreenOption virtualOption1;
3247 virtualOption1.name_ = "createVirtualOption";
3248 virtualOption1.width_ = 200;
3249 virtualOption1.height_ = 100;
3250 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
3251
3252 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
3253 MultiScreenPositionOptions secondScreenOption = {screenId1, 200, 50};
3254 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3255 ASSERT_EQ(ret, DMError::DM_OK);
3256
3257 ssm_->DestroyVirtualScreen(screenId);
3258 ssm_->DestroyVirtualScreen(screenId1);
3259 #endif
3260 }
3261
3262 /**
3263 * @tc.name: SetMultiScreenRelativePosition
3264 * @tc.desc: B is located below A
3265 * @tc.type: FUNC
3266 */
3267 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition03, Function | SmallTest | Level3)
3268 {
3269 #ifdef WM_MULTI_SCREEN_ENABLE
3270 ASSERT_NE(ssm_, nullptr);
3271 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3272 EXPECT_NE(displayManagerAgent, nullptr);
3273 VirtualScreenOption virtualOption;
3274 virtualOption.name_ = "createVirtualOption";
3275 virtualOption.width_ = 200;
3276 virtualOption.height_ = 100;
3277 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3278
3279 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
3280 EXPECT_NE(displayManagerAgent1, nullptr);
3281 VirtualScreenOption virtualOption1;
3282 virtualOption1.name_ = "createVirtualOption";
3283 virtualOption1.width_ = 200;
3284 virtualOption1.height_ = 100;
3285 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
3286
3287 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
3288 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 100};
3289 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3290 ASSERT_EQ(ret, DMError::DM_OK);
3291
3292 ssm_->DestroyVirtualScreen(screenId);
3293 ssm_->DestroyVirtualScreen(screenId1);
3294 #endif
3295 }
3296
3297 /**
3298 * @tc.name: SetMultiScreenRelativePosition
3299 * @tc.desc: INVALID_PARAM
3300 * @tc.type: FUNC
3301 */
3302 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition04, Function | SmallTest | Level3)
3303 {
3304 #ifdef WM_MULTI_SCREEN_ENABLE
3305 ASSERT_NE(ssm_, nullptr);
3306 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3307 EXPECT_NE(displayManagerAgent, nullptr);
3308 VirtualScreenOption virtualOption;
3309 virtualOption.name_ = "createVirtualOption";
3310 virtualOption.width_ = 200;
3311 virtualOption.height_ = 100;
3312 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3313
3314 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
3315 EXPECT_NE(displayManagerAgent1, nullptr);
3316 VirtualScreenOption virtualOption1;
3317 virtualOption1.name_ = "createVirtualOption";
3318 virtualOption1.width_ = 200;
3319 virtualOption1.height_ = 100;
3320 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
3321
3322 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
3323 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 50};
3324 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3325 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
3326
3327 ssm_->DestroyVirtualScreen(screenId);
3328 ssm_->DestroyVirtualScreen(screenId1);
3329 #endif
3330 }
3331
3332 /**
3333 * @tc.name: SetMultiScreenRelativePosition
3334 * @tc.desc: INVALID_PARAM
3335 * @tc.type: FUNC
3336 */
3337 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition05, Function | SmallTest | Level3)
3338 {
3339 #ifdef WM_MULTI_SCREEN_ENABLE
3340 ASSERT_NE(ssm_, nullptr);
3341 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3342 EXPECT_NE(displayManagerAgent, nullptr);
3343 VirtualScreenOption virtualOption;
3344 virtualOption.name_ = "createVirtualOption";
3345 virtualOption.width_ = 200;
3346 virtualOption.height_ = 100;
3347 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3348
3349 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
3350 EXPECT_NE(displayManagerAgent1, nullptr);
3351 VirtualScreenOption virtualOption1;
3352 virtualOption1.name_ = "createVirtualOption";
3353 virtualOption1.width_ = 200;
3354 virtualOption1.height_ = 100;
3355 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
3356
3357 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
3358 MultiScreenPositionOptions secondScreenOption = {screenId1, 200, 100};
3359 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3360 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
3361
3362 ssm_->DestroyVirtualScreen(screenId);
3363 ssm_->DestroyVirtualScreen(screenId1);
3364 #endif
3365 }
3366
3367 /**
3368 * @tc.name: SetMultiScreenRelativePosition
3369 * @tc.desc: DisplayNode is null
3370 * @tc.type: FUNC
3371 */
3372 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition06, Function | SmallTest | Level3)
3373 {
3374 #ifdef WM_MULTI_SCREEN_ENABLE
3375 ASSERT_NE(ssm_, nullptr);
3376 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3377 EXPECT_NE(displayManagerAgent, nullptr);
3378 VirtualScreenOption virtualOption;
3379 virtualOption.name_ = "createVirtualOption";
3380 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3381
3382 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
3383 EXPECT_NE(displayManagerAgent1, nullptr);
3384 VirtualScreenOption virtualOption1;
3385 virtualOption1.name_ = "createVirtualOption";
3386 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
3387
3388 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 100};
3389 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 100};
3390
3391 sptr<ScreenSession> secondScreenSession = ssm_->GetScreenSession(screenId1);
3392 secondScreenSession->ReleaseDisplayNode();
3393 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3394 ASSERT_EQ(ret, DMError::DM_OK);
3395
3396 sptr<ScreenSession> firstScreenSession = ssm_->GetScreenSession(screenId);
3397 firstScreenSession->ReleaseDisplayNode();
3398 ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
3399
3400 ssm_->DestroyVirtualScreen(screenId);
3401 ssm_->DestroyVirtualScreen(screenId1);
3402 #endif
3403 }
3404
3405 /**
3406 * @tc.name: SetCoordinationFlag
3407 * @tc.desc: SetCoordinationFlag
3408 * @tc.type: FUNC
3409 */
3410 HWTEST_F(ScreenSessionManagerTest, SetCoordinationFlag, Function | SmallTest | Level3)
3411 {
3412 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3413 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3414 }
3415 ScreenSessionManager* ssm = new ScreenSessionManager();
3416 ASSERT_NE(ssm, nullptr);
3417 ASSERT_EQ(ssm->isCoordinationFlag_, false);
3418 ssm->SetCoordinationFlag(true);
3419 ASSERT_EQ(ssm->isCoordinationFlag_, true);
3420 }
3421
3422 /**
3423 * @tc.name: GetTentMode
3424 * @tc.desc: Test get tent mode
3425 * @tc.type: FUNC
3426 */
3427 HWTEST_F(ScreenSessionManagerTest, GetTentMode, Function | SmallTest | Level1)
3428 {
3429 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3430 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3431 }
3432 auto tentMode = ssm_->GetTentMode();
3433 ASSERT_EQ(tentMode, false);
3434 }
3435
3436 /**
3437 * @tc.name: OnTentModeChanged
3438 * @tc.desc: Test change tent mode
3439 * @tc.type: FUNC
3440 */
3441 HWTEST_F(ScreenSessionManagerTest, OnTentModeChanged, Function | SmallTest | Level1)
3442 {
3443 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3444 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3445 }
3446 bool isTentMode = false;
3447 ssm_->OnTentModeChanged(isTentMode);
3448 ASSERT_EQ(ssm_->GetTentMode(), false);
3449 }
3450
3451 /**
3452 * @tc.name: GetScreenCapture
3453 * @tc.desc: GetScreenCapture
3454 * @tc.type: FUNC
3455 */
3456 HWTEST_F(ScreenSessionManagerTest, GetScreenCapture, Function | SmallTest | Level3)
3457 {
3458 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3459 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3460 }
3461 ScreenSessionManager* ssm = new ScreenSessionManager();
3462 ASSERT_NE(ssm, nullptr);
3463 CaptureOption option;
3464 option.displayId_ = 0;
3465 DmErrorCode errCode;
3466 std::shared_ptr<Media::PixelMap> bitMap = ssm->GetScreenCapture(option, &errCode);
3467 if (errCode == DmErrorCode::DM_OK) {
3468 ASSERT_NE(bitMap, nullptr);
3469 } else {
3470 ASSERT_EQ(bitMap, nullptr);
3471 }
3472 }
3473
3474 /**
3475 * @tc.name: OnScreenCaptureNotify
3476 * @tc.desc: OnScreenCaptureNotify
3477 * @tc.type: FUNC
3478 */
3479 HWTEST_F(ScreenSessionManagerTest, OnScreenCaptureNotify, Function | SmallTest | Level3)
3480 {
3481 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3482 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3483 }
3484 ScreenSessionManager* ssm = new ScreenSessionManager();
3485 ASSERT_NE(ssm, nullptr);
3486 ScreenId screenId = 0;
3487 int32_t uid = 0;
3488 std::string clientName = "test";
3489 ssm->OnScreenCaptureNotify(screenId, uid, clientName);
3490 }
3491
3492 /**
3493 * @tc.name: GetPrimaryDisplayInfo
3494 * @tc.desc: GetPrimaryDisplayInfo
3495 * @tc.type: FUNC
3496 */
3497 HWTEST_F(ScreenSessionManagerTest, GetPrimaryDisplayInfo, Function | SmallTest | Level3)
3498 {
3499 ASSERT_NE(ssm_, nullptr);
3500 ASSERT_NE(ssm_->GetPrimaryDisplayInfo(), nullptr);
3501 }
3502
3503 /*
3504 * @tc.name: TransferTypeToString
3505 * @tc.desc: TransferTypeToString
3506 * @tc.type: FUNC
3507 */
3508 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString1, Function | SmallTest | Level3)
3509 {
3510 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3511 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3512 }
3513 ScreenSessionManager* ssm = new ScreenSessionManager();
3514 ASSERT_NE(ssm, nullptr);
3515 std::string screenType = ssm->TransferTypeToString(ScreenType::REAL);
3516 std::string expectType = "REAL";
3517 ASSERT_EQ(screenType, expectType);
3518 }
3519
3520 /**
3521 * @tc.name: TransferTypeToString
3522 * @tc.desc: TransferTypeToString
3523 * @tc.type: FUNC
3524 */
3525 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString2, Function | SmallTest | Level3)
3526 {
3527 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3528 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3529 }
3530 ScreenSessionManager* ssm = new ScreenSessionManager();
3531 ASSERT_NE(ssm, nullptr);
3532 std::string screenType = ssm->TransferTypeToString(ScreenType::VIRTUAL);
3533 std::string expectType = "VIRTUAL";
3534 ASSERT_EQ(screenType, expectType);
3535 }
3536
3537 /**
3538 * @tc.name: TransferTypeToString
3539 * @tc.desc: TransferTypeToString
3540 * @tc.type: FUNC
3541 */
3542 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString3, Function | SmallTest | Level3)
3543 {
3544 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3545 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3546 }
3547 ScreenSessionManager* ssm = new ScreenSessionManager();
3548 ASSERT_NE(ssm, nullptr);
3549 std::string screenType = ssm->TransferTypeToString(ScreenType::UNDEFINED);
3550 std::string expectType = "UNDEFINED";
3551 ASSERT_EQ(screenType, expectType);
3552 }
3553
3554 /**
3555 * @tc.name: TransferPropertyChangeTypeToString
3556 * @tc.desc: TransferPropertyChangeTypeToString
3557 * @tc.type: FUNC
3558 */
3559 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString1, Function | SmallTest | Level3)
3560 {
3561 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3562 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3563 }
3564 ScreenSessionManager* ssm = new ScreenSessionManager();
3565 ASSERT_NE(ssm, nullptr);
3566 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::UNSPECIFIED);
3567 std::string expectType = "UNSPECIFIED";
3568 ASSERT_EQ(screenType, expectType);
3569 }
3570
3571 /**
3572 * @tc.name: TransferPropertyChangeTypeToString
3573 * @tc.desc: TransferPropertyChangeTypeToString
3574 * @tc.type: FUNC
3575 */
3576 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString2, Function | SmallTest | Level3)
3577 {
3578 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3579 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3580 }
3581 ScreenSessionManager* ssm = new ScreenSessionManager();
3582 ASSERT_NE(ssm, nullptr);
3583 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::ROTATION_BEGIN);
3584 std::string expectType = "ROTATION_BEGIN";
3585 ASSERT_EQ(screenType, expectType);
3586 }
3587
3588 /**
3589 * @tc.name: TransferPropertyChangeTypeToString
3590 * @tc.desc: TransferPropertyChangeTypeToString
3591 * @tc.type: FUNC
3592 */
3593 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString3, Function | SmallTest | Level3)
3594 {
3595 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3596 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3597 }
3598 ScreenSessionManager* ssm = new ScreenSessionManager();
3599 ASSERT_NE(ssm, nullptr);
3600 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::ROTATION_END);
3601 std::string expectType = "ROTATION_END";
3602 ASSERT_EQ(screenType, expectType);
3603 }
3604
3605 /**
3606 * @tc.name: TransferPropertyChangeTypeToString
3607 * @tc.desc: TransferPropertyChangeTypeToString
3608 * @tc.type: FUNC
3609 */
3610 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString4, Function | SmallTest | Level3)
3611 {
3612 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3613 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3614 }
3615 ScreenSessionManager* ssm = new ScreenSessionManager();
3616 ASSERT_NE(ssm, nullptr);
3617 std::string screenType = ssm->TransferPropertyChangeTypeToString(
3618 ScreenPropertyChangeType::ROTATION_UPDATE_PROPERTY_ONLY);
3619 std::string expectType = "ROTATION_UPDATE_PROPERTY_ONLY";
3620 ASSERT_EQ(screenType, expectType);
3621 }
3622
3623 /**
3624 * @tc.name: ConvertOffsetToCorrectRotation
3625 * @tc.desc: ConvertOffsetToCorrectRotation
3626 * @tc.type: FUNC
3627 */
3628 HWTEST_F(ScreenSessionManagerTest, ConvertOffsetToCorrectRotation, Function | SmallTest | Level3)
3629 {
3630 int32_t phyOffset = 90;
3631 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_270);
3632 phyOffset = 180;
3633 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_180);
3634 phyOffset = 270;
3635 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_90);
3636 phyOffset = 0;
3637 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_0);
3638 }
3639
3640 /**
3641 * @tc.name: ConfigureScreenSnapshotParams
3642 * @tc.desc: ConfigureScreenSnapshotParams
3643 * @tc.type: FUNC
3644 */
3645 HWTEST_F(ScreenSessionManagerTest, ConfigureScreenSnapshotParams, Function | SmallTest | Level3)
3646 {
3647 ssm_->OnStart();
3648 auto stringConfig = ScreenSceneConfig::GetStringConfig();
3649 if (g_isPcDevice) {
3650 ASSERT_EQ(stringConfig.count("screenSnapshotBundleName"), 1);
3651 } else {
3652 ASSERT_EQ(stringConfig.count("screenSnapshotBundleName"), 0);
3653 }
3654 ssm_->ConfigureScreenSnapshotParams();
3655 }
3656
3657 /**
3658 * @tc.name: RegisterRefreshRateChangeListener
3659 * @tc.desc: RegisterRefreshRateChangeListener
3660 * @tc.type: FUNC
3661 */
3662 HWTEST_F(ScreenSessionManagerTest, RegisterRefreshRateChangeListener, Function | SmallTest | Level3)
3663 {
3664 ssm_->RegisterRefreshRateChangeListener();
3665 std::string ret = ssm_->screenEventTracker_.recordInfos_.back().info;
3666 ASSERT_NE(ret, "Dms RefreshRateChange register failed.");
3667 }
3668
3669 /**
3670 * @tc.name: FreeDisplayMirrorNodeInner
3671 * @tc.desc: FreeDisplayMirrorNodeInner
3672 * @tc.type: FUNC
3673 */
3674 HWTEST_F(ScreenSessionManagerTest, FreeDisplayMirrorNodeInner, Function | SmallTest | Level3)
3675 {
3676 sptr<ScreenSession> mirrorSession = nullptr;
3677 ssm_->FreeDisplayMirrorNodeInner(mirrorSession);
3678 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3679 VirtualScreenOption virtualOption;
3680 virtualOption.name_ = "createVirtualOption";
3681 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3682 ASSERT_EQ(ssm_->GetScreenSession(screenId)->GetDisplayNode(), nullptr);
3683 }
3684
3685 /**
3686 * @tc.name: GetPowerStatus
3687 * @tc.desc: GetPowerStatus test
3688 * @tc.type: FUNC
3689 */
3690 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus01, Function | SmallTest | Level3)
3691 {
3692 ASSERT_NE(ssm_, nullptr);
3693 ScreenPowerStatus status;
3694 ssm_->GetPowerStatus(ScreenPowerState::POWER_ON, PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT, status);
3695 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_ON_ADVANCED);
3696 ssm_->GetPowerStatus(ScreenPowerState::POWER_ON, PowerStateChangeReason::POWER_BUTTON, status);
3697 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_ON);
3698 }
3699
3700 /**
3701 * @tc.name: GetPowerStatus
3702 * @tc.desc: GetPowerStatus test
3703 * @tc.type: FUNC
3704 */
3705 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus02, Function | SmallTest | Level3)
3706 {
3707 ASSERT_NE(ssm_, nullptr);
3708 ScreenPowerStatus status;
3709 ssm_->GetPowerStatus(ScreenPowerState::POWER_OFF,
3710 PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF, status);
3711 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_OFF_ADVANCED);
3712 ssm_->GetPowerStatus(ScreenPowerState::POWER_OFF, PowerStateChangeReason::POWER_BUTTON, status);
3713 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_OFF);
3714 }
3715
3716 /**
3717 * @tc.name: GetPowerStatus
3718 * @tc.desc: GetPowerStatus test
3719 * @tc.type: FUNC
3720 */
3721 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus03, Function | SmallTest | Level3)
3722 {
3723 ASSERT_NE(ssm_, nullptr);
3724 ScreenPowerStatus status;
3725 ssm_->GetPowerStatus(ScreenPowerState::POWER_SUSPEND, PowerStateChangeReason::POWER_BUTTON, status);
3726 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_SUSPEND);
3727 }
3728
3729 /**
3730 * @tc.name: GetPowerStatus
3731 * @tc.desc: GetPowerStatus test
3732 * @tc.type: FUNC
3733 */
3734 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus04, Function | SmallTest | Level3)
3735 {
3736 ASSERT_NE(ssm_, nullptr);
3737 ScreenPowerStatus status;
3738 ssm_->GetPowerStatus(ScreenPowerState::POWER_DOZE, PowerStateChangeReason::POWER_BUTTON, status);
3739 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_DOZE);
3740 }
3741
3742 /**
3743 * @tc.name: GetPowerStatus
3744 * @tc.desc: GetPowerStatus test
3745 * @tc.type: FUNC
3746 */
3747 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus05, Function | SmallTest | Level3)
3748 {
3749 ASSERT_NE(ssm_, nullptr);
3750 ScreenPowerStatus status;
3751 ssm_->GetPowerStatus(ScreenPowerState::POWER_DOZE_SUSPEND, PowerStateChangeReason::POWER_BUTTON, status);
3752 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_DOZE_SUSPEND);
3753 }
3754
3755 /**
3756 * @tc.name: SetGotScreenOffAndWakeUpBlock
3757 * @tc.desc: SetGotScreenOffAndWakeUpBlock test
3758 * @tc.type: FUNC
3759 */
3760 HWTEST_F(ScreenSessionManagerTest, SetGotScreenOffAndWakeUpBlock, Function | SmallTest | Level3)
3761 {
3762 ASSERT_NE(ssm_, nullptr);
3763 ssm_->SetGotScreenOffAndWakeUpBlock();
3764 ASSERT_TRUE(ssm_->gotScreenOffNotify_);
3765 ssm_->needScreenOffNotify_ = true;
3766 ssm_->SetGotScreenOffAndWakeUpBlock();
3767 ASSERT_FALSE(ssm_->needScreenOffNotify_);
3768 }
3769
3770 /**
3771 * @tc.name: GetFoldStatus
3772 * @tc.desc: GetFoldStatus test
3773 * @tc.type: FUNC
3774 */
3775 HWTEST_F(ScreenSessionManagerTest, GetFoldStatus, Function | SmallTest | Level3)
3776 {
3777 ASSERT_NE(ssm_, nullptr);
3778 auto status = ssm_->GetFoldStatus();
3779 if (ssm_->IsFoldable()) {
3780 EXPECT_NE(FoldStatus::UNKNOWN, status);
3781 } else {
3782 EXPECT_EQ(FoldStatus::UNKNOWN, status);
3783 }
3784 }
3785
3786 /**
3787 * @tc.name: SetLowTemp
3788 * @tc.desc: SetLowTemp test
3789 * @tc.type: FUNC
3790 */
3791 HWTEST_F(ScreenSessionManagerTest, SetLowTemp, Function | SmallTest | Level3)
3792 {
3793 ASSERT_NE(ssm_, nullptr);
3794 ssm_->SetLowTemp(LowTempMode::LOW_TEMP_OFF);
3795 ASSERT_EQ(ssm_->lowTemp_, LowTempMode::LOW_TEMP_OFF);
3796 ssm_->SetLowTemp(LowTempMode::LOW_TEMP_ON);
3797 ASSERT_EQ(ssm_->lowTemp_, LowTempMode::LOW_TEMP_ON);
3798 }
3799
3800 /**
3801 * @tc.name: SetScreenSkipProtectedWindow
3802 * @tc.desc: SetScreenSkipProtectedWindow test
3803 * @tc.type: FUNC
3804 */
3805 HWTEST_F(ScreenSessionManagerTest, SetScreenSkipProtectedWindow, Function | SmallTest | Level3)
3806 {
3807 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3808 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3809 }
3810 ASSERT_NE(ssm_, nullptr);
3811 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3812 ASSERT_NE(displayManagerAgent, nullptr);
3813 VirtualScreenOption virtualOption;
3814 virtualOption.name_ = "createVirtualOption1";
3815 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3816 if (screenId != VIRTUAL_SCREEN_ID) {
3817 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
3818 }
3819 const std::vector<ScreenId> screenIds = {screenId, 1002};
3820 bool isEnable = true;
3821 ASSERT_EQ(ssm_->SetScreenSkipProtectedWindow(screenIds, isEnable), DMError::DM_OK);
3822 isEnable = false;
3823 ASSERT_EQ(ssm_->SetScreenSkipProtectedWindow(screenIds, isEnable), DMError::DM_OK);
3824 }
3825
3826 /**
3827 * @tc.name: SetScreenSkipProtectedWindowInner
3828 * @tc.desc: SetScreenSkipProtectedWindowInner test
3829 * @tc.type: FUNC
3830 */
3831 HWTEST_F(ScreenSessionManagerTest, SetScreenSkipProtectedWindowInner, Function | SmallTest | Level3)
3832 {
3833 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3834 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3835 }
3836 ASSERT_NE(ssm_, nullptr);
3837 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3838 ASSERT_NE(displayManagerAgent, nullptr);
3839 VirtualScreenOption virtualOption;
3840 virtualOption.name_ = "createVirtualOption1";
3841 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3842 if (screenId != VIRTUAL_SCREEN_ID) {
3843 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
3844 }
3845 virtualOption.name_ = "createVirtualOption2";
3846 auto screenId2 = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3847 if (screenId2 != VIRTUAL_SCREEN_ID) {
3848 ASSERT_TRUE(screenId2 != VIRTUAL_SCREEN_ID);
3849 }
3850 auto screenSession = ssm_->GetScreenSession(screenId);
3851 screenSession->SetShareProtect(true);
3852 ssm_->SetScreenSkipProtectedWindowInner();
3853 }
3854
3855 /**
3856 * @tc.name: GetDisplayCapability
3857 * @tc.desc: GetDisplayCapability test
3858 * @tc.type: FUNC
3859 */
3860 HWTEST_F(ScreenSessionManagerTest, GetDisplayCapability, Function | SmallTest | Level3)
3861 {
3862 std::string info {""};
3863 if (ssm_ != nullptr) {
3864 EXPECT_EQ(DMError::DM_OK, ssm_->GetDisplayCapability(info));
3865 ASSERT_NE(info, "");
3866 } else {
3867 ASSERT_EQ(info, "");
3868 }
3869 }
3870
3871 /**
3872 * @tc.name: GetSecondaryDisplayCapability
3873 * @tc.desc: GetSecondaryDisplayCapability test
3874 * @tc.type: FUNC
3875 */
3876 HWTEST_F(ScreenSessionManagerTest, GetSecondaryDisplayCapability, Function | SmallTest | Level3)
3877 {
3878 std::string info {""};
3879 if (ssm_ != nullptr) {
3880 EXPECT_EQ(DMError::DM_OK, ssm_->GetSecondaryDisplayCapability(info));
3881 ASSERT_NE(info, "");
3882 } else {
3883 ASSERT_EQ(info, "");
3884 }
3885 }
3886
3887 /**
3888 * @tc.name: GetSuperFoldCapability
3889 * @tc.desc: GetSuperFoldCapability test
3890 * @tc.type: FUNC
3891 */
3892 HWTEST_F(ScreenSessionManagerTest, GetSuperFoldCapability, Function | SmallTest | Level3)
3893 {
3894 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3895 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3896 }
3897 std::string info {""};
3898 if (ssm_ != nullptr) {
3899 EXPECT_EQ(DMError::DM_OK, ssm_->GetSuperFoldCapability(info));
3900 ASSERT_NE(info, "");
3901 } else {
3902 ASSERT_EQ(info, "");
3903 }
3904 }
3905
3906 /**
3907 * @tc.name: GetFoldableDeviceCapability
3908 * @tc.desc: GetFoldableDeviceCapability test
3909 * @tc.type: FUNC
3910 */
3911 HWTEST_F(ScreenSessionManagerTest, GetFoldableDeviceCapability, Function | SmallTest | Level3)
3912 {
3913 if (!SceneBoardJudgement::IsSceneBoardEnabled()) {
3914 GTEST_SKIP() << "SceneBoard is not enabled, skipping test.";
3915 }
3916 std::string info {""};
3917 if (ssm_ != nullptr) {
3918 EXPECT_EQ(DMError::DM_OK, ssm_->GetFoldableDeviceCapability(info));
3919 ASSERT_NE(info, "");
3920 } else {
3921 ASSERT_EQ(info, "");
3922 }
3923 }
3924
3925 /**
3926 * @tc.name: DoMakeUniqueScreenOld
3927 * @tc.desc: DoMakeUniqueScreenOld test
3928 * @tc.type: FUNC
3929 */
3930 HWTEST_F(ScreenSessionManagerTest, DoMakeUniqueScreenOld, Function | SmallTest | Level3)
3931 {
3932 ASSERT_NE(ssm_, nullptr);
3933 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3934 ASSERT_NE(displayManagerAgent, nullptr);
3935 VirtualScreenOption virtualOption;
3936 virtualOption.name_ = "createVirtualOption";
3937 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3938 if (screenId != VIRTUAL_SCREEN_ID) {
3939 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
3940 }
3941 std::vector<ScreenId> allUniqueScreenIds = {screenId, 99};
3942 std::vector<DisplayId> displayIds = {};
3943 ssm_->DoMakeUniqueScreenOld(allUniqueScreenIds, displayIds, false);
3944 ASSERT_EQ(displayIds.size(), 1);
3945 }
3946
3947 /**
3948 * @tc.name: SetCastPrivacyFromSettingData
3949 * @tc.desc: SetCastPrivacyFromSettingData test
3950 * @tc.type: FUNC
3951 */
3952 HWTEST_F(ScreenSessionManagerTest, SetCastPrivacyFromSettingData, Function | SmallTest | Level3)
3953 {
3954 ASSERT_NE(ssm_, nullptr);
3955 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3956 ASSERT_NE(displayManagerAgent, nullptr);
3957 ScreenId id = 2;
3958 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
3959 ASSERT_NE(newSession, nullptr);
3960 ssm_->screenSessionMap_[id] = newSession;
3961 ssm_->SetCastPrivacyFromSettingData();
3962 }
3963
3964 /**
3965 * @tc.name: SetCastPrivacyToRS
3966 * @tc.desc: SetCastPrivacyToRS test
3967 * @tc.type: FUNC
3968 */
3969 HWTEST_F(ScreenSessionManagerTest, SetCastPrivacyToRS, Function | SmallTest | Level3)
3970 {
3971 ASSERT_NE(ssm_, nullptr);
3972 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3973 ASSERT_NE(displayManagerAgent, nullptr);
3974 sptr<ScreenSession> defScreen = ssm_->GetScreenSession(DEFAULT_SCREEN_ID);
3975 ASSERT_EQ(ssm_->SetCastPrivacyToRS(defScreen, true), false);
3976 VirtualScreenOption virtualOption;
3977 virtualOption.name_ = "createVirtualOption";
3978 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
3979 sptr<ScreenSession> virtualSession = ssm_->GetScreenSession(virtualScreenId);
3980 ASSERT_EQ(ssm_->SetCastPrivacyToRS(virtualSession, true), false);
3981 ScreenId id = 2;
3982 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
3983 ASSERT_NE(newSession, nullptr);
3984 newSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
3985 ASSERT_EQ(ssm_->SetCastPrivacyToRS(newSession, true), true);
3986 }
3987
3988 /**
3989 * @tc.name: RegisterSettingWireCastObserver
3990 * @tc.desc: RegisterSettingWireCastObserver
3991 * @tc.type: FUNC
3992 */
3993 HWTEST_F(ScreenSessionManagerTest, RegisterSettingWireCastObserver, Function | SmallTest | Level3)
3994 {
3995 ASSERT_NE(ssm_, nullptr);
3996 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
3997 ASSERT_NE(displayManagerAgent, nullptr);
3998 ScreenId id = 2;
3999 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
4000 ASSERT_NE(newSession, nullptr);
4001 ssm_->screenSessionMap_[id] = newSession;
4002 ssm_->RegisterSettingWireCastObserver(newSession);
4003 }
4004
4005 /**
4006 * @tc.name: UnregisterSettingWireCastObserver
4007 * @tc.desc: UnregisterSettingWireCastObserver
4008 * @tc.type: FUNC
4009 */
4010 HWTEST_F(ScreenSessionManagerTest, UnregisterSettingWireCastObserver, Function | SmallTest | Level3)
4011 {
4012 ASSERT_NE(ssm_, nullptr);
4013 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
4014 ASSERT_NE(displayManagerAgent, nullptr);
4015 ScreenId id = 2;
4016 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
4017 ASSERT_NE(newSession, nullptr);
4018 ssm_->screenSessionMap_[id] = newSession;
4019 ssm_->UnregisterSettingWireCastObserver(id);
4020 }
4021
4022 /**
4023 * @tc.name: MultiScreenChangeOuter
4024 * @tc.desc: MultiScreenChangeOuter
4025 * @tc.type: FUNC
4026 */
4027 HWTEST_F(ScreenSessionManagerTest, MultiScreenChangeOuter, Function | SmallTest | Level3)
4028 {
4029 ASSERT_NE(ssm_, nullptr);
4030 EXPECT_EQ(ssm_->clientProxy_, nullptr);
4031 std::string outerFlag = "2";
4032 ssm_->MultiScreenChangeOuter(outerFlag);
4033 outerFlag = "0";
4034 ssm_->MultiScreenChangeOuter(outerFlag);
4035 outerFlag = "1";
4036 ssm_->MultiScreenChangeOuter(outerFlag);
4037 }
4038
4039 /**
4040 * @tc.name: UpdateValidArea
4041 * @tc.desc: UpdateValidArea
4042 * @tc.type: FUNC
4043 */
4044 HWTEST_F(ScreenSessionManagerTest, UpdateValidArea, Function | SmallTest | Level3)
4045 {
4046 ASSERT_NE(ssm_, nullptr);
4047 ssm_->UpdateValidArea(2000, 800, 1000);
4048
4049 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
4050 VirtualScreenOption virtualOption;
4051 virtualOption.name_ = "createVirtualOption";
4052 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
4053 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
4054
4055 int32_t originValidWidth = screenSession->GetValidWidth();
4056 int32_t originValidHeight = screenSession->GetValidHeight();
4057 ssm_->UpdateValidArea(screenId, 800, 1000);
4058 EXPECT_EQ(800, screenSession->GetValidWidth());
4059 EXPECT_EQ(1000, screenSession->GetValidHeight());
4060 ssm_->UpdateValidArea(screenId, originValidWidth, originValidHeight);
4061 ssm_->DestroyVirtualScreen(screenId);
4062 }
4063
4064 /**
4065 * @tc.name: GetIsRealScreen
4066 * @tc.desc: GetIsRealScreen
4067 * @tc.type: FUNC
4068 */
4069 HWTEST_F(ScreenSessionManagerTest, GetIsRealScreen, Function | SmallTest | Level3)
4070 {
4071 ASSERT_NE(ssm_, nullptr);
4072 EXPECT_EQ(ssm_->GetIsRealScreen(2000), false);
4073
4074 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
4075 VirtualScreenOption virtualOption;
4076 virtualOption.name_ = "createVirtualOption";
4077 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
4078 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
4079 screenSession->SetIsRealScreen(true);
4080 ASSERT_EQ(ssm_->GetIsRealScreen(screenId), true);
4081 screenSession->SetIsRealScreen(false);
4082 ASSERT_EQ(ssm_->GetIsRealScreen(screenId), false);
4083 ssm_->DestroyVirtualScreen(screenId);
4084 }
4085
4086 /**
4087 * @tc.name: SetSystemKeyboardStatus
4088 * @tc.desc: SetSystemKeyboardStatus with true as parameter
4089 * @tc.type: FUNC
4090 */
4091 HWTEST_F(ScreenSessionManagerTest, SetSystemKeyboardStatus01, Function | SmallTest | Level3)
4092 {
4093 ASSERT_NE(ssm_, nullptr);
4094 auto ret = ssm_->SetSystemKeyboardStatus(true);
4095 ASSERT_NE(ret, DMError::DM_ERROR_UNKNOWN);
4096 }
4097
4098 /**
4099 * @tc.name: SetSystemKeyboardStatus
4100 * @tc.desc: SetSystemKeyboardStatus with false as parameter
4101 * @tc.type: FUNC
4102 */
4103 HWTEST_F(ScreenSessionManagerTest, SetSystemKeyboardStatus02, Function | SmallTest | Level3)
4104 {
4105 ASSERT_NE(ssm_, nullptr);
4106 auto ret = ssm_->SetSystemKeyboardStatus(false);
4107 ASSERT_NE(ret, DMError::DM_ERROR_UNKNOWN);
4108 }
4109
4110 /**
4111 * @tc.name: NotifyCastWhenSwitchScbNode
4112 * @tc.desc: NotifyCastWhenSwitchScbNode
4113 * @tc.type: FUNC
4114 */
4115 HWTEST_F(ScreenSessionManagerTest, NotifyCastWhenSwitchScbNode, Function | SmallTest | Level3)
4116 {
4117 ASSERT_NE(ssm_, nullptr);
4118 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
4119 ASSERT_NE(displayManagerAgent, nullptr);
4120
4121 ScreenId id = 2;
4122 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
4123 newSession ->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
4124 ASSERT_NE(newSession, nullptr);
4125 ssm_->screenSessionMap_[id] = newSession;
4126 ScreenId id1 = 3;
4127 sptr<ScreenSession> newSession1 = new (std::nothrow) ScreenSession(id1, ScreenProperty(), 0);
4128 newSession1 ->SetScreenCombination(ScreenCombination::SCREEN_UNIQUE);
4129 ASSERT_NE(newSession1, nullptr);
4130 ssm_->screenSessionMap_[id1] = newSession1;
4131 ScreenId id2 = 4;
4132 sptr<ScreenSession> newSession2 = nullptr;
4133 ssm_->screenSessionMap_[id2] = newSession2;
4134
4135 ssm_->NotifyCastWhenSwitchScbNode();
4136 }
4137 }
4138 } // namespace Rosen
4139 } // namespace OHOS
4140