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 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, 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 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, Function | SmallTest | 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, Function | SmallTest | 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, Function | SmallTest | 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: HandleOnScreenConnectionChanged
487 * @tc.desc: HandleOnScreenConnectionChanged test
488 * @tc.type: FUNC
489 */
490 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenConnectionChanged, Function | SmallTest | Level2)
491 {
492 MessageParcel data;
493 MessageParcel reply;
494
495 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
496 ScreenId screenId = 0;
497 data.WriteUint64(screenId);
498 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
499 data.WriteUint8(static_cast<uint8_t>(screenEvent));
500 ScreenId rsId = 0;
501 data.WriteUint64(rsId);
502 std::string name;
503 data.WriteString(name);
504 data.WriteBool(false);
505 int ret = screenSessionManagerClientStub_->HandleOnScreenConnectionChanged(data, reply);
506 EXPECT_EQ(ret, 0);
507 }
508
509 /**
510 * @tc.name: HandleOnPropertyChanged
511 * @tc.desc: HandleOnPropertyChanged test
512 * @tc.type: FUNC
513 */
514 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPropertyChanged, Function | SmallTest | Level2)
515 {
516 MessageParcel data;
517 MessageParcel reply;
518
519 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
520 ScreenId screenId = 0;
521 data.WriteUint64(screenId);
522 ScreenProperty property;
523 RSMarshallingHelper::Marshalling(data, property);
524 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
525 data.WriteUint32(static_cast<uint32_t>(reason));
526
527 int ret = screenSessionManagerClientStub_->HandleOnPropertyChanged(data, reply);
528 EXPECT_EQ(ret, 0);
529 }
530
531 /**
532 * @tc.name: HandleOnSuperFoldStatusChanged
533 * @tc.desc: HandleOnSuperFoldStatusChanged test
534 * @tc.type: FUNC
535 */
536 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSuperFoldStatusChanged, Function | SmallTest | Level2)
537 {
538 MessageParcel data;
539 MessageParcel reply;
540
541 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
542 ScreenId screenId = 0;
543 data.WriteUint64(screenId);
544 ScreenProperty property;
545 RSMarshallingHelper::Marshalling(data, property);
546 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
547 data.WriteUint32(static_cast<uint32_t>(reason));
548
549 int ret = screenSessionManagerClientStub_->HandleOnSuperFoldStatusChanged(data, reply);
550 EXPECT_EQ(ret, 0);
551 }
552
553 /**
554 * @tc.name: HandleOnHoverStatusChanged
555 * @tc.desc: HandleOnHoverStatusChanged test
556 * @tc.type: FUNC
557 */
558 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnHoverStatusChanged, Function | SmallTest | Level2)
559 {
560 MessageParcel data;
561 MessageParcel reply;
562
563 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
564 ScreenId screenId = 0;
565 data.WriteUint64(screenId);
566 int32_t hoverStatus = 0;
567 data.WriteInt32(hoverStatus);
568
569 int ret = screenSessionManagerClientStub_->HandleOnHoverStatusChanged(data, reply);
570 EXPECT_EQ(ret, 0);
571 }
572
573 /**
574 * @tc.name: HandleOnSensorRotationChanged
575 * @tc.desc: HandleOnSensorRotationChanged test
576 * @tc.type: FUNC
577 */
578 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSensorRotationChanged, Function | SmallTest | Level2)
579 {
580 MessageParcel data;
581 MessageParcel reply;
582
583 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
584 ScreenId screenId = 0;
585 data.WriteUint64(screenId);
586 float sensorRotation = 0;
587 data.WriteFloat(sensorRotation);
588
589 int ret = screenSessionManagerClientStub_->HandleOnSensorRotationChanged(data, reply);
590 EXPECT_EQ(ret, 0);
591 }
592
593 /**
594 * @tc.name: HandleOnScreenExtendChanged
595 * @tc.desc: HandleOnScreenExtendChanged test
596 * @tc.type: FUNC
597 */
598 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenExtendChanged, Function | SmallTest | Level2)
599 {
600 MessageParcel data;
601 MessageParcel reply;
602
603 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
604 ScreenId mainScreenId = 0;
605 ScreenId extendScreenId = 100;
606 data.WriteUint64(mainScreenId);
607 data.WriteUint64(extendScreenId);
608
609 int ret = screenSessionManagerClientStub_->HandleOnScreenExtendChanged(data, reply);
610 EXPECT_EQ(ret, 0);
611 }
612
613 /**
614 * @tc.name: HandleOnScreenOrientationChanged
615 * @tc.desc: HandleOnScreenOrientationChanged test
616 * @tc.type: FUNC
617 */
618 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenOrientationChanged, Function | SmallTest | Level2)
619 {
620 MessageParcel data;
621 MessageParcel reply;
622
623 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
624 ScreenId screenId = 0;
625 data.WriteUint64(screenId);
626 float screenOrientation = 0;
627 data.WriteFloat(screenOrientation);
628
629 int ret = screenSessionManagerClientStub_->HandleOnScreenOrientationChanged(data, reply);
630 EXPECT_EQ(ret, 0);
631 }
632
633 /**
634 * @tc.name: HandleOnScreenRotationLockedChanged
635 * @tc.desc: HandleOnScreenRotationLockedChanged test
636 * @tc.type: FUNC
637 */
638 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenRotationLockedChanged, Function | SmallTest | Level2)
639 {
640 MessageParcel data;
641 MessageParcel reply;
642
643 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
644 ScreenId screenId = 0;
645 data.WriteUint64(screenId);
646 bool isLocked = false;
647 data.WriteBool(isLocked);
648
649 int ret = screenSessionManagerClientStub_->HandleOnScreenRotationLockedChanged(data, reply);
650 EXPECT_EQ(ret, 0);
651 }
652
653 /**
654 * @tc.name: HandleOnDisplayStateChanged
655 * @tc.desc: HandleOnDisplayStateChanged test
656 * @tc.type: FUNC
657 */
658 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnDisplayStateChanged, Function | SmallTest | Level2)
659 {
660 MessageParcel data;
661 MessageParcel reply;
662
663 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
664 ScreenId screenId = 0;
665 data.WriteUint64(screenId);
666 sptr<DisplayInfo> displayInfo = new DisplayInfo();
667 data.WriteStrongParcelable(displayInfo);
668 data.WriteUint32(0);
669 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
670 data.WriteUint32(static_cast<uint32_t>(type));
671
672 int ret = screenSessionManagerClientStub_->HandleOnDisplayStateChanged(data, reply);
673 EXPECT_EQ(ret, 0);
674 }
675
676 /**
677 * @tc.name: HandleOnScreenshot
678 * @tc.desc: HandleOnScreenshot test
679 * @tc.type: FUNC
680 */
681 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnScreenshot, Function | SmallTest | Level2)
682 {
683 MessageParcel data;
684 MessageParcel reply;
685
686 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
687 ScreenId screenId = 0;
688 data.WriteUint64(screenId);
689
690 int ret = screenSessionManagerClientStub_->HandleOnScreenshot(data, reply);
691 EXPECT_EQ(ret, 0);
692 }
693
694 /**
695 * @tc.name: HandleOnImmersiveStateChanged
696 * @tc.desc: HandleOnImmersiveStateChanged test
697 * @tc.type: FUNC
698 */
699 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnImmersiveStateChanged, Function | SmallTest | Level2)
700 {
701 MessageParcel data;
702 MessageParcel reply;
703
704 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
705
706 int ret = screenSessionManagerClientStub_->HandleOnImmersiveStateChanged(data, reply);
707 EXPECT_EQ(ret, 0);
708 }
709
710 /**
711 * @tc.name: HandleOnPowerStatusChanged
712 * @tc.desc: HandleOnPowerStatusChanged test
713 * @tc.type: FUNC
714 */
715 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnPowerStatusChanged, Function | SmallTest | Level2)
716 {
717 MessageParcel data;
718 MessageParcel reply;
719
720 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
721
722 int ret = screenSessionManagerClientStub_->HandleOnPowerStatusChanged(data, reply);
723 EXPECT_EQ(ret, 0);
724 }
725
726 /**
727 * @tc.name: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged
728 * @tc.desc: HandleOnGetSurfaceNodeIdsFromMissionIdsChanged test
729 * @tc.type: FUNC
730 */
731 HWTEST_F(ScreenSessionManagerClientStubTest,
732 HandleOnGetSurfaceNodeIdsFromMissionIdsChanged, Function | SmallTest | Level2)
733 {
734 MessageParcel data;
735 MessageParcel reply;
736
737 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
738
739 int ret = screenSessionManagerClientStub_->HandleOnGetSurfaceNodeIdsFromMissionIdsChanged(data, reply);
740 EXPECT_EQ(ret, 0);
741 }
742
743 /**
744 * @tc.name: HandleOnSetDisplayNodeScreenId
745 * @tc.desc: HandleOnSetDisplayNodeScreenId test
746 * @tc.type: FUNC
747 */
748 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnSetDisplayNodeScreenId, Function | SmallTest | Level2)
749 {
750 MessageParcel data;
751 MessageParcel reply;
752
753 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
754
755 int ret = screenSessionManagerClientStub_->HandleOnSetDisplayNodeScreenId(data, reply);
756 EXPECT_EQ(ret, 0);
757 }
758
759 /**
760 * @tc.name: HandleSwitchUserCallback
761 * @tc.desc: HandleSwitchUserCallback test
762 * @tc.type: FUNC
763 */
764 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSwitchUserCallback, Function | SmallTest | Level2)
765 {
766 MessageParcel data;
767 MessageParcel reply;
768
769 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
770 std::vector<int32_t> oldScbPids {0, 1};
771 data.WriteInt32Vector(oldScbPids);
772 int32_t currentScbPid = 1;
773 data.WriteInt32(currentScbPid);
774
775 int ret = screenSessionManagerClientStub_->HandleSwitchUserCallback(data, reply);
776 EXPECT_EQ(ret, 0);
777 }
778
779 /**
780 * @tc.name: HandleOnUpdateFoldDisplayMode
781 * @tc.desc: HandleOnUpdateFoldDisplayMode test
782 * @tc.type: FUNC
783 */
784 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnUpdateFoldDisplayMode, Function | SmallTest | Level2)
785 {
786 MessageParcel data;
787 MessageParcel reply;
788
789 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
790 FoldDisplayMode foldDisplayMode = FoldDisplayMode::MAIN;
791 data.WriteUint32(static_cast<uint32_t>(foldDisplayMode));
792
793 int ret = screenSessionManagerClientStub_->HandleOnUpdateFoldDisplayMode(data, reply);
794 EXPECT_EQ(ret, 0);
795 }
796
797 /**
798 * @tc.name: HandleSetVirtualPixelRatioSystem
799 * @tc.desc: HandleSetVirtualPixelRatioSystem test
800 * @tc.type: FUNC
801 */
802 HWTEST_F(ScreenSessionManagerClientStubTest, HandleSetVirtualPixelRatioSystem, Function | SmallTest | Level2)
803 {
804 MessageParcel data;
805 MessageParcel reply;
806
807 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
808 ScreenId screenId = 0;
809 data.WriteUint64(screenId);
810 float virtualPixelRatio = 1.0f;
811 data.WriteFloat(virtualPixelRatio);
812
813 int ret = screenSessionManagerClientStub_->HandleSetVirtualPixelRatioSystem(data, reply);
814 EXPECT_EQ(ret, 0);
815 }
816
817 /**
818 * @tc.name: HandleOnFoldStatusChangedReportUE
819 * @tc.desc: HandleOnFoldStatusChangedReportUE test
820 * @tc.type: FUNC
821 */
822 HWTEST_F(ScreenSessionManagerClientStubTest, HandleOnFoldStatusChangedReportUE, Function | SmallTest | Level2)
823 {
824 MessageParcel data;
825 MessageParcel reply;
826
827 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
828 std::vector<std::string> screenFoldInfo = {"0", "0", "0", "0"};
829 data.WriteStringVector(screenFoldInfo);
830
831 int ret = screenSessionManagerClientStub_->HandleOnFoldStatusChangedReportUE(data, reply);
832 EXPECT_EQ(ret, 0);
833 }
834
835 /**
836 * @tc.name: HandleScreenCaptureNotify
837 * @tc.desc: HandleScreenCaptureNotify test
838 * @tc.type: FUNC
839 */
840 HWTEST_F(ScreenSessionManagerClientStubTest, HandleScreenCaptureNotify, Function | SmallTest | Level2)
841 {
842 MessageParcel data;
843 MessageParcel reply;
844
845 data.WriteInterfaceToken(ScreenSessionManagerClientStub::GetDescriptor());
846
847 ScreenId screenId = 0;
848 data.WriteUint64(screenId);
849 data.WriteInt32(0);
850 data.WriteString("test");
851 ASSERT_TRUE(screenSessionManagerClientStub_ != nullptr);
852 int ret = screenSessionManagerClientStub_->HandleScreenCaptureNotify(data, reply);
853 EXPECT_EQ(ret, 0);
854 }
855 } // namespace Rosen
856 } // namespace OHOS
857