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.h>
19
20 #include "display_manager_agent_default.h"
21 #include "display_manager_proxy.h"
22 #include "iconsumer_surface.h"
23 #include "iremote_object_mocker.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS {
29 namespace Rosen {
30 using RemoteMocker = MockIRemoteObject;
31 class DisplayManagerProxyTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37 int32_t dmError_ = static_cast<int32_t>(DMError::DM_ERROR_UNKNOWN);
38 };
39
SetUpTestCase()40 void DisplayManagerProxyTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void DisplayManagerProxyTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void DisplayManagerProxyTest::SetUp()
49 {
50 }
51
TearDown()52 void DisplayManagerProxyTest::TearDown()
53 {
54 dmError_ = static_cast<int32_t>(DMError::DM_ERROR_UNKNOWN);
55 }
56
57 namespace {
58 /**
59 * @tc.name: GetDefaultDisplayInfo
60 * @tc.desc: test DisplayManagerProxy::GetDefaultDisplayInfo
61 * @tc.type: FUNC
62 */
63 HWTEST_F(DisplayManagerProxyTest, GetDefaultDisplayInfo01, TestSize.Level1)
64 {
65 DisplayManagerProxy proxy1(nullptr);
66 ASSERT_EQ(nullptr, proxy1.remoteObject_);
67 sptr<DisplayInfo> displayInfo;
68 ErrCode errCode = proxy1.GetDefaultDisplayInfo(displayInfo);
69 ASSERT_EQ(nullptr, displayInfo);
70 EXPECT_EQ(ERR_INVALID_DATA, errCode);
71
72 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
73 DisplayManagerProxy proxy2(remoteMocker);
74 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
75 errCode = proxy2.GetDefaultDisplayInfo(displayInfo);
76 ASSERT_EQ(nullptr, displayInfo);
77 EXPECT_EQ(ERR_INVALID_DATA, errCode);
78
79 remoteMocker->sendRequestResult_ = 1;
80 errCode = proxy2.GetDefaultDisplayInfo(displayInfo);
81 ASSERT_EQ(nullptr, displayInfo);
82 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
83 }
84
85 /**
86 * @tc.name: GetDisplayInfoById01
87 * @tc.desc: test DisplayManagerProxy::GetDisplayInfoById
88 * @tc.type: FUNC
89 */
90 HWTEST_F(DisplayManagerProxyTest, GetDisplayInfoById01, TestSize.Level1)
91 {
92 DisplayManagerProxy proxy1(nullptr);
93 ASSERT_EQ(nullptr, proxy1.remoteObject_);
94 sptr<DisplayInfo> displayInfo;
95 ErrCode errCode = proxy1.GetDisplayInfoById(0, displayInfo);
96 ASSERT_EQ(nullptr, displayInfo);
97 EXPECT_EQ(ERR_INVALID_DATA, errCode);
98
99 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
100 DisplayManagerProxy proxy2(remoteMocker);
101 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
102 errCode = proxy2.GetDisplayInfoById(0, displayInfo);
103 ASSERT_EQ(nullptr, displayInfo);
104 EXPECT_EQ(ERR_INVALID_DATA, errCode);
105
106 remoteMocker->sendRequestResult_ = 1;
107 errCode = proxy2.GetDisplayInfoById(0, displayInfo);
108 ASSERT_EQ(nullptr, displayInfo);
109 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
110 }
111
112 /**
113 * @tc.name: GetDisplayInfoByScreen01
114 * @tc.desc: test DisplayManagerProxy::GetDisplayInfoByScreen
115 * @tc.type: FUNC
116 */
117 HWTEST_F(DisplayManagerProxyTest, GetDisplayInfoByScreen01, TestSize.Level1)
118 {
119 DisplayManagerProxy proxy1(nullptr);
120 ASSERT_EQ(nullptr, proxy1.remoteObject_);
121 sptr<DisplayInfo> displayInfo;
122 ErrCode errCode = proxy1.GetDisplayInfoByScreen(0, displayInfo);
123 ASSERT_EQ(nullptr, displayInfo);
124 EXPECT_EQ(ERR_INVALID_DATA, errCode);
125
126 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
127 DisplayManagerProxy proxy2(remoteMocker);
128 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
129 errCode = proxy2.GetDisplayInfoByScreen(0, displayInfo);
130 ASSERT_EQ(nullptr, displayInfo);
131 EXPECT_EQ(ERR_INVALID_DATA, errCode);
132
133 remoteMocker->sendRequestResult_ = 1;
134 errCode = proxy2.GetDisplayInfoByScreen(0, displayInfo);
135 ASSERT_EQ(nullptr, displayInfo);
136 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
137 }
138
139 /**
140 * @tc.name: CreateVirtualScreen01
141 * @tc.desc: test DisplayManagerProxy::CreateVirtualScreen
142 * @tc.type: FUNC
143 */
144 HWTEST_F(DisplayManagerProxyTest, CreateVirtualScreen01, TestSize.Level1)
145 {
146 DisplayManagerProxy proxy1(nullptr);
147 ASSERT_EQ(nullptr, proxy1.remoteObject_);
148 VirtualScreenOption virtualOption1{};
149 virtualOption1.name_ = "testVirtualOption";
150 DmVirtualScreenOption dmVirtualScreenOption1(virtualOption1);
151 sptr<IRemoteObject> displayManagerAgent = new RemoteMocker();
152 ScreenId screenId = SCREEN_ID_INVALID;
153 ErrCode errCode = proxy1.CreateVirtualScreen(dmVirtualScreenOption1, displayManagerAgent, screenId);
154 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
155 EXPECT_EQ(ERR_INVALID_DATA, errCode);
156
157 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
158 DisplayManagerProxy proxy2(remoteMocker);
159 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
160 VirtualScreenOption virtualOption2{};
161 virtualOption2.name_ = "testVirtualOption";
162 DmVirtualScreenOption dmVirtualScreenOption2(virtualOption2);
163 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, nullptr, screenId);
164 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
165 EXPECT_EQ(ERR_INVALID_DATA, errCode);
166 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, displayManagerAgent, screenId);
167 EXPECT_EQ(ERR_OK, errCode);
168
169 screenId = SCREEN_ID_INVALID;
170 remoteMocker->sendRequestResult_ = 1;
171 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, displayManagerAgent, screenId);
172 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
173 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
174 }
175
176 /**
177 * @tc.name: CreateVirtualScreen02
178 * @tc.desc: test DisplayManagerProxy::CreateVirtualScreen
179 * @tc.type: FUNC
180 */
181 HWTEST_F(DisplayManagerProxyTest, CreateVirtualScreen02, TestSize.Level1)
182 {
183 DisplayManagerProxy proxy1(nullptr);
184 ASSERT_EQ(nullptr, proxy1.remoteObject_);
185 VirtualScreenOption virtualOption1{};
186 virtualOption1.name_ = "testVirtualOption";
187 DmVirtualScreenOption dmVirtualScreenOption1(virtualOption1);
188 sptr<IRemoteObject> displayManagerAgent = new RemoteMocker();
189 ScreenId screenId = SCREEN_ID_INVALID;
190 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
191 ErrCode errCode = proxy1.CreateVirtualScreen(dmVirtualScreenOption1, displayManagerAgent, screenId,
192 surface->GetProducer());
193 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
194 EXPECT_EQ(ERR_INVALID_DATA, errCode);
195
196 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
197 DisplayManagerProxy proxy2(remoteMocker);
198 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
199 VirtualScreenOption virtualOption2{};
200 virtualOption2.name_ = "testVirtualOption";
201 DmVirtualScreenOption dmVirtualScreenOption2(virtualOption2);
202 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, nullptr, screenId, surface->GetProducer());
203 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
204 EXPECT_EQ(ERR_INVALID_DATA, errCode);
205 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, displayManagerAgent, screenId, surface->GetProducer());
206 EXPECT_EQ(ERR_OK, errCode);
207
208 screenId = SCREEN_ID_INVALID;
209 remoteMocker->sendRequestResult_ = 1;
210 errCode = proxy2.CreateVirtualScreen(dmVirtualScreenOption2, displayManagerAgent, screenId, surface->GetProducer());
211 ASSERT_EQ(SCREEN_ID_INVALID, screenId);
212 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
213 }
214
215 /**
216 * @tc.name: DestroyVirtualScreen01
217 * @tc.desc: test DisplayManagerProxy::DestroyVirtualScreen
218 * @tc.type: FUNC
219 */
220 HWTEST_F(DisplayManagerProxyTest, DestroyVirtualScreen01, TestSize.Level1)
221 {
222 DisplayManagerProxy proxy1(nullptr);
223 ASSERT_EQ(nullptr, proxy1.remoteObject_);
224 ErrCode errCode = proxy1.DestroyVirtualScreen(0, dmError_);
225 EXPECT_EQ(ERR_INVALID_DATA, errCode);
226
227 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
228 DisplayManagerProxy proxy2(remoteMocker);
229 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
230 errCode = proxy2.DestroyVirtualScreen(0, dmError_);
231 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
232 EXPECT_EQ(ERR_OK, errCode);
233
234 remoteMocker->sendRequestResult_ = 1;
235 errCode = proxy2.DestroyVirtualScreen(0, dmError_);
236 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
237 }
238
239 /**
240 * @tc.name: SetVirtualScreenSurface01
241 * @tc.desc: test DisplayManagerProxy::SetVirtualScreenSurface
242 * @tc.type: FUNC
243 */
244 HWTEST_F(DisplayManagerProxyTest, SetVirtualScreenSurface01, TestSize.Level1)
245 {
246 DisplayManagerProxy proxy1(nullptr);
247 ASSERT_EQ(nullptr, proxy1.remoteObject_);
248 ErrCode errCode = proxy1.SetVirtualScreenSurface(0, nullptr, dmError_);
249 EXPECT_EQ(ERR_INVALID_DATA, errCode);
250
251 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
252 DisplayManagerProxy proxy2(remoteMocker);
253 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
254 errCode = proxy2.SetVirtualScreenSurface(0, nullptr, dmError_);
255 EXPECT_EQ(ERR_INVALID_DATA, errCode);
256
257 sptr<IConsumerSurface> surface = IConsumerSurface::Create();
258 errCode = proxy2.SetVirtualScreenSurface(0, surface->GetProducer(), dmError_);
259 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
260 EXPECT_EQ(ERR_OK, errCode);
261
262 remoteMocker->sendRequestResult_ = 1;
263 errCode = proxy2.SetVirtualScreenSurface(0, surface->GetProducer(), dmError_);
264 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
265 }
266
267 /**
268 * @tc.name: SetOrientation01
269 * @tc.desc: test DisplayManagerProxy::SetOrientation
270 * @tc.type: FUNC
271 */
272 HWTEST_F(DisplayManagerProxyTest, SetOrientation01, TestSize.Level1)
273 {
274 DisplayManagerProxy proxy1(nullptr);
275 ASSERT_EQ(nullptr, proxy1.remoteObject_);
276 ErrCode errCode = proxy1.SetOrientation(0, static_cast<uint32_t>(Orientation::VERTICAL), dmError_);
277 EXPECT_EQ(ERR_INVALID_DATA, errCode);
278
279 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
280 DisplayManagerProxy proxy2(remoteMocker);
281 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
282 errCode = proxy2.SetOrientation(0, static_cast<uint32_t>(Orientation::VERTICAL), dmError_);
283 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
284 EXPECT_EQ(ERR_OK, errCode);
285
286 remoteMocker->sendRequestResult_ = 1;
287 errCode = proxy2.SetOrientation(0, static_cast<uint32_t>(Orientation::VERTICAL), dmError_);
288 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
289 }
290
291 /**
292 * @tc.name: GetDisplaySnapshot01
293 * @tc.desc: test DisplayManagerProxy::GetDisplaySnapshot
294 * @tc.type: FUNC
295 */
296 HWTEST_F(DisplayManagerProxyTest, GetDisplaySnapshot01, TestSize.Level1)
297 {
298 DisplayManagerProxy proxy1(nullptr);
299 ASSERT_EQ(nullptr, proxy1.remoteObject_);
300 int32_t errorCode;
301 std::shared_ptr<Media::PixelMap> pixelMap;
302 ErrCode errCode = proxy1.GetDisplaySnapshot(0, errorCode, false, false, pixelMap);
303 ASSERT_EQ(nullptr, pixelMap);
304 EXPECT_EQ(ERR_INVALID_DATA, errCode);
305
306 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
307 DisplayManagerProxy proxy2(remoteMocker);
308 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
309 errCode = proxy2.GetDisplaySnapshot(0, errorCode, false, false, pixelMap);
310 ASSERT_EQ(nullptr, pixelMap);
311 EXPECT_EQ(ERR_INVALID_DATA, errCode);
312
313 remoteMocker->sendRequestResult_ = 1;
314 errCode = proxy2.GetDisplaySnapshot(0, errorCode, false, false, pixelMap);
315 ASSERT_EQ(nullptr, pixelMap);
316 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
317 }
318
319 /**
320 * @tc.name: GetScreenSupportedColorGamuts01
321 * @tc.desc: test DisplayManagerProxy::GetScreenSupportedColorGamuts
322 * @tc.type: FUNC
323 */
324 HWTEST_F(DisplayManagerProxyTest, GetScreenSupportedColorGamuts01, TestSize.Level1)
325 {
326 std::vector<uint32_t> gamutVector;
327 DisplayManagerProxy proxy1(nullptr);
328 ASSERT_EQ(nullptr, proxy1.remoteObject_);
329 ErrCode errCode = proxy1.GetScreenSupportedColorGamuts(0, gamutVector, dmError_);
330 EXPECT_EQ(ERR_INVALID_DATA, errCode);
331 gamutVector.clear();
332
333 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
334 DisplayManagerProxy proxy2(remoteMocker);
335 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
336 errCode = proxy2.GetScreenSupportedColorGamuts(0, gamutVector, dmError_);
337 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
338 EXPECT_EQ(ERR_OK, errCode);
339
340 remoteMocker->sendRequestResult_ = 1;
341 errCode = proxy2.GetScreenSupportedColorGamuts(0, gamutVector, dmError_);
342 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
343 }
344
345 /**
346 * @tc.name: GetScreenColorGamut01
347 * @tc.desc: test DisplayManagerProxy::GetScreenColorGamut
348 * @tc.type: FUNC
349 */
350 HWTEST_F(DisplayManagerProxyTest, GetScreenColorGamut01, TestSize.Level1)
351 {
352 DisplayManagerProxy proxy1(nullptr);
353 ASSERT_EQ(nullptr, proxy1.remoteObject_);
354 uint32_t screenColorGamut;
355 ErrCode errCode = proxy1.GetScreenColorGamut(0, screenColorGamut, dmError_);
356 EXPECT_EQ(ERR_INVALID_DATA, errCode);
357
358 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
359 DisplayManagerProxy proxy2(remoteMocker);
360 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
361 screenColorGamut = static_cast<uint32_t>(ScreenColorGamut::COLOR_GAMUT_ADOBE_RGB);
362 errCode = proxy2.GetScreenColorGamut(0, screenColorGamut, dmError_);
363 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
364 EXPECT_EQ(ERR_OK, errCode);
365 ASSERT_EQ(static_cast<uint32_t>(ScreenColorGamut::COLOR_GAMUT_NATIVE), screenColorGamut);
366
367 screenColorGamut = static_cast<uint32_t>(ScreenColorGamut::COLOR_GAMUT_ADOBE_RGB);
368 remoteMocker->sendRequestResult_ = 1;
369 errCode = proxy2.GetScreenColorGamut(0, screenColorGamut, dmError_);
370 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
371 ASSERT_EQ(static_cast<uint32_t>(ScreenColorGamut::COLOR_GAMUT_ADOBE_RGB), screenColorGamut);
372 }
373
374 /**
375 * @tc.name: SetScreenColorGamut01
376 * @tc.desc: test DisplayManagerProxy::SetScreenColorGamut
377 * @tc.type: FUNC
378 */
379 HWTEST_F(DisplayManagerProxyTest, SetScreenColorGamut01, TestSize.Level1)
380 {
381 DisplayManagerProxy proxy1(nullptr);
382 ASSERT_EQ(nullptr, proxy1.remoteObject_);
383 ErrCode errCode = proxy1.SetScreenColorGamut(0, 3, dmError_);
384 EXPECT_EQ(ERR_INVALID_DATA, errCode);
385
386 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
387 DisplayManagerProxy proxy2(remoteMocker);
388 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
389 errCode = proxy2.SetScreenColorGamut(0, 3, dmError_);
390 EXPECT_EQ(ERR_OK, errCode);
391
392 remoteMocker->sendRequestResult_ = 1;
393 errCode = proxy2.SetScreenColorGamut(0, 3, dmError_);
394 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
395 }
396
397 /**
398 * @tc.name: GetScreenGamutMap01
399 * @tc.desc: test DisplayManagerProxy::GetScreenGamutMap
400 * @tc.type: FUNC
401 */
402 HWTEST_F(DisplayManagerProxyTest, GetScreenGamutMap01, TestSize.Level1)
403 {
404 DisplayManagerProxy proxy1(nullptr);
405 ASSERT_EQ(nullptr, proxy1.remoteObject_);
406 auto gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
407 ErrCode errCode = proxy1.GetScreenGamutMap(0, gamutMap, dmError_);
408 EXPECT_EQ(ERR_INVALID_DATA, errCode);
409
410 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
411 DisplayManagerProxy proxy2(remoteMocker);
412 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
413 gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
414 errCode = proxy2.GetScreenGamutMap(0, gamutMap, dmError_);
415 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
416 ASSERT_EQ(static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_CONSTANT), gamutMap);
417 EXPECT_EQ(ERR_OK, errCode);
418
419 gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
420 remoteMocker->sendRequestResult_ = 1;
421 errCode = proxy2.GetScreenGamutMap(0, gamutMap, dmError_);
422 ASSERT_EQ(static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION), gamutMap);
423 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
424 }
425
426 /**
427 * @tc.name: SetScreenGamutMap01
428 * @tc.desc: test DisplayManagerProxy::SetScreenGamutMap
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DisplayManagerProxyTest, SetScreenGamutMap01, TestSize.Level1)
432 {
433 DisplayManagerProxy proxy1(nullptr);
434 ASSERT_EQ(nullptr, proxy1.remoteObject_);
435 auto gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
436 ErrCode errCode = proxy1.SetScreenGamutMap(0, gamutMap, dmError_);
437 EXPECT_EQ(ERR_INVALID_DATA, errCode);
438
439 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
440 DisplayManagerProxy proxy2(remoteMocker);
441 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
442 gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
443 errCode = proxy2.SetScreenGamutMap(0, gamutMap, dmError_);
444 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
445 ASSERT_EQ(static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION), gamutMap);
446 EXPECT_EQ(ERR_OK, errCode);
447
448 gamutMap = static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION);
449 remoteMocker->sendRequestResult_ = 1;
450 errCode = proxy2.SetScreenGamutMap(0, gamutMap, dmError_);
451 ASSERT_EQ(static_cast<uint32_t>(ScreenGamutMap::GAMUT_MAP_HDR_EXTENSION), gamutMap);
452 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
453 }
454
455 /**
456 * @tc.name: SetScreenColorTransform01
457 * @tc.desc: test DisplayManagerProxy::SetScreenColorTransform
458 * @tc.type: FUNC
459 */
460 HWTEST_F(DisplayManagerProxyTest, SetScreenColorTransform01, TestSize.Level1)
461 {
462 DisplayManagerProxy proxy1(nullptr);
463 ASSERT_EQ(nullptr, proxy1.remoteObject_);
464 ErrCode errCode = proxy1.SetScreenColorTransform(0);
465 EXPECT_EQ(ERR_INVALID_DATA, errCode);
466
467 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
468 DisplayManagerProxy proxy2(remoteMocker);
469 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
470 errCode = proxy2.SetScreenColorTransform(0);
471 EXPECT_EQ(ERR_OK, errCode);
472
473 remoteMocker->sendRequestResult_ = 1;
474 errCode = proxy2.SetScreenColorTransform(0);
475 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
476 }
477
478 /**
479 * @tc.name: RegisterDisplayManagerAgent01
480 * @tc.desc: test DisplayManagerProxy::RegisterDisplayManagerAgent
481 * @tc.type: FUNC
482 */
483 HWTEST_F(DisplayManagerProxyTest, RegisterDisplayManagerAgent01, TestSize.Level1)
484 {
485 DisplayManagerProxy proxy1(nullptr);
486 ASSERT_EQ(nullptr, proxy1.remoteObject_);
487 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
488 auto type = static_cast<uint32_t>(DisplayManagerAgentType::SCREENSHOT_EVENT_LISTENER);
489 ErrCode errCode = proxy1.RegisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
490 EXPECT_EQ(ERR_INVALID_DATA, errCode);
491
492 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
493 DisplayManagerProxy proxy2(remoteMocker);
494 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
495 errCode = proxy2.RegisterDisplayManagerAgent(nullptr, type, dmError_);
496 EXPECT_EQ(ERR_INVALID_DATA, errCode);
497 errCode = proxy2.RegisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
498 EXPECT_EQ(ERR_OK, errCode);
499
500 remoteMocker->sendRequestResult_ = 1;
501 errCode = proxy2.RegisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
502 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
503 }
504
505 /**
506 * @tc.name: UnregisterDisplayManagerAgent01
507 * @tc.desc: test DisplayManagerProxy::UnregisterDisplayManagerAgent
508 * @tc.type: FUNC
509 */
510 HWTEST_F(DisplayManagerProxyTest, UnregisterDisplayManagerAgent01, TestSize.Level1)
511 {
512 DisplayManagerProxy proxy1(nullptr);
513 ASSERT_EQ(nullptr, proxy1.remoteObject_);
514 sptr<IDisplayManagerAgent> displayManagerAgent = new DisplayManagerAgentDefault();
515 auto type = static_cast<uint32_t>(DisplayManagerAgentType::SCREENSHOT_EVENT_LISTENER);
516 ErrCode errCode = proxy1.UnregisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
517 EXPECT_EQ(ERR_INVALID_DATA, errCode);
518
519 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
520 DisplayManagerProxy proxy2(remoteMocker);
521 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
522 errCode = proxy2.UnregisterDisplayManagerAgent(nullptr, type, dmError_);
523 EXPECT_EQ(ERR_INVALID_DATA, errCode);
524 errCode = proxy2.UnregisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
525 EXPECT_EQ(ERR_OK, errCode);
526 ASSERT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError_);
527
528 remoteMocker->sendRequestResult_ = 1;
529 errCode = proxy2.UnregisterDisplayManagerAgent(displayManagerAgent, type, dmError_);
530 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
531 }
532
533 /**
534 * @tc.name: WakeUpBegin01
535 * @tc.desc: test DisplayManagerProxy::WakeUpBegin
536 * @tc.type: FUNC
537 */
538 HWTEST_F(DisplayManagerProxyTest, WakeUpBegin01, TestSize.Level1)
539 {
540 DisplayManagerProxy proxy1(nullptr);
541 ASSERT_EQ(nullptr, proxy1.remoteObject_);
542 auto reason = static_cast<uint32_t>(PowerStateChangeReason::POWER_BUTTON);
543 bool isSucc = false;
544 ErrCode errCode = proxy1.WakeUpBegin(reason, isSucc);
545 EXPECT_EQ(ERR_INVALID_DATA, errCode);
546
547 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
548 DisplayManagerProxy proxy2(remoteMocker);
549 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
550 errCode = proxy2.WakeUpBegin(reason, isSucc);
551 EXPECT_EQ(ERR_OK, errCode);
552
553 remoteMocker->sendRequestResult_ = 1;
554 errCode = proxy2.WakeUpBegin(reason, isSucc);
555 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
556 }
557
558 /**
559 * @tc.name: WakeUpEnd01
560 * @tc.desc: test DisplayManagerProxy::WakeUpEnd
561 * @tc.type: FUNC
562 */
563 HWTEST_F(DisplayManagerProxyTest, WakeUpEnd01, TestSize.Level1)
564 {
565 DisplayManagerProxy proxy1(nullptr);
566 ASSERT_EQ(nullptr, proxy1.remoteObject_);
567 bool isSucc = false;
568 ErrCode errCode = proxy1.WakeUpEnd(isSucc);
569 EXPECT_EQ(ERR_INVALID_DATA, errCode);
570
571 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
572 DisplayManagerProxy proxy2(remoteMocker);
573 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
574 errCode = proxy2.WakeUpEnd(isSucc);
575 EXPECT_EQ(ERR_OK, errCode);
576
577 remoteMocker->sendRequestResult_ = 1;
578 errCode = proxy2.WakeUpEnd(isSucc);
579 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
580 }
581
582 /**
583 * @tc.name: SuspendBegin
584 * @tc.desc: test DisplayManagerProxy::SuspendBegin
585 * @tc.type: FUNC
586 */
587 HWTEST_F(DisplayManagerProxyTest, SuspendBegin, TestSize.Level1)
588 {
589 DisplayManagerProxy proxy1(nullptr);
590 ASSERT_EQ(nullptr, proxy1.remoteObject_);
591 auto reason = static_cast<uint32_t>(PowerStateChangeReason::POWER_BUTTON);
592 bool isSucc = false;
593 ErrCode errCode = proxy1.SuspendBegin(reason, isSucc);
594 EXPECT_EQ(ERR_INVALID_DATA, errCode);
595
596 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
597 DisplayManagerProxy proxy2(remoteMocker);
598 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
599 errCode = proxy2.SuspendBegin(reason, isSucc);
600 EXPECT_EQ(ERR_OK, errCode);
601
602 remoteMocker->sendRequestResult_ = 1;
603 errCode = proxy2.SuspendBegin(reason, isSucc);
604 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
605 }
606
607 /**
608 * @tc.name: SuspendEnd
609 * @tc.desc: test DisplayManagerProxy::SuspendEnd
610 * @tc.type: FUNC
611 */
612 HWTEST_F(DisplayManagerProxyTest, SuspendEnd, TestSize.Level1)
613 {
614 DisplayManagerProxy proxy1(nullptr);
615 ASSERT_EQ(nullptr, proxy1.remoteObject_);
616 bool isSucc = false;
617 ErrCode errCode = proxy1.SuspendEnd(isSucc);
618 EXPECT_EQ(ERR_INVALID_DATA, errCode);
619
620 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
621 DisplayManagerProxy proxy2(remoteMocker);
622 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
623 errCode = proxy2.SuspendEnd(isSucc);
624 EXPECT_EQ(ERR_OK, errCode);
625
626 remoteMocker->sendRequestResult_ = 1;
627 errCode = proxy2.SuspendEnd(isSucc);
628 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
629 }
630
631 /**
632 * @tc.name: SetScreenPowerForAll
633 * @tc.desc: test DisplayManagerProxy::SetScreenPowerForAll
634 * @tc.type: FUNC
635 */
636 HWTEST_F(DisplayManagerProxyTest, SetScreenPowerForAll, TestSize.Level1)
637 {
638 DisplayManagerProxy proxy1(nullptr);
639 ASSERT_EQ(nullptr, proxy1.remoteObject_);
640 auto state = static_cast<uint32_t>(ScreenPowerState::POWER_ON);
641 auto reason = static_cast<uint32_t>(PowerStateChangeReason::POWER_BUTTON);
642 bool isSucc = false;
643 ErrCode errCode = proxy1.SetScreenPowerForAll(state, reason, isSucc);
644 EXPECT_EQ(ERR_INVALID_DATA, errCode);
645
646 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
647 DisplayManagerProxy proxy2(remoteMocker);
648 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
649 errCode = proxy2.SetScreenPowerForAll(state, reason, isSucc);
650 EXPECT_EQ(ERR_OK, errCode);
651
652 remoteMocker->sendRequestResult_ = 1;
653 errCode = proxy2.SetScreenPowerForAll(state, reason, isSucc);
654 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
655 }
656
657 /**
658 * @tc.name: SetSpecifiedScreenPower
659 * @tc.desc: test DisplayManagerProxy::SetSpecifiedScreenPower
660 * @tc.type: FUNC
661 */
662 HWTEST_F(DisplayManagerProxyTest, SetSpecifiedScreenPower, TestSize.Level1)
663 {
664 DisplayManagerProxy proxy1(nullptr);
665 ASSERT_EQ(nullptr, proxy1.remoteObject_);
666 auto state = static_cast<uint32_t>(ScreenPowerState::POWER_ON);
667 auto reason = static_cast<uint32_t>(PowerStateChangeReason::POWER_BUTTON);
668 bool isSucc = false;
669 ErrCode errCode = proxy1.SetSpecifiedScreenPower(0, state, reason, isSucc);
670 EXPECT_EQ(ERR_INVALID_DATA, errCode);
671
672 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
673 DisplayManagerProxy proxy2(remoteMocker);
674 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
675 errCode = proxy2.SetSpecifiedScreenPower(0, state, reason, isSucc);
676 EXPECT_EQ(ERR_OK, errCode);
677
678 remoteMocker->sendRequestResult_ = 1;
679 errCode = proxy2.SetSpecifiedScreenPower(0, state, reason, isSucc);
680 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
681 }
682
683 /**
684 * @tc.name: SetDisplayState
685 * @tc.desc: test DisplayManagerProxy::SetDisplayState
686 * @tc.type: FUNC
687 */
688 HWTEST_F(DisplayManagerProxyTest, SetDisplayState, TestSize.Level1)
689 {
690 DisplayManagerProxy proxy1(nullptr);
691 ASSERT_EQ(nullptr, proxy1.remoteObject_);
692 auto state = static_cast<uint32_t>(DisplayState::UNKNOWN);
693 bool isSucc = false;
694 ErrCode errCode = proxy1.SetDisplayState(state, isSucc);
695 EXPECT_EQ(ERR_INVALID_DATA, errCode);
696
697 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
698 DisplayManagerProxy proxy2(remoteMocker);
699 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
700 errCode = proxy2.SetDisplayState(state, isSucc);
701 EXPECT_EQ(ERR_OK, errCode);
702
703 remoteMocker->sendRequestResult_ = 1;
704 errCode = proxy2.SetDisplayState(state, isSucc);
705 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
706 }
707
708 /**
709 * @tc.name: AddSurfaceNodeToDisplay
710 * @tc.desc: test DisplayManagerProxy::AddSurfaceNodeToDisplay
711 * @tc.type: FUNC
712 */
713 HWTEST_F(DisplayManagerProxyTest, AddSurfaceNodeToDisplay, TestSize.Level1)
714 {
715 DisplayManagerProxy proxy1(nullptr);
716 ASSERT_EQ(nullptr, proxy1.remoteObject_);
717 RSSurfaceNodeConfig rsSurfaceNodeConfig;
718 std::shared_ptr<RSSurfaceNode> surfaceNode = std::make_shared<RSSurfaceNode>(rsSurfaceNodeConfig, true, 0);
719 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(surfaceNode);
720 ErrCode errCode = proxy1.AddSurfaceNodeToDisplay(0, dmRsSurfaceNode, dmError_);
721 EXPECT_EQ(ERR_INVALID_DATA, errCode);
722
723 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
724 DisplayManagerProxy proxy2(remoteMocker);
725 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
726 errCode = proxy2.AddSurfaceNodeToDisplay(0, dmRsSurfaceNode, dmError_);
727 EXPECT_EQ(ERR_OK, errCode);
728
729 remoteMocker->sendRequestResult_ = 1;
730 errCode = proxy2.AddSurfaceNodeToDisplay(0, dmRsSurfaceNode, dmError_);
731 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
732 }
733
734 /**
735 * @tc.name: RemoveSurfaceNodeFromDisplay
736 * @tc.desc: test DisplayManagerProxy::RemoveSurfaceNodeFromDisplay
737 * @tc.type: FUNC
738 */
739 HWTEST_F(DisplayManagerProxyTest, RemoveSurfaceNodeFromDisplay, TestSize.Level1)
740 {
741 DisplayManagerProxy proxy1(nullptr);
742 ASSERT_EQ(nullptr, proxy1.remoteObject_);
743 RSSurfaceNodeConfig rsSurfaceNodeConfig;
744 std::shared_ptr<RSSurfaceNode> surfaceNode = std::make_shared<RSSurfaceNode>(rsSurfaceNodeConfig, true, 0);
745 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(surfaceNode);
746 ErrCode errCode = proxy1.RemoveSurfaceNodeFromDisplay(0, dmRsSurfaceNode, dmError_);
747 EXPECT_EQ(ERR_INVALID_DATA, errCode);
748
749 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
750 DisplayManagerProxy proxy2(remoteMocker);
751 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
752 errCode = proxy2.RemoveSurfaceNodeFromDisplay(0, dmRsSurfaceNode, dmError_);
753 EXPECT_EQ(ERR_OK, errCode);
754
755 remoteMocker->sendRequestResult_ = 1;
756 errCode = proxy2.RemoveSurfaceNodeFromDisplay(0, dmRsSurfaceNode, dmError_);
757 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
758 }
759
760 /**
761 * @tc.name: HasPrivateWindow
762 * @tc.desc: test DisplayManagerProxy::HasPrivateWindow
763 * @tc.type: FUNC
764 */
765 HWTEST_F(DisplayManagerProxyTest, HasPrivateWindow, TestSize.Level1)
766 {
767 DisplayManagerProxy proxy1(nullptr);
768 ASSERT_EQ(nullptr, proxy1.remoteObject_);
769 bool hasPrivateWindow = false;
770 ErrCode errCode = proxy1.HasPrivateWindow(0, hasPrivateWindow, dmError_);
771 EXPECT_EQ(ERR_INVALID_DATA, errCode);
772
773 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
774 DisplayManagerProxy proxy2(remoteMocker);
775 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
776 errCode = proxy2.HasPrivateWindow(0, hasPrivateWindow, dmError_);
777 EXPECT_EQ(ERR_OK, errCode);
778
779 remoteMocker->sendRequestResult_ = 1;
780 errCode = proxy2.HasPrivateWindow(0, hasPrivateWindow, dmError_);
781 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
782 }
783
784 /**
785 * @tc.name: SetFreeze
786 * @tc.desc: test DisplayManagerProxy::SetFreeze
787 * @tc.type: FUNC
788 */
789 HWTEST_F(DisplayManagerProxyTest, SetFreeze, TestSize.Level1)
790 {
791 DisplayManagerProxy proxy1(nullptr);
792 ASSERT_EQ(nullptr, proxy1.remoteObject_);
793 std::vector<uint64_t> displayIds;
794 bool isFreeze = true;
795 bool isSucc = false;
796 ErrCode errCode = proxy1.SetFreeze(displayIds, isFreeze, isSucc);
797 EXPECT_EQ(ERR_INVALID_DATA, errCode);
798
799 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
800 DisplayManagerProxy proxy2(remoteMocker);
801 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
802 errCode = proxy2.SetFreeze(displayIds, isFreeze, isSucc);
803 EXPECT_EQ(ERR_OK, errCode);
804
805 remoteMocker->sendRequestResult_ = 1;
806 errCode = proxy2.SetFreeze(displayIds, isFreeze, isSucc);
807 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
808 }
809
810 /**
811 * @tc.name: GetDisplayState
812 * @tc.desc: test DisplayManagerProxy::GetDisplayState
813 * @tc.type: FUNC
814 */
815 HWTEST_F(DisplayManagerProxyTest, GetDisplayState, TestSize.Level1)
816 {
817 DisplayManagerProxy proxy1(nullptr);
818 ASSERT_EQ(nullptr, proxy1.remoteObject_);
819 DisplayId displayId = 0;
820 uint32_t displayState = 0;
821 ErrCode errCode = proxy1.GetDisplayState(displayId, displayState);
822 EXPECT_EQ(ERR_INVALID_DATA, errCode);
823
824 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
825 DisplayManagerProxy proxy2(remoteMocker);
826 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
827 errCode = proxy2.GetDisplayState(displayId, displayState);
828 EXPECT_EQ(ERR_OK, errCode);
829
830 remoteMocker->sendRequestResult_ = 1;
831 errCode = proxy2.GetDisplayState(displayId, displayState);
832 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
833 }
834
835 /**
836 * @tc.name: GetScreenPower
837 * @tc.desc: test DisplayManagerProxy::GetScreenPower
838 * @tc.type: FUNC
839 */
840 HWTEST_F(DisplayManagerProxyTest, GetScreenPower, TestSize.Level1)
841 {
842 DisplayManagerProxy proxy1(nullptr);
843 ASSERT_EQ(nullptr, proxy1.remoteObject_);
844 DisplayId displayId = 0;
845 uint32_t screenPowerState = 0;
846 ErrCode errCode = proxy1.GetScreenPower(displayId, screenPowerState);
847 EXPECT_EQ(ERR_INVALID_DATA, errCode);
848
849 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
850 DisplayManagerProxy proxy2(remoteMocker);
851 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
852 errCode = proxy2.GetScreenPower(displayId, screenPowerState);
853 EXPECT_EQ(ERR_OK, errCode);
854
855 remoteMocker->sendRequestResult_ = 1;
856 errCode = proxy2.GetScreenPower(displayId, screenPowerState);
857 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
858 }
859
860 /**
861 * @tc.name: GetAllDisplayIds
862 * @tc.desc: test DisplayManagerProxy::GetAllDisplayIds
863 * @tc.type: FUNC
864 */
865 HWTEST_F(DisplayManagerProxyTest, GetAllDisplayIds, TestSize.Level1)
866 {
867 DisplayManagerProxy proxy1(nullptr);
868 ASSERT_EQ(nullptr, proxy1.remoteObject_);
869 std::vector<DisplayId> displayIds;
870 ErrCode errCode = proxy1.GetAllDisplayIds(displayIds);
871 EXPECT_EQ(ERR_INVALID_DATA, errCode);
872
873 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
874 DisplayManagerProxy proxy2(remoteMocker);
875 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
876 errCode = proxy2.GetAllDisplayIds(displayIds);
877 EXPECT_EQ(ERR_OK, errCode);
878
879 remoteMocker->sendRequestResult_ = 1;
880 errCode = proxy2.GetAllDisplayIds(displayIds);
881 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
882 }
883
884 /**
885 * @tc.name: GetCutoutInfo
886 * @tc.desc: test DisplayManagerProxy::GetCutoutInfo
887 * @tc.type: FUNC
888 */
889 HWTEST_F(DisplayManagerProxyTest, GetCutoutInfo, TestSize.Level1)
890 {
891 DisplayManagerProxy proxy1(nullptr);
892 ASSERT_EQ(nullptr, proxy1.remoteObject_);
893 sptr<CutoutInfo> cutoutInfo;
894 ErrCode errCode = proxy1.GetCutoutInfo(0, cutoutInfo);
895 EXPECT_EQ(ERR_INVALID_DATA, errCode);
896
897 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
898 DisplayManagerProxy proxy2(remoteMocker);
899 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
900 errCode = proxy2.GetCutoutInfo(0, cutoutInfo);
901 EXPECT_EQ(ERR_INVALID_DATA, errCode);
902
903 remoteMocker->sendRequestResult_ = 1;
904 errCode = proxy2.GetCutoutInfo(0, cutoutInfo);
905 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
906 }
907
908 /**
909 * @tc.name: NotifyDisplayEvent
910 * @tc.desc: test DisplayManagerProxy::NotifyDisplayEvent
911 * @tc.type: FUNC
912 */
913 HWTEST_F(DisplayManagerProxyTest, NotifyDisplayEvent, TestSize.Level1)
914 {
915 DisplayManagerProxy proxy1(nullptr);
916 ASSERT_EQ(nullptr, proxy1.remoteObject_);
917 auto event = static_cast<uint32_t>(DisplayEvent::UNLOCK);
918 ErrCode errCode = proxy1.NotifyDisplayEvent(event);
919 EXPECT_EQ(ERR_INVALID_DATA, errCode);
920
921 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
922 DisplayManagerProxy proxy2(remoteMocker);
923 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
924 errCode = proxy2.NotifyDisplayEvent(event);
925 EXPECT_EQ(ERR_OK, errCode);
926
927 remoteMocker->sendRequestResult_ = 1;
928 errCode = proxy2.NotifyDisplayEvent(event);
929 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
930 }
931
932 /**
933 * @tc.name: MakeMirror
934 * @tc.desc: test DisplayManagerProxy::MakeMirror
935 * @tc.type: FUNC
936 */
937 HWTEST_F(DisplayManagerProxyTest, MakeMirror, TestSize.Level1)
938 {
939 ScreenId mainScreenId = 0;
940 std::vector<ScreenId> mirrorScreenId;
941 mirrorScreenId.emplace_back(1001);
942 ScreenId screenGroupId = 0;
943 DisplayManagerProxy proxy1(nullptr);
944 ASSERT_EQ(nullptr, proxy1.remoteObject_);
945 ErrCode errCode = proxy1.MakeMirror(mainScreenId, mirrorScreenId, screenGroupId, dmError_);
946 EXPECT_EQ(ERR_INVALID_DATA, errCode);
947
948 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
949 DisplayManagerProxy proxy2(remoteMocker);
950 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
951 errCode = proxy2.MakeMirror(mainScreenId, mirrorScreenId, screenGroupId, dmError_);
952 EXPECT_EQ(ERR_OK, errCode);
953
954 remoteMocker->sendRequestResult_ = 1;
955 errCode = proxy2.MakeMirror(mainScreenId, mirrorScreenId, screenGroupId, dmError_);
956 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
957 }
958
959 /**
960 * @tc.name: StopMirror
961 * @tc.desc: test DisplayManagerProxy::StopMirror
962 * @tc.type: FUNC
963 */
964 HWTEST_F(DisplayManagerProxyTest, StopMirror, TestSize.Level1)
965 {
966 std::vector<ScreenId> mirrorScreenId;
967 mirrorScreenId.emplace_back(1001);
968 DisplayManagerProxy proxy1(nullptr);
969 ASSERT_EQ(nullptr, proxy1.remoteObject_);
970 ErrCode errCode = proxy1.StopMirror(mirrorScreenId, dmError_);
971 EXPECT_EQ(ERR_INVALID_DATA, errCode);
972
973 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
974 DisplayManagerProxy proxy2(remoteMocker);
975 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
976 errCode = proxy2.StopMirror(mirrorScreenId, dmError_);
977 EXPECT_EQ(ERR_OK, errCode);
978
979 remoteMocker->sendRequestResult_ = 1;
980 errCode = proxy2.StopMirror(mirrorScreenId, dmError_);
981 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
982 }
983
984 /**
985 * @tc.name: GetScreenInfoById
986 * @tc.desc: test DisplayManagerProxy::GetScreenInfoById
987 * @tc.type: FUNC
988 */
989 HWTEST_F(DisplayManagerProxyTest, GetScreenInfoById, TestSize.Level1)
990 {
991 ScreenId screenId = 0;
992 sptr<ScreenInfo> screenInfo;
993 DisplayManagerProxy proxy1(nullptr);
994 ASSERT_EQ(nullptr, proxy1.remoteObject_);
995 ErrCode errCode = proxy1.GetScreenInfoById(screenId, screenInfo);
996 EXPECT_EQ(ERR_INVALID_DATA, errCode);
997
998 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
999 DisplayManagerProxy proxy2(remoteMocker);
1000 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1001 errCode = proxy2.GetScreenInfoById(screenId, screenInfo);
1002 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1003
1004 remoteMocker->sendRequestResult_ = 1;
1005 errCode = proxy2.GetScreenInfoById(screenId, screenInfo);
1006 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1007 }
1008
1009 /**
1010 * @tc.name: GetScreenGroupInfoById
1011 * @tc.desc: test DisplayManagerProxy::GetScreenGroupInfoById
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(DisplayManagerProxyTest, GetScreenGroupInfoById, TestSize.Level1)
1015 {
1016 ScreenId screenId = 0;
1017 DisplayManagerProxy proxy1(nullptr);
1018 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1019 sptr<ScreenGroupInfo> screenGroupInfo;
1020 ErrCode errCode = proxy1.GetScreenGroupInfoById(screenId, screenGroupInfo);
1021 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1022
1023 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1024 DisplayManagerProxy proxy2(remoteMocker);
1025 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1026 errCode = proxy2.GetScreenGroupInfoById(screenId, screenGroupInfo);
1027 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1028
1029 remoteMocker->sendRequestResult_ = 1;
1030 errCode = proxy2.GetScreenGroupInfoById(screenId, screenGroupInfo);
1031 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1032 }
1033
1034 /**
1035 * @tc.name: GetAllScreenInfos
1036 * @tc.desc: test DisplayManagerProxy::GetAllScreenInfos
1037 * @tc.type: FUNC
1038 */
1039 HWTEST_F(DisplayManagerProxyTest, GetAllScreenInfos, TestSize.Level1)
1040 {
1041 std::vector<sptr<ScreenInfo>> screenInfos;
1042 DisplayManagerProxy proxy1(nullptr);
1043 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1044 ErrCode errCode = proxy1.GetAllScreenInfos(screenInfos, dmError_);
1045 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1046
1047 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1048 DisplayManagerProxy proxy2(remoteMocker);
1049 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1050 errCode = proxy2.GetAllScreenInfos(screenInfos, dmError_);
1051 EXPECT_EQ(ERR_OK, errCode);
1052
1053 remoteMocker->sendRequestResult_ = 1;
1054 errCode = proxy2.GetAllScreenInfos(screenInfos, dmError_);
1055 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1056 }
1057
1058 /**
1059 * @tc.name: MakeExpand
1060 * @tc.desc: test DisplayManagerProxy::MakeExpand
1061 * @tc.type: FUNC
1062 */
1063 HWTEST_F(DisplayManagerProxyTest, MakeExpand, TestSize.Level1)
1064 {
1065 ScreenId screenId_ = 0;
1066 std::vector<ScreenId> screenId;
1067 screenId.push_back(screenId_);
1068 std::vector<Point> startPoint;
1069 Point point{0, 0};
1070 startPoint.push_back(point);
1071 ScreenId screenGroupId = 0;
1072 DisplayManagerProxy proxy1(nullptr);
1073 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1074 ErrCode errCode = proxy1.MakeExpand(screenId, startPoint, screenGroupId, dmError_);
1075 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1076
1077 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1078 DisplayManagerProxy proxy2(remoteMocker);
1079 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1080 errCode = proxy2.MakeExpand(screenId, startPoint, screenGroupId, dmError_);
1081 EXPECT_EQ(ERR_OK, errCode);
1082
1083 remoteMocker->sendRequestResult_ = 1;
1084 errCode = proxy2.MakeExpand(screenId, startPoint, screenGroupId, dmError_);
1085 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1086 }
1087
1088 /**
1089 * @tc.name: StopExpand
1090 * @tc.desc: test DisplayManagerProxy::StopExpand
1091 * @tc.type: FUNC
1092 */
1093 HWTEST_F(DisplayManagerProxyTest, StopExpand, TestSize.Level1)
1094 {
1095 std::vector<ScreenId> expandScreenIds;
1096 expandScreenIds.push_back(0);
1097 DisplayManagerProxy proxy1(nullptr);
1098 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1099 ErrCode errCode = proxy1.StopExpand(expandScreenIds, dmError_);
1100 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1101
1102 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1103 DisplayManagerProxy proxy2(remoteMocker);
1104 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1105 errCode = proxy2.StopExpand(expandScreenIds, dmError_);
1106 EXPECT_EQ(ERR_OK, errCode);
1107
1108 remoteMocker->sendRequestResult_ = 1;
1109 errCode = proxy2.StopExpand(expandScreenIds, dmError_);
1110 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1111 }
1112
1113 /**
1114 * @tc.name: RemoveVirtualScreenFromGroup
1115 * @tc.desc: test DisplayManagerProxy::RemoveVirtualScreenFromGroup
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(DisplayManagerProxyTest, RemoveVirtualScreenFromGroup, TestSize.Level1)
1119 {
1120 std::vector<ScreenId> screens;
1121 screens.push_back(0);
1122 DisplayManagerProxy proxy1(nullptr);
1123 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1124 ErrCode errCode = proxy1.RemoveVirtualScreenFromGroup(screens);
1125 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1126
1127 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1128 DisplayManagerProxy proxy2(remoteMocker);
1129 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1130 errCode = proxy2.RemoveVirtualScreenFromGroup(screens);
1131 EXPECT_EQ(ERR_OK, errCode);
1132
1133 remoteMocker->sendRequestResult_ = 1;
1134 errCode = proxy2.RemoveVirtualScreenFromGroup(screens);
1135 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1136 }
1137
1138 /**
1139 * @tc.name: SetScreenActiveMode
1140 * @tc.desc: test DisplayManagerProxy::SetScreenActiveMode
1141 * @tc.type: FUNC
1142 */
1143 HWTEST_F(DisplayManagerProxyTest, SetScreenActiveMode, TestSize.Level1)
1144 {
1145 ScreenId screenId = 0;
1146 DisplayManagerProxy proxy1(nullptr);
1147 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1148 ErrCode errCode = proxy1.SetScreenActiveMode(screenId, 0, dmError_);
1149 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1150
1151 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1152 DisplayManagerProxy proxy2(remoteMocker);
1153 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1154 errCode = proxy2.SetScreenActiveMode(screenId, 0, dmError_);
1155 EXPECT_EQ(ERR_OK, errCode);
1156
1157 remoteMocker->sendRequestResult_ = 1;
1158 errCode = proxy2.SetScreenActiveMode(screenId, 0, dmError_);
1159 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1160 }
1161
1162 /**
1163 * @tc.name: SetVirtualPixelRatio
1164 * @tc.desc: test DisplayManagerProxy::SetVirtualPixelRatio
1165 * @tc.type: FUNC
1166 */
1167 HWTEST_F(DisplayManagerProxyTest, SetVirtualPixelRatio, TestSize.Level1)
1168 {
1169 ScreenId screenId = 0;
1170 float virtualPixelRatio = 0;
1171 DisplayManagerProxy proxy1(nullptr);
1172 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1173 ErrCode errCode = proxy1.SetVirtualPixelRatio(screenId, virtualPixelRatio, dmError_);
1174 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1175
1176 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1177 DisplayManagerProxy proxy2(remoteMocker);
1178 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1179 errCode = proxy2.SetVirtualPixelRatio(screenId, virtualPixelRatio, dmError_);
1180 EXPECT_EQ(ERR_OK, errCode);
1181
1182 remoteMocker->sendRequestResult_ = 1;
1183 errCode = proxy2.SetVirtualPixelRatio(screenId, virtualPixelRatio, dmError_);
1184 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1185 }
1186
1187 /**
1188 * @tc.name: SetResolution
1189 * @tc.desc: test DisplayManagerProxy::SetResolution
1190 * @tc.type: FUNC
1191 */
1192 HWTEST_F(DisplayManagerProxyTest, SetResolution, TestSize.Level1)
1193 {
1194 ScreenId screenId = 0;
1195 DisplayManagerProxy proxy1(nullptr);
1196 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1197 ErrCode errCode = proxy1.SetResolution(screenId, 50, 100, 1.00, dmError_);
1198 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1199
1200 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1201 DisplayManagerProxy proxy2(remoteMocker);
1202 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1203 errCode = proxy2.SetResolution(screenId, 50, 100, 1.00, dmError_);
1204 EXPECT_EQ(ERR_OK, errCode);
1205
1206 remoteMocker->sendRequestResult_ = 1;
1207 errCode = proxy2.SetResolution(screenId, 50, 100, 1.00, dmError_);
1208 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1209 }
1210
1211 /**
1212 * @tc.name: GetDensityInCurResolution
1213 * @tc.desc: test DisplayManagerProxy::GetDensityInCurResolution
1214 * @tc.type: FUNC
1215 */
1216 HWTEST_F(DisplayManagerProxyTest, GetDensityInCurResolution, TestSize.Level1)
1217 {
1218 ScreenId screenId = 0;
1219 float virtualPixelRatio = 0;
1220 DisplayManagerProxy proxy1(nullptr);
1221 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1222 ErrCode errCode = proxy1.GetDensityInCurResolution(screenId, virtualPixelRatio, dmError_);
1223 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1224
1225 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1226 DisplayManagerProxy proxy2(remoteMocker);
1227 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1228 errCode = proxy2.GetDensityInCurResolution(screenId, virtualPixelRatio, dmError_);
1229 EXPECT_EQ(ERR_OK, errCode);
1230
1231 remoteMocker->sendRequestResult_ = 1;
1232 errCode = proxy2.GetDensityInCurResolution(screenId, virtualPixelRatio, dmError_);
1233 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1234 }
1235
1236 /**
1237 * @tc.name: IsScreenRotationLocked
1238 * @tc.desc: test DisplayManagerProxy::IsScreenRotationLocked
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(DisplayManagerProxyTest, IsScreenRotationLocked, TestSize.Level1)
1242 {
1243 bool isLocked = true;
1244 DisplayManagerProxy proxy1(nullptr);
1245 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1246 ErrCode errCode = proxy1.IsScreenRotationLocked(isLocked, dmError_);
1247 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1248
1249 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1250 DisplayManagerProxy proxy2(remoteMocker);
1251 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1252 errCode = proxy2.IsScreenRotationLocked(isLocked, dmError_);
1253 EXPECT_EQ(ERR_OK, errCode);
1254
1255 remoteMocker->sendRequestResult_ = 1;
1256 errCode = proxy2.IsScreenRotationLocked(isLocked, dmError_);
1257 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1258 }
1259
1260 /**
1261 * @tc.name: SetScreenRotationLocked
1262 * @tc.desc: test DisplayManagerProxy::SetScreenRotationLocked
1263 * @tc.type: FUNC
1264 */
1265 HWTEST_F(DisplayManagerProxyTest, SetScreenRotationLocked, TestSize.Level1)
1266 {
1267 bool isLocked = true;
1268 DisplayManagerProxy proxy1(nullptr);
1269 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1270 ErrCode errCode = proxy1.SetScreenRotationLocked(isLocked, dmError_);
1271 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1272
1273 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1274 DisplayManagerProxy proxy2(remoteMocker);
1275 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1276 errCode = proxy2.SetScreenRotationLocked(isLocked, dmError_);
1277 EXPECT_EQ(ERR_OK, errCode);
1278
1279 remoteMocker->sendRequestResult_ = 1;
1280 errCode = proxy2.SetScreenRotationLocked(isLocked, dmError_);
1281 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1282 }
1283
1284 /**
1285 * @tc.name: SetScreenRotationLockedFromJs
1286 * @tc.desc: test DisplayManagerProxy::SetScreenRotationLockedFromJs
1287 * @tc.type: FUNC
1288 */
1289 HWTEST_F(DisplayManagerProxyTest, SetScreenRotationLockedFromJs, TestSize.Level1)
1290 {
1291 bool isLocked = true;
1292 DisplayManagerProxy proxy1(nullptr);
1293 ASSERT_EQ(nullptr, proxy1.remoteObject_);
1294 ErrCode errCode = proxy1.SetScreenRotationLockedFromJs(isLocked, dmError_);
1295 EXPECT_EQ(ERR_INVALID_DATA, errCode);
1296
1297 sptr<RemoteMocker> remoteMocker = new RemoteMocker();
1298 DisplayManagerProxy proxy2(remoteMocker);
1299 ASSERT_EQ(static_cast<sptr<IRemoteObject>>(remoteMocker), proxy2.remoteObject_);
1300 errCode = proxy2.SetScreenRotationLockedFromJs(isLocked, dmError_);
1301 EXPECT_EQ(ERR_OK, errCode);
1302
1303 remoteMocker->sendRequestResult_ = 1;
1304 errCode = proxy2.SetScreenRotationLockedFromJs(isLocked, dmError_);
1305 EXPECT_EQ(remoteMocker->sendRequestResult_, errCode);
1306 }
1307 }
1308 } // namespace Rosen
1309 } // namespace OHOS
1310