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: OnScreenConnectionChanged01
112  * @tc.desc: OnScreenConnectionChanged test
113  * @tc.type: FUNC
114  */
115 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged01, Function | SmallTest | Level2)
116 {
117     EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
118     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
119     screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
120     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
121 
122     ScreenId screenId = 0;
123     ScreenEvent screenEvent = ScreenEvent::CONNECTED;
124     ScreenId rsId = 0;
125     std::string name;
126     screenSessionManagerClient_->OnScreenConnectionChanged(screenId, screenEvent, rsId, name);
127     sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
128     EXPECT_NE(screenSession, nullptr);
129 }
130 
131 /**
132  * @tc.name: OnScreenConnectionChanged02
133  * @tc.desc: OnScreenConnectionChanged test
134  * @tc.type: FUNC
135  */
136 HWTEST_F(ScreenSessionManagerClientTest, OnScreenConnectionChanged02, Function | SmallTest | Level2)
137 {
138     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
139 
140     ScreenId screenId = 0;
141     ScreenEvent screenEvent = ScreenEvent::DISCONNECTED;
142     ScreenId rsId = 0;
143     std::string name;
144     screenSessionManagerClient_->OnScreenConnectionChanged(screenId, screenEvent, rsId, name);
145     sptr<ScreenSession> screenSession = screenSessionManagerClient_->GetScreenSession(screenId);
146     EXPECT_EQ(screenSession, nullptr);
147 }
148 
149 /**
150  * @tc.name: CheckIfNeedCennectScreen01
151  * @tc.desc: CheckIfNeedCennectScreen test
152  * @tc.type: FUNC
153  */
154 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen01, Function | SmallTest | Level2)
155 {
156     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
157 
158     ScreenId screenId = 0;
159     ScreenId rsId = 0;
160     std::string name = "HiCar";
161     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
162     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
163     EXPECT_EQ(result, true);
164 }
165 
166 /**
167  * @tc.name: CheckIfNeedCennectScreen02
168  * @tc.desc: CheckIfNeedCennectScreen test
169  * @tc.type: FUNC
170  */
171 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen02, Function | SmallTest | Level2)
172 {
173     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
174 
175     ScreenId screenId = 0;
176     ScreenId rsId = SCREEN_ID_INVALID;
177     std::string name;
178     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
179     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
180     EXPECT_EQ(result, false);
181 }
182 
183 /**
184  * @tc.name: CheckIfNeedCennectScreen03
185  * @tc.desc: CheckIfNeedCennectScreen test
186  * @tc.type: FUNC
187  */
188 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen03, Function | SmallTest | Level2)
189 {
190     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
191 
192     ScreenId screenId = 0;
193     ScreenId rsId = 0;
194     std::string name;
195     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::REAL);
196     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
197     EXPECT_EQ(result, true);
198 }
199 
200 /**
201  * @tc.name: CheckIfNeedCennectScreen04
202  * @tc.desc: CheckIfNeedCennectScreen test
203  * @tc.type: FUNC
204  */
205 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen04, Function | SmallTest | Level2)
206 {
207     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
208 
209     ScreenId screenId = 0;
210     ScreenId rsId = 0;
211     std::string name = "HiCar";
212     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
213     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
214     EXPECT_EQ(result, true);
215 }
216 
217 /**
218  * @tc.name: CheckIfNeedCennectScreen05
219  * @tc.desc: CheckIfNeedCennectScreen test
220  * @tc.type: FUNC
221  */
222 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen05, Function | SmallTest | Level2)
223 {
224     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
225 
226     ScreenId screenId = 0;
227     ScreenId rsId = 0;
228     std::string name = "SuperLauncher";
229     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
230     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
231     EXPECT_EQ(result, true);
232 }
233 
234 /**
235  * @tc.name: CheckIfNeedCennectScreen06
236  * @tc.desc: CheckIfNeedCennectScreen test
237  * @tc.type: FUNC
238  */
239 HWTEST_F(ScreenSessionManagerClientTest, CheckIfNeedCennectScreen06, Function | SmallTest | Level2)
240 {
241     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
242 
243     ScreenId screenId = 0;
244     ScreenId rsId = 0;
245     std::string name = "CastEngine";
246     screenSessionManagerClient_->screenSessionManager_->GetScreenProperty(screenId).SetScreenType(ScreenType::VIRTUAL);
247     bool result = screenSessionManagerClient_->CheckIfNeedCennectScreen(screenId, rsId, name);
248     EXPECT_EQ(result, true);
249 }
250 
251 /**
252  * @tc.name: OnPowerStatusChanged
253  * @tc.desc: OnPowerStatusChanged test
254  * @tc.type: FUNC
255  */
256 HWTEST_F(ScreenSessionManagerClientTest, OnPowerStatusChanged, Function | SmallTest | Level2)
257 {
258     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
259     ScreenId screenId = 0;
260     sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
261     screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
262     DisplayPowerEvent event = DisplayPowerEvent::WAKE_UP;
263     EventStatus status = EventStatus::BEGIN;
264     PowerStateChangeReason reason = PowerStateChangeReason::STATE_CHANGE_REASON_ACCESS;
265     screenSessionManagerClient_->OnPowerStatusChanged(event, status, reason);
266     sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
267     EXPECT_NE(screenSession1, nullptr);
268 }
269 
270 /**
271  * @tc.name: GetAllScreensProperties
272  * @tc.desc: GetAllScreensProperties test
273  * @tc.type: FUNC
274  */
275 HWTEST_F(ScreenSessionManagerClientTest, GetAllScreensProperties, Function | SmallTest | Level2)
276 {
277     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
278     screenSessionManagerClient_->screenSessionMap_.clear();
279     ScreenId screenId = 0;
280     sptr<ScreenSession> screenSession = new ScreenSession(screenId, ScreenProperty(), 0);
281     screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
282     EXPECT_EQ(1, screenSessionManagerClient_->GetAllScreensProperties().size());
283 }
284 
285 /**
286  * @tc.name: SetPrivacyStateByDisplayId01
287  * @tc.desc: SetPrivacyStateByDisplayId01 test
288  * @tc.type: FUNC
289  */
290 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId01, Function | SmallTest | Level2)
291 {
292     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
293     screenSessionManagerClient_->screenSessionManager_ = nullptr;
294     EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
295     screenSessionManagerClient_->ConnectToServer();
296     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
297 
298     sptr<DisplayManager::IPrivateWindowListener> displayListener_ = new DmPrivateWindowListener();
299     DisplayManager::GetInstance().RegisterPrivateWindowListener(displayListener_);
300 
301     DisplayId id = 0;
302     bool hasPrivate = true;
303     screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
304 
305     bool result = false;
306     screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
307     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
308         EXPECT_EQ(result, true);
309     } else {
310         EXPECT_NE(result, true);
311     }
312 }
313 
314 /**
315  * @tc.name: SetPrivacyStateByDisplayId02
316  * @tc.desc: SetPrivacyStateByDisplayId02 test
317  * @tc.type: FUNC
318  */
319 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId02, Function | SmallTest | Level2)
320 {
321     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
322     DisplayId id = 0;
323     bool hasPrivate = false;
324     screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
325     bool result = true;
326     screenSessionManagerClient_->screenSessionManager_->HasPrivateWindow(id, result);
327     if (SceneBoardJudgement::IsSceneBoardEnabled()) {
328         EXPECT_EQ(result, false);
329     } else {
330         EXPECT_NE(result, false);
331     }
332 }
333 
334 /**
335  * @tc.name: SetScreenPrivacyWindowList
336  * @tc.desc: SetScreenPrivacyWindowList test
337  * @tc.type: FUNC
338  */
339 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyWindowList, Function | SmallTest | Level2)
340 {
341     screenSessionManagerClient_->screenSessionManager_ = nullptr;
342     EXPECT_EQ(screenSessionManagerClient_->screenSessionManager_, nullptr);
343     screenSessionManagerClient_->ConnectToServer();
344     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
345 
346     DisplayId id = 0;
347     std::vector<std::string> privacyWindowList{"win0", "win1"};
348     std::vector<std::string> privacyWindowList2{"win0"};
349     sptr<DisplayManager::IPrivateWindowListChangeListener> listener_ = new DmPrivateWindowListChangeListener();
350     listener_->setCallback([privacyWindowList, privacyWindowList2](std::vector<std::string> windowList)
__anond1e6a52f0202(std::vector<std::string> windowList) 351     {
352         EXPECT_EQ(windowList, privacyWindowList);
353         EXPECT_NE(windowList, privacyWindowList2);
354     });
355     DisplayManager::GetInstance().RegisterPrivateWindowListChangeListener(listener_);
356 
357     screenSessionManagerClient_->SetScreenPrivacyWindowList(id, privacyWindowList);
358     std::this_thread::sleep_for(std::chrono::milliseconds(100));
359 }
360 
361 /**
362  * @tc.name: GetFoldDisplayMode01
363  * @tc.desc: GetFoldDisplayMode test
364  * @tc.type: FUNC
365  */
366 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode01, Function | SmallTest | Level2)
367 {
368     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
369     if (screenSessionManagerClient_->IsFoldable()) {
370         EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
371         EXPECT_NE(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
372     } else {
373         EXPECT_NE(FoldDisplayMode::FULL, screenSessionManagerClient_->GetFoldDisplayMode());
374         EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
375     }
376     EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
377 }
378 
379 /**
380  * @tc.name: GetFoldDisplayMode02
381  * @tc.desc: GetFoldDisplayMode test
382  * @tc.type: FUNC
383  */
384 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode02, Function | SmallTest | Level2)
385 {
386     screenSessionManagerClient_->screenSessionManager_ = nullptr;
387     ScreenId screenId = 0;
388     bool foldToExpand = true;
389     DMRect area;
390     screenSessionManagerClient_->GetPhyScreenProperty(screenId);
391     screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
392     screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
393     if (screenSessionManagerClient_->IsFoldable()) {
394         EXPECT_NE(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
395     } else {
396         EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerClient_->GetFoldDisplayMode());
397     }
398     EXPECT_EQ(FoldStatus::UNKNOWN, screenSessionManagerClient_->GetFoldStatus());
399     EXPECT_EQ(0, screenSessionManagerClient_->GetCurvedCompressionArea());
400 }
401 
402 /**
403  * @tc.name: UpdateScreenRotationProperty
404  * @tc.desc: UpdateScreenRotationProperty test
405  * @tc.type: FUNC
406  */
407 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty, Function | SmallTest | Level2)
408 {
409     ScreenId screenId = 0;
410     ScreenId displayNodeScreenId = 0;
411     sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
412     screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
413     DMRect area;
414     bool foldToExpand = true;
415     RRect bounds;
416     bounds.rect_.width_ = 1344;
417     bounds.rect_.height_ = 2772;
418     float scaleX = 1.0;
419     float scaleY = 1.0;
420     ScreenDirectionInfo directionInfo;
421     directionInfo.notifyRotation_ = 90;
422     directionInfo.screenRotation_ = 90;
423     directionInfo.rotation_ = 90;
424     ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
425     screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
426         screenPropertyChangeType);
427     screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
428     screenSessionManagerClient_->GetPhyScreenProperty(screenId);
429     screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
430     screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
431     screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
432     sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
433     EXPECT_NE(screenSession1, nullptr);
434 }
435 
436 /**
437  * @tc.name: UpdateScreenRotationProperty02
438  * @tc.desc: UpdateScreenRotationProperty test
439  * @tc.type: FUNC
440  */
441 HWTEST_F(ScreenSessionManagerClientTest, UpdateScreenRotationProperty02, Function | SmallTest | Level2)
442 {
443     ScreenId screenId = 0;
444     ScreenId displayNodeScreenId = 0;
445     sptr<ScreenSession> screenSession = new ScreenSession(0, ScreenProperty(), 0);
446     screenSessionManagerClient_->screenSessionMap_.emplace(screenId, screenSession);
447     DMRect area;
448     bool foldToExpand = true;
449     RRect bounds;
450     bounds.rect_.width_ = 1344;
451     bounds.rect_.height_ = 2772;
452     float scaleX = 1.0;
453     float scaleY = 1.0;
454     ScreenDirectionInfo directionInfo;
455     directionInfo.notifyRotation_ = 90;
456     directionInfo.screenRotation_ = 90;
457     directionInfo.rotation_ = 90;
458     ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
459     screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
460         screenPropertyChangeType);
461     screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
462     screenSessionManagerClient_->GetPhyScreenProperty(screenId);
463     screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
464     screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
465     screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
466     sptr<ScreenSession> screenSession1 = screenSessionManagerClient_->GetScreenSession(screenId);
467     EXPECT_NE(screenSession1, nullptr);
468 }
469 
470 /**
471  * @tc.name: GetScreenSnapshot
472  * @tc.desc: GetScreenSnapshot test
473  * @tc.type: FUNC
474  */
475 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSnapshot, Function | SmallTest | Level2)
476 {
477     screenSessionManagerClient_->screenSessionMap_.clear();
478     ScreenId screenId = 0;
479     ScreenId displayNodeScreenId = 0;
480     float scaleX = 1.0;
481     float scaleY = 1.0;
482     RRect bounds;
483     bounds.rect_.width_ = 1344;
484     bounds.rect_.height_ = 2772;
485     ScreenDirectionInfo directionInfo;
486     directionInfo.notifyRotation_ = 90;
487     directionInfo.screenRotation_ = 90;
488     directionInfo.rotation_ = 90;
489     ScreenPropertyChangeType screenPropertyChangeType = ScreenPropertyChangeType::ROTATION_BEGIN;
490     screenSessionManagerClient_->UpdateScreenRotationProperty(screenId, bounds, directionInfo,
491         screenPropertyChangeType);
492     screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
493     std::shared_ptr<Media::PixelMap> res = screenSessionManagerClient_->GetScreenSnapshot(screenId, scaleX, scaleY);
494     EXPECT_EQ(nullptr, res);
495 }
496 
497 /**
498  * @tc.name: SetScreenOffDelayTime
499  * @tc.desc: SetScreenOffDelayTime test
500  * @tc.type: FUNC
501  */
502 HWTEST_F(ScreenSessionManagerClientTest, SetScreenOffDelayTime, Function | SmallTest | Level2)
503 {
504     screenSessionManagerClient_->screenSessionManager_ = nullptr;
505     int32_t ret = screenSessionManagerClient_->SetScreenOffDelayTime(1);
506     EXPECT_EQ(ret, 0);
507 }
508 
509 /**
510  * @tc.name: GetDeviceScreenConfig
511  * @tc.desc: GetDeviceScreenConfig test
512  * @tc.type: FUNC
513  */
514 HWTEST_F(ScreenSessionManagerClientTest, GetDeviceScreenConfig, Function | SmallTest | Level2)
515 {
516     DeviceScreenConfig deviceScreenConfig = screenSessionManagerClient_->GetDeviceScreenConfig();
517     EXPECT_FALSE(deviceScreenConfig.rotationPolicy_.empty());
518 }
519 
520 /**
521  * @tc.name: OnUpdateFoldDisplayMode
522  * @tc.desc: OnUpdateFoldDisplayMode test
523  * @tc.type: FUNC
524  */
525 HWTEST_F(ScreenSessionManagerClientTest, GetFoldDisplayMode, Function | SmallTest | Level2)
526 {
527     screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::UNKNOWN);
528     auto ret1 = screenSessionManagerClient_->GetFoldDisplayMode();
529     EXPECT_EQ(FoldDisplayMode::UNKNOWN, ret1);
530     screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::FULL);
531     auto ret2 = screenSessionManagerClient_->GetFoldDisplayMode();
532     EXPECT_EQ(FoldDisplayMode::FULL, ret2);
533     screenSessionManagerClient_->OnUpdateFoldDisplayMode(FoldDisplayMode::MAIN);
534     auto ret3 = screenSessionManagerClient_->GetFoldDisplayMode();
535     EXPECT_EQ(FoldDisplayMode::MAIN, ret3);
536 }
537 
538 /**
539  * @tc.name: GetScreenSessionById
540  * @tc.desc: GetScreenSessionById test
541  * @tc.type: FUNC
542  */
543 HWTEST_F(ScreenSessionManagerClientTest, GetScreenSessionById, Function | SmallTest | Level2)
544 {
545     ScreenId screenId = 0;
546     sptr<ScreenSession> ret = screenSessionManagerClient_->GetScreenSessionById(screenId);
547     EXPECT_EQ(nullptr, ret);
548 }
549 
550 /**
551  * @tc.name: ConnectToServer01
552  * @tc.desc: ConnectToServer test
553  * @tc.type: FUNC
554  */
555 HWTEST_F(ScreenSessionManagerClientTest, ConnectToServer01, Function | SmallTest | Level2)
556 {
557     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
558 
559     screenSessionManagerClient_->screenSessionManager_ = nullptr;
560     screenSessionManagerClient_->ConnectToServer();
561 }
562 
563 /**
564  * @tc.name: OnPropertyChanged
565  * @tc.desc: OnPropertyChanged test
566  * @tc.type: FUNC
567  */
568 HWTEST_F(ScreenSessionManagerClientTest, OnPropertyChanged, Function | SmallTest | Level2)
569 {
570     ScreenId screenId = 0;
571     ScreenProperty property;
572     ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
573 
574     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
575     screenSessionManagerClient_->OnPropertyChanged(screenId, property, reason);
576 }
577 
578 /**
579  * @tc.name: OnSensorRotationChanged01
580  * @tc.desc: OnSensorRotationChanged test
581  * @tc.type: FUNC
582  */
583 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged01, Function | SmallTest | Level2)
584 {
585     ScreenId screenId = 0;
586     float sensorRotation = 0;
587 
588     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
589     screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
590 }
591 
592 /**
593  * @tc.name: OnSensorRotationChanged02
594  * @tc.desc: OnSensorRotationChanged test
595  * @tc.type: FUNC
596  */
597 HWTEST_F(ScreenSessionManagerClientTest, OnSensorRotationChanged02, Function | SmallTest | Level2)
598 {
599     ScreenId screenId = 1;
600     float sensorRotation = 90.0f;
601 
602     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
603     screenSessionManagerClient_->OnSensorRotationChanged(screenId, sensorRotation);
604 }
605 
606 /**
607  * @tc.name: OnHoverStatusChanged01
608  * @tc.desc: OnHoverStatusChanged test
609  * @tc.type: FUNC
610  */
611 HWTEST_F(ScreenSessionManagerClientTest, OnHoverStatusChanged01, Function | SmallTest | Level2)
612 {
613     ScreenId screenId = 0;
614     int32_t hoverStatus = 0;
615 
616     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
617     screenSessionManagerClient_->OnHoverStatusChanged(screenId, hoverStatus);
618 }
619 
620 /**
621  * @tc.name: OnScreenOrientationChanged01
622  * @tc.desc: OnScreenOrientationChanged test
623  * @tc.type: FUNC
624  */
625 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged01, Function | SmallTest | Level2)
626 {
627     ScreenId screenId = 0;
628     float screenOrientation = 0;
629 
630     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
631     screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
632 }
633 
634 /**
635  * @tc.name: OnScreenOrientationChanged02
636  * @tc.desc: OnScreenOrientationChanged test
637  * @tc.type: FUNC
638  */
639 HWTEST_F(ScreenSessionManagerClientTest, OnScreenOrientationChanged02, Function | SmallTest | Level2)
640 {
641     ScreenId screenId = 1;
642     float screenOrientation = 90.0f;
643 
644     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
645     screenSessionManagerClient_->OnScreenOrientationChanged(screenId, screenOrientation);
646 }
647 
648 /**
649  * @tc.name: OnScreenRotationLockedChanged01
650  * @tc.desc: OnScreenRotationLockedChanged test
651  * @tc.type: FUNC
652  */
653 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged01, Function | SmallTest | Level2)
654 {
655     ScreenId screenId = 0;
656     bool isLocked = false;
657 
658     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
659     screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
660 }
661 
662 /**
663  * @tc.name: OnScreenRotationLockedChanged02
664  * @tc.desc: OnScreenRotationLockedChanged test
665  * @tc.type: FUNC
666  */
667 HWTEST_F(ScreenSessionManagerClientTest, OnScreenRotationLockedChanged02, Function | SmallTest | Level2)
668 {
669     ScreenId screenId = 1;
670     bool isLocked = true;
671 
672     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
673     screenSessionManagerClient_->OnScreenRotationLockedChanged(screenId, isLocked);
674 }
675 
676 /**
677  * @tc.name: RegisterDisplayChangeListener
678  * @tc.desc: RegisterDisplayChangeListener test
679  * @tc.type: FUNC
680  */
681 HWTEST_F(ScreenSessionManagerClientTest, RegisterDisplayChangeListener, Function | SmallTest | Level2)
682 {
683     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
684     screenSessionManagerClient_->RegisterDisplayChangeListener(nullptr);
685 }
686 
687 /**
688  * @tc.name: OnDisplayStateChanged01
689  * @tc.desc: OnDisplayStateChanged test
690  * @tc.type: FUNC
691  */
692 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged01, Function | SmallTest | Level2)
693 {
694     DisplayId defaultDisplayId = 0;
695     sptr<DisplayInfo> displayInfo = new DisplayInfo();
696     std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
697         { displayInfo->GetDisplayId(), displayInfo },
698     };
699     DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
700 
701     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
702     screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
703 }
704 
705 /**
706  * @tc.name: OnDisplayStateChanged02
707  * @tc.desc: OnDisplayStateChanged test
708  * @tc.type: FUNC
709  */
710 HWTEST_F(ScreenSessionManagerClientTest, OnDisplayStateChanged02, Function | SmallTest | Level2)
711 {
712     DisplayId defaultDisplayId = 0;
713     sptr<DisplayInfo> displayInfo = new DisplayInfo();
714     std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
715         { displayInfo->GetDisplayId(), displayInfo },
716     };
717     DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
718 
719     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
720     screenSessionManagerClient_->displayChangeListener_ = nullptr;
721     screenSessionManagerClient_->OnDisplayStateChanged(defaultDisplayId, displayInfo, displayInfoMap, type);
722 }
723 
724 /**
725  * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged01
726  * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
727  * @tc.type: FUNC
728  */
729 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged01, Function | SmallTest | Level2)
730 {
731     std::vector<uint64_t> missionIds = {0, 1};
732     std::vector<uint64_t> surfaceNodeIds;
733     bool isBlackList = false;
734 
735     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
736     screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
737 }
738 
739 /**
740  * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged02
741  * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
742  * @tc.type: FUNC
743  */
744 HWTEST_F(ScreenSessionManagerClientTest, OnGetSurfaceNodeIdsFromMissionIdsChanged02, Function | SmallTest | Level2)
745 {
746     std::vector<uint64_t> missionIds = {0, 1};
747     std::vector<uint64_t> surfaceNodeIds;
748     bool isBlackList = false;
749 
750     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
751     screenSessionManagerClient_->displayChangeListener_ = nullptr;
752     screenSessionManagerClient_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
753 }
754 
755 /**
756  * @tc.name: OnScreenshot01
757  * @tc.desc: OnScreenshot test
758  * @tc.type: FUNC
759  */
760 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot01, Function | SmallTest | Level2)
761 {
762     DisplayId displayId = 0;
763 
764     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
765     screenSessionManagerClient_->OnScreenshot(displayId);
766 }
767 
768 /**
769  * @tc.name: OnScreenshot02
770  * @tc.desc: OnScreenshot test
771  * @tc.type: FUNC
772  */
773 HWTEST_F(ScreenSessionManagerClientTest, OnScreenshot02, Function | SmallTest | Level2)
774 {
775     DisplayId displayId = 0;
776 
777     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
778     screenSessionManagerClient_->displayChangeListener_ = nullptr;
779     screenSessionManagerClient_->OnScreenshot(displayId);
780 }
781 
782 /**
783  * @tc.name: OnImmersiveStateChanged01
784  * @tc.desc: OnImmersiveStateChanged test
785  * @tc.type: FUNC
786  */
787 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged01, Function | SmallTest | Level2)
788 {
789     bool immersive = false;
790 
791     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
792     screenSessionManagerClient_->OnImmersiveStateChanged(immersive);
793 }
794 
795 /**
796  * @tc.name: OnImmersiveStateChanged02
797  * @tc.desc: OnImmersiveStateChanged test
798  * @tc.type: FUNC
799  */
800 HWTEST_F(ScreenSessionManagerClientTest, OnImmersiveStateChanged02, Function | SmallTest | Level2)
801 {
802     bool immersive = false;
803 
804     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
805     screenSessionManagerClient_->displayChangeListener_ = nullptr;
806     screenSessionManagerClient_->OnImmersiveStateChanged(immersive);
807 }
808 
809 /**
810  * @tc.name: SetDisplayNodeScreenId
811  * @tc.desc: SetDisplayNodeScreenId test
812  * @tc.type: FUNC
813  */
814 HWTEST_F(ScreenSessionManagerClientTest, SetDisplayNodeScreenId, Function | SmallTest | Level2)
815 {
816     ScreenId screenId = 0;
817     ScreenId displayNodeScreenId = 0;
818 
819     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
820     screenSessionManagerClient_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
821 }
822 
823 /**
824  * @tc.name: GetCurvedCompressionArea
825  * @tc.desc: GetCurvedCompressionArea test
826  * @tc.type: FUNC
827  */
828 HWTEST_F(ScreenSessionManagerClientTest, GetCurvedCompressionArea, Function | SmallTest | Level2)
829 {
830     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
831     screenSessionManagerClient_->GetCurvedCompressionArea();
832 }
833 
834 /**
835  * @tc.name: GetPhyScreenProperty
836  * @tc.desc: GetPhyScreenProperty test
837  * @tc.type: FUNC
838  */
839 HWTEST_F(ScreenSessionManagerClientTest, GetPhyScreenProperty, Function | SmallTest | Level2)
840 {
841     ScreenId screenId = 0;
842     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
843     screenSessionManagerClient_->GetPhyScreenProperty(screenId);
844 }
845 
846 /**
847  * @tc.name: NotifyDisplayChangeInfoChanged
848  * @tc.desc: NotifyDisplayChangeInfoChanged test
849  * @tc.type: FUNC
850  */
851 HWTEST_F(ScreenSessionManagerClientTest, NotifyDisplayChangeInfoChanged, Function | SmallTest | Level2)
852 {
853     sptr<DisplayChangeInfo> info = new DisplayChangeInfo();
854     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
855     screenSessionManagerClient_->NotifyDisplayChangeInfoChanged(info);
856 }
857 
858 /**
859  * @tc.name: SetScreenPrivacyState01
860  * @tc.desc: SetScreenPrivacyState test
861  * @tc.type: FUNC
862  */
863 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState01, Function | SmallTest | Level2)
864 {
865     bool hasPrivate = false;
866     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
867     screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
868 }
869 
870 /**
871  * @tc.name: SetScreenPrivacyState02
872  * @tc.desc: SetScreenPrivacyState test
873  * @tc.type: FUNC
874  */
875 HWTEST_F(ScreenSessionManagerClientTest, SetScreenPrivacyState02, Function | SmallTest | Level2)
876 {
877     bool hasPrivate = false;
878     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
879     sptr<IRemoteObject> iRemoteObjectMocker = new IRemoteObjectMocker();
880     screenSessionManagerClient_->screenSessionManager_ = new ScreenSessionManagerProxy(iRemoteObjectMocker);
881     EXPECT_NE(screenSessionManagerClient_->screenSessionManager_, nullptr);
882     screenSessionManagerClient_->SetScreenPrivacyState(hasPrivate);
883 }
884 
885 /**
886  * @tc.name: SetPrivacyStateByDisplayId
887  * @tc.desc: SetPrivacyStateByDisplayId test
888  * @tc.type: FUNC
889  */
890 HWTEST_F(ScreenSessionManagerClientTest, SetPrivacyStateByDisplayId, Function | SmallTest | Level2)
891 {
892     DisplayId id = 0;
893     bool hasPrivate = false;
894     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
895     screenSessionManagerClient_->SetPrivacyStateByDisplayId(id, hasPrivate);
896 }
897 
898 /**
899  * @tc.name: UpdateAvailableArea
900  * @tc.desc: UpdateAvailableArea test
901  * @tc.type: FUNC
902  */
903 HWTEST_F(ScreenSessionManagerClientTest, UpdateAvailableArea, Function | SmallTest | Level2)
904 {
905     ScreenId screenId = 0;
906     DMRect area;
907 
908     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
909     screenSessionManagerClient_->UpdateAvailableArea(screenId, area);
910 }
911 
912 /**
913  * @tc.name: NotifyFoldToExpandCompletion
914  * @tc.desc: NotifyFoldToExpandCompletion test
915  * @tc.type: FUNC
916  */
917 HWTEST_F(ScreenSessionManagerClientTest, NotifyFoldToExpandCompletion, Function | SmallTest | Level2)
918 {
919     bool foldToExpand = true;
920 
921     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
922     screenSessionManagerClient_->NotifyFoldToExpandCompletion(foldToExpand);
923 }
924 
925 /**
926  * @tc.name: SwitchUserCallback01
927  * @tc.desc: SwitchUserCallback test
928  * @tc.type: FUNC
929  */
930 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback01, Function | SmallTest | Level2)
931 {
932     std::vector<int32_t> oldScbPids = {0, 1};
933     int32_t currentScbPid = 1;
934 
935     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
936     screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
937 }
938 
939 /**
940  * @tc.name: SwitchUserCallback02
941  * @tc.desc: SwitchUserCallback test
942  * @tc.type: FUNC
943  */
944 HWTEST_F(ScreenSessionManagerClientTest, SwitchUserCallback02, Function | SmallTest | Level2)
945 {
946     std::vector<int32_t> oldScbPids = {};
947     int32_t currentScbPid = 1;
948 
949     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
950     screenSessionManagerClient_->SwitchUserCallback(oldScbPids, currentScbPid);
951 }
952 
953 /**
954  * @tc.name: SwitchingCurrentUser
955  * @tc.desc: SwitchingCurrentUser test
956  * @tc.type: FUNC
957  */
958 HWTEST_F(ScreenSessionManagerClientTest, SwitchingCurrentUser, Function | SmallTest | Level2)
959 {
960     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
961     screenSessionManagerClient_->SwitchingCurrentUser();
962 }
963 
964 /**
965  * @tc.name: GetFoldStatus
966  * @tc.desc: GetFoldStatus test
967  * @tc.type: FUNC
968  */
969 HWTEST_F(ScreenSessionManagerClientTest, GetFoldStatus, Function | SmallTest | Level2)
970 {
971     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
972     screenSessionManagerClient_->GetFoldStatus();
973 }
974 
975 /**
976  * @tc.name: GetDefaultScreenId
977  * @tc.desc: GetDefaultScreenId test
978  * @tc.type: FUNC
979  */
980 HWTEST_F(ScreenSessionManagerClientTest, GetDefaultScreenId, Function | SmallTest | Level2)
981 {
982     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
983     screenSessionManagerClient_->GetDefaultScreenId();
984 }
985 
986 /**
987  * @tc.name: IsFoldable
988  * @tc.desc: IsFoldable test
989  * @tc.type: FUNC
990  */
991 HWTEST_F(ScreenSessionManagerClientTest, IsFoldable, Function | SmallTest | Level2)
992 {
993     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
994     screenSessionManagerClient_->IsFoldable();
995 }
996 
997 /**
998  * @tc.name: SetVirtualPixelRatioSystem
999  * @tc.desc: SetVirtualPixelRatioSystem test
1000  * @tc.type: FUNC
1001  */
1002 HWTEST_F(ScreenSessionManagerClientTest, SetVirtualPixelRatioSystem, Function | SmallTest | Level2)
1003 {
1004     ScreenId screenId = 0;
1005     float virtualPixelRatio = 1.0f;
1006 
1007     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1008     screenSessionManagerClient_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
1009 }
1010 
1011 /**
1012  * @tc.name: UpdateDisplayHookInfo
1013  * @tc.desc: UpdateDisplayHookInfo test
1014  * @tc.type: FUNC
1015  */
1016 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayHookInfo, Function | SmallTest | Level2)
1017 {
1018     int32_t uid = 0;
1019     bool enable = false;
1020     DMHookInfo hookInfo;
1021     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1022     screenSessionManagerClient_->UpdateDisplayHookInfo(uid, enable, hookInfo);
1023 }
1024 
1025 /**
1026  * @tc.name: OnFoldStatusChangedReportUE
1027  * @tc.desc: OnFoldStatusChangedReportUE test
1028  * @tc.type: FUNC
1029  */
1030 HWTEST_F(ScreenSessionManagerClientTest, OnFoldStatusChangedReportUE, Function | SmallTest | Level2)
1031 {
1032     std::vector<std::string> screenFoldInfo;
1033 
1034     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1035     screenSessionManagerClient_->OnFoldStatusChangedReportUE(screenFoldInfo);
1036 }
1037 
1038 /**
1039  * @tc.name: UpdateDisplayScale01
1040  * @tc.desc: UpdateDisplayScale test
1041  * @tc.type: FUNC
1042 */
1043 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale01, Function | SmallTest | Level2)
1044 {
1045     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1046     const float scaleX = 1.0f;
1047     const float scaleY = 1.0f;
1048     const float pivotX = 0.5f;
1049     const float pivotY = 0.5f;
1050     const float translateX = 0.0f;
1051     const float translateY = 0.0f;
1052     ScreenId defaultScreenId = screenSessionManagerClient_->GetDefaultScreenId();
1053     screenSessionManagerClient_->UpdateDisplayScale(defaultScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1054                                                     translateY);
1055 }
1056 
1057 /**
1058  * @tc.name: UpdateDisplayScale02
1059  * @tc.desc: UpdateDisplayScale test
1060  * @tc.type: FUNC
1061 */
1062 HWTEST_F(ScreenSessionManagerClientTest, UpdateDisplayScale02, Function | SmallTest | Level2)
1063 {
1064     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1065     const float scaleX = 1.0f;
1066     const float scaleY = 1.0f;
1067     const float pivotX = 0.5f;
1068     const float pivotY = 0.5f;
1069     const float translateX = 0.0f;
1070     const float translateY = 0.0f;
1071     uint64_t fakeScreenId = 100;
1072     screenSessionManagerClient_->UpdateDisplayScale(fakeScreenId, scaleX, scaleY, pivotX, pivotY, translateX,
1073                                                     translateY);
1074 }
1075 
1076 /**
1077  * @tc.name: ScreenCaptureNotify
1078  * @tc.desc: ScreenCaptureNotify test
1079  * @tc.type: FUNC
1080  */
1081 HWTEST_F(ScreenSessionManagerClientTest, ScreenCaptureNotify, Function | SmallTest | Level2)
1082 {
1083     ScreenId screenId = 0;
1084     int32_t uid = 0;
1085     std::string clientName = "test";
1086     ASSERT_TRUE(screenSessionManagerClient_ != nullptr);
1087     screenSessionManagerClient_->ScreenCaptureNotify(screenId, uid, clientName);
1088 }
1089 } // namespace Rosen
1090 } // namespace OHOS
1091