1 /*
2 * Copyright (c) 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
18 #include "common_test_utils.h"
19 #include "display_manager_adapter.h"
20 #include "display_manager_config.h"
21 #include "display_manager_ipc_service.h"
22 #include "mock_rs_display_node.h"
23 #include "scene_board_judgement.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27
28 namespace OHOS::Rosen {
29
30 class DisplayManagerIpcServiceTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34
35 static std::unique_ptr<DisplayManagerIpcService> dms_;
36 };
37
38 std::unique_ptr<DisplayManagerIpcService> DisplayManagerIpcServiceTest::dms_ = nullptr;
39
SetUpTestCase()40 void DisplayManagerIpcServiceTest::SetUpTestCase()
41 {
42 dms_ = std::make_unique<DisplayManagerIpcService>();
43 dms_->displayManagerService_.abstractScreenController_->defaultRsScreenId_ = 0;
44 dms_->displayManagerService_.abstractScreenController_->screenIdManager_.rs2DmsScreenIdMap_.clear();
45 dms_->displayManagerService_.abstractScreenController_->screenIdManager_.rs2DmsScreenIdMap_ = {
46 { 0, 0 }
47 };
48 dms_->displayManagerService_.abstractScreenController_->screenIdManager_.dms2RsScreenIdMap_.clear();
49 dms_->displayManagerService_.abstractScreenController_->screenIdManager_.dms2RsScreenIdMap_ = {
50 { 0, 0 }
51 };
52
53 const char* perms[] = {
54 "ohos.permission.CAPTURE_SCREEN"
55 };
56 CommonTestUtils::SetAceessTokenPermission("DisplayManagerIpcServiceTest", perms, 1);
57 }
58
TearDownTestCase()59 void DisplayManagerIpcServiceTest::TearDownTestCase()
60 {
61 dms_ = nullptr;
62 }
63
64 namespace {
65
66 /**
67 * @tc.name: Dump
68 * @tc.desc: DMS dump
69 * @tc.type: FUNC
70 */
71 HWTEST_F(DisplayManagerIpcServiceTest, Dump, TestSize.Level1)
72 {
73 std::vector<std::u16string> args;
74 EXPECT_EQ(static_cast<int>(DMError::DM_ERROR_INVALID_PARAM), dms_->Dump(-1, args));
75 }
76
77 /**
78 * @tc.name: HasPrivateWindow
79 * @tc.desc: DMS has private window
80 * @tc.type: FUNC
81 */
82 HWTEST_F(DisplayManagerIpcServiceTest, HasPrivateWindow, TestSize.Level1)
83 {
84 bool hasPrivateWindow = false;
85 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_.clear();
86 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_ = {
87 { 1, nullptr }
88 };
89 int32_t dmError;
90 ASSERT_EQ(ERR_OK, dms_->HasPrivateWindow(0, hasPrivateWindow, dmError));
91 EXPECT_FALSE(hasPrivateWindow);
92 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
93
94 dms_->displayManagerService_.RegisterWindowInfoQueriedListener(nullptr);
95 ASSERT_EQ(ERR_OK, dms_->HasPrivateWindow(1, hasPrivateWindow, dmError));
96 EXPECT_FALSE(hasPrivateWindow);
97 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
98 }
99
100 /**
101 * @tc.name: GetScreenInfoById01
102 * @tc.desc: DMS get screen info by id
103 * @tc.type: FUNC
104 */
105 HWTEST_F(DisplayManagerIpcServiceTest, GetScreenInfoById01, TestSize.Level1)
106 {
107 sptr<ScreenInfo> screenInfo;
108 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetScreenInfoById(SCREEN_ID_INVALID, screenInfo));
109 EXPECT_EQ(screenInfo, nullptr);
110 }
111
112 /**
113 * @tc.name: GetScreenBrightness
114 * @tc.desc: DMS get screen brightness
115 * @tc.type: FUNC
116 */
117 HWTEST_F(DisplayManagerIpcServiceTest, SetScreenBrightness, TestSize.Level1)
118 {
119 bool isSucc = true;
120 ASSERT_EQ(ERR_OK, dms_->SetScreenBrightness(0, 100, isSucc));
121 EXPECT_TRUE(isSucc);
122 }
123
124 /**
125 * @tc.name: GetScreenBrightness
126 * @tc.desc: DMS get screen brightness
127 * @tc.type: FUNC
128 */
129 HWTEST_F(DisplayManagerIpcServiceTest, GetScreenBrightness, TestSize.Level1)
130 {
131 uint32_t level = 0;
132 ASSERT_EQ(ERR_OK, dms_->GetScreenBrightness(0, level));
133 EXPECT_GT(level, 0);
134 }
135
136 /**
137 * @tc.name: GetDisplayInfo
138 * @tc.desc: DMS get display info
139 * @tc.type: FUNC
140 */
141 HWTEST_F(DisplayManagerIpcServiceTest, GetDisplayInfo, TestSize.Level1)
142 {
143 // build abstractDisplayController_ env
144 std::string name = "testDisplay";
145 sptr<SupportedScreenModes> info = new SupportedScreenModes();
146 sptr<AbstractScreen> absScreen =
147 new AbstractScreen(dms_->displayManagerService_.abstractScreenController_, name, 0, 0);
148 sptr<AbstractDisplay> absDisplay = new AbstractDisplay(0, info, absScreen);
149
150 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_.clear();
151 sptr<DisplayInfo> displayInfo;
152 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetDefaultDisplayInfo(displayInfo));
153 ASSERT_EQ(nullptr, displayInfo);
154
155 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_ = {
156 { 0, absDisplay }
157 };
158 ASSERT_EQ(ERR_OK, dms_->GetDefaultDisplayInfo(displayInfo));
159 ASSERT_NE(nullptr, displayInfo);
160 EXPECT_EQ(absDisplay->name_, displayInfo->GetName());
161
162 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetDisplayInfoById(1, displayInfo));
163 ASSERT_EQ(nullptr, displayInfo);
164
165 ASSERT_EQ(ERR_OK, dms_->GetDisplayInfoById(0, displayInfo));
166 ASSERT_NE(nullptr, displayInfo);
167 EXPECT_EQ(0, displayInfo->GetDisplayId());
168 EXPECT_EQ(absDisplay->name_, displayInfo->GetName());
169
170 absDisplay->screenId_ = 0;
171
172 sptr<ScreenInfo> screenInfo;
173 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetScreenInfoById(1, screenInfo));
174 ASSERT_EQ(nullptr, screenInfo);
175 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetScreenInfoById(0, screenInfo));
176 ASSERT_EQ(nullptr, screenInfo);
177
178 sptr<ScreenGroupInfo> screenGroupInfo;
179 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetScreenGroupInfoById(1, screenGroupInfo));
180 ASSERT_EQ(nullptr, screenGroupInfo);
181 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetScreenGroupInfoById(0, screenGroupInfo));
182 ASSERT_EQ(nullptr, screenGroupInfo);
183
184 std::vector<uint64_t> displayIds;
185 ASSERT_EQ(ERR_OK, dms_->GetAllDisplayIds(displayIds));
186 EXPECT_NE(0, displayIds.size());
187
188 std::vector<sptr<ScreenInfo>> screenInfos;
189 int32_t dmError;
190 ASSERT_EQ(ERR_OK, dms_->GetAllScreenInfos(screenInfos, dmError));
191 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
192 EXPECT_EQ(0, screenInfos.size());
193
194 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_.clear();
195 }
196
197 /**
198 * @tc.name: VirtualScreen
199 * @tc.desc: DMS virtual screen
200 * @tc.type: FUNC
201 */
202 HWTEST_F(DisplayManagerIpcServiceTest, VirtualScreen, TestSize.Level1)
203 {
204 DmVirtualScreenOption option;
205 uint64_t screenId = 0;
206 ASSERT_EQ(ERR_OK, dms_->CreateVirtualScreen(option, nullptr, screenId));
207 EXPECT_EQ(SCREEN_ID_INVALID, screenId);
208
209 screenId = 0;
210 sptr<IBufferProducer> surface;
211 ASSERT_EQ(ERR_OK, dms_->CreateVirtualScreen(option, nullptr, screenId, surface));
212 EXPECT_EQ(SCREEN_ID_INVALID, screenId);
213
214 int32_t dmError = 0;
215 ASSERT_EQ(ERR_OK, dms_->SetVirtualScreenSurface(-1, nullptr, dmError));
216 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
217 ASSERT_EQ(ERR_OK, dms_->SetVirtualScreenSurface(0, nullptr, dmError));
218 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_RENDER_SERVICE_FAILED), dmError);
219
220 std::vector<ScreenId> screens;
221 ASSERT_EQ(ERR_OK, dms_->RemoveVirtualScreenFromGroup(screens));
222
223 ASSERT_EQ(ERR_OK, dms_->DestroyVirtualScreen(10086, dmError));
224 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_CALLING), dmError);
225 }
226
227 /**
228 * @tc.name: OrientationAndRotation
229 * @tc.desc: DMS set orientation and rotation
230 * @tc.type: FUNC
231 */
232 HWTEST_F(DisplayManagerIpcServiceTest, OrientationAndRotation, TestSize.Level1)
233 {
234 int32_t dmError = 0;
235 auto orientation = static_cast<uint32_t>(Orientation::VERTICAL);
236 ASSERT_EQ(ERR_OK, dms_->SetOrientation(0, orientation, dmError));
237 EXPECT_NE(static_cast<int32_t>(DMError::DM_OK), dmError);
238 orientation = static_cast<uint32_t>(Orientation::SENSOR_VERTICAL);
239 ASSERT_EQ(ERR_OK, dms_->SetOrientation(0, orientation, dmError));
240 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
241 orientation = static_cast<uint32_t>(Orientation::UNSPECIFIED);
242 ASSERT_EQ(ERR_OK, dms_->SetOrientation(0, orientation, dmError));
243 EXPECT_NE(static_cast<int32_t>(DMError::DM_OK), dmError);
244 }
245
246 /**
247 * @tc.name: ScreenColor
248 * @tc.desc: DMS screen color
249 * @tc.type: FUNC
250 */
251 HWTEST_F(DisplayManagerIpcServiceTest, ScreenColor, TestSize.Level1)
252 {
253 int32_t dmError = 0;
254 std::vector<uint32_t> colorGamuts;
255 ASSERT_EQ(ERR_OK, dms_->GetScreenSupportedColorGamuts(SCREEN_ID_INVALID, colorGamuts, dmError));
256 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
257 EXPECT_EQ(0, colorGamuts.size());
258 ASSERT_EQ(ERR_OK, dms_->GetScreenSupportedColorGamuts(0, colorGamuts, dmError));
259 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
260 EXPECT_EQ(0, colorGamuts.size());
261
262 uint32_t colorGamut = ScreenColorGamut::COLOR_GAMUT_SRGB;
263 ASSERT_EQ(ERR_OK, dms_->GetScreenColorGamut(SCREEN_ID_INVALID, colorGamut, dmError));
264 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
265 EXPECT_EQ(ScreenColorGamut::COLOR_GAMUT_NATIVE, colorGamut);
266 ASSERT_EQ(ERR_OK, dms_->GetScreenColorGamut(0, colorGamut, dmError));
267 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
268 EXPECT_EQ(ScreenColorGamut::COLOR_GAMUT_NATIVE, colorGamut);
269
270 colorGamut = ScreenColorGamut::COLOR_GAMUT_SRGB;
271 ASSERT_EQ(ERR_OK, dms_->SetScreenColorGamut(SCREEN_ID_INVALID, colorGamut, dmError));
272 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
273 ASSERT_EQ(ERR_OK, dms_->SetScreenColorGamut(0, colorGamut, dmError));
274 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
275
276 ASSERT_EQ(ERR_OK, dms_->SetScreenColorGamut(SCREEN_ID_INVALID, 0, dmError));
277 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
278 ASSERT_EQ(ERR_OK, dms_->SetScreenColorGamut(0, 0, dmError));
279 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
280
281 uint32_t gamutMap = ScreenGamutMap::GAMUT_MAP_CONSTANT;
282 ASSERT_EQ(ERR_OK, dms_->GetScreenGamutMap(SCREEN_ID_INVALID, gamutMap, dmError));
283 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
284 EXPECT_EQ(ScreenGamutMap::GAMUT_MAP_CONSTANT, gamutMap);
285 ASSERT_EQ(ERR_OK, dms_->GetScreenGamutMap(0, gamutMap, dmError));
286 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
287 EXPECT_EQ(ScreenGamutMap::GAMUT_MAP_CONSTANT, gamutMap);
288
289 ASSERT_EQ(ERR_OK, dms_->SetScreenGamutMap(SCREEN_ID_INVALID, gamutMap, dmError));
290 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
291 ASSERT_EQ(ERR_OK, dms_->SetScreenGamutMap(0, gamutMap, dmError));
292 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
293
294 ASSERT_EQ(ERR_OK, dms_->SetScreenColorTransform(SCREEN_ID_INVALID));
295 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
296 ASSERT_EQ(ERR_OK, dms_->SetScreenColorTransform(0));
297 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
298 }
299
300 /**
301 * @tc.name: RegisterDisplayManagerAgent
302 * @tc.desc: DMS register display manager agent
303 * @tc.type: FUNC
304 */
305 HWTEST_F(DisplayManagerIpcServiceTest, RegisterDisplayManagerAgent, TestSize.Level1)
306 {
307 auto type = static_cast<uint32_t>(DisplayManagerAgentType::DISPLAY_STATE_LISTENER);
308 int32_t dmError = 0;
309 ASSERT_EQ(ERR_OK, dms_->RegisterDisplayManagerAgent(nullptr, type, dmError));
310 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
311 ASSERT_EQ(ERR_OK, dms_->UnregisterDisplayManagerAgent(nullptr, type, dmError));
312 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
313 }
314
315 /**
316 * @tc.name: ScreenPower
317 * @tc.desc: DMS screen power
318 * @tc.type: FUNC
319 */
320 HWTEST_F(DisplayManagerIpcServiceTest, ScreenPower, TestSize.Level1)
321 {
322 auto reason = static_cast<uint32_t>(PowerStateChangeReason::POWER_BUTTON);
323 auto screenPowerState = static_cast<uint32_t>(ScreenPowerState::POWER_ON);
324 auto displayState = static_cast<uint32_t>(DisplayState::ON);
325 bool isSucc = true;
326
327 ASSERT_EQ(ERR_OK, dms_->WakeUpBegin(reason, isSucc));
328 EXPECT_FALSE(isSucc);
329 ASSERT_EQ(ERR_OK, dms_->WakeUpEnd(isSucc));
330 EXPECT_FALSE(isSucc);
331
332 ASSERT_EQ(ERR_OK, dms_->SuspendBegin(reason, isSucc));
333 EXPECT_FALSE(isSucc);
334 ASSERT_EQ(ERR_OK, dms_->SuspendEnd(isSucc));
335 EXPECT_FALSE(isSucc);
336
337 ASSERT_EQ(ERR_OK, dms_->SetScreenPowerForAll(screenPowerState, reason, isSucc));
338 EXPECT_FALSE(isSucc);
339
340 ScreenId dmsScreenId = 2;
341 ASSERT_EQ(ERR_OK, dms_->GetScreenPower(dmsScreenId, screenPowerState));
342 EXPECT_EQ(static_cast<uint32_t>(ScreenPowerState::INVALID_STATE), screenPowerState);
343
344 ASSERT_EQ(ERR_OK, dms_->SetDisplayState(displayState, isSucc));
345 EXPECT_TRUE(isSucc);
346 uint32_t displayStateOut = 0;
347 ASSERT_EQ(ERR_OK, dms_->GetDisplayState(0, displayStateOut));
348 EXPECT_EQ(static_cast<uint32_t>(DisplayState::ON), displayStateOut);
349 }
350
351 /**
352 * @tc.name: MirrorAndExpand
353 * @tc.desc: DMS mirror
354 * @tc.type: FUNC
355 */
356 HWTEST_F(DisplayManagerIpcServiceTest, MirrorAndExpand, TestSize.Level1)
357 {
358 int32_t dmError = 0;
359 std::vector<uint64_t> mirrorScreenIds;
360 uint64_t screenGroupId1 = DISPLAY_ID_INVALID;
361 ASSERT_EQ(ERR_OK, dms_->MakeMirror(DISPLAY_ID_INVALID, mirrorScreenIds, screenGroupId1, dmError));
362 EXPECT_EQ(SCREEN_ID_INVALID, screenGroupId1);
363 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
364 ASSERT_EQ(ERR_OK, dms_->StopMirror(mirrorScreenIds, dmError));
365 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
366
367 std::vector<uint64_t> expandScreenIds;
368 std::vector<Point> startPoints;
369 uint64_t screenGroupId2 = DISPLAY_ID_INVALID;
370 ASSERT_EQ(ERR_OK, dms_->MakeExpand(expandScreenIds, startPoints, screenGroupId2, dmError));
371 EXPECT_EQ(SCREEN_ID_INVALID, screenGroupId2);
372 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
373 ASSERT_EQ(ERR_OK, dms_->StopExpand(expandScreenIds, dmError));
374 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
375 }
376
377 /**
378 * @tc.name: ScreenActiveMode
379 * @tc.desc: DMS mirror
380 * @tc.type: FUNC
381 */
382 HWTEST_F(DisplayManagerIpcServiceTest, ScreenActiveMode, TestSize.Level1)
383 {
384 int32_t dmError = 0;
385 ASSERT_EQ(ERR_OK, dms_->SetScreenActiveMode(SCREEN_ID_INVALID, 0, dmError));
386 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
387 }
388
389 /**
390 * @tc.name: VirtualPixelRatio
391 * @tc.desc: DMS mirror
392 * @tc.type: FUNC
393 */
394 HWTEST_F(DisplayManagerIpcServiceTest, VirtualPixelRatio, TestSize.Level1)
395 {
396 int32_t dmError = 0;
397 ASSERT_EQ(ERR_OK, dms_->SetVirtualPixelRatio(SCREEN_ID_INVALID, 0.f, dmError));
398 EXPECT_NE(static_cast<int32_t>(DMError::DM_OK), dmError);
399 }
400
401 /**
402 * @tc.name: RemoveSurfaceNodeFromDisplay01
403 * @tc.desc: RemoveSurfaceNodeFromDisplay
404 * @tc.type: FUNC
405 */
406 HWTEST_F(DisplayManagerIpcServiceTest, RemoveSurfaceNodeFromDisplay01, TestSize.Level1)
407 {
408 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(nullptr);
409 int32_t dmError = 0;
410 ASSERT_EQ(ERR_OK, dms_->RemoveSurfaceNodeFromDisplay(0, dmRsSurfaceNode, dmError));
411 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
412 }
413
414 /**
415 * @tc.name: NotifyDisplayEvent
416 * @tc.desc: NotifyDisplayEvent
417 * @tc.type: FUNC
418 */
419 HWTEST_F(DisplayManagerIpcServiceTest, NotifyDisplayEvent, TestSize.Level1)
420 {
421 auto event = static_cast<uint32_t>(DisplayEvent::KEYGUARD_DRAWN);
422 ASSERT_EQ(ERR_OK, dms_->NotifyDisplayEvent(event));
423 EXPECT_NE(dms_->displayManagerService_.displayPowerController_, nullptr);
424 }
425
426 /**
427 * @tc.name: SetFreeze
428 * @tc.desc: SetFreeze
429 * @tc.type: FUNC
430 */
431 HWTEST_F(DisplayManagerIpcServiceTest, SetFreeze, TestSize.Level1)
432 {
433 std::vector<DisplayId> displayIds = { 0 };
434 bool isFreeze = false;
435 bool isSucc = true;
436 ASSERT_EQ(ERR_OK, dms_->SetFreeze(displayIds, isFreeze, isSucc));
437 EXPECT_TRUE(isSucc);
438 EXPECT_NE(dms_->displayManagerService_.abstractDisplayController_, nullptr);
439 }
440
441 /**
442 * @tc.name: AddSurfaceNodeToDisplay
443 * @tc.desc: AddSurfaceNodeToDisplay
444 * @tc.type: FUNC
445 */
446 HWTEST_F(DisplayManagerIpcServiceTest, AddSurfaceNodeToDisplay, TestSize.Level1)
447 {
448 DisplayId displayId = 1;
449 struct RSSurfaceNodeConfig config;
450 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
451 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(surfaceNode);
452 int32_t dmError = 0;
453 ASSERT_EQ(ERR_OK, dms_->AddSurfaceNodeToDisplay(displayId, dmRsSurfaceNode, dmError));
454 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
455 EXPECT_NE(dms_->displayManagerService_.abstractScreenController_, nullptr);
456 }
457
458 /**
459 * @tc.name: IsScreenRotationLocked
460 * @tc.desc: IsScreenRotationLocked
461 * @tc.type: FUNC
462 */
463 HWTEST_F(DisplayManagerIpcServiceTest, IsScreenRotationLocked, TestSize.Level1)
464 {
465 bool isLocked = true;
466 int32_t dmError = 0;
467 ASSERT_EQ(ERR_OK, dms_->IsScreenRotationLocked(isLocked, dmError));
468 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
469 }
470
471 /**
472 * @tc.name: SetScreenRotationLocked
473 * @tc.desc: SetScreenRotationLocked
474 * @tc.type: FUNC
475 */
476 HWTEST_F(DisplayManagerIpcServiceTest, SetScreenRotationLocked, TestSize.Level1)
477 {
478 bool isLocked = true;
479 int32_t dmError = 0;
480 ASSERT_EQ(ERR_OK, dms_->SetScreenRotationLocked(isLocked, dmError));
481 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
482 }
483
484 /**
485 * @tc.name: SetScreenRotationLockedFromJs
486 * @tc.desc: SetScreenRotationLockedFromJs
487 * @tc.type: FUNC
488 */
489 HWTEST_F(DisplayManagerIpcServiceTest, SetScreenRotationLockedFromJs, TestSize.Level1)
490 {
491 bool isLocked = true;
492 int32_t dmError = 0;
493 ASSERT_EQ(ERR_OK, dms_->SetScreenRotationLockedFromJs(isLocked, dmError));
494 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
495 }
496
497 /**
498 * @tc.name: MakeMirror
499 * @tc.desc: MakeMirror
500 * @tc.type: FUNC
501 */
502 HWTEST_F(DisplayManagerIpcServiceTest, MakeMirror, TestSize.Level1)
503 {
504 ScreenId mainScreenId = 1;
505 std::vector<ScreenId> mirrorScreenIds = { 2 };
506 ScreenId screenGroupId = 3;
507 sptr<AbstractScreen> absScreen =
508 new AbstractScreen(nullptr, "", INVALID_SCREEN_ID, INVALID_SCREEN_ID);
509 dms_->displayManagerService_.abstractScreenController_->dmsScreenMap_.insert(
510 std::make_pair(mainScreenId, absScreen));
511 int32_t dmError = 0;
512 ASSERT_EQ(ERR_OK, dms_->MakeMirror(mainScreenId, mirrorScreenIds, screenGroupId, dmError));
513 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
514 dms_->displayManagerService_.abstractScreenController_->dmsScreenMap_.clear();
515 }
516
517 /**
518 * @tc.name: StopMirror
519 * @tc.desc: StopMirror
520 * @tc.type: FUNC
521 */
522 HWTEST_F(DisplayManagerIpcServiceTest, StopMirror, TestSize.Level1)
523 {
524 std::vector<ScreenId> mirrorScreenIds = { 2 };
525 sptr<AbstractScreen> absScreen = new AbstractScreen(nullptr, "", INVALID_SCREEN_ID, INVALID_SCREEN_ID);
526 dms_->displayManagerService_.abstractScreenController_->dmsScreenMap_.insert(std::make_pair(2, absScreen));
527 int32_t dmError = 0;
528 ASSERT_EQ(ERR_OK, dms_->StopMirror(mirrorScreenIds, dmError));
529 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
530 }
531
532 /**
533 * @tc.name: RemoveSurfaceNodeFromDisplay02
534 * @tc.desc: RemoveSurfaceNodeFromDisplay
535 * @tc.type: FUNC
536 */
537 HWTEST_F(DisplayManagerIpcServiceTest, RemoveSurfaceNodeFromDisplay02, TestSize.Level1)
538 {
539 DisplayId displayId = 1;
540 struct RSSurfaceNodeConfig config;
541 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(config);
542 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(surfaceNode);
543 int32_t dmError = 0;
544 ASSERT_EQ(ERR_OK, dms_->RemoveSurfaceNodeFromDisplay(displayId, dmRsSurfaceNode, dmError));
545 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
546 }
547
548 /**
549 * @tc.name: SetOrientation
550 * @tc.desc: DMS SetOrientation
551 * @tc.type: FUNC
552 */
553 HWTEST_F(DisplayManagerIpcServiceTest, SetOrientation, TestSize.Level1)
554 {
555 ScreenId screenId = 0;
556 auto orientation = static_cast<uint32_t>(Orientation::VERTICAL);
557 int32_t dmError = 0;
558 ASSERT_EQ(ERR_OK, dms_->SetOrientation(screenId, orientation, dmError));
559 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
560 }
561
562 /**
563 * @tc.name: GetDisplaySnapshot
564 * @tc.desc: DMS GetDisplaySnapshot
565 * @tc.type: FUNC
566 */
567 HWTEST_F(DisplayManagerIpcServiceTest, GetDisplaySnapshot, TestSize.Level1)
568 {
569 DisplayId displayId = -1;
570 int32_t errorCode = 0;
571 std::shared_ptr<PixelMap> pixelMap;
572 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetDisplaySnapshot(displayId, errorCode, false, false, pixelMap));
573 ASSERT_EQ(static_cast<int32_t>(DmErrorCode::DM_OK), errorCode);
574 ASSERT_EQ(nullptr, pixelMap);
575 }
576
577 /**
578 * @tc.name: AddSurfaceNodeToDisplay
579 * @tc.desc: DMS AddSurfaceNodeToDisplay
580 * @tc.type: FUNC
581 */
582 HWTEST_F(DisplayManagerIpcServiceTest, AddSurfaceNodeToDisplay02, TestSize.Level1)
583 {
584 DisplayId displayId = 1;
585 std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
586 std::shared_ptr<DmRsSurfaceNode> dmRsSurfaceNode = std::make_shared<DmRsSurfaceNode>(surfaceNode);
587 int32_t dmError = 0;
588 ASSERT_EQ(ERR_OK, dms_->AddSurfaceNodeToDisplay(displayId, dmRsSurfaceNode, dmError));
589 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
590 }
591
592 /**
593 * @tc.name: GetAllScreenInfos
594 * @tc.desc: DMS GetAllScreenInfos
595 * @tc.type: FUNC
596 */
597 HWTEST_F(DisplayManagerIpcServiceTest, GetAllScreenInfos, TestSize.Level1)
598 {
599 std::vector<sptr<ScreenInfo>> screenInfos;
600 int32_t dmError = 0;
601 ASSERT_EQ(ERR_OK, dms_->GetAllScreenInfos(screenInfos, dmError));
602 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
603 }
604
605 /**
606 * @tc.name: MakeExpand
607 * @tc.desc: DMS MakeExpand
608 * @tc.type: FUNC
609 */
610 HWTEST_F(DisplayManagerIpcServiceTest, MakeExpand01, TestSize.Level1)
611 {
612 std::vector<ScreenId> expandScreenIds{ 1 };
613 std::vector<Point> startPoints(1);
614 ScreenId screenGroupId = 3;
615 int32_t dmError = 0;
616 ASSERT_EQ(ERR_OK, dms_->MakeExpand(expandScreenIds, startPoints, screenGroupId, dmError));
617 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_NULLPTR), dmError);
618 EXPECT_EQ(3u, screenGroupId);
619 }
620
621 /**
622 * @tc.name: MakeExpand
623 * @tc.desc: DMS MakeExpand
624 * @tc.type: FUNC
625 */
626 HWTEST_F(DisplayManagerIpcServiceTest, MakeExpand02, TestSize.Level1)
627 {
628 std::vector<ScreenId> expandScreenIds{ 1, 2, 3, 4, 5 };
629 std::vector<Point> startPoints(1);
630 ScreenId screenGroupId = 3;
631 int32_t dmError = 0;
632 ASSERT_EQ(ERR_OK, dms_->MakeExpand(expandScreenIds, startPoints, screenGroupId, dmError));
633 EXPECT_EQ(static_cast<int32_t>(DMError::DM_ERROR_INVALID_PARAM), dmError);
634 EXPECT_EQ(3u, screenGroupId);
635 }
636
637 /**
638 * @tc.name: StopExpand
639 * @tc.desc: DMS StopExpand
640 * @tc.type: FUNC
641 */
642 HWTEST_F(DisplayManagerIpcServiceTest, StopExpand, TestSize.Level1)
643 {
644 std::vector<ScreenId> expandScreenIds{ 0, 1, 2, 3, 4, 5 };
645 int32_t dmError = 0;
646 ASSERT_EQ(ERR_OK, dms_->StopExpand(expandScreenIds, dmError));
647 EXPECT_EQ(static_cast<int32_t>(DMError::DM_OK), dmError);
648 }
649
650 /**
651 * @tc.name: GetVisibleAreaDisplayInfoById01
652 * @tc.desc: GetVisibleAreaDisplayInfoById
653 * @tc.type: FUNC
654 */
655 HWTEST_F(DisplayManagerIpcServiceTest, GetVisibleAreaDisplayInfoById01, TestSize.Level1)
656 {
657 DisplayId displayId = DISPLAY_ID_INVALID;
658 sptr<DisplayInfo> displayInfo;
659 ASSERT_EQ(ERR_INVALID_DATA, dms_->GetVisibleAreaDisplayInfoById(displayId, displayInfo));
660 EXPECT_EQ(displayInfo, nullptr);
661 }
662
663 /**
664 * @tc.name: GetVisibleAreaDisplayInfoById02
665 * @tc.desc: GetVisibleAreaDisplayInfoById
666 * @tc.type: FUNC
667 */
668 HWTEST_F(DisplayManagerIpcServiceTest, GetVisibleAreaDisplayInfoById02, TestSize.Level1)
669 {
670 DisplayId displayId = 2;
671 std::string name = "testDisplay";
672 sptr<SupportedScreenModes> info = new SupportedScreenModes();
673 sptr<AbstractScreen> absScreen =
674 new AbstractScreen(dms_->displayManagerService_.abstractScreenController_, name, 0, 0);
675 sptr<AbstractDisplay> absDisplay = new AbstractDisplay(0, info, absScreen);
676 dms_->displayManagerService_.abstractDisplayController_->abstractDisplayMap_.insert({ displayId, absDisplay });
677 sptr<DisplayInfo> displayInfo;
678 ASSERT_EQ(ERR_OK, dms_->GetVisibleAreaDisplayInfoById(displayId, displayInfo));
679 EXPECT_NE(displayInfo, nullptr);
680 }
681
682 /**
683 * @tc.name: GetAllDisplayPhysicalResolution01
684 * @tc.desc: Test GetAllDisplayPhysicalResolution function when allDisplayPhysicalResolution_ is empty.
685 * @tc.type: FUNC
686 */
687 HWTEST_F(DisplayManagerIpcServiceTest, GetAllDisplayPhysicalResolution01, TestSize.Level1)
688 {
689 dms_->displayManagerService_.allDisplayPhysicalResolution_.clear();
690 std::vector<DisplayPhysicalResolution> displayPhysicalResolutions;
691 ASSERT_EQ(ERR_OK, dms_->GetAllDisplayPhysicalResolution(displayPhysicalResolutions));
692 EXPECT_FALSE(displayPhysicalResolutions.empty());
693 }
694
695 /**
696 * @tc.name: GetAllDisplayPhysicalResolution02
697 * @tc.desc: Test GetAllDisplayPhysicalResolution function when allDisplayPhysicalResolution_ is not empty.
698 * @tc.type: FUNC
699 */
700 HWTEST_F(DisplayManagerIpcServiceTest, GetAllDisplayPhysicalResolution02, TestSize.Level1)
701 {
702 dms_->displayManagerService_.allDisplayPhysicalResolution_.emplace_back();
703 std::vector<DisplayPhysicalResolution> displayPhysicalResolutions;
704 ASSERT_EQ(ERR_OK, dms_->GetAllDisplayPhysicalResolution(displayPhysicalResolutions));
705 EXPECT_FALSE(displayPhysicalResolutions.empty());
706 }
707
708 /**
709 * @tc.name : SetVirtualScreenAsDefault
710 * @tc.number: SetVirtualScreenAsDefault test
711 * @tc.desc : FUNC
712 */
713 HWTEST_F(DisplayManagerIpcServiceTest, SetVirtualScreenAsDefault, TestSize.Level1) {
714 bool isSucc = false;
715 uint64_t screenId = SCREEN_ID_INVALID;
716
717 ErrCode result = dms_->SetVirtualScreenAsDefault(screenId, isSucc);
718
719 EXPECT_EQ(result, ERR_OK);
720 EXPECT_FALSE(isSucc);
721 }
722 } // namespace
723 } // namespace OHOS::Rosen
724