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_session.h"
19 #include "mock/mock_session_stage.h"
20 #include "mock/mock_window_event_channel.h"
21 #include "session_manager/include/scene_session_manager.h"
22 #include "session_manager/include/zidl/scene_session_manager_interface.h"
23 #include "session_manager/include/zidl/scene_session_manager_proxy.h"
24 #include "window_manager_agent.h"
25 #include "zidl/window_manager_agent_interface.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29 namespace OHOS {
30 namespace Rosen {
31 class sceneSessionManagerProxyTest : public testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37 sptr<IRemoteObject> iRemoteObjectMocker;
38 };
39
SetUpTestCase()40 void sceneSessionManagerProxyTest::SetUpTestCase()
41 {
42 }
43
TearDownTestCase()44 void sceneSessionManagerProxyTest::TearDownTestCase()
45 {
46 }
47
SetUp()48 void sceneSessionManagerProxyTest::SetUp()
49 {
50 }
51
TearDown()52 void sceneSessionManagerProxyTest::TearDown()
53 {
54 }
55
56 namespace {
57 /**
58 * @tc.name: CreateAndConnectSpecificSession
59 * @tc.desc: normal function
60 * @tc.type: FUNC
61 */
62 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession, Function | SmallTest | Level2)
63 {
64 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
65 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
66 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
67 EXPECT_NE(sceneSessionManagerProxy, nullptr);
68
69 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
70 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
71 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
72 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
73 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
74 int32_t persistentId = 0;
75 SessionInfo info;
76 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
77 SystemSessionConfig systemConfig;
78 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
79
80 sceneSessionManagerProxy->CreateAndConnectSpecificSession(sessionStage, eventChannel, node, property,
81 persistentId, session, systemConfig, token);
82 EXPECT_NE(sceneSessionManagerProxy, nullptr);
83 }
84
85 /**
86 * @tc.name: CreateAndConnectSpecificSession2
87 * @tc.desc: normal function
88 * @tc.type: FUNC
89 */
90 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession2, Function | SmallTest | Level2)
91 {
92 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
93 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
94 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
95 EXPECT_NE(sceneSessionManagerProxy, nullptr);
96
97 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
98 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
99 std::shared_ptr<RSSurfaceNode> node = nullptr;
100 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
101 int32_t persistentId = 0;
102 SessionInfo info;
103 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
104 SystemSessionConfig systemConfig;
105 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
106
107 sceneSessionManagerProxy->CreateAndConnectSpecificSession(sessionStage, eventChannel, node, property,
108 persistentId, session, systemConfig, token);
109 EXPECT_NE(sceneSessionManagerProxy, nullptr);
110 }
111
112 /**
113 * @tc.name: CreateAndConnectSpecificSession3
114 * @tc.desc: normal function
115 * @tc.type: FUNC
116 */
117 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession3, Function | SmallTest | Level2)
118 {
119 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
120 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
121 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
122 EXPECT_NE(sceneSessionManagerProxy, nullptr);
123
124 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
125 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
126 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
127 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
128 sptr<WindowSessionProperty> property = nullptr;
129 int32_t persistentId = 0;
130 SessionInfo info;
131 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
132 SystemSessionConfig systemConfig;
133 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
134
135 sceneSessionManagerProxy->CreateAndConnectSpecificSession(sessionStage, eventChannel, node, property,
136 persistentId, session, systemConfig, token);
137 EXPECT_NE(sceneSessionManagerProxy, nullptr);
138 }
139
140 /**
141 * @tc.name: CreateAndConnectSpecificSession4
142 * @tc.desc: normal function
143 * @tc.type: FUNC
144 */
145 HWTEST_F(sceneSessionManagerProxyTest, CreateAndConnectSpecificSession4, Function | SmallTest | Level2)
146 {
147 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
148 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
149 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
150 EXPECT_NE(sceneSessionManagerProxy, nullptr);
151
152 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
153 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
154 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
155 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
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(sessionStage, eventChannel, node, property,
164 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, Function | SmallTest | Level2)
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 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
183 SessionInfo info;
184 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
185 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
186
187 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(sessionStage, eventChannel, node, property,
188 session, token);
189 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
190 }
191
192 /**
193 * @tc.name: RecoverAndConnectSpecificSession2
194 * @tc.desc: normal function
195 * @tc.type: FUNC
196 */
197 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndConnectSpecificSession2, Function | SmallTest | Level2)
198 {
199 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
200 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
201
202 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
203 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
204 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
205 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
206 sptr<WindowSessionProperty> property = nullptr;
207 SessionInfo info;
208 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
209 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
210
211 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(sessionStage, eventChannel, node, property,
212 session, token);
213 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
214 }
215
216 /**
217 * @tc.name: RecoverAndConnectSpecificSession3
218 * @tc.desc: normal function
219 * @tc.type: FUNC
220 */
221 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndConnectSpecificSession3, Function | SmallTest | Level2)
222 {
223 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
224 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
225
226 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
227 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
228 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
229 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
230 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
231 SessionInfo info;
232 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
233 sptr<IRemoteObject> token = nullptr;
234
235 auto ret = sceneSessionManagerProxy->RecoverAndConnectSpecificSession(sessionStage, eventChannel, node, property,
236 session, token);
237 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
238 }
239
240 /**
241 * @tc.name: RecoverAndReconnectSceneSession
242 * @tc.desc: normal function
243 * @tc.type: FUNC
244 */
245 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession, Function | SmallTest | Level2)
246 {
247 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
248 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
249
250 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
251 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
252 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
253 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
254 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
255 SessionInfo info;
256 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
257 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
258
259 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(sessionStage, eventChannel, node, session,
260 property, token);
261 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
262 }
263
264 /**
265 * @tc.name: RecoverAndReconnectSceneSession2
266 * @tc.desc: normal function
267 * @tc.type: FUNC
268 */
269 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession2, Function | SmallTest | Level2)
270 {
271 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
272 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
273
274 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
275 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
276 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
277 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
278 sptr<WindowSessionProperty> property = nullptr;
279 SessionInfo info;
280 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
281 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
282
283 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(sessionStage, eventChannel, node, session,
284 property, token);
285 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
286 }
287
288 /**
289 * @tc.name: RecoverAndReconnectSceneSession3
290 * @tc.desc: normal function
291 * @tc.type: FUNC
292 */
293 HWTEST_F(sceneSessionManagerProxyTest, RecoverAndReconnectSceneSession3, Function | SmallTest | Level2)
294 {
295 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
296 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
297
298 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
299 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
300 struct RSSurfaceNodeConfig rsSurfaceNodeConfig;
301 std::shared_ptr<RSSurfaceNode> node = RSSurfaceNode::Create(rsSurfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
302 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
303 SessionInfo info;
304 sptr<ISession> session = sptr<SessionMocker>::MakeSptr(info);
305 sptr<IRemoteObject> token = nullptr;
306
307 auto ret = sceneSessionManagerProxy->RecoverAndReconnectSceneSession(sessionStage, eventChannel, node, session,
308 property, token);
309 EXPECT_EQ(ret, WSError::WS_ERROR_IPC_FAILED);
310 }
311
312 /**
313 * @tc.name: DestroyAndDisconnectSpecificSession
314 * @tc.desc: normal function
315 * @tc.type: FUNC
316 */
317 HWTEST_F(sceneSessionManagerProxyTest, DestroyAndDisconnectSpecificSession, Function | SmallTest | Level2)
318 {
319 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
320 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
321 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
322 EXPECT_NE(sceneSessionManagerProxy, nullptr);
323
324 sceneSessionManagerProxy->DestroyAndDisconnectSpecificSession(0);
325 EXPECT_NE(sceneSessionManagerProxy, nullptr);
326 }
327
328 /**
329 * @tc.name: DestroyAndDisconnectSpecificSessionWithDetachCallback
330 * @tc.desc: normal function
331 * @tc.type: FUNC
332 */
333 HWTEST_F(
334 sceneSessionManagerProxyTest,
335 DestroyAndDisconnectSpecificSessionWithDetachCallback,
336 Function | SmallTest | Level2
337 )
338 {
339 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
340 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
341 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
342 EXPECT_NE(sceneSessionManagerProxy, nullptr);
343
344 sptr<IRemoteObject> callback = sptr<IRemoteObjectMocker>::MakeSptr();
345
346 sceneSessionManagerProxy->DestroyAndDisconnectSpecificSessionWithDetachCallback(0, callback);
347 EXPECT_NE(sceneSessionManagerProxy, nullptr);
348 }
349
350 /**
351 * @tc.name: UpdateSessionTouchOutsideListener
352 * @tc.desc: normal function
353 * @tc.type: FUNC
354 */
355 HWTEST_F(sceneSessionManagerProxyTest, UpdateSessionTouchOutsideListener, Function | SmallTest | Level2)
356 {
357 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
358 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
359 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
360 EXPECT_NE(sceneSessionManagerProxy, nullptr);
361
362 int32_t persistentId = 0;
363 sceneSessionManagerProxy->UpdateSessionTouchOutsideListener(persistentId, true);
364 sceneSessionManagerProxy->UpdateSessionTouchOutsideListener(persistentId, false);
365 EXPECT_NE(sceneSessionManagerProxy, nullptr);
366 }
367
368 /**
369 * @tc.name: SkipSnapshotForAppProcess
370 * @tc.desc: normal function
371 * @tc.type: FUNC
372 */
373 HWTEST_F(sceneSessionManagerProxyTest, SkipSnapshotForAppProcess, Function | SmallTest | Level2)
374 {
375 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
376 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
377
378 int32_t pid = 1000;
379 bool skip = false;
380 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SkipSnapshotForAppProcess(pid, skip));
381 }
382
383 /**
384 * @tc.name: SetGestureNavigationEnabled
385 * @tc.desc: normal function
386 * @tc.type: FUNC
387 */
388 HWTEST_F(sceneSessionManagerProxyTest, SetGestureNavigationEnabled, Function | SmallTest | Level2)
389 {
390 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
391 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
392 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
393 EXPECT_NE(sceneSessionManagerProxy, nullptr);
394
395 sceneSessionManagerProxy->SetGestureNavigationEnabled(true);
396 sceneSessionManagerProxy->SetGestureNavigationEnabled(false);
397 EXPECT_NE(sceneSessionManagerProxy, nullptr);
398 }
399
400 /**
401 * @tc.name: GetFocusWindowInfo
402 * @tc.desc: normal function
403 * @tc.type: FUNC
404 */
405 HWTEST_F(sceneSessionManagerProxyTest, GetFocusWindowInfo, Function | SmallTest | Level2)
406 {
407 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
408 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
409 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
410 EXPECT_NE(sceneSessionManagerProxy, nullptr);
411
412 FocusChangeInfo focusInfo{};
413 sceneSessionManagerProxy->GetFocusWindowInfo(focusInfo);
414 EXPECT_NE(sceneSessionManagerProxy, nullptr);
415 }
416
417 /**
418 * @tc.name: SetSessionIcon
419 * @tc.desc: normal function
420 * @tc.type: FUNC
421 */
422 HWTEST_F(sceneSessionManagerProxyTest, SetSessionIcon, Function | SmallTest | Level2)
423 {
424 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
425 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
426 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
427 EXPECT_NE(sceneSessionManagerProxy, nullptr);
428
429 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
430 std::shared_ptr<Media::PixelMap> icon = nullptr;
431 sceneSessionManagerProxy->SetSessionIcon(token, icon);
432 EXPECT_NE(sceneSessionManagerProxy, nullptr);
433 }
434
435 /**
436 * @tc.name: GetAccessibilityWindowInfo
437 * @tc.desc: normal function
438 * @tc.type: FUNC
439 */
440 HWTEST_F(sceneSessionManagerProxyTest, GetAccessibilityWindowInfo, Function | SmallTest | Level2)
441 {
442 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
443 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
444 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
445 EXPECT_NE(sceneSessionManagerProxy, nullptr);
446
447 std::vector<sptr<AccessibilityWindowInfo>> infos{};
448 sceneSessionManagerProxy->GetAccessibilityWindowInfo(infos);
449 EXPECT_NE(sceneSessionManagerProxy, nullptr);
450 }
451
452 /**
453 * @tc.name: GetUnreliableWindowInfo
454 * @tc.desc: normal function
455 * @tc.type: FUNC
456 */
457 HWTEST_F(sceneSessionManagerProxyTest, GetUnreliableWindowInfo, Function | SmallTest | Level2)
458 {
459 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
460 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
461 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
462 EXPECT_NE(sceneSessionManagerProxy, nullptr);
463
464 std::vector<sptr<UnreliableWindowInfo>> infos{};
465 sceneSessionManagerProxy->GetUnreliableWindowInfo(0, infos);
466 EXPECT_NE(sceneSessionManagerProxy, nullptr);
467 }
468
469 /**
470 * @tc.name: GetSessionInfos
471 * @tc.desc: normal function
472 * @tc.type: FUNC
473 */
474 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfos, Function | SmallTest | Level2)
475 {
476 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
477 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
478 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
479 EXPECT_NE(sceneSessionManagerProxy, nullptr);
480
481 std::string deviceId;
482 std::vector<SessionInfoBean> sessionInfos{};
483 sceneSessionManagerProxy->GetSessionInfos(deviceId, 0, sessionInfos);
484 EXPECT_NE(sceneSessionManagerProxy, nullptr);
485 }
486
487 /**
488 * @tc.name: GetSessionInfo
489 * @tc.desc: normal function
490 * @tc.type: FUNC
491 */
492 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfo, Function | SmallTest | Level2)
493 {
494 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
495 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
496 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
497 EXPECT_NE(sceneSessionManagerProxy, nullptr);
498
499 std::string deviceId;
500 SessionInfoBean sessionInfo;
501 sceneSessionManagerProxy->GetSessionInfo(deviceId, 0, sessionInfo);
502 EXPECT_NE(sceneSessionManagerProxy, nullptr);
503 }
504
505 /**
506 * @tc.name: RegisterWindowManagerAgent01
507 * @tc.desc: normal function
508 * @tc.type: FUNC
509 */
510 HWTEST_F(sceneSessionManagerProxyTest, RegisterWindowManagerAgent01, Function | SmallTest | Level2)
511 {
512 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
513 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
514 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
515 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
516
517 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->RegisterWindowManagerAgent(type, windowManagerAgent));
518 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->UnregisterWindowManagerAgent(type, windowManagerAgent));
519 }
520
521 /**
522 * @tc.name: UpdateModalExtensionRect
523 * @tc.desc: normal function
524 * @tc.type: FUNC
525 */
526 HWTEST_F(sceneSessionManagerProxyTest, UpdateModalExtensionRect, Function | SmallTest | Level2)
527 {
528 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
529 ASSERT_NE(iRemoteObjectMocker, nullptr);
530 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
531 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
532 ASSERT_NE(sceneSessionManagerProxy, nullptr);
533
534 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
535 ASSERT_NE(token, nullptr);
536 Rect rect { 1, 2, 3, 4 };
537 sceneSessionManagerProxy->UpdateModalExtensionRect(token, rect);
538 sceneSessionManagerProxy->UpdateModalExtensionRect(nullptr, rect);
539 }
540
541 /**
542 * @tc.name: ProcessModalExtensionPointDown
543 * @tc.desc: normal function
544 * @tc.type: FUNC
545 */
546 HWTEST_F(sceneSessionManagerProxyTest, ProcessModalExtensionPointDown, Function | SmallTest | Level2)
547 {
548 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
549 ASSERT_NE(iRemoteObjectMocker, nullptr);
550 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
551 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
552 ASSERT_NE(sceneSessionManagerProxy, nullptr);
553
554 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
555 ASSERT_NE(token, nullptr);
556 sceneSessionManagerProxy->ProcessModalExtensionPointDown(token, 0, 0);
557 sceneSessionManagerProxy->ProcessModalExtensionPointDown(nullptr, 0, 0);
558 }
559
560 /**
561 * @tc.name: AddExtensionWindowStageToSCB
562 * @tc.desc: normal function
563 * @tc.type: FUNC
564 */
565 HWTEST_F(sceneSessionManagerProxyTest, AddExtensionWindowStageToSCB, Function | SmallTest | Level2)
566 {
567 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
568 ASSERT_NE(iRemoteObjectMocker, nullptr);
569 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
570 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
571 ASSERT_NE(sceneSessionManagerProxy, nullptr);
572
573 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
574 ASSERT_NE(sessionStage, nullptr);
575 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
576 ASSERT_NE(token, nullptr);
577 sceneSessionManagerProxy->AddExtensionWindowStageToSCB(sessionStage, token, 12345);
578 }
579
580 /**
581 * @tc.name: RemoveExtensionWindowStageFromSCB
582 * @tc.desc: normal function
583 * @tc.type: FUNC
584 */
585 HWTEST_F(sceneSessionManagerProxyTest, RemoveExtensionWindowStageFromSCB, Function | SmallTest | Level2)
586 {
587 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
588 ASSERT_NE(iRemoteObjectMocker, nullptr);
589 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
590 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
591 ASSERT_NE(sceneSessionManagerProxy, nullptr);
592
593 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
594 ASSERT_NE(sessionStage, nullptr);
595 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
596 ASSERT_NE(token, nullptr);
597 sceneSessionManagerProxy->RemoveExtensionWindowStageFromSCB(sessionStage, token);
598 }
599
600 /**
601 * @tc.name: AddOrRemoveSecureSession
602 * @tc.desc: normal function
603 * @tc.type: FUNC
604 */
605 HWTEST_F(sceneSessionManagerProxyTest, AddOrRemoveSecureSession001, Function | SmallTest | Level2)
606 {
607 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
608 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
609
610 int32_t persistentId = 12345;
611 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->AddOrRemoveSecureSession(persistentId, true));
612 }
613
614 /**
615 * @tc.name: UpdateExtWindowFlags
616 * @tc.desc: normal function
617 * @tc.type: FUNC
618 */
619 HWTEST_F(sceneSessionManagerProxyTest, UpdateExtWindowFlags, Function | SmallTest | Level2)
620 {
621 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
622 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
623
624 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
625 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->UpdateExtWindowFlags(token, 7, 7));
626 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, sceneSessionManagerProxy->UpdateExtWindowFlags(nullptr, 7, 7));
627 }
628
629 /**
630 * @tc.name: GetSessionInfoByContinueSessionId
631 * @tc.desc: normal function
632 * @tc.type: FUNC
633 */
634 HWTEST_F(sceneSessionManagerProxyTest, GetSessionInfoByContinueSessionId, Function | SmallTest | Level2)
635 {
636 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
637 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
638
639 std::string continueSessionId = "test_01";
640 SessionInfoBean missionInfo;
641 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED,
642 sceneSessionManagerProxy->GetSessionInfoByContinueSessionId(continueSessionId, missionInfo));
643 }
644
645 /**
646 * @tc.name: RequestFocusStatus01
647 * @tc.desc: normal function
648 * @tc.type: FUNC
649 */
650 HWTEST_F(sceneSessionManagerProxyTest, RequestFocusStatus01, Function | SmallTest | Level2)
651 {
652 int32_t persistendId = 0;
653 bool isFocused = true;
654 bool byForeground = true;
655 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
656 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
657
658 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->RequestFocusStatus(persistendId, isFocused, byForeground));
659 }
660
661 /**
662 * @tc.name: RequestFocusStatusBySA01
663 * @tc.desc: normal function
664 * @tc.type: FUNC
665 */
666 HWTEST_F(sceneSessionManagerProxyTest, RequestFocusStatusBySA01, Function | SmallTest | Level2)
667 {
668 FocusChangeReason reason = FocusChangeReason::CLICK;
669 int32_t persistendId = 0;
670 bool isFocused = true;
671 bool byForeground = true;
672 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
673 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
674 auto result = sceneSessionManagerProxy->SceneSessionManagerProxy::RequestFocusStatusBySA(
675 persistendId, isFocused, byForeground, reason);
676 ASSERT_EQ(WMError::WM_OK, result);
677 }
678
679 /**
680 * @tc.name: RaiseWindowToTop
681 * @tc.desc: normal function
682 * @tc.type: FUNC
683 */
684 HWTEST_F(sceneSessionManagerProxyTest, RaiseWindowToTop, Function | SmallTest | Level2)
685 {
686 int32_t persistendId = 0;
687 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
688 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
689
690 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->RaiseWindowToTop(persistendId));
691 }
692
693 /**
694 * @tc.name: BindDialogSessionTarget
695 * @tc.desc: normal function
696 * @tc.type: FUNC
697 */
698 HWTEST_F(sceneSessionManagerProxyTest, BindDialogSessionTarget, Function | SmallTest | Level2)
699 {
700 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
701 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
702 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
703 EXPECT_NE(sceneSessionManagerProxy, nullptr);
704
705 sptr<IRemoteObject> targetToken = sptr<IRemoteObjectMocker>::MakeSptr();
706 sceneSessionManagerProxy->BindDialogSessionTarget(0, targetToken);
707 EXPECT_NE(sceneSessionManagerProxy, nullptr);
708 }
709
710 /**
711 * @tc.name: BindDialogSessionTarget2
712 * @tc.desc: normal function
713 * @tc.type: FUNC
714 */
715 HWTEST_F(sceneSessionManagerProxyTest, BindDialogSessionTarget2, Function | SmallTest | Level2)
716 {
717 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
718 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
719 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
720 EXPECT_NE(sceneSessionManagerProxy, nullptr);
721
722 sptr<IRemoteObject> targetToken = nullptr;
723 sceneSessionManagerProxy->BindDialogSessionTarget(0, targetToken);
724 EXPECT_NE(sceneSessionManagerProxy, nullptr);
725 }
726
727 /**
728 * @tc.name: UpdateSessionAvoidAreaListener
729 * @tc.desc: normal function
730 * @tc.type: FUNC
731 */
732 HWTEST_F(sceneSessionManagerProxyTest, UpdateSessionAvoidAreaListener, Function | SmallTest | Level2)
733 {
734 int32_t persistendId = 0;
735 bool haveListener = true;
736 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
737 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
738
739 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->UpdateSessionAvoidAreaListener(persistendId,
740 haveListener));
741 }
742
743 /**
744 * @tc.name: SetSessionLabel
745 * @tc.desc: normal function
746 * @tc.type: FUNC
747 */
748 HWTEST_F(sceneSessionManagerProxyTest, SetSessionLabel, Function | SmallTest | Level2)
749 {
750 sptr<IRemoteObject> token = nullptr;
751 std::string label = "SetSessionLabel";
752 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
753 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
754
755 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, sceneSessionManagerProxy->SetSessionLabel(token, label));
756 }
757
758 /**
759 * @tc.name: IsValidSessionIds
760 * @tc.desc: normal function
761 * @tc.type: FUNC
762 */
763 HWTEST_F(sceneSessionManagerProxyTest, IsValidSessionIds, Function | SmallTest | Level2)
764 {
765 std::vector<int32_t> sessionIds;
766 std::vector<bool> results;
767 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
768 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
769
770 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->IsValidSessionIds(sessionIds, results));
771 }
772
773 /**
774 * @tc.name: RegisterSessionListener01
775 * @tc.desc: normal function
776 * @tc.type: FUNC
777 */
778 HWTEST_F(sceneSessionManagerProxyTest, RegisterSessionListener01, Function | SmallTest | Level2)
779 {
780 sptr<ISessionListener> listener = nullptr;
781 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
782 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
783
784 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->RegisterSessionListener(listener));
785 }
786
787 /**
788 * @tc.name: UnRegisterSessionListener
789 * @tc.desc: normal function
790 * @tc.type: FUNC
791 */
792 HWTEST_F(sceneSessionManagerProxyTest, UnRegisterSessionListener, Function | SmallTest | Level2)
793 {
794 sptr<ISessionListener> listener = nullptr;
795 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
796 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
797
798 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->UnRegisterSessionListener(listener));
799 }
800
801 /**
802 * @tc.name: GetSnapshotByWindowId
803 * @tc.desc: normal function
804 * @tc.type: FUNC
805 */
806 HWTEST_F(sceneSessionManagerProxyTest, GetSnapshotByWindowId, Function | SmallTest | Level2)
807 {
808 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
809 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
810 int32_t windowId = -1;
811 std::shared_ptr<Media::PixelMap> pixelMap = nullptr;
812 WMError ret = sceneSessionManagerProxy->GetSnapshotByWindowId(windowId, pixelMap);
813 ASSERT_EQ(WMError::WM_OK, ret);
814 }
815
816 /**
817 * @tc.name: GetSessionSnapshotById
818 * @tc.desc: normal function
819 * @tc.type: FUNC
820 */
821 HWTEST_F(sceneSessionManagerProxyTest, GetSessionSnapshotById, Function | SmallTest | Level2)
822 {
823 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
824 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
825 int32_t windowId = -1;
826 SessionSnapshot snapshot;
827 WMError ret = sceneSessionManagerProxy->GetSessionSnapshotById(windowId, snapshot);
828 ASSERT_EQ(WMError::WM_OK, ret);
829 }
830
831 /**
832 * @tc.name: TerminateSessionNew
833 * @tc.desc: normal function
834 * @tc.type: FUNC
835 */
836 HWTEST_F(sceneSessionManagerProxyTest, TerminateSessionNew, Function | SmallTest | Level2)
837 {
838 sptr<ISessionListener> listener = nullptr;
839 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
840 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
841
842 ASSERT_EQ(WSError::WS_ERROR_INVALID_SESSION, sceneSessionManagerProxy->TerminateSessionNew(nullptr, true, true));
843 }
844
845 /**
846 * @tc.name: GetSessionDumpInfo
847 * @tc.desc: normal function
848 * @tc.type: FUNC
849 */
850 HWTEST_F(sceneSessionManagerProxyTest, GetSessionDumpInfo, Function | SmallTest | Level2)
851 {
852 std::vector<std::string> params;
853 std::string info = "info";
854 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
855 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
856
857 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->GetSessionDumpInfo(params, info));
858 }
859
860 /**
861 * @tc.name: LockSession
862 * @tc.desc: normal function
863 * @tc.type: FUNC
864 */
865 HWTEST_F(sceneSessionManagerProxyTest, LockSession, Function | SmallTest | Level2)
866 {
867 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
868 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
869
870 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->LockSession(0));
871 }
872
873 /**
874 * @tc.name: GetUIContentRemoteObj
875 * @tc.desc: normal function
876 * @tc.type: FUNC
877 */
878 HWTEST_F(sceneSessionManagerProxyTest, GetUIContentRemoteObj, Function | SmallTest | Level2)
879 {
880 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
881 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
882 sptr<IRemoteObject> remoteObj;
883 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, sceneSessionManagerProxy->GetUIContentRemoteObj(1, remoteObj));
884 }
885
886 /**
887 * @tc.name: ClearSession
888 * @tc.desc: normal function
889 * @tc.type: FUNC
890 */
891 HWTEST_F(sceneSessionManagerProxyTest, ClearSession, Function | SmallTest | Level2)
892 {
893 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
894 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
895
896 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->LockSession(0));
897 }
898
899 /**
900 * @tc.name: RegisterIAbilityManagerCollaborator
901 * @tc.desc: normal function
902 * @tc.type: FUNC
903 */
904 HWTEST_F(sceneSessionManagerProxyTest, RegisterIAbilityManagerCollaborator, Function | SmallTest | Level2)
905 {
906 sptr<AAFwk::IAbilityManagerCollaborator> impl = nullptr;
907 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
908 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
909
910 ASSERT_EQ(WSError::WS_ERROR_INVALID_PARAM, sceneSessionManagerProxy->RegisterIAbilityManagerCollaborator(0, impl));
911 }
912
913 /**
914 * @tc.name: NotifyWindowExtensionVisibilityChange
915 * @tc.desc: normal function
916 * @tc.type: FUNC
917 */
918 HWTEST_F(sceneSessionManagerProxyTest, NotifyWindowExtensionVisibilityChange, Function | SmallTest | Level2)
919 {
920 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
921 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
922
923 ASSERT_EQ(WSError::WS_OK, sceneSessionManagerProxy->NotifyWindowExtensionVisibilityChange(0, 0, true));
924 }
925
926 /**
927 * @tc.name: GetTopWindowId
928 * @tc.desc: normal function
929 * @tc.type: FUNC
930 */
931 HWTEST_F(sceneSessionManagerProxyTest, GetTopWindowId, Function | SmallTest | Level2)
932 {
933 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
934 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
935
936 uint32_t topWinId = 1;
937 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->GetTopWindowId(0, topWinId));
938 }
939
940 /**
941 * @tc.name: GetWindowStyleType
942 * @tc.desc: normal function
943 * @tc.type: FUNC
944 */
945 HWTEST_F(sceneSessionManagerProxyTest, GetWindowStyleType, Function | SmallTest | Level2)
946 {
947 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
948 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
949
950 WindowStyleType styleType;
951 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->GetWindowStyleType(styleType));
952 }
953
954 /**
955 * @tc.name: SetProcessWatermark
956 * @tc.desc: normal function
957 * @tc.type: FUNC
958 */
959 HWTEST_F(sceneSessionManagerProxyTest, SetProcessWatermark, Function | SmallTest | Level2)
960 {
961 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
962 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
963
964 int32_t pid = 1000;
965 const std::string watermarkName = "SetProcessWatermarkName";
966 bool isEnabled = false;
967 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SetProcessWatermark(pid, watermarkName, isEnabled));
968 }
969
970 /**
971 * @tc.name: GetWindowIdsByCoordinate
972 * @tc.desc: normal function
973 * @tc.type: FUNC
974 */
975 HWTEST_F(sceneSessionManagerProxyTest, GetWindowIdsByCoordinate, Function | SmallTest | Level2)
976 {
977 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
978 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
979
980 int64_t displayId = 1000;
981 int32_t windowNumber = 2;
982 int32_t x = 0;
983 int32_t y = 0;
984 std::vector<int32_t> windowIds;
985 WMError res = sceneSessionManagerProxy->GetWindowIdsByCoordinate(displayId, windowNumber, x, y, windowIds);
986 ASSERT_EQ(WMError::WM_OK, res);
987 }
988
989 /**
990 * @tc.name: GetProcessSurfaceNodeIdByPersistentId
991 * @tc.desc: normal function
992 * @tc.type: FUNC
993 */
994 HWTEST_F(sceneSessionManagerProxyTest, GetProcessSurfaceNodeIdByPersistentId, Function | SmallTest | Level2)
995 {
996 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
997 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
998
999 int32_t pid = 123;
1000 std::vector<int32_t> persistentIds = {1, 2, 3};
1001 std::vector<uint64_t> surfaceNodeIds;
1002 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->GetProcessSurfaceNodeIdByPersistentId(
1003 pid, persistentIds, surfaceNodeIds));
1004 }
1005
1006 /**
1007 * @tc.name: SkipSnapshotByUserIdAndBundleNames
1008 * @tc.desc: normal function
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(sceneSessionManagerProxyTest, SkipSnapshotByUserIdAndBundleNames, Function | SmallTest | Level2)
1012 {
1013 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1014 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1015
1016 int32_t userId = 1;
1017 std::vector<std::string> bundleNameList = {"a", "b", "c"};
1018 ASSERT_EQ(WMError::WM_OK, sceneSessionManagerProxy->SkipSnapshotByUserIdAndBundleNames(
1019 userId, bundleNameList));
1020 }
1021
1022 /**
1023 * @tc.name: UpdateScreenLockStatusForApp
1024 * @tc.desc: normal function
1025 * @tc.type: FUNC
1026 */
1027 HWTEST_F(sceneSessionManagerProxyTest, UpdateScreenLockStatusForApp, Function | SmallTest | Level2)
1028 {
1029 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1030 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1031 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1032 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1033 ASSERT_EQ(sceneSessionManagerProxy->UpdateScreenLockStatusForApp("", true), WMError::WM_OK);
1034 }
1035
1036 /**
1037 * @tc.name: AddSkipSelfWhenShowOnVirtualScreenList
1038 * @tc.desc: normal function
1039 * @tc.type: FUNC
1040 */
1041 HWTEST_F(sceneSessionManagerProxyTest, AddSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
1042 {
1043 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1044 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1045 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1046 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1047 std::vector<int32_t> persistentIds {0, 1, 2};
1048 ASSERT_EQ(sceneSessionManagerProxy->AddSkipSelfWhenShowOnVirtualScreenList(persistentIds), WMError::WM_OK);
1049 }
1050
1051 /**
1052 * @tc.name: RemoveSkipSelfWhenShowOnVirtualScreenList
1053 * @tc.desc: normal function
1054 * @tc.type: FUNC
1055 */
1056 HWTEST_F(sceneSessionManagerProxyTest, RemoveSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
1057 {
1058 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1059 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1060 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1061 EXPECT_NE(sceneSessionManagerProxy, nullptr);
1062 std::vector<int32_t> persistentIds {0, 1, 2};
1063 ASSERT_EQ(sceneSessionManagerProxy->RemoveSkipSelfWhenShowOnVirtualScreenList(persistentIds), WMError::WM_OK);
1064 }
1065
1066 /**
1067 * @tc.name: IsPcWindow
1068 * @tc.desc: IsPcWindow
1069 * @tc.type: FUNC
1070 */
1071 HWTEST_F(sceneSessionManagerProxyTest, IsPcWindow, Function | SmallTest | Level2)
1072 {
1073 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1074 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1075 bool isPcWindow = false;
1076 ASSERT_EQ(sceneSessionManagerProxy->IsPcWindow(isPcWindow),
1077 WMError::WM_ERROR_IPC_FAILED);
1078 ASSERT_EQ(isPcWindow, false);
1079 }
1080
1081 /**
1082 * @tc.name: IsPcOrPadFreeMultiWindowMode
1083 * @tc.desc: IsPcOrPadFreeMultiWindowMode
1084 * @tc.type: FUNC
1085 */
1086 HWTEST_F(sceneSessionManagerProxyTest, IsPcOrPadFreeMultiWindowMode, Function | SmallTest | Level2)
1087 {
1088 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1089 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1090 bool isPcOrPadFreeMultiWindowMode = false;
1091 ASSERT_EQ(sceneSessionManagerProxy->IsPcOrPadFreeMultiWindowMode(isPcOrPadFreeMultiWindowMode),
1092 WMError::WM_ERROR_IPC_FAILED);
1093 ASSERT_EQ(isPcOrPadFreeMultiWindowMode, false);
1094 }
1095
1096 /**
1097 * @tc.name: IsWindowRectAutoSave
1098 * @tc.desc: IsWindowRectAutoSave
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(sceneSessionManagerProxyTest, IsWindowRectAutoSave, Function | SmallTest | Level2)
1102 {
1103 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1104 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1105 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1106 bool enabled = false;
1107 std::string key = "com.example.recposentryEntryAbility";
1108 int persistentId = 1;
1109 ASSERT_EQ(sceneSessionManagerProxy->IsWindowRectAutoSave(key, enabled, persistentId), WMError::WM_ERROR_IPC_FAILED);
1110 }
1111
1112 /**
1113 * @tc.name: GetDisplayIdByWindowId
1114 * @tc.desc: GetDisplayIdByWindowId
1115 * @tc.type: FUNC
1116 */
1117 HWTEST_F(sceneSessionManagerProxyTest, GetDisplayIdByWindowId, Function | SmallTest | Level2)
1118 {
1119 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1120 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1121 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1122 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1123 const std::vector<uint64_t> windowIds = {1, 2};
1124 std::unordered_map<uint64_t, DisplayId> windowDisplayIdMap;
1125 sceneSessionManagerProxy->GetDisplayIdByWindowId(windowIds, windowDisplayIdMap);
1126 }
1127
1128 /**
1129 * @tc.name: SetGlobalDragResizeType
1130 * @tc.desc: SetGlobalDragResizeType
1131 * @tc.type: FUNC
1132 */
1133 HWTEST_F(sceneSessionManagerProxyTest, SetGlobalDragResizeType, Function | SmallTest | Level2)
1134 {
1135 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1136 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1137 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1138 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1139 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1140 sceneSessionManagerProxy->SetGlobalDragResizeType(dragResizeType);
1141 }
1142
1143 /**
1144 * @tc.name: GetGlobalDragResizeType
1145 * @tc.desc: GetGlobalDragResizeType
1146 * @tc.type: FUNC
1147 */
1148 HWTEST_F(sceneSessionManagerProxyTest, GetGlobalDragResizeType, Function | SmallTest | Level2)
1149 {
1150 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1151 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1152 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1153 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1154 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1155 sceneSessionManagerProxy->GetGlobalDragResizeType(dragResizeType);
1156 }
1157
1158 /**
1159 * @tc.name: SetAppDragResizeType
1160 * @tc.desc: SetAppDragResizeType
1161 * @tc.type: FUNC
1162 */
1163 HWTEST_F(sceneSessionManagerProxyTest, SetAppDragResizeType, Function | SmallTest | Level2)
1164 {
1165 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1166 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1167 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1168 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1169 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1170 const std::string bundleName = "test";
1171 sceneSessionManagerProxy->SetAppDragResizeType(bundleName, dragResizeType);
1172 }
1173
1174 /**
1175 * @tc.name: GetAppDragResizeType
1176 * @tc.desc: GetAppDragResizeType
1177 * @tc.type: FUNC
1178 */
1179 HWTEST_F(sceneSessionManagerProxyTest, GetAppDragResizeType, Function | SmallTest | Level2)
1180 {
1181 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1182 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1183 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1184 ASSERT_TRUE(sceneSessionManagerProxy != nullptr);
1185 DragResizeType toDragResizeType = DragResizeType::RESIZE_EACH_FRAME;
1186 DragResizeType dragResizeType = DragResizeType::RESIZE_TYPE_UNDEFINED;
1187 const std::string bundleName = "test";
1188 std::unordered_map<std::string, DragResizeType> appDragResizeTypeMap_;
1189 appDragResizeTypeMap_[bundleName] = toDragResizeType;
1190 sceneSessionManagerProxy->GetAppDragResizeType(bundleName, dragResizeType);
1191 }
1192
1193 /**
1194 * @tc.name: GetFocusSessionToken
1195 * @tc.desc: GetFocusSessionToken
1196 * @tc.type: FUNC
1197 */
1198 HWTEST_F(sceneSessionManagerProxyTest, GetFocusSessionToken, Function | SmallTest | Level2)
1199 {
1200 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1201 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1202 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1203
1204 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1205 DisplayId displayId = 1000;
1206 WSError res = sceneSessionManagerProxy->GetFocusSessionToken(token, displayId);
1207 ASSERT_EQ(WSError::WS_OK, res);
1208 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1209 res = sceneSessionManagerProxy->GetFocusSessionToken(token, displayId);
1210 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1211 }
1212
1213 /**
1214 * @tc.name: GetFocusSessionElement
1215 * @tc.desc: GetFocusSessionElement
1216 * @tc.type: FUNC
1217 */
1218 HWTEST_F(sceneSessionManagerProxyTest, GetFocusSessionElement, Function | SmallTest | Level2)
1219 {
1220 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1221 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1222 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1223
1224 std::string device = "deviceTest";
1225 std::string bundle = "bundleTest";
1226 std::string ability = "abilityTest";
1227 OHOS::AppExecFwk::ElementName element(device, bundle, ability);
1228 DisplayId displayId = 1000;
1229 WSError res = sceneSessionManagerProxy->GetFocusSessionElement(element, displayId);
1230 ASSERT_EQ(WSError::WS_OK, res);
1231 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1232 res = sceneSessionManagerProxy->GetFocusSessionElement(element, displayId);
1233 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1234 }
1235
1236 /**
1237 * @tc.name: GetSessionSnapshot
1238 * @tc.desc: GetSessionSnapshot
1239 * @tc.type: FUNC
1240 */
1241 HWTEST_F(sceneSessionManagerProxyTest, GetSessionSnapshot, Function | SmallTest | Level2)
1242 {
1243 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1244 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1245 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1246
1247 std::string deviceId;
1248 int32_t persistentId = 0;
1249 SessionSnapshot snapshot;
1250 bool isLowResolution = true;
1251 WSError res = sceneSessionManagerProxy->GetSessionSnapshot(deviceId, persistentId, snapshot, isLowResolution);
1252 ASSERT_EQ(WSError::WS_OK, res);
1253 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1254 res = sceneSessionManagerProxy->GetSessionSnapshot(deviceId, persistentId, snapshot, isLowResolution);
1255 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1256 }
1257
1258 /**
1259 * @tc.name: SetSessionContinueState
1260 * @tc.desc: SetSessionContinueState
1261 * @tc.type: FUNC
1262 */
1263 HWTEST_F(sceneSessionManagerProxyTest, SetSessionContinueState, Function | SmallTest | Level2)
1264 {
1265 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1266 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1267 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1268
1269 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1270 int32_t tempcontinueState = 0;
1271 ContinueState continueState = static_cast<ContinueState>(tempcontinueState);
1272 WSError res = sceneSessionManagerProxy->SetSessionContinueState(token, continueState);
1273 ASSERT_EQ(WSError::WS_OK, res);
1274 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1275 res = sceneSessionManagerProxy->SetSessionContinueState(token, continueState);
1276 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1277 }
1278
1279 /**
1280 * @tc.name: UnlockSession
1281 * @tc.desc: UnlockSession
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(sceneSessionManagerProxyTest, UnlockSession, Function | SmallTest | Level2)
1285 {
1286 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1287 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1288 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1289
1290 int32_t sessionId = 0;
1291 WSError res = sceneSessionManagerProxy->UnlockSession(sessionId);
1292 ASSERT_EQ(WSError::WS_OK, res);
1293 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1294 res = sceneSessionManagerProxy->UnlockSession(sessionId);
1295 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1296 }
1297
1298 /**
1299 * @tc.name: MoveSessionsToForeground
1300 * @tc.desc: MoveSessionsToForeground
1301 * @tc.type: FUNC
1302 */
1303 HWTEST_F(sceneSessionManagerProxyTest, MoveSessionsToForeground, Function | SmallTest | Level2)
1304 {
1305 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1306 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1307 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1308
1309 std::vector<int32_t> sessionIds;
1310 int32_t topSessionId = 0;
1311 WSError res = sceneSessionManagerProxy->MoveSessionsToForeground(sessionIds, topSessionId);
1312 ASSERT_EQ(WSError::WS_OK, res);
1313 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1314 res = sceneSessionManagerProxy->MoveSessionsToForeground(sessionIds, topSessionId);
1315 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1316 }
1317
1318 /**
1319 * @tc.name: MoveSessionsToBackground
1320 * @tc.desc: MoveSessionsToBackground
1321 * @tc.type: FUNC
1322 */
1323 HWTEST_F(sceneSessionManagerProxyTest, MoveSessionsToBackground, Function | SmallTest | Level2)
1324 {
1325 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1326 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1327 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1328
1329 std::vector<int32_t> sessionIds;
1330 std::vector<int32_t> result;
1331 WSError res = sceneSessionManagerProxy->MoveSessionsToBackground(sessionIds, result);
1332 ASSERT_EQ(WSError::WS_OK, res);
1333 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1334 res = sceneSessionManagerProxy->MoveSessionsToBackground(sessionIds, result);
1335 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1336 }
1337
1338 /**
1339 * @tc.name: ClearAllSessions
1340 * @tc.desc: ClearAllSessions
1341 * @tc.type: FUNC
1342 */
1343 HWTEST_F(sceneSessionManagerProxyTest, ClearAllSessions, Function | SmallTest | Level2)
1344 {
1345 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1346 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1347 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1348
1349 WSError res = sceneSessionManagerProxy->ClearAllSessions();
1350 ASSERT_EQ(WSError::WS_OK, res);
1351 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1352 res = sceneSessionManagerProxy->ClearAllSessions();
1353 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1354 }
1355
1356 /**
1357 * @tc.name: UnregisterIAbilityManagerCollaborator
1358 * @tc.desc: UnregisterIAbilityManagerCollaborator
1359 * @tc.type: FUNC
1360 */
1361 HWTEST_F(sceneSessionManagerProxyTest, UnregisterIAbilityManagerCollaborator, Function | SmallTest | Level2)
1362 {
1363 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1364 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1365 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1366
1367 int32_t type = 0;
1368 WSError res = sceneSessionManagerProxy->UnregisterIAbilityManagerCollaborator(type);
1369 ASSERT_EQ(WSError::WS_OK, res);
1370 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1371 res = sceneSessionManagerProxy->UnregisterIAbilityManagerCollaborator(type);
1372 ASSERT_EQ(WSError::WS_ERROR_IPC_FAILED, res);
1373 }
1374
1375 /**
1376 * @tc.name: NotifyWatchGestureConsumeResult
1377 * @tc.desc: NotifyWatchGestureConsumeResult
1378 * @tc.type: FUNC
1379 */
1380 HWTEST_F(sceneSessionManagerProxyTest, NotifyWatchGestureConsumeResult, Function | SmallTest | Level2)
1381 {
1382 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1383 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1384 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1385
1386 int32_t keyCode = 0;
1387 bool isConsumed = true;
1388 WMError res = sceneSessionManagerProxy->NotifyWatchGestureConsumeResult(keyCode, isConsumed);
1389 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1390 }
1391
1392 /**
1393 * @tc.name: NotifyWatchFocusActiveChange
1394 * @tc.desc: NotifyWatchFocusActiveChange
1395 * @tc.type: FUNC
1396 */
1397 HWTEST_F(sceneSessionManagerProxyTest, NotifyWatchFocusActiveChange, Function | SmallTest | Level2)
1398 {
1399 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1400 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1401 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1402
1403 bool isActive = true;
1404 WMError res = sceneSessionManagerProxy->NotifyWatchFocusActiveChange(isActive);
1405 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1406 }
1407
1408 /**
1409 * @tc.name: GetParentMainWindowId
1410 * @tc.desc: GetParentMainWindowId
1411 * @tc.type: FUNC
1412 */
1413 HWTEST_F(sceneSessionManagerProxyTest, GetParentMainWindowId, Function | SmallTest | Level2)
1414 {
1415 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1416 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1417 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1418
1419 int32_t windowId = 0;
1420 int32_t mainWindowId = 0;
1421 WMError res = sceneSessionManagerProxy->GetParentMainWindowId(windowId, mainWindowId);
1422 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1423 }
1424
1425 /**
1426 * @tc.name: ListWindowInfo
1427 * @tc.desc: ListWindowInfo
1428 * @tc.type: FUNC
1429 */
1430 HWTEST_F(sceneSessionManagerProxyTest, ListWindowInfo, Function | SmallTest | Level2)
1431 {
1432 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1433 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1434 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1435
1436 WindowInfoOption windowInfoOption;
1437 std::vector<sptr<WindowInfo>> infos;
1438 WMError res = sceneSessionManagerProxy->ListWindowInfo(windowInfoOption, infos);
1439 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1440 }
1441
1442 /**
1443 * @tc.name: GetWindowModeType
1444 * @tc.desc: GetWindowModeType
1445 * @tc.type: FUNC
1446 */
1447 HWTEST_F(sceneSessionManagerProxyTest, GetWindowModeType, Function | SmallTest | Level2)
1448 {
1449 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1450 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1451 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1452
1453 WindowModeType windowModeType;
1454 WMError res = sceneSessionManagerProxy->GetWindowModeType(windowModeType);
1455 ASSERT_EQ(WMError::WM_OK, res);
1456 sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(nullptr);
1457 res = sceneSessionManagerProxy->GetWindowModeType(windowModeType);
1458 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1459 }
1460
1461 /**
1462 * @tc.name: SetParentWindow
1463 * @tc.desc: SetParentWindow
1464 * @tc.type: FUNC
1465 */
1466 HWTEST_F(sceneSessionManagerProxyTest, SetParentWindow, Function | SmallTest | Level2)
1467 {
1468 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1469 sptr<SceneSessionManagerProxy> sceneSessionManagerProxy =
1470 sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1471
1472 int32_t subWindowId = 1;
1473 int32_t newParentWindowId = 2;
1474 WMError res = sceneSessionManagerProxy->SetParentWindow(subWindowId, newParentWindowId);
1475 ASSERT_EQ(WMError::WM_ERROR_IPC_FAILED, res);
1476 }
1477
1478 /**
1479 * @tc.name: MinimizeByWindowId
1480 * @tc.desc: MinimizeByWindowId
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(sceneSessionManagerProxyTest, MinimizeByWindowId, Function | SmallTest | Level2)
1484 {
1485 sptr<IRemoteObject> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
1486 auto sceneSessionManagerProxy = sptr<SceneSessionManagerProxy>::MakeSptr(iRemoteObjectMocker);
1487 std::vector<int32_t> windowIds;
1488 WMError res = sceneSessionManagerProxy->MinimizeByWindowId(windowIds);
1489 ASSERT_EQ(WMError::WM_OK, res);
1490 }
1491 } // namespace
1492 }
1493 }
1494