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 /**
101 * @tc.name: OnScreenChange
102 * @tc.desc: OnScreenChange test
103 * @tc.type: FUNC
104 */
105 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenChange, Function | SmallTest | Level3)
106 {
107 sptr<ScreenInfo> screenInfo = nullptr;
108 DisplayManagerAgentController::GetInstance().OnScreenChange(screenInfo, ScreenChangeEvent::UPDATE_ROTATION);
109 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
110 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
111
112 DisplayManagerAgentController displayManagerAgentController;
113 screenInfo = new ScreenInfo();
114 ScreenChangeEvent screenChangeEvent = ScreenChangeEvent::CHANGE_MODE;
115 displayManagerAgentController.OnScreenChange(screenInfo, screenChangeEvent);
116 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
117 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
118 setIDisplay.insert(idma_);
119 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
120 {DisplayManagerAgentType::SCREEN_EVENT_LISTENER, setIDisplay});
121 displayManagerAgentController.OnScreenChange(screenInfo, screenChangeEvent);
122 int result = displayManagerAgentController.dmAgentContainer_.
123 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
124 ASSERT_EQ(result, 1);
125 }
126
127 /**
128 * @tc.name: OnScreenGroupChange
129 * @tc.desc: OnScreenChange test
130 * @tc.type: FUNC
131 */
132 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenGroupChange, Function | SmallTest | Level3)
133 {
134 sptr<ScreenInfo> screenInfo = nullptr;
135 std::string trigger;
136 DisplayManagerAgentController::GetInstance().OnScreenGroupChange(trigger, screenInfo,
137 ScreenGroupChangeEvent::ADD_TO_GROUP);
138 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
139 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
140 std::vector<sptr<ScreenInfo>> screenInfos;
141 screenInfos.push_back(screenInfo);
142 DisplayManagerAgentController::GetInstance().OnScreenGroupChange(trigger, screenInfos,
143 ScreenGroupChangeEvent::ADD_TO_GROUP);
144
145 DisplayManagerAgentController displayManagerAgentController;
146 ScreenGroupChangeEvent groupEvent = ScreenGroupChangeEvent::ADD_TO_GROUP;
147 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
148 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
149 setIDisplay.insert(idma_);
150 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
151 {DisplayManagerAgentType::SCREEN_EVENT_LISTENER, setIDisplay});
152 displayManagerAgentController.OnScreenGroupChange(trigger, screenInfos, groupEvent);
153 int result = displayManagerAgentController.dmAgentContainer_.
154 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
155 ASSERT_EQ(result, 1);
156 }
157
158 /**
159 * @tc.name: OnDisplayCreate
160 * @tc.desc: OnDisplayCreate test
161 * @tc.type: FUNC
162 */
163 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayCreate, Function | SmallTest | Level3)
164 {
165 sptr<DisplayInfo> displayInfo;
166 DisplayManagerAgentController::GetInstance().OnDisplayCreate(displayInfo);
167 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
168 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
169
170 DisplayManagerAgentController displayManagerAgentController;
171 displayInfo = new DisplayInfo();
172 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
173 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
174 setIDisplay.insert(idma_);
175 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
176 {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
177 displayManagerAgentController.OnDisplayCreate(displayInfo);
178 int result = displayManagerAgentController.dmAgentContainer_.
179 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
180 ASSERT_EQ(result, 0);
181 }
182
183 /**
184 * @tc.name: OnDisplayDestroy
185 * @tc.desc: OnDisplayDestroy test
186 * @tc.type: FUNC
187 */
188 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayDestroy, Function | SmallTest | Level3)
189 {
190 DisplayId displayId = 0;
191 DisplayManagerAgentController::GetInstance().OnDisplayDestroy(displayId);
192 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
193 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
194
195 DisplayManagerAgentController displayManagerAgentController;
196 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
197 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
198 setIDisplay.insert(idma_);
199 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
200 {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
201 displayManagerAgentController.OnDisplayDestroy(displayId);
202 int result = displayManagerAgentController.dmAgentContainer_.
203 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
204 ASSERT_EQ(result, 0);
205 }
206
207 /**
208 * @tc.name: OnDisplayChange
209 * @tc.desc: OnDisplayChange test
210 * @tc.type: FUNC
211 */
212 HWTEST_F(DisplayManagerAgentControllerTest, OnDisplayChange, Function | SmallTest | Level3)
213 {
214 sptr<DisplayInfo> displayInfo = nullptr;
215 DisplayManagerAgentController::GetInstance().OnDisplayChange(displayInfo, DisplayChangeEvent::UNKNOWN);
216 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
217 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
218 displayInfo = new DisplayInfo();
219 DisplayManagerAgentController::GetInstance().OnDisplayChange(displayInfo, DisplayChangeEvent::UNKNOWN);
220 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
221 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
222
223 DisplayChangeEvent displayChangeEvent = DisplayChangeEvent::UNKNOWN;
224 DisplayManagerAgentController displayManagerAgentController;
225 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
226 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
227 setIDisplay.insert(idma_);
228 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
229 {DisplayManagerAgentType::DISPLAY_EVENT_LISTENER, setIDisplay});
230 displayManagerAgentController.OnDisplayChange(displayInfo, displayChangeEvent);
231 int result = displayManagerAgentController.dmAgentContainer_.
232 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
233 ASSERT_EQ(result, 0);
234 }
235
236 /**
237 * @tc.name: OnScreenshot
238 * @tc.desc: OnScreenshot test
239 * @tc.type: FUNC
240 */
241 HWTEST_F(DisplayManagerAgentControllerTest, OnScreenshot, Function | SmallTest | Level3)
242 {
243 sptr<ScreenshotInfo> info = nullptr;
244 DisplayManagerAgentController::GetInstance().OnScreenshot(info);
245 ASSERT_EQ(0, DisplayManagerAgentController::GetInstance().
246 dmAgentContainer_.GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size());
247
248 info = new ScreenshotInfo();
249 DisplayManagerAgentController displayManagerAgentController;
250 displayManagerAgentController.OnScreenshot(info);
251 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
252 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
253 setIDisplay.insert(idma_);
254 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
255 {DisplayManagerAgentType::SCREENSHOT_EVENT_LISTENER, setIDisplay});
256 displayManagerAgentController.OnScreenshot(info);
257 int result = displayManagerAgentController.dmAgentContainer_.
258 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
259 ASSERT_EQ(result, 0);
260 }
261
262 /**
263 * @tc.name: NotifyPrivateWindowStateChanged
264 * @tc.desc: NotifyPrivateWindowStateChanged test
265 * @tc.type: FUNC
266 */
267 HWTEST_F(DisplayManagerAgentControllerTest, NotifyPrivateWindowStateChanged, Function | SmallTest | Level3)
268 {
269 bool hasPrivate = true;
270 DisplayManagerAgentController displayManagerAgentController;
271 displayManagerAgentController.NotifyPrivateWindowStateChanged(hasPrivate);
272 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
273 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
274 setIDisplay.insert(idma_);
275 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
276 {DisplayManagerAgentType::PRIVATE_WINDOW_LISTENER, setIDisplay});
277 displayManagerAgentController.NotifyPrivateWindowStateChanged(hasPrivate);
278 int result = displayManagerAgentController.dmAgentContainer_.
279 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
280 ASSERT_EQ(result, 0);
281 }
282
283 /**
284 * @tc.name: NotifyFoldStatusChanged
285 * @tc.desc: NotifyFoldStatusChanged test
286 * @tc.type: FUNC
287 */
288 HWTEST_F(DisplayManagerAgentControllerTest, NotifyFoldStatusChanged, Function | SmallTest | Level3)
289 {
290 FoldStatus foldStatus = FoldStatus::UNKNOWN;
291 DisplayManagerAgentController displayManagerAgentController;
292 displayManagerAgentController.NotifyFoldStatusChanged(foldStatus);
293 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
294 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
295 setIDisplay.insert(idma_);
296 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
297 {DisplayManagerAgentType::FOLD_STATUS_CHANGED_LISTENER, setIDisplay});
298 displayManagerAgentController.NotifyFoldStatusChanged(foldStatus);
299 int result = displayManagerAgentController.dmAgentContainer_.
300 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
301 ASSERT_EQ(result, 0);
302 }
303
304 /**
305 * @tc.name: NotifyDisplayModeChanged
306 * @tc.desc: NotifyDisplayModeChanged test
307 * @tc.type: FUNC
308 */
309 HWTEST_F(DisplayManagerAgentControllerTest, NotifyDisplayModeChanged, Function | SmallTest | Level3)
310 {
311 FoldDisplayMode displayMode = FoldDisplayMode::UNKNOWN;
312 DisplayManagerAgentController displayManagerAgentController;
313 displayManagerAgentController.NotifyDisplayModeChanged(displayMode);
314 sptr<IDisplayManagerAgent> idma_ = new DisplayManagerAgentDefault();
315 std::set<sptr<IDisplayManagerAgent>> setIDisplay;
316 setIDisplay.insert(idma_);
317 displayManagerAgentController.dmAgentContainer_.agentMap_.insert(
318 {DisplayManagerAgentType::DISPLAY_MODE_CHANGED_LISTENER, setIDisplay});
319 displayManagerAgentController.NotifyDisplayModeChanged(displayMode);
320 int result = displayManagerAgentController.dmAgentContainer_.
321 GetAgentsByType(DisplayManagerAgentType::SCREEN_EVENT_LISTENER).size();
322 ASSERT_EQ(result, 0);
323 }
324 }
325 } // namespace Rosen
326 } // namespace OHOS
327