1 /*
2  * Copyright (c) 2022 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 "abstract_screen_controller.h"
19 #include "iremote_object_mocker.h"
20 
21 using namespace testing;
22 using namespace testing::ext;
23 
24 namespace OHOS {
25 namespace Rosen {
26 class AbstractScreenControllerTest : public testing::Test {
27 public:
28     static void SetUpTestCase();
29     static void TearDownTestCase();
30     void SetUp() override;
31     void TearDown() override;
32 
33     std::recursive_mutex mutex;
34     sptr<AbstractScreenController> absController_ = new AbstractScreenController(mutex);
35     std::string name = "AbstractScreenController";
36     std::vector<sptr<AbstractScreen>> screenVec;
37     std::vector<sptr<AbstractScreenGroup>> screenGroupVec;
38 };
39 
SetUpTestCase()40 void AbstractScreenControllerTest::SetUpTestCase()
41 {
42 }
43 
TearDownTestCase()44 void AbstractScreenControllerTest::TearDownTestCase()
45 {
46 }
47 
SetUp()48 void AbstractScreenControllerTest::SetUp()
49 {
50     uint64_t index = 5;
51     for (uint64_t i = 0; i < index; ++i) {
52         ScreenId dmsId = i;
53         ScreenId rsId = i;
54         sptr<AbstractScreen> absScreen = new AbstractScreen(absController_, name, dmsId, rsId);
55         sptr<AbstractScreenGroup> absScreenGroup = new AbstractScreenGroup(absController_,
56             dmsId, rsId, name, ScreenCombination::SCREEN_ALONE);
57         screenVec.emplace_back(absScreen);
58         screenGroupVec.emplace_back(absScreenGroup);
59         // init dmsScreenMap_
60         absController_->dmsScreenMap_.insert(std::make_pair(dmsId, absScreen));
61         // init screenIdManager_
62         absController_->screenIdManager_.rs2DmsScreenIdMap_.insert(std::make_pair(rsId, dmsId));
63         absController_->screenIdManager_.dms2RsScreenIdMap_.insert(std::make_pair(dmsId, rsId));
64         // init dmsScreenGroupMap_
65         absController_->dmsScreenGroupMap_.insert(std::make_pair(rsId, absScreenGroup));
66     }
67     screenVec[4]->type_ = ScreenType::UNDEFINED;
68     screenVec[3]->type_ = ScreenType::VIRTUAL;
69     absController_->dmsScreenMap_.insert(std::make_pair(index, nullptr));
70     absController_->screenIdManager_.dms2RsScreenIdMap_.insert(std::make_pair(index, SCREEN_ID_INVALID));
71     absController_->dmsScreenGroupMap_.insert(std::make_pair(index, nullptr));
72 }
73 
TearDown()74 void AbstractScreenControllerTest::TearDown()
75 {
76     screenVec.clear();
77 }
78 
79 namespace {
80 /**
81  * @tc.name: ProcessScreenDisconnected
82  * @tc.desc: ProcessScreenDisconnected test
83  * @tc.type: FUNC
84  */
85 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected01, Function | SmallTest | Level3)
86 {
87     ScreenId rsId = 6;
88     ScreenId dmsId;
89     absController_->ProcessScreenDisconnected(rsId);
90     ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
91 }
92 /**
93  * @tc.name: ProcessScreenDisconnected
94  * @tc.desc: ProcessScreenDisconnected test
95  * @tc.type: FUNC
96  */
97 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected02, Function | SmallTest | Level3)
98 {
99     ScreenId rsId = 2;
100     ScreenId dmsId;
101     absController_->ProcessScreenDisconnected(rsId);
102     absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId);
103     absController_->dmsScreenMap_.erase(dmsId);
104     ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
105     ASSERT_EQ(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
106 }
107 /**
108  * @tc.name: ProcessScreenDisconnected
109  * @tc.desc: ProcessScreenDisconnected test
110  * @tc.type: FUNC
111  */
112 HWTEST_F(AbstractScreenControllerTest, ProcessScreenDisconnected03, Function | SmallTest | Level3)
113 {
114     ScreenId rsId = 2;
115     ScreenId dmsId;
116     absController_->abstractScreenCallback_ = nullptr;
117     absController_->ProcessScreenDisconnected(rsId);
118     ASSERT_EQ(false, absController_->screenIdManager_.ConvertToDmsScreenId(rsId, dmsId));
119     ASSERT_NE(absController_->dmsScreenMap_.end(), absController_->dmsScreenMap_.find(dmsId));
120 }
121 /**
122  * @tc.name: SetScreenRotateAnimation
123  * @tc.desc: SetScreenRotateAnimation test
124  * @tc.type: FUNC
125  */
126 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation01, Function | SmallTest | Level3)
127 {
128     RSDisplayNodeConfig config;
129     absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
130     sptr<AbstractScreen> screen = screenVec[0];
131     screen->rotation_ = Rotation::ROTATION_270;
132     absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_0, true);
133     ASSERT_EQ(Rotation::ROTATION_270, screen->rotation_);
134 }
135 /**
136  * @tc.name: SetScreenRotateAnimation
137  * @tc.desc: SetScreenRotateAnimation test
138  * @tc.type: FUNC
139  */
140 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation02, Function | SmallTest | Level3)
141 {
142     RSDisplayNodeConfig config;
143     absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
144     sptr<AbstractScreen> screen = screenVec[0];
145     screen->rotation_ = Rotation::ROTATION_0;
146     absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, true);
147     ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
148 }
149 /**
150  * @tc.name: SetScreenRotateAnimation
151  * @tc.desc: SetScreenRotateAnimation test
152  * @tc.type: FUNC
153  */
154 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation03, Function | SmallTest | Level3)
155 {
156     RSDisplayNodeConfig config;
157     absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
158     sptr<AbstractScreen> screen = screenVec[0];
159     screen->rotation_ = Rotation::ROTATION_0;
160     absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, false);
161     ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
162 }
163 /**
164  * @tc.name: MakeMirror
165  * @tc.desc: MakeMirror test
166  * @tc.type: FUNC
167  */
168 HWTEST_F(AbstractScreenControllerTest, MakeMirror01, Function | SmallTest | Level3)
169 {
170     std::vector<ScreenId> screens;
171     ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(5, screens));
172     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
173 }
174 /**
175  * @tc.name: MakeMirror
176  * @tc.desc: MakeMirror test
177  * @tc.type: FUNC
178  */
179 HWTEST_F(AbstractScreenControllerTest, MakeMirror02, Function | SmallTest | Level3)
180 {
181     std::vector<ScreenId> screens;
182     absController_->dmsScreenMap_[2]->type_ = ScreenType::UNDEFINED;
183     ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
184     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
185 }
186 /**
187  * @tc.name: MakeMirror
188  * @tc.desc: MakeMirror test
189  * @tc.type: FUNC
190  */
191 HWTEST_F(AbstractScreenControllerTest, MakeMirror03, Function | SmallTest | Level3)
192 {
193     std::vector<ScreenId> screens;
194     absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
195     absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
196     absController_->abstractScreenCallback_ = nullptr;
197     ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
198     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
199 }
200 /**
201  * @tc.name: MakeMirror
202  * @tc.desc: MakeMirror test
203  * @tc.type: FUNC
204  */
205 HWTEST_F(AbstractScreenControllerTest, MakeMirror04, Function | SmallTest | Level3)
206 {
207     std::vector<ScreenId> screens;
208     absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
209     absController_->dmsScreenMap_[2]->groupDmsId_ = 5;
210     absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
211     ASSERT_TRUE(DMError::DM_OK != absController_->MakeMirror(2, screens));
212     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
213 }
214 /**
215  * @tc.name: MakeMirror
216  * @tc.desc: MakeMirror test
217  * @tc.type: FUNC
218  */
219 HWTEST_F(AbstractScreenControllerTest, MakeMirror05, Function | SmallTest | Level3)
220 {
221     std::vector<ScreenId> screens;
222     absController_->dmsScreenMap_[2]->type_ = ScreenType::REAL;
223     absController_->dmsScreenMap_[2]->groupDmsId_ = 2;
224     absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
225     ASSERT_TRUE(DMError::DM_OK == absController_->MakeMirror(2, screens));
226     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screens, ScreenCombination::SCREEN_MIRROR));
227 }
228 /**
229  * @tc.name: ProcessScreenConnected
230  * @tc.desc: ProcessScreenConnected test
231  * @tc.type: FUNC
232  */
233 HWTEST_F(AbstractScreenControllerTest, ProcessScreenConnected01, Function | SmallTest | Level3)
234 {
235     ScreenId id = 0;
236     absController_->ProcessScreenConnected(id);
237     ASSERT_EQ(true, absController_->screenIdManager_.HasRsScreenId(id));
238 }
239 /**
240  * @tc.name: OnRsScreenConnectionChange
241  * @tc.desc: OnRsScreenConnectionChange test
242  * @tc.type: FUNC
243  */
244 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange01, Function | SmallTest | Level3)
245 {
246     ScreenEvent event = ScreenEvent::UNKNOWN;
247     ScreenId rsScreenId = 100;
248     absController_->OnRsScreenConnectionChange(rsScreenId, event);
249     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
250 }
251 /**
252  * @tc.name: OnRsScreenConnectionChange
253  * @tc.desc: OnRsScreenConnectionChange test
254  * @tc.type: FUNC
255  */
256 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange02, Function | SmallTest | Level3)
257 {
258     ScreenEvent event = ScreenEvent::UNKNOWN;
259     ScreenId rsScreenId = 1;
260     absController_->OnRsScreenConnectionChange(rsScreenId, event);
261     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
262 }
263 /**
264  * @tc.name: OnRsScreenConnectionChange
265  * @tc.desc: OnRsScreenConnectionChange test
266  * @tc.type: FUNC
267  */
268 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange03, Function | SmallTest | Level3)
269 {
270     ScreenEvent event = ScreenEvent::CONNECTED;
271     ScreenId rsScreenId = 1;
272     absController_->OnRsScreenConnectionChange(rsScreenId, event);
273     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
274 }
275 /**
276  * @tc.name: OnRsScreenConnectionChange
277  * @tc.desc: OnRsScreenConnectionChange test
278  * @tc.type: FUNC
279  */
280 HWTEST_F(AbstractScreenControllerTest, OnRsScreenConnectionChange04, Function | SmallTest | Level3)
281 {
282     ScreenEvent event = ScreenEvent::DISCONNECTED;
283     ScreenId rsScreenId = 1;
284     absController_->OnRsScreenConnectionChange(rsScreenId, event);
285     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
286 }
287 /**
288  * @tc.name: GetAllValidScreenIds
289  * @tc.desc: GetAllValidScreenIds test
290  * @tc.type: FUNC
291  */
292 HWTEST_F(AbstractScreenControllerTest, GetAllValidScreenIds, Function | SmallTest | Level3)
293 {
294     std::vector<ScreenId> screenIds {0, 1, 1, 2, 2, 3, 4};
295     std::vector<ScreenId> valid {0, 1, 2, 3};
296     ASSERT_EQ(valid, absController_->GetAllValidScreenIds(screenIds));
297 }
298 /**
299  * @tc.name: GetRSDisplayNodeByScreenId
300  * @tc.desc: GetRSDisplayNodeByScreenId test
301  * @tc.type: FUNC
302  */
303 HWTEST_F(AbstractScreenControllerTest, GetRSDisplayNodeByScreenId, Function | SmallTest | Level3)
304 {
305     ScreenId id = 6;
306     std::shared_ptr<RSDisplayNode> node = nullptr;
307     ASSERT_EQ(node, absController_->GetRSDisplayNodeByScreenId(id));
308 }
309 /**
310  * @tc.name: UpdateRSTree
311  * @tc.desc: UpdateRSTree test
312  * @tc.type: FUNC
313  */
314 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree01, Function | SmallTest | Level3)
315 {
316     ScreenId id = 8;
317     std::shared_ptr<RSSurfaceNode> node = nullptr;
318     absController_->UpdateRSTree(id, id, node, true, true);
319     ASSERT_EQ(nullptr, absController_->GetAbstractScreen(id));
320 }
321 /**
322  * @tc.name: UpdateRSTree
323  * @tc.desc: UpdateRSTree test
324  * @tc.type: FUNC
325  */
326 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree02, Function | SmallTest | Level3)
327 {
328     ScreenId id = 1;
329     ScreenId parentId = 8;
330     std::shared_ptr<RSSurfaceNode> node = nullptr;
331     absController_->UpdateRSTree(id, parentId, node, true, true);
332     ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
333     ASSERT_EQ(nullptr, absController_->GetAbstractScreen(parentId));
334 }
335 /**
336  * @tc.name: UpdateRSTree
337  * @tc.desc: UpdateRSTree test
338  * @tc.type: FUNC
339  */
340 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree03, Function | SmallTest | Level3)
341 {
342     ScreenId id = 1;
343     ScreenId parentId = 2;
344     std::shared_ptr<RSSurfaceNode> node = nullptr;
345     ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
346     sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
347     ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
348     parentScreen->rsDisplayNode_ = nullptr;
349     absController_->UpdateRSTree(id, parentId, node, true, true);
350 }
351 /**
352  * @tc.name: UpdateRSTree
353  * @tc.desc: UpdateRSTree test
354  * @tc.type: FUNC
355  */
356 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree04, Function | SmallTest | Level3)
357 {
358     ScreenId id = 1;
359     ScreenId parentId = 2;
360     std::shared_ptr<RSSurfaceNode> node = nullptr;
361     RSDisplayNodeConfig config;
362     ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
363     sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
364     ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
365     parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);;
366     absController_->UpdateRSTree(id, parentId, node, true, true);
367 }
368 /**
369  * @tc.name: UpdateRSTree
370  * @tc.desc: UpdateRSTree test
371  * @tc.type: FUNC
372  */
373 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree05, Function | SmallTest | Level3)
374 {
375     ScreenId id = 1;
376     ScreenId parentId = 2;
377     std::shared_ptr<RSSurfaceNode> node = nullptr;
378     RSDisplayNodeConfig config;
379     ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
380     sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
381     ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
382     parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);;
383     absController_->UpdateRSTree(id, parentId, node, true, false);
384 }
385 /**
386  * @tc.name: RegisterAbstractScreenCallback
387  * @tc.desc: RegisterAbstractScreenCallback test
388  * @tc.type: FUNC
389  */
390 HWTEST_F(AbstractScreenControllerTest, RegisterAbstractScreenCallback, Function | SmallTest | Level3)
391 {
392     sptr<AbstractScreenController::AbstractScreenCallback> cb = nullptr;
393     absController_->RegisterAbstractScreenCallback(cb);
394     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
395 }
396 /**
397  * @tc.name: AddToGroupLocked
398  * @tc.desc: AddToGroupLocked test
399  * @tc.type: FUNC
400  */
401 HWTEST_F(AbstractScreenControllerTest, AddToGroupLocked, Function | SmallTest | Level3)
402 {
403     ASSERT_EQ(false, absController_->dmsScreenGroupMap_.empty());
404     ASSERT_EQ(nullptr, absController_->AddToGroupLocked(screenVec[0]));
405 }
406 /**
407  * @tc.name: RemoveFromGroupLocked
408  * @tc.desc: RemoveFromGroupLocked test
409  * @tc.type: FUNC
410  */
411 HWTEST_F(AbstractScreenControllerTest, RemoveFromGroupLocked01, Function | SmallTest | Level3)
412 {
413     sptr<AbstractScreen> screen = screenVec[0];
414     screen->groupDmsId_ = 0;
415     ASSERT_EQ(nullptr, absController_->RemoveFromGroupLocked(screen));
416 }
417 /**
418  * @tc.name: RemoveChildFromGroup
419  * @tc.desc: RemoveChildFromGroup test
420  * @tc.type: FUNC
421  */
422 HWTEST_F(AbstractScreenControllerTest, RemoveChildFromGroup01, Function | SmallTest | Level3)
423 {
424     sptr<AbstractScreen> screen = screenVec[0];
425     ScreenId dmsId = screen->dmsId_;
426     sptr<AbstractScreenGroup> screenGroup = absController_->dmsScreenGroupMap_[0];
427     screenGroup->screenMap_.insert(std::make_pair(dmsId, screen));
428     ASSERT_EQ(true, absController_->RemoveChildFromGroup(screen, screenGroup));
429 }
430 /**
431  * @tc.name: AddAsSuccedentScreenLocked
432  * @tc.desc: AddAsSuccedentScreenLocked test
433  * @tc.type: FUNC
434  */
435 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked01, Function | SmallTest | Level3)
436 {
437     sptr<AbstractScreen> screen = screenVec[0];
438     absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
439     ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
440 }
441 /**
442  * @tc.name: AddAsSuccedentScreenLocked
443  * @tc.desc: AddAsSuccedentScreenLocked test
444  * @tc.type: FUNC
445  */
446 HWTEST_F(AbstractScreenControllerTest, AddAsSuccedentScreenLocked02, Function | SmallTest | Level3)
447 {
448     sptr<AbstractScreen> screen = screenVec[0];
449     ASSERT_EQ(nullptr, absController_->AddAsSuccedentScreenLocked(screen));
450 }
451 /**
452  * @tc.name: CreateVirtualScreen
453  * @tc.desc: CreateVirtualScreen test
454  * @tc.type: FUNC
455  */
456 HWTEST_F(AbstractScreenControllerTest, CreateVirtualScreen01, Function | SmallTest | Level3)
457 {
458     VirtualScreenOption option;
459     sptr<IRemoteObject> displayManagerAgent = new IRemoteObjectMocker();
460     auto ret = absController_->CreateVirtualScreen(option, displayManagerAgent);
461     if (ret != 0)
462     {
463         ASSERT_NE(0, ret);
464     }
465 }
466 
467 /**
468  * @tc.name: InitVirtualScreen
469  * @tc.desc: InitVirtualScreen test
470  * @tc.type: FUNC
471  */
472 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen01, Function | SmallTest | Level3)
473 {
474     VirtualScreenOption option;
475     absController_->dmsScreenMap_.erase(absController_->GetDefaultAbstractScreenId());
476     sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
477     auto ret = screen->activeIdx_;
478     if (ret != 0) {
479         ASSERT_NE(0, ret);
480     }
481 }
482 
483 /**
484  * @tc.name: InitVirtualScreen
485  * @tc.desc: InitVirtualScreen test
486  * @tc.type: FUNC
487  */
488 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen02, Function | SmallTest | Level3)
489 {
490     VirtualScreenOption option;
491     sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
492     sptr<SupportedScreenModes> modes;
493     if (defaultScreen != nullptr) {
494         defaultScreen->modes_.emplace_back(modes);
495         defaultScreen->activeIdx_ = 0;
496         ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
497         sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
498         ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
499     }
500 }
501 
502 /**
503  * @tc.name: DestroyVirtualScreen
504  * @tc.desc: DestroyVirtualScreen test
505  * @tc.type: FUNC
506  */
507 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen01, Function | SmallTest | Level3)
508 {
509     ScreenId id = 5;
510     ASSERT_EQ(DMError::DM_ERROR_INVALID_PARAM, absController_->DestroyVirtualScreen(id));
511 }
512 /**
513  * @tc.name: DestroyVirtualScreen
514  * @tc.desc: DestroyVirtualScreen test
515  * @tc.type: FUNC
516  */
517 HWTEST_F(AbstractScreenControllerTest, DestroyVirtualScreen02, Function | SmallTest | Level3)
518 {
519     ScreenId id = 1;
520     ASSERT_EQ(DMError::DM_OK, absController_->DestroyVirtualScreen(id));
521 }
522 /**
523  * @tc.name: SetVirtualScreenSurface
524  * @tc.desc: SetVirtualScreenSurface test
525  * @tc.type: FUNC
526  */
527 HWTEST_F(AbstractScreenControllerTest, SetVirtualScreenSurface01, Function | SmallTest | Level3)
528 {
529     ScreenId id = 6;
530     sptr<Surface> surface = nullptr;
531     ASSERT_EQ(DMError::DM_ERROR_RENDER_SERVICE_FAILED, absController_->SetVirtualScreenSurface(id, surface));
532 }
533 /**
534  * @tc.name: SetBuildInDefaultOrientation
535  * @tc.desc: SetBuildInDefaultOrientation test
536  * @tc.type: FUNC
537  */
538 HWTEST_F(AbstractScreenControllerTest, SetBuildInDefaultOrientation, Function | SmallTest | Level3)
539 {
540     Orientation orientation = Orientation::BEGIN;
541     absController_->SetBuildInDefaultOrientation(orientation);
542     ASSERT_EQ(orientation, absController_->buildInDefaultOrientation_);
543 }
544 /**
545  * @tc.name: SetOrientation
546  * @tc.desc: SetOrientation test
547  * @tc.type: FUNC
548  */
549 HWTEST_F(AbstractScreenControllerTest, SetOrientation01, Function | SmallTest | Level3)
550 {
551     absController_->dmsScreenMap_[1]->isScreenGroup_ = true;
552     Orientation orientation = Orientation::BEGIN;
553     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetOrientation(1, orientation, true));
554 }
555 /**
556  * @tc.name: SetOrientation
557  * @tc.desc: SetOrientation test
558  * @tc.type: FUNC
559  */
560 HWTEST_F(AbstractScreenControllerTest, SetOrientation02, Function | SmallTest | Level3)
561 {
562     absController_->dmsScreenMap_[1]->isScreenGroup_ = false;
563 
564     Orientation orientation = Orientation::BEGIN;
565     bool isFromWindow = true;
566     DMError ret = absController_->SetOrientation(1, orientation, isFromWindow);
567     ASSERT_EQ(DMError::DM_OK, ret);
568 
569     orientation = Orientation::VERTICAL;
570     ret = absController_->SetOrientation(1, orientation, isFromWindow);
571     ASSERT_EQ(DMError::DM_OK, ret);
572 
573     isFromWindow = false;
574     ret = absController_->SetOrientation(1, orientation, isFromWindow);
575     ASSERT_EQ(DMError::DM_OK, ret);
576 
577     ret = absController_->SetOrientation(1, orientation, isFromWindow, false);
578     ASSERT_EQ(DMError::DM_OK, ret);
579 }
580 /**
581  * @tc.name: SetRotation
582  * @tc.desc: SetRotation test
583  * @tc.type: FUNC
584  */
585 HWTEST_F(AbstractScreenControllerTest, SetRotation01, Function | SmallTest | Level3)
586 {
587     absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
588     absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
589     ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
590     absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
591     ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, false));
592     ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
593 }
594 /**
595  * @tc.name: SetScreenActiveMode
596  * @tc.desc: SetScreenActiveMode test
597  * @tc.type: FUNC
598  */
599 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode01, Function | SmallTest | Level3)
600 {
601     ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(5, 0));
602 }
603 /**
604  * @tc.name: SetScreenActiveMode
605  * @tc.desc: SetScreenActiveMode test
606  * @tc.type: FUNC
607  */
608 HWTEST_F(AbstractScreenControllerTest, SetScreenActiveMode02, Function | SmallTest | Level3)
609 {
610     absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
611     ASSERT_TRUE(DMError::DM_OK != absController_->SetScreenActiveMode(1, 0));
612 }
613 /**
614  * @tc.name: ProcessScreenModeChanged
615  * @tc.desc: ProcessScreenModeChanged test
616  * @tc.type: FUNC
617  */
618 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged01, Function | SmallTest | Level3)
619 {
620     absController_->ProcessScreenModeChanged(7);
621     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
622 }
623 /**
624  * @tc.name: ProcessScreenModeChanged
625  * @tc.desc: ProcessScreenModeChanged test
626  * @tc.type: FUNC
627  */
628 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged02, Function | SmallTest | Level3)
629 {
630     absController_->ProcessScreenModeChanged(5);
631     ASSERT_EQ(nullptr, absController_->dmsScreenMap_[5]);
632 }
633 /**
634  * @tc.name: ProcessScreenModeChanged
635  * @tc.desc: ProcessScreenModeChanged test
636  * @tc.type: FUNC
637  */
638 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged03, Function | SmallTest | Level3)
639 {
640     absController_->ProcessScreenModeChanged(2);
641     ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
642 }
643 /**
644  * @tc.name: ProcessScreenModeChanged
645  * @tc.desc: ProcessScreenModeChanged test
646  * @tc.type: FUNC
647  */
648 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged04, Function | SmallTest | Level3)
649 {
650     sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
651     screen->activeIdx_ = 0;
652     absController_->abstractScreenCallback_ = nullptr;
653     absController_->ProcessScreenModeChanged(2);
654     ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
655 }
656 /**
657  * @tc.name: ProcessScreenModeChanged
658  * @tc.desc: ProcessScreenModeChanged test
659  * @tc.type: FUNC
660  */
661 HWTEST_F(AbstractScreenControllerTest, ProcessScreenModeChanged05, Function | SmallTest | Level3)
662 {
663     sptr<AbstractScreen> screen = absController_->GetAbstractScreen(2);
664     screen->activeIdx_ = 0;
665     absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
666     absController_->ProcessScreenModeChanged(2);
667     ASSERT_NE(nullptr, absController_->dmsScreenMap_[2]);
668 }
669 /**
670  * @tc.name: ChangeScreenGroup
671  * @tc.desc: ChangeScreenGroup test
672  * @tc.type: FUNC
673  */
674 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup01, Function | SmallTest | Level3)
675 {
676     sptr<AbstractScreenGroup> group = screenGroupVec[0];
677     Point point;
678     group->screenMap_.insert(std::make_pair(0, screenVec[0]));
679     group->screenMap_.insert(std::make_pair(1, screenVec[0]));
680     std::vector<Point> startPoints;
681     std::vector<ScreenId> screens;
682     for (ScreenId i = 0; i < 7; ++i) {
683         screens.emplace_back(i);
684         startPoints.emplace_back(point);
685         if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
686             absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
687         }
688     }
689     absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
690     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
691 }
692 /**
693  * @tc.name: ChangeScreenGroup
694  * @tc.desc: ChangeScreenGroup test
695  * @tc.type: FUNC
696  */
697 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup02, Function | SmallTest | Level3)
698 {
699     sptr<AbstractScreenGroup> group = screenGroupVec[0];
700     Point point;
701     group->screenMap_.insert(std::make_pair(0, screenVec[0]));
702     group->screenMap_.insert(std::make_pair(1, screenVec[0]));
703     std::vector<Point> startPoints;
704     std::vector<ScreenId> screens;
705     for (ScreenId i = 0; i < 7; ++i) {
706         screens.emplace_back(i);
707         startPoints.emplace_back(point);
708         if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
709             absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
710         }
711     }
712     absController_->abstractScreenCallback_ = nullptr;
713     absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
714     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
715 }
716 /**
717  * @tc.name: ChangeScreenGroup
718  * @tc.desc: ChangeScreenGroup test
719  * @tc.type: FUNC
720  */
721 HWTEST_F(AbstractScreenControllerTest, AddScreenToGroup01, Function | SmallTest | Level3)
722 {
723     sptr<AbstractScreenGroup> group = screenGroupVec[0];
724     std::vector<ScreenId> addScreens {0, 1, 2, 3, 4, 5};
725     Point point;
726     std::vector<Point> addChildPos(10, point);
727     std::map<ScreenId, bool> removeChildResMap;
728     absController_->AddScreenToGroup(group, addScreens, addChildPos, removeChildResMap);
729     absController_->abstractScreenCallback_ = nullptr;
730     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
731 }
732 
733 /**
734  * @tc.name: MakeExpand
735  * @tc.desc: MakeExpand test
736  * @tc.type: FUNC
737  */
738 HWTEST_F(AbstractScreenControllerTest, MakeExpand01, Function | SmallTest | Level3)
739 {
740     std::vector<ScreenId> screenIds;
741     std::vector<Point> startPoints;
742     ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
743     absController_->dmsScreenMap_[defaultId] = nullptr;
744     ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
745     ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
746 }
747 
748 /**
749  * @tc.name: MakeExpand
750  * @tc.desc: MakeExpand test
751  * @tc.type: FUNC
752  */
753 HWTEST_F(AbstractScreenControllerTest, MakeExpand02, Function | SmallTest | Level3)
754 {
755     std::vector<ScreenId> screenIds;
756     std::vector<Point> startPoints;
757     ScreenId defaultId = absController_->GetDefaultAbstractScreenId();
758     auto defaultScreen = absController_->GetAbstractScreen(defaultId);
759     if (defaultScreen != nullptr)
760     {
761         ScreenId groupDmsId = defaultScreen->groupDmsId_;
762         absController_->dmsScreenGroupMap_[groupDmsId] = nullptr;
763         ASSERT_EQ(false, absController_->MakeExpand(screenIds, startPoints));
764         ASSERT_EQ(DMError::DM_OK, absController_->StopScreens(screenIds, ScreenCombination::SCREEN_EXPAND));
765     }
766 }
767 
768 /**
769  * @tc.name: RemoveVirtualScreenFromGroup
770  * @tc.desc: RemoveVirtualScreenFromGroup test
771  * @tc.type: FUNC
772  */
773 HWTEST_F(AbstractScreenControllerTest, RemoveVirtualScreenFromGroup01, Function | SmallTest | Level3)
774 {
775     std::vector<ScreenId> screens {0, 1, 2, 3, 4, 5, 6, 7};
776     absController_->abstractScreenCallback_ = nullptr;
777     absController_->RemoveVirtualScreenFromGroup(screens);
778     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
779 }
780 
781 /**
782  * @tc.name: OnRemoteDied
783  * @tc.desc: OnRemoteDied test
784  * @tc.type: FUNC
785  */
786 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied01, Function | SmallTest | Level3)
787 {
788     sptr<IRemoteObject> agent = nullptr;
789     ASSERT_EQ(false, absController_->OnRemoteDied(agent));
790 }
791 
792 /**
793  * @tc.name: OnRemoteDied
794  * @tc.desc: OnRemoteDied test
795  * @tc.type: FUNC
796  */
797 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied02, Function | SmallTest | Level3)
798 {
799     sptr<IRemoteObject> agent = new IRemoteObjectMocker();
800     ASSERT_EQ(true, absController_->OnRemoteDied(agent));
801 }
802 
803 /**
804  * @tc.name: OnRemoteDied
805  * @tc.desc: OnRemoteDied test
806  * @tc.type: FUNC
807  */
808 HWTEST_F(AbstractScreenControllerTest, OnRemoteDied03, Function | SmallTest | Level3)
809 {
810     sptr<IRemoteObject> agent = new IRemoteObjectMocker();
811     std::vector<ScreenId> screens {5};
812     absController_->screenAgentMap_.insert(std::make_pair(agent, screens));
813     ASSERT_EQ(true, absController_->OnRemoteDied(agent));
814     ASSERT_EQ(0, absController_->screenAgentMap_.size());
815 }
816 
817 /**
818  * @tc.name: CreateAndGetNewScreenId
819  * @tc.desc: CreateAndGetNewScreenId test
820  * @tc.type: FUNC
821  */
822 HWTEST_F(AbstractScreenControllerTest, CreateAndGetNewScreenId01, Function | SmallTest | Level3)
823 {
824     ScreenId rsScreenId = 1;
825     ScreenId dmsScreenId = absController_->screenIdManager_.dmsScreenCount_;
826     ASSERT_EQ(dmsScreenId, absController_->screenIdManager_.CreateAndGetNewScreenId(rsScreenId));
827     ASSERT_EQ(++dmsScreenId, absController_->screenIdManager_.dmsScreenCount_);
828 }
829 
830 /**
831  * @tc.name: ConvertToRsScreenId
832  * @tc.desc: ConvertToRsScreenId test
833  * @tc.type: FUNC
834  */
835 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId01, Function | SmallTest | Level3)
836 {
837     ScreenId rsScreenId;
838     ScreenId dmsScreenId = 8;
839     ASSERT_EQ(false, absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId, rsScreenId));
840 }
841 
842 /**
843  * @tc.name: NotifyScreenConnected
844  * @tc.desc: NotifyScreenConnected test
845  * @tc.type: FUNC
846  */
847 HWTEST_F(AbstractScreenControllerTest, NotifyScreenConnected, Function | SmallTest | Level3)
848 {
849     sptr<ScreenInfo> screenInfo = nullptr;
850     absController_->NotifyScreenConnected(screenInfo);
851     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
852 }
853 
854 /**
855  * @tc.name: NotifyScreenConnected
856  * @tc.desc: NotifyScreenConnected test
857  * @tc.type: FUNC
858  */
859 HWTEST_F(AbstractScreenControllerTest, NotifyScreenChanged, Function | SmallTest | Level3)
860 {
861     sptr<ScreenInfo> screenInfo = nullptr;
862     absController_->NotifyScreenChanged(screenInfo, ScreenChangeEvent::UPDATE_ORIENTATION);
863     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
864 }
865 
866 /**
867  * @tc.name: NotifyScreenConnected
868  * @tc.desc: NotifyScreenConnected test
869  * @tc.type: FUNC
870  */
871 HWTEST_F(AbstractScreenControllerTest, NotifyScreenGroupChanged, Function | SmallTest | Level3)
872 {
873     sptr<ScreenInfo> screenInfo = nullptr;
874     absController_->NotifyScreenGroupChanged(screenInfo, ScreenGroupChangeEvent::ADD_TO_GROUP);
875     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
876 }
877 
878 /**
879  * @tc.name: NotifyScreenConnected
880  * @tc.desc: NotifyScreenConnected test
881  * @tc.type: FUNC
882  */
883 HWTEST_F(AbstractScreenControllerTest, SetScreenPowerForAll, Function | SmallTest | Level3)
884 {
885     ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::POWER_ON,
886         PowerStateChangeReason::POWER_BUTTON));
887 
888     for (uint32_t i = 0; i < screenVec.size(); ++i) {
889         if (screenVec[i] != nullptr && screenVec[i]->type_ == ScreenType::REAL) {
890             screenVec[i]->type_ = ScreenType::UNDEFINED;
891         }
892     }
893     ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::INVALID_STATE,
894         PowerStateChangeReason::POWER_BUTTON));
895 
896     ASSERT_EQ(false, absController_->SetScreenPowerForAll(ScreenPowerState::POWER_OFF,
897         PowerStateChangeReason::POWER_BUTTON));
898 }
899 /**
900  * @tc.name: SetVirtualPixelRatio
901  * @tc.desc: SetVirtualPixelRatio test
902  * @tc.type: FUNC
903  */
904 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio01, Function | SmallTest | Level3)
905 {
906     auto screen = screenVec[0];
907     ScreenId id = 0;
908     float ratio = 1.0;
909     screen->isScreenGroup_ = true;
910     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->SetVirtualPixelRatio(id, ratio));
911 }
912 /**
913  * @tc.name: SetVirtualPixelRatio
914  * @tc.desc: SetVirtualPixelRatio test
915  * @tc.type: FUNC
916  */
917 HWTEST_F(AbstractScreenControllerTest, SetVirtualPixelRatio02, Function | SmallTest | Level3)
918 {
919     ScreenId id = 0;
920     float ratio = 1.0;
921     absController_->abstractScreenCallback_ = nullptr;
922     ASSERT_EQ(DMError::DM_OK, absController_->SetVirtualPixelRatio(id, ratio));
923 }
924 /**
925  * @tc.name: RegisterRsScreenConnectionChangeListener
926  * @tc.desc: RegisterRsScreenConnectionChangeListener test
927  * @tc.type: FUNC
928  */
929 HWTEST_F(AbstractScreenControllerTest, RegisterRsScreenConnectionChangeListener, Function | SmallTest | Level3)
930 {
931     sptr<IRemoteObject> agent = new IRemoteObjectMocker();
932     absController_->Init();
933     ASSERT_EQ(true, absController_->OnRemoteDied(agent));
934     agent.clear();
935 }
936 /**
937  * @tc.name: RemoveSurfaceNodeFromScreen
938  * @tc.desc: RemoveSurfaceNodeFromScreen test
939  * @tc.type: FUNC
940  */
941 HWTEST_F(AbstractScreenControllerTest, RemoveSurfaceNodeFromScreen, Function | SmallTest | Level3)
942 {
943     ScreenId dmsScreenId = 8;
944     std::shared_ptr<RSSurfaceNode> surfaceNode = nullptr;
945     ASSERT_EQ(DMError::DM_ERROR_NULLPTR, absController_->RemoveSurfaceNodeFromScreen(dmsScreenId, surfaceNode));
946     ASSERT_EQ(nullptr, absController_->GetAbstractScreen(dmsScreenId));
947 }
948 /**
949  * @tc.name: ProcessDefaultScreenReconnected
950  * @tc.desc: ProcessDefaultScreenReconnected test
951  * @tc.type: FUNC
952  */
953 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected01, Function | SmallTest | Level3)
954 {
955     ScreenId rsScreenId = 8;
956     absController_->ProcessDefaultScreenReconnected(rsScreenId);
957     absController_->defaultRsScreenId_ = 8;
958     rsScreenId = 1;
959     absController_->ProcessDefaultScreenReconnected(rsScreenId);
960     rsScreenId = 8;
961     absController_->ProcessDefaultScreenReconnected(rsScreenId);
962     ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
963 }
964 /**
965  * @tc.name: ProcessDefaultScreenReconnected
966  * @tc.desc: ProcessDefaultScreenReconnected test
967  * @tc.type: FUNC
968  */
969 HWTEST_F(AbstractScreenControllerTest, ProcessDefaultScreenReconnected02, Function | SmallTest | Level3)
970 {
971     ScreenId rsScreenId = 8;
972     absController_->defaultRsScreenId_ = 8;
973     absController_->ProcessDefaultScreenReconnected(rsScreenId);
974     ASSERT_EQ(nullptr, absController_->GetAbstractScreen(rsScreenId));
975     rsScreenId = 5;
976     absController_->defaultRsScreenId_ = 5;
977     absController_->ProcessDefaultScreenReconnected(rsScreenId);
978     rsScreenId = 1;
979     absController_->defaultRsScreenId_ = 1;
980     absController_->ProcessDefaultScreenReconnected(rsScreenId);
981 }
982 
983 /**
984  * @tc.name: ConvertToRsScreenId
985  * @tc.desc: ConvertToRsScreenId test
986  * @tc.type: FUNC
987  */
988 HWTEST_F(AbstractScreenControllerTest, ConvertToRsScreenId, Function | SmallTest | Level3)
989 {
990     ScreenId dmsScreenId = 6;
991     ASSERT_TRUE(absController_->screenIdManager_.ConvertToRsScreenId(dmsScreenId));
992 }
993 
994 /**
995  * @tc.name: ConvertToDmsScreenId
996  * @tc.desc: ConvertToDmsScreenId test
997  * @tc.type: FUNC
998  */
999 HWTEST_F(AbstractScreenControllerTest, ConvertToDmsScreenId, Function | SmallTest | Level3)
1000 {
1001     ScreenId rsScreenId = 7;
1002     ASSERT_TRUE(absController_->screenIdManager_.ConvertToDmsScreenId(rsScreenId));
1003 }
1004 
1005 /**
1006  * @tc.name: AddSurfaceNodeToScreen
1007  * @tc.desc: AddSurfaceNodeToScreen test
1008  * @tc.type: FUNC
1009  */
1010 HWTEST_F(AbstractScreenControllerTest, AddSurfaceNodeToScreen, Function | SmallTest | Level3)
1011 {
1012     ScreenId dmsScreenId = 7;
1013     struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
1014     std::shared_ptr<RSSurfaceNode> surfaceNode = std::make_shared<RSSurfaceNode>(rsSurfaceNodeConfig, true, 0);
1015     DMError ret = absController_->AddSurfaceNodeToScreen(dmsScreenId, surfaceNode, true);
1016     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1017 
1018     dmsScreenId = 1;
1019     ret = absController_->AddSurfaceNodeToScreen(dmsScreenId, surfaceNode, true);
1020     ASSERT_EQ(ret, DMError::DM_ERROR_NULLPTR);
1021 }
1022 
1023 /**
1024  * @tc.name: GetScreenSupportedColorGamuts
1025  * @tc.desc: GetScreenSupportedColorGamuts test
1026  * @tc.type: FUNC
1027  */
1028 HWTEST_F(AbstractScreenControllerTest, GetScreenSupportedColorGamuts, Function | SmallTest | Level3)
1029 {
1030     ScreenId screenId = 1;
1031     std::vector<ScreenColorGamut> colorGamuts;
1032     DMError ret = absController_->GetScreenSupportedColorGamuts(screenId, colorGamuts);
1033 
1034     ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1035 }
1036 
1037 /**
1038  * @tc.name: GetScreenColorGamut
1039  * @tc.desc: GetScreenColorGamut test
1040  * @tc.type: FUNC
1041  */
1042 HWTEST_F(AbstractScreenControllerTest, GetScreenColorGamut, Function | SmallTest | Level3)
1043 {
1044     ScreenId screenId = 1;
1045     ScreenColorGamut colorGamut;
1046     DMError ret = absController_->GetScreenColorGamut(screenId, colorGamut);
1047 
1048     ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1049 }
1050 
1051 /**
1052  * @tc.name: SetScreenColorGamut
1053  * @tc.desc: SetScreenColorGamut test
1054  * @tc.type: FUNC
1055  */
1056 HWTEST_F(AbstractScreenControllerTest, SetScreenColorGamut, Function | SmallTest | Level3)
1057 {
1058     ScreenId screenId = 1;
1059     int32_t colorGamutIdx = 1;
1060     DMError ret = absController_->SetScreenColorGamut(screenId, colorGamutIdx);
1061 
1062     ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1063 }
1064 
1065 /**
1066  * @tc.name: GetScreenGamutMap
1067  * @tc.desc: GetScreenGamutMap test
1068  * @tc.type: FUNC
1069  */
1070 HWTEST_F(AbstractScreenControllerTest, GetScreenGamutMap, Function | SmallTest | Level3)
1071 {
1072     ScreenId screenId = 1;
1073     ScreenGamutMap gamutMap;
1074     DMError ret = absController_->GetScreenGamutMap(screenId, gamutMap);
1075 
1076     ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1077 }
1078 
1079 /**
1080  * @tc.name: SetScreenGamutMap
1081  * @tc.desc: SetScreenGamutMap test
1082  * @tc.type: FUNC
1083  */
1084 HWTEST_F(AbstractScreenControllerTest, SetScreenGamutMap, Function | SmallTest | Level3)
1085 {
1086     ScreenId screenId = 1;
1087     ScreenGamutMap gamutMap = {};
1088     DMError ret = absController_->SetScreenGamutMap(screenId, gamutMap);
1089 
1090     ASSERT_EQ(ret, DMError::DM_ERROR_RENDER_SERVICE_FAILED);
1091 }
1092 
1093 /**
1094  * @tc.name: SetScreenColorTransform
1095  * @tc.desc: SetScreenColorTransform test
1096  * @tc.type: FUNC
1097  */
1098 HWTEST_F(AbstractScreenControllerTest, SetScreenColorTransform, Function | SmallTest | Level3)
1099 {
1100     ScreenId screenId = 1;
1101     DMError ret = absController_->SetScreenColorTransform(screenId);
1102 
1103     ASSERT_EQ(ret, DMError::DM_OK);
1104 }
1105 
1106 /**
1107  * @tc.name: StopScreens
1108  * @tc.desc: StopScreens test
1109  * @tc.type: FUNC
1110  */
1111 HWTEST_F(AbstractScreenControllerTest, StopScreens, Function | SmallTest | Level3)
1112 {
1113     std::vector<ScreenId> screenIds = {7};
1114     ScreenCombination stopCombination = ScreenCombination::SCREEN_ALONE;
1115     DMError ret = absController_->StopScreens(screenIds, stopCombination);
1116     ASSERT_EQ(ret, DMError::DM_OK);
1117 
1118     screenIds[0] = 2;
1119     ret = absController_->StopScreens(screenIds, stopCombination);
1120     ASSERT_EQ(ret, DMError::DM_OK);
1121 
1122     absController_->dmsScreenMap_[2]->groupDmsId_=2;
1123     ret = absController_->StopScreens(screenIds, stopCombination);
1124     ASSERT_EQ(ret, DMError::DM_OK);
1125 
1126     absController_->dmsScreenMap_[2]->groupDmsId_=5;
1127     ret = absController_->StopScreens(screenIds, stopCombination);
1128     ASSERT_EQ(ret, DMError::DM_OK);
1129 
1130     absController_->dmsScreenMap_[2]->groupDmsId_=2;
1131     stopCombination = ScreenCombination::SCREEN_MIRROR;
1132     ret = absController_->StopScreens(screenIds, stopCombination);
1133     ASSERT_EQ(ret, DMError::DM_OK);
1134 }
1135 
1136 /**
1137  * @tc.name: ChangeScreenGroup
1138  * @tc.desc: ChangeScreenGroup test
1139  * @tc.type: FUNC
1140  */
1141 HWTEST_F(AbstractScreenControllerTest, ChangeScreenGroup03, Function | SmallTest | Level3)
1142 {
1143     sptr<AbstractScreenGroup> group = screenGroupVec[0];
1144     Point point;
1145     group->screenMap_.insert(std::make_pair(0, screenVec[0]));
1146     group->screenMap_.insert(std::make_pair(1, screenVec[0]));
1147     std::vector<Point> startPoints;
1148     std::vector<ScreenId> screens;
1149     for (ScreenId i = 0; i < 7; ++i) {
1150         screens.emplace_back(i);
1151         startPoints.emplace_back(point);
1152         if (i < absController_->dmsScreenMap_.size() && absController_->dmsScreenMap_[i] != nullptr) {
1153             absController_->dmsScreenMap_[i]->groupDmsId_ = 1;
1154         }
1155     }
1156     absController_->abstractScreenCallback_ = nullptr;
1157     absController_->ChangeScreenGroup(group, screens, startPoints, true, ScreenCombination::SCREEN_ALONE);
1158     ASSERT_EQ(6, absController_->dmsScreenMap_.size());
1159 }
1160 
1161 /**
1162  * @tc.name: UpdateRSTree
1163  * @tc.desc: UpdateRSTree test
1164  * @tc.type: FUNC
1165  */
1166 HWTEST_F(AbstractScreenControllerTest, UpdateRSTree06, Function | SmallTest | Level3)
1167 {
1168     ScreenId id = 1;
1169     ScreenId parentId = 2;
1170     std::shared_ptr<RSSurfaceNode> node = nullptr;
1171     RSDisplayNodeConfig config;
1172     ASSERT_NE(nullptr, absController_->GetAbstractScreen(id));
1173     sptr<AbstractScreen> parentScreen = absController_->GetAbstractScreen(parentId);
1174     ASSERT_NE(nullptr, absController_->GetAbstractScreen(parentId));
1175     parentScreen->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);;
1176     absController_->UpdateRSTree(id, parentId, node, true, false);
1177 }
1178 
1179 /**
1180  * @tc.name: SetScreenRotateAnimation
1181  * @tc.desc: SetScreenRotateAnimation test
1182  * @tc.type: FUNC
1183  */
1184 HWTEST_F(AbstractScreenControllerTest, SetScreenRotateAnimation04, Function | SmallTest | Level3)
1185 {
1186     RSDisplayNodeConfig config;
1187     absController_->dmsScreenMap_[1]->rsDisplayNode_ = std::make_shared<RSDisplayNode>(config);
1188     sptr<AbstractScreen> screen = screenVec[0];
1189     screen->rotation_ = Rotation::ROTATION_0;
1190     absController_->SetScreenRotateAnimation(screen, 1, Rotation::ROTATION_270, false);
1191     ASSERT_EQ(Rotation::ROTATION_0, screen->rotation_);
1192 }
1193 
1194 /**
1195  * @tc.name: SetRotation
1196  * @tc.desc: SetRotation test
1197  * @tc.type: FUNC
1198  */
1199 HWTEST_F(AbstractScreenControllerTest, SetRotation02, Function | SmallTest | Level3)
1200 {
1201     absController_->dmsScreenMap_[1]->rotation_ = Rotation::ROTATION_180;
1202     absController_->screenIdManager_.dms2RsScreenIdMap_.erase(1);
1203     ASSERT_EQ(true, absController_->SetRotation(1, Rotation::ROTATION_0, true));
1204     absController_->abstractScreenCallback_ = new AbstractScreenController::AbstractScreenCallback;
1205     ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, false));
1206     ASSERT_EQ(false, absController_->SetRotation(1, Rotation::ROTATION_0, true));
1207 }
1208 
1209 /**
1210  * @tc.name: InitVirtualScreen
1211  * @tc.desc: InitVirtualScreen test
1212  * @tc.type: FUNC
1213  */
1214 HWTEST_F(AbstractScreenControllerTest, InitVirtualScreen03, Function | SmallTest | Level3)
1215 {
1216     VirtualScreenOption option;
1217     sptr<AbstractScreen> defaultScreen = absController_->dmsScreenMap_[absController_->GetDefaultAbstractScreenId()];
1218     sptr<SupportedScreenModes> modes;
1219     if (defaultScreen != nullptr) {
1220         defaultScreen->modes_.emplace_back(modes);
1221         defaultScreen->activeIdx_ = 0;
1222         ASSERT_EQ(nullptr, defaultScreen->GetActiveScreenMode());
1223         sptr<AbstractScreen> screen = absController_->InitVirtualScreen(0, 0, option);
1224         ASSERT_EQ(ScreenType::VIRTUAL, screen->type_);
1225     }
1226 }
1227 }
1228 } // namespace Rosen
1229 } // namespace OHOS
1230