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 "iremote_object_mocker.h"
19 #include "screen_session_manager_client.h"
20 #include "zidl/screen_session_manager_proxy.h"
21 #include "display_manager.h"
22 #include "window_manager_hilog.h"
23 #include "scene_board_judgement.h"
24 #include "fold_screen_state_internel.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28
29 namespace OHOS {
30 namespace Rosen {
31 namespace {
32 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenSessionManagerClientTest"};
33 }
34
35 namespace {
36 std::string logMsg;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)37 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
38 const char* msg)
39 {
40 logMsg = msg;
41 }
42 }
43
44 class DmPrivateWindowListener : public DisplayManager::IPrivateWindowListener {
45 public:
OnPrivateWindow(bool hasPrivate)46 void OnPrivateWindow(bool hasPrivate) {WLOGFI("IPrivateWindowListener hasPrivatewindow: %{public}u", hasPrivate);}
47 };
48 class DmPrivateWindowListChangeListener : public DisplayManager::IPrivateWindowListChangeListener {
49 public:
OnPrivateWindowListChange(DisplayId displayId,std::vector<std::string> privacyWindowList)50 void OnPrivateWindowListChange(DisplayId displayId, std::vector<std::string> privacyWindowList)
51 {
52 WLOGFI("IPrivateWindowListChangeListener displayId: %{public}" PRIu64".", displayId);
53 std::string concatenatedString;
54 std::vector<std::string> result = privacyWindowList;
55 for (const auto& window : result) {
56 concatenatedString.append(window);
57 concatenatedString.append(" ");
58 }
59 WLOGFI("privacyWindowList: %{public}s", concatenatedString.c_str());
60 callback_(privacyWindowList);
61 }
setCallback(std::function<void (std::vector<std::string>)> callback)62 void setCallback(std::function<void(std::vector<std::string>)> callback)
63 {
64 callback_ = callback;
65 }
66 private:
67 std::function<void(std::vector<std::string>)> callback_;
68 };
69
70 class MockDisplayChangeListener : public IDisplayChangeListener {
71 public:
OnDisplayStateChange(DisplayId defaultDisplayId,sptr<DisplayInfo> info,const std::map<DisplayId,sptr<DisplayInfo>> & displayInfoMap,DisplayStateChangeType type)72 virtual void OnDisplayStateChange(DisplayId defaultDisplayId, sptr<DisplayInfo> info,
73 const std::map<DisplayId, sptr<DisplayInfo>>& displayInfoMap, DisplayStateChangeType type) { return; }
OnScreenshot(DisplayId displayId)74 virtual void OnScreenshot(DisplayId displayId) { return; }
75 };
76
77 class ScreenSessionManagerClientTest : public testing::Test {
78 public:
79 void SetUp() override;
80 void TearDown() override;
81 ScreenSessionManagerClient* screenSessionManagerClient_;
82 };
83
SetUp()84 void ScreenSessionManagerClientTest::SetUp()
85 {
86 screenSessionManagerClient_ = &ScreenSessionManagerClient::GetInstance();
87 }
88
TearDown()89 void ScreenSessionManagerClientTest::TearDown()
90 {
91 screenSessionManagerClient_ = nullptr;
92 }
93
94 /**
95 * @tc.name: RegisterScreenConnectionListener
96 * @tc.desc: RegisterScreenConnectionListener test
97 * @tc.type: FUNC
98 */
99 HWTEST_F(ScreenSessionManagerClientTest, RegisterScreenConnectionListener, TestSize.Level1)
100 {
101 IScreenConnectionListener* listener = nullptr;
102 screenSessionManagerClient_->RegisterScreenConnectionListener(listener);
103 EXPECT_EQ(screenSessionManagerClient_->screenConnectionListener_, nullptr);
104 }
105
106 /**
107 * @tc.name: GetScreenSession
108 * @tc.desc: GetScreenSession test
109 * @tc.type: FUNC
110 */
111 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSession, TestSize.Level1)
112 {
113 ScreenId screenId = 0;
114 sptr<ScreenSession> screenSession = nullptr;
115 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
116 EXPECT_EQ(screenSession, nullptr);
117
118 screenSession = new ScreenSession(0, ScreenProperty(), 0);
119 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
120
121 auto screenSession2 = screenSessionManagerClient_->GetScreenSession(screenId);
122 EXPECT_EQ(screenSession2, screenSession);
123
124 screenSessionManagerClient_->screenSessionMap_.clear();
125 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
126 EXPECT_EQ(screenSession, nullptr);
127 }
128
129 /**
130 * @tc.name: GetScreenSessionExtra
131 * @tc.desc: GetScreenSessionExtra test
132 * @tc.type: FUNC
133 */
134 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSessionExtra, TestSize.Level1)
135 {
136 ScreenId screenId = 0;
137 sptr<ScreenSession> screenSession = nullptr;
138 screenSession = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
139 EXPECT_EQ(screenSession, nullptr);
140
141 screenSession = new ScreenSession(0, ScreenProperty(), 0);
142 screenSessionManagerClient_->extraScreenSessionMap_.emplace(screenId, screenSession);
143
144 auto screenSession2 = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
145 EXPECT_EQ(screenSession2, screenSession);
146
147 screenSessionManagerClient_->extraScreenSessionMap_.clear();
148 screenSession = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
149 EXPECT_EQ(screenSession, nullptr);
150 }
151
152 /**
153 * @tc.name: OnScreenConnectionChanged01
154 * @tc.desc: OnScreenConnectionChanged test
155 * @tc.type: FUNC
156 */
157 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged01, TestSize.Level1)
158 {
159 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
160 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
161 screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
162 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
163
164 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
165 SessionOption option = {
166 .rsId_ = 0,
167 .isExtend_ = false,
168 .screenId_ = 0,
169 };
170 ScreenId screenId = 0;
171 screenSessionManagerClient_->OnScreenConnectionChanged(option, screenEvent);
172 sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
173 EXPECT_NE(screenSession, nullptr);
174 }
175
176 /**
177 * @tc.name: OnScreenConnectionChanged02
178 * @tc.desc: OnScreenConnectionChanged test
179 * @tc.type: FUNC
180 */
181 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged02, TestSize.Level1)
182 {
183 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
184
185 ScreenEvent screenEvent = ScreenEvent::DISCONNECTED;
186 SessionOption option = {
187 .rsId_ = 0,
188 .isExtend_ = false,
189 .screenId_ = 0,
190 };
191 ScreenId screenId = 0;
192 screenSessionManagerClient_->OnScreenConnectionChanged(option, screenEvent);
193 sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
194 EXPECT_EQ(screenSession, nullptr);
195 }
196
197 /**
198 * @tc.name: CheckIfNeedConnectScreen01
199 * @tc.desc: CheckIfNeedConnectScreen test
200 * @tc.type: FUNC
201 */
202 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen01, TestSize.Level1)
203 {
204 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
205
206 SessionOption option = {
207 .rsId_ = 0,
208 .screenId_ = 0,
209 .name_ = "HiCar",
210 };
211 ScreenId screenId = 0;
212 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
213 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
214 EXPECT_EQ(result, true);
215 }
216
217 /**
218 * @tc.name: CheckIfNeedConnectScreen02
219 * @tc.desc: CheckIfNeedConnectScreen test
220 * @tc.type: FUNC
221 */
222 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen02, TestSize.Level1)
223 {
224 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
225 SessionOption option = {
226 .rsId_ = SCREEN_ID_INVALID,
227 .screenId_ = 0,
228 .name_ = "",
229 };
230 ScreenId screenId = 0;
231 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
232 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
233 EXPECT_EQ(result, false);
234 }
235
236 /**
237 * @tc.name: CheckIfNeedConnectScreen03
238 * @tc.desc: CheckIfNeedConnectScreen test
239 * @tc.type: FUNC
240 */
241 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen03, TestSize.Level1)
242 {
243 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
244 SessionOption option = {
245 .rsId_ = 0,
246 .screenId_ = 0,
247 .name_ = "",
248 };
249 ScreenId screenId = 0;
250 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::REAL);
251 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
252 EXPECT_EQ(result, true);
253 }
254
255 /**
256 * @tc.name: CheckIfNeedConnectScreen04
257 * @tc.desc: CheckIfNeedConnectScreen test
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen04, TestSize.Level1)
261 {
262 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
263 SessionOption option = {
264 .rsId_ = 0,
265 .screenId_ = 0,
266 .name_ = "HiCar",
267 };
268 ScreenId screenId = 0;
269 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
270 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
271 EXPECT_EQ(result, true);
272 }
273
274 /**
275 * @tc.name: CheckIfNeedConnectScreen05
276 * @tc.desc: CheckIfNeedConnectScreen test
277 * @tc.type: FUNC
278 */
279 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen05, TestSize.Level1)
280 {
281 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
282 SessionOption option = {
283 .rsId_ = 0,
284 .screenId_ = 0,
285 .name_ = "SuperLauncher",
286 };
287 ScreenId screenId = 0;
288 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
289 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
290 EXPECT_EQ(result, true);
291 }
292
293 /**
294 * @tc.name: CheckIfNeedConnectScreen06
295 * @tc.desc: CheckIfNeedConnectScreen test
296 * @tc.type: FUNC
297 */
298 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen06, TestSize.Level1)
299 {
300 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
301 SessionOption option = {
302 .rsId_ = 0,
303 .screenId_ = 0,
304 .name_ = "CastEngine",
305 };
306 ScreenId screenId = 0;
307 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
308 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
309 EXPECT_EQ(result, true);
310 }
311
312 /**
313 * @tc.name: OnPowerStatusChanged
314 * @tc.desc: OnPowerStatusChanged test
315 * @tc.type: FUNC
316 */
317 HWTEST_F(ScreenSessionManagerClientTest, OnPowerStatusChanged, TestSize.Level1)
318 {
319 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
320 ScreenId screenId = 0;
321 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
322 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
323 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
324 EventStatus status = EventStatus::BEGIN;
325 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_ACCESS;
326 screenSessionManagerClient_->OnPowerStatusChanged(event, status, reason);
327 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
328 EXPECT_NE(screenSession1, nullptr);
329 }
330
331 /**
332 * @tc.name: GetAllScreensProperties
333 * @tc.desc: GetAllScreensProperties test
334 * @tc.type: FUNC
335 */
336 HWTEST_F(ScreenSessionManagerClientTest, GetAllScreensProperties, TestSize.Level1)
337 {
338 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
339 screenSessionManagerClient_->screenSessionMap_.clear();
340 ScreenId screenId = 0;
341 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
342 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
343 EXPECT_EQ(1, screenSessionManagerClient_->GetAllScreensProperties().size());
344 }
345
346 /**
347 * @tc.name: SetPrivacyStateByDisplayId01
348 * @tc.desc: SetPrivacyStateByDisplayId01 test
349 * @tc.type: FUNC
350 */
351 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId01, TestSize.Level1)
352 {
353 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
354 screenSessionManagerClient_->screenSessionManager_ = nullptr;
355 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
356 screenSessionManagerClient_->ConnectToServer();
357 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
358
359 sptr<DisplayManager::IPrivateWindowListener> displayListener_ = new DmPrivateWindowListener();
360 DisplayManager::GetInstance().RegisterPrivateWindowListener(displayListener_);
361
362 DisplayId id = 0;
363 bool hasPrivate = true;
364 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
365
366 bool result = false;
367 screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
368 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
369 EXPECT_EQ(result, true);
370 } else {
371 EXPECT_NE(result, true);
372 }
373 }
374
375 /**
376 * @tc.name: SetPrivacyStateByDisplayId02
377 * @tc.desc: SetPrivacyStateByDisplayId02 test
378 * @tc.type: FUNC
379 */
380 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId02, TestSize.Level1)
381 {
382 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
383 DisplayId id = 0;
384 bool hasPrivate = false;
385 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
386 bool result = true;
387 screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
388 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
389 EXPECT_EQ(result, false);
390 } else {
391 EXPECT_NE(result, false);
392 }
393 }
394
395 /**
396 * @tc.name: SetScreenPrivacyWindowList
397 * @tc.desc: SetScreenPrivacyWindowList test
398 * @tc.type: FUNC
399 */
400 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyWindowList, TestSize.Level1)
401 {
402 screenSessionManagerClient_->screenSessionManager_ = nullptr;
403 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
404 screenSessionManagerClient_->ConnectToServer();
405 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
406
407 DisplayId id = 0;
408 std::vector<std::string> privacyWindowList{"win0", "win1"};
409 std::vector<std::string> privacyWindowList2{"win0"};
410 sptr<DisplayManager::IPrivateWindowListChangeListener> listener_ = new DmPrivateWindowListChangeListener();
411 listener_->setCallback([privacyWindowList, privacyWindowList2](std::vector<std::string> windowList)
__anon04fad1990302(std::vector<std::string> windowList) 412 {
413 EXPECT_EQ(windowList, privacyWindowList);
414 EXPECT_NE(windowList, privacyWindowList2);
415 });
416 DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener_);
417
418 screenSessionManagerClient_->SetScreenPrivacyWindowList(id, privacyWindowList);
419 std::this_thread::sleep_for(std::chrono::milliseconds(100));
420 }
421
422 /**
423 * @tc.name: GetFoldDisplayMode01
424 * @tc.desc: GetFoldDisplayMode test
425 * @tc.type: FUNC
426 */
427 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode01, TestSize.Level1)
428 {
429 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
430 if (FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
431 EXPECT_NE(FoldDisplayMode::FULL, screenSessionManagerClient_->GetFoldDisplayMode());
432 EXPECT_NE(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
433 } else if (screenSessionManagerClient_->IsFoldable()) {
434 EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
435 EXPECT_NE(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
436 } else {
437 EXPECT_NE(FoldDisplayMode::FULL, screenSessionManagerClient_->GetFoldDisplayMode());
438 EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
439 }
440 EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
441 }
442
443 /**
444 * @tc.name: GetFoldDisplayMode02
445 * @tc.desc: GetFoldDisplayMode test
446 * @tc.type: FUNC
447 */
448 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode02, TestSize.Level1)
449 {
450 screenSessionManagerClient_->screenSessionManager_ = nullptr;
451 ScreenId screenId = 0;
452 bool foldToExpand = true;
453 DMRect area;
454 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
455 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
456 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
457 if (screenSessionManagerClient_->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
458 EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
459 } else {
460 EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
461 }
462 EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
463 EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
464 }
465
466 /**
467 * @tc.name: UpdateScreenRotationProperty
468 * @tc.desc: UpdateScreenRotationProperty test
469 * @tc.type: FUNC
470 */
471 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty, TestSize.Level1)
472 {
473 ScreenId screenId = 0;
474 ScreenId displayNodeScreenId = 0;
475 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
476 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
477 DMRect area;
478 bool foldToExpand = true;
479 RRect bounds;
480 bounds.rect_.width_ = 1344;
481 bounds.rect_.height_ = 2772;
482 float scaleX = 1.0;
483 float scaleY = 1.0;
484 ScreenDirectionInfo directionInfo;
485 directionInfo.notifyRotation_ = 90;
486 directionInfo.screenRotation_ = 90;
487 directionInfo.rotation_ = 90;
488 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
489 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
490 screenPropertyChangeType);
491 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
492 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
493 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
494 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
495 screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
496 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
497 EXPECT_NE(screenSession1, nullptr);
498 }
499
500 /**
501 * @tc.name: GetScreenSnapshot
502 * @tc.desc: GetScreenSnapshot test
503 * @tc.type: FUNC
504 */
505 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSnapshot, TestSize.Level1)
506 {
507 screenSessionManagerClient_->screenSessionMap_.clear();
508 ScreenId screenId = 0;
509 ScreenId displayNodeScreenId = 0;
510 float scaleX = 1.0;
511 float scaleY = 1.0;
512 RRect bounds;
513 bounds.rect_.width_ = 1344;
514 bounds.rect_.height_ = 2772;
515 ScreenDirectionInfo directionInfo;
516 directionInfo.notifyRotation_ = 90;
517 directionInfo.screenRotation_ = 90;
518 directionInfo.rotation_ = 90;
519 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
520 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
521 screenPropertyChangeType);
522 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
523 std::shared_ptr<Media::PixelMap> res = screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
524 EXPECT_EQ(nullptr, res);
525 }
526
527 /**
528 * @tc.name: SetScreenOffDelayTime
529 * @tc.desc: SetScreenOffDelayTime test
530 * @tc.type: FUNC
531 */
532 HWTEST_F(ScreenSessionManagerClientTest, SetScreenOffDelayTime, TestSize.Level1)
533 {
534 screenSessionManagerClient_->screenSessionManager_ = nullptr;
535 int32_t ret = screenSessionManagerClient_->SetScreenOffDelayTime(1);
536 EXPECT_EQ(ret, 0);
537 }
538
539 /**
540 * @tc.name: GetDeviceScreenConfig
541 * @tc.desc: GetDeviceScreenConfig test
542 * @tc.type: FUNC
543 */
544 HWTEST_F(ScreenSessionManagerClientTest, GetDeviceScreenConfig, TestSize.Level1)
545 {
546 DeviceScreenConfig deviceScreenConfig = screenSessionManagerClient_->GetDeviceScreenConfig();
547 EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
548 }
549
550 /**
551 * @tc.name: OnUpdateFoldDisplayMode
552 * @tc.desc: OnUpdateFoldDisplayMode test
553 * @tc.type: FUNC
554 */
555 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode, TestSize.Level1)
556 {
557 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::UNKNOWN);
558 auto ret1 = screenSessionManagerClient_->GetFoldDisplayMode();
559 EXPECT_EQ(FoldDisplayMode::UNKNOWN, ret1);
560 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::FULL);
561 auto ret2 = screenSessionManagerClient_->GetFoldDisplayMode();
562 EXPECT_EQ(FoldDisplayMode::FULL, ret2);
563 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::MAIN);
564 auto ret3 = screenSessionManagerClient_->GetFoldDisplayMode();
565 EXPECT_EQ(FoldDisplayMode::MAIN, ret3);
566 }
567
568 /**
569 * @tc.name: GetScreenSessionById
570 * @tc.desc: GetScreenSessionById test
571 * @tc.type: FUNC
572 */
573 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSessionById, TestSize.Level1)
574 {
575 ScreenId screenId = 0;
576 sptr<ScreenSession> ret = screenSessionManagerClient_->GetScreenSessionById(screenId);
577 EXPECT_EQ(nullptr, ret);
578 }
579
580 /**
581 * @tc.name: ConnectToServer01
582 * @tc.desc: ConnectToServer test
583 * @tc.type: FUNC
584 */
585 HWTEST_F(ScreenSessionManagerClientTest, ConnectToServer01, TestSize.Level1)
586 {
587 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
588
589 screenSessionManagerClient_->screenSessionManager_ = nullptr;
590 screenSessionManagerClient_->ConnectToServer();
591 }
592
593 /**
594 * @tc.name: OnPropertyChanged
595 * @tc.desc: OnPropertyChanged test
596 * @tc.type: FUNC
597 */
598 HWTEST_F(ScreenSessionManagerClientTest, OnPropertyChanged, TestSize.Level1)
599 {
600 ScreenId screenId = 0;
601 ScreenProperty property;
602 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
603
604 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
605 screenSessionManagerClient_->OnPropertyChanged(screenId, property, reason);
606 }
607
608 /**
609 * @tc.name: OnSensorRotationChanged01
610 * @tc.desc: OnSensorRotationChanged test
611 * @tc.type: FUNC
612 */
613 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged01, TestSize.Level1)
614 {
615 ScreenId screenId = 0;
616 float sensorRotation = 0;
617
618 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
619 screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
620 }
621
622 /**
623 * @tc.name: OnSensorRotationChanged02
624 * @tc.desc: OnSensorRotationChanged test
625 * @tc.type: FUNC
626 */
627 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged02, TestSize.Level1)
628 {
629 ScreenId screenId = 1;
630 float sensorRotation = 90.0f;
631
632 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
633 screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
634 }
635
636 /**
637 * @tc.name: OnHoverStatusChanged01
638 * @tc.desc: OnHoverStatusChanged test
639 * @tc.type: FUNC
640 */
641 HWTEST_F(ScreenSessionManagerClientTest, OnHoverStatusChanged01, TestSize.Level1)
642 {
643 ScreenId screenId = 0;
644 int32_t hoverStatus = 0;
645
646 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
647 screenSessionManagerClient_->OnHoverStatusChanged(screenId, hoverStatus);
648 }
649
650 /**
651 * @tc.name: OnScreenOrientationChanged01
652 * @tc.desc: OnScreenOrientationChanged test
653 * @tc.type: FUNC
654 */
655 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged01, TestSize.Level1)
656 {
657 ScreenId screenId = 0;
658 float screenOrientation = 0;
659
660 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
661 screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
662 }
663
664 /**
665 * @tc.name: OnScreenOrientationChanged02
666 * @tc.desc: OnScreenOrientationChanged test
667 * @tc.type: FUNC
668 */
669 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged02, TestSize.Level1)
670 {
671 ScreenId screenId = 1;
672 float screenOrientation = 90.0f;
673
674 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
675 screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
676 }
677
678 /**
679 * @tc.name: OnScreenRotationLockedChanged01
680 * @tc.desc: OnScreenRotationLockedChanged test
681 * @tc.type: FUNC
682 */
683 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged01, TestSize.Level1)
684 {
685 ScreenId screenId = 0;
686 bool isLocked = false;
687
688 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
689 screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
690 }
691
692 /**
693 * @tc.name: OnScreenRotationLockedChanged02
694 * @tc.desc: OnScreenRotationLockedChanged test
695 * @tc.type: FUNC
696 */
697 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged02, TestSize.Level1)
698 {
699 ScreenId screenId = 1;
700 bool isLocked = true;
701
702 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
703 screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
704 }
705
706 /**
707 * @tc.name: OnSuperFoldStatusChanged
708 * @tc.desc: OnSuperFoldStatusChanged test
709 * @tc.type: FUNC
710 */
711 HWTEST_F(ScreenSessionManagerClientTest, OnSuperFoldStatusChanged, TestSize.Level1)
712 {
713 ScreenId screenId = 0;
714 SuperFoldStatus superFoldStatus = SuperFoldStatus::UNKNOWN;
715
716 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
717 screenSessionManagerClient_->OnSuperFoldStatusChanged(screenId, superFoldStatus);
718 }
719
720 /**
721 * @tc.name: RegisterDisplayChangeListener
722 * @tc.desc: RegisterDisplayChangeListener test
723 * @tc.type: FUNC
724 */
725 HWTEST_F(ScreenSessionManagerClientTest, RegisterDisplayChangeListener, TestSize.Level1)
726 {
727 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
728 screenSessionManagerClient_->RegisterDisplayChangeListener(nullptr);
729 }
730
731 /**
732 * @tc.name: OnDisplayStateChanged01
733 * @tc.desc: OnDisplayStateChanged test
734 * @tc.type: FUNC
735 */
736 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged01, TestSize.Level1)
737 {
738 DisplayId defaultDisplayId = 0;
739 sptr<DisplayInfo> displayInfo = new DisplayInfo();
740 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
741 { displayInfo->GetDisplayId(), displayInfo },
742 };
743 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
744
745 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
746 screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
747 }
748
749 /**
750 * @tc.name: OnDisplayStateChanged02
751 * @tc.desc: OnDisplayStateChanged test
752 * @tc.type: FUNC
753 */
754 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged02, TestSize.Level1)
755 {
756 DisplayId defaultDisplayId = 0;
757 sptr<DisplayInfo> displayInfo = new DisplayInfo();
758 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
759 { displayInfo->GetDisplayId(), displayInfo },
760 };
761 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
762
763 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
764 screenSessionManagerClient_->displayChangeListener_ = nullptr;
765 screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
766 }
767
768 /**
769 * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged01
770 * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
771 * @tc.type: FUNC
772 */
773 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged01, TestSize.Level1)
774 {
775 std::vector<uint64_t> missionIds = {0, 1};
776 std::vector<uint64_t> surfaceNodeIds;
777 bool isBlackList = false;
778
779 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
780 screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
781 }
782
783 /**
784 * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged02
785 * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
786 * @tc.type: FUNC
787 */
788 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged02, TestSize.Level1)
789 {
790 std::vector<uint64_t> missionIds = {0, 1};
791 std::vector<uint64_t> surfaceNodeIds;
792 bool isBlackList = false;
793
794 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
795 screenSessionManagerClient_->displayChangeListener_ = nullptr;
796 screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
797 }
798
799 /**
800 * @tc.name: OnSetSurfaceNodeIdsChanged01
801 * @tc.desc: OnSetSurfaceNodeIdsChanged test
802 * @tc.type: FUNC
803 */
804 HWTEST_F(ScreenSessionManagerClientTest, OnSetSurfaceNodeIdsChanged01, TestSize.Level1)
805 {
806 sptr<ScreenSessionManagerClient> client = sptr<ScreenSessionManagerClient>::MakeSptr();
807 ASSERT_NE(nullptr, client);
808
809 DisplayId displayId = 0;
810 std::vector<uint64_t> surfaceNodeIds = { 100, 101 };
811 sptr<MockDisplayChangeListener> listener = sptr<MockDisplayChangeListener>::MakeSptr();
812 client->displayChangeListener_ = listener;
813 client->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
814
815 client->displayChangeListener_ = nullptr;
816 client->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
817 }
818
819 /**
820 * @tc.name: OnVirtualScreenDisconnected01
821 * @tc.desc: OnVirtualScreenDisconnected test
822 * @tc.type: FUNC
823 */
824 HWTEST_F(ScreenSessionManagerClientTest, OnVirtualScreenDisconnected01, TestSize.Level1)
825 {
826 sptr<ScreenSessionManagerClient> client = sptr<ScreenSessionManagerClient>::MakeSptr();
827 ASSERT_NE(nullptr, client);
828
829 DisplayId displayId = 0;
830 sptr<MockDisplayChangeListener> listener = sptr<MockDisplayChangeListener>::MakeSptr();
831 client->displayChangeListener_ = listener;
832 client->OnVirtualScreenDisconnected(displayId);
833
834 client->displayChangeListener_ = nullptr;
835 client->OnVirtualScreenDisconnected(displayId);
836 }
837
838 /**
839 * @tc.name: OnScreenshot01
840 * @tc.desc: OnScreenshot test
841 * @tc.type: FUNC
842 */
843 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot01, TestSize.Level1)
844 {
845 DisplayId displayId = 0;
846
847 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
848 screenSessionManagerClient_->OnScreenshot(displayId);
849 }
850
851 /**
852 * @tc.name: OnScreenshot02
853 * @tc.desc: OnScreenshot test
854 * @tc.type: FUNC
855 */
856 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot02, TestSize.Level1)
857 {
858 DisplayId displayId = 0;
859
860 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
861 screenSessionManagerClient_->displayChangeListener_ = nullptr;
862 screenSessionManagerClient_->OnScreenshot(displayId);
863 }
864
865 /**
866 * @tc.name: OnImmersiveStateChanged01
867 * @tc.desc: OnImmersiveStateChanged test
868 * @tc.type: FUNC
869 */
870 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged01, TestSize.Level1)
871 {
872 bool immersive = false;
873
874 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
875 screenSessionManagerClient_->OnImmersiveStateChanged(0u, immersive);
876 }
877
878 /**
879 * @tc.name: OnImmersiveStateChanged02
880 * @tc.desc: OnImmersiveStateChanged test
881 * @tc.type: FUNC
882 */
883 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged02, TestSize.Level1)
884 {
885 bool immersive = false;
886
887 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
888 screenSessionManagerClient_->displayChangeListener_ = nullptr;
889 screenSessionManagerClient_->OnImmersiveStateChanged(0u, immersive);
890 }
891
892 /**
893 * @tc.name: SetDisplayNodeScreenId
894 * @tc.desc: SetDisplayNodeScreenId test
895 * @tc.type: FUNC
896 */
897 HWTEST_F(ScreenSessionManagerClientTest, SetDisplayNodeScreenId, TestSize.Level1)
898 {
899 ScreenId screenId = 0;
900 ScreenId displayNodeScreenId = 0;
901
902 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
903 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
904 }
905
906 /**
907 * @tc.name: GetCurvedCompressionArea
908 * @tc.desc: GetCurvedCompressionArea test
909 * @tc.type: FUNC
910 */
911 HWTEST_F(ScreenSessionManagerClientTest, GetCurvedCompressionArea, TestSize.Level1)
912 {
913 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
914 screenSessionManagerClient_->GetCurvedCompressionArea();
915 }
916
917 /**
918 * @tc.name: GetPhyScreenProperty
919 * @tc.desc: GetPhyScreenProperty test
920 * @tc.type: FUNC
921 */
922 HWTEST_F(ScreenSessionManagerClientTest, GetPhyScreenProperty, TestSize.Level1)
923 {
924 ScreenId screenId = 0;
925 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
926 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
927 }
928
929 /**
930 * @tc.name: NotifyDisplayChangeInfoChanged
931 * @tc.desc: NotifyDisplayChangeInfoChanged test
932 * @tc.type: FUNC
933 */
934 HWTEST_F(ScreenSessionManagerClientTest, NotifyDisplayChangeInfoChanged, TestSize.Level1)
935 {
936 sptr<DisplayChangeInfo> info = new DisplayChangeInfo();
937 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
938 screenSessionManagerClient_->NotifyDisplayChangeInfoChanged(info);
939 }
940
941 /**
942 * @tc.name: SetScreenPrivacyState01
943 * @tc.desc: SetScreenPrivacyState test
944 * @tc.type: FUNC
945 */
946 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState01, TestSize.Level1)
947 {
948 bool hasPrivate = false;
949 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
950 screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
951 }
952
953 /**
954 * @tc.name: SetScreenPrivacyState02
955 * @tc.desc: SetScreenPrivacyState test
956 * @tc.type: FUNC
957 */
958 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState02, TestSize.Level1)
959 {
960 bool hasPrivate = false;
961 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
962 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
963 screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
964 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
965 screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
966 }
967
968 /**
969 * @tc.name: SetPrivacyStateByDisplayId
970 * @tc.desc: SetPrivacyStateByDisplayId test
971 * @tc.type: FUNC
972 */
973 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId, TestSize.Level1)
974 {
975 DisplayId id = 0;
976 bool hasPrivate = false;
977 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
978 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
979 }
980
981 /**
982 * @tc.name: UpdateAvailableArea
983 * @tc.desc: UpdateAvailableArea test
984 * @tc.type: FUNC
985 */
986 HWTEST_F(ScreenSessionManagerClientTest, UpdateAvailableArea, TestSize.Level1)
987 {
988 ScreenId screenId = 0;
989 DMRect area;
990
991 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
992 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
993 }
994
995 /**
996 * @tc.name: NotifyFoldToExpandCompletion
997 * @tc.desc: NotifyFoldToExpandCompletion test
998 * @tc.type: FUNC
999 */
1000 HWTEST_F(ScreenSessionManagerClientTest, NotifyFoldToExpandCompletion, TestSize.Level1)
1001 {
1002 bool foldToExpand = true;
1003
1004 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1005 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
1006 }
1007
1008 /**
1009 * @tc.name: NotifyScreenConnectCompletion
1010 * @tc.desc: NotifyScreenConnectCompletion test
1011 * @tc.type: FUNC
1012 */
1013 HWTEST_F(ScreenSessionManagerClientTest, NotifyScreenConnectCompletion, TestSize.Level1)
1014 {
1015 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1016 screenSessionManagerClient_->NotifyScreenConnectCompletion(1001);
1017 }
1018
1019 /**
1020 * @tc.name: SwitchUserCallback01
1021 * @tc.desc: SwitchUserCallback test
1022 * @tc.type: FUNC
1023 */
1024 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback01, TestSize.Level1)
1025 {
1026 std::vector<int32_t> oldScbPids = {0, 1};
1027 int32_t currentScbPid = 1;
1028
1029 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1030 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
1031 }
1032
1033 /**
1034 * @tc.name: SwitchUserCallback02
1035 * @tc.desc: SwitchUserCallback test
1036 * @tc.type: FUNC
1037 */
1038 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback02, TestSize.Level1)
1039 {
1040 std::vector<int32_t> oldScbPids = {};
1041 int32_t currentScbPid = 1;
1042
1043 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1044 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
1045 }
1046
1047 /**
1048 * @tc.name: SwitchUserCallback03
1049 * @tc.desc: SwitchUserCallback test
1050 * @tc.type: FUNC
1051 */
1052 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback03, TestSize.Level1)
1053 {
1054 logMsg.clear();
1055 LOG_SetCallback(MyLogCallback);
1056 std::vector<int32_t> oldScbPids = {0};
1057 int32_t currentScbPid = 1;
1058 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1059 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1060 screenSessionManagerClient_->screenSessionManager_ = sptr<ScreenSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1061 ScreenId screenId = 1234;
1062 sptr<ScreenSession> screenSession = nullptr;
1063 screenSessionManagerClient_->screenSessionMap_.insert({screenId, screenSession});
1064 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
1065 EXPECT_TRUE(logMsg.find("screenSession is null") != std::string::npos);
1066 logMsg.clear();
1067 screenSession = sptr<ScreenSession>::MakeSptr(screenId, ScreenProperty(), 0);
1068 screenSessionManagerClient_->screenSessionMap_.erase(screenId);
1069 screenSessionManagerClient_->screenSessionMap_.insert({screenId, screenSession});
1070 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
1071 EXPECT_FALSE(logMsg.find("screenSession is null") != std::string::npos);
1072 screenSessionManagerClient_->screenSessionMap_.erase(screenId);
1073 logMsg.clear();
1074 }
1075
1076 /**
1077 * @tc.name: SwitchingCurrentUser
1078 * @tc.desc: SwitchingCurrentUser test
1079 * @tc.type: FUNC
1080 */
1081 HWTEST_F(ScreenSessionManagerClientTest, SwitchingCurrentUser, TestSize.Level1)
1082 {
1083 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1084 screenSessionManagerClient_->SwitchingCurrentUser();
1085 }
1086
1087 /**
1088 * @tc.name: GetFoldStatus
1089 * @tc.desc: GetFoldStatus test
1090 * @tc.type: FUNC
1091 */
1092 HWTEST_F(ScreenSessionManagerClientTest, GetFoldStatus, TestSize.Level1)
1093 {
1094 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1095 screenSessionManagerClient_->GetFoldStatus();
1096 }
1097
1098 /**
1099 * @tc.name: GetSuperFoldStatus
1100 * @tc.desc: GetSuperFoldStatus test
1101 * @tc.type: FUNC
1102 */
1103 HWTEST_F(ScreenSessionManagerClientTest, GetSuperFoldStatus, TestSize.Level1)
1104 {
1105 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1106 screenSessionManagerClient_->GetSuperFoldStatus();
1107 }
1108
1109 /**
1110 * @tc.name: SetLandscapeLockStatus
1111 * @tc.desc: SetLandscapeLockStatus test
1112 * @tc.type: FUNC
1113 */
1114 HWTEST_F(ScreenSessionManagerClientTest, SetLandscapeLockStatus, Function | SmallTest | Level2)
1115 {
1116 bool isLocked = false;
1117 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1118 screenSessionManagerClient_->SetLandscapeLockStatus(isLocked);
1119 }
1120
1121 /**
1122 * @tc.name: GetDefaultScreenId
1123 * @tc.desc: GetDefaultScreenId test
1124 * @tc.type: FUNC
1125 */
1126 HWTEST_F(ScreenSessionManagerClientTest, GetDefaultScreenId, TestSize.Level1)
1127 {
1128 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1129 screenSessionManagerClient_->GetDefaultScreenId();
1130 }
1131
1132 /**
1133 * @tc.name: IsFoldable
1134 * @tc.desc: IsFoldable test
1135 * @tc.type: FUNC
1136 */
1137 HWTEST_F(ScreenSessionManagerClientTest, IsFoldable, TestSize.Level1)
1138 {
1139 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1140 screenSessionManagerClient_->IsFoldable();
1141 }
1142
1143 /**
1144 * @tc.name: SetVirtualPixelRatioSystem
1145 * @tc.desc: SetVirtualPixelRatioSystem test
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(ScreenSessionManagerClientTest, SetVirtualPixelRatioSystem, TestSize.Level1)
1149 {
1150 ScreenId screenId = 0;
1151 float virtualPixelRatio = 1.0f;
1152
1153 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1154 screenSessionManagerClient_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
1155 }
1156
1157 /**
1158 * @tc.name: UpdateDisplayHookInfo
1159 * @tc.desc: UpdateDisplayHookInfo test
1160 * @tc.type: FUNC
1161 */
1162 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayHookInfo, TestSize.Level1)
1163 {
1164 int32_t uid = 0;
1165 bool enable = false;
1166 DMHookInfo hookInfo;
1167 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1168 screenSessionManagerClient_->UpdateDisplayHookInfo(uid, enable, hookInfo);
1169 }
1170
1171 HWTEST_F(ScreenSessionManagerClientTest, GetDisplayHookInfo, Function | SmallTest | Level2)
1172 {
1173 int32_t uid = 0;
1174 DMHookInfo hookInfo;
1175 hookInfo.enableHookRotation_ = true;
1176 hookInfo.rotation_ = true;
1177 hookInfo.density_ = 1.1;
1178 hookInfo.width_ = 100;
1179 hookInfo.height_ = 200;
1180 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1181 screenSessionManagerClient_->UpdateDisplayHookInfo(uid, true, hookInfo);
1182 screenSessionManagerClient_->GetDisplayHookInfo(uid, hookInfo);
1183 ASSERT_TRUE(hookInfo.enableHookRotation_);
1184 ASSERT_TRUE(hookInfo.rotation_);
1185 ASSERT_EQ(hookInfo.width_, 100);
1186 ASSERT_EQ(hookInfo.height_, 200);
1187 }
1188
1189 /**
1190 * @tc.name: OnFoldStatusChangedReportUE
1191 * @tc.desc: OnFoldStatusChangedReportUE test
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(ScreenSessionManagerClientTest, OnFoldStatusChangedReportUE, TestSize.Level1)
1195 {
1196 std::vector<std::string> screenFoldInfo;
1197
1198 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1199 screenSessionManagerClient_->OnFoldStatusChangedReportUE(screenFoldInfo);
1200 }
1201
1202 /**
1203 * @tc.name: UpdateDisplayScale01
1204 * @tc.desc: UpdateDisplayScale test
1205 * @tc.type: FUNC
1206 */
1207 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale01, TestSize.Level1)
1208 {
1209 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1210 const float scaleX = 1.0f;
1211 const float scaleY = 1.0f;
1212 const float pivotX = 0.5f;
1213 const float pivotY = 0.5f;
1214 const float translateX = 0.0f;
1215 const float translateY = 0.0f;
1216 ScreenId defaultScreenId = screenSessionManagerClient_->GetDefaultScreenId();
1217 screenSessionManagerClient_->UpdateDisplayScale(defaultScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1218 translateY);
1219 }
1220
1221 /**
1222 * @tc.name: UpdateDisplayScale02
1223 * @tc.desc: UpdateDisplayScale test
1224 * @tc.type: FUNC
1225 */
1226 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale02, TestSize.Level1)
1227 {
1228 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1229 const float scaleX = 1.0f;
1230 const float scaleY = 1.0f;
1231 const float pivotX = 0.5f;
1232 const float pivotY = 0.5f;
1233 const float translateX = 0.0f;
1234 const float translateY = 0.0f;
1235 uint64_t fakeScreenId = 100;
1236 screenSessionManagerClient_->UpdateDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1237 translateY);
1238 }
1239
1240 /**
1241 * @tc.name: RegisterScreenConnectionListener02
1242 * @tc.desc: RegisterScreenConnectionListener test
1243 * @tc.type: FUNC
1244 */
1245 HWTEST_F(ScreenSessionManagerClientTest, RegisterScreenConnectionListener02, TestSize.Level1)
1246 {
1247 IScreenConnectionListener* listener = nullptr;
1248 screenSessionManagerClient_->RegisterScreenConnectionListener(listener);
1249 EXPECT_EQ(screenSessionManagerClient_->screenConnectionListener_, nullptr);
1250 }
1251
1252 /**
1253 * @tc.name: GetScreenSession02
1254 * @tc.desc: GetScreenSession test
1255 * @tc.type: FUNC
1256 */
1257 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSession02, TestSize.Level1)
1258 {
1259 ScreenId screenId = 0;
1260 sptr<ScreenSession> screenSession = nullptr;
1261 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
1262 EXPECT_EQ(screenSession, nullptr);
1263
1264 screenSession = new ScreenSession(0, ScreenProperty(), 0);
1265 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1266
1267 auto screenSession2 = screenSessionManagerClient_->GetScreenSession(screenId);
1268 EXPECT_EQ(screenSession2, screenSession);
1269
1270 screenSessionManagerClient_->screenSessionMap_.clear();
1271 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
1272 EXPECT_EQ(screenSession, nullptr);
1273 }
1274
1275 /**
1276 * @tc.name: SwitchingCurrentUser02
1277 * @tc.desc: SwitchingCurrentUser test
1278 * @tc.type: FUNC
1279 */
1280 HWTEST_F(ScreenSessionManagerClientTest, SwitchingCurrentUser02, TestSize.Level1)
1281 {
1282 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1283 screenSessionManagerClient_->SwitchingCurrentUser();
1284 }
1285
1286 /**
1287 * @tc.name: GetFoldStatus02
1288 * @tc.desc: GetFoldStatus test
1289 * @tc.type: FUNC
1290 */
1291 HWTEST_F(ScreenSessionManagerClientTest, GetFoldStatus02, TestSize.Level1)
1292 {
1293 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1294 screenSessionManagerClient_->GetFoldStatus();
1295 }
1296
1297 /**
1298 * @tc.name: GetDefaultScreenId02
1299 * @tc.desc: GetDefaultScreenId test
1300 * @tc.type: FUNC
1301 */
1302 HWTEST_F(ScreenSessionManagerClientTest, GetDefaultScreenId02, TestSize.Level1)
1303 {
1304 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1305 screenSessionManagerClient_->GetDefaultScreenId();
1306 }
1307
1308 /**
1309 * @tc.name: IsFoldable02
1310 * @tc.desc: IsFoldable test
1311 * @tc.type: FUNC
1312 */
1313 HWTEST_F(ScreenSessionManagerClientTest, IsFoldable02, TestSize.Level1)
1314 {
1315 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1316 screenSessionManagerClient_->IsFoldable();
1317 }
1318
1319 /**
1320 * @tc.name: SetVirtualPixelRatioSystem02
1321 * @tc.desc: SetVirtualPixelRatioSystem test
1322 * @tc.type: FUNC
1323 */
1324 HWTEST_F(ScreenSessionManagerClientTest, SetVirtualPixelRatioSystem02, TestSize.Level1)
1325 {
1326 ScreenId screenId = 0;
1327 float virtualPixelRatio = 1.0f;
1328
1329 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1330 screenSessionManagerClient_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
1331 }
1332
1333 /**
1334 * @tc.name: UpdateDisplayHookInfo02
1335 * @tc.desc: UpdateDisplayHookInfo test
1336 * @tc.type: FUNC
1337 */
1338 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayHookInfo02, TestSize.Level1)
1339 {
1340 int32_t uid = 0;
1341 bool enable = false;
1342 DMHookInfo hookInfo;
1343 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1344 screenSessionManagerClient_->UpdateDisplayHookInfo(uid, enable, hookInfo);
1345 }
1346
1347 /**
1348 * @tc.name: OnFoldStatusChangedReportUE02
1349 * @tc.desc: OnFoldStatusChangedReportUE test
1350 * @tc.type: FUNC
1351 */
1352 HWTEST_F(ScreenSessionManagerClientTest, OnFoldStatusChangedReportUE02, TestSize.Level1)
1353 {
1354 std::vector<std::string> screenFoldInfo;
1355
1356 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1357 screenSessionManagerClient_->OnFoldStatusChangedReportUE(screenFoldInfo);
1358 }
1359
1360 /**
1361 * @tc.name: SetPrivacyStateByDisplayId03
1362 * @tc.desc: SetPrivacyStateByDisplayId test
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId03, TestSize.Level1)
1366 {
1367 DisplayId id = 0;
1368 bool hasPrivate = false;
1369 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1370 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
1371 }
1372
1373 /**
1374 * @tc.name: UpdateAvailableArea02
1375 * @tc.desc: UpdateAvailableArea test
1376 * @tc.type: FUNC
1377 */
1378 HWTEST_F(ScreenSessionManagerClientTest, UpdateAvailableArea02, TestSize.Level1)
1379 {
1380 ScreenId screenId = 0;
1381 DMRect area;
1382
1383 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1384 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
1385 }
1386
1387 /**
1388 * @tc.name: NotifyFoldToExpandCompletion02
1389 * @tc.desc: NotifyFoldToExpandCompletion test
1390 * @tc.type: FUNC
1391 */
1392 HWTEST_F(ScreenSessionManagerClientTest, NotifyFoldToExpandCompletion02, TestSize.Level1)
1393 {
1394 bool foldToExpand = true;
1395
1396 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1397 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
1398 }
1399
1400 /**
1401 * @tc.name: OnPowerStatusChanged02
1402 * @tc.desc: OnPowerStatusChanged test
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(ScreenSessionManagerClientTest, OnPowerStatusChanged02, TestSize.Level1)
1406 {
1407 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1408 ScreenId screenId = 0;
1409 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
1410 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1411 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
1412 EventStatus status = EventStatus::BEGIN;
1413 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_ACCESS;
1414 screenSessionManagerClient_->OnPowerStatusChanged(event, status, reason);
1415 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
1416 EXPECT_NE(screenSession1, nullptr);
1417 }
1418
1419 /**
1420 * @tc.name: GetAllScreensProperties02
1421 * @tc.desc: GetAllScreensProperties test
1422 * @tc.type: FUNC
1423 */
1424 HWTEST_F(ScreenSessionManagerClientTest, GetAllScreensProperties02, TestSize.Level1)
1425 {
1426 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1427 screenSessionManagerClient_->screenSessionMap_.clear();
1428 ScreenId screenId = 0;
1429 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
1430 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1431 EXPECT_EQ(1, screenSessionManagerClient_->GetAllScreensProperties().size());
1432 }
1433
1434 /**
1435 * @tc.name: SetScreenPrivacyWindowList02
1436 * @tc.desc: SetScreenPrivacyWindowList test
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyWindowList02, TestSize.Level1)
1440 {
1441 screenSessionManagerClient_->screenSessionManager_ = nullptr;
1442 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
1443 screenSessionManagerClient_->ConnectToServer();
1444 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1445
1446 DisplayId id = 0;
1447 std::vector<std::string> privacyWindowList{"win0", "win1"};
1448 std::vector<std::string> privacyWindowList2{"win0"};
1449 sptr<DisplayManager::IPrivateWindowListChangeListener> listener_ = new DmPrivateWindowListChangeListener();
1450 listener_->setCallback([privacyWindowList, privacyWindowList2](std::vector<std::string> windowList)
__anon04fad1990402(std::vector<std::string> windowList) 1451 {
1452 EXPECT_EQ(windowList, privacyWindowList);
1453 EXPECT_NE(windowList, privacyWindowList2);
1454 });
1455 DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener_);
1456
1457 screenSessionManagerClient_->SetScreenPrivacyWindowList(id, privacyWindowList);
1458 std::this_thread::sleep_for(std::chrono::milliseconds(100));
1459 }
1460
1461 /**
1462 * @tc.name: UpdateScreenRotationProperty02
1463 * @tc.desc: UpdateScreenRotationProperty test
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty02, TestSize.Level1)
1467 {
1468 ScreenId screenId = 0;
1469 ScreenId displayNodeScreenId = 0;
1470 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
1471 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1472 DMRect area;
1473 bool foldToExpand = true;
1474 RRect bounds;
1475 bounds.rect_.width_ = 1344;
1476 bounds.rect_.height_ = 2772;
1477 float scaleX = 1.0;
1478 float scaleY = 1.0;
1479 ScreenDirectionInfo directionInfo;
1480 directionInfo.notifyRotation_ = 90;
1481 directionInfo.screenRotation_ = 90;
1482 directionInfo.rotation_ = 90;
1483 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
1484 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
1485 screenPropertyChangeType);
1486 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
1487 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
1488 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
1489 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
1490 screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
1491 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
1492 EXPECT_NE(screenSession1, nullptr);
1493 }
1494
1495 /**
1496 * @tc.name: ScreenCaptureNotify
1497 * @tc.desc: ScreenCaptureNotify test
1498 * @tc.type: FUNC
1499 */
1500 HWTEST_F(ScreenSessionManagerClientTest, ScreenCaptureNotify, TestSize.Level1)
1501 {
1502 ScreenId screenId = 0;
1503 int32_t uid = 0;
1504 std::string clientName = "test";
1505 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1506 screenSessionManagerClient_->ScreenCaptureNotify(screenId, uid, clientName);
1507 }
1508
1509 /**
1510 * @tc.name: HandleScreenConnection
1511 * @tc.desc: HandleScreenConnection test
1512 * @tc.type: FUNC
1513 */
1514 HWTEST_F(ScreenSessionManagerClientTest, HandleScreenConnection, TestSize.Level2)
1515 {
1516 SessionOption option1 = {
1517 .rsId_ = -1ULL,
1518 };
1519 screenSessionManagerClient_->HandleScreenConnection(option1);
1520
1521 VirtualScreenOption virtualOption;
1522 virtualOption.name_ = "createVirtualOption";
1523 auto screenId = screenSessionManagerClient_->screenSessionManager_->
1524 CreateVirtualScreen(virtualOption, nullptr);
1525 SessionOption option2 = {
1526 .name_ = "HiCar",
1527 .screenId_ = screenId,
1528 };
1529 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1530 screenSessionManagerClient_->HandleScreenConnection(option2);
1531 }
1532
1533 /**
1534 * @tc.name: HandleScreenDisconnection
1535 * @tc.desc: HandleScreenDisconnection test
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(ScreenSessionManagerClientTest, HandleScreenDisconnection, TestSize.Level2)
1539 {
1540 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1541 ASSERT_TRUE(client != nullptr);
1542
1543 sptr<ScreenSession> screenSession1 = new ScreenSession(50, ScreenProperty(), 0);
1544 ASSERT_NE(nullptr, screenSession1);
1545 client->screenSessionMap_[50] = screenSession1;
1546
1547 SessionOption option = {
1548 .screenId_ = 50,
1549 };
1550 client->HandleScreenDisconnection(option);
1551 SessionOption option1 = {
1552 .screenId_ = 51,
1553 };
1554 ASSERT_TRUE(client != nullptr);
1555 client->HandleScreenDisconnection(option1);
1556 }
1557
1558 /**
1559 * @tc.name: OnCreateScreenSessionOnly
1560 * @tc.desc: OnCreateScreenSessionOnly test
1561 * @tc.type: FUNC
1562 */
1563 HWTEST_F(ScreenSessionManagerClientTest, OnCreateScreenSessionOnly, TestSize.Level2)
1564 {
1565 sptr<ScreenSessionManagerClient> client = sptr<ScreenSessionManagerClient>::MakeSptr();
1566 client->ConnectToServer();
1567
1568 sptr<ScreenSession> screenSession1 = sptr<ScreenSession>::MakeSptr(50, ScreenProperty(), 0);
1569 ASSERT_NE(nullptr, screenSession1);
1570 client->screenSessionMap_[50] = screenSession1;
1571
1572 sptr<ScreenSession> screenSession2 = nullptr;
1573 client->screenSessionMap_[51] = screenSession2;
1574
1575 auto ret = client->OnCreateScreenSessionOnly(50, 50, "test1", true);
1576 EXPECT_EQ(ret, true);
1577
1578 ret = client->OnCreateScreenSessionOnly(51, 51, "test2", true);
1579 EXPECT_EQ(ret, true);
1580
1581 ret = client->OnCreateScreenSessionOnly(52, 52, "test3", true);
1582 EXPECT_EQ(ret, true);
1583 }
1584
1585 /**
1586 * @tc.name: OnExtendDisplayNodeChange
1587 * @tc.desc: OnExtendDisplayNodeChange test
1588 * @tc.type: FUNC
1589 */
1590 HWTEST_F(ScreenSessionManagerClientTest, OnExtendDisplayNodeChange, TestSize.Level2)
1591 {
1592 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1593 screenSessionManagerClient_->ConnectToServer();
1594
1595 RSDisplayNodeConfig config;
1596 std::shared_ptr<RSDisplayNode> node = std::make_shared<RSDisplayNode>(config);
1597 sptr<ScreenSession> screenSession1 = new ScreenSession(50, 50, "test1", ScreenProperty(), node);
1598 ASSERT_NE(nullptr, screenSession1);
1599 screenSessionManagerClient_->screenSessionMap_[50] = screenSession1;
1600
1601 sptr<ScreenSession> screenSession2 = new ScreenSession(51, 51, "test1", ScreenProperty(), node);
1602 ASSERT_NE(nullptr, screenSession2);
1603 screenSessionManagerClient_->screenSessionMap_[51] = screenSession2;
1604
1605 sptr<ScreenSession> screenSession3 = new ScreenSession(52, 52, "test1", ScreenProperty(), nullptr);
1606 ASSERT_NE(nullptr, screenSession3);
1607 screenSessionManagerClient_->screenSessionMap_[52] = screenSession3;
1608
1609 sptr<ScreenSession> screenSession4 = nullptr;
1610 screenSessionManagerClient_->screenSessionMap_[53] = screenSession4;
1611
1612 auto ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(50, 53);
1613 EXPECT_EQ(ret, false);
1614
1615 ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(53, 50);
1616 EXPECT_EQ(ret, false);
1617
1618 ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(50, 52);
1619 EXPECT_EQ(ret, false);
1620
1621 ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(52, 52);
1622 EXPECT_EQ(ret, false);
1623
1624 ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(52, 50);
1625 EXPECT_EQ(ret, false);
1626
1627 ret = screenSessionManagerClient_->OnExtendDisplayNodeChange(51, 50);
1628 EXPECT_EQ(ret, true);
1629 }
1630
1631 /**
1632 * @tc.name: OnMainDisplayNodeChange
1633 * @tc.desc: OnMainDisplayNodeChange test
1634 * @tc.type: FUNC
1635 */
1636 HWTEST_F(ScreenSessionManagerClientTest, OnMainDisplayNodeChange, TestSize.Level2)
1637 {
1638 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1639 screenSessionManagerClient_->screenSessionManager_ = nullptr;
1640 auto ret = screenSessionManagerClient_->OnMainDisplayNodeChange(53, 50, 50);
1641 EXPECT_EQ(ret, false);
1642
1643 screenSessionManagerClient_->screenSessionManager_ = sptr<ScreenSessionManagerProxyMock>::MakeSptr();
1644 RSDisplayNodeConfig config;
1645 std::shared_ptr<RSDisplayNode> node1 = std::make_shared<RSDisplayNode>(config);
1646 std::shared_ptr<RSDisplayNode> node2 = std::make_shared<RSDisplayNode>(config);
1647 sptr<ScreenSession> screenSession1 = new ScreenSession(50, 50, "test1", ScreenProperty(), node1);
1648 ASSERT_NE(nullptr, screenSession1);
1649 screenSessionManagerClient_->screenSessionMap_[50] = screenSession1;
1650
1651 sptr<ScreenSession> screenSession2 = new ScreenSession(51, 51, "test1", ScreenProperty(), node2);
1652 ASSERT_NE(nullptr, screenSession2);
1653 screenSessionManagerClient_->screenSessionMap_[51] = screenSession2;
1654
1655 sptr<ScreenSession> screenSession3 = new ScreenSession(52, 52, "test1", ScreenProperty(), nullptr);
1656 ASSERT_NE(nullptr, screenSession3);
1657 screenSessionManagerClient_->screenSessionMap_[52] = screenSession3;
1658
1659 sptr<ScreenSession> screenSession4 = nullptr;
1660 screenSessionManagerClient_->screenSessionMap_[53] = screenSession4;
1661
1662 ret = screenSessionManagerClient_->OnMainDisplayNodeChange(53, 50, 50);
1663 EXPECT_EQ(ret, false);
1664
1665 ret = screenSessionManagerClient_->OnMainDisplayNodeChange(50, 52, 52);
1666 EXPECT_EQ(ret, false);
1667
1668 ret = screenSessionManagerClient_->OnMainDisplayNodeChange(52, 50, 50);
1669 EXPECT_EQ(ret, false);
1670
1671 ret = screenSessionManagerClient_->OnMainDisplayNodeChange(52, 52, 52);
1672 EXPECT_EQ(ret, false);
1673 }
1674
1675 /**
1676 * @tc.name: SetScreenCombination
1677 * @tc.desc: SetScreenCombination test
1678 * @tc.type: FUNC
1679 */
1680 HWTEST_F(ScreenSessionManagerClientTest, SetScreenCombination, TestSize.Level2)
1681 {
1682 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1683 ASSERT_TRUE(client != nullptr);
1684 client->ConnectToServer();
1685
1686 sptr<ScreenSession> screenSession1 = new ScreenSession(50, ScreenProperty(), 0);
1687 ASSERT_NE(nullptr, screenSession1);
1688 client->screenSessionMap_[50] = screenSession1;
1689
1690 sptr<ScreenSession> screenSession2 = nullptr;
1691 client->screenSessionMap_[51] = screenSession2;
1692
1693 ScreenCombination combination = ScreenCombination::SCREEN_EXPAND;
1694
1695 client->SetScreenCombination(51, 50, combination);
1696 client->SetScreenCombination(50, 51, combination);
1697 client->SetScreenCombination(50, 50, combination);
1698 EXPECT_NE(client, nullptr);
1699 }
1700
1701 /**
1702 * @tc.name: ExtraDestroyScreen
1703 * @tc.desc: ExtraDestroyScreen test
1704 * @tc.type: FUNC
1705 */
1706 HWTEST_F(ScreenSessionManagerClientTest, ExtraDestroyScreen, TestSize.Level2)
1707 {
1708 logMsg.clear();
1709 LOG_SetCallback(MyLogCallback);
1710
1711 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1712 ASSERT_TRUE(client != nullptr);
1713 client->ConnectToServer();
1714
1715 ScreenId screenId = 1;
1716 sptr<ScreenSession> screenSession1 = new ScreenSession(screenId, ScreenProperty(), 0);
1717 ASSERT_NE(nullptr, screenSession1);
1718 client->extraScreenSessionMap_.emplace(screenId, screenSession1);
1719
1720 ScreenId screenId11 = 11;
1721 client->extraScreenSessionMap_.emplace(screenId11, nullptr);
1722 client->ExtraDestroyScreen(screenId11);
1723 EXPECT_TRUE(logMsg.find("extra screenSession is null") != std::string::npos);
1724 }
1725
1726 /**
1727 * @tc.name: OnDumperClientScreenSessions
1728 * @tc.desc: OnDumperClientScreenSessions test
1729 * @tc.type: FUNC
1730 */
1731 HWTEST_F(ScreenSessionManagerClientTest, OnDumperClientScreenSessions, TestSize.Level2)
1732 {
1733 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1734 ASSERT_TRUE(client != nullptr);
1735 client->ConnectToServer();
1736
1737 RSDisplayNodeConfig config;
1738 std::shared_ptr<RSDisplayNode> node = std::make_shared<RSDisplayNode>(config);
1739 sptr<ScreenSession> screenSession1 = new ScreenSession(50, 50, "test1", ScreenProperty(), node);
1740 ASSERT_NE(nullptr, screenSession1);
1741 client->screenSessionMap_[50] = screenSession1;
1742
1743 sptr<ScreenSession> screenSession3 = new ScreenSession(52, 52, "test1", ScreenProperty(), nullptr);
1744 ASSERT_NE(nullptr, screenSession3);
1745 client->screenSessionMap_[52] = screenSession3;
1746
1747 sptr<ScreenSession> screenSession4 = nullptr;
1748 client->screenSessionMap_[53] = screenSession4;
1749
1750 auto ret = client->OnDumperClientScreenSessions();
1751 EXPECT_EQ(ret.empty(), false);
1752 }
1753
1754 /**
1755 * @tc.name: OnBeforeScreenPropertyChanged
1756 * @tc.desc: OnBeforeScreenPropertyChanged test
1757 * @tc.type: FUNC
1758 */
1759 HWTEST_F(ScreenSessionManagerClientTest, OnBeforeScreenPropertyChanged, TestSize.Level2)
1760 {
1761 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1762 client->ConnectToServer();
1763 ASSERT_TRUE(client != nullptr);
1764
1765 RSDisplayNodeConfig config;
1766 std::shared_ptr<RSDisplayNode> node = std::make_shared<RSDisplayNode>(config);
1767 sptr<ScreenSession> screenSession1 = new ScreenSession(50, 50, "test1", ScreenProperty(), node);
1768 ASSERT_NE(nullptr, screenSession1);
1769 client->screenSessionMap_[50] = screenSession1;
1770
1771 sptr<ScreenSession> screenSession3 = new ScreenSession(52, 52, "test1", ScreenProperty(), nullptr);
1772 ASSERT_NE(nullptr, screenSession3);
1773 client->screenSessionMap_[52] = screenSession3;
1774
1775 sptr<ScreenSession> screenSession4 = nullptr;
1776 client->screenSessionMap_[53] = screenSession4;
1777
1778 FoldStatus foldStatus = FoldStatus::UNKNOWN;
1779 client->OnBeforeScreenPropertyChanged(foldStatus);
1780 EXPECT_NE(client, nullptr);
1781 }
1782
1783 /**
1784 * @tc.name: SetPrimaryDisplaySystemDpi
1785 * @tc.desc: SetPrimaryDisplaySystemDpi test
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(ScreenSessionManagerClientTest, SetPrimaryDisplaySystemDpi, TestSize.Level2)
1789 {
1790 sptr<ScreenSessionManagerClient> client = new ScreenSessionManagerClient();
1791 ASSERT_TRUE(client != nullptr);
1792 client->ConnectToServer();
1793
1794 RSDisplayNodeConfig config;
1795 std::shared_ptr<RSDisplayNode> node = std::make_shared<RSDisplayNode>(config);
1796 sptr<ScreenSession> screenSession = new ScreenSession(50, 50, "SetPrimaryDisplaySystemDpi", ScreenProperty(), node);
1797 ASSERT_NE(nullptr, screenSession);
1798 float dpi = 2.125f;
1799 screenSession->SetDensityInCurResolution(dpi);
1800 screenSession->SetIsExtend(false);
1801 client->screenSessionMap_[0] = screenSession;
1802 EXPECT_EQ(screenSession->GetDensityInCurResolution(), 2.125f);
1803 dpi = 2.2f;
1804 client->SetPrimaryDisplaySystemDpi(dpi);
1805 EXPECT_EQ(DisplayManager::GetInstance().GetPrimaryDisplaySystemDpi(), 2.2f);
1806 }
1807 /**
1808 * @tc.name: DisconnectAllExternalScreen
1809 * @tc.desc: DisconnectAllExternalScreen test
1810 * @tc.type: FUNC
1811 */
1812 HWTEST_F(ScreenSessionManagerClientTest, DisconnectAllExternalScreen, TestSize.Level2)
1813 {
1814 logMsg.clear();
1815 LOG_SetCallback(MyLogCallback);
1816
1817 ASSERT_NE(screenSessionManagerClient_, nullptr);
1818 RSDisplayNodeConfig config;
1819 std::shared_ptr<RSDisplayNode> node1 = std::make_shared<RSDisplayNode>(config);
1820 screenSessionManagerClient_->screenSessionMap_[50] = nullptr;
1821 screenSessionManagerClient_->DisconnectAllExternalScreen();
1822 EXPECT_TRUE(logMsg.find("screenSession is nullptr") != std::string::npos);
1823 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(50, 50, "test1", ScreenProperty(), node1);
1824 ASSERT_NE(nullptr, screenSession);
1825 screenSessionManagerClient_->screenSessionMap_[50] = screenSession;
1826 screenSession->SetScreenType(ScreenType::REAL);
1827 screenSession->SetIsExtend(true);
1828 screenSessionManagerClient_->DisconnectAllExternalScreen();
1829 EXPECT_TRUE(logMsg.find("disconnect extend screen") != std::string::npos);
1830 }
1831
1832 /**
1833 * @tc.name: CreateTempScreenSession
1834 * @tc.desc: CreateTempScreenSession test
1835 * @tc.type: FUNC
1836 */
1837 HWTEST_F(ScreenSessionManagerClientTest, CreateTempScreenSession, TestSize.Level2)
1838 {
1839 ASSERT_NE(screenSessionManagerClient_, nullptr);
1840 RSDisplayNodeConfig config;
1841 std::shared_ptr<RSDisplayNode> node1 = std::make_shared<RSDisplayNode>(config);
1842 std::shared_ptr<RSDisplayNode> node2 = std::make_shared<RSDisplayNode>(config);
1843 sptr<ScreenSession> screenSession = sptr<ScreenSession>::MakeSptr(50, 50, "test1", ScreenProperty(), node1);
1844 ASSERT_NE(nullptr, screenSession);
1845 screenSessionManagerClient_->screenSessionMap_[50] = screenSession;
1846 screenSessionManagerClient_->screenSessionManager_ = sptr<ScreenSessionManagerProxyMock>::MakeSptr();
1847
1848 auto tempScreenSession = screenSessionManagerClient_->CreateTempScreenSession(50, 51, node2);
1849 ASSERT_NE(nullptr, tempScreenSession);
1850 tempScreenSession = screenSessionManagerClient_->CreateTempScreenSession(52, 51, node2);
1851 ASSERT_NE(nullptr, tempScreenSession);
1852 screenSessionManagerClient_->screenSessionManager_ = nullptr;
1853 }
1854
1855 /**
1856 * @tc.name: FreezeScreen
1857 * @tc.desc: FreezeScreen test
1858 * @tc.type: FUNC
1859 */
1860 HWTEST_F(ScreenSessionManagerClientTest, FreezeScreen, TestSize.Level2)
1861 {
1862 LOG_SetCallback(MyLogCallback);
1863 logMsg.clear();
1864 screenSessionManagerClient_->screenSessionMap_.clear();
1865 ScreenId screenId = 0;
1866 bool isFreeze = false;
1867 screenSessionManagerClient_->FreezeScreen(screenId, isFreeze);
1868 EXPECT_TRUE(logMsg.find("get screen session is null, screenId is 0") != std::string::npos);
1869
1870 ScreenProperty screenProperty;
1871 sptr<ScreenSession> screenSession = new ScreenSession(screenId, screenProperty, screenId);
1872 screenSessionManagerClient_->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
1873 screenSessionManagerClient_->FreezeScreen(screenId, isFreeze);
1874 screenSessionManagerClient_->screenSessionMap_.clear();
1875 logMsg.clear();
1876 }
1877
1878 /**
1879 * @tc.name: GetScreenSnapshotWithAllWindows01
1880 * @tc.desc: GetScreenSnapshotWithAllWindows01 test
1881 * @tc.type: FUNC
1882 */
1883 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSnapshotWithAllWindows01, TestSize.Level2)
1884 {
1885 LOG_SetCallback(MyLogCallback);
1886 logMsg.clear();
1887 screenSessionManagerClient_->screenSessionMap_.clear();
1888 ScreenId screenId = 0;
1889 float scaleX = 1.0;
1890 float scaleY = 1.0;
1891 bool isNeedCheckDrmAndSurfaceLock = false;
1892 screenSessionManagerClient_->GetScreenSnapshotWithAllWindows(screenId, scaleX, scaleY,
1893 isNeedCheckDrmAndSurfaceLock);
1894 EXPECT_TRUE(logMsg.find("get screen session is null, screenId is 0") != std::string::npos);
1895 screenSessionManagerClient_->screenSessionMap_.clear();
1896 logMsg.clear();
1897 }
1898
1899 /**
1900 * @tc.name: GetScreenSnapshotWithAllWindows02
1901 * @tc.desc: GetScreenSnapshotWithAllWindows02 test
1902 * @tc.type: FUNC
1903 */
1904 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSnapshotWithAllWindows02, TestSize.Level2)
1905 {
1906 screenSessionManagerClient_->screenSessionMap_.clear();
1907 ScreenProperty screenProperty;
1908 ScreenId screenId = 0;
1909 sptr<ScreenSession> screenSession = new ScreenSession(screenId, screenProperty, screenId);
1910 screenSessionManagerClient_->screenSessionMap_.insert(std::make_pair(screenId, screenSession));
1911 float scaleX = 1.0;
1912 float scaleY = 1.0;
1913 bool isNeedCheckDrmAndSurfaceLock = false;
1914 std::shared_ptr<Media::PixelMap> res = screenSessionManagerClient_->GetScreenSnapshotWithAllWindows(screenId,
1915 scaleX, scaleY, isNeedCheckDrmAndSurfaceLock);
1916 EXPECT_EQ(res, nullptr);
1917 screenSessionManagerClient_->screenSessionMap_.clear();
1918 }
1919 } // namespace Rosen
1920 } // namespace OHOS
1921