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 #include "iremote_object_mocker.h"
28 #include "../mock/mock_accesstoken_kit.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace Rosen {
35 namespace {
36 const int32_t CV_WAIT_SCREENOFF_MS = 1500;
37 const int32_t CV_WAIT_SCREENON_MS = 300;
38 const int32_t CV_WAIT_SCREENOFF_MS_MAX = 3000;
39 const uint32_t INVALID_DISPLAY_ORIENTATION = 99;
40 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
41 constexpr int32_t CAST_WIRED_PROJECTION_START = 1005;
42 constexpr int32_t CAST_WIRED_PROJECTION_STOP = 1007;
43 bool g_isPcDevice = ScreenSceneConfig::GetExternalScreenDefaultMode() == "none";
44 const bool IS_SUPPORT_PC_MODE = system::GetBoolParameter("const.window.support_window_pcmode_switch", false);
45 std::string logMsg;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)46 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char *tag,
47 const char *msg)
48 {
49 logMsg = msg;
50 }
51 }
52 class ScreenSessionManagerTest : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp() override;
57 void TearDown() override;
58
59 static sptr<ScreenSessionManager> ssm_;
60
61 ScreenId DEFAULT_SCREEN_ID {0};
62 ScreenId VIRTUAL_SCREEN_ID {2};
63 ScreenId VIRTUAL_SCREEN_RS_ID {100};
64 void SetAceessTokenPermission(const std::string processName);
65 sptr<ScreenSession> InitTestScreenSession(std::string name, ScreenId &screenId);
66 DMHookInfo CreateDefaultHookInfo();
67 };
68
69 sptr<ScreenSessionManager> ScreenSessionManagerTest::ssm_ = nullptr;
70
SetUpTestCase()71 void ScreenSessionManagerTest::SetUpTestCase()
72 {
73 ssm_ = new ScreenSessionManager();
74 CommonTestUtils::InjectTokenInfoByHapName(0, "com.ohos.systemui", 0);
75 const char** perms = new const char *[1];
76 perms[0] = "ohos.permission.CAPTURE_SCREEN";
77 CommonTestUtils::SetAceessTokenPermission("foundation", perms, 1);
78 }
79
TearDownTestCase()80 void ScreenSessionManagerTest::TearDownTestCase()
81 {
82 ssm_ = nullptr;
83 }
84
SetUp()85 void ScreenSessionManagerTest::SetUp()
86 {
87 }
88
TearDown()89 void ScreenSessionManagerTest::TearDown()
90 {
91 usleep(SLEEP_TIME_IN_US);
92 }
93
InitTestScreenSession(std::string name,ScreenId & screenId)94 sptr<ScreenSession> ScreenSessionManagerTest::InitTestScreenSession(std::string name, ScreenId &screenId)
95 {
96 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
97 VirtualScreenOption virtualOption;
98 virtualOption.name_ = name;
99 screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
100 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
101 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(name, screenId, rsid, 0);
102 return screenSession;
103 }
104
CreateDefaultHookInfo()105 DMHookInfo ScreenSessionManagerTest::CreateDefaultHookInfo()
106 {
107 uint32_t hookWidth = 500;
108 uint32_t hookHeight = 700;
109 float_t hookDensity = 3.0;
110 uint32_t hookRotation = static_cast<uint32_t>(Rotation::ROTATION_0);
111 uint32_t hookDisplayOrientation = static_cast<uint32_t>(DisplayOrientation::PORTRAIT);
112 DMHookInfo dmHookInfo = { hookWidth, hookHeight, hookDensity, hookRotation, true, hookDisplayOrientation, true };
113 return dmHookInfo;
114 }
115
116 namespace {
117 /**
118 * @tc.name: RegisterDisplayManagerAgent
119 * @tc.desc: RegisterDisplayManagerAgent test
120 * @tc.type: FUNC
121 */
122 HWTEST_F(ScreenSessionManagerTest, RegisterDisplayManagerAgent, TestSize.Level1)
123 {
124 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
125 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
126 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
127 EXPECT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
128
129 type = DisplayManagerAgentType::PRIVATE_WINDOW_LISTENER;
130 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->RegisterDisplayManagerAgent(nullptr, type));
131 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->UnregisterDisplayManagerAgent(nullptr, type));
132
133 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
134 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
135 }
136
137 /**
138 * @tc.name: WakeupBegin
139 * @tc.desc: WakeupBegin test
140 * @tc.type: FUNC
141 */
142 HWTEST_F(ScreenSessionManagerTest, WakeUpBegin, TestSize.Level1)
143 {
144 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
145 EXPECT_NE(displayManagerAgent, nullptr);
146
147 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
148 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
149
150 VirtualScreenOption virtualOption;
151 virtualOption.name_ = "createVirtualOption";
152 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
153 if (screenId != VIRTUAL_SCREEN_ID) {
154 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
155 }
156
157 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
158 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
159
160 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
161 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
162
163 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
164 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
165
166 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
167 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
168
169 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
170 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
171
172 reason = PowerStateChangeReason::STATE_CHANGE_REASON_START_DREAM;
173 ASSERT_EQ(false, ssm_->WakeUpBegin(reason));
174
175 reason = PowerStateChangeReason::STATE_CHANGE_REASON_END_DREAM;
176 ASSERT_EQ(true, ssm_->WakeUpBegin(reason));
177
178 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
179 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
180 }
181
182 /**
183 * @tc.name: WakeUp for Multi
184 * @tc.desc: WakeUp for Multi test
185 * @tc.type: FUNC
186 */
187 HWTEST_F(ScreenSessionManagerTest, WakeUpForMulti, Function | SmallTest | Level3)
188 {
189 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
190 EXPECT_NE(displayManagerAgent, nullptr);
191
192 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
193 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
194 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
195 ASSERT_TRUE(ssm_->WakeUpBegin(reason));
196 usleep(SLEEP_TIME_IN_US);
197 ASSERT_TRUE(ssm_->WakeUpEnd());
198 ASSERT_FALSE(ssm_->isMultiScreenCollaboration_);
199 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
200 }
201
202 /**
203 * @tc.name: SuspendBegin
204 * @tc.desc: SuspendBegin test
205 * @tc.type: FUNC
206 */
207 HWTEST_F(ScreenSessionManagerTest, SuspendBegin, TestSize.Level1)
208 {
209 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
210 EXPECT_NE(displayManagerAgent, nullptr);
211
212 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
213 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
214
215 VirtualScreenOption virtualOption;
216 virtualOption.name_ = "createVirtualOption";
217 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
218 if (screenId != VIRTUAL_SCREEN_ID) {
219 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
220 }
221
222 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
223 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
224
225 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
226 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
227
228 reason = PowerStateChangeReason::STATE_CHANGE_REASON_START_DREAM;
229 ASSERT_EQ(true, ssm_->SuspendBegin(reason));
230
231 reason = PowerStateChangeReason::STATE_CHANGE_REASON_END_DREAM;
232 ASSERT_EQ(false, ssm_->SuspendBegin(reason));
233
234 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
235 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
236 }
237
238 /**
239 * @tc.name: Suspend for Multi
240 * @tc.desc: Suspend for Multi test
241 * @tc.type: FUNC
242 */
243 HWTEST_F(ScreenSessionManagerTest, SuspendforMulti, Function | SmallTest | Level3)
244 {
245 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
246 EXPECT_NE(displayManagerAgent, nullptr);
247
248 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
249 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
250 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
251 ASSERT_TRUE(ssm_->SuspendBegin(reason));
252 ASSERT_TRUE(ssm_->isMultiScreenCollaboration_);
253 usleep(SLEEP_TIME_IN_US);
254 ASSERT_TRUE(ssm_->SuspendEnd());
255 ASSERT_FALSE(ssm_->isMultiScreenCollaboration_);
256 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
257 }
258
259 /**
260 * @tc.name: GetInternalScreenId
261 * @tc.desc: GetInternalScreenId test
262 * @tc.type: FUNC
263 */
264 HWTEST_F(ScreenSessionManagerTest, GetInternalScreenId, TestSize.Level1)
265 {
266 ASSERT_EQ(SCREEN_ID_INVALID, ssm_->GetInternalScreenId());
267
268 ScreenSessionConfig config;
269 sptr<ScreenSession> session = new ScreenSession(config,
270 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
271 session->SetIsInternal(true);
272 ScreenId id = 0;
273 ssm_->screenSessionMap_.insert(std::make_pair(id, session));
274 ASSERT_EQ(0, ssm_->GetInternalScreenId());
275
276 ssm_->screenSessionMap_.erase(0);
277 }
278
279 /**
280 * @tc.name: SetScreenPowerById01
281 * @tc.desc: SetScreenPowerById test POWER_ON
282 * @tc.type: FUNC
283 */
284 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById01, TestSize.Level1)
285 {
286 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
287 EXPECT_NE(displayManagerAgent, nullptr);
288
289 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
290 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
291
292 VirtualScreenOption virtualOption;
293 virtualOption.name_ = "createVirtualOption";
294 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
295 if (screenId != VIRTUAL_SCREEN_ID) {
296 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
297 }
298
299 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
300 ScreenPowerState state = ScreenPowerState::POWER_ON;
301 ASSERT_EQ(true, ssm_->SetScreenPowerById(screenId, state, reason));
302
303 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
304 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
305 }
306
307 /**
308 * @tc.name: SetScreenPowerById02
309 * @tc.desc: SetScreenPowerById test POWER_OFF
310 * @tc.type: FUNC
311 */
312 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById02, TestSize.Level1)
313 {
314 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
315 EXPECT_NE(displayManagerAgent, nullptr);
316
317 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
318 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
319
320 VirtualScreenOption virtualOption;
321 virtualOption.name_ = "createVirtualOption";
322 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
323 if (screenId != VIRTUAL_SCREEN_ID) {
324 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
325 }
326
327 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
328 ScreenPowerState state = ScreenPowerState::POWER_OFF;
329 ASSERT_EQ(true, ssm_->SetScreenPowerById(screenId, state, reason));
330
331 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
332 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
333 }
334
335 /**
336 * @tc.name: SetScreenPowerById03
337 * @tc.desc: SetScreenPowerById test INVALID_STATE
338 * @tc.type: FUNC
339 */
340 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerById03, TestSize.Level1)
341 {
342 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
343 EXPECT_NE(displayManagerAgent, nullptr);
344
345 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
346 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
347
348 VirtualScreenOption virtualOption;
349 virtualOption.name_ = "createVirtualOption";
350 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
351 if (screenId != VIRTUAL_SCREEN_ID) {
352 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
353 }
354
355 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_POWER_KEY;
356 ScreenPowerState state = ScreenPowerState::INVALID_STATE;
357 ASSERT_EQ(false, ssm_->SetScreenPowerById(screenId, state, 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: SetScreenPowerForAll
365 * @tc.desc: SetScreenPowerForAll test
366 * @tc.type: FUNC
367 */
368 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll, TestSize.Level1)
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_POWER_KEY;
384 ScreenPowerState state = ScreenPowerState::POWER_ON;
385 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
386
387 reason = PowerStateChangeReason::STATE_CHANGE_REASON_SWITCH;
388 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
389
390 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT;
391 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
392
393 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_SUCCESS;
394 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
395
396 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_ON;
397 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
398
399 reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
400 state = ScreenPowerState::POWER_OFF;
401 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
402
403 reason = PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF;
404 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
405
406 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
407 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
408 }
409
410 /**
411 * @tc.name: SetScreenPowerForAll01
412 * @tc.desc: SetScreenPowerForAll01 test
413 * @tc.type: FUNC
414 */
415 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll01, TestSize.Level1)
416 {
417 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
418 EXPECT_NE(displayManagerAgent, nullptr);
419
420 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
421 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
422
423 VirtualScreenOption virtualOption;
424 virtualOption.name_ = "createVirtualOption";
425 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
426 if (screenId != VIRTUAL_SCREEN_ID) {
427 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
428 }
429
430 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_INIT;
431 ScreenPowerState state = ScreenPowerState::POWER_ON;
432 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
433
434 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
435 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
436 }
437
438 /**
439 * @tc.name: SetScreenPowerForAll02
440 * @tc.desc: SetScreenPowerForAll02 test
441 * @tc.type: FUNC
442 */
443 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll02, TestSize.Level1)
444 {
445 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
446 EXPECT_NE(displayManagerAgent, nullptr);
447
448 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
449 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
450
451 VirtualScreenOption virtualOption;
452 virtualOption.name_ = "createVirtualOption";
453 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
454 if (screenId != VIRTUAL_SCREEN_ID) {
455 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
456 }
457
458 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_RUNNING_LOCK;
459 ScreenPowerState state = ScreenPowerState::POWER_ON;
460 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
461
462 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
463 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
464 }
465
466 /**
467 * @tc.name: SetScreenPowerForAll03
468 * @tc.desc: SetScreenPowerForAll03 test
469 * @tc.type: FUNC
470 */
471 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll03, TestSize.Level1)
472 {
473 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
474 EXPECT_NE(displayManagerAgent, nullptr);
475
476 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
477 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
478
479 VirtualScreenOption virtualOption;
480 virtualOption.name_ = "createVirtualOption";
481 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
482 if (screenId != VIRTUAL_SCREEN_ID) {
483 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
484 }
485
486 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_BATTERY;
487 ScreenPowerState state = ScreenPowerState::POWER_ON;
488 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
489
490 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
491 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
492 }
493
494 /**
495 * @tc.name: SetScreenPowerForAll04
496 * @tc.desc: SetScreenPowerForAll04 test
497 * @tc.type: FUNC
498 */
499 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll04, TestSize.Level1)
500 {
501 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
502 EXPECT_NE(displayManagerAgent, nullptr);
503
504 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
505 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
506
507 VirtualScreenOption virtualOption;
508 virtualOption.name_ = "createVirtualOption";
509 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
510 if (screenId != VIRTUAL_SCREEN_ID) {
511 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
512 }
513
514 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_THERMAL;
515 ScreenPowerState state = ScreenPowerState::POWER_ON;
516 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
517
518 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
519 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
520 }
521
522 /**
523 * @tc.name: SetScreenPowerForAll05
524 * @tc.desc: SetScreenPowerForAll05 test
525 * @tc.type: FUNC
526 */
527 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll05, TestSize.Level1)
528 {
529 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
530 EXPECT_NE(displayManagerAgent, nullptr);
531
532 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
533 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
534
535 VirtualScreenOption virtualOption;
536 virtualOption.name_ = "createVirtualOption";
537 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
538 if (screenId != VIRTUAL_SCREEN_ID) {
539 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
540 }
541
542 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_WORK;
543 ScreenPowerState state = ScreenPowerState::POWER_ON;
544 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
545
546 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
547 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
548 }
549
550 /**
551 * @tc.name: SetScreenPowerForAll06
552 * @tc.desc: SetScreenPowerForAll06 test
553 * @tc.type: FUNC
554 */
555 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll06, TestSize.Level1)
556 {
557 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
558 EXPECT_NE(displayManagerAgent, nullptr);
559
560 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
561 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
562
563 VirtualScreenOption virtualOption;
564 virtualOption.name_ = "createVirtualOption";
565 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
566 if (screenId != VIRTUAL_SCREEN_ID) {
567 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
568 }
569
570 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SYSTEM;
571 ScreenPowerState state = ScreenPowerState::POWER_ON;
572 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
573
574 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
575 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
576 }
577
578 /**
579 * @tc.name: SetScreenPowerForAll07
580 * @tc.desc: SetScreenPowerForAll07 test
581 * @tc.type: FUNC
582 */
583 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll07, TestSize.Level1)
584 {
585 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
586 EXPECT_NE(displayManagerAgent, nullptr);
587
588 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
589 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
590
591 VirtualScreenOption virtualOption;
592 virtualOption.name_ = "createVirtualOption";
593 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
594 if (screenId != VIRTUAL_SCREEN_ID) {
595 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
596 }
597
598 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_APPLICATION;
599 ScreenPowerState state = ScreenPowerState::POWER_ON;
600 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
601
602 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
603 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
604 }
605
606 /**
607 * @tc.name: SetScreenPowerForAll08
608 * @tc.desc: SetScreenPowerForAll08 test
609 * @tc.type: FUNC
610 */
611 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll08, TestSize.Level1)
612 {
613 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
614 EXPECT_NE(displayManagerAgent, nullptr);
615
616 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
617 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
618
619 VirtualScreenOption virtualOption;
620 virtualOption.name_ = "createVirtualOption";
621 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
622 if (screenId != VIRTUAL_SCREEN_ID) {
623 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
624 }
625
626 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_SETTINGS;
627 ScreenPowerState state = ScreenPowerState::POWER_ON;
628 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
629
630 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
631 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
632 }
633
634 /**
635 * @tc.name: SetScreenPowerForAll09
636 * @tc.desc: SetScreenPowerForAll09 test
637 * @tc.type: FUNC
638 */
639 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll09, TestSize.Level1)
640 {
641 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
642 EXPECT_NE(displayManagerAgent, nullptr);
643
644 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
645 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
646
647 VirtualScreenOption virtualOption;
648 virtualOption.name_ = "createVirtualOption";
649 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
650 if (screenId != VIRTUAL_SCREEN_ID) {
651 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
652 }
653
654 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_HARD_KEY;
655 ScreenPowerState state = ScreenPowerState::POWER_ON;
656 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
657
658 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
659 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
660 }
661
662 /**
663 * @tc.name: SetScreenPowerForAll10
664 * @tc.desc: SetScreenPowerForAll10 test
665 * @tc.type: FUNC
666 */
667 HWTEST_F(ScreenSessionManagerTest, SetScreenPowerForAll10, TestSize.Level1)
668 {
669 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
670 EXPECT_NE(displayManagerAgent, nullptr);
671
672 DisplayManagerAgentType type = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
673 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
674
675 VirtualScreenOption virtualOption;
676 virtualOption.name_ = "createVirtualOption";
677 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
678 if (screenId != VIRTUAL_SCREEN_ID) {
679 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
680 }
681
682 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_TOUCH;
683 ScreenPowerState state = ScreenPowerState::POWER_ON;
684 ASSERT_EQ(true, ssm_->SetScreenPowerForAll(state, reason));
685
686 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
687 EXPECT_EQ(DMError::DM_OK, ssm_->UnregisterDisplayManagerAgent(displayManagerAgent, type));
688 }
689
690 /**
691 * @tc.name: ScreenChange
692 * @tc.desc: ScreenChange test
693 * @tc.type: FUNC
694 */
695 HWTEST_F(ScreenSessionManagerTest, ScreenChange, TestSize.Level1)
696 {
697 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
698 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
699 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
700 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
701 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
702 EXPECT_TRUE(1);
703
704 screenEvent = ScreenEvent::DISCONNECTED;
705 ssm_->OnVirtualScreenChange(DEFAULT_SCREEN_ID, screenEvent);
706 ssm_->OnVirtualScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
707 ssm_->OnScreenChange(DEFAULT_SCREEN_ID, screenEvent);
708 ssm_->OnScreenChange(VIRTUAL_SCREEN_ID, screenEvent);
709 EXPECT_TRUE(1);
710 }
711
712 /**
713 * @tc.name: ScreenPower
714 * @tc.desc: ScreenSesionManager screen power
715 * @tc.type: FUNC
716 */
717 HWTEST_F(ScreenSessionManagerTest, ScreenPower, TestSize.Level1)
718 {
719 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
720 ScreenPowerState state = ScreenPowerState::POWER_ON;
721 DisplayState displayState = DisplayState::ON;
722
723 ASSERT_EQ(false, ssm_->WakeUpBegin(reason));
724 ASSERT_EQ(false, ssm_->WakeUpEnd());
725
726 ASSERT_EQ(false, ssm_->SuspendBegin(reason));
727 ASSERT_EQ(false, ssm_->SuspendEnd());
728
729 ASSERT_EQ(false, ssm_->SetScreenPowerForAll(state, reason));
730
731 DisplayId id = 0;
732 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
733 ssm_->screenSessionMap_[id] = screenSession;
734 ASSERT_EQ(true, ssm_->SetDisplayState(displayState));
735 ASSERT_EQ(DisplayState::ON, ssm_->GetDisplayState(0));
736 }
737
738 /**
739 * @tc.name: GetScreenPower
740 * @tc.desc: GetScreenPower screen power
741 * @tc.type: FUNC
742 */
743 HWTEST_F(ScreenSessionManagerTest, GetScreenPower, TestSize.Level1)
744 {
745 DisplayId id = 0;
746 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
747 ssm_->screenSessionMap_[id] = screenSession;
748 ssm_->GetScreenPower(0);
749 EXPECT_TRUE(1);
750 }
751
752 /**
753 * @tc.name: IsScreenRotationLocked
754 * @tc.desc: IsScreenRotationLocked test
755 * @tc.type: FUNC
756 */
757 HWTEST_F(ScreenSessionManagerTest, IsScreenRotationLocked, TestSize.Level1)
758 {
759 bool isLocked = false;
760 DisplayId id = 0;
761 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
762 ssm_->screenSessionMap_[id] = screenSession;
763 ASSERT_EQ(DMError::DM_OK, ssm_->IsScreenRotationLocked(isLocked));
764 }
765
766 /**
767 * @tc.name: CreateScreenProperty
768 * @tc.desc: CreateScreenProperty test
769 * @tc.type: FUNC
770 */
771 HWTEST_F(ScreenSessionManagerTest, CreateScreenProperty, Function | SmallTest | Level3)
772 {
773 ASSERT_NE(ssm_, nullptr);
774 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
775 VirtualScreenOption virtualOption;
776 virtualOption.name_ = "testVirtualOption";
777 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
778 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
779 ScreenProperty property;
780 ssm_->isDensityDpiLoad_ = false;
781 ssm_->CreateScreenProperty(screenId, property);
782 ssm_->isDensityDpiLoad_ = true;
783 ASSERT_EQ(0, screenSession->GetScreenProperty().GetRefreshRate());
784 ssm_->DestroyVirtualScreen(screenId);
785 }
786
787 /**
788 * @tc.name: GetInternalWidth
789 * @tc.desc: GetInternalWidth test
790 * @tc.type: FUNC
791 */
792 HWTEST_F(ScreenSessionManagerTest, GetInternalWidth, Function | SmallTest | Level3)
793 {
794 ASSERT_NE(ssm_, nullptr);
795 auto screenId = ssm_->GetInternalScreenId();
796 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
797 ASSERT_EQ(screenSession, nullptr);
798 ssm_->GetInternalWidth();
799 }
800
801 /**
802 * @tc.name: InitExtendScreen01
803 * @tc.desc: InitExtendScreen01 test
804 * @tc.type: FUNC
805 */
806 HWTEST_F(ScreenSessionManagerTest, InitExtendScreen01, Function | SmallTest | Level3)
807 {
808 ASSERT_NE(ssm_, nullptr);
809 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
810 VirtualScreenOption virtualOption;
811 virtualOption.name_ = "testVirtualOption";
812 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
813 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
814 sptr<ScreenSession> screenSession1 = ssm_->GetScreenSession(ssm_->GetDefaultScreenId());
815 ScreenProperty property = screenSession->GetScreenProperty();
816 ssm_->InitExtendScreenProperty(screenId, screenSession, property);
817 ssm_->InitExtendScreenDensity(screenSession, property);
818 EXPECT_EQ(property.GetDensityInCurResolution(), screenSession1->GetScreenProperty().GetDensityInCurResolution());
819 ssm_->DestroyVirtualScreen(screenId);
820 }
821
822 /**
823 * @tc.name: InitExtendScreen
824 * @tc.desc: InitExtendScreen test
825 * @tc.type: FUNC
826 */
827 HWTEST_F(ScreenSessionManagerTest, InitExtendScreen02, Function | SmallTest | Level3)
828 {
829 ASSERT_NE(ssm_, nullptr);
830 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
831 VirtualScreenOption virtualOption;
832 virtualOption.name_ = "testVirtualOption";
833 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
834 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
835 sptr<ScreenSession> screenSession1 = ssm_->GetScreenSession(ssm_->GetDefaultScreenId());
836 ScreenProperty property = screenSession->GetScreenProperty();
837 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
838 ssm_->InitExtendScreenDensity(screenSession, property);
839 EXPECT_EQ(property.GetDensityInCurResolution(), screenSession1->GetScreenProperty().GetDensityInCurResolution());
840 ssm_->DestroyVirtualScreen(screenId);
841 }
842
843 /**
844 * @tc.name: SetExtendedScreenFallbackPlan
845 * @tc.desc: SetExtendedScreenFallbackPlan test
846 * @tc.type: FUNC
847 */
848 HWTEST_F(ScreenSessionManagerTest, SetExtendedScreenFallbackPlan, Function | SmallTest | Level3)
849 {
850 ASSERT_NE(ssm_, nullptr);
851 ssm_->SetExtendedScreenFallbackPlan(3030);
852 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
853 VirtualScreenOption virtualOption;
854 virtualOption.name_ = "testVirtualOption";
855 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
856 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
857 screenSession->SetIsInternal(true);
858 ssm_->SetExtendedScreenFallbackPlan(screenId);
859
860 screenSession->SetIsInternal(false);
861 ScreenProperty screenProperty = screenSession->GetScreenProperty();
862 screenProperty.SetCurrentOffScreenRendering(false);
863 ssm_->SetExtendedScreenFallbackPlan(screenId);
864
865 screenProperty.SetCurrentOffScreenRendering(true);
866 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
867 ASSERT_EQ(screenSession->displayNode_, nullptr);
868
869 screenSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
870 ASSERT_EQ(screenSession->displayNode_, nullptr);
871 ssm_->DestroyVirtualScreen(screenId);
872 }
873
874 /**
875 * @tc.name: BlockSetDisplayState
876 * @tc.desc: BlockSetDisplayState test
877 * @tc.type: FUNC
878 */
879 HWTEST_F(ScreenSessionManagerTest, BlockSetDisplayState, Function | SmallTest | Level3)
880 {
881 ASSERT_NE(ssm_, nullptr);
882 EXPECT_TRUE(ssm_->BlockSetDisplayState());
883 }
884
885 /**
886 * @tc.name: TryToCancelScreenOff
887 * @tc.desc: TryToCancelScreenOff test
888 * @tc.type: FUNC
889 */
890 HWTEST_F(ScreenSessionManagerTest, TryToCancelScreenOff, Function | SmallTest | Level3)
891 {
892 ASSERT_NE(ssm_, nullptr);
893 bool ret = ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_;
894 bool ret1 = ssm_->gotScreenOffNotify_;
895 bool ret2 = ssm_->needScreenOffNotify_;
896 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = true;
897 ASSERT_EQ(true, ssm_->TryToCancelScreenOff());
898
899 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = false;
900 ssm_->gotScreenOffNotify_ = true;
901 ASSERT_EQ(false, ssm_->TryToCancelScreenOff());
902
903 ssm_->gotScreenOffNotify_ = false;
904 ssm_->needScreenOffNotify_ = false;
905 ASSERT_EQ(false, ssm_->TryToCancelScreenOff());
906
907 ssm_->needScreenOffNotify_ = true;
908 ASSERT_EQ(true, ssm_->TryToCancelScreenOff());
909 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = ret;
910 ssm_->gotScreenOffNotify_ = ret1;
911 ssm_->needScreenOffNotify_ = ret2;
912 }
913
914 /**
915 * @tc.name: ForceSkipScreenOffAnimation
916 * @tc.desc: ForceSkipScreenOffAnimation test
917 * @tc.type: FUNC
918 */
919 HWTEST_F(ScreenSessionManagerTest, ForceSkipScreenOffAnimation, Function | SmallTest | Level3)
920 {
921 ASSERT_NE(ssm_, nullptr);
922 bool ret = ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_;
923 bool ret1 = ssm_->gotScreenOffNotify_;
924 bool ret2 = ssm_->needScreenOffNotify_;
925 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = true;
926 ssm_->ForceSkipScreenOffAnimation();
927 ASSERT_TRUE(ssm_->sessionDisplayPowerController_->skipScreenOffBlock_);
928
929 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = false;
930 ssm_->gotScreenOffNotify_ = true;
931 ssm_->ForceSkipScreenOffAnimation();
932 ASSERT_TRUE(ssm_->sessionDisplayPowerController_->skipScreenOffBlock_);
933
934 ssm_->gotScreenOffNotify_ = false;
935 ssm_->needScreenOffNotify_ = false;
936 ssm_->ForceSkipScreenOffAnimation();
937 ASSERT_TRUE(ssm_->sessionDisplayPowerController_->skipScreenOffBlock_);
938
939 ssm_->needScreenOffNotify_ = true;
940 ssm_->ForceSkipScreenOffAnimation();
941 ASSERT_TRUE(ssm_->sessionDisplayPowerController_->skipScreenOffBlock_);
942 ssm_->sessionDisplayPowerController_->canCancelSuspendNotify_ = ret;
943 ssm_->gotScreenOffNotify_ = ret1;
944 ssm_->needScreenOffNotify_ = ret2;
945 }
946
947 /**
948 * @tc.name: SetOrientation
949 * @tc.desc: SetOrientation test
950 * @tc.type: FUNC
951 */
952 HWTEST_F(ScreenSessionManagerTest, SetOrientation, TestSize.Level1)
953 {
954 Orientation orientation = Orientation::HORIZONTAL;
955 ScreenId id = 0;
956 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
957 ssm_->screenSessionMap_[id] = screenSession;
958 ASSERT_EQ(DMError::DM_OK, ssm_->SetOrientation(id, orientation));
959 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetOrientation(SCREEN_ID_INVALID, orientation));
960 Orientation invalidOrientation = Orientation{20};
961 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetOrientation(id, invalidOrientation));
962 }
963
964 /**
965 * @tc.name: SetRotationFromWindow
966 * @tc.desc: SetRotationFromWindow test
967 * @tc.type: FUNC
968 */
969 HWTEST_F(ScreenSessionManagerTest, SetRotationFromWindow, TestSize.Level1)
970 {
971 Rotation targetRotation = Rotation::ROTATION_0;
972 ScreenId id = 0;
973 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
974 ssm_->screenSessionMap_[id] = screenSession;
975 ASSERT_EQ(ssm_->SetRotationFromWindow(targetRotation), ssm_->SetRotation(id, targetRotation, true));
976 }
977
978 /**
979 * @tc.name: GetDisplaySnapshot
980 * @tc.desc: ScreenSesionManager screen shot
981 * @tc.type: FUNC
982 */
983 HWTEST_F(ScreenSessionManagerTest, GetDisplaySnapshot, TestSize.Level1)
984 {
985 DisplayId displayId(0);
986 DmErrorCode* errorCode = nullptr;
987 ssm_->GetDisplaySnapshot(displayId, errorCode, false, false);
988 EXPECT_TRUE(1);
989 }
990
991 /**
992 * @tc.name: VirtualScreen
993 * @tc.desc: ScreenSesionManager virtual screen
994 * @tc.type: FUNC
995 */
996 HWTEST_F(ScreenSessionManagerTest, VirtualScreen, TestSize.Level1)
997 {
998 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
999 VirtualScreenOption virtualOption;
1000 virtualOption.name_ = "testVirtualOption";
1001 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1002
1003 std::vector<ScreenId> mirrorScreenIds;
1004 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
1005 ScreenId screenGroupId{1};
1006 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1007 mirrorScreenIds.push_back(VIRTUAL_SCREEN_ID);
1008 ASSERT_NE(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1009
1010 mirrorScreenIds.push_back(screenId);
1011 ASSERT_EQ(DMError::DM_OK, ssm_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId));
1012
1013 auto result1 = ssm_->SetVirtualScreenSurface(screenId, nullptr);
1014 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, result1);
1015 sptr<IConsumerSurface> surface = OHOS::IConsumerSurface::Create();
1016 auto result2 = ssm_->SetVirtualScreenSurface(screenId, surface->GetProducer());
1017 ASSERT_EQ(DMError::DM_OK, result2);
1018 ASSERT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
1019 }
1020
1021 /**
1022 * @tc.name: AutoRotate
1023 * @tc.desc: ScreenSesionManager SetVirtualMirrorScreenCanvasRotation test
1024 * @tc.type: FUNC
1025 */
1026 HWTEST_F(ScreenSessionManagerTest, AutoRotate, TestSize.Level1)
1027 {
1028 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1029 VirtualScreenOption virtualOption;
1030 virtualOption.name_ = "testAutoRotate";
1031 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1032 if (screenId != VIRTUAL_SCREEN_ID) {
1033 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1034 }
1035
1036 auto result1 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, true);
1037 ASSERT_EQ(DMError::DM_OK, result1);
1038 auto result2 = ssm_->SetVirtualMirrorScreenCanvasRotation(screenId, false);
1039 ASSERT_EQ(DMError::DM_OK, result2);
1040 ssm_->DestroyVirtualScreen(screenId);
1041 }
1042
1043 /**
1044 * @tc.name: GetScreenSession
1045 * @tc.desc: GetScreenSession virtual screen
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(ScreenSessionManagerTest, GetScreenSession, TestSize.Level1)
1049 {
1050 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1051 VirtualScreenOption virtualOption;
1052 virtualOption.name_ = "GetScreenSession";
1053 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1054 if (screenId != VIRTUAL_SCREEN_ID) {
1055 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1056 }
1057 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1058 sptr<ScreenSession> screenSession =
1059 new (std::nothrow) ScreenSession("GetScreenSession", screenId, rsid, 0);
1060 ASSERT_NE(ssm_->GetScreenSession(screenId), screenSession);
1061 ssm_->DestroyVirtualScreen(screenId);
1062 }
1063
1064 /**
1065 * @tc.name: GetDefaultScreenSession
1066 * @tc.desc: GetDefaultScreenSession virtual screen
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(ScreenSessionManagerTest, GetDefaultScreenSession, TestSize.Level1)
1070 {
1071 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1072 VirtualScreenOption virtualOption;
1073 virtualOption.name_ = "GetDefaultScreenSession";
1074 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1075 if (screenId != VIRTUAL_SCREEN_ID) {
1076 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1077 }
1078 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1079 sptr<ScreenSession> screenSession =
1080 new (std::nothrow) ScreenSession("GetDefaultScreenSession", screenId, rsid, 0);
1081 ASSERT_NE(ssm_->GetDefaultScreenSession(), screenSession);
1082 ssm_->DestroyVirtualScreen(screenId);
1083 }
1084
1085 /**
1086 * @tc.name: GetDefaultDisplayInfo
1087 * @tc.desc: GetDefaultDisplayInfo virtual screen
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(ScreenSessionManagerTest, GetDefaultDisplayInfo, TestSize.Level1)
1091 {
1092 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1093 VirtualScreenOption virtualOption;
1094 virtualOption.name_ = "GetDefaultDisplayInfo";
1095 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1096 if (screenId != VIRTUAL_SCREEN_ID) {
1097 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1098 }
1099 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1100 sptr<ScreenSession> screenSession =
1101 new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
1102 sptr<DisplayInfo> displayInfo = new DisplayInfo();
1103 if (ssm_->GetScreenSession(screenId) == nullptr) {
1104 ASSERT_EQ(ssm_->GetDefaultDisplayInfo(), nullptr);
1105 }
1106 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1107 ASSERT_NE(ssm_->GetDefaultDisplayInfo(), displayInfo);
1108 ssm_->DestroyVirtualScreen(screenId);
1109 }
1110
1111 /**
1112 * @tc.name: HookDisplayInfoByUid
1113 * @tc.desc: HookDisplayInfo by uid
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid, TestSize.Level1)
1117 {
1118 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1119 VirtualScreenOption virtualOption;
1120 virtualOption.name_ = "GetDefaultScreenSession";
1121 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1122 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1123 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession("GetDefaultDisplayInfo", screenId, rsid, 0);
1124 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
1125 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1126 ASSERT_NE(displayInfo, nullptr);
1127 uint32_t uid = 20020001;
1128 DMHookInfo dmHookInfo;
1129 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1130 displayHookMap[uid] = dmHookInfo;
1131 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
1132 displayInfo->SetWidth(100);
1133 ASSERT_EQ(displayInfo->GetWidth(), 100);
1134 displayInfo->SetHeight(100);
1135 ASSERT_EQ(displayInfo->GetHeight(), 100);
1136 displayInfo->SetVirtualPixelRatio(1.0);
1137 ASSERT_EQ(displayInfo->GetVirtualPixelRatio(), 1.0);
1138 displayInfo->SetRotation(Rotation::ROTATION_0);
1139 ASSERT_EQ(displayInfo->GetRotation(), Rotation::ROTATION_0);
1140 displayInfo->SetDisplayOrientation(DisplayOrientation::PORTRAIT);
1141 ASSERT_EQ(displayInfo->GetDisplayOrientation(), DisplayOrientation::PORTRAIT);
1142 ssm_->DestroyVirtualScreen(screenId);
1143 }
1144
1145 /**
1146 * @tc.name: HookDisplayInfoByUid02
1147 * @tc.desc: HookDisplayInfo by uid
1148 * @tc.type: FUNC
1149 */
1150 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid02, TestSize.Level1)
1151 {
1152 ScreenId screenId;
1153 sptr<ScreenSession> screenSession = InitTestScreenSession("HookDisplayInfoByUid02", screenId);
1154 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1155 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
1156 ASSERT_NE(displayInfo, nullptr);
1157 uint32_t uid = getuid();
1158 DMHookInfo dmHookInfo = CreateDefaultHookInfo();
1159 ssm_->displayHookMap_[uid] = dmHookInfo;
1160 EXPECT_NE(ssm_->displayHookMap_.find(uid), ssm_->displayHookMap_.end());
1161 displayInfo = ssm_->HookDisplayInfoByUid(displayInfo, screenSession);
1162 EXPECT_EQ(displayInfo->GetWidth(), dmHookInfo.width_);
1163 EXPECT_EQ(displayInfo->GetHeight(), dmHookInfo.height_);
1164 EXPECT_EQ(displayInfo->GetVirtualPixelRatio(), dmHookInfo.density_);
1165 EXPECT_EQ(static_cast<uint32_t>(displayInfo->GetRotation()), dmHookInfo.rotation_);
1166 EXPECT_EQ(static_cast<uint32_t>(displayInfo->GetDisplayOrientation()), dmHookInfo.displayOrientation_);
1167 ssm_->displayHookMap_.erase(uid);
1168 ssm_->DestroyVirtualScreen(screenId);
1169 }
1170
1171 /**
1172 * @tc.name: HookDisplayInfoByUid03
1173 * @tc.desc: HookDisplayInfo by uid
1174 * @tc.type: FUNC
1175 */
1176 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid03, TestSize.Level1)
1177 {
1178 ScreenId screenId;
1179 sptr<ScreenSession> screenSession = InitTestScreenSession("HookDisplayInfoByUid03", screenId);
1180 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1181 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
1182 ASSERT_NE(displayInfo, nullptr);
1183 uint32_t uid = getuid();
1184 DMHookInfo dmHookInfo = CreateDefaultHookInfo();
1185 dmHookInfo.enableHookDisplayOrientation_ = false;
1186 dmHookInfo.displayOrientation_ = INVALID_DISPLAY_ORIENTATION;
1187 ssm_->displayHookMap_[uid] = dmHookInfo;
1188 EXPECT_NE(ssm_->displayHookMap_.find(uid), ssm_->displayHookMap_.end());
1189 displayInfo = ssm_->HookDisplayInfoByUid(displayInfo, screenSession);
1190 EXPECT_EQ(displayInfo->GetWidth(), dmHookInfo.width_);
1191 EXPECT_EQ(displayInfo->GetHeight(), dmHookInfo.height_);
1192 EXPECT_EQ(displayInfo->GetVirtualPixelRatio(), dmHookInfo.density_);
1193 EXPECT_EQ(static_cast<uint32_t>(displayInfo->GetRotation()), dmHookInfo.rotation_);
1194 EXPECT_NE(static_cast<uint32_t>(displayInfo->GetDisplayOrientation()), dmHookInfo.displayOrientation_);
1195 ssm_->displayHookMap_.erase(uid);
1196 ssm_->DestroyVirtualScreen(screenId);
1197 }
1198
1199 /**
1200 * @tc.name: HookDisplayInfoByUid03
1201 * @tc.desc: HookDisplayInfo by uid
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid04, TestSize.Level1)
1205 {
1206 ScreenId screenId;
1207 sptr<ScreenSession> screenSession = InitTestScreenSession("HookDisplayInfoByUid04", screenId);
1208 ASSERT_NE(ssm_->GetScreenSession(screenId), nullptr);
1209 sptr<DisplayInfo> displayInfo = ssm_->GetDefaultDisplayInfo();
1210 ASSERT_NE(displayInfo, nullptr);
1211 uint32_t uid = getuid();
1212 DMHookInfo dmHookInfo = CreateDefaultHookInfo();
1213 dmHookInfo.displayOrientation_ = INVALID_DISPLAY_ORIENTATION;
1214 ssm_->displayHookMap_[uid] = dmHookInfo;
1215 EXPECT_NE(ssm_->displayHookMap_.find(uid), ssm_->displayHookMap_.end());
1216 displayInfo = ssm_->HookDisplayInfoByUid(displayInfo, screenSession);
1217 EXPECT_EQ(displayInfo->GetWidth(), dmHookInfo.width_);
1218 EXPECT_EQ(displayInfo->GetHeight(), dmHookInfo.height_);
1219 EXPECT_EQ(displayInfo->GetVirtualPixelRatio(), dmHookInfo.density_);
1220 EXPECT_EQ(static_cast<uint32_t>(displayInfo->GetRotation()), dmHookInfo.rotation_);
1221 EXPECT_NE(static_cast<uint32_t>(displayInfo->GetDisplayOrientation()), dmHookInfo.displayOrientation_);
1222 ssm_->displayHookMap_.erase(uid);
1223 ssm_->DestroyVirtualScreen(screenId);
1224 }
1225
1226 /**
1227 * @tc.name: GetDisplayInfoById
1228 * @tc.desc: GetDisplayInfoById virtual screen
1229 * @tc.type: FUNC
1230 */
1231 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoById, TestSize.Level1)
1232 {
1233 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1234 VirtualScreenOption virtualOption;
1235 virtualOption.name_ = "GetDisplayInfoById";
1236 ASSERT_EQ(ssm_->GetDisplayInfoById(1), nullptr);
1237 }
1238
1239 /**
1240 * @tc.name: GetDisplayInfoByScreen
1241 * @tc.desc: GetDisplayInfoByScreen virtual screen
1242 * @tc.type: FUNC
1243 */
1244 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoByScreen, TestSize.Level1)
1245 {
1246 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1247 VirtualScreenOption virtualOption;
1248 virtualOption.name_ = "GetDisplayInfoByScreen";
1249 ASSERT_EQ(ssm_->GetDisplayInfoByScreen(1), nullptr);
1250 }
1251
1252 /**
1253 * @tc.name: GetScreenInfoById
1254 * @tc.desc: GetScreenInfoById virtual screen
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoById, TestSize.Level1)
1258 {
1259 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1260 VirtualScreenOption virtualOption;
1261 virtualOption.name_ = "GetScreenInfoById";
1262 ASSERT_EQ(ssm_->GetScreenInfoById(1), nullptr);
1263 }
1264
1265 /**
1266 * @tc.name: SetScreenActiveMode
1267 * @tc.desc: SetScreenActiveMode virtual screen
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(ScreenSessionManagerTest, SetScreenActiveMode, TestSize.Level1)
1271 {
1272 #ifdef WM_SCREEN_ACTIVE_MODE_ENABLE
1273 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1274 VirtualScreenOption virtualOption;
1275 virtualOption.name_ = "SetScreenActiveMode";
1276 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1277 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1278 ssm_->DestroyVirtualScreen(screenId);
1279 #endif
1280 }
1281
1282 /**
1283 * @tc.name: NotifyScreenChanged
1284 * @tc.desc: NotifyScreenChanged virtual screen
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(ScreenSessionManagerTest, NotifyScreenChanged, TestSize.Level1)
1288 {
1289 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1290 VirtualScreenOption virtualOption;
1291 virtualOption.name_ = "NotifyScreenChanged";
1292 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1293 sptr<ScreenInfo> screenInfo;
1294 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
1295 screenInfo = new ScreenInfo();
1296 ssm_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
1297 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1298 ssm_->DestroyVirtualScreen(screenId);
1299 }
1300
1301 /**
1302 * @tc.name: NotifyDisplayEvent
1303 * @tc.desc: NotifyDisplayEvent virtual screen
1304 * @tc.type: FUNC
1305 */
1306 HWTEST_F(ScreenSessionManagerTest, NotifyDisplayEvent, TestSize.Level1)
1307 {
1308 DisplayEvent event = DisplayEvent::KEYGUARD_DRAWN;
1309 ssm_->NotifyDisplayEvent(event);
1310 ASSERT_EQ(ssm_->keyguardDrawnDone_, true);
1311
1312 event = DisplayEvent::SCREEN_LOCK_SUSPEND;
1313 ssm_->NotifyDisplayEvent(event);
1314 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1315
1316 event = DisplayEvent::SCREEN_LOCK_OFF;
1317 ssm_->NotifyDisplayEvent(event);
1318 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1319
1320 event = DisplayEvent::SCREEN_LOCK_FINGERPRINT;
1321 ssm_->NotifyDisplayEvent(event);
1322 ASSERT_EQ(ssm_->gotScreenlockFingerprint_, true);
1323
1324 ssm_->gotScreenOffNotify_ = false;
1325 event = DisplayEvent::SCREEN_LOCK_DOZE_FINISH;
1326 ssm_->NotifyDisplayEvent(event);
1327 ASSERT_EQ(ssm_->gotScreenOffNotify_, true);
1328 }
1329
1330 /**
1331 * @tc.name: GetScreenInfoByDisplayId
1332 * @tc.desc: GetScreenInfoByDisplayId virtual screen
1333 * @tc.type: FUNC
1334 */
1335 HWTEST_F(ScreenSessionManagerTest, GetScreenInfoByDisplayId, TestSize.Level1)
1336 {
1337 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1338 VirtualScreenOption virtualOption;
1339 virtualOption.name_ = "GetScreenInfoByDisplayId";
1340 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1341 sptr<ScreenInfo> screenInfo;
1342 screenInfo = ssm_->GetScreenInfoByDisplayId(screenId);
1343 ASSERT_NE(screenInfo, nullptr);
1344 ssm_->DestroyVirtualScreen(screenId);
1345 }
1346
1347 /**
1348 * @tc.name: GetScreenModesByDisplayId
1349 * @tc.desc: GetScreenModesByDisplayId virtual screen
1350 * @tc.type: FUNC
1351 */
1352 HWTEST_F(ScreenSessionManagerTest, GetScreenModesByDisplayId, TestSize.Level1)
1353 {
1354 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1355 VirtualScreenOption virtualOption;
1356 virtualOption.name_ = "GetScreenModesByDisplayId";
1357 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1358 sptr<SupportedScreenModes> screenModes;
1359 screenModes = ssm_->GetScreenModesByDisplayId(screenId);
1360 ASSERT_NE(screenModes, nullptr);
1361 ssm_->DestroyVirtualScreen(screenId);
1362 }
1363
1364 /**
1365 * @tc.name: UpdateDisplayHookInfo001
1366 * @tc.desc: UpdateDisplayHookInfo by uid
1367 * @tc.type: FUNC
1368 */
1369 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo001, TestSize.Level1)
1370 {
1371 uint32_t uid = 20020001;
1372 DMHookInfo dmHookInfo;
1373 dmHookInfo.width_ = 100;
1374 dmHookInfo.height_ = 100;
1375 dmHookInfo.density_ = 1.0;
1376 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1377 displayHookMap[uid] = dmHookInfo;
1378 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), true);
1379 auto info = displayHookMap[uid];
1380 ASSERT_EQ(info.width_, 100);
1381 ASSERT_EQ(info.height_, 100);
1382 ASSERT_EQ(info.density_, 1.0);
1383 }
1384
1385 /**
1386 * @tc.name: UpdateDisplayHookInfo002
1387 * @tc.desc: UpdateDisplayHookInfo by uid
1388 * @tc.type: FUNC
1389 */
1390 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayHookInfo002, TestSize.Level1)
1391 {
1392 uint32_t uid = 20020001;
1393 DMHookInfo dmHookInfo;
1394 dmHookInfo.width_ = 100;
1395 dmHookInfo.height_ = 100;
1396 dmHookInfo.density_ = 1.0;
1397 std::map<uint32_t, DMHookInfo> displayHookMap = {};
1398 displayHookMap[uid] = dmHookInfo;
1399 displayHookMap.erase(uid);
1400 ASSERT_EQ(displayHookMap.find(uid) != displayHookMap.end(), false);
1401 }
1402
1403 /**
1404 * @tc.name: GetDisplayHookInfo
1405 * @tc.desc: GetDisplayHookInfo by uid
1406 * @tc.type: FUNC
1407 */
1408 HWTEST_F(ScreenSessionManagerTest, GetDisplayHookInfo, Function | SmallTest | Level2)
1409 {
1410 int32_t uid = 0;
1411 DMHookInfo hookInfo;
1412 hookInfo.enableHookRotation_ = true;
1413 hookInfo.rotation_ = true;
1414 hookInfo.density_ = 1.1;
1415 hookInfo.width_ = 100;
1416 hookInfo.height_ = 200;
1417 ssm_->UpdateDisplayHookInfo(uid, true, hookInfo);
1418 ssm_->GetDisplayHookInfo(uid, hookInfo);
1419 ASSERT_TRUE(hookInfo.enableHookRotation_);
1420 ASSERT_TRUE(hookInfo.rotation_);
1421 ASSERT_EQ(hookInfo.width_, 100);
1422 ASSERT_EQ(hookInfo.height_, 200);
1423 }
1424
1425
1426 /**
1427 * @tc.name: SetVirtualPixelRatio
1428 * @tc.desc: SetVirtualPixelRatio virtual screen
1429 * @tc.type: FUNC
1430 */
1431 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatio, TestSize.Level1)
1432 {
1433 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1434 VirtualScreenOption virtualOption;
1435 virtualOption.name_ = "SetVirtualPixelRatio";
1436 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1437 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatio(screenId, 0.1));
1438 ssm_->DestroyVirtualScreen(screenId);
1439 }
1440
1441 /**
1442 * @tc.name: SetVirtualPixelRatioSystem
1443 * @tc.desc: SetVirtualPixelRatioSystem virtual screen
1444 * @tc.type: FUNC
1445 */
1446 HWTEST_F(ScreenSessionManagerTest, SetVirtualPixelRatioSystem, TestSize.Level1)
1447 {
1448 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1449 VirtualScreenOption virtualOption;
1450 virtualOption.name_ = "SetVirtualPixelRatioSystem";
1451 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1452 ASSERT_EQ(DMError::DM_OK, ssm_->SetVirtualPixelRatioSystem(screenId, 0.1));
1453 ssm_->DestroyVirtualScreen(screenId);
1454 }
1455
1456 /**
1457 * @tc.name: SetDefaultDensityDpi
1458 * @tc.desc: SetDefaultDensityDpi virtual screen
1459 * @tc.type: FUNC
1460 */
1461 HWTEST_F(ScreenSessionManagerTest, SetDefaultDensityDpi, TestSize.Level1)
1462 {
1463 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1464 VirtualScreenOption virtualOption;
1465 virtualOption.name_ = "SetDefaultDensityDpi";
1466 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1467 ASSERT_EQ(DMError::DM_OK, ssm_->SetDefaultDensityDpi(screenId, 0.1));
1468 ssm_->DestroyVirtualScreen(screenId);
1469 }
1470
1471 /**
1472 * @tc.name: SetResolution
1473 * @tc.desc: SetResolution virtual screen
1474 * @tc.type: FUNC
1475 */
1476 HWTEST_F(ScreenSessionManagerTest, SetResolution, TestSize.Level1)
1477 {
1478 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1479 VirtualScreenOption virtualOption;
1480 virtualOption.name_ = "SetResolution";
1481 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1482 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
1483 ssm_->screenSessionMap_[screenId] = screenSession;
1484 sptr<SupportedScreenModes> mode = new SupportedScreenModes();
1485 mode->width_ = 1;
1486 mode->height_ = 1;
1487 screenSession->modes_ = {mode};
1488 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetResolution(screenId, 100, 100, 0.5));
1489 ssm_->DestroyVirtualScreen(screenId);
1490 }
1491
1492 /**
1493 * @tc.name: GetScreenColorGamut
1494 * @tc.desc: GetScreenColorGamut virtual screen
1495 * @tc.type: FUNC
1496 */
1497 HWTEST_F(ScreenSessionManagerTest, GetScreenColorGamut, TestSize.Level1)
1498 {
1499 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1500 ScreenColorGamut colorGamut = ScreenColorGamut::COLOR_GAMUT_SRGB;
1501 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorGamut(1, colorGamut));
1502 DisplayId id = 0;
1503 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
1504 ssm_->screenSessionMap_[id] = screenSession;
1505 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1506 ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, ssm_->GetScreenColorGamut(id, colorGamut));
1507 } else {
1508 ASSERT_NE(DMError::DM_OK, ssm_->GetScreenColorGamut(id, colorGamut));
1509 }
1510 #endif
1511 }
1512
1513 /**
1514 * @tc.name: LoadScreenSceneXml
1515 * @tc.desc: LoadScreenSceneXml virtual screen
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(ScreenSessionManagerTest, LoadScreenSceneXml, TestSize.Level1)
1519 {
1520 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1521 VirtualScreenOption virtualOption;
1522 virtualOption.name_ = "LoadScreenSceneXml";
1523 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1524 ssm_->LoadScreenSceneXml();
1525 ASSERT_EQ(ssm_->SetScreenActiveMode(screenId, 0), DMError::DM_OK);
1526 ssm_->DestroyVirtualScreen(screenId);
1527 }
1528
1529 /**
1530 * @tc.name: GetScreenGamutMap
1531 * @tc.desc: GetScreenGamutMap virtual screen
1532 * @tc.type: FUNC
1533 */
1534 HWTEST_F(ScreenSessionManagerTest, GetScreenGamutMap, TestSize.Level1)
1535 {
1536 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1537 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1538 VirtualScreenOption virtualOption;
1539 virtualOption.name_ = "GetScreenGamutMap";
1540 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1541 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1542 sptr<ScreenSession> screenSession =
1543 new (std::nothrow) ScreenSession("GetScreenGamutMap", screenId, rsid, 0);
1544 ScreenGamutMap gamutMap;
1545 ASSERT_EQ(DMError::DM_OK, ssm_->GetScreenGamutMap(screenId, gamutMap));
1546 ssm_->DestroyVirtualScreen(screenId);
1547 #endif
1548 }
1549
1550 /**
1551 * @tc.name: MakeExpand
1552 * @tc.desc: MakeExpand virtual screen
1553 * @tc.type: FUNC
1554 */
1555 HWTEST_F(ScreenSessionManagerTest, MakeExpand, TestSize.Level1)
1556 {
1557 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1558 VirtualScreenOption virtualOption;
1559 virtualOption.name_ = "MakeExpand";
1560 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1561 if (screenId != VIRTUAL_SCREEN_ID) {
1562 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1563 }
1564 std::vector<ScreenId> mirrorScreenIds;
1565 std::vector<Point> startPoints;
1566 ScreenId screenGroupId2 = DISPLAY_ID_INVALID;
1567 ASSERT_NE(DMError::DM_ERROR_RENDER_SERVICE_FAILED, ssm_->MakeExpand(mirrorScreenIds, startPoints, screenGroupId2));
1568 ssm_->DestroyVirtualScreen(screenId);
1569 }
1570
1571 /**
1572 * @tc.name: DeleteScreenId
1573 * @tc.desc: DeleteScreenId virtual screen
1574 * @tc.type: FUNC
1575 */
1576 HWTEST_F(ScreenSessionManagerTest, DeleteScreenId, TestSize.Level1)
1577 {
1578 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1579 VirtualScreenOption virtualOption;
1580 virtualOption.name_ = "DeleteScreenId";
1581 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1582 if (screenId != VIRTUAL_SCREEN_ID) {
1583 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1584 }
1585 ScreenSessionManager::ScreenIdManager sim;
1586 ASSERT_EQ(false, sim.DeleteScreenId(99));
1587 ssm_->DestroyVirtualScreen(screenId);
1588 }
1589
1590 /**
1591 * @tc.name: HasRsScreenId
1592 * @tc.desc: HasRsScreenId virtual screen
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F(ScreenSessionManagerTest, HasRsScreenId, TestSize.Level1)
1596 {
1597 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1598 VirtualScreenOption virtualOption;
1599 virtualOption.name_ = "HasRsScreenId";
1600
1601 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1602 if (screenId != VIRTUAL_SCREEN_ID) {
1603 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1604 }
1605 ScreenSessionManager::ScreenIdManager sim;
1606 ASSERT_EQ(false, sim.HasRsScreenId(99));
1607 ssm_->DestroyVirtualScreen(screenId);
1608 }
1609
1610 /**
1611 * @tc.name: AddAsFirstScreenLocked
1612 * @tc.desc: AddAsFirstScreenLocked virtual screen
1613 * @tc.type: FUNC
1614 */
1615 HWTEST_F(ScreenSessionManagerTest, AddAsFirstScreenLocked, TestSize.Level1)
1616 {
1617 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1618 VirtualScreenOption virtualOption;
1619 virtualOption.name_ = "AddAsFirstScreenLocked";
1620
1621 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1622 if (screenId != VIRTUAL_SCREEN_ID) {
1623 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1624 }
1625 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
1626 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1627 ASSERT_NE(sessiongroup, ssm_->AddAsFirstScreenLocked(newScreen));
1628 ssm_->DestroyVirtualScreen(screenId);
1629 }
1630
1631 /**
1632 * @tc.name: AddAsSuccedentScreenLocked
1633 * @tc.desc: AddAsSuccedentScreenLocked virtual screen
1634 * @tc.type: FUNC
1635 */
1636 HWTEST_F(ScreenSessionManagerTest, AddAsSuccedentScreenLocked, TestSize.Level1)
1637 {
1638 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1639 VirtualScreenOption virtualOption;
1640 virtualOption.name_ = "AddAsSuccedentScreenLocked";
1641
1642 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1643 if (screenId != VIRTUAL_SCREEN_ID) {
1644 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1645 }
1646 sptr<ScreenSession> newScreen;
1647 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1648 ASSERT_EQ(sessiongroup, ssm_->AddAsSuccedentScreenLocked(newScreen));
1649 ssm_->DestroyVirtualScreen(screenId);
1650 }
1651
1652 /**
1653 * @tc.name: SetMirror
1654 * @tc.desc: SetMirror virtual screen
1655 * @tc.type: FUNC
1656 */
1657 HWTEST_F(ScreenSessionManagerTest, SetMirror, TestSize.Level1)
1658 {
1659 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1660 VirtualScreenOption virtualOption;
1661 virtualOption.name_ = "SetMirror";
1662
1663 std::vector<ScreenId> screens{0, 1, 2, 3, 4, 5, 6, 7};
1664 sptr<ScreenSession> screenSession = nullptr;
1665 screenSession = new (std::nothrow) ScreenSession("GetScreenGamutMap", 2, 2, 3);
1666 std::map<ScreenId, sptr<ScreenSession>> screenSessionMap_{
1667 {2, screenSession},
1668 };
1669 ssm_->screenSessionMap_ = screenSessionMap_;
1670 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1671 auto screen = ssm_->GetScreenSession(2);
1672 screen->GetScreenProperty().SetScreenType(ScreenType::REAL);
1673 ASSERT_EQ(DMError::DM_OK, ssm_->SetMirror(2, screens, DMRect::NONE()));
1674 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetMirror(9, screens, DMRect::NONE()));
1675 ASSERT_EQ(DMError::DM_OK, ssm_->SetMirror(screenId, screens, DMRect::NONE()));
1676 auto mirrorscreen = ssm_->GetScreenSession(screenId);
1677 ASSERT_TRUE(mirrorscreen != nullptr);
1678 mirrorscreen->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
1679 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->SetMirror(screenId, screens, DMRect::NONE()));
1680 ssm_->DestroyVirtualScreen(screenId);
1681 }
1682
1683 /**
1684 * @tc.name: GetAbstractScreenGroup
1685 * @tc.desc: GetAbstractScreenGroup virtual screen
1686 * @tc.type: FUNC
1687 */
1688 HWTEST_F(ScreenSessionManagerTest, GetAbstractScreenGroup, TestSize.Level1)
1689 {
1690 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1691 VirtualScreenOption virtualOption;
1692 virtualOption.name_ = "GetAbstractScreenGroup";
1693
1694 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1695 if (screenId != VIRTUAL_SCREEN_ID) {
1696 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1697 }
1698 sptr<ScreenSessionGroup> sreengroup=nullptr;
1699 ASSERT_EQ(sreengroup, ssm_->GetAbstractScreenGroup(2));
1700 ssm_->DestroyVirtualScreen(screenId);
1701 }
1702
1703 /**
1704 * @tc.name: InitAbstractScreenModesInfo
1705 * @tc.desc: InitAbstractScreenModesInfo virtual screen
1706 * @tc.type: FUNC
1707 */
1708 HWTEST_F(ScreenSessionManagerTest, InitAbstractScreenModesInfo, TestSize.Level1)
1709 {
1710 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1711 VirtualScreenOption virtualOption;
1712 virtualOption.name_ = "InitAbstractScreenModesInfo";
1713
1714 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1715 if (screenId != VIRTUAL_SCREEN_ID) {
1716 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1717 }
1718 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1719 ASSERT_EQ(false, ssm_->InitAbstractScreenModesInfo(screenSession));
1720 ssm_->DestroyVirtualScreen(screenId);
1721 }
1722
1723 /**
1724 * @tc.name: AddToGroupLocked
1725 * @tc.desc: AddToGroupLocked virtual screen
1726 * @tc.type: FUNC
1727 */
1728 HWTEST_F(ScreenSessionManagerTest, AddToGroupLocked, TestSize.Level1)
1729 {
1730 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1731 VirtualScreenOption virtualOption;
1732 virtualOption.name_ = "AddToGroupLocked";
1733
1734 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1735 if (screenId != VIRTUAL_SCREEN_ID) {
1736 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1737 }
1738 sptr<ScreenSession> newScreen=nullptr;
1739 sptr<ScreenSessionGroup> sessiongroup=nullptr;
1740 ASSERT_EQ(sessiongroup, ssm_->AddToGroupLocked(newScreen));
1741 ssm_->DestroyVirtualScreen(screenId);
1742 }
1743
1744 /**
1745 * @tc.name: InitVirtualScreen
1746 * @tc.desc: InitVirtualScreen virtual screen
1747 * @tc.type: FUNC
1748 */
1749 HWTEST_F(ScreenSessionManagerTest, InitVirtualScreen, TestSize.Level1)
1750 {
1751 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1752 VirtualScreenOption virtualOption;
1753 virtualOption.name_ = "InitVirtualScreen";
1754 sptr<ScreenSession> screenSession;
1755 VirtualScreenOption option;
1756 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
1757 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1758 if (screenId != VIRTUAL_SCREEN_ID) {
1759 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1760 }
1761 screenSession =new (std::nothrow) ScreenSession();
1762 ASSERT_NE(screenSession, ssm_->InitVirtualScreen(1, 2, option));
1763 ssm_->DestroyVirtualScreen(screenId);
1764 }
1765
1766 /**
1767 * @tc.name: InitAndGetScreen
1768 * @tc.desc: InitAndGetScreen virtual screen
1769 * @tc.type: FUNC
1770 */
1771 HWTEST_F(ScreenSessionManagerTest, InitAndGetScreen, TestSize.Level1)
1772 {
1773 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1774 VirtualScreenOption virtualOption;
1775 virtualOption.name_ = "InitAndGetScreen";
1776
1777 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1778 if (screenId != VIRTUAL_SCREEN_ID) {
1779 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1780 }
1781 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1782 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1783 ssm_->DestroyVirtualScreen(screenId);
1784 }
1785
1786 /**
1787 * @tc.name: RemoveFromGroupLocked
1788 * @tc.desc: RemoveFromGroupLocked virtual screen
1789 * @tc.type: FUNC
1790 */
1791 HWTEST_F(ScreenSessionManagerTest, RemoveFromGroupLocked, TestSize.Level1)
1792 {
1793 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1794 VirtualScreenOption virtualOption;
1795 virtualOption.name_ = "RemoveFromGroupLocked";
1796
1797 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1798 if (screenId != VIRTUAL_SCREEN_ID) {
1799 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1800 }
1801 sptr<ScreenSession> newScreen = new (std::nothrow) ScreenSession();
1802 sptr<ScreenSessionGroup> sessiongroup;
1803 ASSERT_EQ(sessiongroup, ssm_->RemoveFromGroupLocked(newScreen));
1804 ssm_->DestroyVirtualScreen(screenId);
1805 }
1806
1807 /**
1808 * @tc.name: CreateAndGetNewScreenId
1809 * @tc.desc: CreateAndGetNewScreenId virtual screen
1810 * @tc.type: FUNC
1811 */
1812 HWTEST_F(ScreenSessionManagerTest, CreateAndGetNewScreenId, TestSize.Level1)
1813 {
1814 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1815 VirtualScreenOption virtualOption;
1816 virtualOption.name_ = "CreateAndGetNewScreenId";
1817 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1818 ScreenSessionManager::ScreenIdManager sim;
1819 ASSERT_EQ(1000, sim.CreateAndGetNewScreenId(screenId));
1820 ssm_->DestroyVirtualScreen(screenId);
1821 }
1822
1823 /**
1824 * @tc.name: AddScreenToGroup
1825 * @tc.desc: AddScreenToGroup virtual screen
1826 * @tc.type: FUNC
1827 */
1828 HWTEST_F(ScreenSessionManagerTest, AddScreenToGroup, TestSize.Level1)
1829 {
1830 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1831 VirtualScreenOption virtualOption;
1832 virtualOption.name_ = "AddScreenToGroup";
1833 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1834 if (screenId != VIRTUAL_SCREEN_ID) {
1835 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1836 }
1837 const std::vector<ScreenId> addScreens;
1838 const std::vector<Point> addChildPos;
1839 std::map<ScreenId, bool> removeChildResMap;
1840 sptr<ScreenSessionGroup> group;
1841 ssm_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
1842 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1843 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1844 ssm_->DestroyVirtualScreen(screenId);
1845 }
1846
1847 /**
1848 * @tc.name: GetRSDisplayNodeByScreenId
1849 * @tc.desc: GetRSDisplayNodeByScreenId virtual screen
1850 * @tc.type: FUNC
1851 */
1852 HWTEST_F(ScreenSessionManagerTest, GetRSDisplayNodeByScreenId, TestSize.Level1)
1853 {
1854 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1855 VirtualScreenOption virtualOption;
1856 virtualOption.name_ = "GetRSDisplayNodeByScreenId";
1857 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1858 if (screenId != VIRTUAL_SCREEN_ID) {
1859 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1860 }
1861 ssm_->GetRSDisplayNodeByScreenId(2);
1862 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1863 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1864 ssm_->DestroyVirtualScreen(screenId);
1865 }
1866
1867 /**
1868 * @tc.name: GetAllDisplayIds
1869 * @tc.desc: GetAllDisplayIds virtual screen
1870 * @tc.type: FUNC
1871 */
1872 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayIds, TestSize.Level0)
1873 {
1874 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1875 VirtualScreenOption virtualOption;
1876 virtualOption.name_ = "GetAllDisplayIds";
1877 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1878 if (screenId != VIRTUAL_SCREEN_ID) {
1879 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1880 }
1881 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1882 std::vector<DisplayId> displays(2);
1883 ASSERT_NE(displays, ssm_->GetAllDisplayIds());
1884 ssm_->DestroyVirtualScreen(screenId);
1885 }
1886
1887 /**
1888 * @tc.name: SetScreenGamutMap
1889 * @tc.desc: SetScreenGamutMap virtual screen
1890 * @tc.type: FUNC
1891 */
1892 HWTEST_F(ScreenSessionManagerTest, SetScreenGamutMap, TestSize.Level1)
1893 {
1894 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1895 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1896 VirtualScreenOption virtualOption;
1897 virtualOption.name_ = "SetScreenGamutMap";
1898 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1899 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1900 sptr<ScreenSession> screenSession =
1901 new (std::nothrow) ScreenSession("SetScreenGamutMap", screenId, rsid, 0);
1902 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM,
1903 ssm_->SetScreenGamutMap(SCREEN_ID_INVALID, ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION));
1904 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenGamutMap(screenId, ScreenGamutMap::GAMUT_MAP_EXTENSION));
1905 ssm_->DestroyVirtualScreen(screenId);
1906 #endif
1907 }
1908
1909 /**
1910 * @tc.name: StopExpand
1911 * @tc.desc: StopExpand virtual screen
1912 * @tc.type: FUNC
1913 */
1914 HWTEST_F(ScreenSessionManagerTest, StopExpand, TestSize.Level1)
1915 {
1916 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1917 VirtualScreenOption virtualOption;
1918 virtualOption.name_ = "StopExpand";
1919 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1920 if (screenId != VIRTUAL_SCREEN_ID) {
1921 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1922 }
1923 std::vector<ScreenId> expandScreenIds {0, 1, 2, 3, 4, 5};
1924 ASSERT_NE(DMError::DM_ERROR_NOT_SYSTEM_APP, ssm_->StopExpand(expandScreenIds));
1925 ssm_->DestroyVirtualScreen(screenId);
1926 }
1927
1928 /**
1929 * @tc.name: OnScreenDisconnect
1930 * @tc.desc: OnScreenDisconnect virtual screen
1931 * @tc.type: FUNC
1932 */
1933 HWTEST_F(ScreenSessionManagerTest, OnScreenDisconnect, TestSize.Level1)
1934 {
1935 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1936 VirtualScreenOption virtualOption;
1937 virtualOption.name_ = "OnScreenDisconnect";
1938 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1939 if (screenId != VIRTUAL_SCREEN_ID) {
1940 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1941 }
1942 ssm_->OnScreenDisconnect(1);
1943 sptr<ScreenSession> screenSession =new (std::nothrow) ScreenSession();
1944 ASSERT_NE(screenSession, ssm_->InitAndGetScreen(2));
1945 ssm_->DestroyVirtualScreen(screenId);
1946 }
1947
1948 /**
1949 * @tc.name: SetScreenColorGamut
1950 * @tc.desc: SetScreenColorGamut virtual screen
1951 * @tc.type: FUNC
1952 */
1953 HWTEST_F(ScreenSessionManagerTest, SetScreenColorGamut, TestSize.Level1)
1954 {
1955 #ifdef WM_SCREEN_COLOR_GAMUT_ENABLE
1956 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1957 VirtualScreenOption virtualOption;
1958 virtualOption.name_ = "SetScreenColorGamut";
1959 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1960 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1961 sptr<ScreenSession> screenSession =
1962 new (std::nothrow) ScreenSession("SetScreenColorGamut", screenId, rsid, 0);
1963 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorGamut(screenId, 2));
1964 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorGamut(SCREEN_ID_INVALID, 2));
1965 ssm_->DestroyVirtualScreen(screenId);
1966 #endif
1967 }
1968
1969 /**
1970 * @tc.name: SetScreenColorTransform
1971 * @tc.desc: SetScreenColorTransform virtual screen
1972 * @tc.type: FUNC
1973 */
1974 HWTEST_F(ScreenSessionManagerTest, SetScreenColorTransform, TestSize.Level1)
1975 {
1976 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
1977 VirtualScreenOption virtualOption;
1978 virtualOption.name_ = "SetScreenColorTransform";
1979 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
1980 if (screenId != VIRTUAL_SCREEN_ID) {
1981 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
1982 }
1983 auto rsid = ssm_->screenIdManager_.ConvertToRsScreenId(screenId);
1984 sptr<ScreenSession> screenSession =
1985 new (std::nothrow) ScreenSession("SetScreenColorTransform", screenId, rsid, 0);
1986 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenColorTransform(screenId));
1987 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorTransform(SCREEN_ID_INVALID));
1988 ssm_->DestroyVirtualScreen(screenId);
1989 }
1990
1991 /**
1992 * @tc.name: SetScreenRotationLocked
1993 * @tc.desc: SetScreenRotationLocked virtual screen
1994 * @tc.type: FUNC
1995 */
1996 HWTEST_F(ScreenSessionManagerTest, SetScreenRotationLocked, TestSize.Level1)
1997 {
1998 ScreenId id = 0;
1999 ssm_->screenSessionMap_[id] = nullptr;
2000 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenRotationLocked(false));
2001 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2002 ssm_->screenSessionMap_[id] = screenSession;
2003 ASSERT_EQ(DMError::DM_OK, ssm_->SetScreenRotationLocked(false));
2004 }
2005
2006 /**
2007 * @tc.name: UpdateScreenRotationProperty
2008 * @tc.desc: UpdateScreenRotationProperty virtual screen
2009 * @tc.type: FUNC
2010 */
2011 HWTEST_F(ScreenSessionManagerTest, UpdateScreenRotationProperty, TestSize.Level1)
2012 {
2013 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2014 VirtualScreenOption virtualOption;
2015 virtualOption.name_ = "UpdateScreenRotationProperty";
2016 RRect bounds;
2017 bounds.rect_.width_ = 1344;
2018 bounds.rect_.height_ = 2772;
2019 int rotation = 1;
2020 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
2021 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(1, bounds, 1, screenPropertyChangeType, false);
2022 auto screenId = ScreenSessionManager::GetInstance().CreateVirtualScreen(virtualOption,
2023 displayManagerAgent->AsObject());
2024 if (screenId != VIRTUAL_SCREEN_ID) {
2025 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2026 }
2027 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(screenId, bounds, rotation,
2028 screenPropertyChangeType, false);
2029 screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_END;
2030 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(screenId, bounds, rotation,
2031 screenPropertyChangeType, false);
2032 screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_UPDATE_PROPERTY_ONLY;
2033 ScreenSessionManager::GetInstance().UpdateScreenRotationProperty(screenId, bounds, rotation,
2034 screenPropertyChangeType, true);
2035 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession();
2036 ASSERT_NE(screenSession, ScreenSessionManager::GetInstance().InitAndGetScreen(2));
2037 ssm_->DestroyVirtualScreen(screenId);
2038 }
2039
2040 /**
2041 * @tc.name: MakeUniqueScreen
2042 * @tc.desc: Make unique screen
2043 * @tc.type: FUNC
2044 */
2045 HWTEST_F(ScreenSessionManagerTest, MakeUniqueScreen, TestSize.Level1)
2046 {
2047 #ifdef WM_MULTI_SCREEN_ENABLE
2048 vector<ScreenId> screenIds;
2049 screenIds.clear();
2050 std::vector<DisplayId> displayIds;
2051 ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->MakeUniqueScreen(screenIds, displayIds));
2052 #endif
2053 }
2054
2055 /**
2056 * @tc.name: ConvertScreenIdToRsScreenId
2057 * @tc.desc: convert screen id to RS screen id
2058 * @tc.type: FUNC
2059 */
2060 HWTEST_F(ScreenSessionManagerTest, ConvertScreenIdToRsScreenId, TestSize.Level1)
2061 {
2062 ScreenId rsScreenId = VIRTUAL_SCREEN_RS_ID;
2063 ssm_->screenIdManager_.rs2SmsScreenIdMap_.erase(rsScreenId);
2064 ScreenId screenId = ssm_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId);
2065 ASSERT_EQ(true, ssm_->screenIdManager_.HasRsScreenId(rsScreenId));
2066 ScreenId tmpRsScreenId = SCREEN_ID_INVALID;
2067 ASSERT_EQ(true, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
2068 ASSERT_EQ(tmpRsScreenId, rsScreenId);
2069 ssm_->screenIdManager_.DeleteScreenId(screenId);
2070 ASSERT_EQ(false, ssm_->ConvertScreenIdToRsScreenId(screenId, tmpRsScreenId));
2071 }
2072
2073 /**
2074 * @tc.name: DisableMirror
2075 * @tc.desc: DisableMirror test
2076 * @tc.type: FUNC
2077 */
2078 HWTEST_F(ScreenSessionManagerTest, DisableMirror, TestSize.Level1)
2079 {
2080 ASSERT_EQ(DMError::DM_OK, ssm_->DisableMirror(false));
2081 }
2082
2083 /**
2084 * @tc.name: HasImmersiveWindow
2085 * @tc.desc: HasImmersiveWindow test
2086 * @tc.type: FUNC
2087 */
2088 HWTEST_F(ScreenSessionManagerTest, HasImmersiveWindow, TestSize.Level1)
2089 {
2090 bool immersive = false;
2091 ASSERT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(0u, immersive));
2092 immersive = true;
2093 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->HasImmersiveWindow(0u, immersive));
2094 }
2095
2096 /**
2097 * @tc.name: SetSpecifiedScreenPower
2098 * @tc.desc: ScreenSessionManager screen power
2099 * @tc.type: FUNC
2100 */
2101 HWTEST_F(ScreenSessionManagerTest, SetSpecifiedScreenPower, TestSize.Level1)
2102 {
2103 ScreenId mainScreenId(DEFAULT_SCREEN_ID);
2104 ScreenPowerState state = ScreenPowerState::POWER_ON;
2105 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
2106 ASSERT_EQ(false, ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
2107
2108 reason = PowerStateChangeReason::STATE_CHANGE_REASON_COLLABORATION;
2109 EXPECT_TRUE(ssm_->SetSpecifiedScreenPower(mainScreenId, state, reason));
2110 }
2111
2112 /**
2113 * @tc.name: NotifyFoldStatusChanged
2114 * @tc.desc: ScreenSessionManager notify foldStatus changed
2115 * @tc.type: FUNC
2116 */
2117 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged, TestSize.Level1)
2118 {
2119 const std::string& dumpParam = "-p";
2120 if (ssm_ != nullptr)
2121 {
2122 int errCode = ssm_->NotifyFoldStatusChanged(dumpParam);
2123 ASSERT_EQ(errCode, 0);
2124 } else {
2125 ASSERT_EQ(1, 0);
2126 }
2127 }
2128
2129 /**
2130 * @tc.name: NotifyPrivateWindowListChanged
2131 * @tc.desc: ScreenSessionManager notify PrivateWindowList changed
2132 * @tc.type: FUNC
2133 */
2134 HWTEST_F(ScreenSessionManagerTest, NotifyPrivateWindowListChanged, TestSize.Level1)
2135 {
2136 DisplayId id = 0;
2137 std::vector<std::string> privacyWindowList{"win0", "win1"};
2138 if (ssm_ != nullptr)
2139 {
2140 ssm_->NotifyPrivateWindowListChanged(id, privacyWindowList);
2141 ASSERT_EQ(0, 0);
2142 } else {
2143 ASSERT_EQ(1, 0);
2144 }
2145 }
2146
2147 /**
2148 * @tc.name: SetPrivacyStateByDisplayId01
2149 * @tc.desc: SetPrivacyStateByDisplayId true test
2150 * @tc.type: FUNC
2151 */
2152 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId01, TestSize.Level1)
2153 {
2154 DisplayId id = 0;
2155 bool hasPrivate = true;
2156 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2157 ssm_->screenSessionMap_[id] = screenSession;
2158 ASSERT_NE(nullptr, screenSession);
2159 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
2160 bool result = screenSession->HasPrivateSessionForeground();
2161 EXPECT_EQ(result, true);
2162 }
2163
2164 /**
2165 * @tc.name: SetPrivacyStateByDisplayId02
2166 * @tc.desc: SetPrivacyStateByDisplayId false test
2167 * @tc.type: FUNC
2168 */
2169 HWTEST_F(ScreenSessionManagerTest, SetPrivacyStateByDisplayId02, TestSize.Level1)
2170 {
2171 DisplayId id = 0;
2172 bool hasPrivate = false;
2173 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2174 ssm_->screenSessionMap_[id] = screenSession;
2175 ASSERT_NE(nullptr, screenSession);
2176 ssm_->SetPrivacyStateByDisplayId(id, hasPrivate);
2177 bool result = screenSession->HasPrivateSessionForeground();
2178 EXPECT_EQ(result, false);
2179 }
2180
2181 /**
2182 * @tc.name: SetScreenPrivacyWindowList
2183 * @tc.desc: SetScreenPrivacyWindowList test
2184 * @tc.type: FUNC
2185 */
2186 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyWindowList, TestSize.Level1)
2187 {
2188 DisplayId id = 0;
2189 std::vector<std::string> privacyWindowList{"win0", "win1"};
2190 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
2191 ASSERT_NE(nullptr, screenSession);
2192 ssm_->SetScreenPrivacyWindowList(id, privacyWindowList);
2193 ASSERT_EQ(0, 0);
2194 }
2195
2196 /**
2197 * @tc.name: GetAllScreenIds
2198 * @tc.desc: GetAllScreenIds screen power
2199 * @tc.type: FUNC
2200 */
2201 HWTEST_F(ScreenSessionManagerTest, GetAllScreenIds, TestSize.Level1)
2202 {
2203 sptr<ScreenSession> screenSession = new ScreenSession();
2204 ASSERT_NE(nullptr, screenSession);
2205 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
2206 ssm_->GetAllScreenIds();
2207 EXPECT_TRUE(1);
2208 }
2209
2210 /**
2211 * @tc.name: GetAllScreenInfos
2212 * @tc.desc: GetAllScreenInfos test
2213 * @tc.type: FUNC
2214 */
2215 HWTEST_F(ScreenSessionManagerTest, GetAllScreenInfos, TestSize.Level1)
2216 {
2217 ScreenId id = 0;
2218 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2219 ssm_->screenSessionMap_[id] = screenSession;
2220 ASSERT_NE(nullptr, screenSession);
2221 std::vector<sptr<ScreenInfo>> screenInfos;
2222 EXPECT_EQ(DMError::DM_OK, ssm_->GetAllScreenInfos(screenInfos));
2223 }
2224
2225 /**
2226 * @tc.name: GetScreenSupportedColorGamuts
2227 * @tc.desc: GetScreenSupportedColorGamuts test
2228 * @tc.type: FUNC
2229 */
2230 HWTEST_F(ScreenSessionManagerTest, GetScreenSupportedColorGamuts, TestSize.Level1)
2231 {
2232 std::vector<ScreenColorGamut> colorGamuts;
2233 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenSupportedColorGamuts(SCREEN_ID_INVALID, colorGamuts));
2234 ScreenId id = 0;
2235 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2236 ssm_->screenSessionMap_[id] = screenSession;
2237 ASSERT_NE(nullptr, screenSession);
2238 EXPECT_EQ(ssm_->GetScreenSupportedColorGamuts(id, colorGamuts),
2239 screenSession->GetScreenSupportedColorGamuts(colorGamuts));
2240 }
2241
2242 /**
2243 * @tc.name: GetPixelFormat
2244 * @tc.desc: GetPixelFormat test
2245 * @tc.type: FUNC
2246 */
2247 HWTEST_F(ScreenSessionManagerTest, GetPixelFormat, TestSize.Level1)
2248 {
2249 GraphicPixelFormat pixelFormat;
2250 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
2251 ScreenId id = 0;
2252 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2253 ssm_->screenSessionMap_[id] = screenSession;
2254 ASSERT_NE(nullptr, screenSession);
2255 EXPECT_EQ(ssm_->GetPixelFormat(id, pixelFormat), screenSession->GetPixelFormat(pixelFormat));
2256 }
2257
2258 /**
2259 * @tc.name: SetPixelFormat
2260 * @tc.desc: SetPixelFormat test
2261 * @tc.type: FUNC
2262 */
2263 HWTEST_F(ScreenSessionManagerTest, SetPixelFormat, TestSize.Level1)
2264 {
2265 GraphicPixelFormat pixelFormat = GraphicPixelFormat{GRAPHIC_PIXEL_FMT_CLUT8};
2266 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetPixelFormat(SCREEN_ID_INVALID, pixelFormat));
2267 ScreenId id = 0;
2268 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2269 ssm_->screenSessionMap_[id] = screenSession;
2270 ASSERT_NE(nullptr, screenSession);
2271 EXPECT_EQ(ssm_->SetPixelFormat(id, pixelFormat), screenSession->SetPixelFormat(pixelFormat));
2272 }
2273
2274 /**
2275 * @tc.name: GetSupportedHDRFormats
2276 * @tc.desc: GetSupportedHDRFormats test
2277 * @tc.type: FUNC
2278 */
2279 HWTEST_F(ScreenSessionManagerTest, GetSupportedHDRFormats, TestSize.Level1)
2280 {
2281 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2282 std::vector<ScreenHDRFormat> hdrFormats;
2283 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedHDRFormats(SCREEN_ID_INVALID, hdrFormats));
2284 ScreenId id = 0;
2285 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2286 ssm_->screenSessionMap_[id] = screenSession;
2287 ASSERT_NE(nullptr, screenSession);
2288 EXPECT_EQ(ssm_->GetSupportedHDRFormats(id, hdrFormats), screenSession->GetSupportedHDRFormats(hdrFormats));
2289 #endif
2290 }
2291
2292 /**
2293 * @tc.name: GetScreenHDRFormat
2294 * @tc.desc: GetScreenHDRFormat test
2295 * @tc.type: FUNC
2296 */
2297 HWTEST_F(ScreenSessionManagerTest, GetScreenHDRFormat, TestSize.Level1)
2298 {
2299 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2300 ScreenHDRFormat hdrFormat;
2301 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenHDRFormat(SCREEN_ID_INVALID, hdrFormat));
2302 ScreenId id = 0;
2303 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2304 ssm_->screenSessionMap_[id] = screenSession;
2305 ASSERT_NE(nullptr, screenSession);
2306 EXPECT_EQ(ssm_->GetScreenHDRFormat(id, hdrFormat), screenSession->GetScreenHDRFormat(hdrFormat));
2307 #endif
2308 }
2309
2310 /**
2311 * @tc.name: SetScreenHDRFormat
2312 * @tc.desc: SetScreenHDRFormat test
2313 * @tc.type: FUNC
2314 */
2315 HWTEST_F(ScreenSessionManagerTest, SetScreenHDRFormat, TestSize.Level1)
2316 {
2317 #ifdef WM_SCREEN_HDR_FORMAT_ENABLE
2318 int32_t modeIdx {0};
2319 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenHDRFormat(SCREEN_ID_INVALID, modeIdx));
2320 ScreenId id = 0;
2321 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2322 ssm_->screenSessionMap_[id] = screenSession;
2323 ASSERT_NE(nullptr, screenSession);
2324 EXPECT_EQ(ssm_->SetScreenHDRFormat(id, modeIdx), screenSession->SetScreenHDRFormat(modeIdx));
2325 #endif
2326 }
2327
2328 /**
2329 * @tc.name: GetSupportedColorSpaces
2330 * @tc.desc: GetSupportedColorSpaces test
2331 * @tc.type: FUNC
2332 */
2333 HWTEST_F(ScreenSessionManagerTest, GetSupportedColorSpaces, TestSize.Level1)
2334 {
2335 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2336 std::vector<GraphicCM_ColorSpaceType> colorSpaces;
2337 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetSupportedColorSpaces(SCREEN_ID_INVALID, colorSpaces));
2338 ScreenId id = 0;
2339 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2340 ssm_->screenSessionMap_[id] = screenSession;
2341 ASSERT_NE(nullptr, screenSession);
2342 EXPECT_EQ(ssm_->GetSupportedColorSpaces(id, colorSpaces), screenSession->GetSupportedColorSpaces(colorSpaces));
2343 #endif
2344 }
2345
2346 /**
2347 * @tc.name: GetScreenColorSpace
2348 * @tc.desc: GetScreenColorSpace test
2349 * @tc.type: FUNC
2350 */
2351 HWTEST_F(ScreenSessionManagerTest, GetScreenColorSpace, TestSize.Level1)
2352 {
2353 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2354 GraphicCM_ColorSpaceType colorSpace;
2355 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->GetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
2356 ScreenId id = 0;
2357 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2358 ssm_->screenSessionMap_[id] = screenSession;
2359 ASSERT_NE(nullptr, screenSession);
2360 EXPECT_EQ(ssm_->GetScreenColorSpace(id, colorSpace), screenSession->GetScreenColorSpace(colorSpace));
2361 #endif
2362 }
2363
2364 /**
2365 * @tc.name: SetScreenColorSpace
2366 * @tc.desc: SetScreenColorSpace test
2367 * @tc.type: FUNC
2368 */
2369 HWTEST_F(ScreenSessionManagerTest, SetScreenColorSpace, TestSize.Level1)
2370 {
2371 #ifdef WM_SCREEN_COLOR_SPACE_ENABLE
2372 GraphicCM_ColorSpaceType colorSpace = GraphicCM_ColorSpaceType{GRAPHIC_CM_COLORSPACE_NONE};
2373 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetScreenColorSpace(SCREEN_ID_INVALID, colorSpace));
2374 ScreenId id = 0;
2375 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2376 ssm_->screenSessionMap_[id] = screenSession;
2377 ASSERT_NE(nullptr, screenSession);
2378 EXPECT_EQ(ssm_->SetScreenColorSpace(id, colorSpace), screenSession->SetScreenColorSpace(colorSpace));
2379 #endif
2380 }
2381
2382 /**
2383 * @tc.name: HasPrivateWindow
2384 * @tc.desc: HasPrivateWindow test
2385 * @tc.type: FUNC
2386 */
2387 HWTEST_F(ScreenSessionManagerTest, HasPrivateWindow, TestSize.Level1)
2388 {
2389 bool hasPrivateWindow;
2390 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->HasPrivateWindow(SCREEN_ID_INVALID, hasPrivateWindow));
2391 DisplayId id = 0;
2392 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2393 ssm_->screenSessionMap_[id] = screenSession;
2394 ASSERT_NE(nullptr, screenSession);
2395 EXPECT_EQ(DMError::DM_OK, ssm_->HasPrivateWindow(id, hasPrivateWindow));
2396 }
2397
2398 /**
2399 * @tc.name: GetAvailableArea
2400 * @tc.desc: GetAvailableArea test
2401 * @tc.type: FUNC
2402 */
2403 HWTEST_F(ScreenSessionManagerTest, GetAvailableArea01, TestSize.Level1)
2404 {
2405 DMRect area;
2406 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetAvailableArea(SCREEN_ID_INVALID, area));
2407 DisplayId id = 0;
2408 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2409 ssm_->screenSessionMap_[id] = screenSession;
2410 ASSERT_NE(nullptr, screenSession);
2411 EXPECT_EQ(DMError::DM_OK, ssm_->GetAvailableArea(id, area));
2412 }
2413
2414 /**
2415 * @tc.name: GetAvailableArea
2416 * @tc.desc: GetAvailableArea test
2417 * @tc.type: FUNC
2418 */
2419 HWTEST_F(ScreenSessionManagerTest, GetAvailableArea02, TestSize.Level1)
2420 {
2421 DMRect area;
2422 DisplayId id = 999;
2423 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2424 ssm_->screenSessionMap_.clear();
2425 ssm_->screenSessionMap_[id] = screenSession;
2426 ASSERT_NE(nullptr, screenSession);
2427 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetAvailableArea(id, area));
2428 ssm_->screenSessionMap_.clear();
2429 }
2430
2431
2432 /**
2433 * @tc.name: GetExpandAvailableArea
2434 * @tc.desc: GetExpandAvailableArea test
2435 * @tc.type: FUNC
2436 */
2437 HWTEST_F(ScreenSessionManagerTest, GetExpandAvailableArea02, TestSize.Level1)
2438 {
2439 DMRect area;
2440 DisplayId id = 0;
2441 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetExpandAvailableArea(id, area));
2442 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2443 ssm_->screenSessionMap_.clear();
2444 ssm_->screenSessionMap_[id] = screenSession;
2445 ASSERT_NE(nullptr, screenSession);
2446 EXPECT_EQ(DMError::DM_OK, ssm_->GetExpandAvailableArea(id, area));
2447 ssm_->screenSessionMap_.clear();
2448 }
2449
2450 /**
2451 * @tc.name: ResetAllFreezeStatus
2452 * @tc.desc: ResetAllFreezeStatus test
2453 * @tc.type: FUNC
2454 */
2455 HWTEST_F(ScreenSessionManagerTest, ResetAllFreezeStatus, TestSize.Level1)
2456 {
2457 EXPECT_EQ(DMError::DM_OK, ssm_->ResetAllFreezeStatus());
2458 }
2459
2460 /**
2461 * @tc.name: SetVirtualScreenRefreshRate
2462 * @tc.desc: SetVirtualScreenRefreshRate test
2463 * @tc.type: FUNC
2464 */
2465 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenRefreshRate, TestSize.Level1)
2466 {
2467 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2468 ScreenId id = 0;
2469 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
2470 ssm_->screenSessionMap_[id] = screenSession;
2471 uint32_t refreshInterval {2};
2472 VirtualScreenOption virtualOption;
2473 virtualOption.name_ = "createVirtualOption";
2474 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2475 if (screenId != VIRTUAL_SCREEN_ID) {
2476 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2477 }
2478 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(id, refreshInterval));
2479 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenRefreshRate(screenId, refreshInterval));
2480 uint32_t invalidRefreshInterval {0};
2481 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ssm_->SetVirtualScreenRefreshRate(screenId, invalidRefreshInterval));
2482 ssm_->DestroyVirtualScreen(screenId);
2483 }
2484
2485 /**
2486 * @tc.name: SetVirtualScreenFlag
2487 * @tc.desc: SetVirtualScreenFlag test
2488 * @tc.type: FUNC
2489 */
2490 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenFlag, TestSize.Level1)
2491 {
2492 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2493 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
2494 VirtualScreenOption virtualOption;
2495 virtualOption.name_ = "createVirtualOption";
2496 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2497 if (screenId != VIRTUAL_SCREEN_ID) {
2498 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2499 }
2500 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
2501 ssm_->DestroyVirtualScreen(screenId);
2502 }
2503
2504 /**
2505 * @tc.name: GetVirtualScreenFlag
2506 * @tc.desc: GetVirtualScreenFlag test
2507 * @tc.type: FUNC
2508 */
2509 HWTEST_F(ScreenSessionManagerTest, GetVirtualScreenFlag, TestSize.Level1)
2510 {
2511 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2512 VirtualScreenFlag screenFlag = VirtualScreenFlag::DEFAULT;
2513 VirtualScreenOption virtualOption;
2514 virtualOption.name_ = "createVirtualOption";
2515 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2516 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2517
2518 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualScreenFlag(screenId, screenFlag));
2519 EXPECT_EQ(screenFlag, ssm_->GetVirtualScreenFlag(screenId));
2520 ssm_->DestroyVirtualScreen(screenId);
2521 }
2522
2523 /**
2524 * @tc.name: ResizeVirtualScreen
2525 * @tc.desc: ResizeVirtualScreen test
2526 * @tc.type: FUNC
2527 */
2528 HWTEST_F(ScreenSessionManagerTest, ResizeVirtualScreen, TestSize.Level1)
2529 {
2530 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2531 VirtualScreenOption virtualOption;
2532 virtualOption.name_ = "createVirtualOption";
2533 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2534 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2535
2536 uint32_t width {100};
2537 uint32_t height {100};
2538 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
2539 if (screenSession->GetDisplayNode() != nullptr) {
2540 EXPECT_EQ(DMError::DM_OK, ssm_->ResizeVirtualScreen(screenId, width, height));
2541 }
2542 ssm_->DestroyVirtualScreen(screenId);
2543 }
2544
2545 /**
2546 * @tc.name: SetVirtualMirrorScreenScaleMode
2547 * @tc.desc: SetVirtualMirrorScreenScaleMode test
2548 * @tc.type: FUNC
2549 */
2550 HWTEST_F(ScreenSessionManagerTest, SetVirtualMirrorScreenScaleMode, TestSize.Level1)
2551 {
2552 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
2553 VirtualScreenOption virtualOption;
2554 virtualOption.name_ = "createVirtualOption";
2555 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2556 if (screenId != VIRTUAL_SCREEN_ID) {
2557 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2558 }
2559 ScreenScaleMode scaleMode = ScreenScaleMode::FILL_MODE;
2560 EXPECT_EQ(DMError::DM_OK, ssm_->SetVirtualMirrorScreenScaleMode(screenId, scaleMode));
2561 ssm_->DestroyVirtualScreen(screenId);
2562 }
2563
2564 /**
2565 * @tc.name: StopMirror
2566 * @tc.desc: StopMirror test
2567 * @tc.type: FUNC
2568 */
2569 HWTEST_F(ScreenSessionManagerTest, StopMirror, TestSize.Level1)
2570 {
2571 std::vector<ScreenId> mirrorScreenIds {0, 1, 2, 3, 4, 5};
2572 EXPECT_EQ(DMError::DM_OK, ssm_->StopMirror(mirrorScreenIds));
2573 }
2574
2575 /**
2576 * @tc.name: GetDensityInCurResolution
2577 * @tc.desc: GetDensityInCurResolution screen power
2578 * @tc.type: FUNC
2579 */
2580 HWTEST_F(ScreenSessionManagerTest, GetDensityInCurResolution, TestSize.Level1)
2581 {
2582 sptr<ScreenSession> screenSession = new ScreenSession();
2583 ASSERT_NE(nullptr, screenSession);
2584 ssm_->screenSessionMap_.insert(std::make_pair(1, screenSession));
2585 ScreenId screenId = 100;
2586 float x = 3.14;
2587 auto res = ssm_->GetDensityInCurResolution(screenId, x);
2588 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, res);
2589 screenId = 1;
2590 res = ssm_->GetDensityInCurResolution(screenId, x);
2591 EXPECT_EQ(DMError::DM_OK, res);
2592 }
2593
2594 /**
2595 * @tc.name: SetScreenOffDelayTime
2596 * @tc.desc: SetScreenOffDelayTime test
2597 * @tc.type: FUNC
2598 */
2599 HWTEST_F(ScreenSessionManagerTest, SetScreenOffDelayTime, TestSize.Level1)
2600 {
2601 int32_t delay = CV_WAIT_SCREENOFF_MS - 1;
2602 int32_t ret = ssm_->SetScreenOffDelayTime(delay);
2603 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS);
2604
2605 delay = CV_WAIT_SCREENOFF_MS + 1;
2606 ret = ssm_->SetScreenOffDelayTime(delay);
2607 EXPECT_EQ(ret, delay);
2608
2609 delay = CV_WAIT_SCREENOFF_MS_MAX - 1;
2610 ret = ssm_->SetScreenOffDelayTime(delay);
2611 EXPECT_EQ(ret, delay);
2612
2613 delay = CV_WAIT_SCREENOFF_MS_MAX + 1;
2614 ret = ssm_->SetScreenOffDelayTime(delay);
2615 EXPECT_EQ(ret, CV_WAIT_SCREENOFF_MS_MAX);
2616 }
2617
2618 /**
2619 * @tc.name: GetDeviceScreenConfig
2620 * @tc.desc: GetDeviceScreenConfig test
2621 * @tc.type: FUNC
2622 */
2623 HWTEST_F(ScreenSessionManagerTest, GetDeviceScreenConfig, TestSize.Level1)
2624 {
2625 DeviceScreenConfig deviceScreenConfig = ssm_->GetDeviceScreenConfig();
2626 EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
2627 }
2628
2629 /**
2630 * @tc.name: SetVirtualScreenBlackList
2631 * @tc.desc: SetVirtualScreenBlackList test
2632 * @tc.type: FUNC
2633 */
2634 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList01, TestSize.Level1)
2635 {
2636 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
2637 EXPECT_NE(displayManagerAgent, nullptr);
2638
2639 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
2640 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
2641
2642 VirtualScreenOption virtualOption;
2643 virtualOption.name_ = "createVirtualOption";
2644 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2645 if (screenId != VIRTUAL_SCREEN_ID) {
2646 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2647 }
2648 std::vector<uint64_t> windowId = {10, 20, 30};
2649 ssm_->SetVirtualScreenBlackList(screenId, windowId);
2650 ssm_->DestroyVirtualScreen(screenId);
2651 }
2652
2653 /**
2654 * @tc.name: SetVirtualScreenBlackList
2655 * @tc.desc: ConvertScreenIdToRsScreenId = false
2656 * @tc.type: FUNC
2657 */
2658 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenBlackList02, TestSize.Level1)
2659 {
2660 ScreenId screenId = 1010;
2661 ScreenId rsScreenId = SCREEN_ID_INVALID;
2662 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2663 std::vector<uint64_t> windowId = {10, 20, 30};
2664 ssm_->SetVirtualScreenBlackList(screenId, windowId);
2665 }
2666
2667 /**
2668 * @tc.name: SetVirtualDisplayMuteFlag
2669 * @tc.desc: SetVirtualDisplayMuteFlag test
2670 * @tc.type: FUNC
2671 */
2672 HWTEST_F(ScreenSessionManagerTest, SetVirtualDisplayMuteFlag01, Function | SmallTest | Level3)
2673 {
2674 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
2675 EXPECT_NE(displayManagerAgent, nullptr);
2676
2677 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
2678 EXPECT_EQ(DMError::DM_OK, ssm_->RegisterDisplayManagerAgent(displayManagerAgent, type));
2679
2680 VirtualScreenOption virtualOption;
2681 virtualOption.name_ = "createVirtualOption";
2682 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
2683 if (screenId != VIRTUAL_SCREEN_ID) {
2684 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
2685 }
2686 bool muteFlag = false;
2687 ssm_->SetVirtualDisplayMuteFlag(screenId, muteFlag);
2688 ssm_->DestroyVirtualScreen(screenId);
2689 }
2690
2691 /**
2692 * @tc.name: SetVirtualDisplayMuteFlag
2693 * @tc.desc: ConvertScreenIdToRsScreenId = false
2694 * @tc.type: FUNC
2695 */
2696 HWTEST_F(ScreenSessionManagerTest, SetVirtualDisplayMuteFlag02, Function | SmallTest | Level3)
2697 {
2698 ScreenId screenId = 1010;
2699 ScreenId rsScreenId = SCREEN_ID_INVALID;
2700 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2701 bool muteFlag = false;
2702 ssm_->SetVirtualDisplayMuteFlag(screenId, muteFlag);
2703 }
2704
2705 /**
2706 * @tc.name: GetAllDisplayPhysicalResolution
2707 * @tc.desc: GetAllDisplayPhysicalResolution test
2708 * @tc.type: FUNC
2709 */
2710 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution01, TestSize.Level1)
2711 {
2712 std::vector<DisplayPhysicalResolution> allSize {};
2713 if (ssm_ != nullptr) {
2714 allSize = ssm_->GetAllDisplayPhysicalResolution();
2715 ASSERT_TRUE(!allSize.empty());
2716 } else {
2717 ASSERT_TRUE(allSize.empty());
2718 }
2719 }
2720
2721 /**
2722 * @tc.name: GetAllDisplayPhysicalResolution
2723 * @tc.desc: GetAllDisplayPhysicalResolution test
2724 * @tc.type: FUNC
2725 */
2726 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution02, TestSize.Level1)
2727 {
2728 ssm_->allDisplayPhysicalResolution_.clear();
2729 ssm_->allDisplayPhysicalResolution_.emplace_back(DisplayPhysicalResolution());
2730 std::vector<DisplayPhysicalResolution> result = ssm_->GetAllDisplayPhysicalResolution();
2731 EXPECT_TRUE(!result.empty());
2732 ssm_->allDisplayPhysicalResolution_.clear();
2733 }
2734
2735 /**
2736 * @tc.name: GetAllDisplayPhysicalResolution
2737 * @tc.desc: GetAllDisplayPhysicalResolution test
2738 * @tc.type: FUNC
2739 */
2740 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution03, TestSize.Level1)
2741 {
2742 DisplayPhysicalResolution resolution;
2743 resolution.physicalWidth_ = 1920;
2744 resolution.physicalHeight_ = 1080;
2745 ssm_->allDisplayPhysicalResolution_.clear();
2746 ssm_->allDisplayPhysicalResolution_.push_back(resolution);
2747 std::vector<DisplayPhysicalResolution> result = ssm_->GetAllDisplayPhysicalResolution();
2748 EXPECT_EQ(result.size(), 1);
2749 EXPECT_EQ(result[0].physicalWidth_, 1920);
2750 EXPECT_EQ(result[0].physicalHeight_, 1080);
2751 ssm_->allDisplayPhysicalResolution_.clear();
2752 }
2753
2754 /**
2755 * @tc.name: GetAllDisplayPhysicalResolution
2756 * @tc.desc: GetAllDisplayPhysicalResolution test
2757 * @tc.type: FUNC
2758 */
2759 HWTEST_F(ScreenSessionManagerTest, GetAllDisplayPhysicalResolution04, TestSize.Level1)
2760 {
2761 ssm_->allDisplayPhysicalResolution_.clear();
2762 ssm_->allDisplayPhysicalResolution_.emplace_back(DisplayPhysicalResolution());
2763 ssm_->allDisplayPhysicalResolution_.back().foldDisplayMode_ = FoldDisplayMode::GLOBAL_FULL;
2764 std::vector<DisplayPhysicalResolution> resolutions = ssm_->GetAllDisplayPhysicalResolution();
2765 EXPECT_EQ(resolutions.back().foldDisplayMode_, FoldDisplayMode::FULL);
2766 ssm_->allDisplayPhysicalResolution_.clear();
2767 }
2768
2769 /**
2770 * @tc.name: SetDisplayScale
2771 * @tc.desc: SetDisplayScale test
2772 * @tc.type: FUNC
2773 */
2774 HWTEST_F(ScreenSessionManagerTest, SetDisplayScale, TestSize.Level1)
2775 {
2776 ASSERT_NE(ssm_, nullptr);
2777 ScreenId fakeScreenId = static_cast<ScreenId>(-1);
2778 float scaleX = 1.0f;
2779 float scaleY = 1.0f;
2780 float pivotX = 0.5f;
2781 float pivotY = 0.5f;
2782 ssm_->SetDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY);
2783 ssm_->SetDisplayScale(ssm_->GetDefaultScreenId(), scaleX, scaleY, pivotX, pivotY);
2784 }
2785
2786 /**
2787 * @tc.name: ScreenCastConnection
2788 * @tc.desc: ScreenCastConnection test
2789 * @tc.type: FUNC
2790 */
2791 HWTEST_F(ScreenSessionManagerTest, ScreenCastConnection, TestSize.Level1)
2792 {
2793 std::string castBundleName = "testCastBundleName";
2794 std::string castAbilityName = "testCastAbilityName";
2795
2796 ScreenCastConnection::GetInstance().SetBundleName("");
2797 ScreenCastConnection::GetInstance().SetAbilityName("");
2798 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), "");
2799 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), "");
2800
2801 EXPECT_EQ(ScreenCastConnection::GetInstance().CastConnectExtension(1), false);
2802
2803 ScreenCastConnection::GetInstance().SetBundleName(castBundleName);
2804 ScreenCastConnection::GetInstance().SetAbilityName(castAbilityName);
2805 EXPECT_EQ(ScreenCastConnection::GetInstance().GetBundleName(), castBundleName);
2806 EXPECT_EQ(ScreenCastConnection::GetInstance().GetAbilityName(), castAbilityName);
2807
2808 MessageParcel data;
2809 MessageParcel reply;
2810 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_START, data, reply);
2811 ScreenCastConnection::GetInstance().SendMessageToCastService(CAST_WIRED_PROJECTION_STOP, data, reply);
2812 ScreenCastConnection::GetInstance().CastDisconnectExtension();
2813 EXPECT_EQ(ScreenCastConnection::GetInstance().IsConnectedSync(), false);
2814 }
2815
2816 /**
2817 * @tc.name: ReportFoldStatusToScb
2818 * @tc.desc: clientProxy_ = nullptr
2819 * @tc.type: FUNC
2820 */
2821 HWTEST_F(ScreenSessionManagerTest, ReportFoldStatusToScb, TestSize.Level1)
2822 {
2823 ssm_->clientProxy_ = nullptr;
2824 FoldStatus currentStatus = FoldStatus::FOLDED;
2825 FoldStatus nextStatus = FoldStatus::HALF_FOLD;
2826 int32_t duration = 1;
2827 float postureAngle = 1.2;
2828 std::vector<std::string> screenFoldInfo {std::to_string(static_cast<int32_t>(currentStatus)),
2829 std::to_string(static_cast<int32_t>(nextStatus)), std::to_string(duration), std::to_string(postureAngle)};
2830 ssm_->ReportFoldStatusToScb(screenFoldInfo);
2831 ASSERT_NE(ssm_, nullptr);
2832 }
2833
2834 /**
2835 * @tc.name: DisablePowerOffRenderControl
2836 * @tc.desc: ConvertScreenIdToRsScreenId = true
2837 * @tc.type: FUNC
2838 */
2839 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl01, TestSize.Level1)
2840 {
2841 ScreenId screenId = 1050;
2842 ScreenId rsScreenId = SCREEN_ID_INVALID;
2843 ScreenId rsScreenId1 = 1060;
2844 ssm_->screenIdManager_.sms2RsScreenIdMap_[screenId] = rsScreenId1;
2845 ASSERT_TRUE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2846 ssm_->DisablePowerOffRenderControl(screenId);
2847 }
2848
2849 /**
2850 * @tc.name: DisablePowerOffRenderControl
2851 * @tc.desc: ConvertScreenIdToRsScreenId = false
2852 * @tc.type: FUNC
2853 */
2854 HWTEST_F(ScreenSessionManagerTest, DisablePowerOffRenderControl02, TestSize.Level1)
2855 {
2856 ScreenId screenId = 1010;
2857 ScreenId rsScreenId = SCREEN_ID_INVALID;
2858 ASSERT_FALSE(ssm_->ConvertScreenIdToRsScreenId(screenId, rsScreenId));
2859 ssm_->DisablePowerOffRenderControl(screenId);
2860 }
2861
2862 /**
2863 * @tc.name: CheckAndSendHiSysEvent
2864 * @tc.desc: eventName != "CREATE_VIRTUAL_SCREEN"
2865 * @tc.type: FUNC
2866 */
2867 HWTEST_F(ScreenSessionManagerTest, CheckAndSendHiSysEvent, TestSize.Level1)
2868 {
2869 std::string eventName = "GET_DISPLAY_SNAPSHOT";
2870 std::string bundleName = "hmos.screenshot";
2871 ssm_->CheckAndSendHiSysEvent(eventName, bundleName);
2872 ASSERT_NE(ssm_, nullptr);
2873 }
2874
2875 /**
2876 * @tc.name: ProxyForFreeze
2877 * @tc.desc: ProxyForFreeze
2878 * @tc.type: FUNC
2879 */
2880 HWTEST_F(ScreenSessionManagerTest, ProxyForFreeze, TestSize.Level1)
2881 {
2882 int32_t pid = 1;
2883 std::set<int32_t> unfreezedPidList = {1, 2, 3};
2884 std::set<DisplayManagerAgentType> pidAgentTypes = {DisplayManagerAgentType::SCREEN_EVENT_LISTENER};
2885 ScreenId screenId = 1050;
2886 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2887 ssm_->NotifyUnfreezedAgents(pid, unfreezedPidList, pidAgentTypes, screenSession);
2888
2889 ssm_->NotifyUnfreezed(unfreezedPidList, screenSession);
2890
2891 std::set<int32_t> pidList = {1, 2, 3};
2892 DMError ret = ssm_->ProxyForFreeze(pidList, true);
2893 ASSERT_EQ(ret, DMError::DM_OK);
2894
2895 ret = ssm_->ProxyForFreeze(pidList, false);
2896 ASSERT_EQ(ret, DMError::DM_OK);
2897 }
2898
2899 /**
2900 * @tc.name: GetOrCreateFakeScreenSession
2901 * @tc.desc: GetOrCreateFakeScreenSession
2902 * @tc.type: FUNC
2903 */
2904 HWTEST_F(ScreenSessionManagerTest, GetOrCreateFakeScreenSession, TestSize.Level1)
2905 {
2906 ScreenId screenId = 1050;
2907 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2908 auto ret = ssm_->GetOrCreateFakeScreenSession(screenSession);
2909 ssm_->InitFakeScreenSession(screenSession);
2910 ASSERT_NE(ret, nullptr);
2911 }
2912
2913 /**
2914 * @tc.name: SetVirtualScreenSecurityExemption
2915 * @tc.desc: SetVirtualScreenSecurityExemption
2916 * @tc.type: FUNC
2917 */
2918 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenSecurityExemption, TestSize.Level1)
2919 {
2920 ScreenId screenId = 0;
2921 uint32_t pid = 1111;
2922 std::vector<uint64_t> windowList = {11, 22, 33};
2923 auto ret = ssm_->SetVirtualScreenSecurityExemption(screenId, pid, windowList);
2924 ASSERT_EQ(ret, DMError::DM_ERROR_UNKNOWN);
2925 }
2926
2927 /**
2928 * @tc.name: NotifyFoldToExpandCompletion
2929 * @tc.desc: NotifyFoldToExpandCompletion
2930 * @tc.type: FUNC
2931 */
2932 HWTEST_F(ScreenSessionManagerTest, NotifyFoldToExpandCompletion, TestSize.Level1)
2933 {
2934 bool foldToExpand = false;
2935 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
2936
2937 foldToExpand = true;
2938 ssm_->NotifyFoldToExpandCompletion(foldToExpand);
2939 ASSERT_NE(ssm_, nullptr);
2940 }
2941
2942 /**
2943 * @tc.name: UpdateAvailableArea
2944 * @tc.desc: screenSession == nullptr
2945 * @tc.type: FUNC
2946 */
2947 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea01, TestSize.Level1)
2948 {
2949 ScreenId screenId = 1050;
2950 DMRect area = DMRect{};
2951 ssm_->UpdateAvailableArea(screenId, area);
2952 ASSERT_NE(ssm_, nullptr);
2953 }
2954
2955 /**
2956 * @tc.name: UpdateAvailableArea
2957 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is true
2958 * @tc.type: FUNC
2959 */
2960 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea02, TestSize.Level1)
2961 {
2962 ScreenId screenId = 1050;
2963 DMRect area{0, 0, 600, 900};
2964 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2965 ASSERT_NE(screenSession, nullptr);
2966 ssm_->screenSessionMap_[screenId] = screenSession;
2967 auto screenSession1 = ssm_->GetScreenSession(screenId);
2968 ASSERT_EQ(screenSession1, screenSession);
2969 ASSERT_TRUE(screenSession->UpdateAvailableArea(area));
2970 ssm_->UpdateAvailableArea(screenId, area);
2971 }
2972
2973 /**
2974 * @tc.name: UpdateAvailableArea
2975 * @tc.desc: screenSession != nullptr screenSession->UpdateAvailableArea(area) is false
2976 * @tc.type: FUNC
2977 */
2978 HWTEST_F(ScreenSessionManagerTest, UpdateAvailableArea03, TestSize.Level1)
2979 {
2980 ScreenId screenId = 1050;
2981 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
2982 ASSERT_NE(screenSession, nullptr);
2983 DMRect area = screenSession->GetAvailableArea();
2984 ssm_->screenSessionMap_[screenId] = screenSession;
2985 ASSERT_FALSE(screenSession->UpdateAvailableArea(area));
2986 ssm_->UpdateAvailableArea(screenId, area);
2987 }
2988
2989 /**
2990 * @tc.name: NotifyAvailableAreaChanged
2991 * @tc.desc: agents.empty()
2992 * @tc.type: FUNC
2993 */
2994 HWTEST_F(ScreenSessionManagerTest, NotifyAvailableAreaChanged01, TestSize.Level1)
2995 {
2996 DMRect area = DMRect{};
2997 DisplayId displayId = 0;
2998 ASSERT_NE(ssm_, nullptr);
2999 ssm_->NotifyAvailableAreaChanged(area, displayId);
3000 }
3001
3002 /**
3003 * @tc.name: TriggerFoldStatusChange01
3004 * @tc.desc: test interface TriggerFoldStatusChange
3005 * @tc.type: FUNC
3006 */
3007 HWTEST_F(ScreenSessionManagerTest, TriggerFoldStatusChange01, TestSize.Level1)
3008 {
3009 #ifdef FOLD_ABILITY_ENABLE
3010 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
3011 return;
3012 }
3013 ASSERT_NE(ssm_, nullptr);
3014 FoldStatus foldStatus = FoldStatus::EXPAND;
3015 ssm_->TriggerFoldStatusChange(foldStatus);
3016 FoldStatus res = ssm_->GetFoldStatus();
3017 EXPECT_EQ(res, foldStatus);
3018
3019 foldStatus = FoldStatus::FOLDED;
3020 ssm_->TriggerFoldStatusChange(foldStatus);
3021 res = ssm_->GetFoldStatus();
3022 EXPECT_EQ(res, foldStatus);
3023
3024 foldStatus = FoldStatus::HALF_FOLD;
3025 ssm_->TriggerFoldStatusChange(foldStatus);
3026 res = ssm_->GetFoldStatus();
3027 EXPECT_EQ(res, foldStatus);
3028
3029 foldStatus = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_EXPAND;
3030 ssm_->TriggerFoldStatusChange(foldStatus);
3031 res = ssm_->GetFoldStatus();
3032 EXPECT_EQ(res, foldStatus);
3033
3034 foldStatus = FoldStatus::FOLD_STATE_EXPAND_WITH_SECOND_HALF_FOLDED;
3035 ssm_->TriggerFoldStatusChange(foldStatus);
3036 res = ssm_->GetFoldStatus();
3037 EXPECT_EQ(res, foldStatus);
3038
3039 foldStatus = FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_EXPAND;
3040 ssm_->TriggerFoldStatusChange(foldStatus);
3041 res = ssm_->GetFoldStatus();
3042 EXPECT_EQ(res, foldStatus);
3043
3044 foldStatus = FoldStatus::FOLD_STATE_FOLDED_WITH_SECOND_HALF_FOLDED;
3045 ssm_->TriggerFoldStatusChange(foldStatus);
3046 res = ssm_->GetFoldStatus();
3047 EXPECT_EQ(res, foldStatus);
3048
3049 foldStatus = FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_EXPAND;
3050 ssm_->TriggerFoldStatusChange(foldStatus);
3051 res = ssm_->GetFoldStatus();
3052 EXPECT_EQ(res, foldStatus);
3053
3054 foldStatus = FoldStatus::FOLD_STATE_HALF_FOLDED_WITH_SECOND_HALF_FOLDED;
3055 ssm_->TriggerFoldStatusChange(foldStatus);
3056 res = ssm_->GetFoldStatus();
3057 EXPECT_EQ(res, foldStatus);
3058 #endif
3059 }
3060
3061 /**
3062 * @tc.name: NotifyFoldStatusChanged
3063 * @tc.desc: NotifyFoldStatusChanged
3064 * @tc.type: FUNC
3065 */
3066 HWTEST_F(ScreenSessionManagerTest, NotifyFoldStatusChanged02, TestSize.Level1)
3067 {
3068 #ifdef FOLD_ABILITY_ENABLE
3069 std::string statusParam;
3070 auto ret = ssm_->NotifyFoldStatusChanged(statusParam);
3071 ASSERT_EQ(ret, -1);
3072
3073 statusParam = "-z"; // STATUS_FOLD_HALF
3074 ret = ssm_->NotifyFoldStatusChanged(statusParam);
3075 ASSERT_EQ(ret, 0);
3076
3077 statusParam = "-y"; // STATUS_EXPAND
3078 ret = ssm_->NotifyFoldStatusChanged(statusParam);
3079 ASSERT_EQ(ret, 0);
3080
3081 statusParam = "-coor"; // ARG_FOLD_DISPLAY_COOR
3082 ret = ssm_->NotifyFoldStatusChanged(statusParam);
3083
3084 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
3085 ASSERT_EQ(ssm_->foldScreenController_, nullptr);
3086 GTEST_SKIP();
3087 }
3088 if (!(ssm_->IsFoldable())) {
3089 ssm_->foldScreenController_ = new FoldScreenController(
3090 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
3091 }
3092 ASSERT_NE(ssm_->foldScreenController_, nullptr);
3093 statusParam = "-y";
3094 ssm_->HandleFoldScreenPowerInit();
3095 ret = ssm_->NotifyFoldStatusChanged(statusParam);
3096 ASSERT_EQ(ret, 0);
3097 #endif
3098 }
3099
3100 /**
3101 * @tc.name: Dump
3102 * @tc.desc: Dump
3103 * @tc.type: FUNC
3104 */
3105 HWTEST_F(ScreenSessionManagerTest, Dump, TestSize.Level1)
3106 {
3107 int fd = 2;
3108 std::vector<std::u16string> args;
3109 int ret = ssm_->Dump(fd, args);
3110 ASSERT_EQ(ret, 0);
3111 }
3112
3113 /**
3114 * @tc.name: GetDisplayNode
3115 * @tc.desc: GetDisplayNode
3116 * @tc.type: FUNC
3117 */
3118 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode01, TestSize.Level1)
3119 {
3120 MockAccesstokenKit::MockIsSystemApp(true);
3121 ScreenId screenId = 1051;
3122 auto ret = ssm_->GetDisplayNode(screenId);
3123 ASSERT_EQ(ret, nullptr);
3124 }
3125
3126 /**
3127 * @tc.name: GetDisplayNode
3128 * @tc.desc: !screenSession = false
3129 * @tc.type: FUNC
3130 */
3131 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode02, TestSize.Level1)
3132 {
3133 MockAccesstokenKit::MockIsSystemApp(true);
3134 ScreenId screenId = 1050;
3135 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
3136 ASSERT_NE(screenSession, nullptr);
3137 ssm_->screenSessionMap_[screenId] = screenSession;
3138 auto ret = ssm_->GetDisplayNode(screenId);
3139 ASSERT_NE(ret, nullptr);
3140 }
3141
3142 /**
3143 * @tc.name: GetDisplayNode
3144 * @tc.desc: SystemCalling false
3145 * @tc.type: FUNC
3146 */
3147 HWTEST_F(ScreenSessionManagerTest, GetDisplayNode03, TestSize.Level1)
3148 {
3149 logMsg.clear();
3150 LOG_SetCallback(MyLogCallback);
3151 MockAccesstokenKit::MockIsSystemApp(false);
3152 MockAccesstokenKit::MockIsSACalling(false);
3153 ScreenId screenId = 1050;
3154 ssm_->GetDisplayNode(screenId);
3155 EXPECT_TRUE(logMsg.find("Permission Denied") != std::string::npos);
3156 }
3157
3158 /**
3159 * @tc.name: GetScreenProperty
3160 * @tc.desc: GetScreenProperty
3161 * @tc.type: FUNC
3162 */
3163 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty01, TestSize.Level0)
3164 {
3165 MockAccesstokenKit::MockIsSystemApp(true);
3166 ScreenId screenId = 2000;
3167 ASSERT_EQ(ssm_->GetScreenSession(screenId), nullptr);
3168 auto ret = ssm_->GetScreenProperty(screenId);
3169 ASSERT_EQ(sizeof(ret), sizeof(ScreenProperty));
3170 }
3171
3172 /**
3173 * @tc.name: GetScreenProperty
3174 * @tc.desc: !screenSession = false
3175 * @tc.type: FUNC
3176 */
3177 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty02, TestSize.Level0)
3178 {
3179 MockAccesstokenKit::MockIsSystemApp(true);
3180 ScreenId screenId = 1050;
3181 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
3182 ASSERT_NE(screenSession, nullptr);
3183 ssm_->screenSessionMap_[screenId] = screenSession;
3184 ScreenProperty property = ssm_->GetScreenProperty(screenId);
3185 ASSERT_EQ(sizeof(property), sizeof(screenSession->property_));
3186 }
3187
3188 /**
3189 * @tc.name: GetScreenProperty
3190 * @tc.desc: SystemCalling false
3191 * @tc.type: FUNC
3192 */
3193 HWTEST_F(ScreenSessionManagerTest, GetScreenProperty03, TestSize.Level1)
3194 {
3195 logMsg.clear();
3196 LOG_SetCallback(MyLogCallback);
3197 MockAccesstokenKit::MockIsSystemApp(false);
3198 MockAccesstokenKit::MockIsSACalling(false);
3199 ScreenId screenId = 1050;
3200 ssm_->GetScreenProperty(screenId);
3201 EXPECT_TRUE(logMsg.find("Permission Denied") != std::string::npos);
3202 }
3203
3204 /**
3205 * @tc.name: GetCurrentScreenPhyBounds
3206 * @tc.desc: GetCurrentScreenPhyBounds
3207 * @tc.type: FUNC
3208 */
3209 HWTEST_F(ScreenSessionManagerTest, GetCurrentScreenPhyBounds01, TestSize.Level1)
3210 {
3211 #ifdef FOLD_ABILITY_ENABLE
3212 float phyWidth = 0.0f;
3213 float phyHeight = 0.0f;
3214 bool isReset = true;
3215 ScreenId screenId = 1050;
3216 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
3217 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
3218 ASSERT_EQ(isReset, true);
3219 GTEST_SKIP();
3220 } else {
3221 ASSERT_NE(isReset, true);
3222 }
3223 if (!(ssm_->IsFoldable())) {
3224 ssm_->foldScreenController_ = new FoldScreenController(
3225 ssm_->displayInfoMutex_, ssm_->screenPowerTaskScheduler_);
3226 }
3227
3228 ASSERT_NE(ssm_->foldScreenController_, nullptr);
3229 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
3230 ASSERT_FALSE(isReset);
3231 #endif
3232 }
3233
3234 /**
3235 * @tc.name: GetCurrentScreenPhyBounds
3236 * @tc.desc: GetCurrentScreenPhyBounds
3237 * @tc.type: FUNC
3238 */
3239 HWTEST_F(ScreenSessionManagerTest, GetCurrentScreenPhyBounds02, TestSize.Level1)
3240 {
3241 #ifdef FOLD_ABILITY_ENABLE
3242 float phyWidth = 0.0f;
3243 float phyHeight = 0.0f;
3244 bool isReset = true;
3245 ScreenId screenId = 0;
3246 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
3247 auto foldController = sptr<FoldScreenController>::MakeSptr(ssm_->displayInfoMutex_,
3248 ssm_->screenPowerTaskScheduler_);
3249 ASSERT_NE(foldController, nullptr);
3250 DisplayPhysicalResolution physicalSize_full;
3251 physicalSize_full.foldDisplayMode_ = FoldDisplayMode::FULL;
3252 physicalSize_full.physicalWidth_ = 2048;
3253 physicalSize_full.physicalHeight_ = 2232;
3254 DisplayPhysicalResolution physicalSize_main;
3255 physicalSize_main.foldDisplayMode_ = FoldDisplayMode::MAIN;
3256 physicalSize_main.physicalWidth_ = 1008;
3257 physicalSize_main.physicalHeight_ = 2232;
3258 DisplayPhysicalResolution physicalSize_global_full;
3259 physicalSize_global_full.foldDisplayMode_ = FoldDisplayMode::GLOBAL_FULL;
3260 physicalSize_global_full.physicalWidth_ = 3184;
3261 physicalSize_global_full.physicalHeight_ = 2232;
3262 ScreenSceneConfig::displayPhysicalResolution_.emplace_back(physicalSize_full);
3263 ScreenSceneConfig::displayPhysicalResolution_.emplace_back(physicalSize_main);
3264 ScreenSceneConfig::displayPhysicalResolution_.emplace_back(physicalSize_global_full);
3265 auto foldPolicy = foldController->GetFoldScreenPolicy(DisplayDeviceType::SECONDARY_DISPLAY_DEVICE);
3266 ASSERT_NE(foldPolicy, nullptr);
3267 foldPolicy->lastDisplayMode_ = FoldDisplayMode::GLOBAL_FULL;
3268 foldController->foldScreenPolicy_ = foldPolicy;
3269 ssm_->foldScreenController_ = foldController;
3270 ssm_->GetCurrentScreenPhyBounds(phyWidth, phyHeight, isReset, screenId);
3271 auto phyBounds = ssm_->GetPhyScreenProperty(0).GetPhyBounds();
3272 float phyWidthNow = phyBounds.rect_.width_;
3273 float phyHeightNow = phyBounds.rect_.width_;
3274 int32_t screenRotationOffSet = system::GetIntParameter<int32_t>("const.fold.screen_rotation.offset", 0);
3275 if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
3276 EXPECT_EQ(phyWidth, phyWidthNow);
3277 EXPECT_EQ(phyHeight, phyHeightNow);
3278 } else if (screenRotationOffSet == 1 || screenRotationOffSet == 3) {
3279 EXPECT_EQ(phyHeight, phyHeightNow);
3280 EXPECT_EQ(phyWidth, phyWidthNow);
3281 } else {
3282 EXPECT_EQ(phyWidth, phyWidthNow);
3283 EXPECT_EQ(phyHeight, phyHeightNow);
3284 }
3285 #endif
3286 }
3287
3288 /**
3289 * @tc.name: PhyMirrorConnectWakeupScreen
3290 * @tc.desc: PhyMirrorConnectWakeupScreen test
3291 * @tc.type: FUNC
3292 */
3293 HWTEST_F(ScreenSessionManagerTest, PhyMirrorConnectWakeupScreen, TestSize.Level1)
3294 {
3295 #ifdef WM_MULTI_SCREEN_ENABLE
3296 ASSERT_NE(ssm_, nullptr);
3297 ssm_->PhyMirrorConnectWakeupScreen();
3298 ScreenSceneConfig::stringConfig_["externalScreenDefaultMode"] = "mirror";
3299 ssm_->PhyMirrorConnectWakeupScreen();
3300 #endif
3301 }
3302
3303 /**
3304 * @tc.name: GetIsCurrentInUseById01
3305 * @tc.desc: GetIsCurrentInUseById01
3306 * @tc.type: FUNC
3307 */
3308 HWTEST_F(ScreenSessionManagerTest, GetIsCurrentInUseById01, Function | SmallTest | Level3)
3309 {
3310 ScreenSessionManager* ssm = new ScreenSessionManager();
3311 ASSERT_NE(ssm, nullptr);
3312 ScreenId screenId = 50;
3313 auto res = ssm->GetIsCurrentInUseById(screenId);
3314 ASSERT_EQ(false, res);
3315 }
3316
3317 /**
3318 * @tc.name: GetIsCurrentInUseById02
3319 * @tc.desc: GetIsCurrentInUseById02
3320 * @tc.type: FUNC
3321 */
3322 HWTEST_F(ScreenSessionManagerTest, GetIsCurrentInUseById02, Function | SmallTest | Level3)
3323 {
3324 ScreenSessionManager* ssm = new ScreenSessionManager();
3325 ASSERT_NE(ssm, nullptr);
3326 ScreenId screenId = 50;
3327 sptr<ScreenSession> screenSession = new ScreenSession();
3328 ASSERT_NE(nullptr, screenSession);
3329 screenSession->SetIsCurrentInUse(false);
3330 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3331 auto res = ssm->GetIsCurrentInUseById(screenId);
3332 ASSERT_EQ(false, res);
3333 ssm->screenSessionMap_.erase(50);
3334 }
3335
3336 /**
3337 * @tc.name: GetIsCurrentInUseById03
3338 * @tc.desc: GetIsCurrentInUseById03
3339 * @tc.type: FUNC
3340 */
3341 HWTEST_F(ScreenSessionManagerTest, GetIsCurrentInUseById03, Function | SmallTest | Level3)
3342 {
3343 ScreenSessionManager* ssm = new ScreenSessionManager();
3344 ASSERT_NE(ssm, nullptr);
3345 ScreenId screenId = 50;
3346 sptr<ScreenSession> screenSession = new ScreenSession();
3347 ASSERT_NE(nullptr, screenSession);
3348 screenSession->SetIsCurrentInUse(true);
3349 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3350 auto res = ssm->GetIsCurrentInUseById(screenId);
3351 ASSERT_EQ(true, res);
3352 ssm->screenSessionMap_.erase(50);
3353 }
3354
3355 /**
3356 * @tc.name: ReportHandleScreenEvent01
3357 * @tc.desc: ReportHandleScreenEvent01
3358 * @tc.type: FUNC
3359 */
3360 HWTEST_F(ScreenSessionManagerTest, ReportHandleScreenEvent01, Function | SmallTest | Level3)
3361 {
3362 ScreenSessionManager* ssm = new ScreenSessionManager();
3363 ASSERT_NE(ssm, nullptr);
3364 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
3365 ScreenCombination screenCombination = ScreenCombination::SCREEN_MIRROR;
3366 ssm->ReportHandleScreenEvent(screenEvent, screenCombination);
3367 }
3368
3369 /**
3370 * @tc.name: ReportHandleScreenEvent02
3371 * @tc.desc: ReportHandleScreenEvent02
3372 * @tc.type: FUNC
3373 */
3374 HWTEST_F(ScreenSessionManagerTest, ReportHandleScreenEvent02, Function | SmallTest | Level3)
3375 {
3376 ScreenSessionManager* ssm = new ScreenSessionManager();
3377 ASSERT_NE(ssm, nullptr);
3378 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
3379 ScreenCombination screenCombination = ScreenCombination::SCREEN_EXTEND;
3380 ssm->ReportHandleScreenEvent(screenEvent, screenCombination);
3381 }
3382
3383 /**
3384 * @tc.name: RegisterSettingWireCastObserver01
3385 * @tc.desc: RegisterSettingWireCastObserver01
3386 * @tc.type: FUNC
3387 */
3388 HWTEST_F(ScreenSessionManagerTest, RegisterSettingWireCastObserver01, Function | SmallTest | Level3)
3389 {
3390 ScreenSessionManager* ssm = new ScreenSessionManager();
3391 ASSERT_NE(ssm, nullptr);
3392 sptr<ScreenSession> screenSession = nullptr;
3393 ASSERT_EQ(screenSession, nullptr);
3394 ssm->RegisterSettingWireCastObserver(screenSession);
3395 }
3396
3397 /**
3398 * @tc.name: UnregisterSettingWireCastObserver01
3399 * @tc.desc: UnregisterSettingWireCastObserver01
3400 * @tc.type: FUNC
3401 */
3402 HWTEST_F(ScreenSessionManagerTest, UnregisterSettingWireCastObserver01, Function | SmallTest | Level3)
3403 {
3404 ScreenSessionManager* ssm = new ScreenSessionManager();
3405 ASSERT_NE(ssm, nullptr);
3406 ScreenId screenId = 50;
3407 sptr<ScreenSession> screenSession = nullptr;
3408 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3409 ASSERT_EQ(screenSession, nullptr);
3410 ssm->UnregisterSettingWireCastObserver(screenId);
3411 ssm->screenSessionMap_.erase(50);
3412 }
3413
3414 /**
3415 * @tc.name: UnregisterSettingWireCastObserver02
3416 * @tc.desc: UnregisterSettingWireCastObserver02
3417 * @tc.type: FUNC
3418 */
3419 HWTEST_F(ScreenSessionManagerTest, UnregisterSettingWireCastObserver02, Function | SmallTest | Level3)
3420 {
3421 ScreenSessionManager* ssm = new ScreenSessionManager();
3422 ASSERT_NE(ssm, nullptr);
3423 ScreenId screenId = 50;
3424 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3425 ASSERT_NE(nullptr, screenSession);
3426 screenSession->SetScreenType(ScreenType::REAL);
3427 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
3428 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3429 ssm->UnregisterSettingWireCastObserver(60);
3430 ssm->screenSessionMap_.erase(50);
3431 }
3432
3433 /**
3434 * @tc.name: UnregisterSettingWireCastObserver03
3435 * @tc.desc: UnregisterSettingWireCastObserver03
3436 * @tc.type: FUNC
3437 */
3438 HWTEST_F(ScreenSessionManagerTest, UnregisterSettingWireCastObserver03, Function | SmallTest | Level3)
3439 {
3440 ScreenSessionManager* ssm = new ScreenSessionManager();
3441 ASSERT_NE(ssm, nullptr);
3442 ScreenId screenId = 50;
3443 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3444 ASSERT_NE(nullptr, screenSession);
3445 screenSession->SetScreenType(ScreenType::REAL);
3446 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
3447 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3448 ssm->UnregisterSettingWireCastObserver(50);
3449 ssm->screenSessionMap_.erase(50);
3450 }
3451
3452 /**
3453 * @tc.name: IsPhysicalScreenAndInUse01
3454 * @tc.desc: IsPhysicalScreenAndInUse01
3455 * @tc.type: FUNC
3456 */
3457 HWTEST_F(ScreenSessionManagerTest, IsPhysicalScreenAndInUse01, Function | SmallTest | Level3)
3458 {
3459 ScreenSessionManager* ssm = new ScreenSessionManager();
3460 ASSERT_NE(ssm, nullptr);
3461 ScreenId screenId = 50;
3462 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3463 ASSERT_NE(nullptr, screenSession);
3464 screenSession->SetScreenType(ScreenType::REAL);
3465 screenSession->SetIsCurrentInUse(true);
3466 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3467 auto res = ssm->IsPhysicalScreenAndInUse(screenSession);
3468 ASSERT_EQ(true, res);
3469 ssm->screenSessionMap_.erase(50);
3470 }
3471
3472 /**
3473 * @tc.name: IsPhysicalScreenAndInUse02
3474 * @tc.desc: IsPhysicalScreenAndInUse02
3475 * @tc.type: FUNC
3476 */
3477 HWTEST_F(ScreenSessionManagerTest, IsPhysicalScreenAndInUse02, Function | SmallTest | Level3)
3478 {
3479 ScreenSessionManager* ssm = new ScreenSessionManager();
3480 ASSERT_NE(ssm, nullptr);
3481 ScreenId screenId = 50;
3482 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3483 ASSERT_NE(nullptr, screenSession);
3484 screenSession->SetScreenType(ScreenType::VIRTUAL);
3485 screenSession->SetIsCurrentInUse(true);
3486 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3487 auto res = ssm->IsPhysicalScreenAndInUse(screenSession);
3488 ASSERT_EQ(false, res);
3489 ssm->screenSessionMap_.erase(50);
3490 }
3491
3492 /**
3493 * @tc.name: IsPhysicalScreenAndInUse03
3494 * @tc.desc: IsPhysicalScreenAndInUse03
3495 * @tc.type: FUNC
3496 */
3497 HWTEST_F(ScreenSessionManagerTest, IsPhysicalScreenAndInUse03, Function | SmallTest | Level3)
3498 {
3499 ScreenSessionManager* ssm = new ScreenSessionManager();
3500 ASSERT_NE(ssm, nullptr);
3501 ScreenId screenId = 50;
3502 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3503 ASSERT_NE(nullptr, screenSession);
3504 screenSession->SetScreenType(ScreenType::REAL);
3505 screenSession->SetIsCurrentInUse(false);
3506 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3507 auto res = ssm->IsPhysicalScreenAndInUse(screenSession);
3508 ASSERT_EQ(false, res);
3509 ssm->screenSessionMap_.erase(50);
3510 }
3511
3512 /**
3513 * @tc.name: IsPhysicalScreenAndInUse04
3514 * @tc.desc: IsPhysicalScreenAndInUse04
3515 * @tc.type: FUNC
3516 */
3517 HWTEST_F(ScreenSessionManagerTest, IsPhysicalScreenAndInUse04, Function | SmallTest | Level3)
3518 {
3519 ScreenSessionManager* ssm = new ScreenSessionManager();
3520 ASSERT_NE(ssm, nullptr);
3521 ScreenId screenId = 50;
3522 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
3523 ASSERT_NE(nullptr, screenSession);
3524 screenSession->SetScreenType(ScreenType::VIRTUAL);
3525 screenSession->SetIsCurrentInUse(false);
3526 ssm->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
3527 auto res = ssm->IsPhysicalScreenAndInUse(screenSession);
3528 ASSERT_EQ(false, res);
3529 ssm->screenSessionMap_.erase(50);
3530 }
3531
3532 /**
3533 * @tc.name: IsPhysicalScreenAndInUse05
3534 * @tc.desc: IsPhysicalScreenAndInUse05
3535 * @tc.type: FUNC
3536 */
3537 HWTEST_F(ScreenSessionManagerTest, IsPhysicalScreenAndInUse05, Function | SmallTest | Level3)
3538 {
3539 ScreenSessionManager* ssm = new ScreenSessionManager();
3540 ASSERT_NE(ssm, nullptr);
3541 sptr<ScreenSession> screenSession = nullptr;
3542 ASSERT_EQ(screenSession, nullptr);
3543 auto res = ssm->IsPhysicalScreenAndInUse(screenSession);
3544 ASSERT_EQ(false, res);
3545 }
3546
3547 /**
3548 * @tc.name: HookDisplayInfoByUid01
3549 * @tc.desc: HookDisplayInfo by uid01
3550 * @tc.type: FUNC
3551 */
3552 HWTEST_F(ScreenSessionManagerTest, HookDisplayInfoByUid01, Function | SmallTest | Level3)
3553 {
3554 ScreenSessionManager* ssm = new ScreenSessionManager();
3555 ASSERT_NE(ssm, nullptr);
3556 sptr<DisplayInfo> displayInfo = nullptr;
3557 ASSERT_EQ(displayInfo, nullptr);
3558 sptr<ScreenSession> screenSession = nullptr;
3559 ASSERT_EQ(screenSession, nullptr);
3560 auto res = ssm->HookDisplayInfoByUid(displayInfo, screenSession);
3561 ASSERT_EQ(res, nullptr);
3562 }
3563
3564 /**
3565 * @tc.name: GetDisplayInfoById01
3566 * @tc.desc: GetDisplayInfoById01
3567 * @tc.type: FUNC
3568 */
3569 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoById01, Function | SmallTest | Level3)
3570 {
3571 ScreenSessionManager* ssm = new ScreenSessionManager();
3572 ASSERT_NE(ssm, nullptr);
3573 DisplayId id = 50;
3574 sptr<ScreenSession> screenSession = nullptr;
3575 ASSERT_EQ(screenSession, nullptr);
3576 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3577 auto res = ssm->GetDisplayInfoById(id);
3578 ASSERT_EQ(res, nullptr);
3579 ssm->screenSessionMap_.erase(50);
3580 }
3581
3582 /**
3583 * @tc.name: GetVisibleAreaDisplayInfoById01
3584 * @tc.desc: GetVisibleAreaDisplayInfoById01
3585 * @tc.type: FUNC
3586 */
3587 HWTEST_F(ScreenSessionManagerTest, GetVisibleAreaDisplayInfoById01, Function | SmallTest | Level3)
3588 {
3589 ScreenSessionManager* ssm = new ScreenSessionManager();
3590 ASSERT_NE(ssm, nullptr);
3591 DisplayId id = 50;
3592 sptr<ScreenSession> screenSession = nullptr;
3593 ASSERT_EQ(screenSession, nullptr);
3594 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3595 auto res = ssm->GetVisibleAreaDisplayInfoById(id);
3596 ASSERT_EQ(res, nullptr);
3597 ssm->screenSessionMap_.erase(50);
3598 }
3599
3600 /**
3601 * @tc.name: GetVisibleAreaDisplayInfoById02
3602 * @tc.desc: GetVisibleAreaDisplayInfoById02
3603 * @tc.type: FUNC
3604 */
3605 HWTEST_F(ScreenSessionManagerTest, GetVisibleAreaDisplayInfoById02, Function | SmallTest | Level3)
3606 {
3607 ScreenSessionManager* ssm = new ScreenSessionManager();
3608 ASSERT_NE(ssm, nullptr);
3609 DisplayId id = 50;
3610 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3611 ASSERT_NE(nullptr, screenSession);
3612 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3613 auto res = ssm->GetVisibleAreaDisplayInfoById(id);
3614 ASSERT_NE(res, nullptr);
3615 ssm->screenSessionMap_.erase(50);
3616 }
3617
3618 /**
3619 * @tc.name: GetDisplayInfoByScreen01
3620 * @tc.desc: GetDisplayInfoByScreen01
3621 * @tc.type: FUNC
3622 */
3623 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoByScreen01, Function | SmallTest | Level3)
3624 {
3625 ScreenSessionManager* ssm = new ScreenSessionManager();
3626 ASSERT_NE(ssm, nullptr);
3627 ScreenId id = 50;
3628 sptr<ScreenSession> screenSession = nullptr;
3629 ASSERT_EQ(screenSession, nullptr);
3630 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3631 auto res = ssm->GetDisplayInfoByScreen(id);
3632 ASSERT_EQ(res, nullptr);
3633 ssm->screenSessionMap_.erase(50);
3634 }
3635
3636 /**
3637 * @tc.name: GetDisplayInfoByScreen02
3638 * @tc.desc: GetDisplayInfoByScreen02
3639 * @tc.type: FUNC
3640 */
3641 HWTEST_F(ScreenSessionManagerTest, GetDisplayInfoByScreen02, Function | SmallTest | Level3)
3642 {
3643 ScreenSessionManager* ssm = new ScreenSessionManager();
3644 ASSERT_NE(ssm, nullptr);
3645 ScreenId id = 50;
3646 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3647 ASSERT_NE(nullptr, screenSession);
3648 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3649 auto res = ssm->GetDisplayInfoByScreen(id);
3650 ASSERT_NE(res, nullptr);
3651 ssm->screenSessionMap_.erase(50);
3652 }
3653
3654 /**
3655 * @tc.name: GetFakeDisplayId01
3656 * @tc.desc: GetFakeDisplayId01
3657 * @tc.type: FUNC
3658 */
3659 HWTEST_F(ScreenSessionManagerTest, GetFakeDisplayId01, Function | SmallTest | Level3)
3660 {
3661 ScreenSessionManager* ssm = new ScreenSessionManager();
3662 ASSERT_NE(ssm, nullptr);
3663 ScreenId id = 50;
3664 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3665 ASSERT_NE(nullptr, screenSession);
3666 sptr<ScreenSession> fakeScreenSession = nullptr;
3667 ASSERT_EQ(fakeScreenSession, nullptr);
3668 screenSession->SetFakeScreenSession(fakeScreenSession);
3669 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3670 auto res = ssm->GetFakeDisplayId(screenSession);
3671 ASSERT_EQ(res, DISPLAY_ID_INVALID);
3672 ssm->screenSessionMap_.erase(50);
3673 }
3674
3675 /**
3676 * @tc.name: GetFakeDisplayId02
3677 * @tc.desc: GetFakeDisplayId02
3678 * @tc.type: FUNC
3679 */
3680 HWTEST_F(ScreenSessionManagerTest, GetFakeDisplayId02, Function | SmallTest | Level3)
3681 {
3682 ScreenSessionManager* ssm = new ScreenSessionManager();
3683 ASSERT_NE(ssm, nullptr);
3684 ScreenId id = 50;
3685 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3686 ASSERT_NE(nullptr, screenSession);
3687 sptr<ScreenSession> fakeScreenSession = new ScreenSession(999, ScreenProperty(), 0);
3688 ASSERT_NE(nullptr, fakeScreenSession);
3689 screenSession->SetFakeScreenSession(fakeScreenSession);
3690 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3691 auto res = ssm->GetFakeDisplayId(screenSession);
3692 ASSERT_NE(res, DISPLAY_ID_INVALID);
3693 ssm->screenSessionMap_.erase(50);
3694 }
3695
3696 /**
3697 * @tc.name: CalculateXYPosition01
3698 * @tc.desc: CalculateXYPosition01
3699 * @tc.type: FUNC
3700 */
3701 HWTEST_F(ScreenSessionManagerTest, CalculateXYPosition01, Function | SmallTest | Level3)
3702 {
3703 ScreenSessionManager* ssm = new ScreenSessionManager();
3704 ASSERT_NE(ssm, nullptr);
3705 ScreenId id = 50;
3706 sptr<ScreenSession> screenSession = nullptr;
3707 ASSERT_EQ(screenSession, nullptr);
3708 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3709 ssm->CalculateXYPosition(screenSession);
3710 ssm->screenSessionMap_.erase(50);
3711 }
3712
3713 /**
3714 * @tc.name: CalculateXYPosition02
3715 * @tc.desc: CalculateXYPosition02
3716 * @tc.type: FUNC
3717 */
3718 HWTEST_F(ScreenSessionManagerTest, CalculateXYPosition02, Function | SmallTest | Level3)
3719 {
3720 ScreenSessionManager* ssm = new ScreenSessionManager();
3721 ASSERT_NE(ssm, nullptr);
3722 ScreenId id = 50;
3723 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3724 ASSERT_NE(nullptr, screenSession);
3725 screenSession->SetScreenType(ScreenType::REAL);
3726 screenSession->SetIsInternal(true);
3727 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3728 ssm->CalculateXYPosition(screenSession);
3729 ssm->screenSessionMap_.erase(50);
3730 }
3731
3732 /**
3733 * @tc.name: CalculateXYPosition03
3734 * @tc.desc: CalculateXYPosition03
3735 * @tc.type: FUNC
3736 */
3737 HWTEST_F(ScreenSessionManagerTest, CalculateXYPosition03, Function | SmallTest | Level3)
3738 {
3739 ScreenSessionManager* ssm = new ScreenSessionManager();
3740 ASSERT_NE(ssm, nullptr);
3741 ScreenId id = 50;
3742 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3743 ASSERT_NE(nullptr, screenSession);
3744 screenSession->SetScreenType(ScreenType::REAL);
3745 screenSession->SetIsInternal(false);
3746 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3747 ScreenId internalId = 51;
3748 sptr<ScreenSession> internalSession = new ScreenSession(internalId, ScreenProperty(), 0);
3749 ASSERT_NE(nullptr, internalSession);
3750 internalSession->SetScreenType(ScreenType::REAL);
3751 internalSession->SetIsInternal(true);
3752 ssm->screenSessionMap_.insert(std::make_pair(internalId, internalSession));
3753 ssm->CalculateXYPosition(screenSession);
3754 ssm->screenSessionMap_.erase(50);
3755 ssm->screenSessionMap_.erase(51);
3756 }
3757
3758 /**
3759 * @tc.name: NotifyAndPublishEvent01
3760 * @tc.desc: NotifyAndPublishEvent01
3761 * @tc.type: FUNC
3762 */
3763 HWTEST_F(ScreenSessionManagerTest, NotifyAndPublishEvent01, Function | SmallTest | Level3)
3764 {
3765 ScreenSessionManager* ssm = new ScreenSessionManager();
3766 ASSERT_NE(ssm, nullptr);
3767 sptr<DisplayInfo> displayInfo = new DisplayInfo();
3768 ASSERT_NE(nullptr, displayInfo);
3769 ScreenId id = 50;
3770 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3771 ASSERT_NE(nullptr, screenSession);
3772 ssm->NotifyAndPublishEvent(displayInfo, id, screenSession);
3773 }
3774
3775 /**
3776 * @tc.name: NotifyAndPublishEvent02
3777 * @tc.desc: NotifyAndPublishEvent02
3778 * @tc.type: FUNC
3779 */
3780 HWTEST_F(ScreenSessionManagerTest, NotifyAndPublishEvent02, Function | SmallTest | Level3)
3781 {
3782 ScreenSessionManager* ssm = new ScreenSessionManager();
3783 ASSERT_NE(ssm, nullptr);
3784 sptr<DisplayInfo> displayInfo = new DisplayInfo();
3785 ASSERT_NE(nullptr, displayInfo);
3786 ScreenId id = 50;
3787 sptr<ScreenSession> screenSession = nullptr;
3788 ASSERT_EQ(nullptr, screenSession);
3789 ssm->NotifyAndPublishEvent(displayInfo, id, screenSession);
3790 }
3791
3792 /**
3793 * @tc.name: NotifyAndPublishEvent03
3794 * @tc.desc: NotifyAndPublishEvent03
3795 * @tc.type: FUNC
3796 */
3797 HWTEST_F(ScreenSessionManagerTest, NotifyAndPublishEvent03, Function | SmallTest | Level3)
3798 {
3799 ScreenSessionManager* ssm = new ScreenSessionManager();
3800 ASSERT_NE(ssm, nullptr);
3801 sptr<DisplayInfo> displayInfo = nullptr;
3802 ASSERT_EQ(nullptr, displayInfo);
3803 ScreenId id = 50;
3804 sptr<ScreenSession> screenSession = nullptr;
3805 ASSERT_EQ(nullptr, screenSession);
3806 ssm->NotifyAndPublishEvent(displayInfo, id, screenSession);
3807 }
3808
3809 /**
3810 * @tc.name: UpdateScreenDirectionInfo01
3811 * @tc.desc: UpdateScreenDirectionInfo01
3812 * @tc.type: FUNC
3813 */
3814 HWTEST_F(ScreenSessionManagerTest, UpdateScreenDirectionInfo01, Function | SmallTest | Level3)
3815 {
3816 ScreenSessionManager* ssm = new ScreenSessionManager();
3817 ASSERT_NE(ssm, nullptr);
3818 ScreenId id = 50;
3819 sptr<ScreenSession> screenSession = nullptr;
3820 ASSERT_EQ(screenSession, nullptr);
3821 ScreenDirectionInfo directionInfo;
3822 directionInfo.screenRotation_ = 0.0f;
3823 directionInfo.rotation_ = 0.0f;
3824 directionInfo.phyRotation_ = 0.0f;
3825 RRect bounds;
3826 bounds.rect_.width_ = 1344;
3827 bounds.rect_.height_ = 2772;
3828 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_END;
3829 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3830 ssm->UpdateScreenDirectionInfo(id, directionInfo, screenPropertyChangeType, bounds);
3831 ssm->screenSessionMap_.erase(50);
3832 }
3833
3834 /**
3835 * @tc.name: UpdateScreenDirectionInfo02
3836 * @tc.desc: UpdateScreenDirectionInfo02
3837 * @tc.type: FUNC
3838 */
3839 HWTEST_F(ScreenSessionManagerTest, UpdateScreenDirectionInfo02, Function | SmallTest | Level3)
3840 {
3841 ScreenSessionManager* ssm = new ScreenSessionManager();
3842 ASSERT_NE(ssm, nullptr);
3843 ScreenId id = 50;
3844 sptr<ScreenSession> screenSession = nullptr;
3845 ASSERT_EQ(screenSession, nullptr);
3846 ScreenDirectionInfo directionInfo;
3847 directionInfo.screenRotation_ = 0.0f;
3848 directionInfo.rotation_ = 0.0f;
3849 directionInfo.phyRotation_ = 0.0f;
3850 RRect bounds;
3851 bounds.rect_.width_ = 1344;
3852 bounds.rect_.height_ = 2772;
3853 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::UNSPECIFIED;
3854 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3855 ssm->UpdateScreenDirectionInfo(id, directionInfo, screenPropertyChangeType, bounds);
3856 ssm->screenSessionMap_.erase(50);
3857 }
3858
3859 /**
3860 * @tc.name: UpdateScreenDirectionInfo03
3861 * @tc.desc: UpdateScreenDirectionInfo03
3862 * @tc.type: FUNC
3863 */
3864 HWTEST_F(ScreenSessionManagerTest, UpdateScreenDirectionInfo03, Function | SmallTest | Level3)
3865 {
3866 ScreenSessionManager* ssm = new ScreenSessionManager();
3867 ASSERT_NE(ssm, nullptr);
3868 ScreenId id = 50;
3869 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3870 ASSERT_NE(nullptr, screenSession);
3871 ScreenDirectionInfo directionInfo;
3872 directionInfo.screenRotation_ = 0.0f;
3873 directionInfo.rotation_ = 0.0f;
3874 directionInfo.phyRotation_ = 0.0f;
3875 RRect bounds;
3876 bounds.rect_.width_ = 1344;
3877 bounds.rect_.height_ = 2772;
3878 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::UNSPECIFIED;
3879 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3880 ssm->UpdateScreenDirectionInfo(id, directionInfo, screenPropertyChangeType, bounds);
3881 ssm->screenSessionMap_.erase(50);
3882 }
3883
3884 /**
3885 * @tc.name: GetRSDisplayNodeByScreenId01
3886 * @tc.desc: GetRSDisplayNodeByScreenId01
3887 * @tc.type: FUNC
3888 */
3889 HWTEST_F(ScreenSessionManagerTest, GetRSDisplayNodeByScreenId01, Function | SmallTest | Level3)
3890 {
3891 ScreenSessionManager* ssm = new ScreenSessionManager();
3892 ASSERT_NE(ssm, nullptr);
3893 ScreenId id = 50;
3894 sptr<ScreenSession> screenSession = nullptr;
3895 ASSERT_EQ(screenSession, nullptr);
3896 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3897 auto res = ssm->GetRSDisplayNodeByScreenId(id);
3898 ASSERT_EQ(res, nullptr);
3899 ssm->screenSessionMap_.erase(50);
3900 }
3901
3902 /**
3903 * @tc.name: GetRSDisplayNodeByScreenId02
3904 * @tc.desc: GetRSDisplayNodeByScreenId02
3905 * @tc.type: FUNC
3906 */
3907 HWTEST_F(ScreenSessionManagerTest, GetRSDisplayNodeByScreenId02, Function | SmallTest | Level3)
3908 {
3909 ScreenSessionManager* ssm = new ScreenSessionManager();
3910 ASSERT_NE(ssm, nullptr);
3911 ScreenId id = 50;
3912 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3913 ASSERT_NE(nullptr, screenSession);
3914 screenSession->ReleaseDisplayNode();
3915 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3916 auto res = ssm->GetRSDisplayNodeByScreenId(id);
3917 ASSERT_EQ(res, nullptr);
3918 ssm->screenSessionMap_.erase(50);
3919 }
3920
3921 /**
3922 * @tc.name: OnScreenConnect
3923 * @tc.desc: OnScreenConnect
3924 * @tc.type: FUNC
3925 */
3926 HWTEST_F(ScreenSessionManagerTest, OnScreenConnect, Function | SmallTest | Level3)
3927 {
3928 ScreenSessionManager* ssm = new ScreenSessionManager();
3929 ASSERT_NE(ssm, nullptr);
3930 sptr<ScreenInfo> screenInfo = nullptr;
3931 ASSERT_EQ(nullptr, screenInfo);
3932 ssm->OnScreenConnect(screenInfo);
3933 }
3934
3935 /**
3936 * @tc.name: TransferPropertyChangeTypeToString05
3937 * @tc.desc: TransferPropertyChangeTypeToString05
3938 * @tc.type: FUNC
3939 */
3940 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString05, Function | SmallTest | Level3)
3941 {
3942 ScreenSessionManager* ssm = new ScreenSessionManager();
3943 ASSERT_NE(ssm, nullptr);
3944 std::string screenType = ssm->TransferPropertyChangeTypeToString(
3945 ScreenPropertyChangeType::ROTATION_UPDATE_PROPERTY_ONLY_NOT_NOTIFY);
3946 std::string expectType = "ROTATION_UPDATE_PROPERTY_ONLY_NOT_NOTIFY";
3947 ASSERT_EQ(screenType, expectType);
3948 }
3949
3950 /**
3951 * @tc.name: TransferPropertyChangeTypeToString06
3952 * @tc.desc: TransferPropertyChangeTypeToString06
3953 * @tc.type: FUNC
3954 */
3955 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString06, Function | SmallTest | Level3)
3956 {
3957 ScreenSessionManager* ssm = new ScreenSessionManager();
3958 ASSERT_NE(ssm, nullptr);
3959 std::string screenType = ssm->TransferPropertyChangeTypeToString(
3960 ScreenPropertyChangeType::UNDEFINED);
3961 std::string expectType = "UNDEFINED";
3962 ASSERT_EQ(screenType, expectType);
3963 }
3964
3965 /**
3966 * @tc.name: UpdateDisplayScaleState01
3967 * @tc.desc: UpdateDisplayScaleState01
3968 * @tc.type: FUNC
3969 */
3970 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayScaleState01, Function | SmallTest | Level3)
3971 {
3972 ScreenSessionManager* ssm = new ScreenSessionManager();
3973 ASSERT_NE(ssm, nullptr);
3974 ScreenId id = 50;
3975 sptr<ScreenSession> screenSession = nullptr;
3976 ASSERT_EQ(screenSession, nullptr);
3977 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
3978 ssm->UpdateDisplayScaleState(id);
3979 ssm->screenSessionMap_.erase(50);
3980 }
3981
3982 /**
3983 * @tc.name: UpdateDisplayScaleState02
3984 * @tc.desc: UpdateDisplayScaleState02
3985 * @tc.type: FUNC
3986 */
3987 HWTEST_F(ScreenSessionManagerTest, UpdateDisplayScaleState02, Function | SmallTest | Level3)
3988 {
3989 ScreenSessionManager* ssm = new ScreenSessionManager();
3990 ASSERT_NE(ssm, nullptr);
3991 ScreenId id = 50;
3992 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
3993 ASSERT_NE(nullptr, screenSession);
3994 float scaleX = 3.0f;
3995 float scaleY = 3.0f;
3996 float pivotX = 3.0f;
3997 float pivotY = 3.0f;
3998 float translateX = 0.0f;
3999 float translateY = 0.0f;
4000 screenSession->SetScreenScale(scaleX, scaleY, pivotX, pivotY, translateX, translateY);
4001 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4002 ssm->UpdateDisplayScaleState(id);
4003 ssm->screenSessionMap_.erase(50);
4004 }
4005
4006 /**
4007 * @tc.name: SetDisplayScaleInner
4008 * @tc.desc: SetDisplayScaleInner
4009 * @tc.type: FUNC
4010 */
4011 HWTEST_F(ScreenSessionManagerTest, SetDisplayScaleInner, Function | SmallTest | Level3)
4012 {
4013 ScreenSessionManager* ssm = new ScreenSessionManager();
4014 ASSERT_NE(ssm, nullptr);
4015 ScreenId id = 50;
4016 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4017 ASSERT_NE(nullptr, screenSession);
4018 float scaleX = 0.5f;
4019 float scaleY = 3.0f;
4020 float pivotX = 0.5f;
4021 float pivotY = -0.5f;
4022 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4023 ssm->SetDisplayScaleInner(id, scaleX, scaleY, pivotX, pivotY);
4024 ssm->screenSessionMap_.erase(50);
4025 }
4026
4027 /**
4028 * @tc.name: CalcDisplayNodeTranslateOnFoldableRotation01
4029 * @tc.desc: CalcDisplayNodeTranslateOnFoldableRotation01
4030 * @tc.type: FUNC
4031 */
4032 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnFoldableRotation01, Function | SmallTest | Level3)
4033 {
4034 ScreenSessionManager* ssm = new ScreenSessionManager();
4035 ASSERT_NE(ssm, nullptr);
4036 ScreenId id = 50;
4037 sptr<ScreenSession> screenSession = nullptr;
4038 ASSERT_EQ(nullptr, screenSession);
4039 float scaleX = 0.5f;
4040 float scaleY = 3.0f;
4041 float pivotX = 0.5f;
4042 float pivotY = -0.5f;
4043 float translateX = 0.0f;
4044 float translateY = 0.0f;
4045 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4046 ssm->CalcDisplayNodeTranslateOnFoldableRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4047 translateY);
4048 ssm->screenSessionMap_.erase(50);
4049 }
4050
4051 /**
4052 * @tc.name: CalcDisplayNodeTranslateOnFoldableRotation02
4053 * @tc.desc: CalcDisplayNodeTranslateOnFoldableRotation02
4054 * @tc.type: FUNC
4055 */
4056 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnFoldableRotation02, Function | SmallTest | Level3)
4057 {
4058 ScreenSessionManager* ssm = new ScreenSessionManager();
4059 ASSERT_NE(ssm, nullptr);
4060 ScreenId id = 50;
4061 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4062 ASSERT_NE(nullptr, screenSession);
4063 screenSession->SetRotation(Rotation::ROTATION_0);
4064 float scaleX = 0.5f;
4065 float scaleY = 3.0f;
4066 float pivotX = 0.5f;
4067 float pivotY = 0.5f;
4068 float translateX = 0.0f;
4069 float translateY = 0.0f;
4070 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4071 ssm->CalcDisplayNodeTranslateOnFoldableRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4072 translateY);
4073 ssm->screenSessionMap_.erase(50);
4074 }
4075
4076 /**
4077 * @tc.name: CalcDisplayNodeTranslateOnFoldableRotation03
4078 * @tc.desc: CalcDisplayNodeTranslateOnFoldableRotation03
4079 * @tc.type: FUNC
4080 */
4081 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnFoldableRotation03, Function | SmallTest | Level3)
4082 {
4083 ScreenSessionManager* ssm = new ScreenSessionManager();
4084 ASSERT_NE(ssm, nullptr);
4085 ScreenId id = 50;
4086 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4087 ASSERT_NE(nullptr, screenSession);
4088 screenSession->SetRotation(Rotation::ROTATION_90);
4089 float scaleX = 0.5f;
4090 float scaleY = 3.0f;
4091 float pivotX = 0.5f;
4092 float pivotY = 0.5f;
4093 float translateX = 0.0f;
4094 float translateY = 0.0f;
4095 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4096 ssm->CalcDisplayNodeTranslateOnFoldableRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4097 translateY);
4098 ssm->screenSessionMap_.erase(50);
4099 }
4100
4101 /**
4102 * @tc.name: CalcDisplayNodeTranslateOnFoldableRotation04
4103 * @tc.desc: CalcDisplayNodeTranslateOnFoldableRotation04
4104 * @tc.type: FUNC
4105 */
4106 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnFoldableRotation04, Function | SmallTest | Level3)
4107 {
4108 ScreenSessionManager* ssm = new ScreenSessionManager();
4109 ASSERT_NE(ssm, nullptr);
4110 ScreenId id = 50;
4111 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4112 ASSERT_NE(nullptr, screenSession);
4113 screenSession->SetRotation(Rotation::ROTATION_180);
4114 float scaleX = 0.5f;
4115 float scaleY = 3.0f;
4116 float pivotX = 0.5f;
4117 float pivotY = 0.5f;
4118 float translateX = 0.0f;
4119 float translateY = 0.0f;
4120 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4121 ssm->CalcDisplayNodeTranslateOnFoldableRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4122 translateY);
4123 ssm->screenSessionMap_.erase(50);
4124 }
4125
4126 /**
4127 * @tc.name: CalcDisplayNodeTranslateOnFoldableRotation05
4128 * @tc.desc: CalcDisplayNodeTranslateOnFoldableRotation05
4129 * @tc.type: FUNC
4130 */
4131 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnFoldableRotation05, Function | SmallTest | Level3)
4132 {
4133 ScreenSessionManager* ssm = new ScreenSessionManager();
4134 ASSERT_NE(ssm, nullptr);
4135 ScreenId id = 50;
4136 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4137 ASSERT_NE(nullptr, screenSession);
4138 screenSession->SetRotation(Rotation::ROTATION_270);
4139 float scaleX = 0.5f;
4140 float scaleY = 3.0f;
4141 float pivotX = 0.5f;
4142 float pivotY = 0.5f;
4143 float translateX = 0.0f;
4144 float translateY = 0.0f;
4145 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4146 ssm->CalcDisplayNodeTranslateOnFoldableRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4147 translateY);
4148 ssm->screenSessionMap_.erase(50);
4149 }
4150
4151 /**
4152 * @tc.name: CalcDisplayNodeTranslateOnPocketFoldRotation01
4153 * @tc.desc: CalcDisplayNodeTranslateOnPocketFoldRotation01
4154 * @tc.type: FUNC
4155 */
4156 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnPocketFoldRotation01, Function | SmallTest | Level3)
4157 {
4158 ScreenSessionManager* ssm = new ScreenSessionManager();
4159 ASSERT_NE(ssm, nullptr);
4160 ScreenId id = 50;
4161 sptr<ScreenSession> screenSession = nullptr;
4162 ASSERT_EQ(nullptr, screenSession);
4163 float scaleX = 0.5f;
4164 float scaleY = 3.0f;
4165 float pivotX = 0.5f;
4166 float pivotY = -0.5f;
4167 float translateX = 0.0f;
4168 float translateY = 0.0f;
4169 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4170 ssm->CalcDisplayNodeTranslateOnPocketFoldRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4171 translateY);
4172 ssm->screenSessionMap_.erase(50);
4173 }
4174
4175 /**
4176 * @tc.name: CalcDisplayNodeTranslateOnPocketFoldRotation02
4177 * @tc.desc: CalcDisplayNodeTranslateOnPocketFoldRotation02
4178 * @tc.type: FUNC
4179 */
4180 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnPocketFoldRotation02, Function | SmallTest | Level3)
4181 {
4182 ScreenSessionManager* ssm = new ScreenSessionManager();
4183 ASSERT_NE(ssm, nullptr);
4184 ScreenId id = 50;
4185 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4186 ASSERT_NE(nullptr, screenSession);
4187 screenSession->SetRotation(Rotation::ROTATION_0);
4188 float scaleX = 0.5f;
4189 float scaleY = 3.0f;
4190 float pivotX = 0.5f;
4191 float pivotY = 0.5f;
4192 float translateX = 0.0f;
4193 float translateY = 0.0f;
4194 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4195 ssm->CalcDisplayNodeTranslateOnPocketFoldRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4196 translateY);
4197 ssm->screenSessionMap_.erase(50);
4198 }
4199
4200 /**
4201 * @tc.name: CalcDisplayNodeTranslateOnPocketFoldRotation03
4202 * @tc.desc: CalcDisplayNodeTranslateOnPocketFoldRotation03
4203 * @tc.type: FUNC
4204 */
4205 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnPocketFoldRotation03, Function | SmallTest | Level3)
4206 {
4207 ScreenSessionManager* ssm = new ScreenSessionManager();
4208 ASSERT_NE(ssm, nullptr);
4209 ScreenId id = 50;
4210 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4211 ASSERT_NE(nullptr, screenSession);
4212 screenSession->SetRotation(Rotation::ROTATION_90);
4213 float scaleX = 0.5f;
4214 float scaleY = 3.0f;
4215 float pivotX = 0.5f;
4216 float pivotY = 0.5f;
4217 float translateX = 0.0f;
4218 float translateY = 0.0f;
4219 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4220 ssm->CalcDisplayNodeTranslateOnPocketFoldRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4221 translateY);
4222 ssm->screenSessionMap_.erase(50);
4223 }
4224
4225 /**
4226 * @tc.name: CalcDisplayNodeTranslateOnPocketFoldRotation04
4227 * @tc.desc: CalcDisplayNodeTranslateOnPocketFoldRotation04
4228 * @tc.type: FUNC
4229 */
4230 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnPocketFoldRotation04, Function | SmallTest | Level3)
4231 {
4232 ScreenSessionManager* ssm = new ScreenSessionManager();
4233 ASSERT_NE(ssm, nullptr);
4234 ScreenId id = 50;
4235 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4236 ASSERT_NE(nullptr, screenSession);
4237 screenSession->SetRotation(Rotation::ROTATION_180);
4238 float scaleX = 0.5f;
4239 float scaleY = 3.0f;
4240 float pivotX = 0.5f;
4241 float pivotY = 0.5f;
4242 float translateX = 0.0f;
4243 float translateY = 0.0f;
4244 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4245 ssm->CalcDisplayNodeTranslateOnPocketFoldRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4246 translateY);
4247 ssm->screenSessionMap_.erase(50);
4248 }
4249
4250 /**
4251 * @tc.name: CalcDisplayNodeTranslateOnPocketFoldRotation05
4252 * @tc.desc: CalcDisplayNodeTranslateOnPocketFoldRotation05
4253 * @tc.type: FUNC
4254 */
4255 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnPocketFoldRotation05, Function | SmallTest | Level3)
4256 {
4257 ScreenSessionManager* ssm = new ScreenSessionManager();
4258 ASSERT_NE(ssm, nullptr);
4259 ScreenId id = 50;
4260 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4261 ASSERT_NE(nullptr, screenSession);
4262 screenSession->SetRotation(Rotation::ROTATION_270);
4263 float scaleX = 0.5f;
4264 float scaleY = 3.0f;
4265 float pivotX = 0.5f;
4266 float pivotY = 0.5f;
4267 float translateX = 0.0f;
4268 float translateY = 0.0f;
4269 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4270 ssm->CalcDisplayNodeTranslateOnPocketFoldRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4271 translateY);
4272 ssm->screenSessionMap_.erase(50);
4273 }
4274
4275 /**
4276 * @tc.name: CalcDisplayNodeTranslateOnRotation01
4277 * @tc.desc: CalcDisplayNodeTranslateOnRotation01
4278 * @tc.type: FUNC
4279 */
4280 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnRotation01, Function | SmallTest | Level3)
4281 {
4282 ScreenSessionManager* ssm = new ScreenSessionManager();
4283 ASSERT_NE(ssm, nullptr);
4284 ScreenId id = 50;
4285 sptr<ScreenSession> screenSession = nullptr;
4286 ASSERT_EQ(nullptr, screenSession);
4287 float scaleX = 0.5f;
4288 float scaleY = 3.0f;
4289 float pivotX = 0.5f;
4290 float pivotY = -0.5f;
4291 float translateX = 0.0f;
4292 float translateY = 0.0f;
4293 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4294 ssm->CalcDisplayNodeTranslateOnRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4295 translateY);
4296 ssm->screenSessionMap_.erase(50);
4297 }
4298
4299 /**
4300 * @tc.name: CalcDisplayNodeTranslateOnRotation02
4301 * @tc.desc: CalcDisplayNodeTranslateOnRotation02
4302 * @tc.type: FUNC
4303 */
4304 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnRotation02, Function | SmallTest | Level3)
4305 {
4306 ScreenSessionManager* ssm = new ScreenSessionManager();
4307 ASSERT_NE(ssm, nullptr);
4308 ScreenId id = 50;
4309 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4310 ASSERT_NE(nullptr, screenSession);
4311 screenSession->SetRotation(Rotation::ROTATION_90);
4312 float scaleX = 0.5f;
4313 float scaleY = 3.0f;
4314 float pivotX = 0.5f;
4315 float pivotY = 0.5f;
4316 float translateX = 0.0f;
4317 float translateY = 0.0f;
4318 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4319 ssm->CalcDisplayNodeTranslateOnRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4320 translateY);
4321 ssm->screenSessionMap_.erase(50);
4322 }
4323
4324 /**
4325 * @tc.name: CalcDisplayNodeTranslateOnRotation03
4326 * @tc.desc: CalcDisplayNodeTranslateOnRotation03
4327 * @tc.type: FUNC
4328 */
4329 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnRotation03, Function | SmallTest | Level3)
4330 {
4331 ScreenSessionManager* ssm = new ScreenSessionManager();
4332 ASSERT_NE(ssm, nullptr);
4333 ScreenId id = 50;
4334 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4335 ASSERT_NE(nullptr, screenSession);
4336 screenSession->SetRotation(Rotation::ROTATION_180);
4337 float scaleX = 0.5f;
4338 float scaleY = 3.0f;
4339 float pivotX = 0.5f;
4340 float pivotY = 0.5f;
4341 float translateX = 0.0f;
4342 float translateY = 0.0f;
4343 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4344 ssm->CalcDisplayNodeTranslateOnRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4345 translateY);
4346 ssm->screenSessionMap_.erase(50);
4347 }
4348
4349 /**
4350 * @tc.name: CalcDisplayNodeTranslateOnRotation04
4351 * @tc.desc: CalcDisplayNodeTranslateOnRotation04
4352 * @tc.type: FUNC
4353 */
4354 HWTEST_F(ScreenSessionManagerTest, CalcDisplayNodeTranslateOnRotation04, Function | SmallTest | Level3)
4355 {
4356 ScreenSessionManager* ssm = new ScreenSessionManager();
4357 ASSERT_NE(ssm, nullptr);
4358 ScreenId id = 50;
4359 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4360 ASSERT_NE(nullptr, screenSession);
4361 screenSession->SetRotation(Rotation::ROTATION_270);
4362 float scaleX = 0.5f;
4363 float scaleY = 3.0f;
4364 float pivotX = 0.5f;
4365 float pivotY = 0.5f;
4366 float translateX = 0.0f;
4367 float translateY = 0.0f;
4368 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4369 ssm->CalcDisplayNodeTranslateOnRotation(screenSession, scaleX, scaleY, pivotX, pivotY, translateX,
4370 translateY);
4371 ssm->screenSessionMap_.erase(50);
4372 }
4373
4374 /**
4375 * @tc.name: OnScreenChange
4376 * @tc.desc: OnScreenChange
4377 * @tc.type: FUNC
4378 */
4379 HWTEST_F(ScreenSessionManagerTest, OnScreenChange, Function | SmallTest | Level3)
4380 {
4381 ScreenSessionManager* ssm = new ScreenSessionManager();
4382 ASSERT_NE(ssm, nullptr);
4383 ScreenId id = 50;
4384 sptr<ScreenSession> screenSession = nullptr;
4385 ASSERT_EQ(nullptr, screenSession);
4386 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
4387 ScreenChangeReason reason = ScreenChangeReason::HWCDEAD;
4388 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4389 ssm->OnScreenChange(id, screenEvent, reason);
4390 ssm->screenSessionMap_.erase(50);
4391 }
4392
4393 /**
4394 * @tc.name: GetCurrentInUseScreenNumber01
4395 * @tc.desc: GetCurrentInUseScreenNumber01
4396 * @tc.type: FUNC
4397 */
4398 HWTEST_F(ScreenSessionManagerTest, GetCurrentInUseScreenNumber01, Function | SmallTest | Level3)
4399 {
4400 ScreenSessionManager* ssm = new ScreenSessionManager();
4401 ASSERT_NE(ssm, nullptr);
4402 ScreenId id = 50;
4403 sptr<ScreenSession> screenSession = nullptr;
4404 ASSERT_EQ(nullptr, screenSession);
4405 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4406 auto res = ssm->GetCurrentInUseScreenNumber();
4407 ASSERT_EQ(0, res);
4408 ssm->screenSessionMap_.erase(50);
4409 }
4410
4411 /**
4412 * @tc.name: GetCurrentInUseScreenNumber02
4413 * @tc.desc: GetCurrentInUseScreenNumber02
4414 * @tc.type: FUNC
4415 */
4416 HWTEST_F(ScreenSessionManagerTest, GetCurrentInUseScreenNumber02, Function | SmallTest | Level3)
4417 {
4418 ScreenSessionManager* ssm = new ScreenSessionManager();
4419 ASSERT_NE(ssm, nullptr);
4420 ScreenId id = 50;
4421 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4422 ASSERT_NE(nullptr, screenSession);
4423 screenSession->SetScreenType(ScreenType::REAL);
4424 screenSession->SetIsCurrentInUse(false);
4425 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4426 auto res = ssm->GetCurrentInUseScreenNumber();
4427 ASSERT_EQ(0, res);
4428 ssm->screenSessionMap_.erase(50);
4429 }
4430
4431 /**
4432 * @tc.name: GetCurrentInUseScreenNumber03
4433 * @tc.desc: GetCurrentInUseScreenNumber03
4434 * @tc.type: FUNC
4435 */
4436 HWTEST_F(ScreenSessionManagerTest, GetCurrentInUseScreenNumber03, Function | SmallTest | Level3)
4437 {
4438 ScreenSessionManager* ssm = new ScreenSessionManager();
4439 ASSERT_NE(ssm, nullptr);
4440 ScreenId id = 50;
4441 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4442 ASSERT_NE(nullptr, screenSession);
4443 screenSession->SetScreenType(ScreenType::REAL);
4444 screenSession->SetIsCurrentInUse(true);
4445 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4446 auto res = ssm->GetCurrentInUseScreenNumber();
4447 ASSERT_EQ(1, res);
4448 ssm->screenSessionMap_.erase(50);
4449 }
4450
4451 /**
4452 * @tc.name: GetCurrentInUseScreenNumber04
4453 * @tc.desc: GetCurrentInUseScreenNumber04
4454 * @tc.type: FUNC
4455 */
4456 HWTEST_F(ScreenSessionManagerTest, GetCurrentInUseScreenNumber04, Function | SmallTest | Level3)
4457 {
4458 ScreenSessionManager* ssm = new ScreenSessionManager();
4459 ASSERT_NE(ssm, nullptr);
4460 ScreenId id = 50;
4461 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4462 ASSERT_NE(nullptr, screenSession);
4463 screenSession->SetScreenType(ScreenType::UNDEFINED);
4464 screenSession->SetIsCurrentInUse(true);
4465 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4466 auto res = ssm->GetCurrentInUseScreenNumber();
4467 ASSERT_EQ(0, res);
4468 ssm->screenSessionMap_.erase(50);
4469 }
4470
4471 /**
4472 * @tc.name: SetCastPrivacyFromSettingData01
4473 * @tc.desc: SetCastPrivacyFromSettingData01
4474 * @tc.type: FUNC
4475 */
4476 HWTEST_F(ScreenSessionManagerTest, SetCastPrivacyFromSettingData01, Function | SmallTest | Level3)
4477 {
4478 ScreenSessionManager* ssm = new ScreenSessionManager();
4479 ASSERT_NE(ssm, nullptr);
4480 ScreenId id = 50;
4481 sptr<ScreenSession> screenSession = nullptr;
4482 ASSERT_EQ(nullptr, screenSession);
4483 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4484 ssm->SetCastPrivacyFromSettingData();
4485 ssm->GetAllDisplayIds();
4486 ssm->screenSessionMap_.erase(50);
4487 }
4488
4489 /**
4490 * @tc.name: CallRsSetScreenPowerStatusSyncForExtend01
4491 * @tc.desc: CallRsSetScreenPowerStatusSyncForExtend01
4492 * @tc.type: FUNC
4493 */
4494 HWTEST_F(ScreenSessionManagerTest, CallRsSetScreenPowerStatusSyncForExtend01, Function | SmallTest | Level3)
4495 {
4496 ScreenSessionManager* ssm = new ScreenSessionManager();
4497 ASSERT_NE(ssm, nullptr);
4498 ScreenId id = 50;
4499 sptr<ScreenSession> screenSession = nullptr;
4500 ASSERT_EQ(nullptr, screenSession);
4501 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4502 std::vector<ScreenId> screenIds = {50};
4503 ScreenPowerStatus status = ScreenPowerStatus::POWER_STATUS_ON;
4504 ssm->CallRsSetScreenPowerStatusSyncForExtend(screenIds, status);
4505 ssm->screenSessionMap_.erase(50);
4506 }
4507
4508 /**
4509 * @tc.name: CallRsSetScreenPowerStatusSyncForExtend02
4510 * @tc.desc: CallRsSetScreenPowerStatusSyncForExtend02
4511 * @tc.type: FUNC
4512 */
4513 HWTEST_F(ScreenSessionManagerTest, CallRsSetScreenPowerStatusSyncForExtend02, Function | SmallTest | Level3)
4514 {
4515 ScreenSessionManager* ssm = new ScreenSessionManager();
4516 ASSERT_NE(ssm, nullptr);
4517 ScreenId id = 50;
4518 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4519 ASSERT_NE(nullptr, screenSession);
4520 screenSession->SetScreenType(ScreenType::UNDEFINED);
4521 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4522 std::vector<ScreenId> screenIds = {50};
4523 ScreenPowerStatus status = ScreenPowerStatus::POWER_STATUS_ON;
4524 ssm->CallRsSetScreenPowerStatusSyncForExtend(screenIds, status);
4525 ssm->screenSessionMap_.erase(50);
4526 }
4527
4528 /**
4529 * @tc.name: CallRsSetScreenPowerStatusSyncForExtend03
4530 * @tc.desc: CallRsSetScreenPowerStatusSyncForExtend03
4531 * @tc.type: FUNC
4532 */
4533 HWTEST_F(ScreenSessionManagerTest, CallRsSetScreenPowerStatusSyncForExtend03, Function | SmallTest | Level3)
4534 {
4535 ScreenSessionManager* ssm = new ScreenSessionManager();
4536 ASSERT_NE(ssm, nullptr);
4537 ScreenId id = 50;
4538 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4539 ASSERT_NE(nullptr, screenSession);
4540 screenSession->SetScreenType(ScreenType::REAL);
4541 screenSession->SetIsInternal(true);
4542 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4543 std::vector<ScreenId> screenIds = {50};
4544 ScreenPowerStatus status = ScreenPowerStatus::POWER_STATUS_ON;
4545 ssm->CallRsSetScreenPowerStatusSyncForExtend(screenIds, status);
4546 ssm->screenSessionMap_.erase(50);
4547 }
4548
4549 /**
4550 * @tc.name: CallRsSetScreenPowerStatusSyncForExtend04
4551 * @tc.desc: CallRsSetScreenPowerStatusSyncForExtend04
4552 * @tc.type: FUNC
4553 */
4554 HWTEST_F(ScreenSessionManagerTest, CallRsSetScreenPowerStatusSyncForExtend04, Function | SmallTest | Level3)
4555 {
4556 ScreenSessionManager* ssm = new ScreenSessionManager();
4557 ASSERT_NE(ssm, nullptr);
4558 ScreenId id = 50;
4559 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4560 ASSERT_NE(nullptr, screenSession);
4561 screenSession->SetScreenType(ScreenType::REAL);
4562 screenSession->SetIsInternal(false);
4563 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4564 std::vector<ScreenId> screenIds = {50};
4565 ScreenPowerStatus status = ScreenPowerStatus::POWER_STATUS_ON;
4566 ssm->CallRsSetScreenPowerStatusSyncForExtend(screenIds, status);
4567 ssm->screenSessionMap_.erase(50);
4568 }
4569
4570 /**
4571 * @tc.name: SetExtendPixelRatio01
4572 * @tc.desc: SetExtendPixelRatio01
4573 * @tc.type: FUNC
4574 */
4575 HWTEST_F(ScreenSessionManagerTest, SetExtendPixelRatio01, Function | SmallTest | Level3)
4576 {
4577 ScreenSessionManager* ssm = new ScreenSessionManager();
4578 ASSERT_NE(ssm, nullptr);
4579 float dpi = 1.0f;
4580 ssm->SetExtendPixelRatio(dpi);
4581 ScreenId id = 50;
4582 sptr<ScreenSession> screenSession = nullptr;
4583 ASSERT_EQ(nullptr, screenSession);
4584 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4585 ssm->SetExtendPixelRatio(dpi);
4586 ssm->screenSessionMap_.erase(50);
4587 }
4588
4589 /**
4590 * @tc.name: SetExtendPixelRatio02
4591 * @tc.desc: SetExtendPixelRatio02
4592 * @tc.type: FUNC
4593 */
4594 HWTEST_F(ScreenSessionManagerTest, SetExtendPixelRatio02, Function | SmallTest | Level3)
4595 {
4596 ScreenSessionManager* ssm = new ScreenSessionManager();
4597 ASSERT_NE(ssm, nullptr);
4598 float dpi = 1.0f;
4599 ScreenId id = 50;
4600 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4601 ASSERT_NE(nullptr, screenSession);
4602 screenSession->SetScreenType(ScreenType::REAL);
4603 screenSession->SetIsInternal(false);
4604 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4605 ssm->SetExtendPixelRatio(dpi);
4606 ssm->screenSessionMap_.erase(50);
4607 }
4608
4609 /**
4610 * @tc.name: SetExtendPixelRatio03
4611 * @tc.desc: SetExtendPixelRatio03
4612 * @tc.type: FUNC
4613 */
4614 HWTEST_F(ScreenSessionManagerTest, SetExtendPixelRatio03, Function | SmallTest | Level3)
4615 {
4616 ScreenSessionManager* ssm = new ScreenSessionManager();
4617 ASSERT_NE(ssm, nullptr);
4618 float dpi = 1.0f;
4619 ScreenId id = 50;
4620 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4621 ASSERT_NE(nullptr, screenSession);
4622 screenSession->SetScreenType(ScreenType::REAL);
4623 screenSession->SetIsInternal(true);
4624 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4625 ssm->SetExtendPixelRatio(dpi);
4626 ssm->screenSessionMap_.erase(50);
4627 }
4628
4629 /**
4630 * @tc.name: SetExtendPixelRatio04
4631 * @tc.desc: SetExtendPixelRatio04
4632 * @tc.type: FUNC
4633 */
4634 HWTEST_F(ScreenSessionManagerTest, SetExtendPixelRatio04, Function | SmallTest | Level3)
4635 {
4636 ScreenSessionManager* ssm = new ScreenSessionManager();
4637 ASSERT_NE(ssm, nullptr);
4638 float dpi = 1.0f;
4639 ScreenId id = 50;
4640 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4641 ASSERT_NE(nullptr, screenSession);
4642 screenSession->SetScreenType(ScreenType::UNDEFINED);
4643 screenSession->SetIsInternal(true);
4644 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4645 ssm->SetExtendPixelRatio(dpi);
4646 ssm->screenSessionMap_.erase(50);
4647 }
4648
4649 /**
4650 * @tc.name: SetRotation01
4651 * @tc.desc: SetRotation01
4652 * @tc.type: FUNC
4653 */
4654 HWTEST_F(ScreenSessionManagerTest, SetRotation01, Function | SmallTest | Level3)
4655 {
4656 ScreenSessionManager* ssm = new ScreenSessionManager();
4657 ASSERT_NE(ssm, nullptr);
4658 ScreenId id = 50;
4659 sptr<ScreenSession> screenSession = nullptr;
4660 ASSERT_EQ(nullptr, screenSession);
4661 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4662 Rotation rotationAfter = Rotation::ROTATION_0;
4663 bool isFromWindow = true;
4664 auto res = ssm->SetRotation(id, rotationAfter, isFromWindow);
4665 ASSERT_EQ(false, res);
4666 ssm->screenSessionMap_.erase(50);
4667 }
4668
4669 /**
4670 * @tc.name: SetRotation02
4671 * @tc.desc: SetRotation02
4672 * @tc.type: FUNC
4673 */
4674 HWTEST_F(ScreenSessionManagerTest, SetRotation02, Function | SmallTest | Level3)
4675 {
4676 ScreenSessionManager* ssm = new ScreenSessionManager();
4677 ASSERT_NE(ssm, nullptr);
4678 ScreenId id = 50;
4679 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4680 ASSERT_NE(nullptr, screenSession);
4681 screenSession->SetRotation(Rotation::ROTATION_90);
4682 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4683 Rotation rotationAfter = Rotation::ROTATION_0;
4684 bool isFromWindow = true;
4685 auto res = ssm->SetRotation(id, rotationAfter, isFromWindow);
4686 ASSERT_EQ(true, res);
4687 ssm->screenSessionMap_.erase(50);
4688 }
4689
4690 /**
4691 * @tc.name: OnMakeExpand01
4692 * @tc.desc: OnMakeExpand01
4693 * @tc.type: FUNC
4694 */
4695 HWTEST_F(ScreenSessionManagerTest, OnMakeExpand01, Function | SmallTest | Level3)
4696 {
4697 ScreenSessionManager* ssm = new ScreenSessionManager();
4698 ASSERT_NE(ssm, nullptr);
4699 ScreenId id = 0;
4700 sptr<ScreenSession> screenSession = nullptr;
4701 ASSERT_EQ(nullptr, screenSession);
4702 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4703 std::vector<ScreenId> screenId = {1001, 1002};
4704 std::vector<Point> startPoint(1);
4705 auto res = ssm->OnMakeExpand(screenId, startPoint);
4706 ASSERT_EQ(false, res);
4707 ssm->screenSessionMap_.erase(0);
4708 }
4709
4710 /**
4711 * @tc.name: OnMakeExpand02
4712 * @tc.desc: OnMakeExpand02
4713 * @tc.type: FUNC
4714 */
4715 HWTEST_F(ScreenSessionManagerTest, OnMakeExpand02, Function | SmallTest | Level3)
4716 {
4717 ScreenSessionManager* ssm = new ScreenSessionManager();
4718 ASSERT_NE(ssm, nullptr);
4719 ScreenId id = 0;
4720 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4721 ASSERT_NE(nullptr, screenSession);
4722 screenSession->groupSmsId_ = 50;
4723 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
4724 ScreenId rsId = 1002;
4725 std::string name = "ok";
4726 sptr<ScreenSessionGroup> groupSession = new ScreenSessionGroup(50, rsId, name, combination);
4727 ASSERT_NE(nullptr, groupSession);
4728 ssm->smsScreenGroupMap_.insert(std::make_pair(50, groupSession));
4729 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4730 std::vector<ScreenId> screenId = {1001, 1002};
4731 std::vector<Point> startPoint(1);
4732 auto res = ssm->OnMakeExpand(screenId, startPoint);
4733 ASSERT_EQ(true, res);
4734 ssm->screenSessionMap_.erase(0);
4735 ssm->smsScreenGroupMap_.erase(50);
4736 }
4737
4738 /**
4739 * @tc.name: IsExtendMode01
4740 * @tc.desc: IsExtendMode01
4741 * @tc.type: FUNC
4742 */
4743 HWTEST_F(ScreenSessionManagerTest, IsExtendMode01, Function | SmallTest | Level3)
4744 {
4745 ScreenSessionManager* ssm = new ScreenSessionManager();
4746 ASSERT_NE(ssm, nullptr);
4747 ScreenId id = 50;
4748 sptr<ScreenSession> screenSession = nullptr;
4749 ASSERT_EQ(nullptr, screenSession);
4750 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4751 ssm->IsExtendMode();
4752 ssm->screenSessionMap_.erase(50);
4753 }
4754
4755 /**
4756 * @tc.name: IsExtendMode02
4757 * @tc.desc: IsExtendMode02
4758 * @tc.type: FUNC
4759 */
4760 HWTEST_F(ScreenSessionManagerTest, IsExtendMode02, Function | SmallTest | Level3)
4761 {
4762 ScreenSessionManager* ssm = new ScreenSessionManager();
4763 ASSERT_NE(ssm, nullptr);
4764 ScreenId id = 50;
4765 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4766 ASSERT_NE(nullptr, screenSession);
4767 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
4768 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4769 ssm->IsExtendMode();
4770 screenSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
4771 ssm->IsExtendMode();
4772 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
4773 ssm->IsExtendMode();
4774 ssm->screenSessionMap_.erase(50);
4775 }
4776
4777 /**
4778 * @tc.name: UpdateCameraBackSelfie01
4779 * @tc.desc: UpdateCameraBackSelfie01
4780 * @tc.type: FUNC
4781 */
4782 HWTEST_F(ScreenSessionManagerTest, UpdateCameraBackSelfie01, Function | SmallTest | Level3)
4783 {
4784 ScreenSessionManager* ssm = new ScreenSessionManager();
4785 ASSERT_NE(ssm, nullptr);
4786 ScreenId id = 0;
4787 sptr<ScreenSession> screenSession = nullptr;
4788 ASSERT_EQ(nullptr, screenSession);
4789 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4790 bool isCameraBackSelfie = true;
4791 ssm->UpdateCameraBackSelfie(isCameraBackSelfie);
4792 ssm->UpdateCameraBackSelfie(true);
4793 ssm->screenSessionMap_.erase(0);
4794 }
4795
4796 /**
4797 * @tc.name: UpdateCameraBackSelfie02
4798 * @tc.desc: UpdateCameraBackSelfie02
4799 * @tc.type: FUNC
4800 */
4801 HWTEST_F(ScreenSessionManagerTest, UpdateCameraBackSelfie02, Function | SmallTest | Level3)
4802 {
4803 ScreenSessionManager* ssm = new ScreenSessionManager();
4804 ASSERT_NE(ssm, nullptr);
4805 ScreenId id = 0;
4806 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4807 ASSERT_NE(nullptr, screenSession);
4808 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4809 bool isCameraBackSelfie = true;
4810 ssm->UpdateCameraBackSelfie(isCameraBackSelfie);
4811 ssm->UpdateCameraBackSelfie(false);
4812 ssm->screenSessionMap_.erase(0);
4813 }
4814
4815 /**
4816 * @tc.name: HasCastEngineOrPhyMirror01
4817 * @tc.desc: HasCastEngineOrPhyMirror01
4818 * @tc.type: FUNC
4819 */
4820 HWTEST_F(ScreenSessionManagerTest, HasCastEngineOrPhyMirror01, Function | SmallTest | Level3)
4821 {
4822 ScreenSessionManager* ssm = new ScreenSessionManager();
4823 ASSERT_NE(ssm, nullptr);
4824 ScreenId id = 50;
4825 sptr<ScreenSession> screenSession = nullptr;
4826 ASSERT_EQ(nullptr, screenSession);
4827 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4828 std::vector<ScreenId> screenIdsToExclude = {100};
4829 ssm->HasCastEngineOrPhyMirror(screenIdsToExclude);
4830 ssm->screenSessionMap_.erase(50);
4831 }
4832
4833 /**
4834 * @tc.name: HasCastEngineOrPhyMirror02
4835 * @tc.desc: HasCastEngineOrPhyMirror02
4836 * @tc.type: FUNC
4837 */
4838 HWTEST_F(ScreenSessionManagerTest, HasCastEngineOrPhyMirror02, Function | SmallTest | Level3)
4839 {
4840 ScreenSessionManager* ssm = new ScreenSessionManager();
4841 ASSERT_NE(ssm, nullptr);
4842 ScreenId id = 50;
4843 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4844 ASSERT_NE(nullptr, screenSession);
4845 screenSession->SetScreenType(ScreenType::VIRTUAL);
4846 screenSession->SetName("CastEngine");
4847 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4848 std::vector<ScreenId> screenIdsToExclude = {100};
4849 auto res = ssm->HasCastEngineOrPhyMirror(screenIdsToExclude);
4850 ASSERT_EQ(true, res);
4851 std::vector<ScreenId> idsToExclude = {100, 50};
4852 ssm->HasCastEngineOrPhyMirror(idsToExclude);
4853 ssm->screenSessionMap_.erase(50);
4854 }
4855
4856 /**
4857 * @tc.name: HasCastEngineOrPhyMirror03
4858 * @tc.desc: HasCastEngineOrPhyMirror03
4859 * @tc.type: FUNC
4860 */
4861 HWTEST_F(ScreenSessionManagerTest, HasCastEngineOrPhyMirror03, Function | SmallTest | Level3)
4862 {
4863 ScreenSessionManager* ssm = new ScreenSessionManager();
4864 ASSERT_NE(ssm, nullptr);
4865 ScreenId id = 50;
4866 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4867 ASSERT_NE(nullptr, screenSession);
4868 screenSession->SetScreenType(ScreenType::VIRTUAL);
4869 screenSession->SetName("TestCastEngine");
4870 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4871 std::vector<ScreenId> screenIdsToExclude = {100};
4872 auto res = ssm->HasCastEngineOrPhyMirror(screenIdsToExclude);
4873 ASSERT_EQ(false, res);
4874 screenSession->SetScreenType(ScreenType::REAL);
4875 ssm->HasCastEngineOrPhyMirror(screenIdsToExclude);
4876 ssm->screenSessionMap_.erase(50);
4877 }
4878
4879 /**
4880 * @tc.name: HasCastEngineOrPhyMirror04
4881 * @tc.desc: HasCastEngineOrPhyMirror04
4882 * @tc.type: FUNC
4883 */
4884 HWTEST_F(ScreenSessionManagerTest, HasCastEngineOrPhyMirror04, Function | SmallTest | Level3)
4885 {
4886 ScreenSessionManager* ssm = new ScreenSessionManager();
4887 ASSERT_NE(ssm, nullptr);
4888 ScreenId id = 9;
4889 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
4890 ASSERT_NE(nullptr, screenSession);
4891 screenSession->SetScreenType(ScreenType::VIRTUAL);
4892 screenSession->SetName("CastEngine");
4893 ssm->screenSessionMap_.insert(std::make_pair(id, screenSession));
4894 std::vector<ScreenId> screenIdsToExclude = {100};
4895 ssm->HasCastEngineOrPhyMirror(screenIdsToExclude);
4896 ssm->screenSessionMap_.erase(9);
4897 }
4898
4899 /**
4900 * @tc.name: HotSwitch
4901 * @tc.desc: HotSwitch
4902 * @tc.type: FUNC
4903 */
4904 HWTEST_F(ScreenSessionManagerTest, HotSwitch, Function | SmallTest | Level3)
4905 {
4906 ScreenSessionManager* ssm = new ScreenSessionManager();
4907 ASSERT_NE(ssm, nullptr);
4908 int32_t newUserId = 0;
4909 int32_t newScbPid = 1;
4910 ssm->HotSwitch(newUserId, newScbPid);
4911 sptr<IScreenSessionManagerClient> client = nullptr;
4912 ssm->clientProxyMap_.insert(std::make_pair(newUserId, client));
4913 ssm->HotSwitch(newUserId, newScbPid);
4914 ssm->clientProxyMap_.insert(std::make_pair(1, client));
4915 ssm->HotSwitch(1, newScbPid);
4916 }
4917
4918 /**
4919 * @tc.name: SetVirtualScreenStatus
4920 * @tc.desc: SetVirtualScreenStatus test
4921 * @tc.type: FUNC
4922 */
4923 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenStatus, TestSize.Level1)
4924 {
4925 ASSERT_NE(ssm_, nullptr);
4926 ASSERT_FALSE(ssm_->SetVirtualScreenStatus(SCREEN_ID_INVALID, VirtualScreenStatus::VIRTUAL_SCREEN_PAUSE));
4927
4928 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
4929 VirtualScreenOption virtualOption;
4930 virtualOption.name_ = "createVirtualOption";
4931 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
4932
4933 ASSERT_TRUE(ssm_->SetVirtualScreenStatus(screenId, VirtualScreenStatus::VIRTUAL_SCREEN_PAUSE));
4934 EXPECT_EQ(DMError::DM_OK, ssm_->DestroyVirtualScreen(screenId));
4935 }
4936
4937 /**
4938 * @tc.name: SetClient
4939 * @tc.desc: SetClient
4940 * @tc.type: FUNC
4941 */
4942 HWTEST_F(ScreenSessionManagerTest, SetClient, TestSize.Level1)
4943 {
4944 ScreenSessionManager* ssm = new ScreenSessionManager();
4945 ASSERT_NE(ssm, nullptr);
4946 sptr<IScreenSessionManagerClient> client = nullptr;
4947 ssm->SetClient(client);
4948 }
4949
4950 /**
4951 * @tc.name: SwitchUser
4952 * @tc.desc: SwitchUser
4953 * @tc.type: FUNC
4954 */
4955 HWTEST_F(ScreenSessionManagerTest, SwitchUser, TestSize.Level1)
4956 {
4957 ScreenSessionManager* ssm = new ScreenSessionManager();
4958 ASSERT_NE(ssm, nullptr);
4959 ssm->SwitchUser();
4960 }
4961
4962 /**
4963 * @tc.name: SetScreenPrivacyMaskImage001
4964 * @tc.desc: SetScreenPrivacyMaskImage001
4965 * @tc.type: FUNC
4966 */
4967 HWTEST_F(ScreenSessionManagerTest, SetScreenPrivacyMaskImage001, TestSize.Level1)
4968 {
4969 ScreenId screenId = DEFAULT_SCREEN_ID;
4970 auto ret = ssm_->SetScreenPrivacyMaskImage(screenId, nullptr);
4971 ASSERT_EQ(ret, DMError::DM_OK);
4972 }
4973
4974 /**
4975 * @tc.name: ScbClientDeathCallback
4976 * @tc.desc: ScbClientDeathCallback
4977 * @tc.type: FUNC
4978 */
4979 HWTEST_F(ScreenSessionManagerTest, ScbClientDeathCallback, TestSize.Level1)
4980 {
4981 ScreenSessionManager* ssm = new ScreenSessionManager();
4982 ASSERT_NE(ssm, nullptr);
4983 int32_t deathScbPid = ssm->currentScbPId_;
4984 ssm->currentScbPId_ = -1; // INVALID_SCB_PID
4985 ssm->ScbClientDeathCallback(deathScbPid);
4986 ASSERT_EQ(ssm->clientProxy_, nullptr);
4987
4988 deathScbPid = ssm->currentScbPId_;
4989 ssm->currentScbPId_ = 0;
4990 ssm->ScbClientDeathCallback(deathScbPid);
4991 ASSERT_EQ(ssm->clientProxy_, nullptr);
4992
4993 deathScbPid = 0;
4994 ssm->currentScbPId_ = -1; // INVALID_SCB_PID
4995 ssm->ScbClientDeathCallback(deathScbPid);
4996 ASSERT_EQ(ssm->clientProxy_, nullptr);
4997
4998 deathScbPid = 0;
4999 ssm->currentScbPId_ = 0;
5000 ssm->ScbClientDeathCallback(deathScbPid);
5001 ASSERT_EQ(ssm->clientProxy_, nullptr);
5002 }
5003
5004 /**
5005 * @tc.name: NotifyClientProxyUpdateFoldDisplayMode?
5006 * @tc.desc: NotifyClientProxyUpdateFoldDisplayMode
5007 * @tc.type: FUNC
5008 */
5009 HWTEST_F(ScreenSessionManagerTest, NotifyClientProxyUpdateFoldDisplayMode, TestSize.Level1)
5010 {
5011 ScreenSessionManager* ssm = new ScreenSessionManager();
5012 ASSERT_NE(ssm, nullptr);
5013 FoldDisplayMode displayMode = FoldDisplayMode::FULL;
5014 ASSERT_EQ(ssm->clientProxy_, nullptr);
5015 ssm->NotifyClientProxyUpdateFoldDisplayMode(displayMode);
5016 }
5017
5018 /**
5019 * @tc.name: OnScreenRotationLockedChange
5020 * @tc.desc: OnScreenRotationLockedChange
5021 * @tc.type: FUNC
5022 */
5023 HWTEST_F(ScreenSessionManagerTest, OnScreenRotationLockedChange, TestSize.Level1)
5024 {
5025 ScreenSessionManager* ssm = new ScreenSessionManager();
5026 ASSERT_NE(ssm, nullptr);
5027 bool isLocked = false;
5028 ScreenId screenId = 1050;
5029 ASSERT_EQ(ssm->clientProxy_, nullptr);
5030 ssm->OnScreenRotationLockedChange(isLocked, screenId);
5031 }
5032
5033 /**
5034 * @tc.name: OnScreenOrientationChange
5035 * @tc.desc: OnScreenOrientationChange
5036 * @tc.type: FUNC
5037 */
5038 HWTEST_F(ScreenSessionManagerTest, OnScreenOrientationChange, TestSize.Level1)
5039 {
5040 ScreenSessionManager* ssm = new ScreenSessionManager();
5041 ASSERT_NE(ssm, nullptr);
5042 float screenOrientation = 75.2f;
5043 ScreenId screenId = 1050;
5044 ASSERT_EQ(ssm->clientProxy_, nullptr);
5045 ssm->OnScreenOrientationChange(screenOrientation, screenId);
5046 }
5047
5048 /**
5049 * @tc.name: NotifyDisplayModeChanged
5050 * @tc.desc: NotifyDisplayModeChanged
5051 * @tc.type: FUNC
5052 */
5053 HWTEST_F(ScreenSessionManagerTest, NotifyDisplayModeChanged, TestSize.Level1)
5054 {
5055 ScreenSessionManager* ssm = new ScreenSessionManager();
5056 ASSERT_NE(ssm, nullptr);
5057 ssm->NotifyDisplayModeChanged(FoldDisplayMode::MAIN);
5058 }
5059
5060 /**
5061 * @tc.name: SetMultiScreenMode
5062 * @tc.desc: MultiScreenMode::SCREEN_EXTEND
5063 * @tc.type: FUNC
5064 */
5065 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode01, TestSize.Level1)
5066 {
5067 #ifdef WM_MULTI_SCREEN_ENABLE
5068 ASSERT_NE(ssm_, nullptr);
5069 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5070 EXPECT_NE(displayManagerAgent, nullptr);
5071 VirtualScreenOption virtualOption;
5072 virtualOption.name_ = "createVirtualOption";
5073 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5074 MultiScreenMode screenMode = MultiScreenMode::SCREEN_EXTEND;
5075 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5076 ASSERT_NE(screenSession, nullptr);
5077 screenSession->SetScreenType(ScreenType::REAL);
5078
5079 auto ret = ssm_->SetMultiScreenMode(0, screenSession->GetRSScreenId(), screenMode);
5080 ASSERT_EQ(ret, DMError::DM_OK);
5081 ssm_->DestroyVirtualScreen(screenId);
5082 #endif
5083 }
5084
5085 /**
5086 * @tc.name: SetMultiScreenMode
5087 * @tc.desc: MultiScreenMode::SCREEN_MIRROR
5088 * @tc.type: FUNC
5089 */
5090 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode02, TestSize.Level1)
5091 {
5092 #ifdef WM_MULTI_SCREEN_ENABLE
5093 ASSERT_NE(ssm_, nullptr);
5094 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5095 EXPECT_NE(displayManagerAgent, nullptr);
5096 VirtualScreenOption virtualOption;
5097 virtualOption.name_ = "createVirtualOption";
5098 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5099 MultiScreenMode screenMode = MultiScreenMode::SCREEN_MIRROR;
5100 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5101 ASSERT_NE(screenSession, nullptr);
5102 screenSession->SetScreenType(ScreenType::REAL);
5103
5104 auto ret = ssm_->SetMultiScreenMode(0, screenSession->GetRSScreenId(), screenMode);
5105 ASSERT_EQ(ret, DMError::DM_OK);
5106 ssm_->DestroyVirtualScreen(screenId);
5107 #endif
5108 }
5109
5110 /**
5111 * @tc.name: SetMultiScreenMode
5112 * @tc.desc: operate mode error
5113 * @tc.type: FUNC
5114 */
5115 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenMode03, TestSize.Level1)
5116 {
5117 #ifdef WM_MULTI_SCREEN_ENABLE
5118 ASSERT_NE(ssm_, nullptr);
5119 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5120 EXPECT_NE(displayManagerAgent, nullptr);
5121 VirtualScreenOption virtualOption;
5122 virtualOption.name_ = "createVirtualOption";
5123 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5124 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5125 ASSERT_NE(screenSession, nullptr);
5126 screenSession->SetScreenType(ScreenType::REAL);
5127
5128 uint32_t testNum = 2;
5129 auto ret = ssm_->SetMultiScreenMode(0, screenSession->GetRSScreenId(), static_cast<MultiScreenMode>(testNum));
5130 ASSERT_EQ(ret, DMError::DM_OK);
5131 ssm_->DestroyVirtualScreen(screenId);
5132 #endif
5133 }
5134
5135 /**
5136 * @tc.name: SetMultiScreenRelativePosition
5137 * @tc.desc: ScreenSession is null
5138 * @tc.type: FUNC
5139 */
5140 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition01, TestSize.Level1)
5141 {
5142 #ifdef WM_MULTI_SCREEN_ENABLE
5143 ASSERT_NE(ssm_, nullptr);
5144 ScreenId testId = 2060;
5145 ScreenId testId1 = 3060;
5146 MultiScreenPositionOptions mainScreenOptions = {testId, 100, 100};
5147 MultiScreenPositionOptions secondScreenOption = {testId1, 100, 100};
5148 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5149 ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
5150 #endif
5151 }
5152
5153 /**
5154 * @tc.name: SetMultiScreenRelativePosition
5155 * @tc.desc: B is located on the right side of A
5156 * @tc.type: FUNC
5157 */
5158 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition02, TestSize.Level1)
5159 {
5160 #ifdef WM_MULTI_SCREEN_ENABLE
5161 ASSERT_NE(ssm_, nullptr);
5162 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5163 EXPECT_NE(displayManagerAgent, nullptr);
5164 VirtualScreenOption virtualOption;
5165 virtualOption.name_ = "createVirtualOption";
5166 virtualOption.width_ = 200;
5167 virtualOption.height_ = 100;
5168 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5169
5170 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
5171 EXPECT_NE(displayManagerAgent1, nullptr);
5172 VirtualScreenOption virtualOption1;
5173 virtualOption1.name_ = "createVirtualOption";
5174 virtualOption1.width_ = 200;
5175 virtualOption1.height_ = 100;
5176 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
5177
5178 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
5179 MultiScreenPositionOptions secondScreenOption = {screenId1, 200, 50};
5180 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5181 ASSERT_EQ(ret, DMError::DM_OK);
5182
5183 ssm_->DestroyVirtualScreen(screenId);
5184 ssm_->DestroyVirtualScreen(screenId1);
5185 #endif
5186 }
5187
5188 /**
5189 * @tc.name: SetMultiScreenRelativePosition
5190 * @tc.desc: B is located below A
5191 * @tc.type: FUNC
5192 */
5193 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition03, TestSize.Level1)
5194 {
5195 #ifdef WM_MULTI_SCREEN_ENABLE
5196 ASSERT_NE(ssm_, nullptr);
5197 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5198 EXPECT_NE(displayManagerAgent, nullptr);
5199 VirtualScreenOption virtualOption;
5200 virtualOption.name_ = "createVirtualOption";
5201 virtualOption.width_ = 200;
5202 virtualOption.height_ = 100;
5203 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5204
5205 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
5206 EXPECT_NE(displayManagerAgent1, nullptr);
5207 VirtualScreenOption virtualOption1;
5208 virtualOption1.name_ = "createVirtualOption";
5209 virtualOption1.width_ = 200;
5210 virtualOption1.height_ = 100;
5211 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
5212
5213 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
5214 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 100};
5215 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5216 ASSERT_EQ(ret, DMError::DM_OK);
5217
5218 ssm_->DestroyVirtualScreen(screenId);
5219 ssm_->DestroyVirtualScreen(screenId1);
5220 #endif
5221 }
5222
5223 /**
5224 * @tc.name: SetMultiScreenRelativePosition
5225 * @tc.desc: INVALID_PARAM
5226 * @tc.type: FUNC
5227 */
5228 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition04, TestSize.Level1)
5229 {
5230 #ifdef WM_MULTI_SCREEN_ENABLE
5231 ASSERT_NE(ssm_, nullptr);
5232 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5233 EXPECT_NE(displayManagerAgent, nullptr);
5234 VirtualScreenOption virtualOption;
5235 virtualOption.name_ = "createVirtualOption";
5236 virtualOption.width_ = 200;
5237 virtualOption.height_ = 100;
5238 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5239
5240 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
5241 EXPECT_NE(displayManagerAgent1, nullptr);
5242 VirtualScreenOption virtualOption1;
5243 virtualOption1.name_ = "createVirtualOption";
5244 virtualOption1.width_ = 200;
5245 virtualOption1.height_ = 100;
5246 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
5247
5248 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
5249 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 50};
5250 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5251 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
5252 ASSERT_EQ(ret, DMError::DM_OK);
5253 } else {
5254 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
5255 }
5256
5257 ssm_->DestroyVirtualScreen(screenId);
5258 ssm_->DestroyVirtualScreen(screenId1);
5259 #endif
5260 }
5261
5262 /**
5263 * @tc.name: SetMultiScreenRelativePosition
5264 * @tc.desc: INVALID_PARAM
5265 * @tc.type: FUNC
5266 */
5267 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition05, TestSize.Level1)
5268 {
5269 #ifdef WM_MULTI_SCREEN_ENABLE
5270 ASSERT_NE(ssm_, nullptr);
5271 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5272 EXPECT_NE(displayManagerAgent, nullptr);
5273 VirtualScreenOption virtualOption;
5274 virtualOption.name_ = "createVirtualOption";
5275 virtualOption.width_ = 200;
5276 virtualOption.height_ = 100;
5277 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5278
5279 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
5280 EXPECT_NE(displayManagerAgent1, nullptr);
5281 VirtualScreenOption virtualOption1;
5282 virtualOption1.name_ = "createVirtualOption";
5283 virtualOption1.width_ = 200;
5284 virtualOption1.height_ = 100;
5285 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
5286
5287 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 0};
5288 MultiScreenPositionOptions secondScreenOption = {screenId1, 200, 100};
5289 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5290 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
5291 ASSERT_EQ(ret, DMError::DM_OK);
5292 } else {
5293 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
5294 }
5295
5296 ssm_->DestroyVirtualScreen(screenId);
5297 ssm_->DestroyVirtualScreen(screenId1);
5298 #endif
5299 }
5300
5301 /**
5302 * @tc.name: SetMultiScreenRelativePosition
5303 * @tc.desc: DisplayNode is null
5304 * @tc.type: FUNC
5305 */
5306 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenRelativePosition06, TestSize.Level1)
5307 {
5308 #ifdef WM_MULTI_SCREEN_ENABLE
5309 ASSERT_NE(ssm_, nullptr);
5310 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5311 EXPECT_NE(displayManagerAgent, nullptr);
5312 VirtualScreenOption virtualOption;
5313 virtualOption.name_ = "createVirtualOption";
5314 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5315
5316 sptr<IDisplayManagerAgent> displayManagerAgent1 = new(std::nothrow) DisplayManagerAgentDefault();
5317 EXPECT_NE(displayManagerAgent1, nullptr);
5318 VirtualScreenOption virtualOption1;
5319 virtualOption1.name_ = "createVirtualOption";
5320 auto screenId1 = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
5321
5322 MultiScreenPositionOptions mainScreenOptions = {screenId, 0, 100};
5323 MultiScreenPositionOptions secondScreenOption = {screenId1, 100, 100};
5324
5325 sptr<ScreenSession> secondScreenSession = ssm_->GetScreenSession(screenId1);
5326 secondScreenSession->ReleaseDisplayNode();
5327 auto ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5328 ASSERT_EQ(ret, DMError::DM_OK);
5329
5330 sptr<ScreenSession> firstScreenSession = ssm_->GetScreenSession(screenId);
5331 firstScreenSession->ReleaseDisplayNode();
5332 ret = ssm_->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
5333
5334 ssm_->DestroyVirtualScreen(screenId);
5335 ssm_->DestroyVirtualScreen(screenId1);
5336 #endif
5337 }
5338
5339 /**
5340 * @tc.name: SetCoordinationFlag
5341 * @tc.desc: SetCoordinationFlag
5342 * @tc.type: FUNC
5343 */
5344 HWTEST_F(ScreenSessionManagerTest, SetCoordinationFlag, TestSize.Level1)
5345 {
5346 ScreenSessionManager* ssm = new ScreenSessionManager();
5347 ASSERT_NE(ssm, nullptr);
5348 ASSERT_EQ(ssm->isCoordinationFlag_, false);
5349 ssm->SetCoordinationFlag(true);
5350 ASSERT_EQ(ssm->isCoordinationFlag_, true);
5351 }
5352
5353 /**
5354 * @tc.name: GetTentMode
5355 * @tc.desc: Test get tent mode
5356 * @tc.type: FUNC
5357 */
5358 HWTEST_F(ScreenSessionManagerTest, GetTentMode, TestSize.Level1)
5359 {
5360 auto tentMode = ssm_->GetTentMode();
5361 ASSERT_EQ(tentMode, false);
5362 }
5363
5364 /**
5365 * @tc.name: OnTentModeChanged
5366 * @tc.desc: Test change tent mode
5367 * @tc.type: FUNC
5368 */
5369 HWTEST_F(ScreenSessionManagerTest, OnTentModeChanged, TestSize.Level1)
5370 {
5371 bool isTentMode = false;
5372 ssm_->OnTentModeChanged(isTentMode);
5373 ASSERT_EQ(ssm_->GetTentMode(), false);
5374 }
5375
5376 /**
5377 * @tc.name: GetScreenCapture
5378 * @tc.desc: GetScreenCapture
5379 * @tc.type: FUNC
5380 */
5381 HWTEST_F(ScreenSessionManagerTest, GetScreenCapture, TestSize.Level1)
5382 {
5383 ScreenSessionManager* ssm = new ScreenSessionManager();
5384 ASSERT_NE(ssm, nullptr);
5385 CaptureOption option;
5386 option.displayId_ = 0;
5387 DmErrorCode errCode;
5388 std::shared_ptr<Media::PixelMap> bitMap = ssm->GetScreenCapture(option, &errCode);
5389 if (errCode == DmErrorCode::DM_OK) {
5390 ASSERT_NE(bitMap, nullptr);
5391 } else {
5392 ASSERT_EQ(bitMap, nullptr);
5393 }
5394 }
5395
5396 /**
5397 * @tc.name: OnScreenCaptureNotify
5398 * @tc.desc: OnScreenCaptureNotify
5399 * @tc.type: FUNC
5400 */
5401 HWTEST_F(ScreenSessionManagerTest, OnScreenCaptureNotify, TestSize.Level1)
5402 {
5403 ScreenSessionManager* ssm = new ScreenSessionManager();
5404 ASSERT_NE(ssm, nullptr);
5405 ScreenId screenId = 0;
5406 int32_t uid = 0;
5407 std::string clientName = "test";
5408 ssm->OnScreenCaptureNotify(screenId, uid, clientName);
5409 }
5410
5411 /**
5412 * @tc.name: GetPrimaryDisplayInfo
5413 * @tc.desc: GetPrimaryDisplayInfo
5414 * @tc.type: FUNC
5415 */
5416 HWTEST_F(ScreenSessionManagerTest, GetPrimaryDisplayInfo, TestSize.Level1)
5417 {
5418 ASSERT_NE(ssm_, nullptr);
5419 ASSERT_NE(ssm_->GetPrimaryDisplayInfo(), nullptr);
5420 }
5421
5422 /*
5423 * @tc.name: TransferTypeToString
5424 * @tc.desc: TransferTypeToString
5425 * @tc.type: FUNC
5426 */
5427 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString1, TestSize.Level1)
5428 {
5429 ScreenSessionManager* ssm = new ScreenSessionManager();
5430 ASSERT_NE(ssm, nullptr);
5431 std::string screenType = ssm->TransferTypeToString(ScreenType::REAL);
5432 std::string expectType = "REAL";
5433 ASSERT_EQ(screenType, expectType);
5434 }
5435
5436 /**
5437 * @tc.name: TransferTypeToString
5438 * @tc.desc: TransferTypeToString
5439 * @tc.type: FUNC
5440 */
5441 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString2, TestSize.Level1)
5442 {
5443 ScreenSessionManager* ssm = new ScreenSessionManager();
5444 ASSERT_NE(ssm, nullptr);
5445 std::string screenType = ssm->TransferTypeToString(ScreenType::VIRTUAL);
5446 std::string expectType = "VIRTUAL";
5447 ASSERT_EQ(screenType, expectType);
5448 }
5449
5450 /**
5451 * @tc.name: TransferTypeToString
5452 * @tc.desc: TransferTypeToString
5453 * @tc.type: FUNC
5454 */
5455 HWTEST_F(ScreenSessionManagerTest, TransferTypeToString3, TestSize.Level1)
5456 {
5457 ScreenSessionManager* ssm = new ScreenSessionManager();
5458 ASSERT_NE(ssm, nullptr);
5459 std::string screenType = ssm->TransferTypeToString(ScreenType::UNDEFINED);
5460 std::string expectType = "UNDEFINED";
5461 ASSERT_EQ(screenType, expectType);
5462 }
5463
5464 /**
5465 * @tc.name: TransferPropertyChangeTypeToString
5466 * @tc.desc: TransferPropertyChangeTypeToString
5467 * @tc.type: FUNC
5468 */
5469 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString1, TestSize.Level1)
5470 {
5471 ScreenSessionManager* ssm = new ScreenSessionManager();
5472 ASSERT_NE(ssm, nullptr);
5473 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::UNSPECIFIED);
5474 std::string expectType = "UNSPECIFIED";
5475 ASSERT_EQ(screenType, expectType);
5476 }
5477
5478 /**
5479 * @tc.name: TransferPropertyChangeTypeToString
5480 * @tc.desc: TransferPropertyChangeTypeToString
5481 * @tc.type: FUNC
5482 */
5483 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString2, TestSize.Level1)
5484 {
5485 ScreenSessionManager* ssm = new ScreenSessionManager();
5486 ASSERT_NE(ssm, nullptr);
5487 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::ROTATION_BEGIN);
5488 std::string expectType = "ROTATION_BEGIN";
5489 ASSERT_EQ(screenType, expectType);
5490 }
5491
5492 /**
5493 * @tc.name: TransferPropertyChangeTypeToString
5494 * @tc.desc: TransferPropertyChangeTypeToString
5495 * @tc.type: FUNC
5496 */
5497 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString3, TestSize.Level1)
5498 {
5499 ScreenSessionManager* ssm = new ScreenSessionManager();
5500 ASSERT_NE(ssm, nullptr);
5501 std::string screenType = ssm->TransferPropertyChangeTypeToString(ScreenPropertyChangeType::ROTATION_END);
5502 std::string expectType = "ROTATION_END";
5503 ASSERT_EQ(screenType, expectType);
5504 }
5505
5506 /**
5507 * @tc.name: TransferPropertyChangeTypeToString
5508 * @tc.desc: TransferPropertyChangeTypeToString
5509 * @tc.type: FUNC
5510 */
5511 HWTEST_F(ScreenSessionManagerTest, TransferPropertyChangeTypeToString4, TestSize.Level1)
5512 {
5513 ScreenSessionManager* ssm = new ScreenSessionManager();
5514 ASSERT_NE(ssm, nullptr);
5515 std::string screenType = ssm->TransferPropertyChangeTypeToString(
5516 ScreenPropertyChangeType::ROTATION_UPDATE_PROPERTY_ONLY);
5517 std::string expectType = "ROTATION_UPDATE_PROPERTY_ONLY";
5518 ASSERT_EQ(screenType, expectType);
5519 }
5520
5521 /**
5522 * @tc.name: ConvertOffsetToCorrectRotation
5523 * @tc.desc: ConvertOffsetToCorrectRotation
5524 * @tc.type: FUNC
5525 */
5526 HWTEST_F(ScreenSessionManagerTest, ConvertOffsetToCorrectRotation, TestSize.Level1)
5527 {
5528 int32_t phyOffset = 90;
5529 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_270);
5530 phyOffset = 180;
5531 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_180);
5532 phyOffset = 270;
5533 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_90);
5534 phyOffset = 0;
5535 ASSERT_EQ(ssm_->ConvertOffsetToCorrectRotation(phyOffset), ScreenRotation::ROTATION_0);
5536 }
5537
5538 /**
5539 * @tc.name: ConfigureScreenSnapshotParams
5540 * @tc.desc: ConfigureScreenSnapshotParams
5541 * @tc.type: FUNC
5542 */
5543 HWTEST_F(ScreenSessionManagerTest, ConfigureScreenSnapshotParams, TestSize.Level1)
5544 {
5545 auto stringConfig = ScreenSceneConfig::GetStringConfig();
5546 if (g_isPcDevice) {
5547 ASSERT_EQ(stringConfig.count("screenSnapshotBundleName"), 1);
5548 } else {
5549 ASSERT_EQ(stringConfig.count("screenSnapshotBundleName"), 0);
5550 }
5551 ssm_->ConfigureScreenSnapshotParams();
5552 }
5553
5554 /**
5555 * @tc.name: RegisterRefreshRateChangeListener
5556 * @tc.desc: RegisterRefreshRateChangeListener
5557 * @tc.type: FUNC
5558 */
5559 HWTEST_F(ScreenSessionManagerTest, RegisterRefreshRateChangeListener, TestSize.Level1)
5560 {
5561 ssm_->RegisterRefreshRateChangeListener();
5562 std::string ret = ssm_->screenEventTracker_.recordInfos_.back().info;
5563 ASSERT_NE(ret, "Dms RefreshRateChange register failed.");
5564 }
5565
5566 /**
5567 * @tc.name: FreeDisplayMirrorNodeInner
5568 * @tc.desc: FreeDisplayMirrorNodeInner
5569 * @tc.type: FUNC
5570 */
5571 HWTEST_F(ScreenSessionManagerTest, FreeDisplayMirrorNodeInner, TestSize.Level1)
5572 {
5573 sptr<ScreenSession> mirrorSession = nullptr;
5574 ssm_->FreeDisplayMirrorNodeInner(mirrorSession);
5575 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5576 VirtualScreenOption virtualOption;
5577 virtualOption.name_ = "createVirtualOption";
5578 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5579 ASSERT_EQ(ssm_->GetScreenSession(screenId)->GetDisplayNode(), nullptr);
5580 }
5581
5582 /**
5583 * @tc.name: GetPowerStatus
5584 * @tc.desc: GetPowerStatus test
5585 * @tc.type: FUNC
5586 */
5587 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus01, TestSize.Level1)
5588 {
5589 ASSERT_NE(ssm_, nullptr);
5590 ScreenPowerStatus status;
5591 ssm_->GetPowerStatus(ScreenPowerState::POWER_ON, PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT, status);
5592 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_ON_ADVANCED);
5593 ssm_->GetPowerStatus(ScreenPowerState::POWER_ON, PowerStateChangeReason::POWER_BUTTON, status);
5594 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_ON);
5595 }
5596
5597 /**
5598 * @tc.name: GetPowerStatus
5599 * @tc.desc: GetPowerStatus test
5600 * @tc.type: FUNC
5601 */
5602 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus02, TestSize.Level1)
5603 {
5604 ASSERT_NE(ssm_, nullptr);
5605 ScreenPowerStatus status;
5606 ssm_->GetPowerStatus(ScreenPowerState::POWER_OFF,
5607 PowerStateChangeReason::STATE_CHANGE_REASON_PRE_BRIGHT_AUTH_FAIL_SCREEN_OFF, status);
5608 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_OFF_ADVANCED);
5609 ssm_->GetPowerStatus(ScreenPowerState::POWER_OFF, PowerStateChangeReason::POWER_BUTTON, status);
5610 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_OFF);
5611 }
5612
5613 /**
5614 * @tc.name: GetPowerStatus
5615 * @tc.desc: GetPowerStatus test
5616 * @tc.type: FUNC
5617 */
5618 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus03, TestSize.Level1)
5619 {
5620 ASSERT_NE(ssm_, nullptr);
5621 ScreenPowerStatus status;
5622 ssm_->GetPowerStatus(ScreenPowerState::POWER_SUSPEND, PowerStateChangeReason::POWER_BUTTON, status);
5623 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_SUSPEND);
5624 }
5625
5626 /**
5627 * @tc.name: GetPowerStatus
5628 * @tc.desc: GetPowerStatus test
5629 * @tc.type: FUNC
5630 */
5631 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus04, TestSize.Level1)
5632 {
5633 ASSERT_NE(ssm_, nullptr);
5634 ScreenPowerStatus status;
5635 ssm_->GetPowerStatus(ScreenPowerState::POWER_DOZE, PowerStateChangeReason::POWER_BUTTON, status);
5636 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_DOZE);
5637 }
5638
5639 /**
5640 * @tc.name: GetPowerStatus
5641 * @tc.desc: GetPowerStatus test
5642 * @tc.type: FUNC
5643 */
5644 HWTEST_F(ScreenSessionManagerTest, GetPowerStatus05, TestSize.Level1)
5645 {
5646 ASSERT_NE(ssm_, nullptr);
5647 ScreenPowerStatus status;
5648 ssm_->GetPowerStatus(ScreenPowerState::POWER_DOZE_SUSPEND, PowerStateChangeReason::POWER_BUTTON, status);
5649 ASSERT_EQ(status, ScreenPowerStatus::POWER_STATUS_DOZE_SUSPEND);
5650 }
5651
5652 /**
5653 * @tc.name: SetGotScreenOffAndWakeUpBlock
5654 * @tc.desc: SetGotScreenOffAndWakeUpBlock test
5655 * @tc.type: FUNC
5656 */
5657 HWTEST_F(ScreenSessionManagerTest, SetGotScreenOffAndWakeUpBlock, TestSize.Level1)
5658 {
5659 ASSERT_NE(ssm_, nullptr);
5660 ssm_->SetGotScreenOffAndWakeUpBlock();
5661 ASSERT_TRUE(ssm_->gotScreenOffNotify_);
5662 ssm_->needScreenOffNotify_ = true;
5663 ssm_->SetGotScreenOffAndWakeUpBlock();
5664 ASSERT_FALSE(ssm_->needScreenOffNotify_);
5665 }
5666
5667 /**
5668 * @tc.name: GetFoldStatus
5669 * @tc.desc: GetFoldStatus test
5670 * @tc.type: FUNC
5671 */
5672 HWTEST_F(ScreenSessionManagerTest, GetFoldStatus, TestSize.Level1)
5673 {
5674 ASSERT_NE(ssm_, nullptr);
5675 auto status = ssm_->GetFoldStatus();
5676 if (ssm_->IsFoldable()) {
5677 EXPECT_NE(FoldStatus::UNKNOWN, status);
5678 } else {
5679 EXPECT_EQ(FoldStatus::UNKNOWN, status);
5680 }
5681 }
5682
5683 /**
5684 * @tc.name: SetLowTemp
5685 * @tc.desc: SetLowTemp test
5686 * @tc.type: FUNC
5687 */
5688 HWTEST_F(ScreenSessionManagerTest, SetLowTemp, TestSize.Level1)
5689 {
5690 ASSERT_NE(ssm_, nullptr);
5691 ssm_->SetLowTemp(LowTempMode::LOW_TEMP_OFF);
5692 ASSERT_EQ(ssm_->lowTemp_, LowTempMode::LOW_TEMP_OFF);
5693 ssm_->SetLowTemp(LowTempMode::LOW_TEMP_ON);
5694 ASSERT_EQ(ssm_->lowTemp_, LowTempMode::LOW_TEMP_ON);
5695 }
5696
5697 /**
5698 * @tc.name: SetScreenSkipProtectedWindow
5699 * @tc.desc: SetScreenSkipProtectedWindow test
5700 * @tc.type: FUNC
5701 */
5702 HWTEST_F(ScreenSessionManagerTest, SetScreenSkipProtectedWindow, TestSize.Level1)
5703 {
5704 ASSERT_NE(ssm_, nullptr);
5705 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5706 ASSERT_NE(displayManagerAgent, nullptr);
5707 VirtualScreenOption virtualOption;
5708 virtualOption.name_ = "createVirtualOption1";
5709 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5710 if (screenId != VIRTUAL_SCREEN_ID) {
5711 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
5712 }
5713 const std::vector<ScreenId> screenIds = {screenId, 1234};
5714 bool isEnable = true;
5715 ASSERT_EQ(ssm_->SetScreenSkipProtectedWindow(screenIds, isEnable), DMError::DM_OK);
5716 isEnable = false;
5717 ASSERT_EQ(ssm_->SetScreenSkipProtectedWindow(screenIds, isEnable), DMError::DM_OK);
5718 }
5719
5720 /**
5721 * @tc.name: GetDisplayCapability
5722 * @tc.desc: GetDisplayCapability test
5723 * @tc.type: FUNC
5724 */
5725 HWTEST_F(ScreenSessionManagerTest, GetDisplayCapability, TestSize.Level1)
5726 {
5727 std::string info {""};
5728 if (ssm_ != nullptr) {
5729 EXPECT_EQ(DMError::DM_OK, ssm_->GetDisplayCapability(info));
5730 ASSERT_NE(info, "");
5731 } else {
5732 ASSERT_EQ(info, "");
5733 }
5734 }
5735
5736 /**
5737 * @tc.name: GetSecondaryDisplayCapability
5738 * @tc.desc: GetSecondaryDisplayCapability test
5739 * @tc.type: FUNC
5740 */
5741 HWTEST_F(ScreenSessionManagerTest, GetSecondaryDisplayCapability, TestSize.Level1)
5742 {
5743 std::string info {""};
5744 if (ssm_ != nullptr) {
5745 EXPECT_EQ(DMError::DM_OK, ssm_->GetSecondaryDisplayCapability(info));
5746 ASSERT_NE(info, "");
5747 } else {
5748 ASSERT_EQ(info, "");
5749 }
5750 }
5751
5752 /**
5753 * @tc.name: GetSuperFoldCapability
5754 * @tc.desc: GetSuperFoldCapability test
5755 * @tc.type: FUNC
5756 */
5757 HWTEST_F(ScreenSessionManagerTest, GetSuperFoldCapability, TestSize.Level1)
5758 {
5759 std::string info {""};
5760 if (ssm_ != nullptr) {
5761 EXPECT_EQ(DMError::DM_OK, ssm_->GetSuperFoldCapability(info));
5762 ASSERT_NE(info, "");
5763 } else {
5764 ASSERT_EQ(info, "");
5765 }
5766 }
5767
5768 /**
5769 * @tc.name: GetFoldableDeviceCapability
5770 * @tc.desc: GetFoldableDeviceCapability test
5771 * @tc.type: FUNC
5772 */
5773 HWTEST_F(ScreenSessionManagerTest, GetFoldableDeviceCapability, TestSize.Level1)
5774 {
5775 std::string info {""};
5776 if (ssm_ != nullptr) {
5777 EXPECT_EQ(DMError::DM_OK, ssm_->GetFoldableDeviceCapability(info));
5778 ASSERT_NE(info, "");
5779 } else {
5780 ASSERT_EQ(info, "");
5781 }
5782 }
5783
5784 /**
5785 * @tc.name: DoMakeUniqueScreenOld
5786 * @tc.desc: DoMakeUniqueScreenOld test
5787 * @tc.type: FUNC
5788 */
5789 HWTEST_F(ScreenSessionManagerTest, DoMakeUniqueScreenOld, TestSize.Level1)
5790 {
5791 ASSERT_NE(ssm_, nullptr);
5792 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5793 ASSERT_NE(displayManagerAgent, nullptr);
5794 VirtualScreenOption virtualOption;
5795 virtualOption.name_ = "createVirtualOption";
5796 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5797 if (screenId != VIRTUAL_SCREEN_ID) {
5798 ASSERT_TRUE(screenId != VIRTUAL_SCREEN_ID);
5799 }
5800 std::vector<ScreenId> allUniqueScreenIds = {screenId, 99};
5801 std::vector<DisplayId> displayIds = {};
5802 ssm_->DoMakeUniqueScreenOld(allUniqueScreenIds, displayIds, false);
5803 ASSERT_EQ(displayIds.size(), 1);
5804 }
5805
5806 /**
5807 * @tc.name: SetCastPrivacyFromSettingData
5808 * @tc.desc: SetCastPrivacyFromSettingData test
5809 * @tc.type: FUNC
5810 */
5811 HWTEST_F(ScreenSessionManagerTest, SetCastPrivacyFromSettingData, TestSize.Level1)
5812 {
5813 ASSERT_NE(ssm_, nullptr);
5814 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5815 ASSERT_NE(displayManagerAgent, nullptr);
5816 ScreenId id = 2;
5817 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
5818 ASSERT_NE(newSession, nullptr);
5819 ssm_->screenSessionMap_[id] = newSession;
5820 ssm_->SetCastPrivacyFromSettingData();
5821 }
5822
5823 /**
5824 * @tc.name: SetCastPrivacyToRS
5825 * @tc.desc: SetCastPrivacyToRS test
5826 * @tc.type: FUNC
5827 */
5828 HWTEST_F(ScreenSessionManagerTest, SetCastPrivacyToRS, TestSize.Level1)
5829 {
5830 ASSERT_NE(ssm_, nullptr);
5831 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5832 ASSERT_NE(displayManagerAgent, nullptr);
5833 sptr<ScreenSession> defScreen = ssm_->GetScreenSession(DEFAULT_SCREEN_ID);
5834 ASSERT_EQ(ssm_->SetCastPrivacyToRS(defScreen, true), false);
5835 VirtualScreenOption virtualOption;
5836 virtualOption.name_ = "createVirtualOption";
5837 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5838 sptr<ScreenSession> virtualSession = ssm_->GetScreenSession(virtualScreenId);
5839 ASSERT_EQ(ssm_->SetCastPrivacyToRS(virtualSession, true), false);
5840 ScreenId id = 2;
5841 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
5842 ASSERT_NE(newSession, nullptr);
5843 newSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
5844 ASSERT_EQ(ssm_->SetCastPrivacyToRS(newSession, true), true);
5845 }
5846
5847 /**
5848 * @tc.name: RegisterSettingWireCastObserver
5849 * @tc.desc: RegisterSettingWireCastObserver
5850 * @tc.type: FUNC
5851 */
5852 HWTEST_F(ScreenSessionManagerTest, RegisterSettingWireCastObserver, TestSize.Level1)
5853 {
5854 ASSERT_NE(ssm_, nullptr);
5855 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5856 ASSERT_NE(displayManagerAgent, nullptr);
5857 ScreenId id = 2;
5858 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
5859 ASSERT_NE(newSession, nullptr);
5860 ssm_->screenSessionMap_[id] = newSession;
5861 ssm_->RegisterSettingWireCastObserver(newSession);
5862 }
5863
5864 /**
5865 * @tc.name: UnregisterSettingWireCastObserver
5866 * @tc.desc: UnregisterSettingWireCastObserver
5867 * @tc.type: FUNC
5868 */
5869 HWTEST_F(ScreenSessionManagerTest, UnregisterSettingWireCastObserver, TestSize.Level1)
5870 {
5871 ASSERT_NE(ssm_, nullptr);
5872 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5873 ASSERT_NE(displayManagerAgent, nullptr);
5874 ScreenId id = 2;
5875 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
5876 ASSERT_NE(newSession, nullptr);
5877 ssm_->screenSessionMap_[id] = newSession;
5878 ssm_->UnregisterSettingWireCastObserver(id);
5879 }
5880
5881 /**
5882 * @tc.name: UpdateValidArea
5883 * @tc.desc: UpdateValidArea
5884 * @tc.type: FUNC
5885 */
5886 HWTEST_F(ScreenSessionManagerTest, UpdateValidArea, Function | SmallTest | Level3)
5887 {
5888 ASSERT_NE(ssm_, nullptr);
5889 ssm_->UpdateValidArea(2000, 800, 1000);
5890
5891 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5892 VirtualScreenOption virtualOption;
5893 virtualOption.name_ = "createVirtualOption";
5894 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5895 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5896
5897 uint32_t originValidWidth = screenSession->GetValidWidth();
5898 uint32_t originValidHeight = screenSession->GetValidHeight();
5899 ssm_->UpdateValidArea(screenId, 800, 1000);
5900 EXPECT_EQ(800, screenSession->GetValidWidth());
5901 EXPECT_EQ(1000, screenSession->GetValidHeight());
5902 ssm_->UpdateValidArea(screenId, originValidWidth, originValidHeight);
5903 ssm_->DestroyVirtualScreen(screenId);
5904 }
5905
5906 /**
5907 * @tc.name: GetIsRealScreen
5908 * @tc.desc: GetIsRealScreen
5909 * @tc.type: FUNC
5910 */
5911 HWTEST_F(ScreenSessionManagerTest, GetIsRealScreen, Function | SmallTest | Level3)
5912 {
5913 ASSERT_NE(ssm_, nullptr);
5914 EXPECT_EQ(ssm_->GetIsRealScreen(2000), false);
5915
5916 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5917 VirtualScreenOption virtualOption;
5918 virtualOption.name_ = "createVirtualOption";
5919 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5920 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5921 screenSession->SetIsRealScreen(true);
5922 ASSERT_EQ(ssm_->GetIsRealScreen(screenId), true);
5923 screenSession->SetIsRealScreen(false);
5924 ASSERT_EQ(ssm_->GetIsRealScreen(screenId), false);
5925 ssm_->DestroyVirtualScreen(screenId);
5926 }
5927
5928 /**
5929 * @tc.name: SetSystemKeyboardStatus
5930 * @tc.desc: SetSystemKeyboardStatus with true as parameter
5931 * @tc.type: FUNC
5932 */
5933 HWTEST_F(ScreenSessionManagerTest, SetSystemKeyboardStatus01, Function | SmallTest | Level3)
5934 {
5935 ASSERT_NE(ssm_, nullptr);
5936 auto ret = ssm_->SetSystemKeyboardStatus(true);
5937 ASSERT_NE(ret, DMError::DM_ERROR_UNKNOWN);
5938 }
5939
5940 /**
5941 * @tc.name: SetSystemKeyboardStatus
5942 * @tc.desc: SetSystemKeyboardStatus with false as parameter
5943 * @tc.type: FUNC
5944 */
5945 HWTEST_F(ScreenSessionManagerTest, SetSystemKeyboardStatus02, Function | SmallTest | Level3)
5946 {
5947 ASSERT_NE(ssm_, nullptr);
5948 auto ret = ssm_->SetSystemKeyboardStatus(false);
5949 ASSERT_NE(ret, DMError::DM_ERROR_UNKNOWN);
5950 }
5951
5952 /**
5953 * @tc.name: CalculateXYPosition
5954 * @tc.desc: CalculateXYPosition test
5955 * @tc.type: FUNC
5956 */
5957 HWTEST_F(ScreenSessionManagerTest, CalculateXYPosition, Function | SmallTest | Level3)
5958 {
5959 ASSERT_NE(ssm_, nullptr);
5960
5961 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
5962 VirtualScreenOption virtualOption;
5963 virtualOption.name_ = "createVirtualOption";
5964 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
5965 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
5966 ASSERT_NE(screenSession, nullptr);
5967 screenSession->SetScreenType(ScreenType::REAL);
5968 screenSession->SetIsInternal(true);
5969 int32_t x = screenSession->GetScreenProperty().GetX();
5970 EXPECT_EQ(0, x);
5971 int32_t y = screenSession->GetScreenProperty().GetY();
5972 EXPECT_EQ(0, y);
5973 ssm_->DestroyVirtualScreen(screenId);
5974 }
5975
5976 /**
5977 * @tc.name: IsSpecialApp
5978 * @tc.desc: IsSpecialApp
5979 * @tc.type: FUNC
5980 */
5981 HWTEST_F(ScreenSessionManagerTest, IsSpecialApp, Function | SmallTest | Level3)
5982 {
5983 ASSERT_NE(ssm_, nullptr);
5984
5985 auto ret = ssm_->IsSpecialApp();
5986 ASSERT_EQ(ret, false);
5987 }
5988
5989 /**
5990 * @tc.name: IsScreenCasting
5991 * @tc.desc: IsScreenCasting
5992 * @tc.type: FUNC
5993 */
5994 HWTEST_F(ScreenSessionManagerTest, IsScreenCasting, Function | SmallTest | Level3)
5995 {
5996 ASSERT_NE(ssm_, nullptr);
5997
5998 ssm_->virtualScreenCount_ = 1;
5999 auto ret = ssm_->IsScreenCasting();
6000 ASSERT_EQ(ret, true);
6001
6002 ssm_->virtualScreenCount_ = 0;
6003 ssm_->hdmiScreenCount_ = 0;
6004 ret = ssm_->IsScreenCasting();
6005 ASSERT_EQ(ret, false);
6006 }
6007
6008 /**
6009 * @tc.name: GetCameraPosition
6010 * @tc.desc: GetCameraPosition
6011 * @tc.type: FUNC
6012 */
6013 HWTEST_F(ScreenSessionManagerTest, GetCameraPosition, Function | SmallTest | Level3)
6014 {
6015 ASSERT_NE(ssm_, nullptr);
6016
6017 ssm_->cameraPosition_ = 1;
6018 auto ret = ssm_->GetCameraPosition();
6019 ASSERT_EQ(ret, 1);
6020 }
6021
6022 /**
6023 * @tc.name: GetCameraStatus
6024 * @tc.desc: GetCameraStatus
6025 * @tc.type: FUNC
6026 */
6027 HWTEST_F(ScreenSessionManagerTest, GetCameraStatus, Function | SmallTest | Level3)
6028 {
6029 ASSERT_NE(ssm_, nullptr);
6030
6031 ssm_->cameraStatus_ = 1;
6032 auto ret = ssm_->GetCameraStatus();
6033 ASSERT_EQ(ret, 1);
6034 }
6035
6036 /**
6037 * @tc.name: OnSecondaryReflexionChange
6038 * @tc.desc: OnSecondaryReflexionChange
6039 * @tc.type: FUNC
6040 */
6041 HWTEST_F(ScreenSessionManagerTest, OnSecondaryReflexionChange, Function | SmallTest | Level3)
6042 {
6043 ASSERT_NE(ssm_, nullptr);
6044 ASSERT_EQ(ssm_->clientProxy_, nullptr);
6045
6046 ssm_->OnSecondaryReflexionChange(0, false);
6047 ASSERT_EQ(ssm_->cameraStatus_, 1);
6048 }
6049
6050 /**
6051 * @tc.name: OnExtendScreenConnectStatusChange
6052 * @tc.desc: OnExtendScreenConnectStatusChange
6053 * @tc.type: FUNC
6054 */
6055 HWTEST_F(ScreenSessionManagerTest, OnExtendScreenConnectStatusChange, Function | SmallTest | Level3)
6056 {
6057 ASSERT_NE(ssm_, nullptr);
6058 ASSERT_EQ(ssm_->clientProxy_, nullptr);
6059
6060 ExtendScreenConnectStatus status = ExtendScreenConnectStatus::UNKNOWN;
6061 ssm_->OnExtendScreenConnectStatusChange(0, status);
6062 ASSERT_EQ(ssm_->cameraStatus_, 1);
6063 }
6064
6065 /**
6066 * @tc.name: OnSuperFoldStatusChange
6067 * @tc.desc: OnSuperFoldStatusChange
6068 * @tc.type: FUNC
6069 */
6070 HWTEST_F(ScreenSessionManagerTest, OnSuperFoldStatusChange, Function | SmallTest | Level3)
6071 {
6072 ASSERT_NE(ssm_, nullptr);
6073 ASSERT_EQ(ssm_->clientProxy_, nullptr);
6074
6075 SuperFoldStatus status = SuperFoldStatus::UNKNOWN;
6076 ssm_->OnSuperFoldStatusChange(0, status);
6077 ASSERT_EQ(ssm_->cameraStatus_, 1);
6078 }
6079
6080 /**
6081 * @tc.name: GetPrimaryDisplayInfo02
6082 * @tc.desc: GetPrimaryDisplayInfo02
6083 * @tc.type: FUNC
6084 */
6085 HWTEST_F(ScreenSessionManagerTest, GetPrimaryDisplayInfo02, Function | SmallTest | Level3)
6086 {
6087 ASSERT_NE(ssm_, nullptr);
6088
6089 ssm_->screenSessionMap_.insert(std::pair<ScreenId, sptr<ScreenSession>>(4, nullptr));
6090 auto ret = ssm_->GetPrimaryDisplayInfo();
6091 ASSERT_NE(ret, nullptr);
6092
6093 auto screenSession = new ScreenSession;
6094 screenSession->SetIsExtend(true);
6095 ssm_->screenSessionMap_.insert(std::pair<ScreenId, sptr<ScreenSession>>(6, screenSession));
6096 ret = ssm_->GetPrimaryDisplayInfo();
6097 ASSERT_NE(ret, nullptr);
6098
6099 screenSession->SetIsExtend(false);
6100 ret = ssm_->GetPrimaryDisplayInfo();
6101 ASSERT_NE(ret, nullptr);
6102 }
6103
6104 /**
6105 * @tc.name: AddPermissionUsedRecord
6106 * @tc.desc: AddPermissionUsedRecord
6107 * @tc.type: FUNC
6108 */
6109 HWTEST_F(ScreenSessionManagerTest, AddPermissionUsedRecord, Function | SmallTest | Level3)
6110 {
6111 ASSERT_NE(ssm_, nullptr);
6112
6113 ssm_->AddPermissionUsedRecord("ohos.permission.CUSTOM_SCREEN_CAPTURE", 0, 1);
6114 ASSERT_EQ(ssm_->cameraStatus_, 1);
6115 }
6116
6117 /**
6118 * @tc.name: SetVirtualScreenMaxRefreshRate
6119 * @tc.desc: SetVirtualScreenMaxRefreshRate
6120 * @tc.type: FUNC
6121 */
6122 HWTEST_F(ScreenSessionManagerTest, SetVirtualScreenMaxRefreshRate, Function | SmallTest | Level3)
6123 {
6124 ASSERT_NE(ssm_, nullptr);
6125
6126 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
6127 VirtualScreenOption virtualOption;
6128 virtualOption.name_ = "createVirtualOption";
6129 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
6130 uint32_t actualRefreshRate = 0;
6131
6132 auto ret = ssm_->SetVirtualScreenMaxRefreshRate(0, 120, actualRefreshRate);
6133 ASSERT_EQ(ret, DMError::DM_ERROR_INVALID_PARAM);
6134
6135 ret = ssm_->SetVirtualScreenMaxRefreshRate(screenId, 120, actualRefreshRate);
6136 ASSERT_EQ(ret, DMError::DM_OK);
6137 }
6138
6139 /**
6140 * @tc.name: OnScreenExtendChange
6141 * @tc.desc: OnScreenExtendChange
6142 * @tc.type: FUNC
6143 */
6144 HWTEST_F(ScreenSessionManagerTest, OnScreenExtendChange, Function | SmallTest | Level3)
6145 {
6146 ASSERT_NE(ssm_, nullptr);
6147
6148 ssm_->OnScreenExtendChange(0, 12);
6149 ASSERT_EQ(ssm_->cameraStatus_, 1);
6150 }
6151
6152 /**
6153 * @tc.name: GetSessionOption
6154 * @tc.desc: GetSessionOption
6155 * @tc.type: FUNC
6156 */
6157 HWTEST_F(ScreenSessionManagerTest, GetSessionOption, Function | SmallTest | Level3)
6158 {
6159 ASSERT_NE(ssm_, nullptr);
6160
6161 auto session = ssm_->GetScreenSession(0);
6162 auto ret = ssm_->GetSessionOption(session);
6163 ASSERT_EQ(ret.screenId_, 0);
6164
6165 ret = ssm_->GetSessionOption(session, 0);
6166 ASSERT_EQ(ret.screenId_, 0);
6167 }
6168
6169 /**
6170 * @tc.name: SetMultiScreenDefaultRelativePosition
6171 * @tc.desc: SetMultiScreenDefaultRelativePosition
6172 * @tc.type: FUNC
6173 */
6174 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenDefaultRelativePosition, Function | SmallTest | Level3)
6175 {
6176 ASSERT_NE(ssm_, nullptr);
6177
6178 sptr<ScreenSession> screenSession1 = new ScreenSession(50, ScreenProperty(), 0);
6179 ASSERT_NE(nullptr, screenSession1);
6180 screenSession1->SetIsRealScreen(true);
6181 screenSession1->SetIsExtend(true);
6182 ssm_->screenSessionMap_[50] = screenSession1;
6183
6184 sptr<ScreenSession> screenSession2 = new ScreenSession(51, ScreenProperty(), 0);
6185 ASSERT_NE(nullptr, screenSession2);
6186 screenSession2->SetIsRealScreen(false);
6187 ssm_->screenSessionMap_[51] = screenSession2;
6188
6189 sptr<ScreenSession> screenSession3 = new ScreenSession(52, ScreenProperty(), 0);
6190 ASSERT_NE(nullptr, screenSession3);
6191 screenSession3->SetIsRealScreen(true);
6192 screenSession3->SetIsExtend(false);
6193 ssm_->screenSessionMap_[52] = screenSession3;
6194
6195 sptr<ScreenSession> screenSession4 = nullptr;
6196 ASSERT_EQ(nullptr, screenSession4);
6197 ssm_->screenSessionMap_[53] = screenSession4;
6198
6199 ssm_->SetMultiScreenDefaultRelativePosition();
6200 ASSERT_NE(ssm_->screenSessionMap_.empty(), true);
6201 ssm_->screenSessionMap_.erase(50);
6202 ssm_->screenSessionMap_.erase(51);
6203 ssm_->screenSessionMap_.erase(52);
6204 ssm_->screenSessionMap_.erase(53);
6205 }
6206
6207 /**
6208 * @tc.name: ConvertEdidToString
6209 * @tc.desc: ConvertEdidToString
6210 * @tc.type: FUNC
6211 */
6212 HWTEST_F(ScreenSessionManagerTest, ConvertEdidToString, Function | SmallTest | Level3)
6213 {
6214 ASSERT_NE(ssm_, nullptr);
6215 struct BaseEdid edid = {
6216 .manufacturerName_ = "abc",
6217 .productCode_ = 101,
6218 .serialNumber_ = 1401,
6219 .weekOfManufactureOrModelYearFlag_ = 1,
6220 .yearOfManufactureOrModelYear_ = 2025,
6221 };
6222 std::string edidInfo = edid.manufacturerName_ + std::to_string(edid.productCode_)
6223 + std::to_string(edid.serialNumber_) + std::to_string(edid.weekOfManufactureOrModelYearFlag_)
6224 + std::to_string(edid.yearOfManufactureOrModelYear_);
6225 std::hash<std::string> hasher;
6226 std::size_t hashValue = hasher(edidInfo);
6227 std::ostringstream oss;
6228 oss << std::hex << std::uppercase << hashValue;
6229
6230 auto str = ssm_->ConvertEdidToString(edid);
6231 ASSERT_EQ(str, oss.str());
6232 }
6233
6234 /**
6235 * @tc.name: RecoverRestoredMultiScreenMode
6236 * @tc.desc: RecoverRestoredMultiScreenMode
6237 * @tc.type: FUNC
6238 */
6239 HWTEST_F(ScreenSessionManagerTest, RecoverRestoredMultiScreenMode, Function | SmallTest | Level3)
6240 {
6241 ASSERT_NE(ssm_, nullptr);
6242
6243 sptr<ScreenSession> screenSession1 = new ScreenSession(50, ScreenProperty(), 0);
6244 ASSERT_NE(nullptr, screenSession1);
6245 screenSession1->SetScreenType(ScreenType::REAL);
6246 auto ret = ssm_->RecoverRestoredMultiScreenMode(screenSession1);
6247 ASSERT_EQ(ret, false);
6248
6249 sptr<ScreenSession> screenSession2 = new ScreenSession(51, ScreenProperty(), 0);
6250 ASSERT_NE(nullptr, screenSession2);
6251 screenSession2->SetScreenType(ScreenType::VIRTUAL);
6252 ret = ssm_->RecoverRestoredMultiScreenMode(screenSession2);
6253 ASSERT_EQ(ret, true);
6254 ssm_->screenSessionMap_.erase(50);
6255 ssm_->screenSessionMap_.erase(51);
6256 }
6257
6258 /**
6259 * @tc.name: CheckMultiScreenInfoMap
6260 * @tc.desc: CheckMultiScreenInfoMap
6261 * @tc.type: FUNC
6262 */
6263 HWTEST_F(ScreenSessionManagerTest, CheckMultiScreenInfoMap, Function | SmallTest | Level3)
6264 {
6265 ASSERT_NE(ssm_, nullptr);
6266
6267 std::map<std::string, MultiScreenInfo> multiScreenInfoMap;
6268 ASSERT_EQ(multiScreenInfoMap.empty(), true);
6269 std::string serialNumber = "";
6270 auto ret = ssm_->CheckMultiScreenInfoMap(multiScreenInfoMap, serialNumber);
6271 ASSERT_EQ(ret, false);
6272
6273 MultiScreenInfo info1;
6274 std::map<std::string, MultiScreenInfo> multiScreenInfoMap1;
6275 multiScreenInfoMap1["123"] = info1;
6276 ASSERT_EQ(multiScreenInfoMap1.empty(), false);
6277 std::string serialNumber1 = "";
6278 ret = ssm_->CheckMultiScreenInfoMap(multiScreenInfoMap1, serialNumber1);
6279 ASSERT_EQ(ret, false);
6280
6281 MultiScreenInfo info2;
6282 std::map<std::string, MultiScreenInfo> multiScreenInfoMap2;
6283 multiScreenInfoMap2["123"] = info2;
6284 ASSERT_EQ(multiScreenInfoMap2.empty(), false);
6285 std::string serialNumber2 = "123";
6286 ret = ssm_->CheckMultiScreenInfoMap(multiScreenInfoMap2, serialNumber2);
6287 ASSERT_EQ(ret, true);
6288
6289 MultiScreenInfo info3;
6290 std::map<std::string, MultiScreenInfo> multiScreenInfoMap3;
6291 multiScreenInfoMap3["123"] = info3;
6292 ASSERT_EQ(multiScreenInfoMap3.empty(), false);
6293 std::string serialNumber3 = "456";
6294 ret = ssm_->CheckMultiScreenInfoMap(multiScreenInfoMap3, serialNumber3);
6295 ASSERT_EQ(ret, false);
6296 }
6297
6298 /**
6299 * @tc.name: SetMultiScreenFrameControl
6300 * @tc.desc: SetMultiScreenFrameControl
6301 * @tc.type: FUNC
6302 */
6303 HWTEST_F(ScreenSessionManagerTest, SetMultiScreenFrameControl, Function | SmallTest | Level3)
6304 {
6305 ASSERT_NE(ssm_, nullptr);
6306
6307 sptr<ScreenSession> screenSession1 = new ScreenSession(50, ScreenProperty(), 0);
6308 ASSERT_NE(nullptr, screenSession1);
6309 screenSession1->SetScreenType(ScreenType::REAL);
6310 screenSession1->SetIsCurrentInUse(true);
6311 ssm_->screenSessionMap_[50] = screenSession1;
6312
6313 sptr<ScreenSession> screenSession2 = new ScreenSession(51, ScreenProperty(), 0);
6314 ASSERT_NE(nullptr, screenSession2);
6315 screenSession2->SetScreenType(ScreenType::VIRTUAL);
6316 screenSession2->SetIsCurrentInUse(true);
6317 ssm_->screenSessionMap_[51] = screenSession2;
6318
6319 ssm_->SetMultiScreenFrameControl();
6320 ASSERT_NE(ssm_->screenSessionMap_.empty(), true);
6321
6322 sptr<ScreenSession> screenSession3 = new ScreenSession(52, ScreenProperty(), 0);
6323 ASSERT_NE(nullptr, screenSession3);
6324 screenSession3->SetScreenType(ScreenType::REAL);
6325 screenSession3->SetIsCurrentInUse(true);
6326 ssm_->screenSessionMap_[52] = screenSession3;
6327
6328 ssm_->SetMultiScreenFrameControl();
6329 ASSERT_NE(ssm_->screenSessionMap_.empty(), true);
6330 ssm_->screenSessionMap_.erase(50);
6331 ssm_->screenSessionMap_.erase(51);
6332 ssm_->screenSessionMap_.erase(52);
6333 }
6334
6335 /**
6336 * @tc.name: GetInternalScreenSession
6337 * @tc.desc: GetInternalScreenSession
6338 * @tc.type: FUNC
6339 */
6340 HWTEST_F(ScreenSessionManagerTest, GetInternalScreenSession, Function | SmallTest | Level3)
6341 {
6342 ASSERT_NE(ssm_, nullptr);
6343
6344 sptr<ScreenSession> screenSession1 = nullptr;
6345 ASSERT_EQ(nullptr, screenSession1);
6346 ssm_->screenSessionMap_[50] = screenSession1;
6347
6348 sptr<ScreenSession> screenSession2 = new ScreenSession(51, ScreenProperty(), 0);
6349 ASSERT_NE(nullptr, screenSession2);
6350 screenSession2->SetScreenType(ScreenType::REAL);
6351 screenSession2->isInternal_ = false;
6352 ssm_->screenSessionMap_[51] = screenSession2;
6353
6354 sptr<ScreenSession> screenSession3 = new ScreenSession(52, ScreenProperty(), 0);
6355 ASSERT_NE(nullptr, screenSession3);
6356 screenSession3->SetScreenType(ScreenType::VIRTUAL);
6357 screenSession3->isInternal_ = false;
6358 ssm_->screenSessionMap_[52] = screenSession3;
6359
6360 sptr<ScreenSession> screenSession4 = new ScreenSession(53, ScreenProperty(), 0);
6361 ASSERT_NE(nullptr, screenSession4);
6362 screenSession4->SetScreenType(ScreenType::VIRTUAL);
6363 screenSession4->isInternal_ = true;
6364 ssm_->screenSessionMap_[53] = screenSession4;
6365
6366 sptr<ScreenSession> screenSession5 = new ScreenSession(54, ScreenProperty(), 0);
6367 ASSERT_NE(nullptr, screenSession5);
6368 screenSession5->SetScreenType(ScreenType::REAL);
6369 screenSession5->isInternal_ = true;
6370 ssm_->screenSessionMap_[54] = screenSession5;
6371
6372 auto ret = ssm_->GetInternalScreenSession();
6373 ASSERT_NE(nullptr, ret);
6374 ssm_->screenSessionMap_.erase(50);
6375 ssm_->screenSessionMap_.erase(51);
6376 ssm_->screenSessionMap_.erase(52);
6377 ssm_->screenSessionMap_.erase(53);
6378 ssm_->screenSessionMap_.erase(54);
6379 }
6380
6381 /**
6382 * @tc.name: GetInternalAndExternalSession
6383 * @tc.desc: GetInternalAndExternalSession
6384 * @tc.type: FUNC
6385 */
6386 HWTEST_F(ScreenSessionManagerTest, GetInternalAndExternalSession, Function | SmallTest | Level3)
6387 {
6388 ASSERT_NE(ssm_, nullptr);
6389
6390 sptr<ScreenSession> screenSession1 = nullptr;
6391 ASSERT_EQ(nullptr, screenSession1);
6392 ssm_->screenSessionMap_[50] = screenSession1;
6393
6394 sptr<ScreenSession> screenSession2 = new ScreenSession(51, ScreenProperty(), 0);
6395 ASSERT_NE(nullptr, screenSession2);
6396 screenSession2->SetIsCurrentInUse(false);
6397 ssm_->screenSessionMap_[51] = screenSession2;
6398
6399 sptr<ScreenSession> screenSession3 = new ScreenSession(52, ScreenProperty(), 0);
6400 ASSERT_NE(nullptr, screenSession3);
6401 screenSession3->SetIsCurrentInUse(true);
6402 screenSession3->SetScreenType(ScreenType::VIRTUAL);
6403 ssm_->screenSessionMap_[52] = screenSession3;
6404
6405 sptr<ScreenSession> screenSession4 = new ScreenSession(53, ScreenProperty(), 0);
6406 ASSERT_NE(nullptr, screenSession4);
6407 screenSession3->SetIsCurrentInUse(true);
6408 screenSession3->SetScreenType(ScreenType::REAL);
6409 screenSession3->isInternal_ = false;
6410 ssm_->screenSessionMap_[53] = screenSession4;
6411
6412 sptr<ScreenSession> screenSession5 = new ScreenSession(54, ScreenProperty(), 0);
6413 ASSERT_NE(nullptr, screenSession5);
6414 screenSession5->SetIsCurrentInUse(true);
6415 screenSession5->SetScreenType(ScreenType::REAL);
6416 screenSession5->isInternal_ = true;
6417 ssm_->screenSessionMap_[54] = screenSession5;
6418
6419 sptr<ScreenSession> externalSession = nullptr;
6420 sptr<ScreenSession> internalSession = nullptr;
6421 ssm_->GetInternalAndExternalSession(internalSession, externalSession);
6422 ASSERT_EQ(internalSession, screenSession5);
6423 ssm_->screenSessionMap_.erase(50);
6424 ssm_->screenSessionMap_.erase(51);
6425 ssm_->screenSessionMap_.erase(52);
6426 ssm_->screenSessionMap_.erase(53);
6427 ssm_->screenSessionMap_.erase(54);
6428 }
6429
6430 /**
6431 * @tc.name: GetFakePhysicalScreenSession
6432 * @tc.desc: GetFakePhysicalScreenSession
6433 * @tc.type: FUNC
6434 */
6435 HWTEST_F(ScreenSessionManagerTest, GetFakePhysicalScreenSession, Function | SmallTest | Level3)
6436 {
6437 ASSERT_NE(ssm_, nullptr);
6438
6439 auto ret = ssm_->GetFakePhysicalScreenSession(50, 0, ScreenProperty());
6440 if (g_isPcDevice) {
6441 ASSERT_NE(nullptr, ret);
6442 } else {
6443 ASSERT_EQ(nullptr, ret);
6444 }
6445 }
6446
6447 /**
6448 * @tc.name: NotifyCastWhenSwitchScbNode
6449 * @tc.desc: NotifyCastWhenSwitchScbNode
6450 * @tc.type: FUNC
6451 */
6452 HWTEST_F(ScreenSessionManagerTest, NotifyCastWhenSwitchScbNode, Function | SmallTest | Level3)
6453 {
6454 ASSERT_NE(ssm_, nullptr);
6455 sptr<IDisplayManagerAgent> displayManagerAgent = new(std::nothrow) DisplayManagerAgentDefault();
6456 ASSERT_NE(displayManagerAgent, nullptr);
6457
6458 ScreenId id = 2;
6459 sptr<ScreenSession> newSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
6460 newSession ->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
6461 ASSERT_NE(newSession, nullptr);
6462 ssm_->screenSessionMap_[id] = newSession;
6463 ScreenId id1 = 3;
6464 sptr<ScreenSession> newSession1 = new (std::nothrow) ScreenSession(id1, ScreenProperty(), 0);
6465 newSession1 ->SetScreenCombination(ScreenCombination::SCREEN_UNIQUE);
6466 ASSERT_NE(newSession1, nullptr);
6467 ssm_->screenSessionMap_[id1] = newSession1;
6468 ScreenId id2 = 4;
6469 sptr<ScreenSession> newSession2 = nullptr;
6470 ssm_->screenSessionMap_[id2] = newSession2;
6471
6472 ssm_->NotifyCastWhenSwitchScbNode();
6473 }
6474
6475 /**
6476 * @tc.name: RecoverRestoredMultiScreenMode01
6477 * @tc.desc: RecoverRestoredMultiScreenMode01
6478 * @tc.type: FUNC
6479 */
6480 HWTEST_F(ScreenSessionManagerTest, RecoverRestoredMultiScreenMode01, TestSize.Level1)
6481 {
6482 ScreenId id = 1;
6483 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(id, ScreenProperty(), 0);
6484 screenSession->GetScreenProperty().SetScreenType(ScreenType::REAL);
6485 EXPECT_FALSE(ScreenSessionManager::GetInstance().RecoverRestoredMultiScreenMode(screenSession));
6486 }
6487
6488 /**
6489 * @tc.name: RecoverRestoredMultiScreenMode02
6490 * @tc.desc: RecoverRestoredMultiScreenMode02
6491 * @tc.type: FUNC
6492 */
6493 HWTEST_F(ScreenSessionManagerTest, RecoverRestoredMultiScreenMode02, TestSize.Level1)
6494 {
6495 ScreenId id = 2;
6496 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(id, ScreenProperty(), 0);
6497 screenSession->GetScreenProperty().SetScreenType(ScreenType::UNDEFINED);
6498 EXPECT_FALSE(ScreenSessionManager::GetInstance().RecoverRestoredMultiScreenMode(screenSession));
6499 }
6500
6501 /**
6502 * @tc.name: TestIsFreezed_WhenPidNotExist
6503 * @tc.desc: Test IsFreezed function when agentPid does not exist in freezedPidList_
6504 * @tc.type: FUNC
6505 */
6506 HWTEST_F(ScreenSessionManagerTest, TestIsFreezed_WhenPidNotExist, TestSize.Level1)
6507 {
6508 int32_t agentPid = 1234;
6509 DisplayManagerAgentType agentType = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
6510
6511 EXPECT_FALSE(ScreenSessionManager::GetInstance().IsFreezed(agentPid, agentType));
6512 }
6513
6514 /**
6515 * @tc.name: TestIsFreezed_WhenPidExistButAgentTypeNotExist
6516 * @tc.desc: Test IsFreezed function when agentPid exists in freezedPidList_ but not in pidAgentTypeMap_
6517 * @tc.type: FUNC
6518 */
6519 HWTEST_F(ScreenSessionManagerTest, TestIsFreezed_WhenPidExistButAgentTypeNotExist, TestSize.Level1)
6520 {
6521 int32_t agentPid = 1234;
6522 DisplayManagerAgentType agentType = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
6523
6524 ScreenSessionManager::GetInstance().freezedPidList_.insert(agentPid);
6525 EXPECT_TRUE(ScreenSessionManager::GetInstance().IsFreezed(agentPid, agentType));
6526 EXPECT_EQ(ScreenSessionManager::GetInstance().pidAgentTypeMap_[agentPid].count(agentType), 1);
6527 }
6528
6529 /**
6530 * @tc.name: TestIsFreezed_WhenPidAndAgentTypeExist
6531 * @tc.desc: Test IsFreezed function when agentPid and agentType both exists
6532 * @tc.type: FUNC
6533 */
6534 HWTEST_F(ScreenSessionManagerTest, TestIsFreezed_WhenPidAndAgentTypeExist, TestSize.Level1)
6535 {
6536 int32_t agentPid = 1234;
6537 DisplayManagerAgentType agentType = DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER;
6538
6539 ScreenSessionManager::GetInstance().freezedPidList_.insert(agentPid);
6540 ScreenSessionManager::GetInstance().pidAgentTypeMap_[agentPid] =
6541 std::set<DisplayManagerAgentType>({DisplayManagerAgentType::DISPLAY_POWER_EVENT_LISTENER});
6542 EXPECT_TRUE(ScreenSessionManager::GetInstance().IsFreezed(agentPid, agentType));
6543 EXPECT_EQ(ScreenSessionManager::GetInstance().pidAgentTypeMap_[agentPid].count(agentType), 1);
6544 }
6545
6546 /**
6547 * @tc.name: SetScreenOnDelayTime
6548 * @tc.desc: SetScreenOnDelayTime test
6549 * @tc.type: FUNC
6550 */
6551 HWTEST_F(ScreenSessionManagerTest, SetScreenOnDelayTime, TestSize.Level1)
6552 {
6553 int32_t delay = CV_WAIT_SCREENON_MS - 1;
6554 int32_t ret = ssm_->SetScreenOnDelayTime(delay);
6555 EXPECT_EQ(ret, delay);
6556
6557 delay = CV_WAIT_SCREENON_MS + 1;
6558 ret = ssm_->SetScreenOnDelayTime(delay);
6559 EXPECT_EQ(ret, CV_WAIT_SCREENON_MS);
6560 }
6561
6562 /**
6563 * @tc.name: ShouldReturnOkWhenMultiScreenNotEnabled
6564 * @tc.desc: ShouldReturnOkWhenMultiScreenNotEnabled test
6565 * @tc.type: FUNC
6566 */
6567 HWTEST_F(ScreenSessionManagerTest, ShouldReturnOkWhenMultiScreenNotEnabled, TestSize.Level1)
6568 {
6569 EXPECT_EQ(ScreenSessionManager::GetInstance().VirtualScreenUniqueSwitch({}), DMError::DM_ERROR_NULLPTR);
6570 }
6571
6572 /**
6573 * @tc.name: ShouldReturnOkWhenMultiScreenNotEnabled
6574 * @tc.desc: ShouldReturnOkWhenMultiScreenNotEnabled test
6575 * @tc.type: FUNC
6576 */
6577 HWTEST_F(ScreenSessionManagerTest, ShouldReturnNullPtrWhenDefaultScreenIsNull, TestSize.Level1)
6578 {
6579 #ifndef WM_MULTI_SCREEN_ENABLE
6580 ScreenSessionManager ssm;
6581 ssm = ScreenSessionManager::GetInstance();
6582
6583 ssm.screenSessionMap_.erase(1100);
6584 ssm.defaultScreenId_ = 1100;
6585 EXPECT_EQ(ssm.VirtualScreenYniqueSwitch({}), DMError::DM_ERROR_NULLPTR);
6586 #endif
6587 }
6588
6589 /**
6590 * @tc.name: ShouldHandleExistingGroupSmsId
6591 * @tc.desc: ShouldHandleExistingGroupSmsId test
6592 * @tc.type: FUNC
6593 */
6594 HWTEST_F(ScreenSessionManagerTest, ShouldHandleExistingGroupSmsId, TestSize.Level1)
6595 {
6596 #ifndef WM_MULTI_SCREEN_ENABLE
6597 ScreenSessionManager ssm;
6598 ssm = ScreenSessionManager::GetInstance();
6599
6600 Sptr<ScreenSession> screenSession = Sptr<ScreenSession>::MakeSptr();
6601 screenSession->groupSmsId_ = 1001;
6602 ssm.screenSessionMap_[1100] = screenSession;
6603 ssm.defaultScreenId_ = 1100;
6604 ssm.smsSessionGroupMap_[1001] = {};
6605 EXPECT_EQ(ssm.VirtualScreenYniqueSwitch({}), DMError::DM_OK);
6606 EXPECT_EQ(ssm.smsSessionGroupMap_.count(1), 0);
6607 ssm.screenSessionMap_.erase(1100);
6608 #endif
6609 }
6610
6611 /**
6612 * @tc.name: ShouldHandleNonExistingGroupSmsId
6613 * @tc.desc: ShouldHandleNonExistingGroupSmsId test
6614 * @tc.type: FUNC
6615 */
6616 HWTEST_F(ScreenSessionManagerTest, ShouldHandleNonExistingGroupSmsId, TestSize.Level1)
6617 {
6618 #ifndef WM_MULTI_SCREEN_ENABLE
6619 ScreenSessionManager ssm;
6620 ssm = ScreenSessionManager::GetInstance();
6621
6622 Sptr<ScreenSession> screenSession = Sptr<ScreenSession>::MakeSptr();
6623 screenSession->groupSmsId_ = 1001;
6624 ssm.screenSessionMap_[1100] = screenSession;
6625 ssm.defaultScreenId_ = 1100;
6626 EXPECT_EQ(ssm.VirtualScreenYniqueSwitch({}), DMError::DM_OK);
6627 ssm.screenSessionMap_.erase(1100);
6628 #endif
6629 }
6630
6631 /**
6632 * @tc.name: SetRSScreenPowerStatus
6633 * @tc.desc: call RS power func, and notify brightness while screen on
6634 * @tc.type: FUNC
6635 */
6636 HWTEST_F(ScreenSessionManagerTest, SetRSScreenPowerStatus, TestSize.Level1)
6637 {
6638 ScreenPowerState state;
6639 EXPECT_NE(ssm_, nullptr);
6640
6641 ssm_->SetRSScreenPowerStatus(0, ScreenPowerStatus::POWER_STATUS_ON);
6642 state = ssm_->GetScreenPower(0);
6643 EXPECT_EQ(state, ScreenPowerState::POWER_ON);
6644
6645 ssm_->SetRSScreenPowerStatus(0, ScreenPowerStatus::POWER_STATUS_OFF);
6646 state = ssm_->GetScreenPower(0);
6647 EXPECT_EQ(state, ScreenPowerState::POWER_OFF);
6648 }
6649
6650 /**
6651 * @tc.name: GetScreenCombination01
6652 * @tc.desc: GetScreenCombination01
6653 * @tc.type: FUNC
6654 */
6655 HWTEST_F(ScreenSessionManagerTest, GetScreenCombination01, TestSize.Level1)
6656 {
6657 ScreenId screenId = 1051;
6658 auto ret = ssm_->GetScreenCombination(screenId);
6659 EXPECT_EQ(ret, ScreenCombination::SCREEN_ALONE);
6660 }
6661
6662 /**
6663 * @tc.name: GetScreenCombination02
6664 * @tc.desc: !screenSession = false
6665 * @tc.type: FUNC
6666 */
6667 HWTEST_F(ScreenSessionManagerTest, GetScreenCombination02, TestSize.Level1)
6668 {
6669 ScreenId screenId = 1050;
6670 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(screenId, ScreenProperty(), 0);
6671 EXPECT_NE(screenSession, nullptr);
6672 ssm_->screenSessionMap_[screenId] = screenSession;
6673 auto ret = ssm_->GetScreenCombination(screenId);
6674 EXPECT_EQ(ret, ScreenCombination::SCREEN_ALONE);
6675 }
6676
6677 /**
6678 * @tc.name: OnRemoteDied01
6679 * @tc.desc: OnRemoteDied_ShouldReturnFalse_WhenAgentIsNUllptr
6680 * @tc.type: FUNC
6681 */
6682 HWTEST_F(ScreenSessionManagerTest, OnRemoteDied01, TestSize.Level1)
6683 {
6684 EXPECT_FALSE(ssm_->OnRemoteDied(nullptr));
6685 }
6686
6687 /**
6688 * @tc.name: OnRemoteDied02
6689 * @tc.desc: OnRemoteDied_ShouldReturnTrue_WhenAgentNotFound
6690 * @tc.type: FUNC
6691 */
6692 HWTEST_F(ScreenSessionManagerTest, OnRemoteDied02, TestSize.Level1)
6693 {
6694 sptr<IRemoteObject> agent = sptr<MockIRemoteObject>::MakeSptr();
6695 EXPECT_TRUE(ssm_->OnRemoteDied(agent));
6696 }
6697
6698 /**
6699 * @tc.name: OnRemoteDied03
6700 * @tc.desc: OnRemoteDied_ShouldRemoveAgent_WhenAgentFoundAndNoScreens
6701 * @tc.type: FUNC
6702 */
6703 HWTEST_F(ScreenSessionManagerTest, OnRemoteDied03, TestSize.Level1)
6704 {
6705 sptr<IRemoteObject> agent = sptr<MockIRemoteObject>::MakeSptr();
6706 ssm_->screenAgentMap_[agent] = {};
6707
6708 EXPECT_TRUE(ssm_->OnRemoteDied(agent));
6709 }
6710
6711 /**
6712 * @tc.name: GetExpandAvailableArea
6713 * @tc.desc: GetExpandAvailableArea test
6714 * @tc.type: FUNC
6715 */
6716 HWTEST_F(ScreenSessionManagerTest, GetExpandAvailableArea, TestSize.Level1)
6717 {
6718 DMRect area;
6719 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, ssm_->GetExpandAvailableArea(SCREEN_ID_INVALID, area));
6720 DisplayId id = 0;
6721 sptr<ScreenSession> screenSession = new (std::nothrow) ScreenSession(id, ScreenProperty(), 0);
6722 ssm_->screenSessionMap_[id] = screenSession;
6723 ASSERT_NE(nullptr, screenSession);
6724 EXPECT_EQ(DMError::DM_OK, ssm_->GetExpandAvailableArea(id, area));
6725 }
6726
6727 /**
6728 * @tc.name: GetFakePhysicalScreenSession001
6729 * @tc.desc: Test that the function returns nullptr when g_isPcDevice is false
6730 * @tc.type: FUNC
6731 */
6732 HWTEST_F(ScreenSessionManagerTest, GetFakePhysicalScreenSession001, TestSize.Level1)
6733 {
6734 ScreenId screenId = 1;
6735 ScreenId defScreenId = 2;
6736 ScreenProperty property;
6737
6738 auto screenSession = ScreenSessionManager::GetInstance().GetFakePhysicalScreenSession(screenId, defScreenId,
6739 property);
6740 EXPECT_EQ(screenSession, nullptr);
6741 }
6742
6743 /**
6744 * @tc.name: CreateFakePhysicalMirrorSessionInner
6745 * @tc.desc: CreateFakePhysicalMirrorSessionInner
6746 * @tc.type: FUNC
6747 */
6748 HWTEST_F(ScreenSessionManagerTest, CreateFakePhysicalMirrorSessionInner, TestSize.Level1)
6749 {
6750 ScreenId screenId = 1;
6751 ScreenId defScreenId = 2;
6752 ScreenProperty property;
6753
6754 auto screenSession = ScreenSessionManager::GetInstance().CreateFakePhysicalMirrorSessionInner(screenId, defScreenId,
6755 property);
6756 EXPECT_EQ(screenSession, nullptr);
6757 }
6758
6759 /**
6760 * @tc.name: GetPhysicalScreenSessionInner
6761 * @tc.desc: GetPhysicalScreenSessionInner
6762 * @tc.type: FUNC
6763 */
6764 HWTEST_F(ScreenSessionManagerTest, GetPhysicalScreenSessionInner, TestSize.Level1)
6765 {
6766 ScreenId screenId = 1;
6767 ScreenProperty property;
6768
6769 auto screenSession = ScreenSessionManager::GetInstance().GetPhysicalScreenSessionInner(screenId, property);
6770 EXPECT_EQ(screenSession, nullptr);
6771 }
6772
6773 /**
6774 * @tc.name: GetOrCreatePhysicalScreenSession
6775 * @tc.desc: Test scenario where no existing physical screen session exists and new session creation fails
6776 * @tc.type: FUNC
6777 */
6778 HWTEST_F(ScreenSessionManagerTest, GetOrCreatePhysicalScreenSession, TestSize.Level1)
6779 {
6780 ScreenId screenId = 1;
6781 sptr<ScreenSession> result = ScreenSessionManager::GetInstance().GetOrCreatePhysicalScreenSession(screenId);
6782 EXPECT_EQ(result, nullptr);
6783 }
6784
6785 /**
6786 * @tc.name: GetScreenSessionByRsId01
6787 * @tc.desc: GetScreenSessionByRsId01
6788 * @tc.type: FUNC
6789 */
6790 HWTEST_F(ScreenSessionManagerTest, GetScreenSessionByRsId01, TestSize.Level1)
6791 {
6792 ssm_->screenSessionMap_.erase(123);
6793 ScreenId rsScreenId = 123;
6794 sptr<ScreenSession> newSession = new ScreenSession();
6795 newSession->SetRSScreenId(rsScreenId);
6796 ssm_->screenSessionMap_[rsScreenId] = newSession;
6797
6798 sptr<ScreenSession> result = ssm_->GetScreenSessionByRsId(rsScreenId);
6799 EXPECT_NE(result, nullptr);
6800 ssm_->screenSessionMap_.erase(123);
6801 }
6802
6803 /**
6804 * @tc.name: GetScreenSessionByRsId02
6805 * @tc.desc: GetScreenSessionByRsId02
6806 * @tc.type: FUNC
6807 */
6808 HWTEST_F(ScreenSessionManagerTest, GetScreenSessionByRsId02, TestSize.Level1)
6809 {
6810 ssm_->screenSessionMap_.clear();
6811 ScreenId rsScreenId = 123;
6812 ssm_->screenSessionMap_[rsScreenId] = nullptr;
6813
6814 sptr<ScreenSession> result = ssm_->GetScreenSessionByRsId(rsScreenId);
6815 EXPECT_EQ(result, nullptr);
6816 }
6817
6818 /**
6819 * @tc.name: GetPhysicalScreenSession001
6820 * @tc.desc: Test GetPhysicalScreenSession function when screenId is not found in the map
6821 * @tc.type: FUNC
6822 */
6823 HWTEST_F(ScreenSessionManagerTest, GetPhysicalScreenSession001, TestSize.Level1)
6824 {
6825 ScreenId screenId = 123;
6826 EXPECT_EQ(ssm_->GetPhysicalScreenSession(screenId), nullptr);
6827 }
6828
6829 /**
6830 * @tc.name: GetPhysicalScreenSession002
6831 * @tc.desc: Test GetPhysicalScreenSession function when screenSessionMap is empty
6832 * @tc.type: FUNC
6833 */
6834 HWTEST_F(ScreenSessionManagerTest, GetPhysicalScreenSession002, TestSize.Level1)
6835 {
6836 ssm_->screenAgentMap_.clear();
6837 ScreenId screenId = 123;
6838 EXPECT_EQ(ssm_->GetPhysicalScreenSession(screenId), nullptr);
6839 }
6840
6841 /**
6842 * @tc.name: OnScreenModeChange
6843 * @tc.desc: OnScreenModeChange
6844 * @tc.type: FUNC
6845 */
6846 HWTEST_F(ScreenSessionManagerTest, OnScreenModeChange, Function | SmallTest | Level3)
6847 {
6848 ASSERT_NE(ssm_, nullptr);
6849 ASSERT_EQ(ssm_->clientProxy_, nullptr);
6850
6851 ScreenModeChangeEvent screenModeChangeEvent = ScreenModeChangeEvent::UNKNOWN;
6852 ssm_->OnScreenModeChange(screenModeChangeEvent);
6853 }
6854
6855 /**
6856 * @tc.name: GetIsFoldStatusLocked/SetIsFoldStatusLocked
6857 * @tc.desc: GetIsFoldStatusLocked/SetIsFoldStatusLocked
6858 * @tc.type: FUNC
6859 */
6860 HWTEST_F(ScreenSessionManagerTest, GetIsFoldStatusLocked, Function | SmallTest | Level3)
6861 {
6862 ssm_->SetIsFoldStatusLocked(true);
6863 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), true);
6864
6865 ssm_->SetIsFoldStatusLocked(false);
6866 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), false);
6867 }
6868
6869 /**
6870 * @tc.name: SetFoldStatusExpandAndLocked
6871 * @tc.desc: SetFoldStatusExpandAndLocked
6872 * @tc.type: FUNC
6873 */
6874 HWTEST_F(ScreenSessionManagerTest, SetFoldStatusExpandAndLocked, Function | SmallTest | Level3)
6875 {
6876 if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
6877 GTEST_SKIP();
6878 }
6879 ssm_->SetFoldStatusExpandAndLocked(true);
6880 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), true);
6881
6882 ssm_->SetFoldStatusExpandAndLocked(false);
6883 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), false);
6884 }
6885
6886 /**
6887 * @tc.name: CheckMultiScreenInfoMap01
6888 * @tc.desc: Test CheckMultiScreenInfoMap function when the map is empty.
6889 * @tc.type: FUNC
6890 */
6891 HWTEST_F(ScreenSessionManagerTest, CheckMultiScreenInfoMap01, TestSize.Level1)
6892 {
6893 std::map<std::string, MultiScreenInfo> emptyMap;
6894 EXPECT_FALSE(ScreenSessionManager::GetInstance().CheckMultiScreenInfoMap(emptyMap, "serial123"));
6895 }
6896
6897 /**
6898 * @tc.name: CheckMultiScreenInfoMap02
6899 * @tc.desc: Test CheckMultiScreenInfoMap function when the serial number is empty.
6900 * @tc.type: FUNC
6901 */
6902 HWTEST_F(ScreenSessionManagerTest, CheckMultiScreenInfoMap02, TestSize.Level1)
6903 {
6904 std::map<std::string, MultiScreenInfo> nonEmptyMap;
6905 nonEmptyMap["serial123"] = MultiScreenInfo();
6906 EXPECT_FALSE(ScreenSessionManager::GetInstance().CheckMultiScreenInfoMap(nonEmptyMap, ""));
6907 }
6908
6909 /**
6910 * @tc.name: CheckMultiScreenInfoMap03
6911 * @tc.desc: Test CheckMultiScreenInfoMap function when the serial number is not found in the map.
6912 * @tc.type: FUNC
6913 */
6914 HWTEST_F(ScreenSessionManagerTest, CheckMultiScreenInfoMap03, TestSize.Level1)
6915 {
6916 std::map<std::string, MultiScreenInfo> nonEmptyMap;
6917 nonEmptyMap["serial123"] = MultiScreenInfo();
6918 EXPECT_FALSE(ScreenSessionManager::GetInstance().CheckMultiScreenInfoMap(nonEmptyMap, "serial456"));
6919 }
6920
6921 /**
6922 * @tc.name: CheckMultiScreenInfoMap04
6923 * @tc.desc: Test CHeckMultiScreenInfoMap function when all checks pass.
6924 * @tc.type: FUNC
6925 */
6926 HWTEST_F(ScreenSessionManagerTest, CheckMultiScreenInfoMap04, TestSize.Level1)
6927 {
6928 std::map<std::string, MultiScreenInfo> nonEmptyMap;
6929 nonEmptyMap["serial123"] = MultiScreenInfo();
6930 EXPECT_TRUE(ScreenSessionManager::GetInstance().CheckMultiScreenInfoMap(nonEmptyMap, "serial123"));
6931 }
6932
6933 /**
6934 * @tc.name: AdaptSuperHorizonalBoot
6935 * @tc.desc: AdaptSuperHorizonalBoot
6936 * @tc.type: FUNC
6937 */
6938 HWTEST_F(ScreenSessionManagerTest, AdaptSuperHorizonalBoot, Function | SmallTest | Level3)
6939 {
6940 if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
6941 GTEST_SKIP();
6942 }
6943 ScreenSessionConfig config;
6944 sptr<ScreenSession> session = new ScreenSession(config,
6945 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
6946 ScreenId id = 0;
6947
6948 ssm_->AdaptSuperHorizonalBoot(session, id);
6949 EXPECT_EQ(session->GetRotation(), Rotation::ROTATION_0);
6950 }
6951
6952 /**
6953 * @tc.name: HandleSuperFoldStatusLocked
6954 * @tc.desc: HandleSuperFoldStatusLocked
6955 * @tc.type: FUNC
6956 */
6957 HWTEST_F(ScreenSessionManagerTest, HandleSuperFoldStatusLocked, Function | SmallTest | Level3)
6958 {
6959 if (!FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
6960 GTEST_SKIP();
6961 }
6962 ssm_->HandleSuperFoldStatusLocked(true);
6963 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), true);
6964
6965 ssm_->HandleSuperFoldStatusLocked(false);
6966 EXPECT_EQ(ssm_->GetIsFoldStatusLocked(), false);
6967 }
6968
6969 /**
6970 * @tc.name: HandleMainScreenDisconnect
6971 * @tc.desc: HandleMainScreenDisconnect test
6972 * @tc.type: not main screen
6973 */
6974 HWTEST_F(ScreenSessionManagerTest, HandleMainScreenDisconnect01, TestSize.Level1)
6975 {
6976 #ifndef WM_MULTI_SCREEN_ENABLE
6977 ASSERT_NE(ssm_, nullptr);
6978
6979 ScreenId id = 1001;
6980 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
6981 ASSERT_NE(nullptr, screenSession);
6982 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MIRROR);
6983
6984 ssm_->HandleMainScreenDisconnect(screenSession);
6985 EXPECT_EQ(screenSession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
6986 #endif
6987 }
6988
6989 /**
6990 * @tc.name: HandleMainScreenDisconnect
6991 * @tc.desc: HandleMainScreenDisconnect test
6992 * @tc.type: main screen
6993 */
6994 HWTEST_F(ScreenSessionManagerTest, HandleMainScreenDisconnect02, TestSize.Level1)
6995 {
6996 #ifndef WM_MULTI_SCREEN_ENABLE
6997 ASSERT_NE(ssm_, nullptr);
6998
6999 ScreenId id = 1001;
7000 sptr<ScreenSession> screenSession = new ScreenSession(id, ScreenProperty(), 0);
7001 ASSERT_NE(nullptr, screenSession);
7002 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
7003
7004 ssm_->HandleMainScreenDisconnect(screenSession);
7005 if (!g_isPcDevice) {
7006 EXPECT_EQ(screenSession->GetScreenCombination(), ScreenCombination::SCREEN_MAIN);
7007 } else {
7008 EXPECT_EQ(ssm_->GetIsOuterOnlyMode(), false);
7009 }
7010 #endif
7011 }
7012
7013 /**
7014 * @tc.name: HandleMainScreenDisconnect
7015 * @tc.desc: HandleMainScreenDisconnect test
7016 * @tc.type: main screen
7017 */
7018 HWTEST_F(ScreenSessionManagerTest, HandleMainScreenDisconnect03, TestSize.Level1)
7019 {
7020 #ifndef WM_MULTI_SCREEN_ENABLE
7021 ASSERT_NE(ssm_, nullptr);
7022
7023 ScreenId innerId = 1000;
7024 ScreenId extendId = 1001;
7025 ScreenSessionConfig innerConfig = {
7026 .screenId = innerId,
7027 .rsId = extendId,
7028 .defaultScreenId = innerId,
7029 };
7030 sptr<ScreenSession> innerSession = new ScreenSession(innerConfig,
7031 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
7032 ASSERT_NE(nullptr, innerSession);
7033 innerSession->SetIsInternal(true);
7034 innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
7035 innerSession->SetIsCurrentInUse(true);
7036 ssm_->screenSessionMap_.insert(std::make_pair(innerId, innerSession));
7037
7038 ScreenSessionConfig extendConfig = {
7039 .screenId = extendId,
7040 .rsId = innerId,
7041 .defaultScreenId = innerId,
7042 };
7043 sptr<ScreenSession> extendSession = new ScreenSession(extendConfig,
7044 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
7045 ASSERT_NE(nullptr, extendSession);
7046 extendSession->SetIsInternal(false);
7047 extendSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
7048 extendSession->SetIsCurrentInUse(true);
7049 ssm_->screenSessionMap_.insert(std::make_pair(extendId, extendSession));
7050
7051 ssm_->HandleMainScreenDisconnect(extendSession);
7052 if (!g_isPcDevice) {
7053 EXPECT_EQ(extendSession->GetScreenCombination(), ScreenCombination::SCREEN_MAIN);
7054 } else {
7055 EXPECT_EQ(extendSession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
7056 }
7057 ssm_->screenSessionMap_.erase(innerId);
7058 ssm_->screenSessionMap_.erase(extendId);
7059 #endif
7060 }
7061
7062 /**
7063 * @tc.name: ResetInternalScreenSession
7064 * @tc.desc: ResetInternalScreenSession test
7065 * @tc.type: session null
7066 */
7067 HWTEST_F(ScreenSessionManagerTest, ResetInternalScreenSession01, TestSize.Level1)
7068 {
7069 #ifndef WM_MULTI_SCREEN_ENABLE
7070 ASSERT_NE(ssm_, nullptr);
7071
7072 sptr<ScreenSession> innerSession = nullptr;
7073 sptr<ScreenSession> extendSession = nullptr;
7074
7075 ssm_->ResetInternalScreenSession(innerSession, extendSession);
7076 EXPECT_EQ(nullptr, innerSession);
7077 EXPECT_EQ(nullptr, extendSession);
7078 #endif
7079 }
7080
7081 /**
7082 * @tc.name: ResetInternalScreenSession
7083 * @tc.desc: ResetInternalScreenSession test
7084 * @tc.type: FUNC
7085 */
7086 HWTEST_F(ScreenSessionManagerTest, ResetInternalScreenSession02, TestSize.Level1)
7087 {
7088 #ifndef WM_MULTI_SCREEN_ENABLE
7089 ASSERT_NE(ssm_, nullptr);
7090
7091 ScreenId innerId = 1000;
7092 ScreenId extendId = 1001;
7093 ScreenSessionConfig innerConfig = {
7094 .screenId = innerId,
7095 .rsId = extendId,
7096 .defaultScreenId = innerId,
7097 };
7098 sptr<ScreenSession> innerSession = new ScreenSession(innerConfig,
7099 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
7100 ASSERT_NE(nullptr, innerSession);
7101 innerSession->SetIsInternal(true);
7102 innerSession->SetScreenCombination(ScreenCombination::SCREEN_EXTEND);
7103 ssm_->screenSessionMap_.insert(std::make_pair(innerId, innerSession));
7104
7105 ScreenSessionConfig extendConfig = {
7106 .screenId = extendId,
7107 .rsId = innerId,
7108 .defaultScreenId = innerId,
7109 };
7110 sptr<ScreenSession> extendSession = new ScreenSession(extendConfig,
7111 ScreenSessionReason::CREATE_SESSION_FOR_REAL);
7112 ASSERT_NE(nullptr, extendSession);
7113 extendSession->SetIsInternal(false);
7114 extendSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
7115 ssm_->screenSessionMap_.insert(std::make_pair(extendId, extendSession));
7116
7117 ssm_->ResetInternalScreenSession(innerSession, extendSession);
7118 EXPECT_EQ(innerSession->GetIsInternal(), false);
7119 EXPECT_EQ(extendSession->GetIsInternal(), true);
7120 ssm_->screenSessionMap_.erase(innerId);
7121 ssm_->screenSessionMap_.erase(extendId);
7122 #endif
7123 }
7124
7125 /**
7126 * @tc.name: NotifyCreatedScreen
7127 * @tc.desc: NotifyCreatedScreen test
7128 * @tc.type: NotifyCreatedScreen test
7129 */
7130 HWTEST_F(ScreenSessionManagerTest, NotifyCreatedScreen, TestSize.Level1)
7131 {
7132 logMsg.clear();
7133 if (!g_isPcDevice) {
7134 GTEST_SKIP();
7135 }
7136 ASSERT_NE(ssm_, nullptr);
7137 LOG_SetCallback(MyLogCallback);
7138 ScreenId screenId = 1001;
7139 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
7140 if (screenSession->GetScreenCombination() == ScreenCombination::SCREEN_MIRROR) {
7141 screenSession->SetScreenCombination(ScreenCombination::SCREEN_MAIN);
7142 }
7143 ssm_->NotifyCreatedScreen(screenSession);
7144 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
7145 EXPECT_TRUE(logMsg.find("super fold device, change by rotation.") == std::string::npos);
7146 } else {
7147 EXPECT_FALSE(logMsg.find("super fold device, change by rotation.") == std::string::npos);
7148 }
7149 }
7150
7151 /**
7152 * @tc.name: SetPrimaryDisplaySystemDpi
7153 * @tc.desc: SetPrimaryDisplaySystemDpi
7154 * @tc.type: FUNC
7155 */
7156 HWTEST_F(ScreenSessionManagerTest, SetPrimaryDisplaySystemDpi, Function | SmallTest | Level3)
7157 {
7158 DMError ret = ssm_->SetPrimaryDisplaySystemDpi(2.2);
7159 EXPECT_EQ(DMError::DM_OK, ret);
7160 }
7161
7162 /**
7163 * @tc.name: HandleSwitchPcMode
7164 * @tc.desc: HandleSwitchPcMode
7165 * @tc.type: FUNC
7166 */
7167 HWTEST_F(ScreenSessionManagerTest, HandleSwitchPcMode, TestSize.Level1)
7168 {
7169 ASSERT_NE(ssm_, nullptr);
7170 if (!IS_SUPPORT_PC_MODE) {
7171 bool isPcDevice = ssm_->HandleSwitchPcMode();
7172 ASSERT_EQ(isPcDevice, g_isPcDevice);
7173 return;
7174 }
7175 bool isPcMode = system::GetBoolParameter("persist.sceneboard.ispcmode", false);
7176 bool isPcDevice = ssm_->HandleSwitchPcMode();
7177 if (isPcMode) {
7178 EXPECT_TRUE(isPcDevice);
7179 } else {
7180 EXPECT_FALSE(isPcDevice);
7181 }
7182 }
7183
7184 /**
7185 * @tc.name: SwitchModeHandleExternalScreen
7186 * @tc.desc: SwitchModeHandleExternalScreen
7187 * @tc.type: FUNC
7188 */
7189 HWTEST_F(ScreenSessionManagerTest, SwitchModeHandleExternalScreen01, TestSize.Level1)
7190 {
7191 ASSERT_NE(ssm_, nullptr);
7192 sptr<IDisplayManagerAgent> displayManagerAgent = sptr<DisplayManagerAgentDefault>::MakeSptr();
7193 VirtualScreenOption virtualOption;
7194 virtualOption.name_ = "testVirtualOption";
7195 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
7196 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
7197 ASSERT_NE(screenSession, nullptr);
7198 ssm_->SwitchModeHandleExternalScreen(false);
7199 EXPECT_NE(screenSession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
7200 screenSession->SetIsRealScreen(true);
7201 ssm_->screenSessionMap_.insert(std::make_pair(777, nullptr));
7202 sptr<IDisplayManagerAgent> displayManagerAgent1 = sptr<DisplayManagerAgentDefault>::MakeSptr();
7203 ASSERT_NE(displayManagerAgent1, nullptr);
7204 VirtualScreenOption virtualOption1;
7205 virtualOption1.name_ = "createVirtualOption2";
7206 auto virtualScreenId = ssm_->CreateVirtualScreen(virtualOption1, displayManagerAgent1->AsObject());
7207 ssm_->SwitchModeHandleExternalScreen(false);
7208 EXPECT_EQ(screenSession->GetName(), "CastEngine");
7209 screenSession->SetIsRealScreen(false);
7210 ssm_->DestroyVirtualScreen(screenId);
7211 ssm_->DestroyVirtualScreen(virtualScreenId);
7212 }
7213
7214 /**
7215 * @tc.name: SwitchModeHandleExternalScreen
7216 * @tc.desc: SwitchModeHandleExternalScreen
7217 * @tc.type: FUNC
7218 */
7219 HWTEST_F(ScreenSessionManagerTest, SwitchModeHandleExternalScreen02, TestSize.Level1)
7220 {
7221 ASSERT_NE(ssm_, nullptr);
7222 ssm_->screenSessionMap_.clear();
7223 sptr<IDisplayManagerAgent> displayManagerAgent = sptr<DisplayManagerAgentDefault>::MakeSptr();
7224 VirtualScreenOption virtualOption;
7225 virtualOption.name_ = "testVirtualOption";
7226 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
7227 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
7228 ASSERT_NE(screenSession, nullptr);
7229 screenSession->SetIsRealScreen(true);
7230 ssm_->SwitchModeHandleExternalScreen(true);
7231 EXPECT_NE(screenSession->GetScreenCombination(), ScreenCombination::SCREEN_MIRROR);
7232 ssm_->DestroyVirtualScreen(screenId);
7233 }
7234
7235 /**
7236 * @tc.name: CreateVirtualScreen
7237 * @tc.desc: CreateVirtualScreen test
7238 * @tc.type: FUNC
7239 */
7240 HWTEST_F(ScreenSessionManagerTest, CreateVirtualScreen, TestSize.Level1)
7241 {
7242 ASSERT_NE(ssm_, nullptr);
7243 sptr<IDisplayManagerAgent> displayManagerAgent = sptr<DisplayManagerAgentDefault>::MakeSptr();
7244 VirtualScreenOption virtualOption;
7245 virtualOption.name_ = "CastEngine";
7246 auto screenId = ssm_->CreateVirtualScreen(virtualOption, displayManagerAgent->AsObject());
7247 sptr<ScreenSession> screenSession = ssm_->GetScreenSession(screenId);
7248 ASSERT_NE(screenSession, nullptr);
7249 EXPECT_EQ(screenSession->GetVirtualScreenFlag(), VirtualScreenFlag::CAST);
7250 ssm_->DestroyVirtualScreen(screenId);
7251 }
7252
7253 /**
7254 * @tc.name: SetScreenOffsetFeatureTest
7255 * @tc.desc: SetScreenOffsetInner
7256 * @tc.type: FUNC
7257 */
7258 HWTEST_F(ScreenSessionManagerTest, SetScreenOffsetFeatureTest, Function | SmallTest | Level3)
7259 {
7260 ScreenId screenId = 0;
7261 EXPECT_TRUE(ssm_->SetScreenOffset(screenId, 0.0F, 0.0F));
7262 EXPECT_TRUE(ssm_->SetScreenOffset(screenId, 100.0F, 100.0F));
7263 screenId = -1;
7264 EXPECT_FALSE(ssm_->SetScreenOffset(screenId, 0.0F, 0.0F));
7265 EXPECT_FALSE(ssm_->SetScreenOffset(screenId, 100.0F, 100.0F));
7266 }
7267
7268 +/**
7269 + * @tc.name: SetLapTopLidOpenStatus
7270 + * @tc.desc: test function : SetLapTopLidOpenStatus
7271 + * @tc.type: FUNC
7272 + */
7273 HWTEST_F(ScreenSessionManagerTest, SetLapTopLidOpenStatus, TestSize.Level1)
7274 {
7275 ASSERT_NE(ssm_, nullptr);
7276
7277 ssm_->SetLapTopLidOpenStatus(true);
7278 bool isOpened = ssm_->IsLapTopLidOpen();
7279 EXPECT_EQ(true, isOpened);
7280 }
7281
7282 +/**
7283 + * @tc.name: InitSecondaryDisplayPhysicalParams
7284 + * @tc.desc: test function : InitSecondaryDisplayPhysicalParams
7285 + * @tc.type: FUNC
7286 + */
7287 HWTEST_F(ScreenSessionManagerTest, InitSecondaryDisplayPhysicalParams, TestSize.Level1)
7288 {
7289 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
7290 return;
7291 }
7292 ASSERT_NE(ssm_, nullptr);
7293 ssm_->InitSecondaryDisplayPhysicalParams();
7294 EXPECT_FALSE(ssm_->screenParams_.empty());
7295 }
7296
7297 /**
7298 * @tc.name: GetPhyScreenId
7299 * @tc.desc: test function : GetPhyScreenId
7300 * @tc.type: FUNC
7301 */
7302 HWTEST_F(ScreenSessionManagerTest, GetPhyScreenId, TestSize.Level1)
7303 {
7304 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
7305 GTEST_SKIP();
7306 }
7307
7308 ScreenId screenId = 0;
7309 ssm_->SetCoordinationFlag(true);
7310 ASSERT_EQ(ssm_->GetPhyScreenId(screenId), screenId);
7311
7312 screenId = 5;
7313 ASSERT_EQ(ssm_->GetPhyScreenId(screenId), 0);
7314 }
7315
7316 /**
7317 * @tc.name: UpdateCoordinationRefreshRate
7318 * @tc.desc: test function : UpdateCoordinationRefreshRate
7319 * @tc.type: FUNC
7320 */
7321 HWTEST_F(ScreenSessionManagerTest, UpdateCoordinationRefreshRate, TestSize.Level1)
7322 {
7323 if (!FoldScreenStateInternel::IsSecondaryDisplayFoldDevice()) {
7324 GTEST_SKIP();
7325 }
7326 uint32_t refreshRate = 60;
7327 ssm_->SetCoordinationFlag(false);
7328 ssm_->UpdateCoordinationRefreshRate(refreshRate);
7329 EXPECT_FALSE(ssm_->GetScreenSession(5));
7330
7331 refreshRate = 90;
7332 ssm_->SetCoordinationFlag(true);
7333 ssm_->UpdateCoordinationRefreshRate(refreshRate);
7334 EXPECT_TRUE(ssm_->GetScreenSession(0));
7335 }
7336 }
7337 } // namespace Rosen
7338 } // namespace OHOS
7339