1 /*
2 * Copyright (c) 2023-2025 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 <common/rs_rect.h>
17 #include <gtest/gtest.h>
18 #include <iremote_broker.h>
19 #include <iremote_object_mocker.h>
20 #include <transaction/rs_marshalling_helper.h>
21
22 #include "display_manager_adapter.h"
23 #include "display_manager_agent_default.h"
24 #include "fold_screen_state_internel.h"
25 #include "mock_message_parcel.h"
26 #include "scene_board_judgement.h"
27 #include "screen_session_manager/include/screen_session_manager.h"
28 #include "session_manager/include/scene_session_manager.h"
29 #include "zidl/screen_session_manager_proxy.h"
30 #include "mock_message_parcel.h"
31
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS::Rosen {
36 class ScreenSessionManagerProxyTest : public testing::Test {
37 public:
38 static void SetUpTestSuite();
39 void SetUp() override;
40 sptr<ScreenSessionManagerProxy> screenSessionManagerProxy;
41 };
42
SetUpTestSuite()43 void ScreenSessionManagerProxyTest::SetUpTestSuite()
44 {
45 }
46
SetUp()47 void ScreenSessionManagerProxyTest::SetUp()
48 {
49 if (screenSessionManagerProxy) {
50 return;
51 }
52
53 sptr<IRemoteObject> impl = sptr<IRemoteObjectMocker>::MakeSptr();
54 screenSessionManagerProxy = sptr<ScreenSessionManagerProxy>::MakeSptr(impl);
55 }
56
57 namespace {
58 /**
59 * @tc.name: SetPrivacyStateByDisplayId
60 * @tc.desc: SetPrivacyStateByDisplayId
61 * @tc.type: FUNC
62 */
63 HWTEST_F(ScreenSessionManagerProxyTest, SetPrivacyStateByDisplayId, TestSize.Level1)
64 {
65 DisplayId id = 0;
66 bool hasPrivate = false;
67
68 int resultValue = 0;
69 std::function<void()> func = [&]()
__anon70844abc0202() 70 {
71 screenSessionManagerProxy->SetPrivacyStateByDisplayId(id, hasPrivate);
72 resultValue = 1;
73 };
74 func();
75 ASSERT_EQ(resultValue, 1);
76 }
77
78 /**
79 * @tc.name: SetScreenPrivacyWindowList
80 * @tc.desc: SetScreenPrivacyWindowList
81 * @tc.type: FUNC
82 */
83 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenPrivacyWindowList, TestSize.Level1)
84 {
85 DisplayId id = 0;
86 std::vector<std::string> privacyWindowList{"win0", "win1"};
87
88 int resultValue = 0;
89 std::function<void()> func = [&]()
__anon70844abc0302() 90 {
91 screenSessionManagerProxy->SetScreenPrivacyWindowList(id, privacyWindowList);
92 resultValue = 1;
93 };
94 func();
95 ASSERT_EQ(resultValue, 1);
96 }
97
98 /**
99 * @tc.name: SetVirtualScreenBlackList
100 * @tc.desc: SetVirtualScreenBlackList
101 * @tc.type: FUNC
102 */
103 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenBlackList, TestSize.Level1)
104 {
105 ScreenId id = 1001;
106 std::vector<uint64_t> windowIdList{10, 20, 30};
107
108 int resultValue = 0;
109 std::function<void()> func = [&]()
__anon70844abc0402() 110 {
111 screenSessionManagerProxy->SetVirtualScreenBlackList(id, windowIdList);
112 resultValue = 1;
113 };
114 func();
115 ASSERT_EQ(resultValue, 1);
116 }
117
118 /**
119 * @tc.name: SetVirtualDisplayMuteFlag
120 * @tc.desc: SetVirtualDisplayMuteFlag
121 * @tc.type: FUNC
122 */
123 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualDisplayMuteFlag, Function | SmallTest | Level1)
124 {
125 ScreenId id = 1001;
126 bool muteFlag = false;
127 screenSessionManagerProxy->SetVirtualDisplayMuteFlag(id, muteFlag);
128 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
129 EXPECT_EQ(screenSession, nullptr);
130 }
131
132 /**
133 * @tc.name: ProxyForFreeze
134 * @tc.desc: ProxyForFreeze
135 * @tc.type: FUNC
136 */
137 HWTEST_F(ScreenSessionManagerProxyTest, ProxyForFreeze, TestSize.Level1)
138 {
139 const std::set<int32_t>& pidList = {1, 2, 3};
140 bool isProxy = true;
141
142 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
143 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
144 screenSessionManagerProxy->ProxyForFreeze(pidList, isProxy));
145 } else {
146 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
147 screenSessionManagerProxy->ProxyForFreeze(pidList, isProxy));
148 }
149 }
150
151 /**
152 * @tc.name: SetVirtualScreenStatus
153 * @tc.desc: SetVirtualScreenStatus
154 * @tc.type: FUNC
155 */
156 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenStatus, TestSize.Level1)
157 {
158 ScreenId id = 1001;
159 VirtualScreenStatus screenStatus = VirtualScreenStatus::VIRTUAL_SCREEN_PAUSE;
160
161 bool expectation = true;
162 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
163 EXPECT_NE(expectation, screenSessionManagerProxy->SetVirtualScreenStatus(id, screenStatus));
164 } else {
165 EXPECT_NE(expectation, screenSessionManagerProxy->SetVirtualScreenStatus(id, screenStatus));
166 }
167 }
168
169 /**
170 * @tc.name: SetVirtualScreenSecurityExemption
171 * @tc.desc: SetVirtualScreenSecurityExemption
172 * @tc.type: FUNC
173 */
174 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenSecurityExemption, TestSize.Level1)
175 {
176 ScreenId id = 1001;
177 uint32_t pid = 1;
178 std::vector<uint64_t> windowIdList{10, 20, 30};
179
180 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
181 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
182 screenSessionManagerProxy->SetVirtualScreenSecurityExemption(id, pid, windowIdList));
183 } else {
184 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
185 screenSessionManagerProxy->SetVirtualScreenSecurityExemption(id, pid, windowIdList));
186 }
187 }
188
189 /**
190 * @tc.name: GetAllDisplayPhysicalResolution
191 * @tc.desc: GetAllDisplayPhysicalResolution
192 * @tc.type: FUNC
193 */
194 HWTEST_F(ScreenSessionManagerProxyTest, GetAllDisplayPhysicalResolution, TestSize.Level1)
195 {
196 MockMessageParcel::ClearAllErrorFlag();
197 auto allSize = screenSessionManagerProxy->GetAllDisplayPhysicalResolution();
198 ASSERT_TRUE(!allSize.empty());
199 }
200
201 /**
202 * @tc.name: GetDefaultDisplayInfo
203 * @tc.desc: GetDefaultDisplayInfo
204 * @tc.type: FUNC
205 */
206 HWTEST_F(ScreenSessionManagerProxyTest, GetDefaultDisplayInfo, TestSize.Level1)
207 {
208 MockMessageParcel::ClearAllErrorFlag();
209 auto res = screenSessionManagerProxy->GetDefaultDisplayInfo();
210 ASSERT_EQ(res, nullptr);
211 }
212
213 /**
214 * @tc.name: SetScreenActiveMode
215 * @tc.desc: SetScreenActiveMode
216 * @tc.type: FUNC
217 */
218 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenActiveMode, TestSize.Level1)
219 {
220 ScreenId id = 1001;
221 uint32_t modeId = 1;
222
223
224 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
225 std::function<void()> func = [&]()
__anon70844abc0502() 226 {
227 res = screenSessionManagerProxy->SetScreenActiveMode(id, modeId);
228 };
229 func();
230 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
231 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
232 } else {
233 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
234 }
235 }
236
237 /**
238 * @tc.name: SetVirtualPixelRatio
239 * @tc.desc: SetVirtualPixelRatio
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualPixelRatio, TestSize.Level1)
243 {
244 ScreenId id = 1001;
245 float virtualPixelRatio = 1.0;
246
247
248 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
249 std::function<void()> func = [&]()
__anon70844abc0602() 250 {
251 res = screenSessionManagerProxy->SetVirtualPixelRatio(id, virtualPixelRatio);
252 };
253 func();
254 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
255 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
256 } else {
257 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
258 }
259 }
260
261 /**
262 * @tc.name: NotifyScreenConnectCompletion
263 * @tc.desc: NotifyScreenConnectCompletion
264 * @tc.type: FUNC
265 */
266 HWTEST_F(ScreenSessionManagerProxyTest, NotifyScreenConnectCompletion, TestSize.Level1)
267 {
268 logMsg.clear();
269 LOG_SetCallback(MyLogCallback);
270 ScreenId id = 1001;
271
272 std::function<void()> func = [&]()
__anon70844abc0702() 273 {
274 screenSessionManagerProxy->NotifyScreenConnectCompletion(id);
275 };
276 func();
277 EXPECT_TRUE(logMsg.find("SendRequest failed") == std::string::npos);
278 LOG_SetCallback(nullptr);
279 }
280
281 /**
282 * @tc.name: SetVirtualPixelRatioSystem
283 * @tc.desc: SetVirtualPixelRatioSystem
284 * @tc.type: FUNC
285 */
286 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualPixelRatioSystem, TestSize.Level1)
287 {
288 ScreenId id = 1001;
289 float virtualPixelRatio = 1.0;
290
291
292 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
293 std::function<void()> func = [&]()
__anon70844abc0802() 294 {
295 res = screenSessionManagerProxy->SetVirtualPixelRatioSystem(id, virtualPixelRatio);
296 };
297 func();
298 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
299 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
300 } else {
301 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
302 }
303 }
304
305 /**
306 * @tc.name: SetDefaultDensityDpi
307 * @tc.desc: SetDefaultDensityDpi
308 * @tc.type: FUNC
309 */
310 HWTEST_F(ScreenSessionManagerProxyTest, SetDefaultDensityDpi, TestSize.Level1)
311 {
312 ScreenId id = 1001;
313 float virtualPixelRatio = 1.0;
314
315
316 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
317 std::function<void()> func = [&]()
__anon70844abc0902() 318 {
319 res = screenSessionManagerProxy->SetDefaultDensityDpi(id, virtualPixelRatio);
320 };
321 func();
322 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
323 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
324 } else {
325 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
326 }
327 }
328
329 /**
330 * @tc.name: SetResolution
331 * @tc.desc: SetResolution
332 * @tc.type: FUNC
333 */
334 HWTEST_F(ScreenSessionManagerProxyTest, SetResolution, TestSize.Level1)
335 {
336 ScreenId id = 1001;
337 uint32_t width = 1024;
338 uint32_t height = 1024;
339 float virtualPixelRatio = 1.0;
340
341
342 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
343 std::function<void()> func = [&]()
__anon70844abc0a02() 344 {
345 res = screenSessionManagerProxy->SetResolution(id, width, height, virtualPixelRatio);
346 };
347 func();
348 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
349 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
350 } else {
351 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
352 }
353 }
354
355 /**
356 * @tc.name: GetDensityInCurResolution
357 * @tc.desc: GetDensityInCurResolution
358 * @tc.type: FUNC
359 */
360 HWTEST_F(ScreenSessionManagerProxyTest, GetDensityInCurResolution, TestSize.Level1)
361 {
362 ScreenId id = 1001;
363 float virtualPixelRatio = 1.0;
364
365
366 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
367 std::function<void()> func = [&]()
__anon70844abc0b02() 368 {
369 res = screenSessionManagerProxy->GetDensityInCurResolution(id, virtualPixelRatio);
370 };
371 func();
372 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
373 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
374 } else {
375 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
376 }
377 }
378
379 /**
380 * @tc.name: GetScreenColorGamut
381 * @tc.desc: GetScreenColorGamut
382 * @tc.type: FUNC
383 */
384 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenColorGamut, TestSize.Level1)
385 {
386 ScreenId id = 1001;
387 ScreenColorGamut colorGamut {0};
388
389
390 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
391 std::function<void()> func = [&]()
__anon70844abc0c02() 392 {
393 res = screenSessionManagerProxy->GetScreenColorGamut(id, colorGamut);
394 };
395 func();
396 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
397 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
398 } else {
399 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
400 }
401 }
402
403 /**
404 * @tc.name: SetScreenColorGamut
405 * @tc.desc: SetScreenColorGamut
406 * @tc.type: FUNC
407 */
408 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenColorGamut, TestSize.Level1)
409 {
410 ScreenId id = 1001;
411 uint32_t colorGamut = 0;
412
413
414 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
415 std::function<void()> func = [&]()
__anon70844abc0d02() 416 {
417 res = screenSessionManagerProxy->SetScreenColorGamut(id, colorGamut);
418 };
419 func();
420 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
421 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
422 } else {
423 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
424 }
425 }
426
427 /**
428 * @tc.name: GetScreenGamutMap
429 * @tc.desc: GetScreenGamutMap
430 * @tc.type: FUNC
431 */
432 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenGamutMap, TestSize.Level1)
433 {
434 ScreenId id = 1001;
435 ScreenGamutMap colorGamut;
436
437
438 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
439 std::function<void()> func = [&]()
__anon70844abc0e02() 440 {
441 res = screenSessionManagerProxy->GetScreenGamutMap(id, colorGamut);
442 };
443 func();
444 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
445 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
446 } else {
447 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
448 }
449 }
450
451 /**
452 * @tc.name: SetScreenGamutMap
453 * @tc.desc: SetScreenGamutMap
454 * @tc.type: FUNC
455 */
456 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenGamutMap, TestSize.Level1)
457 {
458 ScreenId id = 1001;
459 ScreenGamutMap colorGamut {0};
460
461
462 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
463 std::function<void()> func = [&]()
__anon70844abc0f02() 464 {
465 res = screenSessionManagerProxy->SetScreenGamutMap(id, colorGamut);
466 };
467 func();
468 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
469 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
470 } else {
471 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
472 }
473 }
474
475 /**
476 * @tc.name: SetScreenColorTransform
477 * @tc.desc: SetScreenColorTransform
478 * @tc.type: FUNC
479 */
480 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenColorTransform, TestSize.Level1)
481 {
482 ScreenId id = 1001;
483
484
485 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
486 std::function<void()> func = [&]()
__anon70844abc1002() 487 {
488 res = screenSessionManagerProxy->SetScreenColorTransform(id);
489 };
490 func();
491 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
492 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
493 } else {
494 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
495 }
496 }
497
498 /**
499 * @tc.name: GetPixelFormat
500 * @tc.desc: GetPixelFormat
501 * @tc.type: FUNC
502 */
503 HWTEST_F(ScreenSessionManagerProxyTest, GetPixelFormat, TestSize.Level1)
504 {
505 ScreenId id = 1001;
506 GraphicPixelFormat pixelFormat = GraphicPixelFormat {GRAPHIC_PIXEL_FMT_CLUT8};
507
508
509 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
510 std::function<void()> func = [&]()
__anon70844abc1102() 511 {
512 res = screenSessionManagerProxy->GetPixelFormat(id, pixelFormat);
513 };
514 func();
515 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
516 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
517 } else {
518 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
519 }
520 }
521
522 /**
523 * @tc.name: SetPixelFormat
524 * @tc.desc: SetPixelFormat
525 * @tc.type: FUNC
526 */
527 HWTEST_F(ScreenSessionManagerProxyTest, SetPixelFormat, TestSize.Level1)
528 {
529 ScreenId id = 1001;
530 GraphicPixelFormat pixelFormat = GraphicPixelFormat {GRAPHIC_PIXEL_FMT_CLUT8};
531
532
533 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
534 std::function<void()> func = [&]()
__anon70844abc1202() 535 {
536 res = screenSessionManagerProxy->SetPixelFormat(id, pixelFormat);
537 };
538 func();
539 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
540 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
541 } else {
542 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
543 }
544 }
545
546 /**
547 * @tc.name: GetSupportedHDRFormats
548 * @tc.desc: GetSupportedHDRFormats
549 * @tc.type: FUNC
550 */
551 HWTEST_F(ScreenSessionManagerProxyTest, GetSupportedHDRFormats, TestSize.Level1)
552 {
553 ScreenId id = 1001;
554 vector<ScreenHDRFormat> hdrFormats;
555
556
557 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
558 std::function<void()> func = [&]()
__anon70844abc1302() 559 {
560 res = screenSessionManagerProxy->GetSupportedHDRFormats(id, hdrFormats);
561 };
562 func();
563 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
564 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
565 } else {
566 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
567 }
568 }
569
570 /**
571 * @tc.name: GetScreenHDRFormat
572 * @tc.desc: GetScreenHDRFormat
573 * @tc.type: FUNC
574 */
575 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenHDRFormat, TestSize.Level1)
576 {
577 ScreenId id = 1001;
578 ScreenHDRFormat hdrFormatS {0};
579
580
581 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
582 std::function<void()> func = [&]()
__anon70844abc1402() 583 {
584 res = screenSessionManagerProxy->GetScreenHDRFormat(id, hdrFormatS);
585 };
586 func();
587 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
588 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
589 } else {
590 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
591 }
592 }
593
594 /**
595 * @tc.name: SetScreenHDRFormat
596 * @tc.desc: SetScreenHDRFormat
597 * @tc.type: FUNC
598 */
599 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenHDRFormat, TestSize.Level1)
600 {
601 ScreenId id = 1001;
602 ScreenHDRFormat hdrFormatS {0};
603
604
605 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
606 std::function<void()> func = [&]()
__anon70844abc1502() 607 {
608 res = screenSessionManagerProxy->SetScreenHDRFormat(id, hdrFormatS);
609 };
610 func();
611 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
612 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
613 } else {
614 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
615 }
616 }
617
618 /**
619 * @tc.name: RegisterDisplayManagerAgent
620 * @tc.desc: RegisterDisplayManagerAgent
621 * @tc.type: FUNC
622 */
623 HWTEST_F(ScreenSessionManagerProxyTest, RegisterDisplayManagerAgent, TestSize.Level1)
624 {
625 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
626 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
627 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
628 EXPECT_EQ(DMError::DM_OK, screenSessionManagerProxy->RegisterDisplayManagerAgent(displayManagerAgent, type));
629 } else {
630 EXPECT_NE(DMError::DM_OK, screenSessionManagerProxy->RegisterDisplayManagerAgent(displayManagerAgent, type));
631 }
632 displayManagerAgent = nullptr;
633 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM,
634 screenSessionManagerProxy->RegisterDisplayManagerAgent(displayManagerAgent, type));
635 }
636
637 /**
638 * @tc.name: UnregisterDisplayManagerAgent
639 * @tc.desc: UnregisterDisplayManagerAgent
640 * @tc.type: FUNC
641 */
642 HWTEST_F(ScreenSessionManagerProxyTest, UnregisterDisplayManagerAgent, TestSize.Level1)
643 {
644 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
645 DisplayManagerAgentType type = DisplayManagerAgentType::SCREEN_EVENT_LISTENER;
646 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
647 EXPECT_EQ(DMError::DM_OK, screenSessionManagerProxy->UnregisterDisplayManagerAgent(displayManagerAgent, type));
648 } else {
649 EXPECT_NE(DMError::DM_OK, screenSessionManagerProxy->UnregisterDisplayManagerAgent(displayManagerAgent, type));
650 }
651 displayManagerAgent = nullptr;
652 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM,
653 screenSessionManagerProxy->UnregisterDisplayManagerAgent(displayManagerAgent, type));
654 }
655
656 /**
657 * @tc.name: WakeUpBegin
658 * @tc.desc: WakeUpBegin
659 * @tc.type: FUNC
660 */
661 HWTEST_F(ScreenSessionManagerProxyTest, WakeUpBegin, TestSize.Level1)
662 {
663 PowerStateChangeReason reason {0};
664 MockMessageParcel::ClearAllErrorFlag();
665 EXPECT_EQ(false, screenSessionManagerProxy->WakeUpBegin(reason));
666 }
667
668 /**
669 * @tc.name: WakeUpEnd
670 * @tc.desc: WakeUpEnd
671 * @tc.type: FUNC
672 */
673 HWTEST_F(ScreenSessionManagerProxyTest, WakeUpEnd, TestSize.Level1)
674 {
675 MockMessageParcel::ClearAllErrorFlag();
676 EXPECT_EQ(false, screenSessionManagerProxy->WakeUpEnd());
677 }
678
679 /**
680 * @tc.name: SuspendBegin
681 * @tc.desc: SuspendBegin
682 * @tc.type: FUNC
683 */
684 HWTEST_F(ScreenSessionManagerProxyTest, SuspendBegin, TestSize.Level1)
685 {
686 PowerStateChangeReason reason {0};
687 MockMessageParcel::ClearAllErrorFlag();
688 EXPECT_EQ(false, screenSessionManagerProxy->SuspendBegin(reason));
689 }
690
691 /**
692 * @tc.name: SuspendEnd
693 * @tc.desc: SuspendEnd
694 * @tc.type: FUNC
695 */
696 HWTEST_F(ScreenSessionManagerProxyTest, SuspendEnd, TestSize.Level1)
697 {
698 MockMessageParcel::ClearAllErrorFlag();
699 EXPECT_EQ(false, screenSessionManagerProxy->SuspendEnd());
700 }
701
702 /**
703 * @tc.name: SetScreenPowerById
704 * @tc.desc: SetScreenPowerById
705 * @tc.type: FUNC
706 */
707 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenPowerById, TestSize.Level1)
708 {
709 ScreenPowerState state {0};
710 ScreenId id = 1001;
711 PowerStateChangeReason reason {1};
712
713 MockMessageParcel::ClearAllErrorFlag();
714 EXPECT_EQ(false, screenSessionManagerProxy->SetScreenPowerById(id, state, reason));
715 }
716
717 /**
718 * @tc.name: SetDisplayState
719 * @tc.desc: SetDisplayState
720 * @tc.type: FUNC
721 */
722 HWTEST_F(ScreenSessionManagerProxyTest, SetDisplayState, TestSize.Level1)
723 {
724 DisplayState state {1};
725 MockMessageParcel::ClearAllErrorFlag();
726 auto ret = screenSessionManagerProxy->SetDisplayState(state);
727 ASSERT_EQ(ret, false);
728 }
729
730 /**
731 * @tc.name: SetSpecifiedScreenPower
732 * @tc.desc: SetSpecifiedScreenPower
733 * @tc.type: FUNC
734 */
735 HWTEST_F(ScreenSessionManagerProxyTest, SetSpecifiedScreenPower, TestSize.Level1)
736 {
737 ScreenPowerState state {0};
738 ScreenId id = 1001;
739 PowerStateChangeReason reason {1};
740 MockMessageParcel::ClearAllErrorFlag();
741 EXPECT_EQ(false, screenSessionManagerProxy->SetSpecifiedScreenPower(id, state, reason));
742 }
743
744 /**
745 * @tc.name: SetScreenPowerForAll
746 * @tc.desc: SetScreenPowerForAll
747 * @tc.type: FUNC
748 */
749 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenPowerForAll, TestSize.Level1)
750 {
751 ScreenPowerState state {0};
752 PowerStateChangeReason reason {1};
753 MockMessageParcel::ClearAllErrorFlag();
754 EXPECT_EQ(false, screenSessionManagerProxy->SetScreenPowerForAll(state, reason));
755 }
756
757 /**
758 * @tc.name: GetDisplayState
759 * @tc.desc: GetDisplayState
760 * @tc.type: FUNC
761 */
762 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayState, TestSize.Level1)
763 {
764 DisplayId displayId {0};
765 MockMessageParcel::ClearAllErrorFlag();
766 EXPECT_EQ(DisplayState::UNKNOWN, screenSessionManagerProxy->GetDisplayState(displayId));
767 }
768
769 /**
770 * @tc.name: TryToCancelScreenOff
771 * @tc.desc: TryToCancelScreenOff
772 * @tc.type: FUNC
773 */
774 HWTEST_F(ScreenSessionManagerProxyTest, TryToCancelScreenOff, TestSize.Level1)
775 {
776 bool expectation = true;
777 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
778 EXPECT_NE(expectation, screenSessionManagerProxy->TryToCancelScreenOff());
779 } else {
780 EXPECT_NE(expectation, screenSessionManagerProxy->TryToCancelScreenOff());
781 }
782 }
783
784 /**
785 * @tc.name: NotifyDisplayEvent
786 * @tc.desc: NotifyDisplayEvent
787 * @tc.type: FUNC
788 */
789 HWTEST_F(ScreenSessionManagerProxyTest, NotifyDisplayEvent, TestSize.Level1)
790 {
791 DisplayEvent event {0};
792 int resultValue = 0;
793 std::function<void()> func = [&]()
__anon70844abc1602() 794 {
795 screenSessionManagerProxy->NotifyDisplayEvent(event);
796 resultValue = 1;
797 };
798 func();
799 ASSERT_EQ(resultValue, 1);
800 }
801
802 /**
803 * @tc.name: GetScreenPower
804 * @tc.desc: GetScreenPower
805 * @tc.type: FUNC
806 */
807 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenPower, TestSize.Level1)
808 {
809 ScreenId dmsScreenId = 1001;
810 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
811 EXPECT_NE(ScreenPowerState::INVALID_STATE, screenSessionManagerProxy->GetScreenPower(dmsScreenId));
812 } else {
813 EXPECT_EQ(ScreenPowerState::INVALID_STATE, screenSessionManagerProxy->GetScreenPower(dmsScreenId));
814 }
815 }
816
817 /**
818 * @tc.name: AddVirtualScreenBlockList
819 * @tc.desc: AddVirtualScreenBlockList
820 * @tc.type: FUNC
821 */
822 HWTEST_F(ScreenSessionManagerProxyTest, AddVirtualScreenBlockList, TestSize.Level1)
823 {
824 std::vector<int32_t> persistentIds {0, 1, 2};
825 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
826 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->AddVirtualScreenBlockList(persistentIds));
827 } else {
828 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->AddVirtualScreenBlockList(persistentIds));
829 }
830 }
831
832 /**
833 * @tc.name: RemoveVirtualScreenBlockList
834 * @tc.desc: RemoveVirtualScreenBlockList
835 * @tc.type: FUNC
836 */
837 HWTEST_F(ScreenSessionManagerProxyTest, RemoveVirtualScreenBlockList, TestSize.Level1)
838 {
839 std::vector<int32_t> persistentIds {0, 1, 2};
840 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
841 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->RemoveVirtualScreenBlockList(persistentIds));
842 } else {
843 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->RemoveVirtualScreenBlockList(persistentIds));
844 }
845 }
846
847 /**
848 * @tc.name: SetVirtualMirrorScreenCanvasRotation
849 * @tc.desc: SetVirtualMirrorScreenCanvasRotation
850 * @tc.type: FUNC
851 */
852 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualMirrorScreenCanvasRotation, TestSize.Level1)
853 {
854 ScreenId ScreenId = 1001;
855 bool canvasRotation = true;
856 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
857 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
858 screenSessionManagerProxy->SetVirtualMirrorScreenCanvasRotation(ScreenId, canvasRotation));
859 } else {
860 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
861 screenSessionManagerProxy->SetVirtualMirrorScreenCanvasRotation(ScreenId, canvasRotation));
862 }
863 }
864
865 /**
866 * @tc.name: SetVirtualMirrorScreenScaleMode
867 * @tc.desc: SetVirtualMirrorScreenScaleMode
868 * @tc.type: FUNC
869 */
870 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualMirrorScreenScaleMode, TestSize.Level1)
871 {
872 ScreenId ScreenId = 1001;
873 ScreenScaleMode scaleMode {0};
874 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
875 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
876 screenSessionManagerProxy->SetVirtualMirrorScreenScaleMode(ScreenId, scaleMode));
877 } else {
878 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
879 screenSessionManagerProxy->SetVirtualMirrorScreenScaleMode(ScreenId, scaleMode));
880 }
881 }
882
883 /**
884 * @tc.name: ResizeVirtualScreen
885 * @tc.desc: ResizeVirtualScreen
886 * @tc.type: FUNC
887 */
888 HWTEST_F(ScreenSessionManagerProxyTest, ResizeVirtualScreen, TestSize.Level1)
889 {
890 ScreenId ScreenId = 1001;
891 uint32_t width = 1024;
892 uint32_t height = 1024;
893 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
894 screenSessionManagerProxy->ResizeVirtualScreen(ScreenId, width, height));
895 }
896
897 /**
898 * @tc.name: DestroyVirtualScreen
899 * @tc.desc: DestroyVirtualScreen
900 * @tc.type: FUNC
901 */
902 HWTEST_F(ScreenSessionManagerProxyTest, DestroyVirtualScreen, TestSize.Level1)
903 {
904 ScreenId ScreenId = 1001;
905 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
906 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
907 screenSessionManagerProxy->DestroyVirtualScreen(ScreenId));
908 } else {
909 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
910 screenSessionManagerProxy->DestroyVirtualScreen(ScreenId));
911 }
912 }
913
914 /**
915 * @tc.name: MakeMirror
916 * @tc.desc: MakeMirror
917 * @tc.type: FUNC
918 */
919 HWTEST_F(ScreenSessionManagerProxyTest, MakeMirror, TestSize.Level1)
920 {
921 ScreenId Id = 1001;
922 std::vector<ScreenId> mirrorScreenIds = {1003, 1004, 1005};
923 ScreenId screenGroupId = 1002;
924 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
925 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
926 screenSessionManagerProxy->MakeMirror(Id, mirrorScreenIds, screenGroupId));
927 } else {
928 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
929 screenSessionManagerProxy->MakeMirror(Id, mirrorScreenIds, screenGroupId));
930 }
931 }
932
933 /**
934 * @tc.name: StopMirror
935 * @tc.desc: StopMirror
936 * @tc.type: FUNC
937 */
938 HWTEST_F(ScreenSessionManagerProxyTest, StopMirror, TestSize.Level1)
939 {
940 const std::vector<ScreenId> mirrorScreenIds = {1003, 1004, 1005};
941 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
942 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->StopMirror(mirrorScreenIds));
943 } else {
944 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->StopMirror(mirrorScreenIds));
945 }
946 }
947
948 /**
949 * @tc.name: DisableMirror
950 * @tc.desc: DisableMirror
951 * @tc.type: FUNC
952 */
953 HWTEST_F(ScreenSessionManagerProxyTest, DisableMirror, TestSize.Level1)
954 {
955 bool disableOrNot = true;
956 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
957 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->DisableMirror(disableOrNot));
958 } else {
959 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->DisableMirror(disableOrNot));
960 }
961 }
962
963 /**
964 * @tc.name: MakeExpand
965 * @tc.desc: MakeExpand
966 * @tc.type: FUNC
967 */
968 HWTEST_F(ScreenSessionManagerProxyTest, MakeExpand, TestSize.Level1)
969 {
970 std::vector<ScreenId> screenId = {1003, 1004, 1005};
971 std::vector<Point> startPoint {};
972 ScreenId screenGroupId = 1001;
973 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
974 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
975 screenSessionManagerProxy->MakeExpand(screenId, startPoint, screenGroupId));
976 } else {
977 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
978 screenSessionManagerProxy->MakeExpand(screenId, startPoint, screenGroupId));
979 }
980 }
981
982 /**
983 * @tc.name: StopExpand
984 * @tc.desc: StopExpand
985 * @tc.type: FUNC
986 */
987 HWTEST_F(ScreenSessionManagerProxyTest, StopExpand, TestSize.Level1)
988 {
989 const std::vector<ScreenId> expandScreenIds = {1003, 1004, 1005};
990 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
991 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->StopExpand(expandScreenIds));
992 } else {
993 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->StopExpand(expandScreenIds));
994 }
995 }
996
997 /**
998 * @tc.name: GetScreenGroupInfoById
999 * @tc.desc: GetScreenGroupInfoById
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenGroupInfoById, TestSize.Level1)
1003 {
1004 sptr<ScreenGroupInfo> expectation = nullptr;
1005 sptr<ScreenGroupInfo> res = nullptr;
1006 ScreenId Id {0};
1007 std::function<void()> func = [&]()
__anon70844abc1702() 1008 {
1009 res = screenSessionManagerProxy->GetScreenGroupInfoById(Id);
1010 };
1011 func();
1012 ASSERT_EQ(res, expectation);
1013 }
1014
1015 /**
1016 * @tc.name: RemoveVirtualScreenFromGroup
1017 * @tc.desc: RemoveVirtualScreenFromGroup
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(ScreenSessionManagerProxyTest, RemoveVirtualScreenFromGroup, TestSize.Level1)
1021 {
1022 std::vector<ScreenId> screens = {1002, 1003, 1004};
1023 screenSessionManagerProxy->RemoveVirtualScreenFromGroup(screens);
1024 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
1025 EXPECT_EQ(screenSession, nullptr);
1026 }
1027
1028 /**
1029 * @tc.name: GetDisplaySnapshot
1030 * @tc.desc: GetDisplaySnapshot
1031 * @tc.type: FUNC
1032 */
1033 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplaySnapshot, TestSize.Level1)
1034 {
1035 std::shared_ptr<Media::PixelMap> expectation = nullptr;
1036 DisplayId displayId {0};
1037 DmErrorCode* errorCode = nullptr;
1038 MockMessageParcel::ClearAllErrorFlag();
1039 auto res = screenSessionManagerProxy->GetDisplaySnapshot(displayId, errorCode, false, false);
1040 ASSERT_EQ(res, expectation);
1041 }
1042
1043 /**
1044 * @tc.name: GetDisplayInfoById
1045 * @tc.desc: GetDisplayInfoById
1046 * @tc.type: FUNC
1047 */
1048 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayInfoById, TestSize.Level1)
1049 {
1050 sptr<DisplayInfo> expectation = nullptr;
1051 DisplayId displayId {0};
1052 MockMessageParcel::ClearAllErrorFlag();
1053 auto res = screenSessionManagerProxy->GetDisplayInfoById(displayId);
1054 ASSERT_EQ(res, expectation);
1055 }
1056
1057 /**
1058 * @tc.name: GetDisplayInfoByScreen
1059 * @tc.desc: GetDisplayInfoByScreen
1060 * @tc.type: FUNC
1061 */
1062 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayInfoByScreen, TestSize.Level1)
1063 {
1064 sptr<DisplayInfo> expectation = nullptr;
1065 ScreenId screenId {0};
1066 MockMessageParcel::ClearAllErrorFlag();
1067 auto res = screenSessionManagerProxy->GetDisplayInfoByScreen(screenId);
1068 ASSERT_EQ(res, expectation);
1069 }
1070
1071 /**
1072 * @tc.name: GetAllDisplayIds
1073 * @tc.desc: GetAllDisplayIds
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(ScreenSessionManagerProxyTest, GetAllDisplayIds, TestSize.Level1)
1077 {
1078 int resultValue = 0;
1079 std::function<void()> func = [&]()
__anon70844abc1802() 1080 {
1081 screenSessionManagerProxy->GetAllDisplayIds();
1082 resultValue = 1;
1083 };
1084 func();
1085 ASSERT_EQ(resultValue, 1);
1086 }
1087
1088 /**
1089 * @tc.name: GetScreenInfoById
1090 * @tc.desc: GetScreenInfoById
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenInfoById, TestSize.Level1)
1094 {
1095 sptr<ScreenInfo> expectation = nullptr;
1096 ScreenId Id {0};
1097 MockMessageParcel::ClearAllErrorFlag();
1098 auto res = screenSessionManagerProxy->GetScreenInfoById(Id);
1099 ASSERT_EQ(res, expectation);
1100 }
1101
1102 /**
1103 * @tc.name: GetAllScreenInfos
1104 * @tc.desc: GetAllScreenInfos
1105 * @tc.type: FUNC
1106 */
1107 HWTEST_F(ScreenSessionManagerProxyTest, GetAllScreenInfos, TestSize.Level1)
1108 {
1109 std::vector<sptr<ScreenInfo>> screenInfos {};
1110 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1111 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
1112 screenSessionManagerProxy->GetAllScreenInfos(screenInfos));
1113 } else {
1114 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
1115 screenSessionManagerProxy->GetAllScreenInfos(screenInfos));
1116 }
1117 }
1118
1119 /**
1120 * @tc.name: GetScreenSupportedColorGamuts
1121 * @tc.desc: GetScreenSupportedColorGamuts
1122 * @tc.type: FUNC
1123 */
1124 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenSupportedColorGamuts, TestSize.Level1)
1125 {
1126 ScreenId screenId = 1001;
1127 std::vector<ScreenColorGamut> colorGamuts {};
1128 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1129 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
1130 screenSessionManagerProxy->GetScreenSupportedColorGamuts(screenId, colorGamuts));
1131 } else {
1132 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
1133 screenSessionManagerProxy->GetScreenSupportedColorGamuts(screenId, colorGamuts));
1134 }
1135 }
1136
1137 /**
1138 * @tc.name: SetOrientation
1139 * @tc.desc: SetOrientation
1140 * @tc.type: FUNC
1141 */
1142 HWTEST_F(ScreenSessionManagerProxyTest, SetOrientation, TestSize.Level1)
1143 {
1144 ScreenId screenId = 1001;
1145 Orientation orientation = Orientation::BEGIN;
1146 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1147 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
1148 screenSessionManagerProxy->SetOrientation(screenId, orientation));
1149 } else {
1150 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
1151 screenSessionManagerProxy->SetOrientation(screenId, orientation));
1152 }
1153 }
1154
1155 /**
1156 * @tc.name: SetScreenRotationLocked
1157 * @tc.desc: SetScreenRotationLocked
1158 * @tc.type: FUNC
1159 */
1160 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenRotationLocked, TestSize.Level1)
1161 {
1162 bool isLocked = true;
1163 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1164 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
1165 screenSessionManagerProxy->SetScreenRotationLocked(isLocked));
1166 } else {
1167 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
1168 screenSessionManagerProxy->SetScreenRotationLocked(isLocked));
1169 }
1170 }
1171
1172 /**
1173 * @tc.name: SetScreenRotationLockedFromJs
1174 * @tc.desc: SetScreenRotationLockedFromJs
1175 * @tc.type: FUNC
1176 */
1177 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenRotationLockedFromJs, TestSize.Level1)
1178 {
1179 bool isLocked = true;
1180 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1181 ASSERT_NE(DMError::DM_ERROR_IPC_FAILED,
1182 screenSessionManagerProxy->SetScreenRotationLockedFromJs(isLocked));
1183 } else {
1184 ASSERT_EQ(DMError::DM_ERROR_IPC_FAILED,
1185 screenSessionManagerProxy->SetScreenRotationLockedFromJs(isLocked));
1186 }
1187 }
1188
1189 /**
1190 * @tc.name: SetMultiScreenMode
1191 * @tc.desc: SetMultiScreenMode
1192 * @tc.type: FUNC
1193 */
1194 HWTEST_F(ScreenSessionManagerProxyTest, SetMultiScreenMode, TestSize.Level1)
1195 {
1196 ScreenId mainScreenId = 0;
1197 ScreenId secondaryScreenId = 1;
1198 MultiScreenMode screenMode = MultiScreenMode::SCREEN_EXTEND;
1199
1200 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
1201 std::function<void()> func = [&]()
__anon70844abc1902() 1202 {
1203 res = screenSessionManagerProxy->SetMultiScreenMode(mainScreenId, secondaryScreenId, screenMode);
1204 };
1205 func();
1206 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1207 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
1208 } else {
1209 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
1210 }
1211 }
1212
1213 /**
1214 * @tc.name: SetMultiScreenRelativePosition
1215 * @tc.desc: SetMultiScreenRelativePosition
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(ScreenSessionManagerProxyTest, SetMultiScreenRelativePosition, TestSize.Level1)
1219 {
1220 ScreenId testId = 2060;
1221 ScreenId testId1 = 3060;
1222 MultiScreenPositionOptions mainScreenOptions = {testId, 100, 100};
1223 MultiScreenPositionOptions secondScreenOption = {testId1, 100, 100};
1224
1225 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
1226 std::function<void()> func = [&]()
__anon70844abc1a02() 1227 {
1228 res = screenSessionManagerProxy->SetMultiScreenRelativePosition(mainScreenOptions, secondScreenOption);
1229 };
1230 func();
1231 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1232 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
1233 } else {
1234 ASSERT_EQ(res, DMError::DM_ERROR_IPC_FAILED);
1235 }
1236 }
1237
1238 /**
1239 * @tc.name: SetVirtualScreenMaxRefreshRate
1240 * @tc.desc: SetVirtualScreenMaxRefreshRate
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenMaxRefreshRate, TestSize.Level1)
1244 {
1245 ScreenId id = 0;
1246 uint32_t refreshRate = 12;
1247 uint32_t actualRefreshRate = 0;
1248
1249 DMError res = DMError::DM_ERROR_NOT_SYSTEM_APP;
1250 std::function<void()> func = [&]()
__anon70844abc1b02() 1251 {
1252 res = screenSessionManagerProxy->SetVirtualScreenMaxRefreshRate(id, refreshRate, actualRefreshRate);
1253 };
1254 func();
1255 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1256 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
1257 } else {
1258 ASSERT_NE(res, DMError::DM_ERROR_IPC_FAILED);
1259 }
1260 }
1261
1262 /**
1263 * @tc.name: IsScreenRotationLocked
1264 * @tc.desc: IsScreenRotationLocked
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(ScreenSessionManagerProxyTest, IsScreenRotationLocked, TestSize.Level1)
1268 {
1269 logMsg.clear();
1270 LOG_SetCallback(MyLogCallback);
1271 bool isLocked = true;
1272
1273 MockMessageParcel::ClearAllErrorFlag();
1274 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1275 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
1276 screenSessionManagerProxy->IsScreenRotationLocked(isLocked));
1277 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1278
1279 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1280 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
1281 screenSessionManagerProxy->IsScreenRotationLocked(isLocked));
1282 } else {
1283 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
1284 screenSessionManagerProxy->IsScreenRotationLocked(isLocked));
1285 }
1286 }
1287
1288 /**
1289 * @tc.name: GetCutoutInfo
1290 * @tc.desc: GetCutoutInfo
1291 * @tc.type: FUNC
1292 */
1293 HWTEST_F(ScreenSessionManagerProxyTest, GetCutoutInfo, TestSize.Level1)
1294 {
1295 logMsg.clear();
1296 LOG_SetCallback(MyLogCallback);
1297 sptr<CutoutInfo> expectation = nullptr;
1298 DisplayId displayId = 0;
1299
1300 MockMessageParcel::ClearAllErrorFlag();
1301 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1302 auto res = screenSessionManagerProxy->GetCutoutInfo(displayId);
1303 EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
1304 EXPECT_EQ(res, expectation);
1305
1306 MockMessageParcel::ClearAllErrorFlag();
1307 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1308 res = screenSessionManagerProxy->GetCutoutInfo(displayId);
1309 EXPECT_TRUE(logMsg.find("write displayId failed") != std::string::npos);
1310 EXPECT_EQ(res, expectation);
1311
1312 MockMessageParcel::ClearAllErrorFlag();
1313 res = screenSessionManagerProxy->GetCutoutInfo(displayId);
1314 EXPECT_EQ(res, expectation);
1315 }
1316
1317 /**
1318 * @tc.name: GetCutoutInfo2
1319 * @tc.desc: GetCutoutInfo2
1320 * @tc.type: FUNC
1321 */
1322 HWTEST_F(ScreenSessionManagerProxyTest, GetCutoutInfo2, TestSize.Level1)
1323 {
1324 logMsg.clear();
1325 LOG_SetCallback(MyLogCallback);
1326 sptr<CutoutInfo> expectation = nullptr;
1327 DisplayId displayId = 0;
1328
1329 MockMessageParcel::ClearAllErrorFlag();
1330 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1331 auto res = screenSessionManagerProxy->GetCutoutInfo(displayId, 0, 0, Rotation::ROTATION_0);
1332 EXPECT_EQ(res, expectation);
1333
1334 MockMessageParcel::ClearAllErrorFlag();
1335 MockMessageParcel::SetWriteInt32ErrorFlag(true);
1336 res = screenSessionManagerProxy->GetCutoutInfo(displayId, 0, 0, Rotation::ROTATION_0);
1337 EXPECT_EQ(res, expectation);
1338
1339 MockMessageParcel::ClearAllErrorFlag();
1340 MockMessageParcel::SetWriteUint32ErrorFlag(true);
1341 res = screenSessionManagerProxy->GetCutoutInfo(displayId, 0, 0, Rotation::ROTATION_0);
1342 EXPECT_EQ(res, expectation);
1343 }
1344
1345 /**
1346 * @tc.name: HasImmersiveWindow
1347 * @tc.desc: HasImmersiveWindow
1348 * @tc.type: FUNC
1349 */
1350 HWTEST_F(ScreenSessionManagerProxyTest, HasImmersiveWindow, TestSize.Level1)
1351 {
1352 logMsg.clear();
1353 LOG_SetCallback(MyLogCallback);
1354 bool immersive = true;
1355
1356 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1357 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
1358 } else {
1359 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
1360 }
1361
1362 MockMessageParcel::ClearAllErrorFlag();
1363 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1364 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
1365 screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
1366 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1367
1368 MockMessageParcel::ClearAllErrorFlag();
1369 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1370 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->HasImmersiveWindow(0u, immersive));
1371 }
1372
1373 /**
1374 * @tc.name: ConvertScreenIdToRsScreenId
1375 * @tc.desc: ConvertScreenIdToRsScreenId
1376 * @tc.type: FUNC
1377 */
1378 HWTEST_F(ScreenSessionManagerProxyTest, ConvertScreenIdToRsScreenId, TestSize.Level1)
1379 {
1380 logMsg.clear();
1381 LOG_SetCallback(MyLogCallback);
1382 ScreenId screenId = 1001;
1383 ScreenId rsScreenId = 1002;
1384
1385 MockMessageParcel::ClearAllErrorFlag();
1386 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1387 auto ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
1388 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1389 EXPECT_EQ(ret, false);
1390
1391 MockMessageParcel::ClearAllErrorFlag();
1392 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1393 ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
1394 EXPECT_EQ(ret, false);
1395
1396 MockMessageParcel::ClearAllErrorFlag();
1397 ret = screenSessionManagerProxy->ConvertScreenIdToRsScreenId(screenId, rsScreenId);
1398 EXPECT_EQ(ret, false);
1399 }
1400
1401 /**
1402 * @tc.name: HasPrivateWindow
1403 * @tc.desc: HasPrivateWindow
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(ScreenSessionManagerProxyTest, HasPrivateWindow, TestSize.Level1)
1407 {
1408 logMsg.clear();
1409 LOG_SetCallback(MyLogCallback);
1410 bool hasPrivateWindow = true;
1411 DisplayId displayId = 0;
1412
1413 MockMessageParcel::ClearAllErrorFlag();
1414 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1415 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
1416 screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
1417 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1418
1419 MockMessageParcel::ClearAllErrorFlag();
1420 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1421 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
1422 screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
1423
1424 MockMessageParcel::ClearAllErrorFlag();
1425 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1426 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
1427 screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
1428 } else {
1429 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
1430 screenSessionManagerProxy->HasPrivateWindow(displayId, hasPrivateWindow));
1431 }
1432 }
1433
1434 /**
1435 * @tc.name: DumpAllScreensInfo
1436 * @tc.desc: DumpAllScreensInfo
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(ScreenSessionManagerProxyTest, DumpAllScreensInfo, TestSize.Level1)
1440 {
1441 logMsg.clear();
1442 LOG_SetCallback(MyLogCallback);
1443 std::string dumpInfo;
1444
1445 MockMessageParcel::ClearAllErrorFlag();
1446 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1447 screenSessionManagerProxy->DumpAllScreensInfo(dumpInfo);
1448 EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
1449 EXPECT_EQ(dumpInfo, "");
1450
1451 MockMessageParcel::ClearAllErrorFlag();
1452 screenSessionManagerProxy->DumpAllScreensInfo(dumpInfo);
1453 EXPECT_EQ(dumpInfo, "");
1454 }
1455
1456 /**
1457 * @tc.name: DumpSpecialScreenInfo
1458 * @tc.desc: DumpSpecialScreenInfo
1459 * @tc.type: FUNC
1460 */
1461 HWTEST_F(ScreenSessionManagerProxyTest, DumpSpecialScreenInfo, TestSize.Level1)
1462 {
1463 logMsg.clear();
1464 LOG_SetCallback(MyLogCallback);
1465 ScreenId id = 1001;
1466 std::string dumpInfo;
1467
1468 MockMessageParcel::ClearAllErrorFlag();
1469 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1470 screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
1471 EXPECT_TRUE(logMsg.find("failed") != std::string::npos);
1472 EXPECT_EQ(dumpInfo, "");
1473
1474 MockMessageParcel::ClearAllErrorFlag();
1475 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1476 screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
1477 EXPECT_TRUE(logMsg.find("write ScreenId failed") != std::string::npos);
1478 EXPECT_EQ(dumpInfo, "");
1479
1480 MockMessageParcel::ClearAllErrorFlag();
1481 screenSessionManagerProxy->DumpSpecialScreenInfo(id, dumpInfo);
1482 EXPECT_EQ(dumpInfo, "");
1483 }
1484
1485 /**
1486 * @tc.name: SetFoldDisplayMode
1487 * @tc.desc: SetFoldDisplayMode
1488 * @tc.type: FUNC
1489 */
1490 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayMode, TestSize.Level1)
1491 {
1492 logMsg.clear();
1493 LOG_SetCallback(MyLogCallback);
1494 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
1495
1496 MockMessageParcel::ClearAllErrorFlag();
1497 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1498 screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
1499 EXPECT_TRUE(logMsg.find("WriteInterfaceToken Failed") != std::string::npos);
1500
1501 MockMessageParcel::ClearAllErrorFlag();
1502 MockMessageParcel::SetWriteUint32ErrorFlag(true);
1503 screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
1504 EXPECT_TRUE(logMsg.find("Write displayMode failed") != std::string::npos);
1505
1506 MockMessageParcel::ClearAllErrorFlag();
1507 screenSessionManagerProxy->SetFoldDisplayMode(displayMode);
1508 if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1509 EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1510 } else if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
1511 EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1512 } else {
1513 EXPECT_EQ(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1514 }
1515 }
1516
1517 /**
1518 * @tc.name: SetFoldDisplayModeAsync
1519 * @tc.desc: SetFoldDisplayModeAsync
1520 * @tc.type: FUNC
1521 */
1522 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayModeAsync, TestSize.Level1)
1523 {
1524 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
1525 screenSessionManagerProxy->SetFoldDisplayModeAsync(displayMode);
1526 if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1527 EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1528 } else if (FoldScreenStateInternel::IsDualDisplayFoldDevice()) {
1529 EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1530 } else {
1531 EXPECT_EQ(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1532 }
1533 }
1534
1535 /**
1536 * @tc.name: SetFoldDisplayModeFromJs
1537 * @tc.desc: SetFoldDisplayModeFromJs
1538 * @tc.type: FUNC
1539 */
1540 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldDisplayModeFromJs, TestSize.Level1)
1541 {
1542 logMsg.clear();
1543 LOG_SetCallback(MyLogCallback);
1544 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
1545
1546 MockMessageParcel::ClearAllErrorFlag();
1547 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1548 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
1549 screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
1550 EXPECT_TRUE(logMsg.find("WriteInterfaceToken Failed") != std::string::npos);
1551
1552 MockMessageParcel::ClearAllErrorFlag();
1553 MockMessageParcel::SetWriteUint32ErrorFlag(true);
1554 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
1555 EXPECT_TRUE(logMsg.find("Write displayMode failed") != std::string::npos);
1556
1557 MockMessageParcel::ClearAllErrorFlag();
1558 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1559 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
1560 } else {
1561 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, screenSessionManagerProxy->SetFoldDisplayModeFromJs(displayMode));
1562 }
1563 }
1564
1565 /**
1566 * @tc.name: SetFoldStatusLocked
1567 * @tc.desc: SetFoldStatusLocked
1568 * @tc.type: FUNC
1569 */
1570 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusLocked, TestSize.Level1)
1571 {
1572 logMsg.clear();
1573 LOG_SetCallback(MyLogCallback);
1574 bool locked = true;
1575
1576 MockMessageParcel::ClearAllErrorFlag();
1577 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1578 screenSessionManagerProxy->SetFoldStatusLocked(locked);
1579 EXPECT_TRUE(logMsg.find("WriteInterfaceToken Failed") != std::string::npos);
1580
1581 MockMessageParcel::ClearAllErrorFlag();
1582 MockMessageParcel::SetWriteUint32ErrorFlag(true);
1583 screenSessionManagerProxy->SetFoldStatusLocked(locked);
1584 EXPECT_TRUE(logMsg.find("Write lock fold display status failed") != std::string::npos);
1585
1586 MockMessageParcel::ClearAllErrorFlag();
1587 screenSessionManagerProxy->SetFoldStatusLocked(locked);
1588 if (screenSessionManagerProxy->IsFoldable() && !FoldScreenStateInternel::IsSuperFoldDisplayDevice()) {
1589 EXPECT_NE(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1590 } else {
1591 EXPECT_EQ(ScreenSessionManager::GetInstance().foldScreenController_, nullptr);
1592 }
1593 }
1594
1595 /**
1596 * @tc.name: GetFoldDisplayMode
1597 * @tc.desc: GetFoldDisplayMode
1598 * @tc.type: FUNC
1599 */
1600 HWTEST_F(ScreenSessionManagerProxyTest, GetFoldDisplayMode, TestSize.Level1)
1601 {
1602 logMsg.clear();
1603 LOG_SetCallback(MyLogCallback);
1604
1605 MockMessageParcel::ClearAllErrorFlag();
1606 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1607 EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerProxy->GetFoldDisplayMode());
1608 EXPECT_TRUE(logMsg.find("WriteInterfaceToken Failed") != std::string::npos);
1609
1610 MockMessageParcel::ClearAllErrorFlag();
1611 EXPECT_EQ(FoldDisplayMode::UNKNOWN, screenSessionManagerProxy->GetFoldDisplayMode());
1612 }
1613
1614 /**
1615 * @tc.name: IsFoldable
1616 * @tc.desc: IsFoldable
1617 * @tc.type: FUNC
1618 */
1619 HWTEST_F(ScreenSessionManagerProxyTest, IsFoldable, TestSize.Level1)
1620 {
1621 logMsg.clear();
1622 LOG_SetCallback(MyLogCallback);
1623
1624 MockMessageParcel::ClearAllErrorFlag();
1625 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1626 screenSessionManagerProxy->IsFoldable();
1627 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1628
1629 MockMessageParcel::ClearAllErrorFlag();
1630 screenSessionManagerProxy->IsFoldable();
1631 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
1632 EXPECT_EQ(screenSession, nullptr);
1633 }
1634
1635 /**
1636 * @tc.name: IsCaptured
1637 * @tc.desc: IsCaptured
1638 * @tc.type: FUNC
1639 */
1640 HWTEST_F(ScreenSessionManagerProxyTest, IsCaptured, TestSize.Level1)
1641 {
1642 logMsg.clear();
1643 LOG_SetCallback(MyLogCallback);
1644
1645 MockMessageParcel::ClearAllErrorFlag();
1646 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1647 auto ret = screenSessionManagerProxy->IsCaptured();
1648 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1649 EXPECT_EQ(ret, false);
1650
1651 MockMessageParcel::ClearAllErrorFlag();
1652 ret = screenSessionManagerProxy->IsCaptured();
1653 EXPECT_EQ(ret, false);
1654 }
1655
1656 /**
1657 * @tc.name: GetFoldStatus
1658 * @tc.desc: GetFoldStatus
1659 * @tc.type: FUNC
1660 */
1661 HWTEST_F(ScreenSessionManagerProxyTest, GetFoldStatus, TestSize.Level1)
1662 {
1663 logMsg.clear();
1664 LOG_SetCallback(MyLogCallback);
1665
1666 MockMessageParcel::ClearAllErrorFlag();
1667 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1668 auto foldStatus = screenSessionManagerProxy->GetFoldStatus();
1669 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1670 EXPECT_EQ(foldStatus, FoldStatus::UNKNOWN);
1671
1672 MockMessageParcel::ClearAllErrorFlag();
1673 foldStatus = screenSessionManagerProxy->GetFoldStatus();
1674 EXPECT_EQ(foldStatus, FoldStatus::UNKNOWN);
1675 }
1676
1677 /**
1678 * @tc.name: GetSuperFoldStatus
1679 * @tc.desc: GetSuperFoldStatus
1680 * @tc.type: FUNC
1681 */
1682 HWTEST_F(ScreenSessionManagerProxyTest, GetSuperFoldStatus, TestSize.Level1)
1683 {
1684 logMsg.clear();
1685 LOG_SetCallback(MyLogCallback);
1686
1687 MockMessageParcel::ClearAllErrorFlag();
1688 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1689 auto superFoldStatus = screenSessionManagerProxy->GetSuperFoldStatus();
1690 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1691 EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
1692
1693 MockMessageParcel::ClearAllErrorFlag();
1694 superFoldStatus = screenSessionManagerProxy->GetSuperFoldStatus();
1695 EXPECT_EQ(superFoldStatus, SuperFoldStatus::UNKNOWN);
1696 }
1697
1698 /**
1699 * @tc.name: GetSuperRotation
1700 * @tc.desc: GetSuperRotation
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(ScreenSessionManagerProxyTest, GetSuperRotation, TestSize.Level1)
1704 {
1705 logMsg.clear();
1706 LOG_SetCallback(MyLogCallback);
1707
1708 MockMessageParcel::ClearAllErrorFlag();
1709 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1710 EXPECT_FLOAT_EQ(screenSessionManagerProxy->GetSuperRotation(), -1.f);
1711 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1712
1713 MockMessageParcel::ClearAllErrorFlag();
1714 EXPECT_FLOAT_EQ(screenSessionManagerProxy->GetSuperRotation(), 0);
1715 }
1716
1717 /**
1718 * @tc.name: SetLandscapeLockStatus
1719 * @tc.desc: SetLandscapeLockStatus
1720 * @tc.type: FUNC
1721 */
1722 HWTEST_F(ScreenSessionManagerProxyTest, SetLandscapeLockStatus, Function | SmallTest | Level1)
1723 {
1724 logMsg.clear();
1725 LOG_SetCallback(MyLogCallback);
1726 bool isLocked = false;
1727
1728 MockMessageParcel::ClearAllErrorFlag();
1729 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1730 screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
1731 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1732 EXPECT_EQ(isLocked, false);
1733
1734 MockMessageParcel::ClearAllErrorFlag();
1735 MockMessageParcel::SetWriteBoolErrorFlag(true);
1736 screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
1737 EXPECT_TRUE(logMsg.find("Write isLocked failed") != std::string::npos);
1738 EXPECT_EQ(isLocked, false);
1739
1740 MockMessageParcel::ClearAllErrorFlag();
1741 screenSessionManagerProxy->SetLandscapeLockStatus(isLocked);
1742 EXPECT_EQ(isLocked, false);
1743 }
1744
1745 /**
1746 * @tc.name: GetCurrentFoldCreaseRegion
1747 * @tc.desc: GetCurrentFoldCreaseRegion
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F(ScreenSessionManagerProxyTest, GetCurrentFoldCreaseRegion, TestSize.Level1)
1751 {
1752 logMsg.clear();
1753 LOG_SetCallback(MyLogCallback);
1754
1755 MockMessageParcel::ClearAllErrorFlag();
1756 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1757 auto foldCreaseRegion = screenSessionManagerProxy->GetCurrentFoldCreaseRegion();
1758 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1759 EXPECT_EQ(foldCreaseRegion, nullptr);
1760
1761 MockMessageParcel::ClearAllErrorFlag();
1762 foldCreaseRegion = screenSessionManagerProxy->GetCurrentFoldCreaseRegion();
1763 EXPECT_EQ(foldCreaseRegion, nullptr);
1764 }
1765
1766 /**
1767 * @tc.name: MakeUniqueScreen
1768 * @tc.desc: MakeUniqueScreen
1769 * @tc.type: FUNC
1770 */
1771 HWTEST_F(ScreenSessionManagerProxyTest, MakeUniqueScreen, TestSize.Level1)
1772 {
1773 logMsg.clear();
1774 LOG_SetCallback(MyLogCallback);
1775 const std::vector<ScreenId> screenIds {1001, 1002, 1003};
1776 std::vector<DisplayId> displayIds;
1777
1778 MockMessageParcel::ClearAllErrorFlag();
1779 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1780 EXPECT_EQ(DMError::DM_ERROR_NULLPTR, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
1781 EXPECT_TRUE(logMsg.find("writeInterfaceToken failed") != std::string::npos);
1782
1783 MockMessageParcel::ClearAllErrorFlag();
1784 MockMessageParcel::SetWriteUint32ErrorFlag(true);
1785 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
1786 EXPECT_TRUE(logMsg.find("write screenIds size failed") != std::string::npos);
1787
1788 MockMessageParcel::ClearAllErrorFlag();
1789 EXPECT_EQ(DMError::DM_OK, screenSessionManagerProxy->MakeUniqueScreen(screenIds, displayIds));
1790 }
1791
1792 /**
1793 * @tc.name: SetClient
1794 * @tc.desc: SetClient
1795 * @tc.type: FUNC
1796 */
1797 HWTEST_F(ScreenSessionManagerProxyTest, SetClient, TestSize.Level1)
1798 {
1799 logMsg.clear();
1800 LOG_SetCallback(MyLogCallback);
1801 const sptr<IScreenSessionManagerClient> client = nullptr;
1802
1803 MockMessageParcel::ClearAllErrorFlag();
1804 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1805 screenSessionManagerProxy->SetClient(client);
1806 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1807 EXPECT_EQ(client, nullptr);
1808
1809 MockMessageParcel::ClearAllErrorFlag();
1810 screenSessionManagerProxy->SetClient(client);
1811 EXPECT_TRUE(logMsg.find("WriteRemoteObject failed") != std::string::npos);
1812 EXPECT_EQ(client, nullptr);
1813 }
1814
1815 /**
1816 * @tc.name: SwitchUser
1817 * @tc.desc: SwitchUser
1818 * @tc.type: FUNC
1819 */
1820 HWTEST_F(ScreenSessionManagerProxyTest, SwitchUser, TestSize.Level1)
1821 {
1822 logMsg.clear();
1823 LOG_SetCallback(MyLogCallback);
1824
1825 MockMessageParcel::ClearAllErrorFlag();
1826 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1827 screenSessionManagerProxy->SwitchUser();
1828 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1829
1830 MockMessageParcel::ClearAllErrorFlag();
1831 screenSessionManagerProxy->SwitchUser();
1832 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
1833 EXPECT_EQ(screenSession, nullptr);
1834 }
1835
1836 /**
1837 * @tc.name: GetScreenProperty
1838 * @tc.desc: GetScreenProperty
1839 * @tc.type: FUNC
1840 */
1841 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenProperty, TestSize.Level1)
1842 {
1843 logMsg.clear();
1844 LOG_SetCallback(MyLogCallback);
1845 ScreenId screenId = 1001;
1846
1847 MockMessageParcel::ClearAllErrorFlag();
1848 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1849 screenSessionManagerProxy->GetScreenProperty(screenId);
1850 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1851
1852 MockMessageParcel::ClearAllErrorFlag();
1853 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1854 screenSessionManagerProxy->GetScreenProperty(screenId);
1855 EXPECT_TRUE(logMsg.find("Write screenId failed") != std::string::npos);
1856
1857 MockMessageParcel::ClearAllErrorFlag();
1858 screenSessionManagerProxy->GetScreenProperty(screenId);
1859 auto screenSession = ScreenSessionManager::GetInstance().GetScreenSession(2000);
1860 EXPECT_EQ(screenSession, nullptr);
1861 }
1862
1863 /**
1864 * @tc.name: GetDisplayHookInfo
1865 * @tc.desc: GetDisplayHookInfo
1866 * @tc.type: FUNC
1867 */
1868 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayHookInfo, Function | SmallTest | Level1)
1869 {
1870 logMsg.clear();
1871 LOG_SetCallback(MyLogCallback);
1872 int32_t uid = 0;
1873 DMHookInfo hookInfo;
1874
1875 MockMessageParcel::ClearAllErrorFlag();
1876 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1877 screenSessionManagerProxy->GetDisplayHookInfo(uid, hookInfo);
1878 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1879
1880 MockMessageParcel::ClearAllErrorFlag();
1881 screenSessionManagerProxy->GetDisplayHookInfo(uid, hookInfo);
1882 EXPECT_EQ(hookInfo.height_, 0);
1883 EXPECT_EQ(hookInfo.width_, 0);
1884 }
1885
1886 /**
1887 * @tc.name: GetScreenCapture
1888 * @tc.desc: GetScreenCapture test
1889 * @tc.type: FUNC
1890 */
1891 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenCapture, TestSize.Level1)
1892 {
1893 logMsg.clear();
1894 LOG_SetCallback(MyLogCallback);
1895 ASSERT_TRUE(screenSessionManagerProxy != nullptr);
1896
1897 CaptureOption option;
1898 option.displayId_ = 0;
1899 DmErrorCode errorCode = DmErrorCode::DM_OK;
1900
1901 MockMessageParcel::ClearAllErrorFlag();
1902 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1903 auto res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
1904 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1905 EXPECT_EQ(res, nullptr);
1906
1907 MockMessageParcel::ClearAllErrorFlag();
1908 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1909 res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
1910 EXPECT_TRUE(logMsg.find("Write displayId or isNeedNotify or isNeedPointer failed") != std::string::npos);
1911 EXPECT_EQ(res, nullptr);
1912
1913 MockMessageParcel::ClearAllErrorFlag();
1914 MockMessageParcel::SetWriteBoolErrorFlag(true);
1915 res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
1916 EXPECT_TRUE(logMsg.find("Write displayId or isNeedNotify or isNeedPointer failed") != std::string::npos);
1917 EXPECT_EQ(res, nullptr);
1918
1919 MockMessageParcel::ClearAllErrorFlag();
1920 res = screenSessionManagerProxy->GetScreenCapture(option, &errorCode);
1921 EXPECT_EQ(res, nullptr);
1922 }
1923
1924 /**
1925 * @tc.name: GetPrimaryDisplayInfo
1926 * @tc.desc: GetPrimaryDisplayInfo test
1927 * @tc.type: FUNC
1928 */
1929 HWTEST_F(ScreenSessionManagerProxyTest, GetPrimaryDisplayInfo, TestSize.Level1)
1930 {
1931 logMsg.clear();
1932 LOG_SetCallback(MyLogCallback);
1933 ASSERT_TRUE(screenSessionManagerProxy != nullptr);
1934
1935 MockMessageParcel::ClearAllErrorFlag();
1936 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1937 auto res = screenSessionManagerProxy->GetPrimaryDisplayInfo();
1938 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1939 EXPECT_EQ(res, nullptr);
1940
1941 MockMessageParcel::ClearAllErrorFlag();
1942 res = screenSessionManagerProxy->GetPrimaryDisplayInfo();
1943 EXPECT_EQ(res, nullptr);
1944 }
1945
1946 /**
1947 * @tc.name: SetScreenSkipProtectedWindow
1948 * @tc.desc: SetScreenSkipProtectedWindow test
1949 * @tc.type: FUNC
1950 */
1951 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenSkipProtectedWindow, TestSize.Level1)
1952 {
1953 logMsg.clear();
1954 LOG_SetCallback(MyLogCallback);
1955 ASSERT_TRUE(screenSessionManagerProxy != nullptr);
1956
1957 const std::vector<ScreenId> screenIds = {1001, 1002};
1958 bool isEnable = true;
1959
1960 MockMessageParcel::ClearAllErrorFlag();
1961 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1962 auto res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
1963 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1964 EXPECT_EQ(res, DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED);
1965
1966 MockMessageParcel::ClearAllErrorFlag();
1967 MockMessageParcel::SetWriteBoolErrorFlag(true);
1968 res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
1969 EXPECT_TRUE(logMsg.find("Write isEnable failed") != std::string::npos);
1970 EXPECT_EQ(res, DMError::DM_ERROR_WRITE_DATA_FAILED);
1971
1972 MockMessageParcel::ClearAllErrorFlag();
1973 res = screenSessionManagerProxy->SetScreenSkipProtectedWindow(screenIds, isEnable);
1974 EXPECT_EQ(res, DMError::DM_OK);
1975 }
1976
1977 /**
1978 * @tc.name: GetDisplayCapability
1979 * @tc.desc: GetDisplayCapability test
1980 * @tc.type: FUNC
1981 */
1982 HWTEST_F(ScreenSessionManagerProxyTest, GetDisplayCapability, TestSize.Level1)
1983 {
1984 logMsg.clear();
1985 LOG_SetCallback(MyLogCallback);
1986 ASSERT_TRUE(screenSessionManagerProxy != nullptr);
1987 std::string capabilitInfo;
1988
1989 MockMessageParcel::ClearAllErrorFlag();
1990 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1991 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED,
1992 screenSessionManagerProxy->GetDisplayCapability(capabilitInfo));
1993 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
1994
1995 MockMessageParcel::ClearAllErrorFlag();
1996 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
1997 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
1998 screenSessionManagerProxy->GetDisplayCapability(capabilitInfo));
1999 } else {
2000 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
2001 screenSessionManagerProxy->GetDisplayCapability(capabilitInfo));
2002 }
2003 }
2004
2005 /**
2006 * @tc.name: SetFoldStatusExpandAndLocked
2007 * @tc.desc: SetFoldStatusExpandAndLocked
2008 * @tc.type: FUNC
2009 */
2010 HWTEST_F(ScreenSessionManagerProxyTest, SetFoldStatusExpandAndLocked, Function | SmallTest | Level1)
2011 {
2012 logMsg.clear();
2013 LOG_SetCallback(MyLogCallback);
2014
2015 MockMessageParcel::ClearAllErrorFlag();
2016 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
2017 screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
2018 EXPECT_TRUE(logMsg.find("WriteInterfaceToken Failed") != std::string::npos);
2019
2020 MockMessageParcel::ClearAllErrorFlag();
2021 MockMessageParcel::SetWriteUint32ErrorFlag(true);
2022 screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
2023 EXPECT_TRUE(logMsg.find("Write lock fold display status failed") != std::string::npos);
2024
2025 MockMessageParcel::ClearAllErrorFlag();
2026 screenSessionManagerProxy->SetFoldStatusExpandAndLocked(false);
2027 EXPECT_EQ(ScreenSessionManager::GetInstance().GetIsFoldStatusLocked(), false);
2028 }
2029
2030 /**
2031 * @tc.name: SetPrimaryDisplaySystemDpi
2032 * @tc.desc: SetPrimaryDisplaySystemDpi
2033 * @tc.type: FUNC
2034 */
2035 HWTEST_F(ScreenSessionManagerProxyTest, SetPrimaryDisplaySystemDpi, Function | SmallTest | Level1)
2036 {
2037 logMsg.clear();
2038 LOG_SetCallback(MyLogCallback);
2039 float dpi = 2.2f;
2040
2041 MockMessageParcel::ClearAllErrorFlag();
2042 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
2043 auto ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
2044 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
2045 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
2046
2047 MockMessageParcel::ClearAllErrorFlag();
2048 MockMessageParcel::SetWriteFloatErrorFlag(true);
2049 ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
2050 EXPECT_TRUE(logMsg.find("write dpi failed") != std::string::npos);
2051 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
2052
2053 MockMessageParcel::ClearAllErrorFlag();
2054 ret = screenSessionManagerProxy->SetPrimaryDisplaySystemDpi(dpi);
2055 EXPECT_EQ(DMError::DM_OK, ret);
2056 }
2057
2058 /**
2059 * @tc.name: GetScreenAreaOfDisplayArea
2060 * @tc.desc: GetScreenAreaOfDisplayArea
2061 * @tc.type: FUNC
2062 */
2063 HWTEST_F(ScreenSessionManagerProxyTest, GetScreenAreaOfDisplayArea, Function | SmallTest | Level1)
2064 {
2065 logMsg.clear();
2066 LOG_SetCallback(MyLogCallback);
2067 DisplayId displayId = 0;
2068 DMRect displayArea = DMRect::NONE();
2069 ScreenId screenId = 0;
2070 DMRect screenArea = DMRect::NONE();
2071
2072 MockMessageParcel::ClearAllErrorFlag();
2073 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
2074 auto ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
2075 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
2076 EXPECT_EQ(DMError::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
2077
2078 MockMessageParcel::ClearAllErrorFlag();
2079 MockMessageParcel::SetWriteUint64ErrorFlag(true);
2080 ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
2081 EXPECT_TRUE(logMsg.find("Write displayId failed") != std::string::npos);
2082 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
2083
2084 MockMessageParcel::ClearAllErrorFlag();
2085 MockMessageParcel::SetWriteInt32ErrorFlag(true);
2086 ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
2087 EXPECT_TRUE(logMsg.find("Write displayArea failed") != std::string::npos);
2088 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
2089
2090 MockMessageParcel::ClearAllErrorFlag();
2091 MockMessageParcel::SetWriteUint32ErrorFlag(true);
2092 ret = screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea);
2093 EXPECT_TRUE(logMsg.find("Write displayArea failed") != std::string::npos);
2094 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
2095
2096 MockMessageParcel::ClearAllErrorFlag();
2097 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2098 EXPECT_NE(DMError::DM_ERROR_IPC_FAILED,
2099 screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
2100 } else {
2101 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED,
2102 screenSessionManagerProxy->GetScreenAreaOfDisplayArea(displayId, displayArea, screenId, screenArea));
2103 }
2104 }
2105
2106 /**
2107 * @tc.name: GetPhysicalScreenIds
2108 * @tc.desc: GetPhysicalScreenIds
2109 * @tc.type: FUNC
2110 */
2111 HWTEST_F(ScreenSessionManagerProxyTest, GetPhysicalScreenIds, Function | SmallTest | Level1)
2112 {
2113 std::vector<ScreenId> screenIds;
2114 sptr<IRemoteObject> impl;
2115 auto ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
2116 EXPECT_EQ(DMError::DM_ERROR_IPC_FAILED, ret);
2117
2118 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
2119 ASSERT_NE(SingletonContainer::Get<ScreenManagerAdapter>().screenSessionManagerServiceProxy_, nullptr);
2120 impl = SingletonContainer::Get<ScreenManagerAdapter>().screenSessionManagerServiceProxy_->AsObject();
2121 } else {
2122 ASSERT_NE(SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_, nullptr);
2123 impl = SingletonContainer::Get<ScreenManagerAdapter>().displayManagerServiceProxy_->AsObject();
2124 }
2125
2126 screenSessionManagerProxy = new (std::nothrow) ScreenSessionManagerProxy(impl);
2127 ASSERT_NE(screenSessionManagerProxy, nullptr);
2128
2129 MockMessageParcel::ClearAllErrorFlag();
2130 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
2131 ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
2132 EXPECT_EQ(DMRect::DM_ERROR_WRITE_INTERFACE_TOKEN_FAILED, ret);
2133
2134 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
2135 MockMessageParcel::SetReadInt32ErrorFlag(true);
2136 ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
2137 EXPECT_EQ(DMRect::DM_ERROR_IPC_FAILED, ret);
2138
2139 MockMessageParcel::SetReadInt32ErrorFlag(false);
2140 ret = screenSessionManagerProxy->GetPhysicalScreenIds(screenIds);
2141 EXPECT_EQ(DMRect::DM_OK, ret);
2142 }
2143
2144 /**
2145 * @tc.name: SetVirtualScreenAutoRotation
2146 * @tc.desc: SetVirtualScreenAutoRotation test
2147 * @tc.type: FUNC
2148 */
2149 HWTEST_F(ScreenSessionManagerProxyTest, SetVirtualScreenAutoRotation, Function | SmallTest | Level1)
2150 {
2151 ASSERT_TRUE(screenSessionManagerProxy != nullptr);
2152 ScreenId screenId = 0;
2153 bool enable = false;
2154 auto res = screenSessionManagerProxy->SetVirtualScreenAutoRotation(screenId, enable);
2155 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, res);
2156
2157 ScreenId screenId = 111;
2158 bool enable = false;
2159
2160 auto ret = screenSessionManagerProxy->SetVirtualScreenAutoRotation(screenId, enable);
2161 EXPECT_EQ(DMError::DM_ERROR_INVALID_PARAM, ret);
2162 }
2163
2164 /**
2165 * @tc.name: SetScreenPrivacyWindowTagSwitch
2166 * @tc.desc: SetScreenPrivacyWindowTagSwitch test
2167 * @tc.type: FUNC
2168 */
2169 HWTEST_F(ScreenSessionManagerProxyTest, SetScreenPrivacyWindowTagSwitch, Function | SmallTest | Level1)
2170 {
2171 logMsg.clear();
2172 LOG_SetCallback(MyLogCallback);
2173 ScreenId mainScreenId = 0;
2174 std::vector<std::string> privacyWindowTag{"test1", "test2"};
2175
2176 MockMessageParcel::ClearAllErrorFlag();
2177 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
2178 screenSessionManagerProxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2179 EXPECT_TRUE(logMsg.find("WriteInterfaceToken failed") != std::string::npos);
2180
2181 MockMessageParcel::ClearAllErrorFlag();
2182 MockMessageParcel::SetWriteUint64ErrorFlag(true);
2183 screenSessionManagerProxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2184 EXPECT_TRUE(logMsg.find("Write screenId failed") != std::string::npos);
2185
2186 MockMessageParcel::ClearAllErrorFlag();
2187 MockMessageParcel::SetWriteBoolErrorFlag(true);
2188 screenSessionManagerProxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2189 EXPECT_TRUE(logMsg.find("Write enable failed") != std::string::npos);
2190
2191 MockMessageParcel::ClearAllErrorFlag();
2192 screenSessionManagerProxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2193 EXPECT_TRUE(logMsg.find("SendRequest failed") == std::string::npos);
2194
2195 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
2196 auto proxy = sptr<ScreenSessionManagerProxy>::MakeSptr(remoteMocker);
2197 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
2198 proxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2199 EXPECT_TRUE(logMsg.find("SendRequest failed") != std::string::npos);
2200 remoteMocker->SetRequestResult(ERR_NONE);
2201
2202 remoteMocker = nullptr;
2203 proxy = sptr<ScreenSessionManagerProxy>::MakeSptr(remoteMocker);
2204 proxy->SetScreenPrivacyWindowTagSwitch(mainScreenId, privacyWindowTag, true);
2205 EXPECT_TRUE(logMsg.find("remote is null") != std::string::npos);
2206 LOG_SetCallback(nullptr);
2207 }
2208 }
2209 }