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