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 <message_option.h>
18 #include <message_parcel.h>
19 #include <common/rs_rect.h>
20 #include <transaction/rs_marshalling_helper.h>
21
22 #include "session_manager/include/scene_session_manager.h"
23 #include "session_manager/include/zidl/scene_session_manager_interface.h"
24 #include "window_manager_agent.h"
25 #include "zidl/screen_session_manager_stub.h"
26 #include "zidl/window_manager_agent_interface.h"
27
28 using namespace testing;
29 using namespace testing::ext;
30 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
34 }
35 class ScreenSessionManagerStubTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 sptr<ScreenSessionManagerStub> stub_;
42 };
43
SetUpTestCase()44 void ScreenSessionManagerStubTest::SetUpTestCase()
45 {
46 }
47
TearDownTestCase()48 void ScreenSessionManagerStubTest::TearDownTestCase()
49 {
50 usleep(SLEEP_TIME_IN_US);
51 }
52
SetUp()53 void ScreenSessionManagerStubTest::SetUp()
54 {
55 stub_ = new ScreenSessionManagerStub();
56 }
57
TearDown()58 void ScreenSessionManagerStubTest::TearDown()
59 {
60 }
61
62 namespace {
63 /**
64 * @tc.name: OnRemoteRequest01
65 * @tc.desc: normal function
66 * @tc.type: FUNC
67 */
68 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest01, Function | SmallTest | Level2)
69 {
70 MessageParcel data;
71 MessageParcel reply;
72 MessageOption option;
73
74 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
75 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
76 data.WriteUint32(static_cast<uint32_t>(type));
77 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
78 data.WriteRemoteObject(windowManagerAgent->AsObject());
79
80 uint32_t code = static_cast<uint32_t>(
81 DisplayManagerMessage::TRANS_ID_GET_DEFAULT_DISPLAY_INFO);
82
83 int res = stub_->OnRemoteRequest(code, data, reply, option);
84 EXPECT_EQ(res, 0);
85 }
86
87 /**
88 * @tc.name: OnRemoteRequest02
89 * @tc.desc: normal function
90 * @tc.type: FUNC
91 */
92 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest02, Function | SmallTest | Level2)
93 {
94 MessageParcel data;
95 MessageParcel reply;
96 MessageOption option;
97
98 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
99 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
100 data.WriteUint32(static_cast<uint32_t>(type));
101 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
102 data.WriteRemoteObject(windowManagerAgent->AsObject());
103
104 uint32_t code = static_cast<uint32_t>(
105 DisplayManagerMessage::TRANS_ID_REGISTER_DISPLAY_MANAGER_AGENT);
106
107 int res = stub_->OnRemoteRequest(code, data, reply, option);
108 EXPECT_EQ(res, -1);
109 }
110
111 /**
112 * @tc.name: OnRemoteRequest03
113 * @tc.desc: normal function
114 * @tc.type: FUNC
115 */
116 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest03, Function | SmallTest | Level2)
117 {
118 MessageParcel data;
119 MessageParcel reply;
120 MessageOption option;
121
122 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
123 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
124 data.WriteUint32(static_cast<uint32_t>(type));
125 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
126 data.WriteRemoteObject(windowManagerAgent->AsObject());
127
128 uint32_t code = static_cast<uint32_t>(
129 DisplayManagerMessage::TRANS_ID_UNREGISTER_DISPLAY_MANAGER_AGENT);
130
131 int res = stub_->OnRemoteRequest(code, data, reply, option);
132 EXPECT_EQ(res, -1);
133 }
134
135 /**
136 * @tc.name: OnRemoteRequest04
137 * @tc.desc: normal function
138 * @tc.type: FUNC
139 */
140 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest04, Function | SmallTest | Level2)
141 {
142 MessageParcel data;
143 MessageParcel reply;
144 MessageOption option;
145
146 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
147 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
148 data.WriteUint32(static_cast<uint32_t>(type));
149 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
150 data.WriteRemoteObject(windowManagerAgent->AsObject());
151
152 uint32_t code = static_cast<uint32_t>(
153 DisplayManagerMessage::TRANS_ID_WAKE_UP_BEGIN);
154
155 int res = stub_->OnRemoteRequest(code, data, reply, option);
156 EXPECT_EQ(res, 0);
157 }
158
159 /**
160 * @tc.name: OnRemoteRequest05
161 * @tc.desc: normal function
162 * @tc.type: FUNC
163 */
164 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest05, Function | SmallTest | Level2)
165 {
166 MessageParcel data;
167 MessageParcel reply;
168 MessageOption option;
169
170 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
171 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
172 data.WriteUint32(static_cast<uint32_t>(type));
173 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
174 data.WriteRemoteObject(windowManagerAgent->AsObject());
175
176 uint32_t code = static_cast<uint32_t>(
177 DisplayManagerMessage::TRANS_ID_WAKE_UP_END);
178
179 int res = stub_->OnRemoteRequest(code, data, reply, option);
180 EXPECT_EQ(res, 0);
181 }
182
183 /**
184 * @tc.name: OnRemoteRequest06
185 * @tc.desc: normal function
186 * @tc.type: FUNC
187 */
188 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest06, Function | SmallTest | Level2)
189 {
190 MessageParcel data;
191 MessageParcel reply;
192 MessageOption option;
193
194 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
195 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
196 data.WriteUint32(static_cast<uint32_t>(type));
197 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
198 data.WriteRemoteObject(windowManagerAgent->AsObject());
199
200 uint32_t code = static_cast<uint32_t>(
201 DisplayManagerMessage::TRANS_ID_SUSPEND_BEGIN);
202
203 int res = stub_->OnRemoteRequest(code, data, reply, option);
204 EXPECT_EQ(res, 0);
205 }
206
207 /**
208 * @tc.name: OnRemoteRequest07
209 * @tc.desc: normal function
210 * @tc.type: FUNC
211 */
212 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest07, Function | SmallTest | Level2)
213 {
214 MessageParcel data;
215 MessageParcel reply;
216 MessageOption option;
217
218 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
219 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
220 data.WriteUint32(static_cast<uint32_t>(type));
221 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
222 data.WriteRemoteObject(windowManagerAgent->AsObject());
223
224 uint32_t code = static_cast<uint32_t>(
225 DisplayManagerMessage::TRANS_ID_SUSPEND_END);
226
227 int res = stub_->OnRemoteRequest(code, data, reply, option);
228 EXPECT_EQ(res, 0);
229 }
230
231 /**
232 * @tc.name: OnRemoteRequest08
233 * @tc.desc: normal function
234 * @tc.type: FUNC
235 */
236 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest08, Function | SmallTest | Level2)
237 {
238 MessageParcel data;
239 MessageParcel reply;
240 MessageOption option;
241
242 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
243 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
244 data.WriteUint32(static_cast<uint32_t>(type));
245 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
246 data.WriteRemoteObject(windowManagerAgent->AsObject());
247
248 uint32_t code = static_cast<uint32_t>(
249 DisplayManagerMessage::TRANS_ID_SET_DISPLAY_STATE);
250
251 int res = stub_->OnRemoteRequest(code, data, reply, option);
252 EXPECT_EQ(res, 0);
253 }
254
255 /**
256 * @tc.name: OnRemoteRequest09
257 * @tc.desc: normal function
258 * @tc.type: FUNC
259 */
260 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest09, Function | SmallTest | Level2)
261 {
262 MessageParcel data;
263 MessageParcel reply;
264 MessageOption option;
265
266 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
267 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
268 data.WriteUint32(static_cast<uint32_t>(type));
269 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
270 data.WriteRemoteObject(windowManagerAgent->AsObject());
271
272 uint32_t code = static_cast<uint32_t>(
273 DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_FOR_ALL);
274
275 int res = stub_->OnRemoteRequest(code, data, reply, option);
276 EXPECT_EQ(res, 0);
277 }
278
279 /**
280 * @tc.name: OnRemoteRequest10
281 * @tc.desc: normal function
282 * @tc.type: FUNC
283 */
284 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest10, Function | SmallTest | Level2)
285 {
286 MessageParcel data;
287 MessageParcel reply;
288 MessageOption option;
289
290 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
291 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
292 data.WriteUint32(static_cast<uint32_t>(type));
293 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
294 data.WriteRemoteObject(windowManagerAgent->AsObject());
295
296 uint32_t code = static_cast<uint32_t>(
297 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_STATE);
298
299 int res = stub_->OnRemoteRequest(code, data, reply, option);
300 EXPECT_EQ(res, 0);
301 }
302
303 /**
304 * @tc.name: OnRemoteRequest11
305 * @tc.desc: normal function
306 * @tc.type: FUNC
307 */
308 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest11, Function | SmallTest | Level2)
309 {
310 MessageParcel data;
311 MessageParcel reply;
312 MessageOption option;
313
314 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
315 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
316 data.WriteUint32(static_cast<uint32_t>(type));
317 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
318 data.WriteRemoteObject(windowManagerAgent->AsObject());
319
320 uint32_t code = static_cast<uint32_t>(
321 DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_EVENT);
322
323 int res = stub_->OnRemoteRequest(code, data, reply, option);
324 EXPECT_EQ(res, 0);
325 }
326
327 /**
328 * @tc.name: OnRemoteRequest12
329 * @tc.desc: normal function
330 * @tc.type: FUNC
331 */
332 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest12, Function | SmallTest | Level2)
333 {
334 MessageParcel data;
335 MessageParcel reply;
336 MessageOption option;
337
338 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
339 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
340 data.WriteUint32(static_cast<uint32_t>(type));
341 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
342 data.WriteRemoteObject(windowManagerAgent->AsObject());
343
344 uint32_t code = static_cast<uint32_t>(
345 DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER);
346
347 int res = stub_->OnRemoteRequest(code, data, reply, option);
348 EXPECT_EQ(res, -1);
349 }
350
351 /**
352 * @tc.name: OnRemoteRequest13
353 * @tc.desc: normal function
354 * @tc.type: FUNC
355 */
356 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest13, Function | SmallTest | Level2)
357 {
358 MessageParcel data;
359 MessageParcel reply;
360 MessageOption option;
361
362 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
363 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
364 data.WriteUint32(static_cast<uint32_t>(type));
365 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
366 data.WriteRemoteObject(windowManagerAgent->AsObject());
367
368 uint32_t code = static_cast<uint32_t>(
369 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_ID);
370
371 int res = stub_->OnRemoteRequest(code, data, reply, option);
372 EXPECT_EQ(res, 0);
373 }
374
375 /**
376 * @tc.name: OnRemoteRequest14
377 * @tc.desc: normal function
378 * @tc.type: FUNC
379 */
380 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest14, Function | SmallTest | Level2)
381 {
382 MessageParcel data;
383 MessageParcel reply;
384 MessageOption option;
385
386 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
387 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
388 data.WriteUint32(static_cast<uint32_t>(type));
389 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
390 data.WriteRemoteObject(windowManagerAgent->AsObject());
391
392 uint32_t code = static_cast<uint32_t>(
393 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_BY_SCREEN);
394
395 int res = stub_->OnRemoteRequest(code, data, reply, option);
396 EXPECT_EQ(res, 0);
397 }
398
399 /**
400 * @tc.name: OnRemoteRequest15
401 * @tc.desc: normal function
402 * @tc.type: FUNC
403 */
404 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest15, Function | SmallTest | Level2)
405 {
406 MessageParcel data;
407 MessageParcel reply;
408 MessageOption option;
409
410 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
411 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
412 data.WriteUint32(static_cast<uint32_t>(type));
413 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
414 data.WriteRemoteObject(windowManagerAgent->AsObject());
415
416 uint32_t code = static_cast<uint32_t>(
417 DisplayManagerMessage::TRANS_ID_GET_ALL_DISPLAYIDS);
418
419 int res = stub_->OnRemoteRequest(code, data, reply, option);
420 EXPECT_EQ(res, 0);
421 }
422
423 /**
424 * @tc.name: OnRemoteRequest16
425 * @tc.desc: normal function
426 * @tc.type: FUNC
427 */
428 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest16, Function | SmallTest | Level2)
429 {
430 MessageParcel data;
431 MessageParcel reply;
432 MessageOption option;
433
434 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
435 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
436 data.WriteUint32(static_cast<uint32_t>(type));
437 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
438 data.WriteRemoteObject(windowManagerAgent->AsObject());
439
440 uint32_t code = static_cast<uint32_t>(
441 DisplayManagerMessage::TRANS_ID_GET_SCREEN_INFO_BY_ID);
442
443 int res = stub_->OnRemoteRequest(code, data, reply, option);
444 EXPECT_EQ(res, 0);
445 }
446
447 /**
448 * @tc.name: OnRemoteRequest17
449 * @tc.desc: normal function
450 * @tc.type: FUNC
451 */
452 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest17, Function | SmallTest | Level2)
453 {
454 MessageParcel data;
455 MessageParcel reply;
456 MessageOption option;
457
458 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
459 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
460 data.WriteUint32(static_cast<uint32_t>(type));
461 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
462 data.WriteRemoteObject(windowManagerAgent->AsObject());
463
464 uint32_t code = static_cast<uint32_t>(
465 DisplayManagerMessage::TRANS_ID_GET_ALL_SCREEN_INFOS);
466
467 int res = stub_->OnRemoteRequest(code, data, reply, option);
468 EXPECT_EQ(res, 0);
469 }
470
471 /**
472 * @tc.name: OnRemoteRequest18
473 * @tc.desc: normal function
474 * @tc.type: FUNC
475 */
476 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest18, Function | SmallTest | Level2)
477 {
478 MessageParcel data;
479 MessageParcel reply;
480 MessageOption option;
481
482 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
483 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
484 data.WriteUint32(static_cast<uint32_t>(type));
485 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
486 data.WriteRemoteObject(windowManagerAgent->AsObject());
487
488 uint32_t code = static_cast<uint32_t>(
489 DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_GAMUTS);
490
491 int res = stub_->OnRemoteRequest(code, data, reply, option);
492 EXPECT_EQ(res, 0);
493 }
494
495 /**
496 * @tc.name: OnRemoteRequest19
497 * @tc.desc: normal function
498 * @tc.type: FUNC
499 */
500 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest19, Function | SmallTest | Level2)
501 {
502 MessageParcel data;
503 MessageParcel reply;
504 MessageOption option;
505
506 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
507 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
508 data.WriteUint32(static_cast<uint32_t>(type));
509 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
510 data.WriteRemoteObject(windowManagerAgent->AsObject());
511
512 uint32_t code = static_cast<uint32_t>(
513 DisplayManagerMessage::TRANS_ID_CREATE_VIRTUAL_SCREEN);
514
515 int res = stub_->OnRemoteRequest(code, data, reply, option);
516 EXPECT_EQ(res, 0);
517 }
518
519 /**
520 * @tc.name: OnRemoteRequest20
521 * @tc.desc: normal function
522 * @tc.type: FUNC
523 */
524 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest20, Function | SmallTest | Level2)
525 {
526 MessageParcel data;
527 MessageParcel reply;
528 MessageOption option;
529
530 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
531 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
532 data.WriteUint32(static_cast<uint32_t>(type));
533 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
534 data.WriteRemoteObject(windowManagerAgent->AsObject());
535
536 uint32_t code = static_cast<uint32_t>(
537 DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN);
538
539 int res = stub_->OnRemoteRequest(code, data, reply, option);
540 EXPECT_EQ(res, 0);
541 }
542
543 /**
544 * @tc.name: OnRemoteRequest21
545 * @tc.desc: normal function
546 * @tc.type: FUNC
547 */
548 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest21, Function | SmallTest | Level2)
549 {
550 MessageParcel data;
551 MessageParcel reply;
552 MessageOption option;
553
554 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
555 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
556 data.WriteUint32(static_cast<uint32_t>(type));
557 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
558 data.WriteRemoteObject(windowManagerAgent->AsObject());
559
560 uint32_t code = static_cast<uint32_t>(
561 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO);
562
563 int res = stub_->OnRemoteRequest(code, data, reply, option);
564 EXPECT_EQ(res, 0);
565 }
566
567 /**
568 * @tc.name: OnRemoteRequest22
569 * @tc.desc: normal function
570 * @tc.type: FUNC
571 */
572 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest22, Function | SmallTest | Level2)
573 {
574 MessageParcel data;
575 MessageParcel reply;
576 MessageOption option;
577
578 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
579 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
580 data.WriteUint32(static_cast<uint32_t>(type));
581 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
582 data.WriteRemoteObject(windowManagerAgent->AsObject());
583
584 uint32_t code = static_cast<uint32_t>(
585 DisplayManagerMessage::TRANS_ID_DESTROY_VIRTUAL_SCREEN);
586
587 int res = stub_->OnRemoteRequest(code, data, reply, option);
588 EXPECT_EQ(res, 0);
589 }
590
591 /**
592 * @tc.name: OnRemoteRequest23
593 * @tc.desc: normal function
594 * @tc.type: FUNC
595 */
596 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest23, Function | SmallTest | Level2)
597 {
598 MessageParcel data;
599 MessageParcel reply;
600 MessageOption option;
601
602 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
603 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
604 data.WriteUint32(static_cast<uint32_t>(type));
605 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
606 data.WriteRemoteObject(windowManagerAgent->AsObject());
607
608 uint32_t code = static_cast<uint32_t>(
609 DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_MIRROR);
610
611 int res = stub_->OnRemoteRequest(code, data, reply, option);
612 EXPECT_EQ(res, 0);
613 }
614
615 /**
616 * @tc.name: OnRemoteRequest24
617 * @tc.desc: normal function
618 * @tc.type: FUNC
619 */
620 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest24, Function | SmallTest | Level2)
621 {
622 MessageParcel data;
623 MessageParcel reply;
624 MessageOption option;
625
626 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
627 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
628 data.WriteUint32(static_cast<uint32_t>(type));
629 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
630 data.WriteRemoteObject(windowManagerAgent->AsObject());
631
632 uint32_t code = static_cast<uint32_t>(
633 DisplayManagerMessage::TRANS_ID_SCREEN_STOP_MIRROR);
634
635 int res = stub_->OnRemoteRequest(code, data, reply, option);
636 EXPECT_EQ(res, 0);
637 }
638
639 /**
640 * @tc.name: OnRemoteRequest25
641 * @tc.desc: normal function
642 * @tc.type: FUNC
643 */
644 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest25, Function | SmallTest | Level2)
645 {
646 MessageParcel data;
647 MessageParcel reply;
648 MessageOption option;
649
650 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
651 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
652 data.WriteUint32(static_cast<uint32_t>(type));
653 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
654 data.WriteRemoteObject(windowManagerAgent->AsObject());
655
656 uint32_t code = static_cast<uint32_t>(
657 DisplayManagerMessage::TRANS_ID_SCREEN_MAKE_EXPAND);
658
659 int res = stub_->OnRemoteRequest(code, data, reply, option);
660 EXPECT_EQ(res, 0);
661 }
662
663 /**
664 * @tc.name: OnRemoteRequest26
665 * @tc.desc: normal function
666 * @tc.type: FUNC
667 */
668 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest26, Function | SmallTest | Level2)
669 {
670 MessageParcel data;
671 MessageParcel reply;
672 MessageOption option;
673
674 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
675 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
676 data.WriteUint32(static_cast<uint32_t>(type));
677 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
678 data.WriteRemoteObject(windowManagerAgent->AsObject());
679
680 uint32_t code = static_cast<uint32_t>(
681 DisplayManagerMessage::TRANS_ID_SCREEN_STOP_EXPAND);
682
683 int res = stub_->OnRemoteRequest(code, data, reply, option);
684 EXPECT_EQ(res, 0);
685 }
686
687 /**
688 * @tc.name: OnRemoteRequest27
689 * @tc.desc: normal function
690 * @tc.type: FUNC
691 */
692 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest27, Function | SmallTest | Level2)
693 {
694 MessageParcel data;
695 MessageParcel reply;
696 MessageOption option;
697
698 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
699 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
700 data.WriteUint32(static_cast<uint32_t>(type));
701 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
702 data.WriteRemoteObject(windowManagerAgent->AsObject());
703
704 uint32_t code = static_cast<uint32_t>(
705 DisplayManagerMessage::TRANS_ID_GET_SCREEN_GROUP_INFO_BY_ID);
706
707 int res = stub_->OnRemoteRequest(code, data, reply, option);
708 EXPECT_EQ(res, 0);
709 }
710
711 /**
712 * @tc.name: OnRemoteRequest28
713 * @tc.desc: normal function
714 * @tc.type: FUNC
715 */
716 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest28, Function | SmallTest | Level2)
717 {
718 MessageParcel data;
719 MessageParcel reply;
720 MessageOption option;
721
722 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
723 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
724 data.WriteUint32(static_cast<uint32_t>(type));
725 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
726 data.WriteRemoteObject(windowManagerAgent->AsObject());
727
728 uint32_t code = static_cast<uint32_t>(
729 DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_FROM_SCREEN_GROUP);
730
731 int res = stub_->OnRemoteRequest(code, data, reply, option);
732 EXPECT_EQ(res, 0);
733 }
734
735 /**
736 * @tc.name: OnRemoteRequest29
737 * @tc.desc: normal function
738 * @tc.type: FUNC
739 */
740 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest29, Function | SmallTest | Level2)
741 {
742 MessageParcel data;
743 MessageParcel reply;
744 MessageOption option;
745
746 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
747 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
748 data.WriteUint32(static_cast<uint32_t>(type));
749 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
750 data.WriteRemoteObject(windowManagerAgent->AsObject());
751
752 uint32_t code = static_cast<uint32_t>(
753 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_SNAPSHOT);
754
755 int res = stub_->OnRemoteRequest(code, data, reply, option);
756 EXPECT_EQ(res, 0);
757 }
758
759 /**
760 * @tc.name: OnRemoteRequest30
761 * @tc.desc: normal function
762 * @tc.type: FUNC
763 */
764 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest30, Function | SmallTest | Level2)
765 {
766 MessageParcel data;
767 MessageParcel reply;
768 MessageOption option;
769
770 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
771 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
772 data.WriteUint32(static_cast<uint32_t>(type));
773 sptr<IWindowManagerAgent> windowManagerAgent = new WindowManagerAgent();
774 data.WriteRemoteObject(windowManagerAgent->AsObject());
775
776 uint32_t code = static_cast<uint32_t>(
777 DisplayManagerMessage::TRANS_ID_SET_SCREEN_ACTIVE_MODE);
778
779 int res = stub_->OnRemoteRequest(code, data, reply, option);
780 EXPECT_EQ(res, 0);
781 }
782
783 /**
784 * @tc.name: OnRemoteRequest32
785 * @tc.desc: normal function
786 * @tc.type: FUNC
787 */
788 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest32, Function | SmallTest | Level2)
789 {
790 MessageParcel data;
791 MessageParcel reply;
792 MessageOption option;
793
794 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
795 data.WriteBool(false);
796 uint32_t code = static_cast<uint32_t>(
797 DisplayManagerMessage::TRANS_ID_SCREEN_DISABLE_MIRROR);
798 int res = stub_->OnRemoteRequest(code, data, reply, option);
799 EXPECT_EQ(res, 0);
800 }
801
802 /**
803 * @tc.name: OnRemoteRequest33
804 * @tc.desc: normal function
805 * @tc.type: FUNC
806 */
807 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest33, Function | SmallTest | Level2)
808 {
809 MessageParcel data;
810 MessageParcel reply;
811 MessageOption option;
812
813 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
814 data.WriteRemoteObject(nullptr);
815 uint32_t code = static_cast<uint32_t>(
816 DisplayManagerMessage::TRANS_ID_SET_CLIENT);
817 int res = stub_->OnRemoteRequest(code, data, reply, option);
818 EXPECT_EQ(res, 0);
819 }
820
821 /**
822 * @tc.name: OnRemoteRequest34
823 * @tc.desc: normal function
824 * @tc.type: FUNC
825 */
826 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest34, Function | SmallTest | Level2)
827 {
828 MessageParcel data;
829 MessageParcel reply;
830 MessageOption option;
831
832 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
833 data.WriteUint64(0);
834 uint32_t code = static_cast<uint32_t>(
835 DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY);
836 int res = stub_->OnRemoteRequest(code, data, reply, option);
837 EXPECT_EQ(res, 0);
838 }
839
840 /**
841 * @tc.name: OnRemoteRequest35
842 * @tc.desc: normal function
843 * @tc.type: FUNC
844 */
845 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest35, Function | SmallTest | Level2)
846 {
847 MessageParcel data;
848 MessageParcel reply;
849 MessageOption option;
850
851 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
852 data.WriteUint64(0);
853 uint32_t code = static_cast<uint32_t>(
854 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE);
855 int res = stub_->OnRemoteRequest(code, data, reply, option);
856 EXPECT_EQ(res, 0);
857 }
858
859 /**
860 * @tc.name: OnRemoteRequest36
861 * @tc.desc: normal function
862 * @tc.type: FUNC
863 */
864 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest36, Function | SmallTest | Level2)
865 {
866 MessageParcel data;
867 MessageParcel reply;
868 MessageOption option;
869
870 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
871 data.WriteUint64(0);
872 RRect bounds;
873 RSMarshallingHelper::Marshalling(data, bounds);
874 data.WriteFloat(0);
875 uint32_t code = static_cast<uint32_t>(
876 DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_ROTATION_PROPERTY);
877 int res = stub_->OnRemoteRequest(code, data, reply, option);
878 EXPECT_EQ(res, 0);
879 }
880
881 /**
882 * @tc.name: OnRemoteRequest37
883 * @tc.desc: normal function
884 * @tc.type: FUNC
885 */
886 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest37, Function | SmallTest | Level2)
887 {
888 MessageParcel data;
889 MessageParcel reply;
890 MessageOption option;
891
892 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
893 uint32_t code = static_cast<uint32_t>(
894 DisplayManagerMessage::TRANS_ID_GET_CURVED_SCREEN_COMPRESSION_AREA);
895 int res = stub_->OnRemoteRequest(code, data, reply, option);
896 EXPECT_EQ(res, 0);
897 }
898
899 /**
900 * @tc.name: OnRemoteRequest38
901 * @tc.desc: normal function
902 * @tc.type: FUNC
903 */
904 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest38, Function | SmallTest | Level2)
905 {
906 MessageParcel data;
907 MessageParcel reply;
908 MessageOption option;
909
910 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
911 data.WriteUint64(0);
912 uint32_t code = static_cast<uint32_t>(
913 DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY);
914 int res = stub_->OnRemoteRequest(code, data, reply, option);
915 EXPECT_EQ(res, 0);
916 }
917
918 /**
919 * @tc.name: OnRemoteRequest39
920 * @tc.desc: normal function
921 * @tc.type: FUNC
922 */
923 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest39, Function | SmallTest | Level2)
924 {
925 MessageParcel data;
926 MessageParcel reply;
927 MessageOption option;
928
929 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
930 data.WriteBool(false);
931 uint32_t code = static_cast<uint32_t>(
932 DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_STATE);
933 int res = stub_->OnRemoteRequest(code, data, reply, option);
934 EXPECT_EQ(res, 0);
935 }
936
937 /**
938 * @tc.name: OnRemoteRequest40
939 * @tc.desc: normal function
940 * @tc.type: FUNC
941 */
942 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest40, Function | SmallTest | Level2)
943 {
944 MessageParcel data;
945 MessageParcel reply;
946 MessageOption option;
947
948 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
949 data.WriteUint64(0);
950 uint32_t code = static_cast<uint32_t>(
951 DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE);
952 int res = stub_->OnRemoteRequest(code, data, reply, option);
953 EXPECT_EQ(res, 0);
954 }
955
956 /**
957 * @tc.name: OnRemoteRequest41
958 * @tc.desc: normal function
959 * @tc.type: FUNC
960 */
961 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest41, Function | SmallTest | Level2)
962 {
963 MessageParcel data;
964 MessageParcel reply;
965 MessageOption option;
966
967 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
968 data.WriteUint64(0);
969 uint32_t code = static_cast<uint32_t>(
970 DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE);
971 int res = stub_->OnRemoteRequest(code, data, reply, option);
972 EXPECT_EQ(res, 0);
973 }
974
975 /**
976 * @tc.name: OnRemoteRequest42
977 * @tc.desc: normal function
978 * @tc.type: FUNC
979 */
980 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest42, Function | SmallTest | Level2)
981 {
982 MessageParcel data;
983 MessageParcel reply;
984 MessageOption option;
985
986 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
987 data.WriteBool(false);
988 uint32_t code = static_cast<uint32_t>(
989 DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT);
990 int res = stub_->OnRemoteRequest(code, data, reply, option);
991 EXPECT_EQ(res, 0);
992 }
993
994 /**
995 * @tc.name: OnRemoteRequest43
996 * @tc.desc: normal function
997 * @tc.type: FUNC
998 */
999 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest43, Function | SmallTest | Level2)
1000 {
1001 MessageParcel data;
1002 MessageParcel reply;
1003 MessageOption option;
1004
1005 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1006 data.WriteUint64(0);
1007 uint32_t code = static_cast<uint32_t>(
1008 DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT);
1009 int res = stub_->OnRemoteRequest(code, data, reply, option);
1010 EXPECT_EQ(res, 0);
1011 }
1012
1013 /**
1014 * @tc.name: OnRemoteRequest44
1015 * @tc.desc: normal function
1016 * @tc.type: FUNC
1017 */
1018 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest44, Function | SmallTest | Level2)
1019 {
1020 MessageParcel data;
1021 MessageParcel reply;
1022 MessageOption option;
1023
1024 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1025 data.WriteUint64(0);
1026 uint32_t code = static_cast<uint32_t>(
1027 DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT);
1028 int res = stub_->OnRemoteRequest(code, data, reply, option);
1029 EXPECT_EQ(res, 0);
1030 }
1031
1032 /**
1033 * @tc.name: OnRemoteRequest45
1034 * @tc.desc: normal function
1035 * @tc.type: FUNC
1036 */
1037 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest45, Function | SmallTest | Level2)
1038 {
1039 MessageParcel data;
1040 MessageParcel reply;
1041 MessageOption option;
1042
1043 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1044 data.WriteBool(false);
1045 uint32_t code = static_cast<uint32_t>(
1046 DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT);
1047 int res = stub_->OnRemoteRequest(code, data, reply, option);
1048 EXPECT_EQ(res, 0);
1049 }
1050
1051 /**
1052 * @tc.name: OnRemoteRequest46
1053 * @tc.desc: normal function
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest46, Function | SmallTest | Level2)
1057 {
1058 MessageParcel data;
1059 MessageParcel reply;
1060 MessageOption option;
1061
1062 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1063 data.WriteUint64(0);
1064 uint32_t code = static_cast<uint32_t>(
1065 DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT);
1066 int res = stub_->OnRemoteRequest(code, data, reply, option);
1067 EXPECT_EQ(res, 0);
1068 }
1069
1070 /**
1071 * @tc.name: OnRemoteRequest47
1072 * @tc.desc: normal function
1073 * @tc.type: FUNC
1074 */
1075 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest47, Function | SmallTest | Level2)
1076 {
1077 MessageParcel data;
1078 MessageParcel reply;
1079 MessageOption option;
1080
1081 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1082 data.WriteBool(false);
1083 uint32_t code = static_cast<uint32_t>(
1084 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM);
1085 int res = stub_->OnRemoteRequest(code, data, reply, option);
1086 EXPECT_EQ(res, 0);
1087 }
1088
1089 /**
1090 * @tc.name: OnRemoteRequest48
1091 * @tc.desc: normal function
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest48, Function | SmallTest | Level2)
1095 {
1096 MessageParcel data;
1097 MessageParcel reply;
1098 MessageOption option;
1099
1100 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1101 data.WriteBool(false);
1102 uint32_t code = static_cast<uint32_t>(
1103 DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP);
1104 int res = stub_->OnRemoteRequest(code, data, reply, option);
1105 EXPECT_EQ(res, 0);
1106 }
1107
1108 /**
1109 * @tc.name: OnRemoteRequest49
1110 * @tc.desc: normal function
1111 * @tc.type: FUNC
1112 */
1113 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest49, Function | SmallTest | Level2)
1114 {
1115 MessageParcel data;
1116 MessageParcel reply;
1117 MessageOption option;
1118
1119 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1120 data.WriteUint64(0);
1121 uint32_t code = static_cast<uint32_t>(
1122 DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP);
1123 int res = stub_->OnRemoteRequest(code, data, reply, option);
1124 EXPECT_EQ(res, 0);
1125 }
1126
1127 /**
1128 * @tc.name: OnRemoteRequest050
1129 * @tc.desc: normal function
1130 * @tc.type: FUNC
1131 */
1132 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest050, Function | SmallTest | Level2)
1133 {
1134 MessageParcel data;
1135 MessageParcel reply;
1136 MessageOption option;
1137
1138 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1139 data.WriteBool(false);
1140 uint32_t code = static_cast<uint32_t>(
1141 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT);
1142 int res = stub_->OnRemoteRequest(code, data, reply, option);
1143 EXPECT_EQ(res, 0);
1144 }
1145
1146 /**
1147 * @tc.name: OnRemoteRequest051
1148 * @tc.desc: normal function
1149 * @tc.type: FUNC
1150 */
1151 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest051, Function | SmallTest | Level2)
1152 {
1153 MessageParcel data;
1154 MessageParcel reply;
1155 MessageOption option;
1156
1157 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1158 data.WriteUint64(0);
1159 uint32_t code = static_cast<uint32_t>(
1160 DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT);
1161 int res = stub_->OnRemoteRequest(code, data, reply, option);
1162 EXPECT_EQ(res, 0);
1163 }
1164
1165 /**
1166 * @tc.name: OnRemoteRequest052
1167 * @tc.desc: normal function
1168 * @tc.type: FUNC
1169 */
1170 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest052, Function | SmallTest | Level2)
1171 {
1172 MessageParcel data;
1173 MessageParcel reply;
1174 MessageOption option;
1175
1176 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1177 data.WriteBool(false);
1178 uint32_t code = static_cast<uint32_t>(
1179 DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION);
1180 int res = stub_->OnRemoteRequest(code, data, reply, option);
1181 EXPECT_EQ(res, 0);
1182 }
1183
1184 /**
1185 * @tc.name: OnRemoteRequest053
1186 * @tc.desc: normal function
1187 * @tc.type: FUNC
1188 */
1189 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest053, Function | SmallTest | Level2)
1190 {
1191 MessageParcel data;
1192 MessageParcel reply;
1193 MessageOption option;
1194
1195 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1196 data.WriteBool(false);
1197 uint32_t code = static_cast<uint32_t>(
1198 DisplayManagerMessage::TRANS_ID_SET_RESOLUTION);
1199 int res = stub_->OnRemoteRequest(code, data, reply, option);
1200 EXPECT_EQ(res, 0);
1201 }
1202
1203 /**
1204 * @tc.name: OnRemoteRequest054
1205 * @tc.desc: normal function
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest054, Function | SmallTest | Level2)
1209 {
1210 MessageParcel data;
1211 MessageParcel reply;
1212 MessageOption option;
1213
1214 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1215 data.WriteBool(false);
1216 uint32_t code = static_cast<uint32_t>(
1217 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE);
1218 int res = stub_->OnRemoteRequest(code, data, reply, option);
1219 EXPECT_EQ(res, 0);
1220 }
1221
1222 /**
1223 * @tc.name: OnRemoteRequest055
1224 * @tc.desc: normal function
1225 * @tc.type: FUNC
1226 */
1227 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest055, Function | SmallTest | Level2)
1228 {
1229 MessageParcel data;
1230 MessageParcel reply;
1231 MessageOption option;
1232
1233 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1234 data.WriteBool(false);
1235 uint32_t code = static_cast<uint32_t>(
1236 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION);
1237 int res = stub_->OnRemoteRequest(code, data, reply, option);
1238 EXPECT_EQ(res, 0);
1239 }
1240
1241 /**
1242 * @tc.name: OnRemoteRequest056
1243 * @tc.desc: normal function
1244 * @tc.type: FUNC
1245 */
1246 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest056, Function | SmallTest | Level2)
1247 {
1248 MessageParcel data;
1249 MessageParcel reply;
1250 MessageOption option;
1251
1252 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1253 data.WriteBool(false);
1254 uint32_t code = static_cast<uint32_t>(
1255 DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER);
1256 int res = stub_->OnRemoteRequest(code, data, reply, option);
1257 EXPECT_EQ(res, -1);
1258 }
1259
1260 /**
1261 * @tc.name: OnRemoteRequest057
1262 * @tc.desc: normal function
1263 * @tc.type: FUNC
1264 */
1265 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest057, Function | SmallTest | Level2)
1266 {
1267 MessageParcel data;
1268 MessageParcel reply;
1269 MessageOption option;
1270
1271 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1272 uint32_t code = static_cast<uint32_t>(
1273 DisplayManagerMessage::TRANS_ID_GET_DEVICE_SCREEN_CONFIG);
1274 int res = stub_->OnRemoteRequest(code, data, reply, option);
1275 EXPECT_EQ(res, 0);
1276 }
1277
1278 /**
1279 * @tc.name: OnRemoteRequest58
1280 * @tc.desc: normal function, TRANS_ID_SET_SCREENID_PRIVACY_STATE test
1281 * @tc.type: FUNC
1282 */
1283 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest58, Function | SmallTest | Level2)
1284 {
1285 MessageParcel data;
1286 MessageParcel reply;
1287 MessageOption option;
1288
1289 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1290 DisplayId displayId = 0;
1291 data.WriteUint64(displayId);
1292 data.WriteBool(false);
1293 uint32_t code = static_cast<uint32_t>(
1294 DisplayManagerMessage::TRANS_ID_SET_SCREENID_PRIVACY_STATE);
1295 int res = stub_->OnRemoteRequest(code, data, reply, option);
1296 EXPECT_EQ(res, 0);
1297 }
1298
1299 /**
1300 * @tc.name: OnRemoteRequest59
1301 * @tc.desc: normal function, TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST test
1302 * @tc.type: FUNC
1303 */
1304 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest59, Function | SmallTest | Level2)
1305 {
1306 MessageParcel data;
1307 MessageParcel reply;
1308 MessageOption option;
1309
1310 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1311 DisplayId displayId = 0;
1312 data.WriteUint64(displayId);
1313 std::vector<std::string> privacyWindowList{"win0", "win1"};
1314 data.WriteStringVector(privacyWindowList);
1315 uint32_t code = static_cast<uint32_t>(
1316 DisplayManagerMessage::TRANS_ID_SET_SCREEN_PRIVACY_WINDOW_LIST);
1317 int res = stub_->OnRemoteRequest(code, data, reply, option);
1318 EXPECT_EQ(res, 0);
1319 }
1320
1321 /**
1322 * @tc.name: OnRemoteRequest60
1323 * @tc.desc: normal function, TRANS_ID_SET_SCREEN_OFF_DELAY_TIME test
1324 * @tc.type: FUNC
1325 */
1326 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest60, Function | SmallTest | Level2)
1327 {
1328 MessageParcel data;
1329 MessageParcel reply;
1330 MessageOption option;
1331
1332 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1333 data.WriteInt32(2000);
1334 uint32_t code = static_cast<uint32_t>(
1335 DisplayManagerMessage::TRANS_ID_SET_SCREEN_OFF_DELAY_TIME);
1336 int res = stub_->OnRemoteRequest(code, data, reply, option);
1337 EXPECT_EQ(res, 0);
1338 }
1339
1340 /**
1341 * @tc.name: OnRemoteRequest61
1342 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST test
1343 * @tc.type: FUNC
1344 */
1345 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest61, Function | SmallTest | Level2)
1346 {
1347 MessageParcel data;
1348 MessageParcel reply;
1349 MessageOption option;
1350
1351 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1352 ScreenId id = 1001;
1353 std::vector<uint64_t> windowIdList{10, 20, 30};
1354 data.WriteUint64(static_cast<uint64_t>(id));
1355 data.WriteUInt64Vector(windowIdList);
1356 uint32_t code = static_cast<uint32_t>(
1357 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST);
1358 int res = stub_->OnRemoteRequest(code, data, reply, option);
1359 EXPECT_EQ(res, 0);
1360 }
1361
1362 /**
1363 * @tc.name: OnRemoteRequest62
1364 * @tc.desc: normal function, TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO test
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest62, Function | SmallTest | Level2)
1368 {
1369 MessageParcel data;
1370 MessageParcel reply;
1371 MessageOption option;
1372
1373 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1374
1375 data.WriteInt32(200);
1376 data.WriteBool(true);
1377 data.WriteUint32(1062);
1378 data.WriteUint32(1062);
1379 data.WriteFloat(1.5);
1380 uint32_t code = static_cast<uint32_t>(
1381 DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_HOOK_INFO);
1382 int res = stub_->OnRemoteRequest(code, data, reply, option);
1383 EXPECT_EQ(res, 0);
1384 }
1385
1386 /**
1387 * @tc.name: OnRemoteRequest63
1388 * @tc.desc: normal function, TRANS_ID_RESET_ALL_FREEZE_STATUS test
1389 * @tc.type: FUNC
1390 */
1391 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest63, Function | SmallTest | Level2)
1392 {
1393 MessageParcel data;
1394 MessageParcel reply;
1395 MessageOption option;
1396
1397 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1398
1399 uint32_t code = static_cast<uint32_t>(
1400 DisplayManagerMessage::TRANS_ID_RESET_ALL_FREEZE_STATUS);
1401 int res = stub_->OnRemoteRequest(code, data, reply, option);
1402 EXPECT_EQ(res, 0);
1403 }
1404
1405 /**
1406 * @tc.name: OnRemoteRequest64
1407 * @tc.desc: normal function, TRANS_ID_PROXY_FOR_FREEZE test
1408 * @tc.type: FUNC
1409 */
1410 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest64, Function | SmallTest | Level2)
1411 {
1412 MessageParcel data;
1413 MessageParcel reply;
1414 MessageOption option;
1415
1416 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1417
1418 int32_t size = 10;
1419 data.WriteInt32(size);
1420 for (int32_t i = 0; i < size; i++) {
1421 data.WriteInt32(i);
1422 }
1423 data.WriteBool(true);
1424 uint32_t code = static_cast<uint32_t>(
1425 DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE);
1426 int res = stub_->OnRemoteRequest(code, data, reply, option);
1427 EXPECT_EQ(res, 0);
1428 }
1429
1430 /**
1431 * @tc.name: OnRemoteRequest65
1432 * @tc.desc: normal function, TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL test
1433 * @tc.type: FUNC
1434 */
1435 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest65, Function | SmallTest | Level2)
1436 {
1437 MessageParcel data;
1438 MessageParcel reply;
1439 MessageOption option;
1440
1441 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1442
1443 data.WriteUint64(1065);
1444 uint32_t code = static_cast<uint32_t>(
1445 DisplayManagerMessage::TRANS_ID_DISABLE_POWEROFF_RENDER_CONTROL);
1446 int res = stub_->OnRemoteRequest(code, data, reply, option);
1447 EXPECT_EQ(res, 0);
1448 }
1449
1450 /**
1451 * @tc.name: OnRemoteRequest66
1452 * @tc.desc: normal function, TRANS_ID_SWITCH_USER test
1453 * @tc.type: FUNC
1454 */
1455 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest66, Function | SmallTest | Level2)
1456 {
1457 MessageParcel data;
1458 MessageParcel reply;
1459 MessageOption option;
1460
1461 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1462
1463 uint32_t code = static_cast<uint32_t>(
1464 DisplayManagerMessage::TRANS_ID_SWITCH_USER);
1465 int res = stub_->OnRemoteRequest(code, data, reply, option);
1466 EXPECT_EQ(res, 0);
1467 }
1468
1469 /**
1470 * @tc.name: OnRemoteRequest67
1471 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE test
1472 * @tc.type: FUNC
1473 */
1474 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest67, Function | SmallTest | Level2)
1475 {
1476 MessageParcel data;
1477 MessageParcel reply;
1478 MessageOption option;
1479
1480 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1481
1482 data.WriteUint64(1067);
1483 data.WriteUint32(120);
1484 uint32_t code = static_cast<uint32_t>(
1485 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_REFRESH_RATE);
1486 int res = stub_->OnRemoteRequest(code, data, reply, option);
1487 EXPECT_EQ(res, 0);
1488 }
1489
1490 /**
1491 * @tc.name: OnRemoteRequest68
1492 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_FLAG test
1493 * @tc.type: FUNC
1494 */
1495 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest68, Function | SmallTest | Level2)
1496 {
1497 MessageParcel data;
1498 MessageParcel reply;
1499 MessageOption option;
1500
1501 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1502
1503 data.WriteUint64(1068);
1504 data.WriteUint32(100);
1505 uint32_t code = static_cast<uint32_t>(
1506 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_FLAG);
1507 int res = stub_->OnRemoteRequest(code, data, reply, option);
1508 EXPECT_EQ(res, 0);
1509 }
1510
1511 /**
1512 * @tc.name: OnRemoteRequest69
1513 * @tc.desc: normal function, TRANS_ID_GET_VIRTUAL_SCREEN_FLAG test
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest69, Function | SmallTest | Level2)
1517 {
1518 MessageParcel data;
1519 MessageParcel reply;
1520 MessageOption option;
1521
1522 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1523
1524 data.WriteUint64(1069);
1525 uint32_t code = static_cast<uint32_t>(
1526 DisplayManagerMessage::TRANS_ID_GET_VIRTUAL_SCREEN_FLAG);
1527 int res = stub_->OnRemoteRequest(code, data, reply, option);
1528 EXPECT_EQ(res, 0);
1529 }
1530
1531 /**
1532 * @tc.name: OnRemoteRequest70
1533 * @tc.desc: normal function, TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION test
1534 * @tc.type: FUNC
1535 */
1536 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest70, Function | SmallTest | Level2)
1537 {
1538 MessageParcel data;
1539 MessageParcel reply;
1540 MessageOption option;
1541
1542 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1543
1544 data.WriteBool(true);
1545 uint32_t code = static_cast<uint32_t>(
1546 DisplayManagerMessage::TRANS_ID_NOTIFY_FOLD_TO_EXPAND_COMPLETION);
1547 int res = stub_->OnRemoteRequest(code, data, reply, option);
1548 EXPECT_EQ(res, 0);
1549 }
1550
1551 /**
1552 * @tc.name: OnRemoteRequest71
1553 * @tc.desc: normal function, TRANS_ID_GET_AVAILABLE_AREA test
1554 * @tc.type: FUNC
1555 */
1556 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest71, Function | SmallTest | Level2)
1557 {
1558 MessageParcel data;
1559 MessageParcel reply;
1560 MessageOption option;
1561
1562 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1563
1564 data.WriteUint64(1071);
1565 uint32_t code = static_cast<uint32_t>(
1566 DisplayManagerMessage::TRANS_ID_GET_AVAILABLE_AREA);
1567 int res = stub_->OnRemoteRequest(code, data, reply, option);
1568 EXPECT_EQ(res, 0);
1569 }
1570
1571 /**
1572 * @tc.name: OnRemoteRequest72
1573 * @tc.desc: normal function, TRANS_ID_UPDATE_AVAILABLE_AREA test
1574 * @tc.type: FUNC
1575 */
1576 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest72, Function | SmallTest | Level2)
1577 {
1578 MessageParcel data;
1579 MessageParcel reply;
1580 MessageOption option;
1581
1582 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1583
1584 data.WriteUint64(1072);
1585 data.WriteInt32(100);
1586 data.WriteInt32(200);
1587 data.WriteUint32(150);
1588 data.WriteInt32(250);
1589 uint32_t code = static_cast<uint32_t>(
1590 DisplayManagerMessage::TRANS_ID_UPDATE_AVAILABLE_AREA);
1591 int res = stub_->OnRemoteRequest(code, data, reply, option);
1592 EXPECT_EQ(res, 0);
1593 }
1594
1595 /**
1596 * @tc.name: OnRemoteRequest73
1597 * @tc.desc: normal function, TRANS_ID_RESIZE_VIRTUAL_SCREEN test
1598 * @tc.type: FUNC
1599 */
1600 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest73, Function | SmallTest | Level2)
1601 {
1602 MessageParcel data;
1603 MessageParcel reply;
1604 MessageOption option;
1605
1606 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1607
1608 data.WriteUint64(1073);
1609 data.WriteUint32(1080);
1610 data.WriteUint32(1440);
1611 uint32_t code = static_cast<uint32_t>(
1612 DisplayManagerMessage::TRANS_ID_RESIZE_VIRTUAL_SCREEN);
1613 int res = stub_->OnRemoteRequest(code, data, reply, option);
1614 EXPECT_EQ(res, 0);
1615 }
1616
1617 /**
1618 * @tc.name: OnRemoteRequest74
1619 * @tc.desc: normal function, TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO test
1620 * @tc.type: FUNC
1621 */
1622 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest74, Function | SmallTest | Level2)
1623 {
1624 MessageParcel data;
1625 MessageParcel reply;
1626 MessageOption option;
1627
1628 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1629
1630 sptr<DisplayChangeInfo> info = new DisplayChangeInfo();
1631 info->action_ = ActionType::SINGLE_START;
1632 ScreenId toScreenId = SCREEN_ID_INVALID;
1633 info->toScreenId_ = toScreenId;
1634 ScreenId fromScreenId = SCREEN_ID_INVALID;
1635 info->fromScreenId_ = fromScreenId;
1636 std::string abilityName = "11";
1637 std::string bundleName = "22";
1638 info->abilityName_ = abilityName;
1639 info->bundleName_ = bundleName;
1640 info->Marshalling(data);
1641 uint32_t code = static_cast<uint32_t>(
1642 DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO);
1643 int res = stub_->OnRemoteRequest(code, data, reply, option);
1644 EXPECT_EQ(res, 0);
1645 }
1646
1647 /**
1648 * @tc.name: OnRemoteRequest75
1649 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN test
1650 * @tc.type: FUNC
1651 */
1652 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest75, Function | SmallTest | Level2)
1653 {
1654 MessageParcel data;
1655 MessageParcel reply;
1656 MessageOption option;
1657
1658 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1659
1660 std::vector<ScreenId> uniqueScreenIds = {1008, 2008, 3008};
1661 data.WriteUint32(uniqueScreenIds.size());
1662 data.WriteUInt64Vector(uniqueScreenIds);
1663 uint32_t code = static_cast<uint32_t>(
1664 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN);
1665 int res = stub_->OnRemoteRequest(code, data, reply, option);
1666 EXPECT_EQ(res, 0);
1667 }
1668
1669 /**
1670 * @tc.name: OnRemoteRequest76
1671 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION test
1672 * @tc.type: FUNC
1673 */
1674 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest76, Function | SmallTest | Level2)
1675 {
1676 MessageParcel data;
1677 MessageParcel reply;
1678 MessageOption option;
1679
1680 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1681
1682 uint32_t code = static_cast<uint32_t>(
1683 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_CURRENT_FOLD_CREASE_REGION);
1684 int res = stub_->OnRemoteRequest(code, data, reply, option);
1685 EXPECT_EQ(res, 0);
1686 }
1687
1688 /**
1689 * @tc.name: OnRemoteRequest77
1690 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS test
1691 * @tc.type: FUNC
1692 */
1693 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest77, Function | SmallTest | Level2)
1694 {
1695 MessageParcel data;
1696 MessageParcel reply;
1697 MessageOption option;
1698
1699 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1700
1701 uint32_t code = static_cast<uint32_t>(
1702 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_STATUS);
1703 int res = stub_->OnRemoteRequest(code, data, reply, option);
1704 EXPECT_EQ(res, 0);
1705 }
1706
1707 /**
1708 * @tc.name: OnRemoteRequest78
1709 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_IS_FOLDABLE test
1710 * @tc.type: FUNC
1711 */
1712 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest78, Function | SmallTest | Level2)
1713 {
1714 MessageParcel data;
1715 MessageParcel reply;
1716 MessageOption option;
1717
1718 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1719
1720 uint32_t code = static_cast<uint32_t>(
1721 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_IS_FOLDABLE);
1722 int res = stub_->OnRemoteRequest(code, data, reply, option);
1723 EXPECT_EQ(res, 0);
1724 }
1725
1726 /**
1727 * @tc.name: OnRemoteRequest79
1728 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE test
1729 * @tc.type: FUNC
1730 */
1731 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest79, Function | SmallTest | Level2)
1732 {
1733 MessageParcel data;
1734 MessageParcel reply;
1735 MessageOption option;
1736
1737 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1738
1739 uint32_t code = static_cast<uint32_t>(
1740 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_FOLD_DISPLAY_MODE);
1741 int res = stub_->OnRemoteRequest(code, data, reply, option);
1742 EXPECT_EQ(res, 0);
1743 }
1744
1745 /**
1746 * @tc.name: OnRemoteRequest80
1747 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS test
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest80, Function | SmallTest | Level2)
1751 {
1752 MessageParcel data;
1753 MessageParcel reply;
1754 MessageOption option;
1755
1756 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1757
1758 uint32_t code = static_cast<uint32_t>(
1759 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_LOCK_FOLD_DISPLAY_STATUS);
1760 int res = stub_->OnRemoteRequest(code, data, reply, option);
1761 EXPECT_EQ(res, 0);
1762 }
1763
1764 /**
1765 * @tc.name: OnRemoteRequest81
1766 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE test
1767 * @tc.type: FUNC
1768 */
1769 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest81, Function | SmallTest | Level2)
1770 {
1771 MessageParcel data;
1772 MessageParcel reply;
1773 MessageOption option;
1774
1775 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1776
1777 uint32_t code = static_cast<uint32_t>(
1778 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_FOLD_DISPLAY_MODE);
1779 int res = stub_->OnRemoteRequest(code, data, reply, option);
1780 EXPECT_EQ(res, 0);
1781 }
1782
1783 /**
1784 * @tc.name: OnRemoteRequest82
1785 * @tc.desc: normal function, TRANS_ID_DEVICE_IS_CAPTURE test
1786 * @tc.type: FUNC
1787 */
1788 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest82, Function | SmallTest | Level2)
1789 {
1790 MessageParcel data;
1791 MessageParcel reply;
1792 MessageOption option;
1793
1794 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1795
1796 uint32_t code = static_cast<uint32_t>(
1797 DisplayManagerMessage::TRANS_ID_DEVICE_IS_CAPTURE);
1798 int res = stub_->OnRemoteRequest(code, data, reply, option);
1799 EXPECT_EQ(res, 0);
1800 }
1801
1802 /**
1803 * @tc.name: OnRemoteRequest83
1804 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN test
1805 * @tc.type: FUNC
1806 */
1807 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest83, Function | SmallTest | Level2)
1808 {
1809 MessageParcel data;
1810 MessageParcel reply;
1811 MessageOption option;
1812
1813 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1814
1815 uint32_t code = static_cast<uint32_t>(
1816 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_SPECIAL_SCREEN);
1817 int res = stub_->OnRemoteRequest(code, data, reply, option);
1818 EXPECT_EQ(res, 0);
1819 }
1820
1821 /**
1822 * @tc.name: OnRemoteRequest84
1823 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN test
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest84, Function | SmallTest | Level2)
1827 {
1828 MessageParcel data;
1829 MessageParcel reply;
1830 MessageOption option;
1831
1832 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1833
1834 uint32_t code = static_cast<uint32_t>(
1835 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_DUMP_ALL_SCREEN);
1836 int res = stub_->OnRemoteRequest(code, data, reply, option);
1837 EXPECT_EQ(res, 0);
1838 }
1839
1840 /**
1841 * @tc.name: OnRemoteRequest85
1842 * @tc.desc: normal function, TRANS_ID_HAS_IMMERSIVE_WINDOW test
1843 * @tc.type: FUNC
1844 */
1845 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest85, Function | SmallTest | Level2)
1846 {
1847 MessageParcel data;
1848 MessageParcel reply;
1849 MessageOption option;
1850
1851 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1852 data.WriteUint64(0u);
1853
1854 uint32_t code = static_cast<uint32_t>(
1855 DisplayManagerMessage::TRANS_ID_HAS_IMMERSIVE_WINDOW);
1856 int res = stub_->OnRemoteRequest(code, data, reply, option);
1857 EXPECT_EQ(res, 0);
1858 }
1859
1860 /**
1861 * @tc.name: OnRemoteRequest86
1862 * @tc.desc: normal function, TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID test
1863 * @tc.type: FUNC
1864 */
1865 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest86, Function | SmallTest | Level2)
1866 {
1867 MessageParcel data;
1868 MessageParcel reply;
1869 MessageOption option;
1870
1871 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1872
1873 data.WriteUint64(1086);
1874 uint32_t code = static_cast<uint32_t>(
1875 DisplayManagerMessage::TRANS_ID_CONVERT_SCREENID_TO_RSSCREENID);
1876 int res = stub_->OnRemoteRequest(code, data, reply, option);
1877 EXPECT_EQ(res, 0);
1878 }
1879
1880 /**
1881 * @tc.name: OnRemoteRequest87
1882 * @tc.desc: normal function, TRANS_ID_HAS_PRIVATE_WINDOW test
1883 * @tc.type: FUNC
1884 */
1885 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest87, Function | SmallTest | Level2)
1886 {
1887 MessageParcel data;
1888 MessageParcel reply;
1889 MessageOption option;
1890
1891 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1892
1893 data.WriteUint64(1087);
1894 uint32_t code = static_cast<uint32_t>(
1895 DisplayManagerMessage::TRANS_ID_HAS_PRIVATE_WINDOW);
1896 int res = stub_->OnRemoteRequest(code, data, reply, option);
1897 EXPECT_EQ(res, 0);
1898 }
1899
1900 /**
1901 * @tc.name: OnRemoteRequest88
1902 * @tc.desc: normal function, TRANS_ID_GET_CUTOUT_INFO test
1903 * @tc.type: FUNC
1904 */
1905 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest88, Function | SmallTest | Level2)
1906 {
1907 MessageParcel data;
1908 MessageParcel reply;
1909 MessageOption option;
1910
1911 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1912
1913 data.WriteUint64(1088);
1914 uint32_t code = static_cast<uint32_t>(
1915 DisplayManagerMessage::TRANS_ID_GET_CUTOUT_INFO);
1916 int res = stub_->OnRemoteRequest(code, data, reply, option);
1917 EXPECT_EQ(res, 0);
1918 }
1919
1920 /**
1921 * @tc.name: OnRemoteRequest89
1922 * @tc.desc: normal function, TRANS_ID_IS_SCREEN_ROTATION_LOCKED test
1923 * @tc.type: FUNC
1924 */
1925 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest89, Function | SmallTest | Level2)
1926 {
1927 MessageParcel data;
1928 MessageParcel reply;
1929 MessageOption option;
1930
1931 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1932
1933 uint32_t code = static_cast<uint32_t>(
1934 DisplayManagerMessage::TRANS_ID_IS_SCREEN_ROTATION_LOCKED);
1935 int res = stub_->OnRemoteRequest(code, data, reply, option);
1936 EXPECT_EQ(res, 0);
1937 }
1938
1939 /**
1940 * @tc.name: OnRemoteRequest90
1941 * @tc.desc: normal function, TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS test
1942 * @tc.type: FUNC
1943 */
1944 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest90, Function | SmallTest | Level2)
1945 {
1946 MessageParcel data;
1947 MessageParcel reply;
1948 MessageOption option;
1949
1950 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1951
1952 data.WriteBool(true);
1953 uint32_t code = static_cast<uint32_t>(
1954 DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED_FROM_JS);
1955 int res = stub_->OnRemoteRequest(code, data, reply, option);
1956 EXPECT_EQ(res, 0);
1957 }
1958
1959 /**
1960 * @tc.name: OnRemoteRequest91
1961 * @tc.desc: normal function, TRANS_ID_SET_SCREEN_ROTATION_LOCKED test
1962 * @tc.type: FUNC
1963 */
1964 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest91, Function | SmallTest | Level2)
1965 {
1966 MessageParcel data;
1967 MessageParcel reply;
1968 MessageOption option;
1969
1970 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1971
1972 data.WriteBool(true);
1973 uint32_t code = static_cast<uint32_t>(
1974 DisplayManagerMessage::TRANS_ID_SET_SCREEN_ROTATION_LOCKED);
1975 int res = stub_->OnRemoteRequest(code, data, reply, option);
1976 EXPECT_EQ(res, 0);
1977 }
1978
1979 /**
1980 * @tc.name: OnRemoteRequest92
1981 * @tc.desc: normal function, TRANS_ID_SET_ORIENTATION test
1982 * @tc.type: FUNC
1983 */
1984 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest92, Function | SmallTest | Level2)
1985 {
1986 MessageParcel data;
1987 MessageParcel reply;
1988 MessageOption option;
1989
1990 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
1991
1992 data.WriteUint64(1092);
1993 data.WriteUint32(270);
1994 uint32_t code = static_cast<uint32_t>(
1995 DisplayManagerMessage::TRANS_ID_SET_ORIENTATION);
1996 int res = stub_->OnRemoteRequest(code, data, reply, option);
1997 EXPECT_EQ(res, 0);
1998 }
1999
2000 /**
2001 * @tc.name: OnRemoteRequest93
2002 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM test
2003 * @tc.type: FUNC
2004 */
2005 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest93, Function | SmallTest | Level2)
2006 {
2007 MessageParcel data;
2008 MessageParcel reply;
2009 MessageOption option;
2010
2011 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2012
2013 data.WriteUint64(1093);
2014 data.WriteFloat(2.5);
2015 uint32_t code = static_cast<uint32_t>(
2016 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_PIXEL_RATIO_SYSTEM);
2017 int res = stub_->OnRemoteRequest(code, data, reply, option);
2018 EXPECT_EQ(res, 0);
2019 }
2020
2021 /**
2022 * @tc.name: OnRemoteRequest94
2023 * @tc.desc: normal function, TRANS_ID_GET_SNAPSHOT_BY_PICKER test
2024 * @tc.type: FUNC
2025 */
2026 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest94, Function | SmallTest | Level2)
2027 {
2028 MessageParcel data;
2029 MessageParcel reply;
2030 MessageOption option;
2031
2032 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2033
2034 uint32_t code = static_cast<uint32_t>(
2035 DisplayManagerMessage::TRANS_ID_GET_SNAPSHOT_BY_PICKER);
2036 int res = stub_->OnRemoteRequest(code, data, reply, option);
2037 EXPECT_EQ(res, 0);
2038 }
2039
2040 /**
2041 * @tc.name: OnRemoteRequest95
2042 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE test
2043 * @tc.type: FUNC
2044 */
2045 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest95, Function | SmallTest | Level2)
2046 {
2047 MessageParcel data;
2048 MessageParcel reply;
2049 MessageOption option;
2050
2051 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2052
2053 data.WriteUint64(1095);
2054 data.WriteUint32(25);
2055 uint32_t code = static_cast<uint32_t>(
2056 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SCALE_MODE);
2057 int res = stub_->OnRemoteRequest(code, data, reply, option);
2058 EXPECT_EQ(res, 0);
2059 }
2060
2061 /**
2062 * @tc.name: OnRemoteRequest96
2063 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE test
2064 * @tc.type: FUNC
2065 */
2066 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest96, Function | SmallTest | Level2)
2067 {
2068 MessageParcel data;
2069 MessageParcel reply;
2070 MessageOption option;
2071
2072 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2073
2074 uint32_t code = static_cast<uint32_t>(
2075 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_SURFACE);
2076 int res = stub_->OnRemoteRequest(code, data, reply, option);
2077 EXPECT_EQ(res, 0);
2078 }
2079
2080 /**
2081 * @tc.name: OnRemoteRequest97
2082 * @tc.desc: normal function, TRANS_ID_SET_SPECIFIED_SCREEN_POWER test
2083 * @tc.type: FUNC
2084 */
2085 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest97, Function | SmallTest | Level2)
2086 {
2087 MessageParcel data;
2088 MessageParcel reply;
2089 MessageOption option;
2090
2091 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2092
2093 data.WriteUint32(1097);
2094 data.WriteUint32(1);
2095 data.WriteUint32(12);
2096 uint32_t code = static_cast<uint32_t>(
2097 DisplayManagerMessage::TRANS_ID_SET_SPECIFIED_SCREEN_POWER);
2098 int res = stub_->OnRemoteRequest(code, data, reply, option);
2099 EXPECT_EQ(res, 0);
2100 }
2101
2102 /**
2103 * @tc.name: OnRemoteRequest98
2104 * @tc.desc: normal function, TRANS_ID_PROXY_FOR_FREEZE test
2105 * @tc.type: FUNC
2106 */
2107 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest98, Function | SmallTest | Level2)
2108 {
2109 MessageParcel data;
2110 MessageParcel reply;
2111 MessageOption option;
2112
2113 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2114 int32_t size = 200;
2115 data.WriteInt32(size);
2116 for (int32_t i = 0; i < size; i++) {
2117 data.WriteInt32(i);
2118 }
2119 data.WriteBool(true);
2120 uint32_t code = static_cast<uint32_t>(
2121 DisplayManagerMessage::TRANS_ID_PROXY_FOR_FREEZE);
2122 int res = stub_->OnRemoteRequest(code, data, reply, option);
2123 EXPECT_EQ(res, 0);
2124 }
2125
2126 /**
2127 * @tc.name: OnRemoteRequest99
2128 * @tc.desc: normal function, invalid TRANS_ID test
2129 * @tc.type: FUNC
2130 */
2131 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest99, Function | SmallTest | Level2)
2132 {
2133 MessageParcel data;
2134 MessageParcel reply;
2135 MessageOption option;
2136
2137 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2138
2139 uint32_t code = static_cast<uint32_t>(3500);
2140 int res = stub_->OnRemoteRequest(code, data, reply, option);
2141 EXPECT_NE(res, 0);
2142 }
2143
2144 /**
2145 * @tc.name: OnRemoteRequest100
2146 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST test
2147 * @tc.type: FUNC
2148 */
2149 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest100, Function | SmallTest | Level2)
2150 {
2151 MessageParcel data;
2152 MessageParcel reply;
2153 MessageOption option;
2154
2155 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2156 ScreenId id = 1100;
2157 std::vector<uint64_t> windowIdList{};
2158 data.WriteUint64(static_cast<uint64_t>(id));
2159 data.WriteUInt64Vector(windowIdList);
2160 uint32_t code = static_cast<uint32_t>(
2161 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_BLACK_LIST);
2162 int res = stub_->OnRemoteRequest(code, data, reply, option);
2163 EXPECT_EQ(res, 0);
2164 }
2165
2166 /**
2167 * @tc.name: OnRemoteRequest101
2168 * @tc.desc: normal function, TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO test
2169 * @tc.type: FUNC
2170 */
2171 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest101, Function | SmallTest | Level2)
2172 {
2173 MessageParcel data;
2174 MessageParcel reply;
2175 MessageOption option;
2176
2177 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2178
2179 sptr<DisplayChangeInfo> info = new DisplayChangeInfo();
2180 info->Marshalling(data);
2181 uint32_t code = static_cast<uint32_t>(
2182 DisplayManagerMessage::TRANS_ID_NOTIFY_DISPLAY_CHANGE_INFO);
2183 int res = stub_->OnRemoteRequest(code, data, reply, option);
2184 EXPECT_EQ(res, 0);
2185 }
2186
2187 /**
2188 * @tc.name: OnRemoteRequest102
2189 * @tc.desc: normal function
2190 * @tc.type: FUNC
2191 */
2192 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest102, Function | SmallTest | Level2)
2193 {
2194 MessageParcel data;
2195 MessageParcel reply;
2196 MessageOption option;
2197
2198 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2199 data.WriteUint64(1102);
2200 uint32_t code = static_cast<uint32_t>(
2201 DisplayManagerMessage::TRANS_ID_GET_PHY_SCREEN_PROPERTY);
2202 int res = stub_->OnRemoteRequest(code, data, reply, option);
2203 EXPECT_EQ(res, 0);
2204 }
2205
2206 /**
2207 * @tc.name: OnRemoteRequest103
2208 * @tc.desc: normal function
2209 * @tc.type: FUNC
2210 */
2211 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest103, Function | SmallTest | Level2)
2212 {
2213 MessageParcel data;
2214 MessageParcel reply;
2215 MessageOption option;
2216
2217 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2218 data.WriteUint64(1103);
2219 uint32_t code = static_cast<uint32_t>(
2220 DisplayManagerMessage::TRANS_ID_GET_DISPLAY_NODE);
2221 int res = stub_->OnRemoteRequest(code, data, reply, option);
2222 EXPECT_EQ(res, 0);
2223 }
2224
2225 /**
2226 * @tc.name: OnRemoteRequest104
2227 * @tc.desc: normal function
2228 * @tc.type: FUNC
2229 */
2230 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest104, Function | SmallTest | Level2)
2231 {
2232 MessageParcel data;
2233 MessageParcel reply;
2234 MessageOption option;
2235
2236 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2237 data.WriteUint64(1104);
2238 uint32_t code = static_cast<uint32_t>(
2239 DisplayManagerMessage::TRANS_ID_GET_SCREEN_PROPERTY);
2240 int res = stub_->OnRemoteRequest(code, data, reply, option);
2241 EXPECT_EQ(res, 0);
2242 }
2243
2244 /**
2245 * @tc.name: OnRemoteRequest105
2246 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN test
2247 * @tc.type: FUNC
2248 */
2249 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest105, Function | SmallTest | Level2)
2250 {
2251 MessageParcel data;
2252 MessageParcel reply;
2253 MessageOption option;
2254
2255 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2256
2257 uint32_t size = 50;
2258 std::vector<ScreenId> uniqueScreenIds;
2259 for (uint32_t i = 0; i < size; i++) {
2260 uniqueScreenIds.push_back(i);
2261 }
2262 data.WriteUint32(size);
2263 data.WriteUInt64Vector(uniqueScreenIds);
2264 uint32_t code = static_cast<uint32_t>(
2265 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN);
2266 int res = stub_->OnRemoteRequest(code, data, reply, option);
2267 EXPECT_EQ(res, 0);
2268 }
2269
2270 /**
2271 * @tc.name: OnRemoteRequest106
2272 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN test
2273 * @tc.type: FUNC
2274 */
2275 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest106, Function | SmallTest | Level2)
2276 {
2277 MessageParcel data;
2278 MessageParcel reply;
2279 MessageOption option;
2280
2281 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2282
2283 uint32_t size = 0;
2284 std::vector<ScreenId> uniqueScreenIds {};
2285 data.WriteUint32(size);
2286 data.WriteUInt64Vector(uniqueScreenIds);
2287 uint32_t code = static_cast<uint32_t>(
2288 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_MAKE_UNIQUE_SCREEN);
2289 int res = stub_->OnRemoteRequest(code, data, reply, option);
2290 EXPECT_EQ(res, 0);
2291 }
2292
2293 /**
2294 * @tc.name: OnRemoteRequest107
2295 * @tc.desc: normal function
2296 * @tc.type: FUNC
2297 */
2298 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest107, Function | SmallTest | Level2)
2299 {
2300 MessageParcel data;
2301 MessageParcel reply;
2302 MessageOption option;
2303
2304 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2305 data.WriteUint64(1107);
2306 uint32_t code = static_cast<uint32_t>(
2307 DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_SPACE);
2308 int res = stub_->OnRemoteRequest(code, data, reply, option);
2309 EXPECT_EQ(res, 0);
2310 }
2311
2312 /**
2313 * @tc.name: OnRemoteRequest108
2314 * @tc.desc: normal function
2315 * @tc.type: FUNC
2316 */
2317 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest108, Function | SmallTest | Level2)
2318 {
2319 MessageParcel data;
2320 MessageParcel reply;
2321 MessageOption option;
2322
2323 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2324 data.WriteUint64(1108);
2325 uint32_t code = static_cast<uint32_t>(
2326 DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_COLOR_SPACE);
2327 int res = stub_->OnRemoteRequest(code, data, reply, option);
2328 EXPECT_EQ(res, 0);
2329 }
2330
2331 /**
2332 * @tc.name: OnRemoteRequest109
2333 * @tc.desc: normal function
2334 * @tc.type: FUNC
2335 */
2336 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest109, Function | SmallTest | Level2)
2337 {
2338 MessageParcel data;
2339 MessageParcel reply;
2340 MessageOption option;
2341
2342 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2343 data.WriteUint64(1109);
2344 uint32_t code = static_cast<uint32_t>(
2345 DisplayManagerMessage::TRANS_ID_SCREEN_GET_HDR_FORMAT);
2346 int res = stub_->OnRemoteRequest(code, data, reply, option);
2347 EXPECT_EQ(res, 0);
2348 }
2349
2350 /**
2351 * @tc.name: OnRemoteRequest110
2352 * @tc.desc: normal function
2353 * @tc.type: FUNC
2354 */
2355 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest110, Function | SmallTest | Level2)
2356 {
2357 MessageParcel data;
2358 MessageParcel reply;
2359 MessageOption option;
2360
2361 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2362 data.WriteUint64(1100);
2363 uint32_t code = static_cast<uint32_t>(
2364 DisplayManagerMessage::TRANS_ID_SCREEN_GET_SUPPORTED_HDR_FORMAT);
2365 int res = stub_->OnRemoteRequest(code, data, reply, option);
2366 EXPECT_EQ(res, 0);
2367 }
2368
2369 /**
2370 * @tc.name: OnRemoteRequest111
2371 * @tc.desc: normal function
2372 * @tc.type: FUNC
2373 */
2374 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest111, Function | SmallTest | Level2)
2375 {
2376 MessageParcel data;
2377 MessageParcel reply;
2378 MessageOption option;
2379
2380 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2381 data.WriteUint64(1111);
2382 uint32_t code = static_cast<uint32_t>(
2383 DisplayManagerMessage::TRANS_ID_SCREEN_GET_PIXEL_FORMAT);
2384 int res = stub_->OnRemoteRequest(code, data, reply, option);
2385 EXPECT_EQ(res, 0);
2386 }
2387
2388 /**
2389 * @tc.name: OnRemoteRequest112
2390 * @tc.desc: normal function
2391 * @tc.type: FUNC
2392 */
2393 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest112, Function | SmallTest | Level2)
2394 {
2395 MessageParcel data;
2396 MessageParcel reply;
2397 MessageOption option;
2398
2399 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2400 data.WriteUint64(1112);
2401 uint32_t code = static_cast<uint32_t>(
2402 DisplayManagerMessage::TRANS_ID_SCREEN_GET_GAMUT_MAP);
2403 int res = stub_->OnRemoteRequest(code, data, reply, option);
2404 EXPECT_EQ(res, 0);
2405 }
2406
2407 /**
2408 * @tc.name: OnRemoteRequest113
2409 * @tc.desc: normal function
2410 * @tc.type: FUNC
2411 */
2412 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest113, Function | SmallTest | Level2)
2413 {
2414 MessageParcel data;
2415 MessageParcel reply;
2416 MessageOption option;
2417
2418 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2419 data.WriteUint64(1113);
2420 uint32_t code = static_cast<uint32_t>(
2421 DisplayManagerMessage::TRANS_ID_SCREEN_GET_COLOR_GAMUT);
2422 int res = stub_->OnRemoteRequest(code, data, reply, option);
2423 EXPECT_EQ(res, 0);
2424 }
2425
2426 /**
2427 * @tc.name: OnRemoteRequest114
2428 * @tc.desc: normal function, TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION test
2429 * @tc.type: FUNC
2430 */
2431 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest114, Function | SmallTest | Level2)
2432 {
2433 MessageParcel data;
2434 MessageParcel reply;
2435 MessageOption option;
2436
2437 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2438 uint32_t code = static_cast<uint32_t>(
2439 DisplayManagerMessage::TRANS_ID_GET_ALL_PHYSICAL_DISPLAY_RESOLUTION);
2440 int res = stub_->OnRemoteRequest(code, data, reply, option);
2441 EXPECT_EQ(res, 0);
2442 }
2443
2444 /**
2445 * @tc.name: OnRemoteRequest115
2446 * @tc.desc: normal function, TRANS_ID_GET_SCREEN_POWER
2447 * @tc.type: FUNC
2448 */
2449 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest115, Function | SmallTest | Level2)
2450 {
2451 MessageParcel data;
2452 MessageParcel reply;
2453 MessageOption option;
2454
2455 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2456 ScreenId testScreenId = 1115;
2457 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2458
2459 uint32_t code = static_cast<uint32_t>(
2460 DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER);
2461
2462 int res = stub_->OnRemoteRequest(code, data, reply, option);
2463 EXPECT_EQ(res, 0);
2464 }
2465
2466 /**
2467 * @tc.name: OnRemoteRequest116
2468 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION
2469 * @tc.type: FUNC
2470 */
2471 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest116, Function | SmallTest | Level2)
2472 {
2473 MessageParcel data;
2474 MessageParcel reply;
2475 MessageOption option;
2476
2477 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2478 ScreenId testScreenId = 1116;
2479 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2480 data.WriteBool(false);
2481 uint32_t code = static_cast<uint32_t>(
2482 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION);
2483 int res = stub_->OnRemoteRequest(code, data, reply, option);
2484 EXPECT_EQ(res, 0);
2485 }
2486
2487 /**
2488 * @tc.name: OnRemoteRequest117
2489 * @tc.desc: normal function, TRANS_ID_SET_RESOLUTION
2490 * @tc.type: FUNC
2491 */
2492 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest117, Function | SmallTest | Level2)
2493 {
2494 MessageParcel data;
2495 MessageParcel reply;
2496 MessageOption option;
2497
2498 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2499 ScreenId testScreenId = 1117;
2500 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2501 uint32_t width = 1080;
2502 data.WriteUint32(width);
2503 uint32_t height = 2560;
2504 data.WriteUint32(height);
2505 float virtualPixelRatio = 64;
2506 data.WriteFloat(virtualPixelRatio);
2507 uint32_t code = static_cast<uint32_t>(
2508 DisplayManagerMessage::TRANS_ID_SET_RESOLUTION);
2509 int res = stub_->OnRemoteRequest(code, data, reply, option);
2510 EXPECT_EQ(res, 0);
2511 }
2512
2513 /**
2514 * @tc.name: OnRemoteRequest118
2515 * @tc.desc: normal function, TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION
2516 * @tc.type: FUNC
2517 */
2518 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest118, Function | SmallTest | Level2)
2519 {
2520 MessageParcel data;
2521 MessageParcel reply;
2522 MessageOption option;
2523
2524 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2525 ScreenId testScreenId = 1118;
2526 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2527 uint32_t code = static_cast<uint32_t>(
2528 DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION);
2529 int res = stub_->OnRemoteRequest(code, data, reply, option);
2530 EXPECT_EQ(res, 0);
2531 }
2532
2533 /**
2534 * @tc.name: OnRemoteRequest119
2535 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_COLOR_GAMUT
2536 * @tc.type: FUNC
2537 */
2538 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest119, Function | SmallTest | Level2)
2539 {
2540 MessageParcel data;
2541 MessageParcel reply;
2542 MessageOption option;
2543
2544 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2545 ScreenId testScreenId = 1119;
2546 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2547 int32_t colorGamutIdx = 64;
2548 data.WriteInt32(colorGamutIdx);
2549 uint32_t code = static_cast<uint32_t>(
2550 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT);
2551 int res = stub_->OnRemoteRequest(code, data, reply, option);
2552 EXPECT_EQ(res, 0);
2553 }
2554
2555 /**
2556 * @tc.name: OnRemoteRequest120
2557 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_GAMUT_MAP
2558 * @tc.type: FUNC
2559 */
2560 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest120, Function | SmallTest | Level2)
2561 {
2562 MessageParcel data;
2563 MessageParcel reply;
2564 MessageOption option;
2565
2566 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2567 ScreenId testScreenId = 1119;
2568 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2569 uint32_t colorGamutIdx = 64;
2570 data.WriteUint32(colorGamutIdx);
2571 uint32_t code = static_cast<uint32_t>(
2572 DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP);
2573 int res = stub_->OnRemoteRequest(code, data, reply, option);
2574 EXPECT_EQ(res, 0);
2575 }
2576
2577 /**
2578 * @tc.name: OnRemoteRequest121
2579 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_COLOR_TRANSFORM
2580 * @tc.type: FUNC
2581 */
2582 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest121, Function | SmallTest | Level2)
2583 {
2584 MessageParcel data;
2585 MessageParcel reply;
2586 MessageOption option;
2587
2588 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2589 ScreenId testScreenId = 1121;
2590 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2591 uint32_t code = static_cast<uint32_t>(
2592 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM);
2593 int res = stub_->OnRemoteRequest(code, data, reply, option);
2594 EXPECT_EQ(res, 0);
2595 }
2596
2597 /**
2598 * @tc.name: OnRemoteRequest122
2599 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_PIXEL_FORMAT
2600 * @tc.type: FUNC
2601 */
2602 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest122, Function | SmallTest | Level2)
2603 {
2604 MessageParcel data;
2605 MessageParcel reply;
2606 MessageOption option;
2607
2608 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2609 ScreenId testScreenId = 1122;
2610 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2611 int32_t pixelFormat = 64;
2612 data.WriteInt32(pixelFormat);
2613 uint32_t code = static_cast<uint32_t>(
2614 DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT);
2615 int res = stub_->OnRemoteRequest(code, data, reply, option);
2616 EXPECT_EQ(res, 0);
2617 }
2618
2619 /**
2620 * @tc.name: OnRemoteRequest123
2621 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_HDR_FORMAT
2622 * @tc.type: FUNC
2623 */
2624 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest123, Function | SmallTest | Level2)
2625 {
2626 MessageParcel data;
2627 MessageParcel reply;
2628 MessageOption option;
2629
2630 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2631 ScreenId testScreenId = 1123;
2632 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2633 int32_t modeIdx = 120;
2634 data.WriteInt32(modeIdx);
2635 uint32_t code = static_cast<uint32_t>(
2636 DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT);
2637 int res = stub_->OnRemoteRequest(code, data, reply, option);
2638 EXPECT_EQ(res, 0);
2639 }
2640
2641 /**
2642 * @tc.name: OnRemoteRequest124
2643 * @tc.desc: normal function
2644 * @tc.type: FUNC
2645 */
2646 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest124, Function | SmallTest | Level2)
2647 {
2648 MessageParcel data;
2649 MessageParcel reply;
2650 MessageOption option;
2651
2652 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2653 ScreenId testScreenId = 1123;
2654 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2655 int32_t colorSpace = 32;
2656 data.WriteInt32(colorSpace);
2657 uint32_t code = static_cast<uint32_t>(
2658 DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE);
2659 int res = stub_->OnRemoteRequest(code, data, reply, option);
2660 EXPECT_EQ(res, 0);
2661 }
2662
2663 /**
2664 * @tc.name: OnRemoteRequest125
2665 * @tc.desc: TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE test
2666 * @tc.type: FUNC
2667 */
2668 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest125, Function | SmallTest | Level2)
2669 {
2670 MessageParcel data;
2671 MessageParcel reply;
2672 MessageOption option;
2673
2674 ScreenId screenId = 0;
2675 float scaleX = 1.0f;
2676 float scaleY = 1.0f;
2677 float pivotX = 0.5f;
2678 float pivotY = 0.5f;
2679 ASSERT_TRUE(data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor()) &&
2680 data.WriteUint64(static_cast<uint64_t>(screenId)) && data.WriteFloat(scaleX) &&
2681 data.WriteFloat(scaleY) && data.WriteFloat(pivotX) && data.WriteFloat(pivotY));
2682 uint32_t code =
2683 static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCENE_BOARD_SET_DISPLAY_SCALE);
2684 int res = stub_->OnRemoteRequest(code, data, reply, option);
2685 EXPECT_EQ(res, 0);
2686 }
2687
2688 /**
2689 * @tc.name: OnRemoteRequest126
2690 * @tc.desc: normal function
2691 * @tc.type: FUNC
2692 */
2693 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest126, Function | SmallTest | Level2)
2694 {
2695 MessageParcel data;
2696 MessageParcel reply;
2697 MessageOption option;
2698
2699 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2700 uint32_t code = static_cast<uint32_t>(
2701 DisplayManagerMessage::TRANS_ID_GET_INTERNAL_SCREEN_ID);
2702 int res = stub_->OnRemoteRequest(code, data, reply, option);
2703 EXPECT_EQ(res, 0);
2704 }
2705
2706 /**
2707 * @tc.name: OnRemoteRequest127
2708 * @tc.desc: normal function
2709 * @tc.type: FUNC
2710 */
2711 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest127, Function | SmallTest | Level2)
2712 {
2713 MessageParcel data;
2714 MessageParcel reply;
2715 MessageOption option;
2716
2717 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2718 ScreenId screenId = 0;
2719 data.WriteUint64(screenId);
2720 ScreenPowerState state = ScreenPowerState{0};
2721 data.WriteUint32(static_cast<uint32_t>(state));
2722 PowerStateChangeReason reason = PowerStateChangeReason{0};
2723 data.WriteUint32(static_cast<uint32_t>(reason));
2724 uint32_t code = static_cast<uint32_t>(
2725 DisplayManagerMessage::TRANS_ID_SET_SCREEN_POWER_BY_ID);
2726 int res = stub_->OnRemoteRequest(code, data, reply, option);
2727 EXPECT_EQ(res, 0);
2728 }
2729
2730 /**
2731 * @tc.name: OnRemoteRequest128
2732 * @tc.desc: normal function
2733 * @tc.type: FUNC
2734 */
2735 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest128, Function | SmallTest | Level2)
2736 {
2737 MessageParcel data;
2738 MessageParcel reply;
2739 MessageOption option;
2740
2741 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2742 uint32_t code = static_cast<uint32_t>(
2743 DisplayManagerMessage::TRANS_ID_TRY_TO_CANCEL_SCREEN_OFF);
2744 int res = stub_->OnRemoteRequest(code, data, reply, option);
2745 EXPECT_EQ(res, 0);
2746 }
2747
2748 /**
2749 * @tc.name: OnRemoteRequest129
2750 * @tc.desc: normal function
2751 * @tc.type: FUNC
2752 */
2753 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest129, Function | SmallTest | Level2)
2754 {
2755 MessageParcel data;
2756 MessageParcel reply;
2757 MessageOption option;
2758
2759 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2760 ScreenId mainScreenId = 0;
2761 data.WriteUint64(static_cast<uint64_t>(mainScreenId));
2762 ScreenId secondaryScreenId = 1;
2763 data.WriteUint64(static_cast<uint64_t>(secondaryScreenId));
2764 MultiScreenMode screenMode = MultiScreenMode::SCREEN_EXTEND;
2765 data.WriteUint32(static_cast<uint32_t>(screenMode));
2766 uint32_t code = static_cast<uint32_t>(
2767 DisplayManagerMessage::TRANS_ID_MULTI_SCREEN_MODE_SWITCH);
2768 int res = stub_->OnRemoteRequest(code, data, reply, option);
2769 EXPECT_EQ(res, 0);
2770 }
2771
2772 /**
2773 * @tc.name: OnRemoteRequest130
2774 * @tc.desc: normal function
2775 * @tc.type: FUNC
2776 */
2777 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest130, Function | SmallTest | Level2)
2778 {
2779 MessageParcel data;
2780 MessageParcel reply;
2781 MessageOption option;
2782
2783 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2784 data.WriteUint64(0);
2785 data.WriteUint32(0);
2786 data.WriteUint32(0);
2787 data.WriteUint64(1);
2788 data.WriteUint32(0);
2789 data.WriteUint32(0);
2790 uint32_t code = static_cast<uint32_t>(
2791 DisplayManagerMessage::TRANS_ID_SET_MULTI_SCREEN_POSITION);
2792 int res = stub_->OnRemoteRequest(code, data, reply, option);
2793 EXPECT_EQ(res, 0);
2794 }
2795
2796 /**
2797 * @tc.name: OnRemoteRequest131
2798 * @tc.desc: normal function
2799 * @tc.type: FUNC
2800 */
2801 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest131, Function | SmallTest | Level2)
2802 {
2803 MessageParcel data;
2804 MessageParcel reply;
2805 MessageOption option;
2806
2807 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2808 ScreenId screenId = 100;
2809 data.WriteUint64(static_cast<uint64_t>(screenId));
2810 data.WriteInt32(static_cast<int32_t>(0));
2811 uint32_t code = static_cast<uint32_t>(
2812 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_STATUS);
2813 int res = stub_->OnRemoteRequest(code, data, reply, option);
2814 EXPECT_EQ(res, 0);
2815 }
2816
2817 /**
2818 * @tc.name: OnRemoteRequest132
2819 * @tc.desc: normal function
2820 * @tc.type: FUNC
2821 */
2822 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest132, Function | SmallTest | Level2)
2823 {
2824 MessageParcel data;
2825 MessageParcel reply;
2826 MessageOption option;
2827
2828 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2829 ScreenId id = 100;
2830 data.WriteUint64(static_cast<uint64_t>(id));
2831 uint32_t refreshRate = 12;
2832 data.WriteUint32(refreshRate);
2833 uint32_t code = static_cast<uint32_t>(
2834 DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_MAX_REFRESHRATE);
2835 int res = stub_->OnRemoteRequest(code, data, reply, option);
2836 EXPECT_EQ(res, 0);
2837 }
2838
2839 /**
2840 * @tc.name: OnRemoteRequest133
2841 * @tc.desc: normal function
2842 * @tc.type: FUNC
2843 */
2844 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest133, Function | SmallTest | Level2)
2845 {
2846 MessageParcel data;
2847 MessageParcel reply;
2848 MessageOption option;
2849
2850 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2851 ScreenId id = 0;
2852 data.WriteUint64(static_cast<uint64_t>(id));
2853 data.WriteBool(true);
2854 data.WriteBool(true);
2855 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPTURE);
2856 int res = stub_->OnRemoteRequest(code, data, reply, option);
2857 EXPECT_EQ(res, 0);
2858 }
2859
2860 /**
2861 * @tc.name: OnRemoteRequest134
2862 * @tc.desc: normal function
2863 * @tc.type: FUNC
2864 */
2865 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest134, Function | SmallTest | Level2)
2866 {
2867 MessageParcel data;
2868 MessageParcel reply;
2869 MessageOption option;
2870
2871 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2872 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_PRIMARY_DISPLAY_INFO);
2873 int res = stub_->OnRemoteRequest(code, data, reply, option);
2874 EXPECT_EQ(res, 0);
2875 }
2876
2877 /**
2878 * @tc.name: OnRemoteRequest135
2879 * @tc.desc: normal function
2880 * @tc.type: FUNC
2881 */
2882 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest135, Function | SmallTest | Level2)
2883 {
2884 MessageParcel data;
2885 MessageParcel reply;
2886 MessageOption option;
2887
2888 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2889 data.WriteUint64(0);
2890 data.WriteFloat(0);
2891 data.WriteFloat(0);
2892 uint32_t code = static_cast<uint32_t>(
2893 DisplayManagerMessage::TRANS_ID_UPDATE_SCREEN_DIRECTION_INFO);
2894 int res = stub_->OnRemoteRequest(code, data, reply, option);
2895 EXPECT_EQ(res, 0);
2896 }
2897 /**
2898 * @tc.name: OnRemoteRequest136
2899 * @tc.desc: normal function, TRANS_ID_GET_SCREEN_POWER
2900 * @tc.type: FUNC
2901 */
2902 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest136, Function | SmallTest | Level2)
2903 {
2904 MessageParcel data;
2905 MessageParcel reply;
2906 MessageOption option;
2907
2908 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2909 ScreenId testScreenId = 1115;
2910 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2911
2912 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_SCREEN_POWER);
2913
2914 int res = stub_->OnRemoteRequest(code, data, reply, option);
2915 EXPECT_EQ(res, 0);
2916 }
2917
2918 /**
2919 * @tc.name: OnRemoteRequest137
2920 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION
2921 * @tc.type: FUNC
2922 */
2923 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest137, Function | SmallTest | Level2)
2924 {
2925 MessageParcel data;
2926 MessageParcel reply;
2927 MessageOption option;
2928
2929 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2930 ScreenId testScreenId = 1116;
2931 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2932 data.WriteBool(false);
2933 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_SCREEN_CANVAS_ROTATION);
2934 int res = stub_->OnRemoteRequest(code, data, reply, option);
2935 EXPECT_EQ(res, 0);
2936 }
2937
2938 /**
2939 * @tc.name: OnRemoteRequest138
2940 * @tc.desc: normal function, TRANS_ID_SET_RESOLUTION
2941 * @tc.type: FUNC
2942 */
2943 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest138, Function | SmallTest | Level2)
2944 {
2945 MessageParcel data;
2946 MessageParcel reply;
2947 MessageOption option;
2948
2949 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2950 ScreenId testScreenId = 1117;
2951 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2952 uint32_t width = 1080;
2953 data.WriteUint32(width);
2954 uint32_t height = 2560;
2955 data.WriteUint32(height);
2956 float virtualPixelRatio = 64;
2957 data.WriteFloat(virtualPixelRatio);
2958 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_RESOLUTION);
2959 int res = stub_->OnRemoteRequest(code, data, reply, option);
2960 EXPECT_EQ(res, 0);
2961 }
2962
2963 /**
2964 * @tc.name: OnRemoteRequest139
2965 * @tc.desc: normal function, TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION
2966 * @tc.type: FUNC
2967 */
2968 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest139, Function | SmallTest | Level2)
2969 {
2970 MessageParcel data;
2971 MessageParcel reply;
2972 MessageOption option;
2973
2974 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2975 ScreenId testScreenId = 1118;
2976 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2977 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_DENSITY_IN_CURRENT_RESOLUTION);
2978 int res = stub_->OnRemoteRequest(code, data, reply, option);
2979 EXPECT_EQ(res, 0);
2980 }
2981
2982 /**
2983 * @tc.name: OnRemoteRequest140
2984 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_COLOR_GAMUT
2985 * @tc.type: FUNC
2986 */
2987 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest140, Function | SmallTest | Level2)
2988 {
2989 MessageParcel data;
2990 MessageParcel reply;
2991 MessageOption option;
2992
2993 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
2994 ScreenId testScreenId = 1119;
2995 data.WriteUint64(static_cast<uint64_t>(testScreenId));
2996 int32_t colorGamutIdx = 64;
2997 data.WriteInt32(colorGamutIdx);
2998 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_GAMUT);
2999 int res = stub_->OnRemoteRequest(code, data, reply, option);
3000 EXPECT_EQ(res, 0);
3001 }
3002
3003 /**
3004 * @tc.name: OnRemoteRequest141
3005 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_GAMUT_MAP
3006 * @tc.type: FUNC
3007 */
3008 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest141, Function | SmallTest | Level2)
3009 {
3010 MessageParcel data;
3011 MessageParcel reply;
3012 MessageOption option;
3013
3014 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3015 ScreenId testScreenId = 1119;
3016 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3017 uint32_t colorGamutIdx = 64;
3018 data.WriteUint32(colorGamutIdx);
3019 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_GAMUT_MAP);
3020 int res = stub_->OnRemoteRequest(code, data, reply, option);
3021 EXPECT_EQ(res, 0);
3022 }
3023
3024 /**
3025 * @tc.name: OnRemoteRequest142
3026 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_COLOR_TRANSFORM
3027 * @tc.type: FUNC
3028 */
3029 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest142, Function | SmallTest | Level2)
3030 {
3031 MessageParcel data;
3032 MessageParcel reply;
3033 MessageOption option;
3034
3035 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3036 ScreenId testScreenId = 1121;
3037 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3038 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_TRANSFORM);
3039 int res = stub_->OnRemoteRequest(code, data, reply, option);
3040 EXPECT_EQ(res, 0);
3041 }
3042
3043 /**
3044 * @tc.name: OnRemoteRequest143
3045 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_PIXEL_FORMAT
3046 * @tc.type: FUNC
3047 */
3048 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest143, Function | SmallTest | Level2)
3049 {
3050 MessageParcel data;
3051 MessageParcel reply;
3052 MessageOption option;
3053
3054 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3055 ScreenId testScreenId = 1122;
3056 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3057 int32_t pixelFormat = 64;
3058 data.WriteInt32(pixelFormat);
3059 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_PIXEL_FORMAT);
3060 int res = stub_->OnRemoteRequest(code, data, reply, option);
3061 EXPECT_EQ(res, 0);
3062 }
3063
3064 /**
3065 * @tc.name: OnRemoteRequest144
3066 * @tc.desc: normal function, TRANS_ID_SCREEN_SET_HDR_FORMAT
3067 * @tc.type: FUNC
3068 */
3069 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest144, Function | SmallTest | Level2)
3070 {
3071 MessageParcel data;
3072 MessageParcel reply;
3073 MessageOption option;
3074
3075 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3076 ScreenId testScreenId = 1123;
3077 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3078 int32_t modeIdx = 120;
3079 data.WriteInt32(modeIdx);
3080 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_HDR_FORMAT);
3081 int res = stub_->OnRemoteRequest(code, data, reply, option);
3082 EXPECT_EQ(res, 0);
3083 }
3084
3085 /**
3086 * @tc.name: OnRemoteRequest145
3087 * @tc.desc: normal function
3088 * @tc.type: FUNC
3089 */
3090 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest145, Function | SmallTest | Level2)
3091 {
3092 MessageParcel data;
3093 MessageParcel reply;
3094 MessageOption option;
3095
3096 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3097 ScreenId testScreenId = 1123;
3098 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3099 int32_t colorSpace = 32;
3100 data.WriteInt32(colorSpace);
3101 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SCREEN_SET_COLOR_SPACE);
3102 int res = stub_->OnRemoteRequest(code, data, reply, option);
3103 EXPECT_EQ(res, 0);
3104 }
3105
3106 /**
3107 * @tc.name: OnRemoteRequest146
3108 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_GET_SUPER_FOLD_STATUS test
3109 * @tc.type: FUNC
3110 */
3111 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest146, Function | SmallTest | Level2)
3112 {
3113 MessageParcel data;
3114 MessageParcel reply;
3115 MessageOption option;
3116
3117 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3118
3119 uint32_t code = static_cast<uint32_t>(
3120 DisplayManagerMessage::TRANS_ID_SCENE_BOARD_GET_SUPER_FOLD_STATUS);
3121 int res = stub_->OnRemoteRequest(code, data, reply, option);
3122 EXPECT_EQ(res, 0);
3123 }
3124
3125 /**
3126 * @tc.name: OnRemoteRequest147
3127 * @tc.desc: normal function, TRANS_ID_SCENE_BOARD_GET_SUPER_FOLD_STATUS test
3128 * @tc.type: FUNC
3129 */
3130 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest147, Function | SmallTest | Level2)
3131 {
3132 MessageParcel data;
3133 MessageParcel reply;
3134 MessageOption option;
3135 const std::vector<ScreenId> screenIds = {1001, 1002};
3136 bool isEnable = true;
3137 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3138 data.WriteUInt64Vector(screenIds);
3139 data.WriteBool(isEnable);
3140 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_SCREEN_SKIP_PROTECTED_WINDOW);
3141 int res = stub_->OnRemoteRequest(code, data, reply, option);
3142 EXPECT_EQ(res, 0);
3143 }
3144
3145 /**
3146 * @tc.name: OnRemoteRequest148
3147 * @tc.desc: normal function, TRANS_ID_GET_DISPLAY_CAPABILITY test
3148 * @tc.type: FUNC
3149 */
3150 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest148, Function | SmallTest | Level2)
3151 {
3152 MessageParcel data;
3153 MessageParcel reply;
3154 MessageOption option;
3155 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3156 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_GET_DISPLAY_CAPABILITY);
3157 int res = stub_->OnRemoteRequest(code, data, reply, option);
3158 EXPECT_EQ(res, 0);
3159 }
3160
3161 /**
3162 * @tc.name: OnRemoteRequest149
3163 * @tc.desc: normal function, TRANS_ID_SET_SYSTEM_KEYBOARD_ON test
3164 * @tc.type: FUNC
3165 */
3166 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest149, Function | SmallTest | Level2)
3167 {
3168 MessageParcel data;
3169 MessageParcel reply;
3170 MessageOption option;
3171 bool isOn = true;
3172 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3173 data.WriteBool(isOn);
3174 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_SYSTEM_KEYBOARD_ON);
3175 int res = stub_->OnRemoteRequest(code, data, reply, option);
3176 EXPECT_EQ(res, 0);
3177 }
3178
3179 /**
3180 * @tc.name: OnRemoteRequest150
3181 * @tc.desc: normal function, TRANS_ID_SET_VIRTUAL_DISPLAY_MUTE_FLAG test
3182 * @tc.type: FUNC
3183 */
3184 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest150, Function | SmallTest | Level2)
3185 {
3186 MessageParcel data;
3187 MessageParcel reply;
3188 MessageOption option;
3189 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3190 ScreenId testScreenId = 1123;
3191 data.WriteUint64(static_cast<uint64_t>(testScreenId));
3192 bool muteFlag = false;
3193 data.WriteBool(muteFlag);
3194 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_SET_VIRTUAL_DISPLAY_MUTE_FLAG);
3195 int res = stub_->OnRemoteRequest(code, data, reply, option);
3196 EXPECT_EQ(res, 0);
3197 }
3198
3199 /**
3200 * @tc.name: OnRemoteRequest151
3201 * @tc.desc: normal function, TRANS_ID_ADD_VIRTUAL_SCREEN_BLACK_LIST test
3202 * @tc.type: FUNC
3203 */
3204 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest151, Function | SmallTest | Level2)
3205 {
3206 MessageParcel data;
3207 MessageParcel reply;
3208 MessageOption option;
3209 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3210 data.WriteUint64(1u);
3211 data.WriteInt32(1);
3212 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_ADD_VIRTUAL_SCREEN_BLOCK_LIST);
3213 int res = stub_->OnRemoteRequest(code, data, reply, option);
3214 EXPECT_EQ(res, 0);
3215 }
3216
3217
3218 /**
3219 * @tc.name: OnRemoteRequest152
3220 * @tc.desc: normal function, TRANS_ID_REMOVE_VIRTUAL_SCREEN_BLACK_LIST test
3221 * @tc.type: FUNC
3222 */
3223 HWTEST_F(ScreenSessionManagerStubTest, OnRemoteRequest152, Function | SmallTest | Level2)
3224 {
3225 MessageParcel data;
3226 MessageParcel reply;
3227 MessageOption option;
3228 data.WriteInterfaceToken(ScreenSessionManagerStub::GetDescriptor());
3229 data.WriteUint64(1u);
3230 data.WriteInt32(1);
3231 uint32_t code = static_cast<uint32_t>(DisplayManagerMessage::TRANS_ID_REMOVE_VIRTUAL_SCREEN_BLOCK_LIST);
3232 int res = stub_->OnRemoteRequest(code, data, reply, option);
3233 EXPECT_EQ(res, 0);
3234 }
3235 }
3236 }
3237 }