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 #include <transaction/rs_marshalling_helper.h>
18 
19 #include "screen_session_manager_client.h"
20 #include "screen_session_manager_client_interface.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace Rosen {
27 class ScreenSessionManagerClientStubTest : public testing::Test {
28 public:
29     void SetUp() override;
30     void TearDown() override;
31     sptr<ScreenSessionManagerClientStub> screenSessionManagerClientStub_;
32 };
33 
SetUp()34 void ScreenSessionManagerClientStubTest::SetUp()
35 {
36     screenSessionManagerClientStub_ = new ScreenSessionManagerClient();
37 }
38 
TearDown()39 void ScreenSessionManagerClientStubTest::TearDown()
40 {
41     screenSessionManagerClientStub_ = nullptr;
42 }
43 
44 /**
45  * @tc.name: OnRemoteRequest01
46  * @tc.desc: TRANS_ID_ON_SCREEN_CONNECTION_CHANGED
47  * @tc.type: FUNC
48  */
49 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest01, Function | SmallTest | Level1)
50 {
51     MessageParcel data;
52     MessageParcel reply;
53     MessageOption option;
54 
55     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
56     ScreenId screenId = 0;
57     data.WriteUint64(screenId);
58     ScreenEvent event = ScreenEvent::UNKNOWN;
59     data.WriteUint8(static_cast<uint8_t>(event));
60     ScreenId rsId = 0;
61     data.WriteUint64(rsId);
62     std::string name = "screen";
63     data.WriteString(name);
64 
65     uint32_t code = static_cast<uint32_t>(
66         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_CONNECTION_CHANGED);
67     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
68     EXPECT_EQ(res, 0);
69 }
70 
71 /**
72  * @tc.name: OnRemoteRequest02
73  * @tc.desc: TRANS_ID_ON_PROPERTY_CHANGED
74  * @tc.type: FUNC
75  */
76 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest02, Function | SmallTest | Level1)
77 {
78     MessageParcel data;
79     MessageParcel reply;
80     MessageOption option;
81 
82     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
83     ScreenId screenId = 0;
84     data.WriteUint64(screenId);
85     ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
86     data.WriteUint32(static_cast<uint32_t>(reason));
87 
88     uint32_t code = static_cast<uint32_t>(
89         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_PROPERTY_CHANGED);
90     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
91     EXPECT_NE(res, 0);
92 }
93 
94 /**
95  * @tc.name: OnRemoteRequest03
96  * @tc.desc: TRANS_ID_ON_POWER_STATUS_CHANGED
97  * @tc.type: FUNC
98  */
99 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest03, Function | SmallTest | Level1)
100 {
101     MessageParcel data;
102     MessageParcel reply;
103     MessageOption option;
104 
105     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
106     DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_OFF;
107     data.WriteUint32(static_cast<uint32_t>(event));
108     EventStatus status = EventStatus::BEGIN;
109     data.WriteUint32(static_cast<uint32_t>(status));
110     PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
111     data.WriteUint32(static_cast<uint32_t>(reason));
112 
113     uint32_t code = static_cast<uint32_t>(
114         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_POWER_STATUS_CHANGED);
115     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
116     EXPECT_EQ(res, 0);
117 }
118 
119 /**
120  * @tc.name: OnRemoteRequest04
121  * @tc.desc: TRANS_ID_ON_SENSOR_ROTATION_CHANGED
122  * @tc.type: FUNC
123  */
124 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest04, Function | SmallTest | Level1)
125 {
126     MessageParcel data;
127     MessageParcel reply;
128     MessageOption option;
129 
130     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
131     ScreenId screenId = 0;
132     data.WriteUint64(screenId);
133     float rotation = 90.0f;
134     data.WriteFloat(rotation);
135 
136     uint32_t code = static_cast<uint32_t>(
137         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SENSOR_ROTATION_CHANGED);
138     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
139     EXPECT_EQ(res, 0);
140 }
141 
142 /**
143  * @tc.name: OnRemoteRequest05
144  * @tc.desc: TRANS_ID_ON_SCREEN_ORIENTATION_CHANGED
145  * @tc.type: FUNC
146  */
147 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest05, Function | SmallTest | Level1)
148 {
149     MessageParcel data;
150     MessageParcel reply;
151     MessageOption option;
152 
153     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
154     ScreenId screenId = 0;
155     data.WriteUint64(screenId);
156     float rotation = 0.0f;
157     data.WriteFloat(rotation);
158 
159     uint32_t code = static_cast<uint32_t>(
160         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_ORIENTATION_CHANGED);
161     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
162     EXPECT_EQ(res, 0);
163 }
164 
165 /**
166  * @tc.name: OnRemoteRequest06
167  * @tc.desc: TRANS_ID_ON_SCREEN_ROTATION_LOCKED_CHANGED
168  * @tc.type: FUNC
169  */
170 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest06, Function | SmallTest | Level1)
171 {
172     MessageParcel data;
173     MessageParcel reply;
174     MessageOption option;
175 
176     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
177     ScreenId screenId = 0;
178     data.WriteUint64(screenId);
179     bool isLocked = false;
180     data.WriteBool(isLocked);
181 
182     uint32_t code = static_cast<uint32_t>(
183         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_ROTATION_LOCKED_CHANGED);
184     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
185     EXPECT_EQ(res, 0);
186 }
187 
188 /**
189  * @tc.name: OnRemoteRequest07
190  * @tc.desc: TRANS_ID_ON_DISPLAY_STATE_CHANGED
191  * @tc.type: FUNC
192  */
193 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest07, Function | SmallTest | Level1)
194 {
195     MessageParcel data;
196     MessageParcel reply;
197     MessageOption option;
198 
199     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
200     DisplayId screenId = 0;
201     data.WriteUint64(screenId);
202     sptr<DisplayInfo> displayInfo;
203     data.WriteStrongParcelable(displayInfo);
204     std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap;
205     for (auto [id, info] : displayInfoMap) {
206         data.WriteUint64(id);
207         data.WriteStrongParcelable(info);
208     }
209     DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
210     data.WriteUint32(static_cast<uint32_t>(type));
211     auto mapSize = static_cast<uint32_t>(displayInfoMap.size());
212     data.WriteUint32(mapSize);
213 
214     uint32_t code = static_cast<uint32_t>(
215         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_DISPLAY_STATE_CHANGED);
216     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
217     EXPECT_EQ(res, 0);
218 }
219 
220 /**
221  * @tc.name: OnRemoteRequest08
222  * @tc.desc: TRANS_ID_ON_SCREEN_SHOT
223  * @tc.type: FUNC
224  */
225 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest08, Function | SmallTest | Level1)
226 {
227     MessageParcel data;
228     MessageParcel reply;
229     MessageOption option;
230 
231     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
232     DisplayId screenId = 0;
233     data.WriteUint64(screenId);
234 
235     uint32_t code = static_cast<uint32_t>(
236         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_SHOT);
237     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
238     EXPECT_EQ(res, 0);
239 }
240 
241 /**
242  * @tc.name: OnRemoteRequest09
243  * @tc.desc: TRANS_ID_ON_IMMERSIVE_STATE_CHANGED
244  * @tc.type: FUNC
245  */
246 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest09, Function | SmallTest | Level1)
247 {
248     MessageParcel data;
249     MessageParcel reply;
250     MessageOption option;
251 
252     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
253 
254     uint32_t code = static_cast<uint32_t>(
255         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_IMMERSIVE_STATE_CHANGED);
256     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
257     EXPECT_EQ(res, 0);
258 }
259 
260 /**
261  * @tc.name: OnRemoteRequest10
262  * @tc.desc: TRANS_ID_SET_DISPLAY_NODE_SCREEN_ID
263  * @tc.type: FUNC
264  */
265 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest10, Function | SmallTest | Level1)
266 {
267     MessageParcel data;
268     MessageParcel reply;
269     MessageOption option;
270 
271     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
272     ScreenId screenId = 0;
273     data.WriteUint64(screenId);
274     ScreenId displayNodeScreenId = 0;
275     data.WriteUint64(displayNodeScreenId);
276 
277     uint32_t code = static_cast<uint32_t>(
278         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_SET_DISPLAY_NODE_SCREEN_ID);
279     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
280     EXPECT_EQ(res, 0);
281 }
282 
283 /**
284  * @tc.name: OnRemoteRequest11
285  * @tc.desc: TRANS_ID_GET_SURFACENODEID_FROM_MISSIONID
286  * @tc.type: FUNC
287  */
288 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest11, Function | SmallTest | Level1)
289 {
290     MessageParcel data;
291     MessageParcel reply;
292     MessageOption option;
293 
294     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
295     std::vector<uint64_t> missionIds = {0, 1};
296     data.WriteUInt64Vector(missionIds);
297     std::vector<uint64_t> surfaceNodeIds = {0, 1};
298     data.WriteUInt64Vector(surfaceNodeIds);
299 
300     uint32_t code = static_cast<uint32_t>(
301         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_GET_SURFACENODEID_FROM_MISSIONID);
302     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
303     EXPECT_EQ(res, 0);
304 }
305 
306 /**
307  * @tc.name: OnRemoteRequest12
308  * @tc.desc: TRANS_ID_SET_FOLD_DISPLAY_MODE
309  * @tc.type: FUNC
310  */
311 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest12, Function | SmallTest | Level1)
312 {
313     MessageParcel data;
314     MessageParcel reply;
315     MessageOption option;
316 
317     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
318     FoldDisplayMode displayMode = FoldDisplayMode::FULL;
319     data.WriteUint32(static_cast<uint32_t>(displayMode));
320 
321     uint32_t code = static_cast<uint32_t>(
322         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_SET_FOLD_DISPLAY_MODE);
323     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
324     EXPECT_EQ(res, 0);
325 }
326 
327 /**
328  * @tc.name: OnRemoteRequest13
329  * @tc.desc: TRANS_ID_ON_SWITCH_USER_CMD
330  * @tc.type: FUNC
331  */
332 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest13, Function | SmallTest | Level1)
333 {
334     MessageParcel data;
335     MessageParcel reply;
336     MessageOption option;
337 
338     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
339     std::vector<int32_t> oldScbPids = {0, 1};
340     data.WriteInt32Vector(oldScbPids);
341     int32_t currentScbPid = 0;
342     data.WriteInt32(currentScbPid);
343 
344     uint32_t code = static_cast<uint32_t>(
345         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SWITCH_USER_CMD);
346     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
347     EXPECT_EQ(res, 0);
348 }
349 
350 /**
351  * @tc.name: OnRemoteRequest14
352  * @tc.desc: TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM
353  * @tc.type: FUNC
354  */
355 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest14, Function | SmallTest | Level1)
356 {
357     MessageParcel data;
358     MessageParcel reply;
359     MessageOption option;
360 
361     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
362     ScreenId screenId = 0;
363     data.WriteUint64(screenId);
364     float virtualPixelRatio = 0.0f;
365     data.WriteFloat(virtualPixelRatio);
366 
367     uint32_t code = static_cast<uint32_t>(
368         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM);
369     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
370     EXPECT_EQ(res, 0);
371 }
372 
373 /**
374  * @tc.name: OnRemoteRequest15
375  * @tc.desc: TRANS_ID_ON_FOLDSTATUS_CHANGED_REPORT_UE
376  * @tc.type: FUNC
377  */
378 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest15, Function | SmallTest | Level1)
379 {
380     MessageParcel data;
381     MessageParcel reply;
382     MessageOption option;
383 
384     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
385     std::vector<std::string> screenFoldInfo{""};
386     data.WriteStringVector(screenFoldInfo);
387 
388     uint32_t code = static_cast<uint32_t>(
389         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_FOLDSTATUS_CHANGED_REPORT_UE);
390     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
391     EXPECT_EQ(res, 0);
392 }
393 
394 /**
395  * @tc.name: OnRemoteRequest16
396  * @tc.desc: default
397  * @tc.type: FUNC
398  */
399 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest16, Function | SmallTest | Level1)
400 {
401     MessageParcel data;
402     MessageParcel reply;
403     MessageOption option;
404 
405     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
406 
407     uint32_t code = static_cast<uint32_t>(20);
408     screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
409     int res = 0;
410     EXPECT_EQ(res, 0);
411 }
412 
413 /**
414  * @tc.name: OnRemoteRequest18
415  * @tc.desc: TRANS_ID_ON_HOVER_STATUS_CHANGED
416  * @tc.type: FUNC
417  */
418 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest18, Function | SmallTest | Level1)
419 {
420     MessageParcel data;
421     MessageParcel reply;
422     MessageOption option;
423 
424     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
425 
426     ScreenId screenId = 0;
427     data.WriteUint64(screenId);
428     int32_t hoverStatus = 1;
429     data.WriteInt32(hoverStatus);
430 
431     uint32_t code = static_cast<uint32_t>(
432         IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_HOVER_STATUS_CHANGED);
433     int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
434     EXPECT_EQ(res, 0);
435 }
436 
437 /**
438  * @tc.name: HandleOnScreenConnectionChanged
439  * @tc.desc: HandleOnScreenConnectionChanged test
440  * @tc.type: FUNC
441  */
442 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenConnectionChanged, Function | SmallTest | Level2)
443 {
444     MessageParcel data;
445     MessageParcel reply;
446 
447     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
448     ScreenId screenId = 0;
449     data.WriteUint64(screenId);
450     ScreenEvent screenEvent = ScreenEvent::CONNECTED;
451     data.WriteUint8(static_cast<uint8_t>(screenEvent));
452     ScreenId rsId = 0;
453     data.WriteUint64(rsId);
454     std::string name;
455     data.WriteString(name);
456 
457     int ret = screenSessionManagerClientStub_->HandleOnScreenConnectionChanged(data, reply);
458     EXPECT_EQ(ret, 0);
459 }
460 
461 /**
462  * @tc.name: HandleOnPropertyChanged
463  * @tc.desc: HandleOnPropertyChanged test
464  * @tc.type: FUNC
465  */
466 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPropertyChanged, Function | SmallTest | Level2)
467 {
468     MessageParcel data;
469     MessageParcel reply;
470 
471     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
472     ScreenId screenId = 0;
473     data.WriteUint64(screenId);
474     ScreenProperty property;
475     RSMarshallingHelper::Marshalling(data, property);
476     ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
477     data.WriteUint32(static_cast<uint32_t>(reason));
478 
479     int ret = screenSessionManagerClientStub_->HandleOnPropertyChanged(data, reply);
480     EXPECT_EQ(ret, 0);
481 }
482 
483 /**
484  * @tc.name: HandleOnHoverStatusChanged
485  * @tc.desc: HandleOnHoverStatusChanged test
486  * @tc.type: FUNC
487  */
488 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnHoverStatusChanged, Function | SmallTest | Level2)
489 {
490     MessageParcel data;
491     MessageParcel reply;
492 
493     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
494     ScreenId screenId = 0;
495     data.WriteUint64(screenId);
496     int32_t hoverStatus = 0;
497     data.WriteInt32(hoverStatus);
498 
499     int ret = screenSessionManagerClientStub_->HandleOnHoverStatusChanged(data, reply);
500     EXPECT_EQ(ret, 0);
501 }
502 
503 /**
504  * @tc.name: HandleOnSensorRotationChanged
505  * @tc.desc: HandleOnSensorRotationChanged test
506  * @tc.type: FUNC
507  */
508 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSensorRotationChanged, Function | SmallTest | Level2)
509 {
510     MessageParcel data;
511     MessageParcel reply;
512 
513     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
514     ScreenId screenId = 0;
515     data.WriteUint64(screenId);
516     float sensorRotation = 0;
517     data.WriteFloat(sensorRotation);
518 
519     int ret = screenSessionManagerClientStub_->HandleOnSensorRotationChanged(data, reply);
520     EXPECT_EQ(ret, 0);
521 }
522 
523 /**
524  * @tc.name: HandleOnScreenOrientationChanged
525  * @tc.desc: HandleOnScreenOrientationChanged test
526  * @tc.type: FUNC
527  */
528 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenOrientationChanged, Function | SmallTest | Level2)
529 {
530     MessageParcel data;
531     MessageParcel reply;
532 
533     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
534     ScreenId screenId = 0;
535     data.WriteUint64(screenId);
536     float screenOrientation = 0;
537     data.WriteFloat(screenOrientation);
538 
539     int ret = screenSessionManagerClientStub_->HandleOnScreenOrientationChanged(data, reply);
540     EXPECT_EQ(ret, 0);
541 }
542 
543 /**
544  * @tc.name: HandleOnScreenRotationLockedChanged
545  * @tc.desc: HandleOnScreenRotationLockedChanged test
546  * @tc.type: FUNC
547  */
548 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenRotationLockedChanged, Function | SmallTest | Level2)
549 {
550     MessageParcel data;
551     MessageParcel reply;
552 
553     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
554     ScreenId screenId = 0;
555     data.WriteUint64(screenId);
556     bool isLocked = false;
557     data.WriteBool(isLocked);
558 
559     int ret = screenSessionManagerClientStub_->HandleOnScreenRotationLockedChanged(data, reply);
560     EXPECT_EQ(ret, 0);
561 }
562 
563 /**
564  * @tc.name: HandleOnDisplayStateChanged
565  * @tc.desc: HandleOnDisplayStateChanged test
566  * @tc.type: FUNC
567  */
568 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnDisplayStateChanged, Function | SmallTest | Level2)
569 {
570     MessageParcel data;
571     MessageParcel reply;
572 
573     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
574     ScreenId screenId = 0;
575     data.WriteUint64(screenId);
576     sptr<DisplayInfo> displayInfo = new DisplayInfo();
577     data.WriteStrongParcelable(displayInfo);
578     data.WriteUint32(0);
579     DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
580     data.WriteUint32(static_cast<uint32_t>(type));
581 
582     int ret = screenSessionManagerClientStub_->HandleOnDisplayStateChanged(data, reply);
583     EXPECT_EQ(ret, 0);
584 }
585 
586 /**
587  * @tc.name: HandleOnScreenshot
588  * @tc.desc: HandleOnScreenshot test
589  * @tc.type: FUNC
590  */
591 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenshot, Function | SmallTest | Level2)
592 {
593     MessageParcel data;
594     MessageParcel reply;
595 
596     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
597     ScreenId screenId = 0;
598     data.WriteUint64(screenId);
599 
600     int ret = screenSessionManagerClientStub_->HandleOnScreenshot(data, reply);
601     EXPECT_EQ(ret, 0);
602 }
603 
604 /**
605  * @tc.name: HandleOnImmersiveStateChanged
606  * @tc.desc: HandleOnImmersiveStateChanged test
607  * @tc.type: FUNC
608  */
609 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnImmersiveStateChanged, Function | SmallTest | Level2)
610 {
611     MessageParcel data;
612     MessageParcel reply;
613 
614     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
615 
616     int ret = screenSessionManagerClientStub_->HandleOnImmersiveStateChanged(data, reply);
617     EXPECT_EQ(ret, 0);
618 }
619 
620 /**
621  * @tc.name: HandleOnPowerStatusChanged
622  * @tc.desc: HandleOnPowerStatusChanged test
623  * @tc.type: FUNC
624  */
625 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPowerStatusChanged, Function | SmallTest | Level2)
626 {
627     MessageParcel data;
628     MessageParcel reply;
629 
630     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
631 
632     int ret = screenSessionManagerClientStub_->HandleOnPowerStatusChanged(data, reply);
633     EXPECT_EQ(ret, 0);
634 }
635 
636 /**
637  * @tc.name: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged
638  * @tc.desc: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged test
639  * @tc.type: FUNC
640  */
641 HWTEST_F(ScreenSessionManagerClientStubTest,
642     HandleOnGetSurfaceNodeIdsFromMissionIdsChanged, Function | SmallTest | Level2)
643 {
644     MessageParcel data;
645     MessageParcel reply;
646 
647     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
648 
649     int ret = screenSessionManagerClientStub_->HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(data, reply);
650     EXPECT_EQ(ret, 0);
651 }
652 
653 /**
654  * @tc.name: HandleOnSetDisplayNodeScreenId
655  * @tc.desc: HandleOnSetDisplayNodeScreenId test
656  * @tc.type: FUNC
657  */
658 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSetDisplayNodeScreenId, Function | SmallTest | Level2)
659 {
660     MessageParcel data;
661     MessageParcel reply;
662 
663     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
664 
665     int ret = screenSessionManagerClientStub_->HandleOnSetDisplayNodeScreenId(data, reply);
666     EXPECT_EQ(ret, 0);
667 }
668 
669 /**
670  * @tc.name: HandleSwitchUserCallback
671  * @tc.desc: HandleSwitchUserCallback test
672  * @tc.type: FUNC
673  */
674 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSwitchUserCallback, Function | SmallTest | Level2)
675 {
676     MessageParcel data;
677     MessageParcel reply;
678 
679     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
680     std::vector<int32_t> oldScbPids {0, 1};
681     data.WriteInt32Vector(oldScbPids);
682     int32_t currentScbPid = 1;
683     data.WriteInt32(currentScbPid);
684 
685     int ret = screenSessionManagerClientStub_->HandleSwitchUserCallback(data, reply);
686     EXPECT_EQ(ret, 0);
687 }
688 
689 /**
690  * @tc.name: HandleOnUpdateFoldDisplayMode
691  * @tc.desc: HandleOnUpdateFoldDisplayMode test
692  * @tc.type: FUNC
693  */
694 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnUpdateFoldDisplayMode, Function | SmallTest | Level2)
695 {
696     MessageParcel data;
697     MessageParcel reply;
698 
699     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
700     FoldDisplayMode foldDisplayMode = FoldDisplayMode::MAIN;
701     data.WriteUint32(static_cast<uint32_t>(foldDisplayMode));
702 
703     int ret = screenSessionManagerClientStub_->HandleOnUpdateFoldDisplayMode(data, reply);
704     EXPECT_EQ(ret, 0);
705 }
706 
707 /**
708  * @tc.name: HandleSetVirtualPixelRatioSystem
709  * @tc.desc: HandleSetVirtualPixelRatioSystem test
710  * @tc.type: FUNC
711  */
712 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSetVirtualPixelRatioSystem, Function | SmallTest | Level2)
713 {
714     MessageParcel data;
715     MessageParcel reply;
716 
717     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
718     ScreenId screenId = 0;
719     data.WriteUint64(screenId);
720     float virtualPixelRatio = 1.0f;
721     data.WriteFloat(virtualPixelRatio);
722 
723     int ret = screenSessionManagerClientStub_->HandleSetVirtualPixelRatioSystem(data, reply);
724     EXPECT_EQ(ret, 0);
725 }
726 
727 /**
728  * @tc.name: HandleOnFoldStatusChangedReportUE
729  * @tc.desc: HandleOnFoldStatusChangedReportUE test
730  * @tc.type: FUNC
731  */
732 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnFoldStatusChangedReportUE, Function | SmallTest | Level2)
733 {
734     MessageParcel data;
735     MessageParcel reply;
736 
737     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
738     std::vector<std::string> screenFoldInfo = {"0", "0", "0", "0"};
739     data.WriteStringVector(screenFoldInfo);
740 
741     int ret = screenSessionManagerClientStub_->HandleOnFoldStatusChangedReportUE(data, reply);
742     EXPECT_EQ(ret, 0);
743 }
744 
745 /**
746  * @tc.name: HandleScreenCaptureNotify
747  * @tc.desc: HandleScreenCaptureNotify test
748  * @tc.type: FUNC
749  */
750 HWTEST_F(ScreenSessionManagerClientStubTest, HandleScreenCaptureNotify, Function | SmallTest | Level2)
751 {
752     MessageParcel data;
753     MessageParcel reply;
754 
755     data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
756 
757     ScreenId screenId = 0;
758     data.WriteUint64(screenId);
759     data.WriteInt32(0);
760     data.WriteString("test");
761     ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
762     int ret = screenSessionManagerClientStub_->HandleScreenCaptureNotify(data, reply);
763     EXPECT_EQ(ret, 0);
764 }
765 } // namespace Rosen
766 } // namespace OHOS
767