1 /*
2 * Copyright (c) 2023 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 "iremote_object_mocker.h"
19 #include "mock/mock_message_parcel.h"
20 #include "zidl/screen_session_manager_client_proxy.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Rosen {
27 namespace {
28 constexpr uint32_t SLEEP_TIME_IN_US = 100000; // 100ms
29 }
30 class ScreenSessionManagerClientProxyTest : public testing::Test {
31 public:
32 static void SetUpTestCase();
33 static void TearDownTestCase();
34 void SetUp() override;
35 void TearDown() override;
36 sptr<IRemoteObjectMocker> iRemoteObjectMocker_;
37 sptr<ScreenSessionManagerClientProxy> screenSessionManagerClientProxy_;
38 };
39
SetUpTestCase()40 void ScreenSessionManagerClientProxyTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void ScreenSessionManagerClientProxyTest::TearDownTestCase()
45 {
46 usleep(SLEEP_TIME_IN_US);
47 }
48
SetUp()49 void ScreenSessionManagerClientProxyTest::SetUp()
50 {
51 iRemoteObjectMocker_ = new IRemoteObjectMocker();
52 screenSessionManagerClientProxy_ = new ScreenSessionManagerClientProxy(iRemoteObjectMocker_);
53 }
54
TearDown()55 void ScreenSessionManagerClientProxyTest::TearDown()
56 {
57 screenSessionManagerClientProxy_ = nullptr;
58 }
59
60 /**
61 * @tc.name: OnScreenConnectionChanged
62 * @tc.desc: OnScreenConnectionChanged test
63 * @tc.type: FUNC
64 */
65 HWTEST_F(ScreenSessionManagerClientProxyTest, OnScreenConnectionChanged, TestSize.Level1)
66 {
67 ScreenEvent screenEvent = ScreenEvent::CONNECTED;
68 SessionOption option = {
69 .rsId_ = 0,
70 .isExtend_ = false,
71 .screenId_ = 0,
72 };
73 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
74 screenSessionManagerClientProxy_->OnScreenConnectionChanged(option, screenEvent);
75 }
76
77 /**
78 * @tc.name: SwitchUserCallback
79 * @tc.desc: SwitchUserCallback test
80 * @tc.type: FUNC
81 */
82 HWTEST_F(ScreenSessionManagerClientProxyTest, SwitchUserCallback, TestSize.Level1)
83 {
84 std::vector<int32_t> oldScbPids {0, 1};
85 int32_t currentScbPid = 0;
86
87 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
88 screenSessionManagerClientProxy_->SwitchUserCallback(oldScbPids, currentScbPid);
89 }
90
91 /**
92 * @tc.name: OnScreenExtendChanged
93 * @tc.desc: OnScreenExtendChanged test
94 * @tc.type: FUNC
95 */
96 HWTEST_F(ScreenSessionManagerClientProxyTest, OnScreenExtendChanged, TestSize.Level1)
97 {
98 ScreenId mainScreenId = 0;
99 ScreenId extendScreenId = 0;
100
101 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
102 screenSessionManagerClientProxy_->OnScreenExtendChanged(mainScreenId, extendScreenId);
103 }
104
105 /**
106 * @tc.name: OnPropertyChanged
107 * @tc.desc: OnPropertyChanged test
108 * @tc.type: FUNC
109 */
110 HWTEST_F(ScreenSessionManagerClientProxyTest, OnPropertyChanged, TestSize.Level1)
111 {
112 ScreenId screenId = 0;
113 ScreenProperty property;
114 ScreenPropertyChangeReason reason = ScreenPropertyChangeReason::UNDEFINED;
115
116 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
117 screenSessionManagerClientProxy_->OnPropertyChanged(screenId, property, reason);
118 }
119
120 /**
121 * @tc.name: OnSuperFoldStatusChanged
122 * @tc.desc: OnSuperFoldStatusChanged test
123 * @tc.type: FUNC
124 */
125 HWTEST_F(ScreenSessionManagerClientProxyTest, OnSuperFoldStatusChanged, TestSize.Level1)
126 {
127 ScreenId screenId = 0;
128 SuperFoldStatus superFoldStatus = SuperFoldStatus::UNKNOWN;
129
130 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
131 screenSessionManagerClientProxy_->OnSuperFoldStatusChanged(screenId, superFoldStatus);
132 }
133
134 /**
135 * @tc.name: OnPowerStatusChanged
136 * @tc.desc: OnPowerStatusChanged test
137 * @tc.type: FUNC
138 */
139 HWTEST_F(ScreenSessionManagerClientProxyTest, OnPowerStatusChanged, TestSize.Level1)
140 {
141 DisplayPowerEvent event = DisplayPowerEvent::DISPLAY_ON;
142 EventStatus status = EventStatus::BEGIN;
143 PowerStateChangeReason reason = PowerStateChangeReason::POWER_BUTTON;
144
145 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
146 screenSessionManagerClientProxy_->OnPowerStatusChanged(event, status, reason);
147 }
148
149 /**
150 * @tc.name: OnSensorRotationChanged
151 * @tc.desc: OnSensorRotationChanged test
152 * @tc.type: FUNC
153 */
154 HWTEST_F(ScreenSessionManagerClientProxyTest, OnSensorRotationChanged, TestSize.Level1)
155 {
156 ScreenId screenId = 0;
157 float sensorRotation = 0;
158
159 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
160 screenSessionManagerClientProxy_->OnSensorRotationChanged(screenId, sensorRotation);
161 }
162
163 /**
164 * @tc.name: OnHoverStatusChanged
165 * @tc.desc: OnHoverStatusChanged test
166 * @tc.type: FUNC
167 */
168 HWTEST_F(ScreenSessionManagerClientProxyTest, OnHoverStatusChanged, TestSize.Level1)
169 {
170 ScreenId screenId = 0;
171 int32_t hoverStatus = 0;
172
173 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
174 screenSessionManagerClientProxy_->OnHoverStatusChanged(screenId, hoverStatus);
175 }
176
177 /**
178 * @tc.name: OnScreenOrientationChanged
179 * @tc.desc: OnScreenOrientationChanged test
180 * @tc.type: FUNC
181 */
182 HWTEST_F(ScreenSessionManagerClientProxyTest, OnScreenOrientationChanged, TestSize.Level1)
183 {
184 ScreenId screenId = 0;
185 float screenOrientation = 0;
186
187 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
188 screenSessionManagerClientProxy_->OnScreenOrientationChanged(screenId, screenOrientation);
189 }
190
191 /**
192 * @tc.name: OnScreenRotationLockedChanged
193 * @tc.desc: OnScreenRotationLockedChanged test
194 * @tc.type: FUNC
195 */
196 HWTEST_F(ScreenSessionManagerClientProxyTest, OnScreenRotationLockedChanged, TestSize.Level1)
197 {
198 ScreenId screenId = 0;
199 bool isLocked = false;
200
201 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
202 screenSessionManagerClientProxy_->OnScreenRotationLockedChanged(screenId, isLocked);
203 }
204
205 /**
206 * @tc.name: OnDisplayStateChanged
207 * @tc.desc: OnDisplayStateChanged test
208 * @tc.type: FUNC
209 */
210 HWTEST_F(ScreenSessionManagerClientProxyTest, OnDisplayStateChanged, TestSize.Level1)
211 {
212 ScreenId screenId = 0;
213 sptr<DisplayInfo> displayInfo = new DisplayInfo();
214 std::map<DisplayId, sptr<DisplayInfo>> displayInfoMap {
215 { displayInfo->GetDisplayId(), displayInfo },
216 };
217 DisplayStateChangeType type = DisplayStateChangeType::BEFORE_SUSPEND;
218
219 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
220 screenSessionManagerClientProxy_->OnDisplayStateChanged(screenId, displayInfo, displayInfoMap, type);
221 }
222
223 /**
224 * @tc.name: OnGetSurfaceNodeIdsFromMissionIdsChanged
225 * @tc.desc: OnGetSurfaceNodeIdsFromMissionIdsChanged test
226 * @tc.type: FUNC
227 */
228 HWTEST_F(ScreenSessionManagerClientProxyTest, OnGetSurfaceNodeIdsFromMissionIdsChanged, TestSize.Level1)
229 {
230 std::vector<uint64_t> missionIds = {0, 1};
231 std::vector<uint64_t> surfaceNodeIds;
232 bool isBlackList = false;
233 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
234 screenSessionManagerClientProxy_->OnGetSurfaceNodeIdsFromMissionIdsChanged(missionIds, surfaceNodeIds, isBlackList);
235 }
236
237 /**
238 * @tc.name: OnUpdateFoldDisplayMode
239 * @tc.desc: OnUpdateFoldDisplayMode test
240 * @tc.type: FUNC
241 */
242 HWTEST_F(ScreenSessionManagerClientProxyTest, OnUpdateFoldDisplayMode, TestSize.Level1)
243 {
244 FoldDisplayMode displayMode = FoldDisplayMode::MAIN;
245
246 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
247 screenSessionManagerClientProxy_->OnUpdateFoldDisplayMode(displayMode);
248 }
249
250 /**
251 * @tc.name: OnScreenshot
252 * @tc.desc: OnScreenshot test
253 * @tc.type: FUNC
254 */
255 HWTEST_F(ScreenSessionManagerClientProxyTest, OnScreenshot, TestSize.Level1)
256 {
257 ScreenId screenId = 0;
258
259 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
260 screenSessionManagerClientProxy_->OnScreenshot(screenId);
261 }
262
263 /**
264 * @tc.name: OnImmersiveStateChanged
265 * @tc.desc: OnImmersiveStateChanged test
266 * @tc.type: FUNC
267 */
268 HWTEST_F(ScreenSessionManagerClientProxyTest, OnImmersiveStateChanged, TestSize.Level1)
269 {
270 bool immersive = false;
271
272 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
273 screenSessionManagerClientProxy_->OnImmersiveStateChanged(0u, immersive);
274 }
275
276 /**
277 * @tc.name: SetDisplayNodeScreenId
278 * @tc.desc: SetDisplayNodeScreenId test
279 * @tc.type: FUNC
280 */
281 HWTEST_F(ScreenSessionManagerClientProxyTest, SetDisplayNodeScreenId, TestSize.Level1)
282 {
283 ScreenId screenId = 0;
284 ScreenId displayNodeScreenId = 0;
285
286 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
287 screenSessionManagerClientProxy_->SetDisplayNodeScreenId(screenId, displayNodeScreenId);
288 }
289
290 /**
291 * @tc.name: SetVirtualPixelRatioSystem
292 * @tc.desc: SetVirtualPixelRatioSystem test
293 * @tc.type: FUNC
294 */
295 HWTEST_F(ScreenSessionManagerClientProxyTest, SetVirtualPixelRatioSystem, TestSize.Level1)
296 {
297 ScreenId screenId = 0;
298 float virtualPixelRatio = 1.0f;
299
300 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
301 screenSessionManagerClientProxy_->SetVirtualPixelRatioSystem(screenId, virtualPixelRatio);
302 }
303
304 /**
305 * @tc.name: OnFoldStatusChangedReportUE
306 * @tc.desc: OnFoldStatusChangedReportUE test
307 * @tc.type: FUNC
308 */
309 HWTEST_F(ScreenSessionManagerClientProxyTest, OnFoldStatusChangedReportUE, TestSize.Level1)
310 {
311 std::vector<std::string> screenFoldInfo = {"0", "0", "0", "0"};
312
313 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
314 screenSessionManagerClientProxy_->OnFoldStatusChangedReportUE(screenFoldInfo);
315 }
316
317 /**
318 * @tc.name: ScreenCaptureNotify
319 * @tc.desc: ScreenCaptureNotify test
320 * @tc.type: FUNC
321 */
322 HWTEST_F(ScreenSessionManagerClientProxyTest, ScreenCaptureNotify, TestSize.Level1)
323 {
324 ScreenId screenId = 0;
325 int32_t uid = 0;
326 std::string clientName = "test";
327
328 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
329 screenSessionManagerClientProxy_->ScreenCaptureNotify(screenId, uid, clientName);
330 }
331
332 /**
333 * @tc.name: OnCreateScreenSessionOnly
334 * @tc.desc: OnCreateScreenSessionOnly test
335 * @tc.type: FUNC
336 */
337 HWTEST_F(ScreenSessionManagerClientProxyTest, OnCreateScreenSessionOnly, TestSize.Level1)
338 {
339 ScreenId screenId = 0;
340 ScreenId rsId = 0;
341 std::string name = "test";
342 bool isExtend = false;
343
344 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
345 screenSessionManagerClientProxy_->OnCreateScreenSessionOnly(screenId, rsId, name, isExtend);
346 }
347
348 /**
349 * @tc.name: OnExtendDisplayNodeChange
350 * @tc.desc: OnExtendDisplayNodeChange test
351 * @tc.type: FUNC
352 */
353 HWTEST_F(ScreenSessionManagerClientProxyTest, OnExtendDisplayNodeChange, TestSize.Level1)
354 {
355 ScreenId firstId = 0;
356 ScreenId secondId = 12;
357
358 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
359 screenSessionManagerClientProxy_->OnExtendDisplayNodeChange(firstId, secondId);
360 }
361
362 /**
363 * @tc.name: OnMainDisplayNodeChange
364 * @tc.desc: OnMainDisplayNodeChange test
365 * @tc.type: FUNC
366 */
367 HWTEST_F(ScreenSessionManagerClientProxyTest, OnMainDisplayNodeChange, TestSize.Level1)
368 {
369 ScreenId mainScreenId = 0;
370 ScreenId extendScreenId = 12;
371 ScreenId extendRSId = 12;
372
373 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
374 screenSessionManagerClientProxy_->OnMainDisplayNodeChange(mainScreenId, extendScreenId, extendRSId);
375 }
376
377 /**
378 * @tc.name: SetScreenCombination
379 * @tc.desc: SetScreenCombination test
380 * @tc.type: FUNC
381 */
382 HWTEST_F(ScreenSessionManagerClientProxyTest, SetScreenCombination, TestSize.Level1)
383 {
384 ScreenId mainScreenId = 0;
385 ScreenId extendScreenId = 12;
386 ScreenCombination combination = ScreenCombination::SCREEN_ALONE;
387
388 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
389 screenSessionManagerClientProxy_->SetScreenCombination(mainScreenId, extendScreenId, combination);
390 }
391
392 /**
393 * @tc.name: OnDumperClientScreenSessions
394 * @tc.desc: OnDumperClientScreenSessions test
395 * @tc.type: FUNC
396 */
397 HWTEST_F(ScreenSessionManagerClientProxyTest, OnDumperClientScreenSessions, TestSize.Level1)
398 {
399 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
400 screenSessionManagerClientProxy_->OnDumperClientScreenSessions();
401 }
402
403 /**
404 * @tc.name: OnBeforeScreenPropertyChanged
405 * @tc.desc: OnBeforeScreenPropertyChanged test
406 * @tc.type: FUNC
407 */
408 HWTEST_F(ScreenSessionManagerClientProxyTest, OnBeforeScreenPropertyChanged, TestSize.Level1)
409 {
410 screenSessionManagerClientProxy_->OnBeforeScreenPropertyChanged(FoldStatus::UNKNOWN);
411 ASSERT_TRUE(screenSessionManagerClientProxy_ != nullptr);
412 }
413
414 /**
415 * @tc.name: OnSetSurfaceNodeIdsChanged
416 * @tc.desc: OnSetSurfaceNodeIdsChanged test
417 * @tc.type: FUNC
418 */
419 HWTEST_F(ScreenSessionManagerClientProxyTest, OnSetSurfaceNodeIdsChanged, TestSize.Level1)
420 {
421 MockMessageParcel::ClearAllErrorFlag();
422 DisplayId displayId = 10;
423 std::vector<uint64_t> surfaceNodeIds = { 100, 101 };
424 auto ssmProxy = sptr<ScreenSessionManagerClientProxy>::MakeSptr(nullptr);
425 ssmProxy->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
426
427 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
428 ssmProxy = sptr<ScreenSessionManagerClientProxy>::MakeSptr(remoteMocker);
429 ASSERT_NE(nullptr, ssmProxy);
430 ssmProxy->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
431
432 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
433 ssmProxy->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
434 remoteMocker->SetRequestResult(ERR_NONE);
435
436 MockMessageParcel::SetWriteUint64ErrorFlag(true);
437 ssmProxy->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
438
439 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
440 ssmProxy->OnSetSurfaceNodeIdsChanged(displayId, surfaceNodeIds);
441 MockMessageParcel::ClearAllErrorFlag();
442 }
443
444 /**
445 * @tc.name: OnVirtualScreenDisconnected
446 * @tc.desc: OnVirtualScreenDisconnected test
447 * @tc.type: FUNC
448 */
449 HWTEST_F(ScreenSessionManagerClientProxyTest, OnVirtualScreenDisconnected, TestSize.Level1)
450 {
451 MockMessageParcel::ClearAllErrorFlag();
452 DisplayId displayId = 10;
453 auto ssmProxy = sptr<ScreenSessionManagerClientProxy>::MakeSptr(nullptr);
454 ssmProxy->OnVirtualScreenDisconnected(displayId);
455
456 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
457 ssmProxy = sptr<ScreenSessionManagerClientProxy>::MakeSptr(remoteMocker);
458 ASSERT_NE(nullptr, ssmProxy);
459 ssmProxy->OnVirtualScreenDisconnected(displayId);
460
461 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
462 ssmProxy->OnVirtualScreenDisconnected(displayId);
463 remoteMocker->SetRequestResult(ERR_NONE);
464
465 MockMessageParcel::SetWriteUint64ErrorFlag(true);
466 ssmProxy->OnVirtualScreenDisconnected(displayId);
467
468 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
469 ssmProxy->OnVirtualScreenDisconnected(displayId);
470 MockMessageParcel::ClearAllErrorFlag();
471 }
472 } // namespace Rosen
473 } // namespace OHOS
474