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 #include "iremote_object_mocker.h"
18 #include "mock/mock_message_parcel.h"
19 #include "mock/mock_session.h"
20 #include "mock/mock_session_stage.h"
21 #include "mock/mock_window_event_channel.h"
22 #include "mock/mock_ui_effect_controller_client_stub.h"
23 #include "mock/mock_ui_effect_controller_stub.h"
24 #include "screen_session_manager_client/include/screen_session_manager_client.h"
25 #include "session_manager/include/scene_session_manager.h"
26 #include "session_manager/include/zidl/scene_session_manager_interface.h"
27 #include "session_manager/include/zidl/scene_session_manager_proxy.h"
28 #include "window_manager_agent.h"
29 #include "zidl/window_manager_agent_interface.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33 namespace OHOS {
34 namespace Rosen {
35 class sceneSessionManagerProxyTest : public testing::Test {
36 public:
37 static void SetUpTestCase();
38 static void TearDownTestCase();
39 void SetUp() override;
40 void TearDown() override;
41 sptr<IRemoteObject> iRemoteObjectMocker;
42 };
43
SetUpTestCase()44 void sceneSessionManagerProxyTest::SetUpTestCase() {}
45
TearDownTestCase()46 void sceneSessionManagerProxyTest::TearDownTestCase() {}
47
SetUp()48 void sceneSessionManagerProxyTest::SetUp() {}
49
TearDown()50 void sceneSessionManagerProxyTest::TearDown() {}
51
52 namespace {
53 /**
54 * @tc.name: CreateAndConnectSpecificSession
55 * @tc.desc: normal function
56 * @tc.type: FUNC
57 */
58 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession, TestSize.Level1)
59 {
60 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
61 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
62 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
63 EXPECT_NE(sceneSessionManagerProxy, nullptr);
64
65 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
66 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
67 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
68 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
69 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
70 node->SetRSUIContext(rsUIContext);
71 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
72 int32_t persistentId = 0;
73 SessionInfo info;
74 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
75 SystemSessionConfig systemConfig;
76 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
77
78 sceneSessionManagerProxy->CreateAndConnectSpecificSession(
79 sessionStage, eventChannel, node, property, persistentId, session, systemConfig, token);
80 EXPECT_NE(sceneSessionManagerProxy, nullptr);
81 }
82
83 /**
84 * @tc.name: CreateAndConnectSpecificSession2
85 * @tc.desc: normal function
86 * @tc.type: FUNC
87 */
88 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession2, TestSize.Level1)
89 {
90 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
91 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
92 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
93 EXPECT_NE(sceneSessionManagerProxy, nullptr);
94
95 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
96 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
97 std::shared_ptr<RSSurfaceNode> node = nullptr;
98 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
99 int32_t persistentId = 0;
100 SessionInfo info;
101 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
102 SystemSessionConfig systemConfig;
103 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
104
105 sceneSessionManagerProxy->CreateAndConnectSpecificSession(
106 sessionStage, eventChannel, node, property, persistentId, session, systemConfig, token);
107 EXPECT_NE(sceneSessionManagerProxy, nullptr);
108 }
109
110 /**
111 * @tc.name: CreateAndConnectSpecificSession3
112 * @tc.desc: normal function
113 * @tc.type: FUNC
114 */
115 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession3, TestSize.Level1)
116 {
117 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
118 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
119 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
120 EXPECT_NE(sceneSessionManagerProxy, nullptr);
121
122 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
123 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
124 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
125 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
126 sptr<WindowSessionProperty> property = nullptr;
127 int32_t persistentId = 0;
128 SessionInfo info;
129 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
130 SystemSessionConfig systemConfig;
131 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
132
133 sceneSessionManagerProxy->CreateAndConnectSpecificSession(
134 sessionStage, eventChannel, node, property, persistentId, session, systemConfig, token);
135 EXPECT_NE(sceneSessionManagerProxy, nullptr);
136 }
137
138 /**
139 * @tc.name: CreateAndConnectSpecificSession4
140 * @tc.desc: normal function
141 * @tc.type: FUNC
142 */
143 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession4, TestSize.Level1)
144 {
145 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
146 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
147 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
148 EXPECT_NE(sceneSessionManagerProxy, nullptr);
149
150 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
151 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
152 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
153 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
154 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
155 node->SetRSUIContext(rsUIContext);
156 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
157 int32_t persistentId = 0;
158 SessionInfo info;
159 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
160 SystemSessionConfig systemConfig;
161 sptr<IRemoteObject> token = nullptr;
162
163 sceneSessionManagerProxy->CreateAndConnectSpecificSession(
164 sessionStage, eventChannel, node, property, persistentId, session, systemConfig, token);
165 EXPECT_NE(sceneSessionManagerProxy, nullptr);
166 }
167
168 /**
169 * @tc.name: RecoverAndConnectSpecificSession
170 * @tc.desc: normal function
171 * @tc.type: FUNC
172 */
173 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndConnectSpecificSession, TestSize.Level1)
174 {
175 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
176 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
177
178 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
179 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
180 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
181 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
182 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
183 node->SetRSUIContext(rsUIContext);
184 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
185 SessionInfo info;
186 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
187 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
188
189 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(
190 sessionStage, eventChannel, node, property, session, token);
191 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
192 }
193
194 /**
195 * @tc.name: RecoverAndConnectSpecificSession2
196 * @tc.desc: normal function
197 * @tc.type: FUNC
198 */
199 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndConnectSpecificSession2, TestSize.Level1)
200 {
201 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
202 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
203
204 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
205 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
206 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
207 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
208 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
209 node->SetRSUIContext(rsUIContext);
210 sptr<WindowSessionProperty> property = nullptr;
211 SessionInfo info;
212 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
213 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
214
215 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(
216 sessionStage, eventChannel, node, property, session, token);
217 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
218 }
219
220 /**
221 * @tc.name: RecoverAndConnectSpecificSession3
222 * @tc.desc: normal function
223 * @tc.type: FUNC
224 */
225 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndConnectSpecificSession3, TestSize.Level1)
226 {
227 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
228 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
229
230 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
231 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
232 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
233 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
234 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
235 node->SetRSUIContext(rsUIContext);
236 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
237 SessionInfo info;
238 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
239 sptr<IRemoteObject> token = nullptr;
240
241 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(
242 sessionStage, eventChannel, node, property, session, token);
243 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
244 }
245
246 /**
247 * @tc.name: RecoverAndReconnectSceneSession
248 * @tc.desc: normal function
249 * @tc.type: FUNC
250 */
251 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession, TestSize.Level1)
252 {
253 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
254 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
255
256 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
257 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
258 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
259 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
260 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
261 node->SetRSUIContext(rsUIContext);
262 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
263 SessionInfo info;
264 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
265 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
266
267 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(
268 sessionStage, eventChannel, node, session, property, token);
269 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
270 }
271
272 /**
273 * @tc.name: RecoverAndReconnectSceneSession2
274 * @tc.desc: normal function
275 * @tc.type: FUNC
276 */
277 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession2, TestSize.Level1)
278 {
279 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
280 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
281
282 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
283 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
284 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
285 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
286 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
287 node->SetRSUIContext(rsUIContext);
288 sptr<WindowSessionProperty> property = nullptr;
289 SessionInfo info;
290 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
291 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
292
293 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(
294 sessionStage, eventChannel, node, session, property, token);
295 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
296 }
297
298 /**
299 * @tc.name: RecoverAndReconnectSceneSession3
300 * @tc.desc: normal function
301 * @tc.type: FUNC
302 */
303 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession3, TestSize.Level1)
304 {
305 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
306 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
307
308 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
309 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
310 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
311 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
312 auto rsUIContext = ScreenSessionManagerClient::GetInstance().GetRSUIContext(0);
313 node->SetRSUIContext(rsUIContext);
314 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
315 SessionInfo info;
316 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
317 sptr<IRemoteObject> token = nullptr;
318
319 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(
320 sessionStage, eventChannel, node, session, property, token);
321 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
322 }
323
324 /**
325 * @tc.name: DestroyAndDisconnectSpecificSession
326 * @tc.desc: normal function
327 * @tc.type: FUNC
328 */
329 HWTEST_F(sceneSessionManagerProxyTest, DestroyAndDisconnectSpecificSession, TestSize.Level1)
330 {
331 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
332 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
333 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
334 EXPECT_NE(sceneSessionManagerProxy, nullptr);
335
336 sceneSessionManagerProxy->DestroyAndDisconnectSpecificSession(0);
337 EXPECT_NE(sceneSessionManagerProxy, nullptr);
338 }
339
340 /**
341 * @tc.name: DestroyAndDisconnectSpecificSessionWithDetachCallback
342 * @tc.desc: normal function
343 * @tc.type: FUNC
344 */
345 HWTEST_F(sceneSessionManagerProxyTest, DestroyAndDisconnectSpecificSessionWithDetachCallback, TestSize.Level1)
346 {
347 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
348 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
349 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
350 EXPECT_NE(sceneSessionManagerProxy, nullptr);
351
352 sptr<IRemoteObject> callback = sptr<IRemoteObjectMocker>::MakeSptr();
353
354 sceneSessionManagerProxy->DestroyAndDisconnectSpecificSessionWithDetachCallback(0, callback);
355 EXPECT_NE(sceneSessionManagerProxy, nullptr);
356 }
357
358 /**
359 * @tc.name: UpdateSessionTouchOutsideListener
360 * @tc.desc: normal function
361 * @tc.type: FUNC
362 */
363 HWTEST_F(sceneSessionManagerProxyTest, UpdateSessionTouchOutsideListener, TestSize.Level1)
364 {
365 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
366 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
367 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
368 EXPECT_NE(sceneSessionManagerProxy, nullptr);
369
370 int32_t persistentId = 0;
371 sceneSessionManagerProxy->UpdateSessionTouchOutsideListener(persistentId, true);
372 sceneSessionManagerProxy->UpdateSessionTouchOutsideListener(persistentId, false);
373 EXPECT_NE(sceneSessionManagerProxy, nullptr);
374 }
375
376 /**
377 * @tc.name: SkipSnapshotForAppProcess
378 * @tc.desc: normal function
379 * @tc.type: FUNC
380 */
381 HWTEST_F(sceneSessionManagerProxyTest, SkipSnapshotForAppProcess, TestSize.Level1)
382 {
383 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
384 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
385
386 int32_t pid = 1000;
387 bool skip = false;
388 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SkipSnapshotForAppProcess(pid, skip));
389 }
390
391 /**
392 * @tc.name: SetGestureNavigationEnabled
393 * @tc.desc: normal function
394 * @tc.type: FUNC
395 */
396 HWTEST_F(sceneSessionManagerProxyTest, SetGestureNavigationEnabled, TestSize.Level1)
397 {
398 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
399 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
400 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
401 EXPECT_NE(sceneSessionManagerProxy, nullptr);
402
403 sceneSessionManagerProxy->SetGestureNavigationEnabled(true);
404 sceneSessionManagerProxy->SetGestureNavigationEnabled(false);
405 EXPECT_NE(sceneSessionManagerProxy, nullptr);
406 }
407
408 /**
409 * @tc.name: GetFocusWindowInfo
410 * @tc.desc: normal function
411 * @tc.type: FUNC
412 */
413 HWTEST_F(sceneSessionManagerProxyTest, GetFocusWindowInfo, TestSize.Level1)
414 {
415 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
416 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
417 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
418 EXPECT_NE(sceneSessionManagerProxy, nullptr);
419
420 FocusChangeInfo focusInfo{};
421 sceneSessionManagerProxy->GetFocusWindowInfo(focusInfo);
422 EXPECT_NE(sceneSessionManagerProxy, nullptr);
423 }
424
425 /**
426 * @tc.name: SetSessionIcon
427 * @tc.desc: normal function
428 * @tc.type: FUNC
429 */
430 HWTEST_F(sceneSessionManagerProxyTest, SetSessionIcon, TestSize.Level1)
431 {
432 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
433 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
434 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
435 EXPECT_NE(sceneSessionManagerProxy, nullptr);
436
437 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
438 std::shared_ptr<Media::PixelMap> icon = nullptr;
439 sceneSessionManagerProxy->SetSessionIcon(token, icon);
440 EXPECT_NE(sceneSessionManagerProxy, nullptr);
441 }
442
443 /**
444 * @tc.name: GetAccessibilityWindowInfo
445 * @tc.desc: normal function
446 * @tc.type: FUNC
447 */
448 HWTEST_F(sceneSessionManagerProxyTest, GetAccessibilityWindowInfo, TestSize.Level1)
449 {
450 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
451 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
452 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
453 EXPECT_NE(sceneSessionManagerProxy, nullptr);
454
455 std::vector<sptr<AccessibilityWindowInfo>> infos{};
456 sceneSessionManagerProxy->GetAccessibilityWindowInfo(infos);
457 EXPECT_NE(sceneSessionManagerProxy, nullptr);
458 }
459
460 /**
461 * @tc.name: GetUnreliableWindowInfo
462 * @tc.desc: normal function
463 * @tc.type: FUNC
464 */
465 HWTEST_F(sceneSessionManagerProxyTest, GetUnreliableWindowInfo, TestSize.Level1)
466 {
467 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
468 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
469 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
470 EXPECT_NE(sceneSessionManagerProxy, nullptr);
471
472 std::vector<sptr<UnreliableWindowInfo>> infos{};
473 sceneSessionManagerProxy->GetUnreliableWindowInfo(0, infos);
474 EXPECT_NE(sceneSessionManagerProxy, nullptr);
475 }
476
477 /**
478 * @tc.name: GetSessionInfos
479 * @tc.desc: normal function
480 * @tc.type: FUNC
481 */
482 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfos, TestSize.Level1)
483 {
484 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
485 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
486 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
487 EXPECT_NE(sceneSessionManagerProxy, nullptr);
488
489 std::string deviceId;
490 std::vector<SessionInfoBean> sessionInfos{};
491 sceneSessionManagerProxy->GetSessionInfos(deviceId, 0, sessionInfos);
492 EXPECT_NE(sceneSessionManagerProxy, nullptr);
493 }
494
495 /**
496 * @tc.name: GetSessionInfo
497 * @tc.desc: normal function
498 * @tc.type: FUNC
499 */
500 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfo, TestSize.Level1)
501 {
502 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
503 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
504 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
505 EXPECT_NE(sceneSessionManagerProxy, nullptr);
506
507 std::string deviceId;
508 SessionInfoBean sessionInfo;
509 sceneSessionManagerProxy->GetSessionInfo(deviceId, 0, sessionInfo);
510 EXPECT_NE(sceneSessionManagerProxy, nullptr);
511 }
512
513 /**
514 * @tc.name: RegisterWindowManagerAgent01
515 * @tc.desc: normal function
516 * @tc.type: FUNC
517 */
518 HWTEST_F(sceneSessionManagerProxyTest, RegisterWindowManagerAgent01, TestSize.Level1)
519 {
520 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
521 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
522 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
523 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
524
525 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->RegisterWindowManagerAgent(type, windowManagerAgent));
526 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->UnregisterWindowManagerAgent(type, windowManagerAgent));
527 }
528
529 /**
530 * @tc.name: RegisterWindowPropertyChangeAgent01
531 * @tc.desc: normal function
532 * @tc.type: FUNC
533 */
534 HWTEST_F(sceneSessionManagerProxyTest, RegisterWindowPropertyChangeAgent01, TestSize.Level1)
535 {
536 WindowInfoKey windowInfoKey = WindowInfoKey::DISPLAY_ID;
537 uint32_t interestInfo = 0;
538 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
539 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
540 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
541
542 EXPECT_EQ(WMError::WM_OK,
543 sceneSessionManagerProxy->RegisterWindowPropertyChangeAgent(windowInfoKey, interestInfo, windowManagerAgent));
544 EXPECT_EQ(WMError::WM_OK,
545 sceneSessionManagerProxy->UnregisterWindowPropertyChangeAgent(windowInfoKey, interestInfo, windowManagerAgent));
546 }
547
548 /**
549 * @tc.name: UpdateModalExtensionRect
550 * @tc.desc: normal function
551 * @tc.type: FUNC
552 */
553 HWTEST_F(sceneSessionManagerProxyTest, UpdateModalExtensionRect, TestSize.Level1)
554 {
555 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
556 ASSERT_NE(iRemoteObjectMocker, nullptr);
557 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
558 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
559 ASSERT_NE(sceneSessionManagerProxy, nullptr);
560
561 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
562 ASSERT_NE(token, nullptr);
563 Rect rect{ 1, 2, 3, 4 };
564 sceneSessionManagerProxy->UpdateModalExtensionRect(token, rect);
565 sceneSessionManagerProxy->UpdateModalExtensionRect(nullptr, rect);
566 }
567
568 /**
569 * @tc.name: ProcessModalExtensionPointDown
570 * @tc.desc: normal function
571 * @tc.type: FUNC
572 */
573 HWTEST_F(sceneSessionManagerProxyTest, ProcessModalExtensionPointDown, TestSize.Level1)
574 {
575 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
576 ASSERT_NE(iRemoteObjectMocker, nullptr);
577 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
578 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
579 ASSERT_NE(sceneSessionManagerProxy, nullptr);
580
581 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
582 ASSERT_NE(token, nullptr);
583 sceneSessionManagerProxy->ProcessModalExtensionPointDown(token, 0, 0);
584 sceneSessionManagerProxy->ProcessModalExtensionPointDown(nullptr, 0, 0);
585 }
586
587 /**
588 * @tc.name: AddExtensionWindowStageToSCB
589 * @tc.desc: normal function
590 * @tc.type: FUNC
591 */
592 HWTEST_F(sceneSessionManagerProxyTest, AddExtensionWindowStageToSCB, TestSize.Level1)
593 {
594 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
595 ASSERT_NE(iRemoteObjectMocker, nullptr);
596 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
597 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
598 ASSERT_NE(sceneSessionManagerProxy, nullptr);
599
600 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
601 ASSERT_NE(sessionStage, nullptr);
602 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
603 ASSERT_NE(token, nullptr);
604 sceneSessionManagerProxy->AddExtensionWindowStageToSCB(sessionStage, token, 12345);
605 }
606
607 /**
608 * @tc.name: SetStartWindowBackgroundColor
609 * @tc.desc: normal function
610 * @tc.type: FUNC
611 */
612 HWTEST_F(sceneSessionManagerProxyTest, SetStartWindowBackgroundColor, TestSize.Level1)
613 {
614 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
615 ASSERT_NE(iRemoteObjectMocker, nullptr);
616 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
617 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
618 ASSERT_NE(sceneSessionManagerProxy, nullptr);
619
620 EXPECT_EQ(WMError::WM_OK,
621 sceneSessionManagerProxy->SetStartWindowBackgroundColor("moduleName", "abilityName", 0xffffffff, 100));
622 }
623
624 /**
625 * @tc.name: RemoveExtensionWindowStageFromSCB
626 * @tc.desc: normal function
627 * @tc.type: FUNC
628 */
629 HWTEST_F(sceneSessionManagerProxyTest, RemoveExtensionWindowStageFromSCB, TestSize.Level1)
630 {
631 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
632 ASSERT_NE(iRemoteObjectMocker, nullptr);
633 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
634 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
635 ASSERT_NE(sceneSessionManagerProxy, nullptr);
636
637 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
638 ASSERT_NE(sessionStage, nullptr);
639 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
640 ASSERT_NE(token, nullptr);
641 sceneSessionManagerProxy->RemoveExtensionWindowStageFromSCB(sessionStage, token);
642 }
643
644 /**
645 * @tc.name: AddOrRemoveSecureSession
646 * @tc.desc: normal function
647 * @tc.type: FUNC
648 */
649 HWTEST_F(sceneSessionManagerProxyTest, AddOrRemoveSecureSession001, TestSize.Level1)
650 {
651 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
652 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
653
654 int32_t persistentId = 12345;
655 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->AddOrRemoveSecureSession(persistentId, true));
656 }
657
658 /**
659 * @tc.name: UpdateExtWindowFlags
660 * @tc.desc: normal function
661 * @tc.type: FUNC
662 */
663 HWTEST_F(sceneSessionManagerProxyTest, UpdateExtWindowFlags, TestSize.Level1)
664 {
665 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
666 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
667
668 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
669 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->UpdateExtWindowFlags(token, 7, 7));
670 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->UpdateExtWindowFlags(nullptr, 7, 7));
671 }
672
673 /**
674 * @tc.name: GetSessionInfoByContinueSessionId
675 * @tc.desc: normal function
676 * @tc.type: FUNC
677 */
678 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfoByContinueSessionId, TestSize.Level1)
679 {
680 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
681 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
682
683 std::string continueSessionId = "test_01";
684 SessionInfoBean missionInfo;
685 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED,
686 sceneSessionManagerProxy->GetSessionInfoByContinueSessionId(continueSessionId, missionInfo));
687 }
688
689 /**
690 * @tc.name: RequestFocusStatus01
691 * @tc.desc: normal function
692 * @tc.type: FUNC
693 */
694 HWTEST_F(sceneSessionManagerProxyTest, RequestFocusStatus01, TestSize.Level1)
695 {
696 int32_t persistendId = 0;
697 bool isFocused = true;
698 bool byForeground = true;
699 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
700 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
701
702 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->RequestFocusStatus(persistendId, isFocused, byForeground));
703 }
704
705 /**
706 * @tc.name: RequestFocusStatusBySA01
707 * @tc.desc: normal function
708 * @tc.type: FUNC
709 */
710 HWTEST_F(sceneSessionManagerProxyTest, RequestFocusStatusBySA01, TestSize.Level1)
711 {
712 FocusChangeReason reason = FocusChangeReason::CLICK;
713 int32_t persistendId = 0;
714 bool isFocused = true;
715 bool byForeground = true;
716 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
717 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
718 auto result = sceneSessionManagerProxy->SceneSessionManagerProxy::RequestFocusStatusBySA(
719 persistendId, isFocused, byForeground, reason);
720 ASSERT_EQ(WMError::WM_OK, result);
721 }
722
723 /**
724 * @tc.name: RaiseWindowToTop
725 * @tc.desc: normal function
726 * @tc.type: FUNC
727 */
728 HWTEST_F(sceneSessionManagerProxyTest, RaiseWindowToTop, TestSize.Level1)
729 {
730 int32_t persistendId = 0;
731 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
732 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
733
734 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->RaiseWindowToTop(persistendId));
735 }
736
737 /**
738 * @tc.name: BindDialogSessionTarget
739 * @tc.desc: normal function
740 * @tc.type: FUNC
741 */
742 HWTEST_F(sceneSessionManagerProxyTest, BindDialogSessionTarget, TestSize.Level1)
743 {
744 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
745 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
746 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
747 EXPECT_NE(sceneSessionManagerProxy, nullptr);
748
749 sptr<IRemoteObject> targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
750 sceneSessionManagerProxy->BindDialogSessionTarget(0, targetToken);
751 EXPECT_NE(sceneSessionManagerProxy, nullptr);
752 }
753
754 /**
755 * @tc.name: BindDialogSessionTarget2
756 * @tc.desc: normal function
757 * @tc.type: FUNC
758 */
759 HWTEST_F(sceneSessionManagerProxyTest, BindDialogSessionTarget2, TestSize.Level1)
760 {
761 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
762 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
763 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
764 EXPECT_NE(sceneSessionManagerProxy, nullptr);
765
766 sptr<IRemoteObject> targetToken = nullptr;
767 sceneSessionManagerProxy->BindDialogSessionTarget(0, targetToken);
768 EXPECT_NE(sceneSessionManagerProxy, nullptr);
769 }
770
771 /**
772 * @tc.name: UpdateSessionAvoidAreaListener
773 * @tc.desc: normal function
774 * @tc.type: FUNC
775 */
776 HWTEST_F(sceneSessionManagerProxyTest, UpdateSessionAvoidAreaListener, TestSize.Level1)
777 {
778 int32_t persistendId = 0;
779 bool haveListener = true;
780 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
781 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
782
783 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->UpdateSessionAvoidAreaListener(persistendId, haveListener));
784 }
785
786 /**
787 * @tc.name: NotifyScreenshotEvent
788 * @tc.desc: normal function
789 * @tc.type: FUNC
790 */
791 HWTEST_F(sceneSessionManagerProxyTest, NotifyScreenshotEvent, TestSize.Level1)
792 {
793 MockMessageParcel::ClearAllErrorFlag();
794 ScreenshotEventType type = ScreenshotEventType::SCROLL_SHOT_START;
795 auto ssmProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
796 auto ret = ssmProxy->NotifyScreenshotEvent(type);
797 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
798
799 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
800 ssmProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
801 ASSERT_NE(nullptr, ssmProxy);
802 ret = ssmProxy->NotifyScreenshotEvent(type);
803 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
804
805 MockMessageParcel::SetReadInt32ErrorFlag(true);
806 ret = ssmProxy->NotifyScreenshotEvent(type);
807 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
808
809 MockMessageParcel::SetWriteInt32ErrorFlag(true);
810 ret = ssmProxy->NotifyScreenshotEvent(type);
811 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
812
813 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
814 ret = ssmProxy->NotifyScreenshotEvent(type);
815 EXPECT_EQ(WMError::WM_OK, ret);
816 MockMessageParcel::ClearAllErrorFlag();
817 }
818
819 /**
820 * @tc.name: SetSessionLabel
821 * @tc.desc: normal function
822 * @tc.type: FUNC
823 */
824 HWTEST_F(sceneSessionManagerProxyTest, SetSessionLabel, TestSize.Level1)
825 {
826 sptr<IRemoteObject> token = nullptr;
827 std::string label = "SetSessionLabel";
828 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
829 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
830
831 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->SetSessionLabel(token, label));
832 }
833
834 /**
835 * @tc.name: IsValidSessionIds
836 * @tc.desc: normal function
837 * @tc.type: FUNC
838 */
839 HWTEST_F(sceneSessionManagerProxyTest, IsValidSessionIds, TestSize.Level1)
840 {
841 std::vector<int32_t> sessionIds;
842 std::vector<bool> results;
843 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
844 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
845
846 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->IsValidSessionIds(sessionIds, results));
847 }
848
849 /**
850 * @tc.name: RegisterSessionListener01
851 * @tc.desc: normal function
852 * @tc.type: FUNC
853 */
854 HWTEST_F(sceneSessionManagerProxyTest, RegisterSessionListener01, TestSize.Level1)
855 {
856 sptr<ISessionListener> listener = nullptr;
857 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
858 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
859
860 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->RegisterSessionListener(listener));
861 }
862
863 /**
864 * @tc.name: UnRegisterSessionListener
865 * @tc.desc: normal function
866 * @tc.type: FUNC
867 */
868 HWTEST_F(sceneSessionManagerProxyTest, UnRegisterSessionListener, TestSize.Level1)
869 {
870 sptr<ISessionListener> listener = nullptr;
871 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
872 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
873
874 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->UnRegisterSessionListener(listener));
875 }
876
877 /**
878 * @tc.name: GetSnapshotByWindowId
879 * @tc.desc: normal function
880 * @tc.type: FUNC
881 */
882 HWTEST_F(sceneSessionManagerProxyTest, GetSnapshotByWindowId, TestSize.Level1)
883 {
884 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
885 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
886 int32_t windowId = -1;
887 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
888 WMError ret = sceneSessionManagerProxy->GetSnapshotByWindowId(windowId, pixelMap);
889 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
890 }
891
892 /**
893 * @tc.name: GetSessionSnapshotById
894 * @tc.desc: normal function
895 * @tc.type: FUNC
896 */
897 HWTEST_F(sceneSessionManagerProxyTest, GetSessionSnapshotById, TestSize.Level1)
898 {
899 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
900 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
901 int32_t windowId = -1;
902 SessionSnapshot snapshot;
903 WMError ret = sceneSessionManagerProxy->GetSessionSnapshotById(windowId, snapshot);
904 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
905 }
906
907 /**
908 * @tc.name: TerminateSessionNew
909 * @tc.desc: normal function
910 * @tc.type: FUNC
911 */
912 HWTEST_F(sceneSessionManagerProxyTest, TerminateSessionNew, TestSize.Level1)
913 {
914 sptr<ISessionListener> listener = nullptr;
915 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
916 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
917
918 ASSERT_EQ(WSError::WS_ERROR_INVALID_SESSION, sceneSessionManagerProxy->TerminateSessionNew(nullptr, true, true));
919 }
920
921 /**
922 * @tc.name: LockSession
923 * @tc.desc: normal function
924 * @tc.type: FUNC
925 */
926 HWTEST_F(sceneSessionManagerProxyTest, LockSession, TestSize.Level1)
927 {
928 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
929 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
930
931 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->LockSession(0));
932 }
933
934 /**
935 * @tc.name: GetUIContentRemoteObj
936 * @tc.desc: normal function
937 * @tc.type: FUNC
938 */
939 HWTEST_F(sceneSessionManagerProxyTest, GetUIContentRemoteObj, TestSize.Level1)
940 {
941 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
942 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
943 sptr<IRemoteObject> remoteObj;
944 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, sceneSessionManagerProxy->GetUIContentRemoteObj(1, remoteObj));
945 }
946
947 /**
948 * @tc.name: ClearSession
949 * @tc.desc: normal function
950 * @tc.type: FUNC
951 */
952 HWTEST_F(sceneSessionManagerProxyTest, ClearSession, TestSize.Level1)
953 {
954 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
955 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
956
957 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->LockSession(0));
958 }
959
960 /**
961 * @tc.name: RegisterIAbilityManagerCollaborator
962 * @tc.desc: normal function
963 * @tc.type: FUNC
964 */
965 HWTEST_F(sceneSessionManagerProxyTest, RegisterIAbilityManagerCollaborator, TestSize.Level1)
966 {
967 sptr<AAFwk::IAbilityManagerCollaborator> impl = nullptr;
968 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
969 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
970
971 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->RegisterIAbilityManagerCollaborator(0, impl));
972 }
973
974 /**
975 * @tc.name: NotifyWindowExtensionVisibilityChange
976 * @tc.desc: normal function
977 * @tc.type: FUNC
978 */
979 HWTEST_F(sceneSessionManagerProxyTest, NotifyWindowExtensionVisibilityChange, TestSize.Level1)
980 {
981 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
982 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
983
984 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->NotifyWindowExtensionVisibilityChange(0, 0, true));
985 }
986
987 /**
988 * @tc.name: GetTopWindowId
989 * @tc.desc: normal function
990 * @tc.type: FUNC
991 */
992 HWTEST_F(sceneSessionManagerProxyTest, GetTopWindowId, TestSize.Level1)
993 {
994 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
995 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
996
997 uint32_t topWinId = 1;
998 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->GetTopWindowId(0, topWinId));
999 }
1000
1001 /**
1002 * @tc.name: GetWindowStyleType
1003 * @tc.desc: normal function
1004 * @tc.type: FUNC
1005 */
1006 HWTEST_F(sceneSessionManagerProxyTest, GetWindowStyleType, TestSize.Level1)
1007 {
1008 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1009 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1010
1011 WindowStyleType styleType;
1012 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->GetWindowStyleType(styleType));
1013 }
1014
1015 /**
1016 * @tc.name: SetProcessWatermark
1017 * @tc.desc: normal function
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(sceneSessionManagerProxyTest, SetProcessWatermark, TestSize.Level1)
1021 {
1022 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1023 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1024
1025 int32_t pid = 1000;
1026 const std::string watermarkName = "SetProcessWatermarkName";
1027 bool isEnabled = false;
1028 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SetProcessWatermark(pid, watermarkName, isEnabled));
1029 }
1030
1031 /**
1032 * @tc.name: GetWindowIdsByCoordinate
1033 * @tc.desc: normal function
1034 * @tc.type: FUNC
1035 */
1036 HWTEST_F(sceneSessionManagerProxyTest, GetWindowIdsByCoordinate, TestSize.Level1)
1037 {
1038 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1039 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1040
1041 int64_t displayId = 1000;
1042 int32_t windowNumber = 2;
1043 int32_t x = 0;
1044 int32_t y = 0;
1045 std::vector<int32_t> windowIds;
1046 WMError res = sceneSessionManagerProxy->GetWindowIdsByCoordinate(displayId, windowNumber, x, y, windowIds);
1047 ASSERT_EQ(WMError::WM_OK, res);
1048 }
1049
1050 /**
1051 * @tc.name: GetProcessSurfaceNodeIdByPersistentId
1052 * @tc.desc: normal function
1053 * @tc.type: FUNC
1054 */
1055 HWTEST_F(sceneSessionManagerProxyTest, GetProcessSurfaceNodeIdByPersistentId, TestSize.Level1)
1056 {
1057 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1058 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1059
1060 int32_t pid = 123;
1061 std::vector<int32_t> persistentIds = { 1, 2, 3 };
1062 std::vector<uint64_t> surfaceNodeIds;
1063 ASSERT_EQ(WMError::WM_OK,
1064 sceneSessionManagerProxy->GetProcessSurfaceNodeIdByPersistentId(pid, persistentIds, surfaceNodeIds));
1065 }
1066
1067 /**
1068 * @tc.name: SkipSnapshotByUserIdAndBundleNames
1069 * @tc.desc: normal function
1070 * @tc.type: FUNC
1071 */
1072 HWTEST_F(sceneSessionManagerProxyTest, SkipSnapshotByUserIdAndBundleNames, TestSize.Level1)
1073 {
1074 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1075 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1076
1077 int32_t userId = 1;
1078 std::vector<std::string> bundleNameList = { "a", "b", "c" };
1079 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SkipSnapshotByUserIdAndBundleNames(userId, bundleNameList));
1080 }
1081
1082 /**
1083 * @tc.name: UpdateScreenLockStatusForApp
1084 * @tc.desc: normal function
1085 * @tc.type: FUNC
1086 */
1087 HWTEST_F(sceneSessionManagerProxyTest, UpdateScreenLockStatusForApp, TestSize.Level1)
1088 {
1089 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1090 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1091 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1092 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1093 ASSERT_EQ(sceneSessionManagerProxy->UpdateScreenLockStatusForApp("", true), WMError::WM_OK);
1094 }
1095
1096 /**
1097 * @tc.name: AddSkipSelfWhenShowOnVirtualScreenList
1098 * @tc.desc: normal function
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(sceneSessionManagerProxyTest, AddSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
1102 {
1103 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1104 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1105 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1106 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1107 std::vector<int32_t> persistentIds{ 0, 1, 2 };
1108 ASSERT_EQ(sceneSessionManagerProxy->AddSkipSelfWhenShowOnVirtualScreenList(persistentIds), WMError::WM_OK);
1109 }
1110
1111 /**
1112 * @tc.name: RemoveSkipSelfWhenShowOnVirtualScreenList
1113 * @tc.desc: normal function
1114 * @tc.type: FUNC
1115 */
1116 HWTEST_F(sceneSessionManagerProxyTest, RemoveSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
1117 {
1118 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1119 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1120 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1121 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1122 std::vector<int32_t> persistentIds{ 0, 1, 2 };
1123 ASSERT_EQ(sceneSessionManagerProxy->RemoveSkipSelfWhenShowOnVirtualScreenList(persistentIds), WMError::WM_OK);
1124 }
1125
1126 /**
1127 * @tc.name: IsPcWindow
1128 * @tc.desc: IsPcWindow
1129 * @tc.type: FUNC
1130 */
1131 HWTEST_F(sceneSessionManagerProxyTest, IsPcWindow, TestSize.Level1)
1132 {
1133 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1134 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1135 bool isPcWindow = false;
1136 ASSERT_EQ(sceneSessionManagerProxy->IsPcWindow(isPcWindow), WMError::WM_OK);
1137 ASSERT_EQ(isPcWindow, false);
1138 }
1139
1140 /**
1141 * @tc.name: IsFreeMultiWindow
1142 * @tc.desc: IsFreeMultiWindow
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(sceneSessionManagerProxyTest, IsFreeMultiWindow, TestSize.Level1)
1146 {
1147 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1148 bool isFreeMultiWindow = false;
1149
1150 // remote == nullptr
1151 auto ret = tempProxy->IsFreeMultiWindow(isFreeMultiWindow);
1152 EXPECT_EQ(isFreeMultiWindow, false);
1153 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1154
1155 // WriteInterfaceToken failed
1156 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1157 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1158 MockMessageParcel::ClearAllErrorFlag();
1159 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1160 ASSERT_NE(proxy, nullptr);
1161 ret = proxy->IsFreeMultiWindow(isFreeMultiWindow);
1162 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1163 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1164
1165 // SendRequest failed
1166 ASSERT_NE(proxy, nullptr);
1167 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1168 ret = proxy->IsFreeMultiWindow(isFreeMultiWindow);
1169 EXPECT_EQ(isFreeMultiWindow, false);
1170 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1171 remoteMocker->SetRequestResult(ERR_NONE);
1172
1173 // ReadInt32 failed
1174 MockMessageParcel::SetReadInt32ErrorFlag(true);
1175 ret = proxy->IsFreeMultiWindow(isFreeMultiWindow);
1176 EXPECT_EQ(isFreeMultiWindow, false);
1177 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1178 MockMessageParcel::SetReadInt32ErrorFlag(false);
1179
1180 // ReadBool failed
1181 MockMessageParcel::SetReadBoolErrorFlag(true);
1182 ret = proxy->IsFreeMultiWindow(isFreeMultiWindow);
1183 EXPECT_EQ(isFreeMultiWindow, false);
1184 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1185 MockMessageParcel::SetReadBoolErrorFlag(false);
1186 MockMessageParcel::ClearAllErrorFlag();
1187
1188 // interface success
1189 ret = proxy->IsFreeMultiWindow(isFreeMultiWindow);
1190 EXPECT_EQ(isFreeMultiWindow, false);
1191 EXPECT_EQ(ret, WMError::WM_OK);
1192 }
1193
1194 /**
1195 * @tc.name: IsPcOrPadFreeMultiWindowMode
1196 * @tc.desc: IsPcOrPadFreeMultiWindowMode
1197 * @tc.type: FUNC
1198 */
1199 HWTEST_F(sceneSessionManagerProxyTest, IsPcOrPadFreeMultiWindowMode, TestSize.Level1)
1200 {
1201 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1202 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1203 bool isPcOrPadFreeMultiWindowMode = false;
1204 ASSERT_EQ(sceneSessionManagerProxy->IsPcOrPadFreeMultiWindowMode(isPcOrPadFreeMultiWindowMode),
1205 WMError::WM_OK);
1206 ASSERT_EQ(isPcOrPadFreeMultiWindowMode, false);
1207 }
1208
1209 /**
1210 * @tc.name: IsWindowRectAutoSave
1211 * @tc.desc: IsWindowRectAutoSave
1212 * @tc.type: FUNC
1213 */
1214 HWTEST_F(sceneSessionManagerProxyTest, IsWindowRectAutoSave, TestSize.Level1)
1215 {
1216 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1217 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1218 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1219 bool enabled = false;
1220 std::string key = "com.example.recposentryEntryAbility";
1221 int persistentId = 1;
1222 ASSERT_EQ(sceneSessionManagerProxy->IsWindowRectAutoSave(key, enabled, persistentId), WMError::WM_ERROR_IPC_FAILED);
1223 }
1224
1225 /**
1226 * @tc.name: SetImageForRecent
1227 * @tc.desc: SetImageForRecent
1228 * @tc.type: FUNC
1229 */
1230 HWTEST_F(sceneSessionManagerProxyTest, SetImageForRecent, TestSize.Level1)
1231 {
1232 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1233 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1234 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1235 ASSERT_EQ(sceneSessionManagerProxy->SetImageForRecent(1, ImageFit::FILL, 1), WMError::WM_ERROR_IPC_FAILED);
1236 }
1237
1238 /**
1239 * @tc.name: GetDisplayIdByWindowId
1240 * @tc.desc: GetDisplayIdByWindowId
1241 * @tc.type: FUNC
1242 */
1243 HWTEST_F(sceneSessionManagerProxyTest, GetDisplayIdByWindowId, TestSize.Level1)
1244 {
1245 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1246 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1247 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1248 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1249 const std::vector<uint64_t> windowIds = { 1, 2 };
1250 std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
1251 sceneSessionManagerProxy->GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
1252 }
1253
1254 /**
1255 * @tc.name: SetGlobalDragResizeType
1256 * @tc.desc: SetGlobalDragResizeType
1257 * @tc.type: FUNC
1258 */
1259 HWTEST_F(sceneSessionManagerProxyTest, SetGlobalDragResizeType, TestSize.Level1)
1260 {
1261 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1262 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1263 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1264 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1265 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1266 sceneSessionManagerProxy->SetGlobalDragResizeType(dragResizeType);
1267 }
1268
1269 /**
1270 * @tc.name: GetGlobalDragResizeType
1271 * @tc.desc: GetGlobalDragResizeType
1272 * @tc.type: FUNC
1273 */
1274 HWTEST_F(sceneSessionManagerProxyTest, GetGlobalDragResizeType, TestSize.Level1)
1275 {
1276 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1277 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1278 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1279 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1280 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1281 sceneSessionManagerProxy->GetGlobalDragResizeType(dragResizeType);
1282 }
1283
1284 /**
1285 * @tc.name: SetAppDragResizeType
1286 * @tc.desc: SetAppDragResizeType
1287 * @tc.type: FUNC
1288 */
1289 HWTEST_F(sceneSessionManagerProxyTest, SetAppDragResizeType, TestSize.Level1)
1290 {
1291 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1292 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1293 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1294 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1295 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1296 const std::string bundleName = "test";
1297 sceneSessionManagerProxy->SetAppDragResizeType(bundleName, dragResizeType);
1298 }
1299
1300 /**
1301 * @tc.name: GetAppDragResizeType
1302 * @tc.desc: GetAppDragResizeType
1303 * @tc.type: FUNC
1304 */
1305 HWTEST_F(sceneSessionManagerProxyTest, GetAppDragResizeType, TestSize.Level1)
1306 {
1307 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1308 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1309 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1310 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1311 DragResizeType toDragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1312 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1313 const std::string bundleName = "test";
1314 std::unordered_map<std::string, DragResizeType> appDragResizeTypeMap_;
1315 appDragResizeTypeMap_[bundleName] = toDragResizeType;
1316 sceneSessionManagerProxy->GetAppDragResizeType(bundleName, dragResizeType);
1317 }
1318
1319 /**
1320 * @tc.name: SetAppKeyFramePolicy
1321 * @tc.desc: SetAppKeyFramePolicy
1322 * @tc.type: FUNC
1323 */
1324 HWTEST_F(sceneSessionManagerProxyTest, SetAppKeyFramePolicy, TestSize.Level1)
1325 {
1326 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1327 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1328 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1329 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1330 const std::string bundleName = "test";
1331 KeyFramePolicy keyFramePolicy;
1332 keyFramePolicy.dragResizeType_ = DragResizeType::RESIZE_KEY_FRAME;
1333 WMError res = sceneSessionManagerProxy->SetAppKeyFramePolicy(bundleName, keyFramePolicy);
1334 ASSERT_EQ(WMError::WM_OK, res);
1335 }
1336
1337 /**
1338 * @tc.name: GetFocusSessionToken
1339 * @tc.desc: GetFocusSessionToken
1340 * @tc.type: FUNC
1341 */
1342 HWTEST_F(sceneSessionManagerProxyTest, GetFocusSessionToken, TestSize.Level1)
1343 {
1344 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1345 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1346 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1347
1348 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1349 DisplayId displayId = 1000;
1350 WSError res = sceneSessionManagerProxy->GetFocusSessionToken(token, displayId);
1351 ASSERT_EQ(WSError::WS_OK, res);
1352 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1353 res = sceneSessionManagerProxy->GetFocusSessionToken(token, displayId);
1354 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1355 }
1356
1357 /**
1358 * @tc.name: GetFocusSessionElement
1359 * @tc.desc: GetFocusSessionElement
1360 * @tc.type: FUNC
1361 */
1362 HWTEST_F(sceneSessionManagerProxyTest, GetFocusSessionElement, TestSize.Level1)
1363 {
1364 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1365 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1366 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1367
1368 std::string device = "deviceTest";
1369 std::string bundle = "bundleTest";
1370 std::string ability = "abilityTest";
1371 OHOS::AppExecFwk::ElementName element(device, bundle, ability);
1372 DisplayId displayId = 1000;
1373 WSError res = sceneSessionManagerProxy->GetFocusSessionElement(element, displayId);
1374 ASSERT_EQ(WSError::WS_OK, res);
1375 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1376 res = sceneSessionManagerProxy->GetFocusSessionElement(element, displayId);
1377 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1378 }
1379
1380 /**
1381 * @tc.name: GetSessionSnapshot
1382 * @tc.desc: GetSessionSnapshot
1383 * @tc.type: FUNC
1384 */
1385 HWTEST_F(sceneSessionManagerProxyTest, GetSessionSnapshot, TestSize.Level1)
1386 {
1387 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1388 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1389 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1390
1391 std::string deviceId;
1392 int32_t persistentId = 0;
1393 SessionSnapshot snapshot;
1394 bool isLowResolution = true;
1395 WSError res = sceneSessionManagerProxy->GetSessionSnapshot(deviceId, persistentId, snapshot, isLowResolution);
1396 ASSERT_EQ(WSError::WS_OK, res);
1397 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1398 res = sceneSessionManagerProxy->GetSessionSnapshot(deviceId, persistentId, snapshot, isLowResolution);
1399 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1400 }
1401
1402 /**
1403 * @tc.name: SetSessionContinueState
1404 * @tc.desc: SetSessionContinueState
1405 * @tc.type: FUNC
1406 */
1407 HWTEST_F(sceneSessionManagerProxyTest, SetSessionContinueState, TestSize.Level1)
1408 {
1409 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1410 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1411 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1412
1413 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1414 int32_t tempcontinueState = 0;
1415 ContinueState continueState = static_cast<ContinueState>(tempcontinueState);
1416 WSError res = sceneSessionManagerProxy->SetSessionContinueState(token, continueState);
1417 ASSERT_EQ(WSError::WS_OK, res);
1418 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1419 res = sceneSessionManagerProxy->SetSessionContinueState(token, continueState);
1420 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1421 }
1422
1423 /**
1424 * @tc.name: UnlockSession
1425 * @tc.desc: UnlockSession
1426 * @tc.type: FUNC
1427 */
1428 HWTEST_F(sceneSessionManagerProxyTest, UnlockSession, TestSize.Level1)
1429 {
1430 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1431 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1432 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1433
1434 int32_t sessionId = 0;
1435 WSError res = sceneSessionManagerProxy->UnlockSession(sessionId);
1436 ASSERT_EQ(WSError::WS_OK, res);
1437 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1438 res = sceneSessionManagerProxy->UnlockSession(sessionId);
1439 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1440 }
1441
1442 /**
1443 * @tc.name: MoveSessionsToForeground
1444 * @tc.desc: MoveSessionsToForeground
1445 * @tc.type: FUNC
1446 */
1447 HWTEST_F(sceneSessionManagerProxyTest, MoveSessionsToForeground, TestSize.Level1)
1448 {
1449 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1450 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1451 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1452
1453 std::vector<int32_t> sessionIds;
1454 int32_t topSessionId = 0;
1455 WSError res = sceneSessionManagerProxy->MoveSessionsToForeground(sessionIds, topSessionId);
1456 ASSERT_EQ(WSError::WS_OK, res);
1457 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1458 res = sceneSessionManagerProxy->MoveSessionsToForeground(sessionIds, topSessionId);
1459 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1460 }
1461
1462 /**
1463 * @tc.name: MoveSessionsToBackground
1464 * @tc.desc: MoveSessionsToBackground
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(sceneSessionManagerProxyTest, MoveSessionsToBackground, TestSize.Level1)
1468 {
1469 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1470 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1471 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1472
1473 std::vector<int32_t> sessionIds;
1474 std::vector<int32_t> result;
1475 WSError res = sceneSessionManagerProxy->MoveSessionsToBackground(sessionIds, result);
1476 ASSERT_EQ(WSError::WS_OK, res);
1477 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1478 res = sceneSessionManagerProxy->MoveSessionsToBackground(sessionIds, result);
1479 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1480 }
1481
1482 /**
1483 * @tc.name: ClearAllSessions
1484 * @tc.desc: ClearAllSessions
1485 * @tc.type: FUNC
1486 */
1487 HWTEST_F(sceneSessionManagerProxyTest, ClearAllSessions, TestSize.Level1)
1488 {
1489 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1490 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1491 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1492
1493 WSError res = sceneSessionManagerProxy->ClearAllSessions();
1494 ASSERT_EQ(WSError::WS_OK, res);
1495 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1496 res = sceneSessionManagerProxy->ClearAllSessions();
1497 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1498 }
1499
1500 /**
1501 * @tc.name: UnregisterIAbilityManagerCollaborator
1502 * @tc.desc: UnregisterIAbilityManagerCollaborator
1503 * @tc.type: FUNC
1504 */
1505 HWTEST_F(sceneSessionManagerProxyTest, UnregisterIAbilityManagerCollaborator, TestSize.Level1)
1506 {
1507 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1508 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1509 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1510
1511 int32_t type = 0;
1512 WSError res = sceneSessionManagerProxy->UnregisterIAbilityManagerCollaborator(type);
1513 ASSERT_EQ(WSError::WS_OK, res);
1514 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1515 res = sceneSessionManagerProxy->UnregisterIAbilityManagerCollaborator(type);
1516 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1517 }
1518
1519 /**
1520 * @tc.name: NotifyWatchGestureConsumeResult
1521 * @tc.desc: NotifyWatchGestureConsumeResult
1522 * @tc.type: FUNC
1523 */
1524 HWTEST_F(sceneSessionManagerProxyTest, NotifyWatchGestureConsumeResult, TestSize.Level1)
1525 {
1526 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1527 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1528 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1529
1530 int32_t keyCode = 0;
1531 bool isConsumed = true;
1532 WMError res = sceneSessionManagerProxy->NotifyWatchGestureConsumeResult(keyCode, isConsumed);
1533 ASSERT_EQ(WMError::WM_OK, res);
1534 }
1535
1536 /**
1537 * @tc.name: NotifyWatchFocusActiveChange
1538 * @tc.desc: NotifyWatchFocusActiveChange
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(sceneSessionManagerProxyTest, NotifyWatchFocusActiveChange, TestSize.Level1)
1542 {
1543 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1544 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1545 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1546
1547 bool isActive = true;
1548 WMError res = sceneSessionManagerProxy->NotifyWatchFocusActiveChange(isActive);
1549 ASSERT_EQ(WMError::WM_OK, res);
1550 }
1551
1552 /**
1553 * @tc.name: GetParentMainWindowId
1554 * @tc.desc: GetParentMainWindowId
1555 * @tc.type: FUNC
1556 */
1557 HWTEST_F(sceneSessionManagerProxyTest, GetParentMainWindowId, TestSize.Level1)
1558 {
1559 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1560 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1561 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1562
1563 int32_t windowId = 0;
1564 int32_t mainWindowId = 0;
1565 WMError res = sceneSessionManagerProxy->GetParentMainWindowId(windowId, mainWindowId);
1566 ASSERT_EQ(WMError::WM_OK, res);
1567 }
1568
1569 /**
1570 * @tc.name: ListWindowInfo
1571 * @tc.desc: ListWindowInfo
1572 * @tc.type: FUNC
1573 */
1574 HWTEST_F(sceneSessionManagerProxyTest, ListWindowInfo, TestSize.Level1)
1575 {
1576 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1577 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1578 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1579
1580 WindowInfoOption windowInfoOption;
1581 std::vector<sptr<WindowInfo>> infos;
1582 WMError res = sceneSessionManagerProxy->ListWindowInfo(windowInfoOption, infos);
1583 ASSERT_EQ(WMError::WM_OK, res);
1584 }
1585
1586 /**
1587 * @tc.name: GetWindowModeType
1588 * @tc.desc: GetWindowModeType
1589 * @tc.type: FUNC
1590 */
1591 HWTEST_F(sceneSessionManagerProxyTest, GetWindowModeType, TestSize.Level1)
1592 {
1593 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1594 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1595 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1596
1597 WindowModeType windowModeType;
1598 WMError res = sceneSessionManagerProxy->GetWindowModeType(windowModeType);
1599 ASSERT_EQ(WMError::WM_OK, res);
1600 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1601 res = sceneSessionManagerProxy->GetWindowModeType(windowModeType);
1602 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1603 }
1604
1605 /**
1606 * @tc.name: SetParentWindow
1607 * @tc.desc: SetParentWindow
1608 * @tc.type: FUNC
1609 */
1610 HWTEST_F(sceneSessionManagerProxyTest, SetParentWindow, TestSize.Level1)
1611 {
1612 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1613 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1614 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1615
1616 int32_t subWindowId = 1;
1617 int32_t newParentWindowId = 2;
1618 WMError res = sceneSessionManagerProxy->SetParentWindow(subWindowId, newParentWindowId);
1619 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1620 }
1621
1622 /**
1623 * @tc.name: MinimizeByWindowId
1624 * @tc.desc: MinimizeByWindowId
1625 * @tc.type: FUNC
1626 */
1627 HWTEST_F(sceneSessionManagerProxyTest, MinimizeByWindowId, TestSize.Level1)
1628 {
1629 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1630 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1631 std::vector<int32_t> windowIds;
1632 WMError res = sceneSessionManagerProxy->MinimizeByWindowId(windowIds);
1633 ASSERT_EQ(WMError::WM_OK, res);
1634 }
1635
1636 /**
1637 * @tc.name: SetForegroundWindowNum
1638 * @tc.desc: SetForegroundWindowNum
1639 * @tc.type: FUNC
1640 */
1641 HWTEST_F(sceneSessionManagerProxyTest, SetForegroundWindowNum, TestSize.Level1)
1642 {
1643 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1644 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1645 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1646
1647 uint32_t windowNum = 1;
1648 WMError res = sceneSessionManagerProxy->SetForegroundWindowNum(windowNum);
1649 ASSERT_EQ(WMError::WM_OK, res);
1650 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1651 res = sceneSessionManagerProxy->SetForegroundWindowNum(windowNum);
1652 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1653 }
1654
1655 /**
1656 * @tc.name: AnimateTo
1657 * @tc.desc: AnimateTo
1658 * @tc.type: FUNC
1659 */
1660 HWTEST_F(sceneSessionManagerProxyTest, AnimateTo, Function | SmallTest | Level2)
1661 {
1662 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1663 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1664 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1665
1666 int32_t windowId = 1;
1667 WindowAnimationProperty animationProperty;
1668 WindowAnimationOption animationOption;
1669
1670 WMError res = sceneSessionManagerProxy->AnimateTo(windowId, animationProperty, animationOption);
1671 ASSERT_EQ(WMError::WM_OK, res);
1672
1673 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1674 res = sceneSessionManagerProxy->AnimateTo(windowId, animationProperty, animationOption);
1675 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1676 }
1677
1678 /**
1679 * @tc.name: AnimateTo
1680 * @tc.desc: AnimateTo
1681 * @tc.type: FUNC
1682 */
1683 HWTEST_F(sceneSessionManagerProxyTest, CreateUIEffectController, Function | SmallTest | Level2)
1684 {
1685 sptr<MockIRemoteObject> iRemoteObjectMocker = sptr<MockIRemoteObject>::MakeSptr();
1686 sptr<SceneSessionManagerProxy> proxy =
1687 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1688 sptr<UIEffectControllerClientStubMocker> controllerClient = sptr<UIEffectControllerClientStubMocker>::MakeSptr();
1689 sptr<IUIEffectController> controller = sptr<UIEffectControllerStubMocker>::MakeSptr();
1690 int32_t id = -1;
1691 MockMessageParcel::ClearAllErrorFlag();
1692 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1693 EXPECT_EQ(proxy->CreateUIEffectController(controllerClient, controller, id), WMError::WM_ERROR_IPC_FAILED);
1694 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1695 sptr<SceneSessionManagerProxy> proxyNull =
1696 sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1697 EXPECT_EQ(proxyNull->CreateUIEffectController(controllerClient, controller, id), WMError::WM_ERROR_IPC_FAILED);
1698 iRemoteObjectMocker->SetRequestResult(10);
1699 EXPECT_EQ(proxy->CreateUIEffectController(controllerClient, controller, id), WMError::WM_ERROR_IPC_FAILED);
1700 iRemoteObjectMocker->SetRequestResult(0);
1701 proxy->CreateUIEffectController(controllerClient, controller, id);
1702 }
1703
1704 /**
1705 * @tc.name: GetPiPSettingSwitchStatus
1706 * @tc.desc: GetPiPSettingSwitchStatus
1707 * @tc.type: FUNC
1708 */
1709 HWTEST_F(sceneSessionManagerProxyTest, GetPiPSettingSwitchStatus, TestSize.Level1)
1710 {
1711 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1712 bool switchStatus = false;
1713
1714 // remote == nullptr
1715 auto ret = tempProxy->GetPiPSettingSwitchStatus(switchStatus);
1716 EXPECT_EQ(switchStatus, false);
1717 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1718
1719 // WriteInterfaceToken failed
1720 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1721 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1722 MockMessageParcel::ClearAllErrorFlag();
1723 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1724 ASSERT_NE(proxy, nullptr);
1725 ret = proxy->GetPiPSettingSwitchStatus(switchStatus);
1726 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1727 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1728
1729 // SendRequest failed
1730 ASSERT_NE(proxy, nullptr);
1731 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1732 ret = proxy->GetPiPSettingSwitchStatus(switchStatus);
1733 EXPECT_EQ(switchStatus, false);
1734 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1735 remoteMocker->SetRequestResult(ERR_NONE);
1736
1737 // ReadBool failed
1738 MockMessageParcel::SetReadBoolErrorFlag(true);
1739 ret = proxy->GetPiPSettingSwitchStatus(switchStatus);
1740 EXPECT_EQ(switchStatus, false);
1741 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1742 MockMessageParcel::SetReadBoolErrorFlag(false);
1743
1744 // ReadInt32 failed
1745 MockMessageParcel::SetReadInt32ErrorFlag(true);
1746 ret = proxy->GetPiPSettingSwitchStatus(switchStatus);
1747 EXPECT_EQ(switchStatus, false);
1748 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1749 MockMessageParcel::SetReadInt32ErrorFlag(false);
1750 MockMessageParcel::ClearAllErrorFlag();
1751
1752 // interface success
1753 ret = proxy->GetPiPSettingSwitchStatus(switchStatus);
1754 EXPECT_EQ(ret, WMError::WM_OK);
1755 }
1756
1757 /**
1758 * @tc.name: SetScreenPrivacyWindowTagSwitch01
1759 * @tc.desc: SetScreenPrivacyWindowTagSwitch
1760 * @tc.type: FUNC
1761 */
1762 HWTEST_F(sceneSessionManagerProxyTest, SetScreenPrivacyWindowTagSwitch01, TestSize.Level1)
1763 {
1764 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1765 uint64_t screenId = 0;
1766 std::vector<std::string> privacyWindowTags;
1767 bool enable = false;
1768
1769 // remote == nullptr
1770 auto ret = tempProxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1771 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1772
1773 // WriteInterfaceToken failed
1774 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1775 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1776 MockMessageParcel::ClearAllErrorFlag();
1777 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1778 ASSERT_NE(proxy, nullptr);
1779 ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1780 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1781 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1782
1783 // SendRequest failed
1784 ASSERT_NE(proxy, nullptr);
1785 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1786 ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1787 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1788 remoteMocker->SetRequestResult(ERR_NONE);
1789 }
1790
1791 /**
1792 * @tc.name: SetScreenPrivacyWindowTagSwitch02
1793 * @tc.desc: SetScreenPrivacyWindowTagSwitch
1794 * @tc.type: FUNC
1795 */
1796 HWTEST_F(sceneSessionManagerProxyTest, SetScreenPrivacyWindowTagSwitch02, TestSize.Level1)
1797 {
1798 uint64_t screenId = 0;
1799 std::vector<std::string> privacyWindowTags;
1800 bool enable = false;
1801
1802 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1803 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1804
1805 // ReadBool failed
1806 MockMessageParcel::SetWriteBoolErrorFlag(true);
1807 auto ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1808 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1809 MockMessageParcel::SetWriteBoolErrorFlag(false);
1810
1811 // ReadUint64 failed
1812 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1813 ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1814 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1815 MockMessageParcel::SetWriteUint64ErrorFlag(false);
1816 MockMessageParcel::ClearAllErrorFlag();
1817
1818 // ReadString failed
1819 privacyWindowTags.push_back("test");
1820 MockMessageParcel::SetWriteStringErrorFlag(true);
1821 ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1822 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1823 MockMessageParcel::SetWriteStringErrorFlag(false);
1824 MockMessageParcel::ClearAllErrorFlag();
1825
1826 // interface success
1827 ret = proxy->SetScreenPrivacyWindowTagSwitch(screenId, privacyWindowTags, enable);
1828 EXPECT_EQ(ret, WMError::WM_OK);
1829 }
1830
1831 /**
1832 * @tc.name: AddSessionBlackList01
1833 * @tc.desc: AddSessionBlackList
1834 * @tc.type: FUNC
1835 */
1836 HWTEST_F(sceneSessionManagerProxyTest, AddSessionBlackList01, TestSize.Level1)
1837 {
1838 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1839 std::unordered_set<std::string> bundleNames;
1840 std::unordered_set<std::string> privacyWindowTags;
1841
1842 // remote == nullptr
1843 auto ret = tempProxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1844 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1845
1846 // WriteInterfaceToken failed
1847 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1848 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1849 MockMessageParcel::ClearAllErrorFlag();
1850 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1851 ASSERT_NE(proxy, nullptr);
1852 ret = proxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1853 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1854 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1855
1856 // SendRequest failed
1857 ASSERT_NE(proxy, nullptr);
1858 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1859 ret = proxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1860 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1861 remoteMocker->SetRequestResult(ERR_NONE);
1862 }
1863
1864 /**
1865 * @tc.name: AddSessionBlackList02
1866 * @tc.desc: AddSessionBlackList
1867 * @tc.type: FUNC
1868 */
1869 HWTEST_F(sceneSessionManagerProxyTest, AddSessionBlackList02, TestSize.Level1)
1870 {
1871 std::unordered_set<std::string> bundleNames;
1872 std::unordered_set<std::string> privacyWindowTags;
1873
1874 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1875 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1876
1877 // ReadUint64 failed
1878 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1879 auto ret = proxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1880 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1881 MockMessageParcel::SetWriteUint64ErrorFlag(false);
1882 MockMessageParcel::ClearAllErrorFlag();
1883
1884 // ReadString failed
1885 bundleNames.insert("test");
1886 MockMessageParcel::SetWriteStringErrorFlag(true);
1887 ret = proxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1888 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1889 MockMessageParcel::SetWriteStringErrorFlag(false);
1890 MockMessageParcel::ClearAllErrorFlag();
1891
1892 // interface success
1893 ret = proxy->AddSessionBlackList(bundleNames, privacyWindowTags);
1894 EXPECT_EQ(ret, WMError::WM_OK);
1895 }
1896
1897 /**
1898 * @tc.name: RemoveSessionBlackList01
1899 * @tc.desc: RemoveSessionBlackList
1900 * @tc.type: FUNC
1901 */
1902 HWTEST_F(sceneSessionManagerProxyTest, RemoveSessionBlackList01, TestSize.Level1)
1903 {
1904 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1905 std::unordered_set<std::string> bundleNames;
1906 std::unordered_set<std::string> privacyWindowTags;
1907
1908 // remote == nullptr
1909 auto ret = tempProxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1910 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1911
1912 // WriteInterfaceToken failed
1913 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1914 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1915 MockMessageParcel::ClearAllErrorFlag();
1916 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1917 ASSERT_NE(proxy, nullptr);
1918 ret = proxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1919 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1920 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1921
1922 // SendRequest failed
1923 ASSERT_NE(proxy, nullptr);
1924 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1925 ret = proxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1926 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1927 remoteMocker->SetRequestResult(ERR_NONE);
1928 }
1929
1930 /**
1931 * @tc.name: RemoveSessionBlackList02
1932 * @tc.desc: RemoveSessionBlackList
1933 * @tc.type: FUNC
1934 */
1935 HWTEST_F(sceneSessionManagerProxyTest, RemoveSessionBlackList02, TestSize.Level1)
1936 {
1937 std::unordered_set<std::string> bundleNames;
1938 std::unordered_set<std::string> privacyWindowTags;
1939
1940 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1941 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1942
1943 // ReadUint64 failed
1944 MockMessageParcel::SetWriteUint64ErrorFlag(true);
1945 auto ret = proxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1946 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1947 MockMessageParcel::SetWriteUint64ErrorFlag(false);
1948 MockMessageParcel::ClearAllErrorFlag();
1949
1950 // ReadString failed
1951 bundleNames.insert("test");
1952 MockMessageParcel::SetWriteStringErrorFlag(true);
1953 ret = proxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1954 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1955 MockMessageParcel::SetWriteStringErrorFlag(false);
1956 MockMessageParcel::ClearAllErrorFlag();
1957
1958 // interface success
1959 ret = proxy->RemoveSessionBlackList(bundleNames, privacyWindowTags);
1960 EXPECT_EQ(ret, WMError::WM_OK);
1961 }
1962
1963 /**
1964 * @tc.name: RecoverWindowPropertyChangeFlag01
1965 * @tc.desc: RecoverWindowPropertyChangeFlag
1966 * @tc.type: FUNC
1967 */
1968 HWTEST_F(sceneSessionManagerProxyTest, RecoverWindowPropertyChangeFlag01, TestSize.Level1)
1969 {
1970 auto tempProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1971 uint32_t observedFlags = 0;
1972 uint32_t interestedFlags = 0;
1973
1974 // remote == nullptr
1975 auto ret = tempProxy->RecoverWindowPropertyChangeFlag(observedFlags, interestedFlags);
1976 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1977
1978 // WriteInterfaceToken failed
1979 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
1980 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
1981 MockMessageParcel::ClearAllErrorFlag();
1982 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(true);
1983 ASSERT_NE(proxy, nullptr);
1984 ret = proxy->RecoverWindowPropertyChangeFlag(observedFlags, interestedFlags);
1985 EXPECT_EQ(WMError::WM_ERROR_IPC_FAILED, ret);
1986 MockMessageParcel::SetWriteInterfaceTokenErrorFlag(false);
1987
1988 // SendRequest failed
1989 ASSERT_NE(proxy, nullptr);
1990 remoteMocker->SetRequestResult(ERR_INVALID_DATA);
1991 ret = proxy->RecoverWindowPropertyChangeFlag(observedFlags, interestedFlags);
1992 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
1993 remoteMocker->SetRequestResult(ERR_NONE);
1994 }
1995
1996 /**
1997 * @tc.name: RecoverWindowPropertyChangeFlag02
1998 * @tc.desc: RecoverWindowPropertyChangeFlag
1999 * @tc.type: FUNC
2000 */
2001 HWTEST_F(sceneSessionManagerProxyTest, RecoverWindowPropertyChangeFlag02, TestSize.Level1)
2002 {
2003 uint32_t observedFlags = 0;
2004 uint32_t interestedFlags = 0;
2005
2006 sptr<MockIRemoteObject> remoteMocker = sptr<MockIRemoteObject>::MakeSptr();
2007 auto proxy = sptr<SceneSessionManagerProxy>::MakeSptr(remoteMocker);
2008
2009 // ReadUint32 failed
2010 MockMessageParcel::SetWriteUint32ErrorFlag(true);
2011 auto ret = proxy->RecoverWindowPropertyChangeFlag(observedFlags, interestedFlags);
2012 EXPECT_EQ(ret, WMError::WM_ERROR_IPC_FAILED);
2013 MockMessageParcel::SetWriteUint32ErrorFlag(false);
2014 MockMessageParcel::ClearAllErrorFlag();
2015
2016 // interface success
2017 ret = proxy->RecoverWindowPropertyChangeFlag(observedFlags, interestedFlags);
2018 EXPECT_EQ(ret, WMError::WM_OK);
2019 }
2020 } // namespace
2021 } // namespace Rosen
2022 } // namespace OHOS
2023