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
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 namespace {
31 constexpr HiviewDFX::HiLogLabel LABEL = {LOG_CORE, HILOG_DOMAIN_DISPLAY, "ScreenSessionManagerClientTest"};
32 }
33 class DmPrivateWindowListener : public DisplayManager::IPrivateWindowListener {
34 public:
OnPrivateWindow(bool hasPrivate)35 void OnPrivateWindow(bool hasPrivate) {WLOGFI("IPrivateWindowListener hasPrivatewindow: %{public}u", hasPrivate);}
36 };
37 class DmPrivateWindowListChangeListener : public DisplayManager::IPrivateWindowListChangeListener {
38 public:
OnPrivateWindowListChange(DisplayId displayId,std::vector<std::string> privacyWindowList)39 void OnPrivateWindowListChange(DisplayId displayId, std::vector<std::string> privacyWindowList)
40 {
41 WLOGFI("IPrivateWindowListChangeListener displayId: %{public}" PRIu64".", displayId);
42 std::string concatenatedString;
43 std::vector<std::string> result = privacyWindowList;
44 for (const auto& window : result) {
45 concatenatedString.append(window);
46 concatenatedString.append(" ");
47 }
48 WLOGFI("privacyWindowList: %{public}s", concatenatedString.c_str());
49 callback_(privacyWindowList);
50 }
setCallback(std::function<void (std::vector<std::string>)> callback)51 void setCallback(std::function<void(std::vector<std::string>)> callback)
52 {
53 callback_ = callback;
54 }
55 private:
56 std::function<void(std::vector<std::string>)> callback_;
57 };
58 class ScreenSessionManagerClientTest : public testing::Test {
59 public:
60 void SetUp() override;
61 void TearDown() override;
62 ScreenSessionManagerClient* screenSessionManagerClient_;
63 };
64
SetUp()65 void ScreenSessionManagerClientTest::SetUp()
66 {
67 screenSessionManagerClient_ = &ScreenSessionManagerClient::GetInstance();
68 }
69
TearDown()70 void ScreenSessionManagerClientTest::TearDown()
71 {
72 screenSessionManagerClient_ = nullptr;
73 }
74
75 /**
76 * @tc.name: RegisterScreenConnectionListener
77 * @tc.desc: RegisterScreenConnectionListener test
78 * @tc.type: FUNC
79 */
80 HWTEST_F(ScreenSessionManagerClientTest, RegisterScreenConnectionListener, Function | SmallTest | Level2)
81 {
82 IScreenConnectionListener* listener = nullptr;
83 screenSessionManagerClient_->RegisterScreenConnectionListener(listener);
84 EXPECT_EQ(screenSessionManagerClient_->screenConnectionListener_, nullptr);
85 }
86
87 /**
88 * @tc.name: GetScreenSession
89 * @tc.desc: GetScreenSession test
90 * @tc.type: FUNC
91 */
92 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSession, Function | SmallTest | Level2)
93 {
94 ScreenId screenId = 0;
95 sptr<ScreenSession> screenSession = nullptr;
96 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
97 EXPECT_EQ(screenSession, nullptr);
98
99 screenSession = new ScreenSession(0, ScreenProperty(), 0);
100 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
101
102 auto screenSession2 = screenSessionManagerClient_->GetScreenSession(screenId);
103 EXPECT_EQ(screenSession2, screenSession);
104
105 screenSessionManagerClient_->screenSessionMap_.clear();
106 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
107 EXPECT_EQ(screenSession, nullptr);
108 }
109
110 /**
111 * @tc.name: GetScreenSessionExtra
112 * @tc.desc: GetScreenSessionExtra test
113 * @tc.type: FUNC
114 */
115 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSessionExtra, Function | SmallTest | Level2)
116 {
117 ScreenId screenId = 0;
118 sptr<ScreenSession> screenSession = nullptr;
119 screenSession = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
120 EXPECT_EQ(screenSession, nullptr);
121
122 screenSession = new ScreenSession(0, ScreenProperty(), 0);
123 screenSessionManagerClient_->extraScreenSessionMap_.emplace(screenId, screenSession);
124
125 auto screenSession2 = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
126 EXPECT_EQ(screenSession2, screenSession);
127
128 screenSessionManagerClient_->extraScreenSessionMap_.clear();
129 screenSession = screenSessionManagerClient_->GetScreenSessionExtra(screenId);
130 EXPECT_EQ(screenSession, nullptr);
131 }
132
133 /**
134 * @tc.name: OnScreenConnectionChanged01
135 * @tc.desc: OnScreenConnectionChanged test
136 * @tc.type: FUNC
137 */
138 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged01, Function | SmallTest | Level2)
139 {
140 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
141 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
142 screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
143 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
144
145 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
146 SessionOption option = {
147 .rsId_ = 0,
148 .isExtend_ = false,
149 .screenId_ = 0,
150 };
151 ScreenId screenId = 0;
152 screenSessionManagerClient_->OnScreenConnectionChanged(option, screenEvent);
153 sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
154 EXPECT_NE(screenSession, nullptr);
155 }
156
157 /**
158 * @tc.name: OnScreenConnectionChanged02
159 * @tc.desc: OnScreenConnectionChanged test
160 * @tc.type: FUNC
161 */
162 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged02, Function | SmallTest | Level2)
163 {
164 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
165
166 ScreenEvent screenEvent = ScreenEvent::DISCONNECTED;
167 SessionOption option = {
168 .rsId_ = 0,
169 .isExtend_ = false,
170 .screenId_ = 0,
171 };
172 ScreenId screenId = 0;
173 screenSessionManagerClient_->OnScreenConnectionChanged(option, screenEvent);
174 sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
175 EXPECT_EQ(screenSession, nullptr);
176 }
177
178 /**
179 * @tc.name: CheckIfNeedConnectScreen01
180 * @tc.desc: CheckIfNeedConnectScreen test
181 * @tc.type: FUNC
182 */
183 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen01, Function | SmallTest | Level2)
184 {
185 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
186
187 SessionOption option = {
188 .rsId_ = 0,
189 .screenId_ = 0,
190 .name_ = "HiCar",
191 };
192 ScreenId screenId = 0;
193 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
194 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
195 EXPECT_EQ(result, true);
196 }
197
198 /**
199 * @tc.name: CheckIfNeedConnectScreen02
200 * @tc.desc: CheckIfNeedConnectScreen test
201 * @tc.type: FUNC
202 */
203 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen02, Function | SmallTest | Level2)
204 {
205 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
206 SessionOption option = {
207 .rsId_ = SCREEN_ID_INVALID,
208 .screenId_ = 0,
209 .name_ = "",
210 };
211 ScreenId screenId = 0;
212 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
213 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
214 EXPECT_EQ(result, false);
215 }
216
217 /**
218 * @tc.name: CheckIfNeedConnectScreen03
219 * @tc.desc: CheckIfNeedConnectScreen test
220 * @tc.type: FUNC
221 */
222 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen03, Function | SmallTest | Level2)
223 {
224 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
225 SessionOption option = {
226 .rsId_ = 0,
227 .screenId_ = 0,
228 .name_ = "",
229 };
230 ScreenId screenId = 0;
231 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::REAL);
232 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
233 EXPECT_EQ(result, true);
234 }
235
236 /**
237 * @tc.name: CheckIfNeedConnectScreen04
238 * @tc.desc: CheckIfNeedConnectScreen test
239 * @tc.type: FUNC
240 */
241 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen04, Function | SmallTest | Level2)
242 {
243 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
244 SessionOption option = {
245 .rsId_ = 0,
246 .screenId_ = 0,
247 .name_ = "HiCar",
248 };
249 ScreenId screenId = 0;
250 screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
251 bool result = screenSessionManagerClient_->CheckIfNeedConnectScreen(option);
252 EXPECT_EQ(result, true);
253 }
254
255 /**
256 * @tc.name: CheckIfNeedConnectScreen05
257 * @tc.desc: CheckIfNeedConnectScreen test
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen05, Function | SmallTest | Level2)
261 {
262 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
263 SessionOption option = {
264 .rsId_ = 0,
265 .screenId_ = 0,
266 .name_ = "SuperLauncher",
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: CheckIfNeedConnectScreen06
276 * @tc.desc: CheckIfNeedConnectScreen test
277 * @tc.type: FUNC
278 */
279 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedConnectScreen06, Function | SmallTest | Level2)
280 {
281 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
282 SessionOption option = {
283 .rsId_ = 0,
284 .screenId_ = 0,
285 .name_ = "CastEngine",
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: OnPowerStatusChanged
295 * @tc.desc: OnPowerStatusChanged test
296 * @tc.type: FUNC
297 */
298 HWTEST_F(ScreenSessionManagerClientTest, OnPowerStatusChanged, Function | SmallTest | Level2)
299 {
300 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
301 ScreenId screenId = 0;
302 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
303 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
304 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
305 EventStatus status = EventStatus::BEGIN;
306 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_ACCESS;
307 screenSessionManagerClient_->OnPowerStatusChanged(event, status, reason);
308 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
309 EXPECT_NE(screenSession1, nullptr);
310 }
311
312 /**
313 * @tc.name: GetAllScreensProperties
314 * @tc.desc: GetAllScreensProperties test
315 * @tc.type: FUNC
316 */
317 HWTEST_F(ScreenSessionManagerClientTest, GetAllScreensProperties, Function | SmallTest | Level2)
318 {
319 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
320 screenSessionManagerClient_->screenSessionMap_.clear();
321 ScreenId screenId = 0;
322 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
323 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
324 EXPECT_EQ(1, screenSessionManagerClient_->GetAllScreensProperties().size());
325 }
326
327 /**
328 * @tc.name: SetPrivacyStateByDisplayId01
329 * @tc.desc: SetPrivacyStateByDisplayId01 test
330 * @tc.type: FUNC
331 */
332 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId01, Function | SmallTest | Level2)
333 {
334 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
335 screenSessionManagerClient_->screenSessionManager_ = nullptr;
336 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
337 screenSessionManagerClient_->ConnectToServer();
338 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
339
340 sptr<DisplayManager::IPrivateWindowListener> displayListener_ = new DmPrivateWindowListener();
341 DisplayManager::GetInstance().RegisterPrivateWindowListener(displayListener_);
342
343 DisplayId id = 0;
344 bool hasPrivate = true;
345 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
346
347 bool result = false;
348 screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
349 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
350 EXPECT_EQ(result, true);
351 } else {
352 EXPECT_NE(result, true);
353 }
354 }
355
356 /**
357 * @tc.name: SetPrivacyStateByDisplayId02
358 * @tc.desc: SetPrivacyStateByDisplayId02 test
359 * @tc.type: FUNC
360 */
361 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId02, Function | SmallTest | Level2)
362 {
363 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
364 DisplayId id = 0;
365 bool hasPrivate = false;
366 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
367 bool result = true;
368 screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
369 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
370 EXPECT_EQ(result, false);
371 } else {
372 EXPECT_NE(result, false);
373 }
374 }
375
376 /**
377 * @tc.name: SetScreenPrivacyWindowList
378 * @tc.desc: SetScreenPrivacyWindowList test
379 * @tc.type: FUNC
380 */
381 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyWindowList, Function | SmallTest | Level2)
382 {
383 screenSessionManagerClient_->screenSessionManager_ = nullptr;
384 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
385 screenSessionManagerClient_->ConnectToServer();
386 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
387
388 DisplayId id = 0;
389 std::vector<std::string> privacyWindowList{"win0", "win1"};
390 std::vector<std::string> privacyWindowList2{"win0"};
391 sptr<DisplayManager::IPrivateWindowListChangeListener> listener_ = new DmPrivateWindowListChangeListener();
392 listener_->setCallback([privacyWindowList, privacyWindowList2](std::vector<std::string> windowList)
__anonfdab37370202(std::vector<std::string> windowList) 393 {
394 EXPECT_EQ(windowList, privacyWindowList);
395 EXPECT_NE(windowList, privacyWindowList2);
396 });
397 DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener_);
398
399 screenSessionManagerClient_->SetScreenPrivacyWindowList(id, privacyWindowList);
400 std::this_thread::sleep_for(std::chrono::milliseconds(100));
401 }
402
403 /**
404 * @tc.name: GetFoldDisplayMode01
405 * @tc.desc: GetFoldDisplayMode test
406 * @tc.type: FUNC
407 */
408 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode01, Function | SmallTest | Level2)
409 {
410 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
411 if (screenSessionManagerClient_->IsFoldable()) {
412 EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
413 EXPECT_NE(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
414 } else {
415 EXPECT_NE(FoldDisplayMode::FULL, screenSessionManagerClient_->GetFoldDisplayMode());
416 EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
417 }
418 EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
419 }
420
421 /**
422 * @tc.name: GetFoldDisplayMode02
423 * @tc.desc: GetFoldDisplayMode test
424 * @tc.type: FUNC
425 */
426 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode02, Function | SmallTest | Level2)
427 {
428 screenSessionManagerClient_->screenSessionManager_ = nullptr;
429 ScreenId screenId = 0;
430 bool foldToExpand = true;
431 DMRect area;
432 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
433 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
434 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
435 if (screenSessionManagerClient_->IsFoldable()) {
436 EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
437 } else {
438 EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
439 }
440 EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
441 EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
442 }
443
444 /**
445 * @tc.name: UpdateScreenRotationProperty
446 * @tc.desc: UpdateScreenRotationProperty test
447 * @tc.type: FUNC
448 */
449 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty, Function | SmallTest | Level2)
450 {
451 ScreenId screenId = 0;
452 ScreenId displayNodeScreenId = 0;
453 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
454 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
455 DMRect area;
456 bool foldToExpand = true;
457 RRect bounds;
458 bounds.rect_.width_ = 1344;
459 bounds.rect_.height_ = 2772;
460 float scaleX = 1.0;
461 float scaleY = 1.0;
462 ScreenDirectionInfo directionInfo;
463 directionInfo.notifyRotation_ = 90;
464 directionInfo.screenRotation_ = 90;
465 directionInfo.rotation_ = 90;
466 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
467 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
468 screenPropertyChangeType);
469 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
470 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
471 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
472 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
473 screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
474 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
475 EXPECT_NE(screenSession1, nullptr);
476 }
477
478 /**
479 * @tc.name: GetScreenSnapshot
480 * @tc.desc: GetScreenSnapshot test
481 * @tc.type: FUNC
482 */
483 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSnapshot, Function | SmallTest | Level2)
484 {
485 screenSessionManagerClient_->screenSessionMap_.clear();
486 ScreenId screenId = 0;
487 ScreenId displayNodeScreenId = 0;
488 float scaleX = 1.0;
489 float scaleY = 1.0;
490 RRect bounds;
491 bounds.rect_.width_ = 1344;
492 bounds.rect_.height_ = 2772;
493 ScreenDirectionInfo directionInfo;
494 directionInfo.notifyRotation_ = 90;
495 directionInfo.screenRotation_ = 90;
496 directionInfo.rotation_ = 90;
497 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
498 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
499 screenPropertyChangeType);
500 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
501 std::shared_ptr<Media::PixelMap> res = screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
502 EXPECT_EQ(nullptr, res);
503 }
504
505 /**
506 * @tc.name: SetScreenOffDelayTime
507 * @tc.desc: SetScreenOffDelayTime test
508 * @tc.type: FUNC
509 */
510 HWTEST_F(ScreenSessionManagerClientTest, SetScreenOffDelayTime, Function | SmallTest | Level2)
511 {
512 screenSessionManagerClient_->screenSessionManager_ = nullptr;
513 int32_t ret = screenSessionManagerClient_->SetScreenOffDelayTime(1);
514 EXPECT_EQ(ret, 0);
515 }
516
517 /**
518 * @tc.name: GetDeviceScreenConfig
519 * @tc.desc: GetDeviceScreenConfig test
520 * @tc.type: FUNC
521 */
522 HWTEST_F(ScreenSessionManagerClientTest, GetDeviceScreenConfig, Function | SmallTest | Level2)
523 {
524 DeviceScreenConfig deviceScreenConfig = screenSessionManagerClient_->GetDeviceScreenConfig();
525 EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
526 }
527
528 /**
529 * @tc.name: OnUpdateFoldDisplayMode
530 * @tc.desc: OnUpdateFoldDisplayMode test
531 * @tc.type: FUNC
532 */
533 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode, Function | SmallTest | Level2)
534 {
535 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::UNKNOWN);
536 auto ret1 = screenSessionManagerClient_->GetFoldDisplayMode();
537 EXPECT_EQ(FoldDisplayMode::UNKNOWN, ret1);
538 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::FULL);
539 auto ret2 = screenSessionManagerClient_->GetFoldDisplayMode();
540 EXPECT_EQ(FoldDisplayMode::FULL, ret2);
541 screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::MAIN);
542 auto ret3 = screenSessionManagerClient_->GetFoldDisplayMode();
543 EXPECT_EQ(FoldDisplayMode::MAIN, ret3);
544 }
545
546 /**
547 * @tc.name: GetScreenSessionById
548 * @tc.desc: GetScreenSessionById test
549 * @tc.type: FUNC
550 */
551 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSessionById, Function | SmallTest | Level2)
552 {
553 ScreenId screenId = 0;
554 sptr<ScreenSession> ret = screenSessionManagerClient_->GetScreenSessionById(screenId);
555 EXPECT_EQ(nullptr, ret);
556 }
557
558 /**
559 * @tc.name: ConnectToServer01
560 * @tc.desc: ConnectToServer test
561 * @tc.type: FUNC
562 */
563 HWTEST_F(ScreenSessionManagerClientTest, ConnectToServer01, Function | SmallTest | Level2)
564 {
565 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
566
567 screenSessionManagerClient_->screenSessionManager_ = nullptr;
568 screenSessionManagerClient_->ConnectToServer();
569 }
570
571 /**
572 * @tc.name: OnPropertyChanged
573 * @tc.desc: OnPropertyChanged test
574 * @tc.type: FUNC
575 */
576 HWTEST_F(ScreenSessionManagerClientTest, OnPropertyChanged, Function | SmallTest | Level2)
577 {
578 ScreenId screenId = 0;
579 ScreenProperty property;
580 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
581
582 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
583 screenSessionManagerClient_->OnPropertyChanged(screenId, property, reason);
584 }
585
586 /**
587 * @tc.name: OnSensorRotationChanged01
588 * @tc.desc: OnSensorRotationChanged test
589 * @tc.type: FUNC
590 */
591 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged01, Function | SmallTest | Level2)
592 {
593 ScreenId screenId = 0;
594 float sensorRotation = 0;
595
596 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
597 screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
598 }
599
600 /**
601 * @tc.name: OnSensorRotationChanged02
602 * @tc.desc: OnSensorRotationChanged test
603 * @tc.type: FUNC
604 */
605 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged02, Function | SmallTest | Level2)
606 {
607 ScreenId screenId = 1;
608 float sensorRotation = 90.0f;
609
610 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
611 screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
612 }
613
614 /**
615 * @tc.name: OnHoverStatusChanged01
616 * @tc.desc: OnHoverStatusChanged test
617 * @tc.type: FUNC
618 */
619 HWTEST_F(ScreenSessionManagerClientTest, OnHoverStatusChanged01, Function | SmallTest | Level2)
620 {
621 ScreenId screenId = 0;
622 int32_t hoverStatus = 0;
623
624 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
625 screenSessionManagerClient_->OnHoverStatusChanged(screenId, hoverStatus);
626 }
627
628 /**
629 * @tc.name: OnScreenOrientationChanged01
630 * @tc.desc: OnScreenOrientationChanged test
631 * @tc.type: FUNC
632 */
633 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged01, Function | SmallTest | Level2)
634 {
635 ScreenId screenId = 0;
636 float screenOrientation = 0;
637
638 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
639 screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
640 }
641
642 /**
643 * @tc.name: OnScreenOrientationChanged02
644 * @tc.desc: OnScreenOrientationChanged test
645 * @tc.type: FUNC
646 */
647 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged02, Function | SmallTest | Level2)
648 {
649 ScreenId screenId = 1;
650 float screenOrientation = 90.0f;
651
652 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
653 screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
654 }
655
656 /**
657 * @tc.name: OnScreenRotationLockedChanged01
658 * @tc.desc: OnScreenRotationLockedChanged test
659 * @tc.type: FUNC
660 */
661 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged01, Function | SmallTest | Level2)
662 {
663 ScreenId screenId = 0;
664 bool isLocked = false;
665
666 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
667 screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
668 }
669
670 /**
671 * @tc.name: OnScreenRotationLockedChanged02
672 * @tc.desc: OnScreenRotationLockedChanged test
673 * @tc.type: FUNC
674 */
675 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged02, Function | SmallTest | Level2)
676 {
677 ScreenId screenId = 1;
678 bool isLocked = true;
679
680 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
681 screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
682 }
683
684 /**
685 * @tc.name: OnSuperFoldStatusChanged
686 * @tc.desc: OnSuperFoldStatusChanged test
687 * @tc.type: FUNC
688 */
689 HWTEST_F(ScreenSessionManagerClientTest, OnSuperFoldStatusChanged, Function | SmallTest | Level2)
690 {
691 ScreenId screenId = 0;
692 SuperFoldStatus superFoldStatus = SuperFoldStatus::UNKNOWN;
693
694 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
695 screenSessionManagerClient_->OnSuperFoldStatusChanged(screenId, superFoldStatus);
696 }
697
698 /**
699 * @tc.name: RegisterDisplayChangeListener
700 * @tc.desc: RegisterDisplayChangeListener test
701 * @tc.type: FUNC
702 */
703 HWTEST_F(ScreenSessionManagerClientTest, RegisterDisplayChangeListener, Function | SmallTest | Level2)
704 {
705 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
706 screenSessionManagerClient_->RegisterDisplayChangeListener(nullptr);
707 }
708
709 /**
710 * @tc.name: OnDisplayStateChanged01
711 * @tc.desc: OnDisplayStateChanged test
712 * @tc.type: FUNC
713 */
714 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged01, Function | SmallTest | Level2)
715 {
716 DisplayId defaultDisplayId = 0;
717 sptr<DisplayInfo> displayInfo = new DisplayInfo();
718 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
719 { displayInfo->GetDisplayId(), displayInfo },
720 };
721 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
722
723 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
724 screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
725 }
726
727 /**
728 * @tc.name: OnDisplayStateChanged02
729 * @tc.desc: OnDisplayStateChanged test
730 * @tc.type: FUNC
731 */
732 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged02, Function | SmallTest | Level2)
733 {
734 DisplayId defaultDisplayId = 0;
735 sptr<DisplayInfo> displayInfo = new DisplayInfo();
736 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
737 { displayInfo->GetDisplayId(), displayInfo },
738 };
739 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
740
741 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
742 screenSessionManagerClient_->displayChangeListener_ = nullptr;
743 screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
744 }
745
746 /**
747 * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged01
748 * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
749 * @tc.type: FUNC
750 */
751 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged01, Function | SmallTest | Level2)
752 {
753 std::vector<uint64_t> missionIds = {0, 1};
754 std::vector<uint64_t> surfaceNodeIds;
755 bool isBlackList = false;
756
757 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
758 screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
759 }
760
761 /**
762 * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged02
763 * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
764 * @tc.type: FUNC
765 */
766 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged02, Function | SmallTest | Level2)
767 {
768 std::vector<uint64_t> missionIds = {0, 1};
769 std::vector<uint64_t> surfaceNodeIds;
770 bool isBlackList = false;
771
772 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
773 screenSessionManagerClient_->displayChangeListener_ = nullptr;
774 screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
775 }
776
777 /**
778 * @tc.name: OnScreenshot01
779 * @tc.desc: OnScreenshot test
780 * @tc.type: FUNC
781 */
782 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot01, Function | SmallTest | Level2)
783 {
784 DisplayId displayId = 0;
785
786 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
787 screenSessionManagerClient_->OnScreenshot(displayId);
788 }
789
790 /**
791 * @tc.name: OnScreenshot02
792 * @tc.desc: OnScreenshot test
793 * @tc.type: FUNC
794 */
795 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot02, Function | SmallTest | Level2)
796 {
797 DisplayId displayId = 0;
798
799 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
800 screenSessionManagerClient_->displayChangeListener_ = nullptr;
801 screenSessionManagerClient_->OnScreenshot(displayId);
802 }
803
804 /**
805 * @tc.name: OnImmersiveStateChanged01
806 * @tc.desc: OnImmersiveStateChanged test
807 * @tc.type: FUNC
808 */
809 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged01, Function | SmallTest | Level2)
810 {
811 bool immersive = false;
812
813 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
814 screenSessionManagerClient_->OnImmersiveStateChanged(0u, immersive);
815 }
816
817 /**
818 * @tc.name: OnImmersiveStateChanged02
819 * @tc.desc: OnImmersiveStateChanged test
820 * @tc.type: FUNC
821 */
822 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged02, Function | SmallTest | Level2)
823 {
824 bool immersive = false;
825
826 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
827 screenSessionManagerClient_->displayChangeListener_ = nullptr;
828 screenSessionManagerClient_->OnImmersiveStateChanged(0u, immersive);
829 }
830
831 /**
832 * @tc.name: SetDisplayNodeScreenId
833 * @tc.desc: SetDisplayNodeScreenId test
834 * @tc.type: FUNC
835 */
836 HWTEST_F(ScreenSessionManagerClientTest, SetDisplayNodeScreenId, Function | SmallTest | Level2)
837 {
838 ScreenId screenId = 0;
839 ScreenId displayNodeScreenId = 0;
840
841 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
842 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
843 }
844
845 /**
846 * @tc.name: GetCurvedCompressionArea
847 * @tc.desc: GetCurvedCompressionArea test
848 * @tc.type: FUNC
849 */
850 HWTEST_F(ScreenSessionManagerClientTest, GetCurvedCompressionArea, Function | SmallTest | Level2)
851 {
852 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
853 screenSessionManagerClient_->GetCurvedCompressionArea();
854 }
855
856 /**
857 * @tc.name: GetPhyScreenProperty
858 * @tc.desc: GetPhyScreenProperty test
859 * @tc.type: FUNC
860 */
861 HWTEST_F(ScreenSessionManagerClientTest, GetPhyScreenProperty, Function | SmallTest | Level2)
862 {
863 ScreenId screenId = 0;
864 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
865 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
866 }
867
868 /**
869 * @tc.name: NotifyDisplayChangeInfoChanged
870 * @tc.desc: NotifyDisplayChangeInfoChanged test
871 * @tc.type: FUNC
872 */
873 HWTEST_F(ScreenSessionManagerClientTest, NotifyDisplayChangeInfoChanged, Function | SmallTest | Level2)
874 {
875 sptr<DisplayChangeInfo> info = new DisplayChangeInfo();
876 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
877 screenSessionManagerClient_->NotifyDisplayChangeInfoChanged(info);
878 }
879
880 /**
881 * @tc.name: SetScreenPrivacyState01
882 * @tc.desc: SetScreenPrivacyState test
883 * @tc.type: FUNC
884 */
885 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState01, Function | SmallTest | Level2)
886 {
887 bool hasPrivate = false;
888 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
889 screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
890 }
891
892 /**
893 * @tc.name: SetScreenPrivacyState02
894 * @tc.desc: SetScreenPrivacyState test
895 * @tc.type: FUNC
896 */
897 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState02, Function | SmallTest | Level2)
898 {
899 bool hasPrivate = false;
900 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
901 sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
902 screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
903 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
904 screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
905 }
906
907 /**
908 * @tc.name: SetPrivacyStateByDisplayId
909 * @tc.desc: SetPrivacyStateByDisplayId test
910 * @tc.type: FUNC
911 */
912 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId, Function | SmallTest | Level2)
913 {
914 DisplayId id = 0;
915 bool hasPrivate = false;
916 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
917 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
918 }
919
920 /**
921 * @tc.name: UpdateAvailableArea
922 * @tc.desc: UpdateAvailableArea test
923 * @tc.type: FUNC
924 */
925 HWTEST_F(ScreenSessionManagerClientTest, UpdateAvailableArea, Function | SmallTest | Level2)
926 {
927 ScreenId screenId = 0;
928 DMRect area;
929
930 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
931 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
932 }
933
934 /**
935 * @tc.name: NotifyFoldToExpandCompletion
936 * @tc.desc: NotifyFoldToExpandCompletion test
937 * @tc.type: FUNC
938 */
939 HWTEST_F(ScreenSessionManagerClientTest, NotifyFoldToExpandCompletion, Function | SmallTest | Level2)
940 {
941 bool foldToExpand = true;
942
943 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
944 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
945 }
946
947 /**
948 * @tc.name: SwitchUserCallback01
949 * @tc.desc: SwitchUserCallback test
950 * @tc.type: FUNC
951 */
952 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback01, Function | SmallTest | Level2)
953 {
954 std::vector<int32_t> oldScbPids = {0, 1};
955 int32_t currentScbPid = 1;
956
957 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
958 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
959 }
960
961 /**
962 * @tc.name: SwitchUserCallback02
963 * @tc.desc: SwitchUserCallback test
964 * @tc.type: FUNC
965 */
966 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback02, Function | SmallTest | Level2)
967 {
968 std::vector<int32_t> oldScbPids = {};
969 int32_t currentScbPid = 1;
970
971 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
972 screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
973 }
974
975 /**
976 * @tc.name: SwitchingCurrentUser
977 * @tc.desc: SwitchingCurrentUser test
978 * @tc.type: FUNC
979 */
980 HWTEST_F(ScreenSessionManagerClientTest, SwitchingCurrentUser, Function | SmallTest | Level2)
981 {
982 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
983 screenSessionManagerClient_->SwitchingCurrentUser();
984 }
985
986 /**
987 * @tc.name: GetFoldStatus
988 * @tc.desc: GetFoldStatus test
989 * @tc.type: FUNC
990 */
991 HWTEST_F(ScreenSessionManagerClientTest, GetFoldStatus, Function | SmallTest | Level2)
992 {
993 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
994 screenSessionManagerClient_->GetFoldStatus();
995 }
996
997 /**
998 * @tc.name: GetSuperFoldStatus
999 * @tc.desc: GetSuperFoldStatus test
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(ScreenSessionManagerClientTest, GetSuperFoldStatus, Function | SmallTest | Level2)
1003 {
1004 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1005 screenSessionManagerClient_->GetSuperFoldStatus();
1006 }
1007
1008 /**
1009 * @tc.name: SetLandscapeLockStatus
1010 * @tc.desc: SetLandscapeLockStatus test
1011 * @tc.type: FUNC
1012 */
1013 HWTEST_F(ScreenSessionManagerClientTest, SetLandscapeLockStatus, Function | SmallTest | Level2)
1014 {
1015 bool isLocked = false;
1016 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1017 screenSessionManagerClient_->SetLandscapeLockStatus(isLocked);
1018 }
1019
1020 /**
1021 * @tc.name: GetDefaultScreenId
1022 * @tc.desc: GetDefaultScreenId test
1023 * @tc.type: FUNC
1024 */
1025 HWTEST_F(ScreenSessionManagerClientTest, GetDefaultScreenId, Function | SmallTest | Level2)
1026 {
1027 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1028 screenSessionManagerClient_->GetDefaultScreenId();
1029 }
1030
1031 /**
1032 * @tc.name: IsFoldable
1033 * @tc.desc: IsFoldable test
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(ScreenSessionManagerClientTest, IsFoldable, Function | SmallTest | Level2)
1037 {
1038 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1039 screenSessionManagerClient_->IsFoldable();
1040 }
1041
1042 /**
1043 * @tc.name: SetVirtualPixelRatioSystem
1044 * @tc.desc: SetVirtualPixelRatioSystem test
1045 * @tc.type: FUNC
1046 */
1047 HWTEST_F(ScreenSessionManagerClientTest, SetVirtualPixelRatioSystem, Function | SmallTest | Level2)
1048 {
1049 ScreenId screenId = 0;
1050 float virtualPixelRatio = 1.0f;
1051
1052 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1053 screenSessionManagerClient_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
1054 }
1055
1056 /**
1057 * @tc.name: UpdateDisplayHookInfo
1058 * @tc.desc: UpdateDisplayHookInfo test
1059 * @tc.type: FUNC
1060 */
1061 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayHookInfo, Function | SmallTest | Level2)
1062 {
1063 int32_t uid = 0;
1064 bool enable = false;
1065 DMHookInfo hookInfo;
1066 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1067 screenSessionManagerClient_->UpdateDisplayHookInfo(uid, enable, hookInfo);
1068 }
1069
1070 /**
1071 * @tc.name: OnFoldStatusChangedReportUE
1072 * @tc.desc: OnFoldStatusChangedReportUE test
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(ScreenSessionManagerClientTest, OnFoldStatusChangedReportUE, Function | SmallTest | Level2)
1076 {
1077 std::vector<std::string> screenFoldInfo;
1078
1079 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1080 screenSessionManagerClient_->OnFoldStatusChangedReportUE(screenFoldInfo);
1081 }
1082
1083 /**
1084 * @tc.name: UpdateDisplayScale01
1085 * @tc.desc: UpdateDisplayScale test
1086 * @tc.type: FUNC
1087 */
1088 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale01, Function | SmallTest | Level2)
1089 {
1090 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1091 const float scaleX = 1.0f;
1092 const float scaleY = 1.0f;
1093 const float pivotX = 0.5f;
1094 const float pivotY = 0.5f;
1095 const float translateX = 0.0f;
1096 const float translateY = 0.0f;
1097 ScreenId defaultScreenId = screenSessionManagerClient_->GetDefaultScreenId();
1098 screenSessionManagerClient_->UpdateDisplayScale(defaultScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1099 translateY);
1100 }
1101
1102 /**
1103 * @tc.name: UpdateDisplayScale02
1104 * @tc.desc: UpdateDisplayScale test
1105 * @tc.type: FUNC
1106 */
1107 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale02, Function | SmallTest | Level2)
1108 {
1109 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1110 const float scaleX = 1.0f;
1111 const float scaleY = 1.0f;
1112 const float pivotX = 0.5f;
1113 const float pivotY = 0.5f;
1114 const float translateX = 0.0f;
1115 const float translateY = 0.0f;
1116 uint64_t fakeScreenId = 100;
1117 screenSessionManagerClient_->UpdateDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1118 translateY);
1119 }
1120
1121 /**
1122 * @tc.name: RegisterScreenConnectionListener02
1123 * @tc.desc: RegisterScreenConnectionListener test
1124 * @tc.type: FUNC
1125 */
1126 HWTEST_F(ScreenSessionManagerClientTest, RegisterScreenConnectionListener02, Function | SmallTest | Level2)
1127 {
1128 IScreenConnectionListener* listener = nullptr;
1129 screenSessionManagerClient_->RegisterScreenConnectionListener(listener);
1130 EXPECT_EQ(screenSessionManagerClient_->screenConnectionListener_, nullptr);
1131 }
1132
1133 /**
1134 * @tc.name: GetScreenSession02
1135 * @tc.desc: GetScreenSession test
1136 * @tc.type: FUNC
1137 */
1138 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSession02, Function | SmallTest | Level2)
1139 {
1140 ScreenId screenId = 0;
1141 sptr<ScreenSession> screenSession = nullptr;
1142 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
1143 EXPECT_EQ(screenSession, nullptr);
1144
1145 screenSession = new ScreenSession(0, ScreenProperty(), 0);
1146 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1147
1148 auto screenSession2 = screenSessionManagerClient_->GetScreenSession(screenId);
1149 EXPECT_EQ(screenSession2, screenSession);
1150
1151 screenSessionManagerClient_->screenSessionMap_.clear();
1152 screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
1153 EXPECT_EQ(screenSession, nullptr);
1154 }
1155
1156 /**
1157 * @tc.name: SwitchingCurrentUser02
1158 * @tc.desc: SwitchingCurrentUser test
1159 * @tc.type: FUNC
1160 */
1161 HWTEST_F(ScreenSessionManagerClientTest, SwitchingCurrentUser02, Function | SmallTest | Level2)
1162 {
1163 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1164 screenSessionManagerClient_->SwitchingCurrentUser();
1165 }
1166
1167 /**
1168 * @tc.name: GetFoldStatus02
1169 * @tc.desc: GetFoldStatus test
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(ScreenSessionManagerClientTest, GetFoldStatus02, Function | SmallTest | Level2)
1173 {
1174 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1175 screenSessionManagerClient_->GetFoldStatus();
1176 }
1177
1178 /**
1179 * @tc.name: GetDefaultScreenId02
1180 * @tc.desc: GetDefaultScreenId test
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(ScreenSessionManagerClientTest, GetDefaultScreenId02, Function | SmallTest | Level2)
1184 {
1185 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1186 screenSessionManagerClient_->GetDefaultScreenId();
1187 }
1188
1189 /**
1190 * @tc.name: IsFoldable02
1191 * @tc.desc: IsFoldable test
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(ScreenSessionManagerClientTest, IsFoldable02, Function | SmallTest | Level2)
1195 {
1196 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1197 screenSessionManagerClient_->IsFoldable();
1198 }
1199
1200 /**
1201 * @tc.name: SetVirtualPixelRatioSystem02
1202 * @tc.desc: SetVirtualPixelRatioSystem test
1203 * @tc.type: FUNC
1204 */
1205 HWTEST_F(ScreenSessionManagerClientTest, SetVirtualPixelRatioSystem02, Function | SmallTest | Level2)
1206 {
1207 ScreenId screenId = 0;
1208 float virtualPixelRatio = 1.0f;
1209
1210 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1211 screenSessionManagerClient_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
1212 }
1213
1214 /**
1215 * @tc.name: UpdateDisplayHookInfo02
1216 * @tc.desc: UpdateDisplayHookInfo test
1217 * @tc.type: FUNC
1218 */
1219 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayHookInfo02, Function | SmallTest | Level2)
1220 {
1221 int32_t uid = 0;
1222 bool enable = false;
1223 DMHookInfo hookInfo;
1224 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1225 screenSessionManagerClient_->UpdateDisplayHookInfo(uid, enable, hookInfo);
1226 }
1227
1228 /**
1229 * @tc.name: OnFoldStatusChangedReportUE02
1230 * @tc.desc: OnFoldStatusChangedReportUE test
1231 * @tc.type: FUNC
1232 */
1233 HWTEST_F(ScreenSessionManagerClientTest, OnFoldStatusChangedReportUE02, Function | SmallTest | Level2)
1234 {
1235 std::vector<std::string> screenFoldInfo;
1236
1237 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1238 screenSessionManagerClient_->OnFoldStatusChangedReportUE(screenFoldInfo);
1239 }
1240
1241 /**
1242 * @tc.name: SetPrivacyStateByDisplayId03
1243 * @tc.desc: SetPrivacyStateByDisplayId test
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId03, Function | SmallTest | Level2)
1247 {
1248 DisplayId id = 0;
1249 bool hasPrivate = false;
1250 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1251 screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
1252 }
1253
1254 /**
1255 * @tc.name: UpdateAvailableArea02
1256 * @tc.desc: UpdateAvailableArea test
1257 * @tc.type: FUNC
1258 */
1259 HWTEST_F(ScreenSessionManagerClientTest, UpdateAvailableArea02, Function | SmallTest | Level2)
1260 {
1261 ScreenId screenId = 0;
1262 DMRect area;
1263
1264 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1265 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
1266 }
1267
1268 /**
1269 * @tc.name: NotifyFoldToExpandCompletion02
1270 * @tc.desc: NotifyFoldToExpandCompletion test
1271 * @tc.type: FUNC
1272 */
1273 HWTEST_F(ScreenSessionManagerClientTest, NotifyFoldToExpandCompletion02, Function | SmallTest | Level2)
1274 {
1275 bool foldToExpand = true;
1276
1277 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1278 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
1279 }
1280
1281 /**
1282 * @tc.name: OnPowerStatusChanged02
1283 * @tc.desc: OnPowerStatusChanged test
1284 * @tc.type: FUNC
1285 */
1286 HWTEST_F(ScreenSessionManagerClientTest, OnPowerStatusChanged02, Function | SmallTest | Level2)
1287 {
1288 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1289 ScreenId screenId = 0;
1290 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
1291 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1292 DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
1293 EventStatus status = EventStatus::BEGIN;
1294 PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_ACCESS;
1295 screenSessionManagerClient_->OnPowerStatusChanged(event, status, reason);
1296 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
1297 EXPECT_NE(screenSession1, nullptr);
1298 }
1299
1300 /**
1301 * @tc.name: GetAllScreensProperties02
1302 * @tc.desc: GetAllScreensProperties test
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(ScreenSessionManagerClientTest, GetAllScreensProperties02, Function | SmallTest | Level2)
1306 {
1307 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1308 screenSessionManagerClient_->screenSessionMap_.clear();
1309 ScreenId screenId = 0;
1310 sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
1311 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1312 EXPECT_EQ(1, screenSessionManagerClient_->GetAllScreensProperties().size());
1313 }
1314
1315 /**
1316 * @tc.name: SetScreenPrivacyWindowList02
1317 * @tc.desc: SetScreenPrivacyWindowList test
1318 * @tc.type: FUNC
1319 */
1320 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyWindowList02, Function | SmallTest | Level2)
1321 {
1322 screenSessionManagerClient_->screenSessionManager_ = nullptr;
1323 EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
1324 screenSessionManagerClient_->ConnectToServer();
1325 EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
1326
1327 DisplayId id = 0;
1328 std::vector<std::string> privacyWindowList{"win0", "win1"};
1329 std::vector<std::string> privacyWindowList2{"win0"};
1330 sptr<DisplayManager::IPrivateWindowListChangeListener> listener_ = new DmPrivateWindowListChangeListener();
1331 listener_->setCallback([privacyWindowList, privacyWindowList2](std::vector<std::string> windowList)
__anonfdab37370302(std::vector<std::string> windowList) 1332 {
1333 EXPECT_EQ(windowList, privacyWindowList);
1334 EXPECT_NE(windowList, privacyWindowList2);
1335 });
1336 DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener_);
1337
1338 screenSessionManagerClient_->SetScreenPrivacyWindowList(id, privacyWindowList);
1339 std::this_thread::sleep_for(std::chrono::milliseconds(100));
1340 }
1341
1342 /**
1343 * @tc.name: UpdateScreenRotationProperty02
1344 * @tc.desc: UpdateScreenRotationProperty test
1345 * @tc.type: FUNC
1346 */
1347 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty02, Function | SmallTest | Level2)
1348 {
1349 ScreenId screenId = 0;
1350 ScreenId displayNodeScreenId = 0;
1351 sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
1352 screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
1353 DMRect area;
1354 bool foldToExpand = true;
1355 RRect bounds;
1356 bounds.rect_.width_ = 1344;
1357 bounds.rect_.height_ = 2772;
1358 float scaleX = 1.0;
1359 float scaleY = 1.0;
1360 ScreenDirectionInfo directionInfo;
1361 directionInfo.notifyRotation_ = 90;
1362 directionInfo.screenRotation_ = 90;
1363 directionInfo.rotation_ = 90;
1364 ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
1365 screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
1366 screenPropertyChangeType);
1367 screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
1368 screenSessionManagerClient_->GetPhyScreenProperty(screenId);
1369 screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
1370 screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
1371 screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
1372 sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
1373 EXPECT_NE(screenSession1, nullptr);
1374 }
1375
1376 /**
1377 * @tc.name: ScreenCaptureNotify
1378 * @tc.desc: ScreenCaptureNotify test
1379 * @tc.type: FUNC
1380 */
1381 HWTEST_F(ScreenSessionManagerClientTest, ScreenCaptureNotify, Function | SmallTest | Level2)
1382 {
1383 ScreenId screenId = 0;
1384 int32_t uid = 0;
1385 std::string clientName = "test";
1386 ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1387 screenSessionManagerClient_->ScreenCaptureNotify(screenId, uid, clientName);
1388 }
1389 } // namespace Rosen
1390 } // namespace OHOS
1391