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 "display_manager_agent_controller.h"
19 #include "display_manager_agent_default.h"
20 #include "scene_board_judgement.h"
21 
22 using namespace testing;
23 using namespace testing::ext;
24 
25 namespace OHOS {
26 namespace Rosen {
27 class DisplayManagerAgentControllerTest : public testing::Test {
28 public:
29     static void SetUpTestCase();
30     static void TearDownTestCase();
31     void SetUp() override;
32     void TearDown() override;
33 };
34 
SetUpTestCase()35 void DisplayManagerAgentControllerTest::SetUpTestCase()
36 {
37 }
38 
TearDownTestCase()39 void DisplayManagerAgentControllerTest::TearDownTestCase()
40 {
41 }
42 
SetUp()43 void DisplayManagerAgentControllerTest::SetUp()
44 {
45 }
46 
TearDown()47 void DisplayManagerAgentControllerTest::TearDown()
48 {
49 }
50 
51 namespace {
52 /**
53  * @tc.name: NotifyDisplayStateChanged
54  * @tc.desc: NotifyDisplayStateChanged test
55  * @tc.type: FUNC
56  */
57 HWTEST_F(DisplayManagerAgentControllerTest, NotifyDisplayStateChanged, Function | SmallTest | Level3)
58 {
59     DisplayManagerAgentController displayManagerAgentController;
60     DisplayId id = 3;
61     DisplayState state = DisplayState::ON;
62     bool result = displayManagerAgentController.NotifyDisplayStateChanged(id, state);
63     EXPECT_FALSE(result);
64 
65     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
66     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
67     setIDisplay.insert(idma_);
68     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
69         {DisplayManagerAgentType::DISPLAY_STATE_LISTENER, setIDisplay});
70     result = displayManagerAgentController.NotifyDisplayStateChanged(id, state);
71     ASSERT_TRUE(result);
72 }
73 
74 /**
75  * @tc.name: OnScreenConnect
76  * @tc.desc: OnScreenConnect test
77  * @tc.type: FUNC
78  */
79 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenConnect, Function | SmallTest | Level3)
80 {
81     sptr<ScreenInfo> screenInfo = nullptr;
82     DisplayManagerAgentController::GetInstance().OnScreenConnect(screenInfo);
83     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
84                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
85 
86     DisplayManagerAgentController displayManagerAgentController;
87     screenInfo = new ScreenInfo();
88     displayManagerAgentController.OnScreenConnect(screenInfo);
89     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
90     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
91     setIDisplay.insert(idma_);
92     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
93         {DisplayManagerAgentType::SCREEN_EVENT_LISTENER, setIDisplay});
94     displayManagerAgentController.OnScreenConnect(screenInfo);
95     int result = displayManagerAgentController.dmAgentContainer_.
96         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
97     ASSERT_EQ(result, 1);
98 }
99 /**
100  * @tc.name: OnScreenChange
101  * @tc.desc: OnScreenChange test
102  * @tc.type: FUNC
103  */
104 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenChange, Function | SmallTest | Level3)
105 {
106     sptr<ScreenInfo> screenInfo = nullptr;
107     DisplayManagerAgentController::GetInstance().OnScreenChange(screenInfo, ScreenChangeEvent::UPDATE_ROTATION);
108     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
109                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
110 
111     DisplayManagerAgentController displayManagerAgentController;
112     screenInfo = new ScreenInfo();
113     ScreenChangeEvent screenChangeEvent = ScreenChangeEvent::CHANGE_MODE;
114     displayManagerAgentController.OnScreenChange(screenInfo, screenChangeEvent);
115     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
116     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
117     setIDisplay.insert(idma_);
118     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
119         {DisplayManagerAgentType::SCREEN_EVENT_LISTENER, setIDisplay});
120     displayManagerAgentController.OnScreenChange(screenInfo, screenChangeEvent);
121     int result = displayManagerAgentController.dmAgentContainer_.
122         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
123     ASSERT_EQ(result, 1);
124 }
125 /**
126  * @tc.name: OnScreenGroupChange
127  * @tc.desc: OnScreenChange test
128  * @tc.type: FUNC
129  */
130 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenGroupChange, Function | SmallTest | Level3)
131 {
132     sptr<ScreenInfo> screenInfo = nullptr;
133     std::string trigger;
134     DisplayManagerAgentController::GetInstance().OnScreenGroupChange(trigger, screenInfo,
135         ScreenGroupChangeEvent::ADD_TO_GROUP);
136     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
137                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
138     std::vector<sptr<ScreenInfo>> screenInfos;
139     screenInfos.push_back(screenInfo);
140     DisplayManagerAgentController::GetInstance().OnScreenGroupChange(trigger, screenInfos,
141         ScreenGroupChangeEvent::ADD_TO_GROUP);
142 
143     DisplayManagerAgentController displayManagerAgentController;
144     ScreenGroupChangeEvent groupEvent = ScreenGroupChangeEvent::ADD_TO_GROUP;
145     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
146     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
147     setIDisplay.insert(idma_);
148     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
149         {DisplayManagerAgentType::SCREEN_EVENT_LISTENER, setIDisplay});
150     displayManagerAgentController.OnScreenGroupChange(trigger, screenInfos, groupEvent);
151     int result = displayManagerAgentController.dmAgentContainer_.
152         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
153     ASSERT_EQ(result, 1);
154 }
155 /**
156  * @tc.name: OnDisplayCreate
157  * @tc.desc: OnDisplayCreate test
158  * @tc.type: FUNC
159  */
160 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayCreate, Function | SmallTest | Level3)
161 {
162     sptr<DisplayInfo> displayInfo;
163     DisplayManagerAgentController::GetInstance().OnDisplayCreate(displayInfo);
164     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
165                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
166 
167     DisplayManagerAgentController displayManagerAgentController;
168     displayInfo = new DisplayInfo();
169     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
170     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
171     setIDisplay.insert(idma_);
172     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
173         {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
174     displayManagerAgentController.OnDisplayCreate(displayInfo);
175     int result = displayManagerAgentController.dmAgentContainer_.
176         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
177     ASSERT_EQ(result, 0);
178 }
179 /**
180  * @tc.name: OnDisplayDestroy
181  * @tc.desc: OnDisplayDestroy test
182  * @tc.type: FUNC
183  */
184 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayDestroy, Function | SmallTest | Level3)
185 {
186     DisplayId displayId = 0;
187     DisplayManagerAgentController::GetInstance().OnDisplayDestroy(displayId);
188     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
189                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
190 
191     DisplayManagerAgentController displayManagerAgentController;
192     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
193     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
194     setIDisplay.insert(idma_);
195     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
196         {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
197     displayManagerAgentController.OnDisplayDestroy(displayId);
198     int result = displayManagerAgentController.dmAgentContainer_.
199         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
200     ASSERT_EQ(result, 0);
201 }
202 /**
203  * @tc.name: OnDisplayChange
204  * @tc.desc: OnDisplayChange test
205  * @tc.type: FUNC
206  */
207 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayChange, Function | SmallTest | Level3)
208 {
209     sptr<DisplayInfo> displayInfo = nullptr;
210     DisplayManagerAgentController::GetInstance().OnDisplayChange(displayInfo, DisplayChangeEvent::UNKNOWN);
211     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
212                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
213     displayInfo = new DisplayInfo();
214     DisplayManagerAgentController::GetInstance().OnDisplayChange(displayInfo, DisplayChangeEvent::UNKNOWN);
215     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
216                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
217 
218     DisplayChangeEvent displayChangeEvent = DisplayChangeEvent::UNKNOWN;
219     DisplayManagerAgentController displayManagerAgentController;
220     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
221     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
222     setIDisplay.insert(idma_);
223     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
224         {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
225     displayManagerAgentController.OnDisplayChange(displayInfo, displayChangeEvent);
226     int result = displayManagerAgentController.dmAgentContainer_.
227         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
228     ASSERT_EQ(result, 0);
229 }
230 /**
231  * @tc.name: OnScreenshot
232  * @tc.desc: OnScreenshot test
233  * @tc.type: FUNC
234  */
235 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenshot, Function | SmallTest | Level3)
236 {
237     sptr<ScreenshotInfo> info = nullptr;
238     DisplayManagerAgentController::GetInstance().OnScreenshot(info);
239     ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
240                 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
241 
242     info = new ScreenshotInfo();
243     DisplayManagerAgentController displayManagerAgentController;
244     displayManagerAgentController.OnScreenshot(info);
245     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
246     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
247     setIDisplay.insert(idma_);
248     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
249         {DisplayManagerAgentType::SCREENSHOT_EVENT_LISTENER, setIDisplay});
250     displayManagerAgentController.OnScreenshot(info);
251     int result = displayManagerAgentController.dmAgentContainer_.
252         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
253     ASSERT_EQ(result, 0);
254 }
255 
256 /**
257  * @tc.name: NotifyPrivateWindowStateChanged
258  * @tc.desc: NotifyPrivateWindowStateChanged test
259  * @tc.type: FUNC
260  */
261 HWTEST_F(DisplayManagerAgentControllerTest, NotifyPrivateWindowStateChanged, Function | SmallTest | Level3)
262 {
263     bool hasPrivate = true;
264     DisplayManagerAgentController displayManagerAgentController;
265     displayManagerAgentController.NotifyPrivateWindowStateChanged(hasPrivate);
266     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
267     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
268     setIDisplay.insert(idma_);
269     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
270         {DisplayManagerAgentType::PRIVATE_WINDOW_LISTENER, setIDisplay});
271     displayManagerAgentController.NotifyPrivateWindowStateChanged(hasPrivate);
272     int result = displayManagerAgentController.dmAgentContainer_.
273         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
274     ASSERT_EQ(result, 0);
275 }
276 
277 /**
278  * @tc.name: NotifyFoldStatusChanged
279  * @tc.desc: NotifyFoldStatusChanged test
280  * @tc.type: FUNC
281  */
282 HWTEST_F(DisplayManagerAgentControllerTest, NotifyFoldStatusChanged, Function | SmallTest | Level3)
283 {
284     FoldStatus foldStatus = FoldStatus::UNKNOWN;
285     DisplayManagerAgentController displayManagerAgentController;
286     displayManagerAgentController.NotifyFoldStatusChanged(foldStatus);
287     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
288     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
289     setIDisplay.insert(idma_);
290     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
291         {DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER, setIDisplay});
292     displayManagerAgentController.NotifyFoldStatusChanged(foldStatus);
293     int result = displayManagerAgentController.dmAgentContainer_.
294         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
295     ASSERT_EQ(result, 0);
296 }
297 
298 /**
299  * @tc.name: NotifyDisplayModeChanged
300  * @tc.desc: NotifyDisplayModeChanged test
301  * @tc.type: FUNC
302  */
303 HWTEST_F(DisplayManagerAgentControllerTest, NotifyDisplayModeChanged, Function | SmallTest | Level3)
304 {
305     FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
306     DisplayManagerAgentController displayManagerAgentController;
307     displayManagerAgentController.NotifyDisplayModeChanged(displayMode);
308     sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
309     std::set<sptr<IDisplayManagerAgent>> setIDisplay;
310     setIDisplay.insert(idma_);
311     displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
312         {DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER, setIDisplay});
313     displayManagerAgentController.NotifyDisplayModeChanged(displayMode);
314     int result = displayManagerAgentController.dmAgentContainer_.
315         GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
316     ASSERT_EQ(result, 0);
317 }
318 }
319 } // namespace Rosen
320 } // namespace OHOS
321