1 /*
2 * Copyright (c) 2022-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 <gtest/gtest.h>
17 #include <iremote_broker.h>
18 #include <iremote_object_mocker.h>
19 #include <iservice_registry.h>
20 #include <system_ability_definition.h>
21
22 #include "display_manager.h"
23 #include "display_manager_adapter.h"
24 #include "display_manager_proxy.h"
25 #include "scene_board_judgement.h"
26 #include "window_scene.h"
27 #include "zidl/display_manager_agent_proxy.h"
28 #include "test/mock/mock_message_parcel.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace {
34 std::string g_logMsg;
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)35 void MyLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
36 const char* msg)
37 {
38 g_logMsg = msg;
39 }
40 }
41
42 namespace OHOS::Rosen {
43 class DisplayManagerAgentProxyTest : public testing::Test {
44 public:
45 static void SetUpTestSuite();
46 void SetUp() override;
47 sptr<DisplayManagerAgentProxy> displayManagerAgentProxy;
48 };
49
SetUpTestSuite()50 void DisplayManagerAgentProxyTest::SetUpTestSuite()
51 {
52 }
53
SetUp()54 void DisplayManagerAgentProxyTest::SetUp()
55 {
56 if (displayManagerAgentProxy) {
57 return;
58 }
59
60 sptr<IRemoteObject> impl;
61 if (SceneBoardJudgement::IsSceneBoardEnabled()) {
62 impl = sptr<IRemoteObjectMocker>::MakeSptr();
63 } else {
64 impl = sptr<IRemoteObjectMocker>::MakeSptr();
65 }
66
67 displayManagerAgentProxy = sptr<DisplayManagerAgentProxy>::MakeSptr(impl);
68 ASSERT_NE(displayManagerAgentProxy, nullptr);
69 }
70
71 /**
72 * @tc.name: NotifyDisplayPowerEvent02
73 * @tc.desc: NotifyDisplayPowerEvent
74 * @tc.type: FUNC
75 */
76 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayPowerEvent02, TestSize.Level1)
77 {
78 g_logMsg.clear();
79 LOG_SetCallback(MyLogCallback);
80 DisplayPowerEvent event = DisplayPowerEvent::DESKTOP_READY;
81 EventStatus status = EventStatus::BEGIN;
82
83 MockMessageParcel::ClearAllErrorFlag();
84 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
85 displayManagerAgentProxy->NotifyDisplayPowerEvent(event, status);
86 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
87 }
88
89 /**
90 * @tc.name: NotifyDisplayPowerEvent03
91 * @tc.desc: NotifyDisplayPowerEvent
92 * @tc.type: FUNC
93 */
94 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayPowerEvent03, TestSize.Level1)
95 {
96 g_logMsg.clear();
97 LOG_SetCallback(MyLogCallback);
98 DisplayPowerEvent event = DisplayPowerEvent::DESKTOP_READY;
99 EventStatus status = EventStatus::BEGIN;
100
101 MockMessageParcel::ClearAllErrorFlag();
102 MockMessageParcel::SetWriteUint32ErrorFlag(true);
103 displayManagerAgentProxy->NotifyDisplayPowerEvent(event, status);
104 EXPECT_TRUE(g_logMsg.find("Write event failed") != std::string::npos);
105 }
106
107 /**
108 * @tc.name: NotifyDisplayStateChanged01
109 * @tc.desc: NotifyDisplayStateChanged
110 * @tc.type: FUNC
111 */
112 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayStateChanged01, TestSize.Level1)
113 {
114 g_logMsg.clear();
115 LOG_SetCallback(MyLogCallback);
116 DisplayId displayId = 0;
117 DisplayState state = DisplayState::OFF;
118
119 MockMessageParcel::ClearAllErrorFlag();
120 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
121 displayManagerAgentProxy->NotifyDisplayStateChanged(displayId, state);
122 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
123 }
124
125 /**
126 * @tc.name: NotifyDisplayStateChanged02
127 * @tc.desc: NotifyDisplayStateChanged
128 * @tc.type: FUNC
129 */
130 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayStateChanged02, TestSize.Level1)
131 {
132 g_logMsg.clear();
133 LOG_SetCallback(MyLogCallback);
134 DisplayId displayId = 0;
135 DisplayState state = DisplayState::OFF;
136
137 MockMessageParcel::ClearAllErrorFlag();
138 MockMessageParcel::SetWriteUint32ErrorFlag(true);
139 displayManagerAgentProxy->NotifyDisplayStateChanged(displayId, state);
140 EXPECT_TRUE(g_logMsg.find("Write DisplayState failed") != std::string::npos);
141 }
142
143 /**
144 * @tc.name: NotifyCaptureStatusChanged01
145 * @tc.desc: NotifyCaptureStatusChanged
146 * @tc.type: FUNC
147 */
148 HWTEST_F(DisplayManagerAgentProxyTest, NotifyCaptureStatusChanged01, TestSize.Level1)
149 {
150 g_logMsg.clear();
151 LOG_SetCallback(MyLogCallback);
152
153 MockMessageParcel::ClearAllErrorFlag();
154 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
155 displayManagerAgentProxy->NotifyCaptureStatusChanged(false);
156 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
157 }
158
159 /**
160 * @tc.name: NotifyCaptureStatusChanged02
161 * @tc.desc: NotifyCaptureStatusChanged
162 * @tc.type: FUNC
163 */
164 HWTEST_F(DisplayManagerAgentProxyTest, NotifyCaptureStatusChanged02, TestSize.Level1)
165 {
166 g_logMsg.clear();
167 LOG_SetCallback(MyLogCallback);
168
169 MockMessageParcel::ClearAllErrorFlag();
170 MockMessageParcel::SetWriteBoolErrorFlag(true);
171 displayManagerAgentProxy->NotifyCaptureStatusChanged(false);
172 EXPECT_TRUE(g_logMsg.find("Write isCapture failed") != std::string::npos);
173 }
174
175 /**
176 * @tc.name: NotifyDisplayChangeInfoChanged
177 * @tc.desc: NotifyDisplayChangeInfoChanged
178 * @tc.type: FUNC
179 */
180 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayChangeInfoChanged, TestSize.Level1)
181 {
182 g_logMsg.clear();
183 LOG_SetCallback(MyLogCallback);
184 sptr<DisplayChangeInfo> display_change_info = sptr<DisplayChangeInfo>::MakeSptr();
185
186 MockMessageParcel::ClearAllErrorFlag();
187 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
188 displayManagerAgentProxy->NotifyDisplayChangeInfoChanged(display_change_info);
189 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
190 }
191
192 /**
193 * @tc.name: NotifyDisplayModeChanged01
194 * @tc.desc: NotifyDisplayModeChanged
195 * @tc.type: FUNC
196 */
197 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayModeChanged01, TestSize.Level1)
198 {
199 g_logMsg.clear();
200 LOG_SetCallback(MyLogCallback);
201 FoldDisplayMode mode = FoldDisplayMode::UNKNOWN;
202 MockMessageParcel::ClearAllErrorFlag();
203 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
204 displayManagerAgentProxy->NotifyDisplayModeChanged(mode);
205 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
206 }
207
208 /**
209 * @tc.name: NotifyDisplayModeChanged02
210 * @tc.desc: NotifyDisplayModeChanged
211 * @tc.type: FUNC
212 */
213 HWTEST_F(DisplayManagerAgentProxyTest, NotifyDisplayModeChanged02, TestSize.Level1)
214 {
215 g_logMsg.clear();
216 LOG_SetCallback(MyLogCallback);
217 FoldDisplayMode mode = FoldDisplayMode::UNKNOWN;
218 MockMessageParcel::ClearAllErrorFlag();
219 MockMessageParcel::SetWriteUint32ErrorFlag(true);
220 displayManagerAgentProxy->NotifyDisplayModeChanged(mode);
221 EXPECT_TRUE(g_logMsg.find("Write displayMode failed") != std::string::npos);
222 }
223 /**
224 * @tc.name: NotifyAvailableAreaChanged
225 * @tc.desc: NotifyAvailableAreaChanged
226 * @tc.type: FUNC
227 */
228 HWTEST_F(DisplayManagerAgentProxyTest, NotifyAvailableAreaChanged, TestSize.Level1)
229 {
230 g_logMsg.clear();
231 LOG_SetCallback(MyLogCallback);
232 DisplayId displayId = 0;
233 DMRect rect = {2, 2, 2, 2};
234
235 MockMessageParcel::ClearAllErrorFlag();
236 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
237 displayManagerAgentProxy->NotifyAvailableAreaChanged(rect, displayId);
238 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
239 }
240
241
242 /**
243 * @tc.name: NotifyAvailableAreaChanged02
244 * @tc.desc: NotifyAvailableAreaChanged02
245 * @tc.type: FUNC
246 */
247 HWTEST_F(DisplayManagerAgentProxyTest, NotifyAvailableAreaChanged02, TestSize.Level1)
248 {
249 g_logMsg.clear();
250 LOG_SetCallback(MyLogCallback);
251 DisplayId displayId = 0;
252 DMRect rect = {2, 2, 2, 2};
253
254 MockMessageParcel::ClearAllErrorFlag();
255 MockMessageParcel::SetWriteInt32ErrorFlag(true);
256 displayManagerAgentProxy->NotifyAvailableAreaChanged(rect, displayId);
257 EXPECT_TRUE(g_logMsg.find("Write rect failed") != std::string::npos);
258 }
259
260 /**
261 * @tc.name: OnScreenConnect02
262 * @tc.desc: OnScreenConnect02
263 * @tc.type: FUNC
264 */
265 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenConnect02, TestSize.Level1)
266 {
267 g_logMsg.clear();
268 LOG_SetCallback(MyLogCallback);
269 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
270
271 MockMessageParcel::ClearAllErrorFlag();
272 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
273 displayManagerAgentProxy->OnScreenConnect(screenInfo);
274 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
275 }
276
277 /**
278 * @tc.name: OnScreenConnect03
279 * @tc.desc: OnScreenConnect03
280 * @tc.type: FUNC
281 */
282 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenConnect03, TestSize.Level1)
283 {
284 g_logMsg.clear();
285 LOG_SetCallback(MyLogCallback);
286 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
287
288 MockMessageParcel::ClearAllErrorFlag();
289 MockMessageParcel::SetWriteParcelableErrorFlag(true);
290 displayManagerAgentProxy->OnScreenConnect(screenInfo);
291 EXPECT_TRUE(g_logMsg.find("Write ScreenInfo failed") != std::string::npos);
292 }
293
294 /**
295 * @tc.name: OnScreenDisconnect01
296 * @tc.desc: OnScreenDisconnect
297 * @tc.type: FUNC
298 */
299 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenDisconnect01, TestSize.Level1)
300 {
301 g_logMsg.clear();
302 LOG_SetCallback(MyLogCallback);
303 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
304 ScreenId screenId = 0;
305
306 MockMessageParcel::ClearAllErrorFlag();
307 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
308 displayManagerAgentProxy->OnScreenDisconnect(screenId);
309 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
310 }
311
312 /**
313 * @tc.name: OnScreenChange02
314 * @tc.desc: OnScreenChange02
315 * @tc.type: FUNC
316 */
317 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenChange02, TestSize.Level1)
318 {
319 g_logMsg.clear();
320 LOG_SetCallback(MyLogCallback);
321 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
322 ScreenChangeEvent event = ScreenChangeEvent::CHANGE_MODE;
323
324 MockMessageParcel::ClearAllErrorFlag();
325 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
326 displayManagerAgentProxy->OnScreenChange(screenInfo, event);
327 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
328 }
329
330 /**
331 * @tc.name: OnScreenChange03
332 * @tc.desc: OnScreenChange03
333 * @tc.type: FUNC
334 */
335 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenChange03, TestSize.Level1)
336 {
337 g_logMsg.clear();
338 LOG_SetCallback(MyLogCallback);
339 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
340 ScreenChangeEvent event = ScreenChangeEvent::CHANGE_MODE;
341
342 MockMessageParcel::ClearAllErrorFlag();
343 MockMessageParcel::SetWriteParcelableErrorFlag(true);
344 displayManagerAgentProxy->OnScreenChange(screenInfo, event);
345 EXPECT_TRUE(g_logMsg.find("Write screenInfo failed") != std::string::npos);
346 }
347
348 /**
349 * @tc.name: OnScreenChange04
350 * @tc.desc: OnScreenChange04
351 * @tc.type: FUNC
352 */
353 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenChange04, TestSize.Level1)
354 {
355 g_logMsg.clear();
356 LOG_SetCallback(MyLogCallback);
357 sptr<ScreenInfo> screenInfo = sptr<ScreenInfo>::MakeSptr();
358 ScreenChangeEvent event = ScreenChangeEvent::CHANGE_MODE;
359
360 MockMessageParcel::ClearAllErrorFlag();
361 MockMessageParcel::SetWriteUint32ErrorFlag(true);
362 displayManagerAgentProxy->OnScreenChange(screenInfo, event);
363 EXPECT_TRUE(g_logMsg.find("Write ScreenChangeEvent failed") != std::string::npos);
364 }
365
366 /**
367 * @tc.name: OnScreenGroupChange02
368 * @tc.desc: OnScreenGroupChange
369 * @tc.type: FUNC
370 */
371 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenGroupChange02, TestSize.Level1)
372 {
373 g_logMsg.clear();
374 LOG_SetCallback(MyLogCallback);
375 std::string trigger = " ";
376 std::vector<sptr<ScreenInfo>> screenInfos = {};
377 ScreenGroupChangeEvent event = ScreenGroupChangeEvent::CHANGE_GROUP;
378
379 MockMessageParcel::ClearAllErrorFlag();
380 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
381 displayManagerAgentProxy->OnScreenGroupChange(trigger, screenInfos, event);
382 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
383 }
384
385 /**
386 * @tc.name: OnScreenGroupChange03
387 * @tc.desc: OnScreenGroupChange
388 * @tc.type: FUNC
389 */
390 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenGroupChange03, TestSize.Level1)
391 {
392 g_logMsg.clear();
393 LOG_SetCallback(MyLogCallback);
394 std::string trigger = " ";
395 std::vector<sptr<ScreenInfo>> screenInfos = {};
396 ScreenGroupChangeEvent event = ScreenGroupChangeEvent::CHANGE_GROUP;
397
398 MockMessageParcel::ClearAllErrorFlag();
399 MockMessageParcel::SetWriteUint32ErrorFlag(true);
400 displayManagerAgentProxy->OnScreenGroupChange(trigger, screenInfos, event);
401 EXPECT_TRUE(g_logMsg.find("Write ScreenGroupChangeEvent failed") != std::string::npos);
402 }
403
404 /**
405 * @tc.name: OnDisplayCreate02
406 * @tc.desc: OnDisplayCreate02
407 * @tc.type: FUNC
408 */
409 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayCreate02, TestSize.Level1)
410 {
411 g_logMsg.clear();
412 LOG_SetCallback(MyLogCallback);
413 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
414 MockMessageParcel::ClearAllErrorFlag();
415 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
416 displayManagerAgentProxy->OnDisplayCreate(displayInfo);
417 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
418 }
419
420 /**
421 * @tc.name: OnDisplayCreate03
422 * @tc.desc: OnDisplayCreate03
423 * @tc.type: FUNC
424 */
425 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayCreate03, TestSize.Level1)
426 {
427 g_logMsg.clear();
428 LOG_SetCallback(MyLogCallback);
429 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
430
431 MockMessageParcel::ClearAllErrorFlag();
432 MockMessageParcel::SetWriteParcelableErrorFlag(true);
433 displayManagerAgentProxy->OnDisplayCreate(displayInfo);
434 EXPECT_TRUE(g_logMsg.find("Write DisplayInfo failed") != std::string::npos);
435 }
436
437 /**
438 * @tc.name: OnDisplayDestroy01
439 * @tc.desc: OnDisplayDestroy
440 * @tc.type: FUNC
441 */
442 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayDestroy01, TestSize.Level1)
443 {
444 g_logMsg.clear();
445 LOG_SetCallback(MyLogCallback);
446 DisplayId displayId = 0;
447
448 MockMessageParcel::ClearAllErrorFlag();
449 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
450 displayManagerAgentProxy->OnDisplayDestroy(displayId);
451 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
452 }
453
454 /**
455 * @tc.name: OnDisplayChange02
456 * @tc.desc: OnDisplayChange02
457 * @tc.type: FUNC
458 */
459 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayChange02, TestSize.Level1)
460 {
461 g_logMsg.clear();
462 LOG_SetCallback(MyLogCallback);
463 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
464 DisplayChangeEvent event = DisplayChangeEvent::DISPLAY_FREEZED;
465
466 MockMessageParcel::ClearAllErrorFlag();
467 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
468 displayManagerAgentProxy->OnDisplayChange(displayInfo, event);
469 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
470 }
471
472 /**
473 * @tc.name: OnDisplayChange03
474 * @tc.desc: OnDisplayChange03
475 * @tc.type: FUNC
476 */
477 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayChange03, TestSize.Level1)
478 {
479 g_logMsg.clear();
480 LOG_SetCallback(MyLogCallback);
481 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
482 DisplayChangeEvent event = DisplayChangeEvent::DISPLAY_FREEZED;
483
484 MockMessageParcel::ClearAllErrorFlag();
485 MockMessageParcel::SetWriteParcelableErrorFlag(true);
486 displayManagerAgentProxy->OnDisplayChange(displayInfo, event);
487 EXPECT_TRUE(g_logMsg.find("Write DisplayInfo failed") != std::string::npos);
488 }
489
490 /**
491 * @tc.name: OnDisplayChange04
492 * @tc.desc: OnDisplayChange04
493 * @tc.type: FUNC
494 */
495 HWTEST_F(DisplayManagerAgentProxyTest, OnDisplayChange04, TestSize.Level1)
496 {
497 g_logMsg.clear();
498 LOG_SetCallback(MyLogCallback);
499 sptr<DisplayInfo> displayInfo = sptr<DisplayInfo>::MakeSptr();
500 DisplayChangeEvent event = DisplayChangeEvent::DISPLAY_FREEZED;
501
502 MockMessageParcel::ClearAllErrorFlag();
503 MockMessageParcel::SetWriteUint32ErrorFlag(true);
504 displayManagerAgentProxy->OnDisplayChange(displayInfo, event);
505 EXPECT_TRUE(g_logMsg.find("Write DisplayChangeEvent failed") != std::string::npos);
506 }
507
508 /**
509 * @tc.name: OnScreenshot01
510 * @tc.desc: OnScreenshot
511 * @tc.type: FUNC
512 */
513 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenshot01, TestSize.Level1)
514 {
515 g_logMsg.clear();
516 LOG_SetCallback(MyLogCallback);
517 sptr<ScreenshotInfo> snapshotInfo = sptr<ScreenshotInfo>::MakeSptr();
518
519 MockMessageParcel::ClearAllErrorFlag();
520 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
521 displayManagerAgentProxy->OnScreenshot(snapshotInfo);
522 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
523 }
524
525 /**
526 * @tc.name: OnScreenshot02
527 * @tc.desc: OnScreenshot
528 * @tc.type: FUNC
529 */
530 HWTEST_F(DisplayManagerAgentProxyTest, OnScreenshot02, TestSize.Level1)
531 {
532 g_logMsg.clear();
533 LOG_SetCallback(MyLogCallback);
534 sptr<ScreenshotInfo> snapshotInfo = sptr<ScreenshotInfo>::MakeSptr();
535
536 MockMessageParcel::ClearAllErrorFlag();
537 MockMessageParcel::SetWriteParcelableErrorFlag(true);
538 displayManagerAgentProxy->OnScreenshot(snapshotInfo);
539 EXPECT_TRUE(g_logMsg.find("Write ScreenshotInfo failed") != std::string::npos);
540 }
541
542 /**
543 * @tc.name: NotifyPrivateWindowStateChanged01
544 * @tc.desc: NotifyPrivateWindowStateChanged01
545 * @tc.type: FUNC
546 */
547 HWTEST_F(DisplayManagerAgentProxyTest, NotifyPrivateWindowStateChanged01, TestSize.Level1)
548 {
549 g_logMsg.clear();
550 LOG_SetCallback(MyLogCallback);
551 bool hasPrivate = true;
552
553 MockMessageParcel::ClearAllErrorFlag();
554 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
555 displayManagerAgentProxy->NotifyPrivateWindowStateChanged(hasPrivate);
556 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
557 }
558
559 /**
560 * @tc.name: NotifyPrivateWindowStateChanged02
561 * @tc.desc: NotifyPrivateWindowStateChanged02
562 * @tc.type: FUNC
563 */
564 HWTEST_F(DisplayManagerAgentProxyTest, NotifyPrivateWindowStateChanged02, TestSize.Level1)
565 {
566 g_logMsg.clear();
567 LOG_SetCallback(MyLogCallback);
568 bool hasPrivate = true;
569
570 MockMessageParcel::ClearAllErrorFlag();
571 MockMessageParcel::SetWriteBoolErrorFlag(true);
572 displayManagerAgentProxy->NotifyPrivateWindowStateChanged(hasPrivate);
573 EXPECT_TRUE(g_logMsg.find("Write private info failed") != std::string::npos);
574 }
575
576 /**
577 * @tc.name: NotifyPrivateStateWindowListChanged01
578 * @tc.desc: NotifyPrivateStateWindowListChanged
579 * @tc.type: FUNC
580 */
581 HWTEST_F(DisplayManagerAgentProxyTest, NotifyPrivateStateWindowListChanged01, TestSize.Level1)
582 {
583 g_logMsg.clear();
584 LOG_SetCallback(MyLogCallback);
585 DisplayId id = 0;
586 std::vector<std::string> privacyWindowList{"win0", "win1"};
587
588 MockMessageParcel::ClearAllErrorFlag();
589 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
590 displayManagerAgentProxy->NotifyPrivateStateWindowListChanged(id, privacyWindowList);
591 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
592 }
593
594 /**
595 * @tc.name: NotifyFoldStatusChanged
596 * @tc.desc: NotifyFoldStatusChanged
597 * @tc.type: FUNC
598 */
599 HWTEST_F(DisplayManagerAgentProxyTest, NotifyFoldStatusChanged, TestSize.Level1)
600 {
601 g_logMsg.clear();
602 LOG_SetCallback(MyLogCallback);
603
604 MockMessageParcel::ClearAllErrorFlag();
605 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
606 displayManagerAgentProxy->NotifyFoldStatusChanged(FoldStatus::EXPAND);
607 EXPECT_TRUE(g_logMsg.find("WriteInterfaceToken failed") != std::string::npos);
608 }
609
610 /**
611 * @tc.name: NotifyFoldStatusChanged01
612 * @tc.desc: NotifyFoldStatusChanged
613 * @tc.type: FUNC
614 */
615 HWTEST_F(DisplayManagerAgentProxyTest, NotifyFoldStatusChanged01, TestSize.Level1)
616 {
617 g_logMsg.clear();
618 LOG_SetCallback(MyLogCallback);
619
620 MockMessageParcel::ClearAllErrorFlag();
621 MockMessageParcel::SetWriteUint32ErrorFlag(true);
622 displayManagerAgentProxy->NotifyFoldStatusChanged(FoldStatus::EXPAND);
623 EXPECT_TRUE(g_logMsg.find("Write foldStatus failed") != std::string::npos);
624 }
625 }