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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.Level1)
247 {
248 MessageParcel data;
249 MessageParcel reply;
250 MessageOption option;
251
252 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
253 data.WriteUint64(0u);
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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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, TestSize.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 int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
410 EXPECT_EQ(res, 0);
411 }
412
413 /**
414 * @tc.name: OnRemoteRequest17
415 * @tc.desc: TRANS_ID_ON_SCREEN_EXTEND_CHANGED
416 * @tc.type: FUNC
417 */
418 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest17, TestSize.Level1)
419 {
420 MessageParcel data;
421 MessageParcel reply;
422 MessageOption option;
423
424 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
425
426 ScreenId mainScreenId = 0;
427 data.WriteUint64(mainScreenId);
428 ScreenId extendScreenId = 100;
429 data.WriteUint64(extendScreenId);
430
431 uint32_t code = static_cast<uint32_t>(
432 IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_EXTEND_CHANGED);
433 int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
434 EXPECT_EQ(res, 0);
435 }
436
437 /**
438 * @tc.name: OnRemoteRequest18
439 * @tc.desc: TRANS_ID_ON_HOVER_STATUS_CHANGED
440 * @tc.type: FUNC
441 */
442 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest18, TestSize.Level1)
443 {
444 MessageParcel data;
445 MessageParcel reply;
446 MessageOption option;
447
448 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
449
450 ScreenId screenId = 0;
451 data.WriteUint64(screenId);
452 int32_t hoverStatus = 1;
453 data.WriteInt32(hoverStatus);
454
455 uint32_t code = static_cast<uint32_t>(
456 IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_HOVER_STATUS_CHANGED);
457 int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
458 EXPECT_EQ(res, 0);
459 }
460
461 /**
462 * @tc.name: OnRemoteRequest19
463 * @tc.desc: TRANS_ID_ON_SUPER_FOLD_STATUS_CHANGED
464 * @tc.type: FUNC
465 */
466 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest19, TestSize.Level1)
467 {
468 MessageParcel data;
469 MessageParcel reply;
470 MessageOption option;
471
472 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
473
474 ScreenId screenId = 0;
475 data.WriteUint64(screenId);
476 SuperFoldStatus superFoldStatus = SuperFoldStatus::UNKNOWN;
477 data.WriteInt32(static_cast<uint32_t>(superFoldStatus));
478
479 uint32_t code = static_cast<uint32_t>(
480 IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SUPER_FOLD_STATUS_CHANGED);
481 int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
482 EXPECT_EQ(res, 0);
483 }
484
485 /**
486 * @tc.name: OnRemoteRequest20
487 * @tc.desc: TRANS_ID_ON_SCREEN_MODE_CHANGED
488 * @tc.type: FUNC
489 */
490 HWTEST_F(ScreenSessionManagerClientStubTest, OnRemoteRequest20, TestSize.Level1)
491 {
492 MessageParcel data;
493 MessageParcel reply;
494 MessageOption option;
495
496 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
497 ScreenModeChangeEvent screenModeChangeEvent = ScreenModeChangeEvent::UNKNOWN;
498 data.WriteInt32(static_cast<uint32_t>(screenModeChangeEvent));
499
500 uint32_t code = static_cast<uint32_t>(
501 IScreenSessionManagerClient::ScreenSessionManagerClientMessage::TRANS_ID_ON_SCREEN_MODE_CHANGED);
502 int res = screenSessionManagerClientStub_->OnRemoteRequest(code, data, reply, option);
503 EXPECT_EQ(res, 0);
504 }
505
506 /**
507 * @tc.name: HandleOnScreenConnectionChanged
508 * @tc.desc: HandleOnScreenConnectionChanged test
509 * @tc.type: FUNC
510 */
511 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenConnectionChanged, TestSize.Level1)
512 {
513 MessageParcel data;
514 MessageParcel reply;
515
516 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
517 ScreenId screenId = 0;
518 data.WriteUint64(screenId);
519 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
520 data.WriteUint8(static_cast<uint8_t>(screenEvent));
521 ScreenId rsId = 0;
522 data.WriteUint64(rsId);
523 std::string name;
524 data.WriteString(name);
525 data.WriteBool(false);
526 int ret = screenSessionManagerClientStub_->HandleOnScreenConnectionChanged(data, reply);
527 EXPECT_EQ(ret, 0);
528 }
529
530 /**
531 * @tc.name: HandleOnPropertyChanged
532 * @tc.desc: HandleOnPropertyChanged test
533 * @tc.type: FUNC
534 */
535 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPropertyChanged, TestSize.Level1)
536 {
537 MessageParcel data;
538 MessageParcel reply;
539
540 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
541 ScreenId screenId = 0;
542 data.WriteUint64(screenId);
543 ScreenProperty property;
544 RSMarshallingHelper::Marshalling(data, property);
545 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
546 data.WriteUint32(static_cast<uint32_t>(reason));
547
548 int ret = screenSessionManagerClientStub_->HandleOnPropertyChanged(data, reply);
549 EXPECT_EQ(ret, 0);
550 }
551
552 /**
553 * @tc.name: HandleOnSuperFoldStatusChanged
554 * @tc.desc: HandleOnSuperFoldStatusChanged test
555 * @tc.type: FUNC
556 */
557 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSuperFoldStatusChanged, TestSize.Level1)
558 {
559 MessageParcel data;
560 MessageParcel reply;
561
562 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
563 ScreenId screenId = 0;
564 data.WriteUint64(screenId);
565 ScreenProperty property;
566 RSMarshallingHelper::Marshalling(data, property);
567 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
568 data.WriteUint32(static_cast<uint32_t>(reason));
569
570 int ret = screenSessionManagerClientStub_->HandleOnSuperFoldStatusChanged(data, reply);
571 EXPECT_EQ(ret, 0);
572 }
573
574 /**
575 * @tc.name: HandleOnHoverStatusChanged
576 * @tc.desc: HandleOnHoverStatusChanged test
577 * @tc.type: FUNC
578 */
579 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnHoverStatusChanged, TestSize.Level1)
580 {
581 MessageParcel data;
582 MessageParcel reply;
583
584 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
585 ScreenId screenId = 0;
586 data.WriteUint64(screenId);
587 int32_t hoverStatus = 0;
588 data.WriteInt32(hoverStatus);
589
590 int ret = screenSessionManagerClientStub_->HandleOnHoverStatusChanged(data, reply);
591 EXPECT_EQ(ret, 0);
592 }
593
594 /**
595 * @tc.name: HandleOnSensorRotationChanged
596 * @tc.desc: HandleOnSensorRotationChanged test
597 * @tc.type: FUNC
598 */
599 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSensorRotationChanged, TestSize.Level1)
600 {
601 MessageParcel data;
602 MessageParcel reply;
603
604 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
605 ScreenId screenId = 0;
606 data.WriteUint64(screenId);
607 float sensorRotation = 0;
608 data.WriteFloat(sensorRotation);
609
610 int ret = screenSessionManagerClientStub_->HandleOnSensorRotationChanged(data, reply);
611 EXPECT_EQ(ret, 0);
612 }
613
614 /**
615 * @tc.name: HandleOnScreenExtendChanged
616 * @tc.desc: HandleOnScreenExtendChanged test
617 * @tc.type: FUNC
618 */
619 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenExtendChanged, TestSize.Level1)
620 {
621 MessageParcel data;
622 MessageParcel reply;
623
624 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
625 ScreenId mainScreenId = 0;
626 ScreenId extendScreenId = 100;
627 data.WriteUint64(mainScreenId);
628 data.WriteUint64(extendScreenId);
629
630 int ret = screenSessionManagerClientStub_->HandleOnScreenExtendChanged(data, reply);
631 EXPECT_EQ(ret, 0);
632 }
633
634 /**
635 * @tc.name: HandleOnScreenOrientationChanged
636 * @tc.desc: HandleOnScreenOrientationChanged test
637 * @tc.type: FUNC
638 */
639 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenOrientationChanged, TestSize.Level1)
640 {
641 MessageParcel data;
642 MessageParcel reply;
643
644 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
645 ScreenId screenId = 0;
646 data.WriteUint64(screenId);
647 float screenOrientation = 0;
648 data.WriteFloat(screenOrientation);
649
650 int ret = screenSessionManagerClientStub_->HandleOnScreenOrientationChanged(data, reply);
651 EXPECT_EQ(ret, 0);
652 }
653
654 /**
655 * @tc.name: HandleOnScreenRotationLockedChanged
656 * @tc.desc: HandleOnScreenRotationLockedChanged test
657 * @tc.type: FUNC
658 */
659 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenRotationLockedChanged, TestSize.Level1)
660 {
661 MessageParcel data;
662 MessageParcel reply;
663
664 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
665 ScreenId screenId = 0;
666 data.WriteUint64(screenId);
667 bool isLocked = false;
668 data.WriteBool(isLocked);
669
670 int ret = screenSessionManagerClientStub_->HandleOnScreenRotationLockedChanged(data, reply);
671 EXPECT_EQ(ret, 0);
672 }
673
674 /**
675 * @tc.name: HandleOnDisplayStateChanged
676 * @tc.desc: HandleOnDisplayStateChanged test
677 * @tc.type: FUNC
678 */
679 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnDisplayStateChanged, TestSize.Level1)
680 {
681 MessageParcel data;
682 MessageParcel reply;
683
684 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
685 ScreenId screenId = 0;
686 data.WriteUint64(screenId);
687 sptr<DisplayInfo> displayInfo = new DisplayInfo();
688 data.WriteStrongParcelable(displayInfo);
689 data.WriteUint32(0);
690 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
691 data.WriteUint32(static_cast<uint32_t>(type));
692
693 int ret = screenSessionManagerClientStub_->HandleOnDisplayStateChanged(data, reply);
694 EXPECT_EQ(ret, 0);
695 }
696
697 /**
698 * @tc.name: HandleOnScreenshot
699 * @tc.desc: HandleOnScreenshot test
700 * @tc.type: FUNC
701 */
702 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenshot, TestSize.Level1)
703 {
704 MessageParcel data;
705 MessageParcel reply;
706
707 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
708 ScreenId screenId = 0;
709 data.WriteUint64(screenId);
710
711 int ret = screenSessionManagerClientStub_->HandleOnScreenshot(data, reply);
712 EXPECT_EQ(ret, 0);
713 }
714
715 /**
716 * @tc.name: HandleOnImmersiveStateChanged
717 * @tc.desc: HandleOnImmersiveStateChanged test
718 * @tc.type: FUNC
719 */
720 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnImmersiveStateChanged, TestSize.Level1)
721 {
722 MessageParcel data;
723 MessageParcel reply;
724
725 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
726
727 int ret = screenSessionManagerClientStub_->HandleOnImmersiveStateChanged(data, reply);
728 EXPECT_EQ(ret, 0);
729 }
730
731 /**
732 * @tc.name: HandleOnPowerStatusChanged
733 * @tc.desc: HandleOnPowerStatusChanged test
734 * @tc.type: FUNC
735 */
736 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPowerStatusChanged, TestSize.Level1)
737 {
738 MessageParcel data;
739 MessageParcel reply;
740
741 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
742
743 int ret = screenSessionManagerClientStub_->HandleOnPowerStatusChanged(data, reply);
744 EXPECT_EQ(ret, 0);
745 }
746
747 /**
748 * @tc.name: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged
749 * @tc.desc: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged test
750 * @tc.type: FUNC
751 */
752 HWTEST_F(ScreenSessionManagerClientStubTest,
753 HandleOnGetSurfaceNodeIdsFromMissionIdsChanged, TestSize.Level1)
754 {
755 MessageParcel data;
756 MessageParcel reply;
757
758 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
759
760 int ret = screenSessionManagerClientStub_->HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(data, reply);
761 EXPECT_EQ(ret, 0);
762 }
763
764 /**
765 * @tc.name: HandleOnSetSurfaceNodeIdsChanged
766 * @tc.desc: HandleOnSetSurfaceNodeIdsChanged test
767 * @tc.type: FUNC
768 */
769 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSetSurfaceNodeIdsChanged, TestSize.Level1)
770 {
771 MessageParcel data;
772 MessageParcel reply;
773 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
774 int ret = screenSessionManagerClientStub_->HandleOnSetSurfaceNodeIdsChanged(data, reply);
775 EXPECT_EQ(ret, 0);
776 }
777
778 /**
779 * @tc.name: HandleOnVirtualScreenDisconnected
780 * @tc.desc: HandleOnVirtualScreenDisconnected test
781 * @tc.type: FUNC
782 */
783 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnVirtualScreenDisconnected, TestSize.Level1)
784 {
785 MessageParcel data;
786 MessageParcel reply;
787 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
788 int ret = screenSessionManagerClientStub_->HandleOnVirtualScreenDisconnected(data, reply);
789 EXPECT_EQ(ret, 0);
790 }
791
792 /**
793 * @tc.name: HandleOnSetDisplayNodeScreenId
794 * @tc.desc: HandleOnSetDisplayNodeScreenId test
795 * @tc.type: FUNC
796 */
797 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSetDisplayNodeScreenId, TestSize.Level1)
798 {
799 MessageParcel data;
800 MessageParcel reply;
801
802 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
803
804 int ret = screenSessionManagerClientStub_->HandleOnSetDisplayNodeScreenId(data, reply);
805 EXPECT_EQ(ret, 0);
806 }
807
808 /**
809 * @tc.name: HandleSwitchUserCallback
810 * @tc.desc: HandleSwitchUserCallback test
811 * @tc.type: FUNC
812 */
813 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSwitchUserCallback, TestSize.Level1)
814 {
815 MessageParcel data;
816 MessageParcel reply;
817
818 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
819 std::vector<int32_t> oldScbPids {0, 1};
820 data.WriteInt32Vector(oldScbPids);
821 int32_t currentScbPid = 1;
822 data.WriteInt32(currentScbPid);
823
824 int ret = screenSessionManagerClientStub_->HandleSwitchUserCallback(data, reply);
825 EXPECT_EQ(ret, 0);
826 }
827
828 /**
829 * @tc.name: HandleOnUpdateFoldDisplayMode
830 * @tc.desc: HandleOnUpdateFoldDisplayMode test
831 * @tc.type: FUNC
832 */
833 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnUpdateFoldDisplayMode, TestSize.Level1)
834 {
835 MessageParcel data;
836 MessageParcel reply;
837
838 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
839 FoldDisplayMode foldDisplayMode = FoldDisplayMode::MAIN;
840 data.WriteUint32(static_cast<uint32_t>(foldDisplayMode));
841
842 int ret = screenSessionManagerClientStub_->HandleOnUpdateFoldDisplayMode(data, reply);
843 EXPECT_EQ(ret, 0);
844 }
845
846 /**
847 * @tc.name: HandleSetVirtualPixelRatioSystem
848 * @tc.desc: HandleSetVirtualPixelRatioSystem test
849 * @tc.type: FUNC
850 */
851 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSetVirtualPixelRatioSystem, TestSize.Level1)
852 {
853 MessageParcel data;
854 MessageParcel reply;
855
856 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
857 ScreenId screenId = 0;
858 data.WriteUint64(screenId);
859 float virtualPixelRatio = 1.0f;
860 data.WriteFloat(virtualPixelRatio);
861
862 int ret = screenSessionManagerClientStub_->HandleSetVirtualPixelRatioSystem(data, reply);
863 EXPECT_EQ(ret, 0);
864 }
865
866 /**
867 * @tc.name: HandleOnFoldStatusChangedReportUE
868 * @tc.desc: HandleOnFoldStatusChangedReportUE test
869 * @tc.type: FUNC
870 */
871 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnFoldStatusChangedReportUE, TestSize.Level1)
872 {
873 MessageParcel data;
874 MessageParcel reply;
875
876 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
877 std::vector<std::string> screenFoldInfo = {"0", "0", "0", "0"};
878 data.WriteStringVector(screenFoldInfo);
879
880 int ret = screenSessionManagerClientStub_->HandleOnFoldStatusChangedReportUE(data, reply);
881 EXPECT_EQ(ret, 0);
882 }
883
884 /**
885 * @tc.name: HandleScreenCaptureNotify
886 * @tc.desc: HandleScreenCaptureNotify test
887 * @tc.type: FUNC
888 */
889 HWTEST_F(ScreenSessionManagerClientStubTest, HandleScreenCaptureNotify, TestSize.Level1)
890 {
891 MessageParcel data;
892 MessageParcel reply;
893
894 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
895
896 ScreenId screenId = 0;
897 data.WriteUint64(screenId);
898 data.WriteInt32(0);
899 data.WriteString("test");
900 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
901 int ret = screenSessionManagerClientStub_->HandleScreenCaptureNotify(data, reply);
902 EXPECT_EQ(ret, 0);
903 }
904
905 /**
906 * @tc.name: HandleOnExtendDisplayNodeChange
907 * @tc.desc: HandleOnExtendDisplayNodeChange test
908 * @tc.type: FUNC
909 */
910 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnExtendDisplayNodeChange, TestSize.Level1)
911 {
912 MessageParcel data;
913 MessageParcel reply;
914
915 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
916
917 ScreenId mainScreenId = 50;
918 ScreenId extendScreenId = 51;
919 data.WriteUint64(mainScreenId);
920 data.WriteUint64(extendScreenId);
921 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
922 auto ret = screenSessionManagerClientStub_->HandleOnExtendDisplayNodeChange(data, reply);
923 EXPECT_EQ(ret, 0);
924 }
925
926 /**
927 * @tc.name: HandleOnDumperClientScreenSessions
928 * @tc.desc: HandleOnDumperClientScreenSessions test
929 * @tc.type: FUNC
930 */
931 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnDumperClientScreenSessions, TestSize.Level1)
932 {
933 MessageParcel data;
934 MessageParcel reply;
935
936 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
937 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
938 auto ret = screenSessionManagerClientStub_->HandleOnDumperClientScreenSessions(data, reply);
939 EXPECT_EQ(ret, 0);
940 }
941
942 /**
943 * @tc.name: HandleOnBeforeScreenPropertyChange01
944 * @tc.desc: HandleOnBeforeScreenPropertyChange test err
945 * @tc.type: FUNC
946 */
947 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnBeforeScreenPropertyChange01, TestSize.Level1)
948 {
949 MessageParcel data;
950 MessageParcel reply;
951 uint32_t errFoldStatus = 123;
952 data.WriteUint32(errFoldStatus);
953 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
954 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
955 auto ret = screenSessionManagerClientStub_->HandleOnBeforeScreenPropertyChange(data, reply);
956 EXPECT_EQ(ret, 22);
957 }
958
959 /**
960 * @tc.name: HandleOnBeforeScreenPropertyChange02
961 * @tc.desc: HandleOnBeforeScreenPropertyChange test normal
962 * @tc.type: FUNC
963 */
964 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnBeforeScreenPropertyChange02, TestSize.Level1)
965 {
966 MessageParcel data;
967 MessageParcel reply;
968 FoldStatus foldStatus = FoldStatus::FOLDED;
969 data.WriteUint32(static_cast<uint32_t>(foldStatus));
970 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
971 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
972 auto ret = screenSessionManagerClientStub_->HandleOnBeforeScreenPropertyChange(data, reply);
973 EXPECT_EQ(ret, 0);
974 }
975
976 /**
977 * @tc.name: HandleSyncScreenCombination
978 * @tc.desc: HandleSyncScreenCombination test
979 * @tc.type: FUNC
980 */
981 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSyncScreenCombination, TestSize.Level1)
982 {
983 MessageParcel data;
984 MessageParcel reply;
985
986 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
987
988 ScreenId mainScreenId = 50;
989 ScreenId extendScreenId = 51;
990 ScreenCombination extendCombination = ScreenCombination::SCREEN_ALONE;
991 data.WriteUint64(mainScreenId);
992 data.WriteUint64(extendScreenId);
993 data.WriteUint32(static_cast<u_int32_t>(extendCombination));
994 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
995 auto ret = screenSessionManagerClientStub_->HandleSyncScreenCombination(data, reply);
996 EXPECT_EQ(ret, 0);
997 }
998
999 /**
1000 * @tc.name: HandleOnScreenModeChanged
1001 * @tc.desc: HandleOnScreenModeChanged test
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenModeChanged, TestSize.Level1)
1005 {
1006 MessageParcel data;
1007 MessageParcel reply;
1008
1009 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
1010
1011 ScreenModeChangeEvent screenModeChangeEvent = ScreenModeChangeEvent::UNKNOWN;
1012 data.WriteUint32(static_cast<u_int32_t>(screenModeChangeEvent));
1013 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
1014 auto ret = screenSessionManagerClientStub_->HandleOnScreenModeChanged(data, reply);
1015 EXPECT_EQ(ret, 0);
1016 }
1017 } // namespace Rosen
1018 } // namespace OHOS
1019