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 <message_option.h>
18 #include <message_parcel.h>
19
20 #include "iremote_object_mocker.h"
21 #include "session_manager/include/scene_session_manager.h"
22 #include "session_manager/include/zidl/scene_session_manager_interface.h"
23 #include "session/container/include/window_event_channel.h"
24 #include "window_manager_agent.h"
25 #include "zidl/scene_session_manager_stub.h"
26 #include "zidl/window_manager_agent_interface.h"
27 #include "pattern_detach_callback.h"
28 #include "test/mock/mock_session_stage.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32 namespace OHOS {
33 namespace Rosen {
34 class SceneSessionManagerStubTest : public testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40 sptr<SceneSessionManagerStub> stub_;
41 private:
42 static constexpr uint32_t WAIT_SYNC_IN_NS = 200000;
43 };
44
SetUpTestCase()45 void SceneSessionManagerStubTest::SetUpTestCase()
46 {
47 }
48
TearDownTestCase()49 void SceneSessionManagerStubTest::TearDownTestCase()
50 {
51 }
52
SetUp()53 void SceneSessionManagerStubTest::SetUp()
54 {
55 stub_ = sptr<SceneSessionManager>::MakeSptr();
56 }
57
TearDown()58 void SceneSessionManagerStubTest::TearDown()
59 {
60 usleep(WAIT_SYNC_IN_NS);
61 }
62
63 namespace {
64 /**
65 * @tc.name: TransIdCreateAndConnectSpecificSession
66 * @tc.desc: test TransIdCreateAndConnectSpecificSession
67 * @tc.type: FUNC
68 */
69 HWTEST_F(SceneSessionManagerStubTest, TransIdCreateAndConnectSpecificSession, Function | SmallTest | Level2)
70 {
71 MessageParcel data;
72 MessageParcel reply;
73 MessageOption option;
74
75 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
76 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
77 ASSERT_NE(nullptr, sessionStage);
78 data.WriteRemoteObject(sessionStage->AsObject());
79 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(sessionStage);
80 ASSERT_NE(nullptr, eventChannel);
81 data.WriteRemoteObject(eventChannel->AsObject());
82 struct RSSurfaceNodeConfig surfaceNodeConfig;
83 surfaceNodeConfig.SurfaceNodeName = "SurfaceNode";
84 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
85 ASSERT_NE(nullptr, surfaceNode);
86 surfaceNode->Marshalling(data);
87 data.WriteBool(false);
88 stub_->HandleCreateAndConnectSpecificSession(data, reply);
89
90 data.WriteRemoteObject(sessionStage->AsObject());
91 data.WriteRemoteObject(eventChannel->AsObject());
92 surfaceNode->Marshalling(data);
93 data.WriteBool(true);
94 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
95 ASSERT_NE(nullptr, property);
96 property->SetTokenState(true);
97 data.WriteStrongParcelable(property);
98 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
99 ASSERT_NE(nullptr, windowManagerAgent);
100 data.WriteRemoteObject(windowManagerAgent->AsObject());
101
102 uint32_t code = static_cast<uint32_t>(
103 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_CREATE_AND_CONNECT_SPECIFIC_SESSION);
104
105 int res = stub_->OnRemoteRequest(code, data, reply, option);
106 EXPECT_EQ(res, ERR_TRANSACTION_FAILED);
107 }
108
109 /**
110 * @tc.name: TransIdRecoverAndConnectSpecificSession
111 * @tc.desc: test TransIdRecoverAndConnectSpecificSession
112 * @tc.type: FUNC
113 */
114 HWTEST_F(SceneSessionManagerStubTest, TransIdRecoverAndConnectSpecificSession, Function | SmallTest | Level2)
115 {
116 MessageParcel data;
117 MessageParcel reply;
118 MessageOption option;
119
120 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
121 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
122 ASSERT_NE(nullptr, sessionStage);
123 data.WriteRemoteObject(sessionStage->AsObject());
124 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(sessionStage);
125 ASSERT_NE(nullptr, eventChannel);
126 data.WriteRemoteObject(eventChannel->AsObject());
127 struct RSSurfaceNodeConfig surfaceNodeConfig;
128 surfaceNodeConfig.SurfaceNodeName = "SurfaceNode";
129 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
130 ASSERT_NE(nullptr, surfaceNode);
131 surfaceNode->Marshalling(data);
132 data.WriteBool(false);
133 stub_->HandleRecoverAndConnectSpecificSession(data, reply);
134
135 data.WriteRemoteObject(sessionStage->AsObject());
136 data.WriteRemoteObject(eventChannel->AsObject());
137 surfaceNode->Marshalling(data);
138 data.WriteBool(true);
139 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
140 ASSERT_NE(nullptr, property);
141 property->SetTokenState(true);
142 data.WriteStrongParcelable(property);
143 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
144 ASSERT_NE(nullptr, windowManagerAgent);
145 data.WriteRemoteObject(windowManagerAgent->AsObject());
146
147 uint32_t code = static_cast<uint32_t>(
148 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_RECOVER_AND_CONNECT_SPECIFIC_SESSION);
149
150 int res = stub_->OnRemoteRequest(code, data, reply, option);
151 EXPECT_EQ(res, ERR_TRANSACTION_FAILED);
152 }
153
154 /**
155 * @tc.name: TransIdRecoverAndReconnectSceneSession
156 * @tc.desc: test TransIdRecoverAndReconnectSceneSession
157 * @tc.type: FUNC
158 */
159 HWTEST_F(SceneSessionManagerStubTest, TransIdRecoverAndReconnectSceneSession, Function | SmallTest | Level2)
160 {
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option;
164
165 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
166 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
167 ASSERT_NE(nullptr, sessionStage);
168 data.WriteRemoteObject(sessionStage->AsObject());
169 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(sessionStage);
170 ASSERT_NE(nullptr, eventChannel);
171 data.WriteRemoteObject(eventChannel->AsObject());
172 struct RSSurfaceNodeConfig surfaceNodeConfig;
173 surfaceNodeConfig.SurfaceNodeName = "SurfaceNode";
174 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
175 ASSERT_NE(nullptr, surfaceNode);
176 surfaceNode->Marshalling(data);
177 data.WriteBool(false);
178 stub_->HandleRecoverAndConnectSpecificSession(data, reply);
179
180 data.WriteRemoteObject(sessionStage->AsObject());
181 data.WriteRemoteObject(eventChannel->AsObject());
182 surfaceNode->Marshalling(data);
183 data.WriteBool(true);
184 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
185 ASSERT_NE(nullptr, property);
186 property->SetTokenState(true);
187 data.WriteStrongParcelable(property);
188 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
189 ASSERT_NE(nullptr, windowManagerAgent);
190 data.WriteRemoteObject(windowManagerAgent->AsObject());
191
192 uint32_t code = static_cast<uint32_t>(
193 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_RECOVER_AND_RECONNECT_SCENE_SESSION);
194
195 int res = stub_->OnRemoteRequest(code, data, reply, option);
196 EXPECT_EQ(res, ERR_TRANSACTION_FAILED);
197 }
198
199 /**
200 * @tc.name: TransIdDestroyAndDisconnectSpecificSession
201 * @tc.desc: test TransIdDestroyAndDisconnectSpecificSession
202 * @tc.type: FUNC
203 */
204 HWTEST_F(SceneSessionManagerStubTest, TransIdDestroyAndDisconnectSpecificSession, Function | SmallTest | Level2)
205 {
206 MessageParcel data;
207 MessageParcel reply;
208 MessageOption option;
209
210 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
211 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
212 data.WriteUint32(static_cast<uint32_t>(type));
213
214 uint32_t code = static_cast<uint32_t>(
215 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_DESTROY_AND_DISCONNECT_SPECIFIC_SESSION);
216
217 int res = stub_->OnRemoteRequest(code, data, reply, option);
218 EXPECT_EQ(res, ERR_NONE);
219 }
220
221 /**
222 * @tc.name: TransIdDestroyAndDisconnectSpecificSessionWithDetachCallback
223 * @tc.desc: test TransIdDestroyAndDisconnectSpecificSessionWithDetachCallback
224 * @tc.type: FUNC
225 */
226 HWTEST_F(SceneSessionManagerStubTest, TransIdDestroyAndDisconnectSpecificSessionWithDetachCallback,
227 Function | SmallTest | Level2)
228 {
229 MessageParcel data;
230 MessageParcel reply;
231 MessageOption option;
232
233 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
234 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
235 data.WriteUint32(static_cast<uint32_t>(type));
236 sptr<PatternDetachCallback> callback = sptr<PatternDetachCallback>::MakeSptr();
237 ASSERT_NE(nullptr, callback);
238 data.WriteRemoteObject(callback->AsObject());
239
240 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::
241 TRANS_ID_DESTROY_AND_DISCONNECT_SPECIFIC_SESSION_WITH_DETACH_CALLBACK);
242
243 int res = stub_->OnRemoteRequest(code, data, reply, option);
244 EXPECT_EQ(res, ERR_NONE);
245 }
246
247 /**
248 * @tc.name: TransIdRequestFocus
249 * @tc.desc: test TransIdRequestFocus
250 * @tc.type: FUNC
251 */
252 HWTEST_F(SceneSessionManagerStubTest, TransIdRequestFocus, Function | SmallTest | Level2)
253 {
254 MessageParcel data;
255 MessageParcel reply;
256 MessageOption option;
257
258 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
259 int32_t persistentId = 65535;
260 data.WriteInt32(persistentId);
261 bool isFocused = true;
262 data.WriteBool(isFocused);
263
264 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_REQUEST_FOCUS);
265
266 int res = stub_->OnRemoteRequest(code, data, reply, option);
267 EXPECT_EQ(res, ERR_NONE);
268 }
269
270 /**
271 * @tc.name: TransIdGetFocusSessionInfo
272 * @tc.desc: test TransIdGetFocusSessionInfo
273 * @tc.type: FUNC
274 */
275 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionInfo, Function | SmallTest | Level2)
276 {
277 MessageParcel data;
278 MessageParcel reply;
279 MessageOption option;
280
281 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
282 data.WriteUint64(0);
283 uint32_t code =
284 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_INFO);
285
286 int res = stub_->OnRemoteRequest(code, data, reply, option);
287 EXPECT_EQ(res, ERR_NONE);
288 }
289
290 /**
291 * @tc.name: TransIdGetFocusSessionInfo1
292 * @tc.desc: test TransIdGetFocusSessionInfo
293 * @tc.type: FUNC
294 */
295 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionInfo1, Function | SmallTest | Level2)
296 {
297 MessageParcel data;
298 MessageParcel reply;
299 MessageOption option;
300
301 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
302 uint32_t code =
303 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_INFO);
304
305 int res = stub_->OnRemoteRequest(code, data, reply, option);
306 EXPECT_EQ(res, ERR_INVALID_DATA);
307 }
308
309 /**
310 * @tc.name: TransIdSetSessionLabel
311 * @tc.desc: test TransIdSetSessionLabel
312 * @tc.type: FUNC
313 */
314 HWTEST_F(SceneSessionManagerStubTest, TransIdSetSessionLabel, Function | SmallTest | Level2)
315 {
316 MessageParcel data;
317 MessageParcel reply;
318 MessageOption option;
319
320 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
321 data.WriteString(static_cast<string>("123"));
322 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
323 ASSERT_NE(nullptr, windowManagerAgent);
324 data.WriteRemoteObject(windowManagerAgent->AsObject());
325
326 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_SET_SESSION_LABEL);
327
328 int res = stub_->OnRemoteRequest(code, data, reply, option);
329 EXPECT_EQ(res, ERR_NONE);
330 }
331
332 /**
333 * @tc.name: TransIdSetSessionIcon
334 * @tc.desc: test TransIdSetSessionIcon
335 * @tc.type: FUNC
336 */
337 HWTEST_F(SceneSessionManagerStubTest, TransIdSetSessionIcon, Function | SmallTest | Level2)
338 {
339 MessageParcel data;
340 MessageParcel reply;
341 MessageOption option;
342
343 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
344 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
345 ASSERT_NE(nullptr, windowManagerAgent);
346 data.WriteRemoteObject(windowManagerAgent->AsObject());
347
348 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_SET_SESSION_ICON);
349
350 int res = stub_->OnRemoteRequest(code, data, reply, option);
351 EXPECT_EQ(res, ERR_INVALID_DATA);
352 }
353
354 /**
355 * @tc.name: TransIdIsValidSessionIds
356 * @tc.desc: test TransIdIsValidSessionIds
357 * @tc.type: FUNC
358 */
359 HWTEST_F(SceneSessionManagerStubTest, TransIdIsValidSessionIds, Function | SmallTest | Level2)
360 {
361 MessageParcel data;
362 MessageParcel reply;
363 MessageOption option;
364
365 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
366 std::vector<int32_t> points{0, 0};
367 data.WriteInt32Vector(points);
368
369 uint32_t code =
370 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_IS_VALID_SESSION_IDS);
371
372 int res = stub_->OnRemoteRequest(code, data, reply, option);
373 EXPECT_EQ(res, ERR_NONE);
374 }
375
376 /**
377 * @tc.name: TransIdPendingSessionToForeground
378 * @tc.desc: test TransIdPendingSessionToForeground
379 * @tc.type: FUNC
380 */
381 HWTEST_F(SceneSessionManagerStubTest, TransIdPendingSessionToForeground, Function | SmallTest | Level2)
382 {
383 MessageParcel data;
384 MessageParcel reply;
385 MessageOption option;
386
387 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
388 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
389 ASSERT_NE(nullptr, windowManagerAgent);
390 data.WriteRemoteObject(windowManagerAgent->AsObject());
391
392 uint32_t code =
393 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_PENDING_SESSION_TO_FOREGROUND);
394
395 int res = stub_->OnRemoteRequest(code, data, reply, option);
396 EXPECT_EQ(res, ERR_NONE);
397 }
398
399 /**
400 * @tc.name: TransIdPendingSessionToBackgroundForDelegator
401 * @tc.desc: test TransIdPendingSessionToBackgroundForDelegator
402 * @tc.type: FUNC
403 */
404 HWTEST_F(SceneSessionManagerStubTest, TransIdPendingSessionToBackgroundForDelegator, Function | SmallTest | Level2)
405 {
406 MessageParcel data;
407 MessageParcel reply;
408 MessageOption option;
409
410 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
411 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
412 ASSERT_NE(nullptr, windowManagerAgent);
413 data.WriteRemoteObject(windowManagerAgent->AsObject());
414
415 data.WriteString("TransIdPendingSessionToBackgroundForDelegator UT Testing");
416 uint32_t code = static_cast<uint32_t>(
417 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_PENDING_SESSION_TO_BACKGROUND_FOR_DELEGATOR);
418
419 int res = stub_->OnRemoteRequest(code, data, reply, option);
420 EXPECT_EQ(res, ERR_NONE);
421 }
422
423 /**
424 * @tc.name: TransIdGetFocusSessionToken
425 * @tc.desc: test TransIdGetFocusSessionToken
426 * @tc.type: FUNC
427 */
428 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionToken, Function | SmallTest | Level2)
429 {
430 MessageParcel data;
431 MessageParcel reply;
432 MessageOption option;
433
434 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
435 data.WriteUint64(0);
436 uint32_t code =
437 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_TOKEN);
438
439 int res = stub_->OnRemoteRequest(code, data, reply, option);
440 EXPECT_EQ(res, ERR_NONE);
441 }
442
443 /**
444 * @tc.name: TransIdGetFocusSessionToken1
445 * @tc.desc: test TransIdGetFocusSessionToken
446 * @tc.type: FUNC
447 */
448 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionToken1, Function | SmallTest | Level2)
449 {
450 MessageParcel data;
451 MessageParcel reply;
452 MessageOption option;
453
454 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
455 uint32_t code =
456 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_TOKEN);
457
458 int res = stub_->OnRemoteRequest(code, data, reply, option);
459 EXPECT_EQ(res, ERR_INVALID_DATA);
460 }
461
462 /**
463 * @tc.name: TransIdGetFocusSessionElement
464 * @tc.desc: test TransIdGetFocusSessionElement
465 * @tc.type: FUNC
466 */
467 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionElement, Function | SmallTest | Level2)
468 {
469 MessageParcel data;
470 MessageParcel reply;
471 MessageOption option;
472
473 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
474 data.WriteUint64(0);
475 uint32_t code =
476 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_ELEMENT);
477
478 int res = stub_->OnRemoteRequest(code, data, reply, option);
479 EXPECT_EQ(res, ERR_NONE);
480 }
481
482 /**
483 * @tc.name: TransIdGetFocusSessionElement1
484 * @tc.desc: test TransIdGetFocusSessionElement
485 * @tc.type: FUNC
486 */
487 HWTEST_F(SceneSessionManagerStubTest, TransIdGetFocusSessionElement1, Function | SmallTest | Level2)
488 {
489 MessageParcel data;
490 MessageParcel reply;
491 MessageOption option;
492
493 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
494 uint32_t code =
495 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_FOCUS_SESSION_ELEMENT);
496
497 int res = stub_->OnRemoteRequest(code, data, reply, option);
498 EXPECT_EQ(res, ERR_INVALID_DATA);
499 }
500
501 /**
502 * @tc.name: TransIdCheckWindowId
503 * @tc.desc: test TransIdCheckWindowId
504 * @tc.type: FUNC
505 */
506 HWTEST_F(SceneSessionManagerStubTest, TransIdCheckWindowId, Function | SmallTest | Level2)
507 {
508 MessageParcel data;
509 MessageParcel reply;
510 MessageOption option;
511
512 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
513 int32_t windowId = 1000;
514 SessionInfo info;
515 info.abilityName_ = "HandleCheckWindowId";
516 info.bundleName_ = "HandleCheckWindowId1";
517 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
518 ASSERT_NE(nullptr, sceneSession);
519 SceneSessionManager::GetInstance().sceneSessionMap_[windowId] = sceneSession;
520 data.WriteInt32(windowId);
521
522 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_CHECK_WINDOW_ID);
523
524 int res = stub_->OnRemoteRequest(code, data, reply, option);
525 EXPECT_EQ(res, ERR_INVALID_DATA);
526 }
527
528 /**
529 * @tc.name: TransIdSetGestureNavigationEnabled
530 * @tc.desc: test TransIdSetGestureNavigationEnabled
531 * @tc.type: FUNC
532 */
533 HWTEST_F(SceneSessionManagerStubTest, TransIdSetGestureNavigationEnabled, Function | SmallTest | Level2)
534 {
535 MessageParcel data;
536 MessageParcel reply;
537 MessageOption option;
538
539 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
540 data.WriteBool(false);
541
542 uint32_t code = static_cast<uint32_t>(
543 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_SET_GESTURE_NAVIGATION_ENABLED);
544
545 int res = stub_->OnRemoteRequest(code, data, reply, option);
546 EXPECT_EQ(res, ERR_NONE);
547 }
548
549 /**
550 * @tc.name: TransIdGetWindowInfo
551 * @tc.desc: test TransIdGetWindowInfo
552 * @tc.type: FUNC
553 */
554 HWTEST_F(SceneSessionManagerStubTest, TransIdGetWindowInfo, Function | SmallTest | Level2)
555 {
556 MessageParcel data;
557 MessageParcel reply;
558 MessageOption option;
559
560 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
561 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
562 data.WriteUint32(static_cast<uint32_t>(type));
563
564 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_WINDOW_INFO);
565
566 int res = stub_->OnRemoteRequest(code, data, reply, option);
567 EXPECT_EQ(res, ERR_NONE);
568 }
569
570 /**
571 * @tc.name: TransIdGetUnreliableWindowInfo
572 * @tc.desc: test TransIdGetUnreliableWindowInfo
573 * @tc.type: FUNC
574 */
575 HWTEST_F(SceneSessionManagerStubTest, TransIdGetUnreliableWindowInfo, Function | SmallTest | Level2)
576 {
577 MessageParcel data;
578 MessageParcel reply;
579 MessageOption option;
580
581 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
582 int32_t windowId = 0;
583 data.WriteInt32(windowId);
584
585 uint32_t code =
586 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_UNRELIABLE_WINDOW_INFO);
587
588 int res = stub_->OnRemoteRequest(code, data, reply, option);
589 EXPECT_EQ(res, ERR_NONE);
590 }
591
592 /**
593 * @tc.name: TransIdRegisterSessionListener
594 * @tc.desc: test TransIdRegisterSessionListener
595 * @tc.type: FUNC
596 */
597 HWTEST_F(SceneSessionManagerStubTest, TransIdRegisterSessionListener, Function | SmallTest | Level2)
598 {
599 MessageParcel data;
600 MessageParcel reply;
601 MessageOption option;
602
603 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
604 sptr<PatternDetachCallback> callback = sptr<PatternDetachCallback>::MakeSptr();
605 ASSERT_NE(nullptr, callback);
606 data.WriteRemoteObject(callback->AsObject());
607
608 uint32_t code =
609 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_REGISTER_SESSION_LISTENER);
610
611 int res = stub_->OnRemoteRequest(code, data, reply, option);
612 EXPECT_EQ(res, ERR_NONE);
613 }
614
615 /**
616 * @tc.name: TransIdUnRegisterSessionListener
617 * @tc.desc: test TransIdUnRegisterSessionListener
618 * @tc.type: FUNC
619 */
620 HWTEST_F(SceneSessionManagerStubTest, TransIdUnRegisterSessionListener, Function | SmallTest | Level2)
621 {
622 MessageParcel data;
623 MessageParcel reply;
624 MessageOption option;
625
626 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
627 sptr<PatternDetachCallback> callback = sptr<PatternDetachCallback>::MakeSptr();
628 ASSERT_NE(nullptr, callback);
629 data.WriteRemoteObject(callback->AsObject());
630
631 uint32_t code =
632 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_UNREGISTER_SESSION_LISTENER);
633
634 int res = stub_->OnRemoteRequest(code, data, reply, option);
635 EXPECT_EQ(res, ERR_NONE);
636 }
637
638 /**
639 * @tc.name: TransIdGetMissionInfos
640 * @tc.desc: test TransIdGetMissionInfos
641 * @tc.type: FUNC
642 */
643 HWTEST_F(SceneSessionManagerStubTest, TransIdGetMissionInfos, Function | SmallTest | Level2)
644 {
645 MessageParcel data;
646 MessageParcel reply;
647 MessageOption option;
648
649 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
650 data.WriteString16(static_cast<std::u16string>(u"123"));
651 int32_t numMax = 100;
652 data.WriteInt32(numMax);
653
654 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_MISSION_INFOS);
655
656 int res = stub_->OnRemoteRequest(code, data, reply, option);
657 EXPECT_EQ(res, ERR_NONE);
658 }
659
660 /**
661 * @tc.name: TransIdGetSessionInfo
662 * @tc.desc: test TransIdGetSessionInfo
663 * @tc.type: FUNC
664 */
665 HWTEST_F(SceneSessionManagerStubTest, TransIdGetSessionInfo, Function | SmallTest | Level2)
666 {
667 MessageParcel data;
668 MessageParcel reply;
669 MessageOption option;
670
671 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
672 data.WriteString16(static_cast<std::u16string>(u"123"));
673 int32_t persistentId = 65535;
674 data.WriteInt32(persistentId);
675
676 uint32_t code =
677 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_MISSION_INFO_BY_ID);
678
679 int res = stub_->OnRemoteRequest(code, data, reply, option);
680 EXPECT_EQ(res, ERR_NONE);
681 }
682
683 /**
684 * @tc.name: TransIdGetSessionInfoByContinueSessionId
685 * @tc.desc: test TransIdGetSessionInfoByContinueSessionId
686 * @tc.type: FUNC
687 */
688 HWTEST_F(SceneSessionManagerStubTest, TransIdGetSessionInfoByContinueSessionId, Function | SmallTest | Level2)
689 {
690 MessageParcel data;
691 MessageParcel reply;
692 MessageOption option;
693
694 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
695 data.WriteString("test_01");
696
697 uint32_t code = static_cast<uint32_t>(
698 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_SESSION_INFO_BY_CONTINUE_SESSION_ID);
699
700 int res = stub_->OnRemoteRequest(code, data, reply, option);
701 EXPECT_EQ(res, ERR_NONE);
702 }
703
704 /**
705 * @tc.name: TransIdDumpSessionAll
706 * @tc.desc: test TransIdDumpSessionAll
707 * @tc.type: FUNC
708 */
709 HWTEST_F(SceneSessionManagerStubTest, TransIdDumpSessionAll, Function | SmallTest | Level2)
710 {
711 MessageParcel data;
712 MessageParcel reply;
713 MessageOption option;
714
715 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
716
717 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_DUMP_SESSION_ALL);
718
719 int res = stub_->OnRemoteRequest(code, data, reply, option);
720 EXPECT_EQ(res, ERR_NONE);
721 }
722
723 /**
724 * @tc.name: TransIdDumpSessionWithId
725 * @tc.desc: test TransIdDumpSessionWithId
726 * @tc.type: FUNC
727 */
728 HWTEST_F(SceneSessionManagerStubTest, TransIdDumpSessionWithId, Function | SmallTest | Level2)
729 {
730 MessageParcel data;
731 MessageParcel reply;
732 MessageOption option;
733
734 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
735 int32_t x = 1;
736 data.WriteInt32(x);
737
738 uint32_t code =
739 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_DUMP_SESSION_WITH_ID);
740
741 int res = stub_->OnRemoteRequest(code, data, reply, option);
742 EXPECT_EQ(res, ERR_NONE);
743 }
744
745 /**
746 * @tc.name: TransIdTerminateSessionNew
747 * @tc.desc: test TransIdTerminateSessionNew
748 * @tc.type: FUNC
749 */
750 HWTEST_F(SceneSessionManagerStubTest, TransIdTerminateSessionNew, Function | SmallTest | Level2)
751 {
752 MessageParcel data;
753 MessageParcel reply;
754 MessageOption option;
755
756 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
757 sptr<AAFwk::SessionInfo> abilitySessionInfo = nullptr;
758 data.WriteParcelable(abilitySessionInfo);
759 data.WriteBool(true);
760 data.WriteBool(true);
761
762 uint32_t code =
763 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_TERMINATE_SESSION_NEW);
764
765 int res = stub_->OnRemoteRequest(code, data, reply, option);
766 EXPECT_EQ(res, ERR_INVALID_DATA);
767 }
768
769 /**
770 * @tc.name: TransIdUpdateSessionAvoidAreaListener
771 * @tc.desc: test TransIdUpdateSessionAvoidAreaListener
772 * @tc.type: FUNC
773 */
774 HWTEST_F(SceneSessionManagerStubTest, TransIdUpdateSessionAvoidAreaListener, Function | SmallTest | Level2)
775 {
776 MessageParcel data;
777 MessageParcel reply;
778 MessageOption option;
779
780 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
781 int32_t persistentId = 65535;
782 data.WriteInt32(persistentId);
783 bool haveAvoidAreaListener = false;
784 data.WriteBool(haveAvoidAreaListener);
785
786 uint32_t code =
787 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_UPDATE_AVOIDAREA_LISTENER);
788
789 int res = stub_->OnRemoteRequest(code, data, reply, option);
790 EXPECT_EQ(res, ERR_NONE);
791 }
792
793 /**
794 * @tc.name: TransIdGetSessionDump
795 * @tc.desc: test TransIdGetSessionDump
796 * @tc.type: FUNC
797 */
798 HWTEST_F(SceneSessionManagerStubTest, TransIdGetSessionDump, Function | SmallTest | Level2)
799 {
800 MessageParcel data;
801 MessageParcel reply;
802 MessageOption option;
803
804 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
805 std::vector<std::string> params = {"-a"};
806 data.WriteStringVector(params);
807 stub_->HandleGetSessionDump(data, reply);
808
809 params.clear();
810 params.push_back("-w");
811 params.push_back("23456");
812 data.WriteStringVector(params);
813 stub_->HandleGetSessionDump(data, reply);
814
815 params.clear();
816 data.WriteStringVector(params);
817
818 uint32_t code =
819 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_SESSION_DUMP_INFO);
820
821 int res = stub_->OnRemoteRequest(code, data, reply, option);
822 EXPECT_EQ(res, ERR_TRANSACTION_FAILED);
823 }
824
825 /**
826 * @tc.name: TransIdGetSessionSnapshot
827 * @tc.desc: test TransIdGetSessionSnapshot
828 * @tc.type: FUNC
829 */
830 HWTEST_F(SceneSessionManagerStubTest, TransIdGetSessionSnapshot, Function | SmallTest | Level2)
831 {
832 MessageParcel data;
833 MessageParcel reply;
834 MessageOption option;
835
836 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
837 data.WriteString16(static_cast<std::u16string>(u"123"));
838 int32_t persistentId = 65535;
839 data.WriteInt32(persistentId);
840 bool isLowResolution = false;
841 data.WriteBool(isLowResolution);
842
843 uint32_t code =
844 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_SESSION_SNAPSHOT);
845
846 int res = stub_->OnRemoteRequest(code, data, reply, option);
847 EXPECT_EQ(res, ERR_NONE);
848 }
849
850 /**
851 * @tc.name: TransIdGetSessionSnapshotById
852 * @tc.desc: test TransIdGetSessionSnapshotById
853 * @tc.type: FUNC
854 */
855 HWTEST_F(SceneSessionManagerStubTest, TransIdGetSessionSnapshotById, Function | SmallTest | Level2)
856 {
857 MessageParcel data;
858 MessageParcel reply;
859 MessageOption option;
860
861 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
862 int32_t persistentId = -1;
863 data.WriteInt32(persistentId);
864
865 uint32_t code =
866 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_SESSION_SNAPSHOT_BY_ID);
867
868 int res = stub_->OnRemoteRequest(code, data, reply, option);
869 EXPECT_EQ(res, ERR_NONE);
870 }
871
872 /**
873 * @tc.name: TransIdGetUIContentRemoteObj
874 * @tc.desc: test TransIdGetUIContentRemoteObj
875 * @tc.type: FUNC
876 */
877 HWTEST_F(SceneSessionManagerStubTest, TransIdGetUIContentRemoteObj, Function | SmallTest | Level2)
878 {
879 MessageParcel data;
880 MessageParcel reply;
881 MessageOption option;
882
883 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
884 data.WriteInt32(1);
885
886 uint32_t code =
887 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_GET_UI_CONTENT_REMOTE_OBJ);
888
889 int res = stub_->OnRemoteRequest(code, data, reply, option);
890 EXPECT_EQ(res, ERR_NONE);
891 }
892
893 /**
894 * @tc.name: TransIdBindDialogTarget
895 * @tc.desc: test TransIdBindDialogTarget
896 * @tc.type: FUNC
897 */
898 HWTEST_F(SceneSessionManagerStubTest, TransIdBindDialogTarget, Function | SmallTest | Level2)
899 {
900 MessageParcel data;
901 MessageParcel reply;
902 MessageOption option;
903
904 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
905 uint64_t persistentId = 65535;
906 data.WriteUint64(persistentId);
907 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
908 ASSERT_NE(nullptr, windowManagerAgent);
909 data.WriteRemoteObject(windowManagerAgent->AsObject());
910
911 uint32_t code =
912 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_BIND_DIALOG_TARGET);
913
914 int res = stub_->OnRemoteRequest(code, data, reply, option);
915 EXPECT_EQ(res, ERR_NONE);
916 }
917
918 /**
919 * @tc.name: TransIdNotifyDumpInfoResult
920 * @tc.desc: test TransIdNotifyDumpInfoResult
921 * @tc.type: FUNC
922 */
923 HWTEST_F(SceneSessionManagerStubTest, TransIdNotifyDumpInfoResult, Function | SmallTest | Level2)
924 {
925 MessageParcel data;
926 MessageParcel reply;
927 MessageOption option;
928
929 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
930 auto res = stub_->HandleNotifyDumpInfoResult(data, reply);
931 EXPECT_EQ(res, ERR_INVALID_DATA);
932
933 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
934 uint32_t vectorSize = 90;
935 data.WriteUint32(vectorSize);
936 res = stub_->HandleNotifyDumpInfoResult(data, reply);
937 EXPECT_EQ(res, ERR_NONE);
938 }
939
940 /**
941 * @tc.name: TransIdSetSessionContinueState
942 * @tc.desc: test TransIdSetSessionContinueState
943 * @tc.type: FUNC
944 */
945 HWTEST_F(SceneSessionManagerStubTest, TransIdSetSessionContinueState, Function | SmallTest | Level2)
946 {
947 MessageParcel data;
948 MessageParcel reply;
949 MessageOption option;
950
951 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
952 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
953 ASSERT_NE(nullptr, windowManagerAgent);
954 data.WriteRemoteObject(windowManagerAgent->AsObject());
955 int32_t x = 1;
956 data.WriteInt32(x);
957
958 uint32_t code =
959 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_SET_SESSION_CONTINUE_STATE);
960
961 int res = stub_->OnRemoteRequest(code, data, reply, option);
962 EXPECT_EQ(res, ERR_NONE);
963 }
964
965 /**
966 * @tc.name: TransIdClearSession
967 * @tc.desc: test TransIdClearSession
968 * @tc.type: FUNC
969 */
970 HWTEST_F(SceneSessionManagerStubTest, TransIdClearSession, Function | SmallTest | Level2)
971 {
972 MessageParcel data;
973 MessageParcel reply;
974 MessageOption option;
975
976 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
977 int32_t x = 1;
978 data.WriteInt32(x);
979
980 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_CLEAR_SESSION);
981
982 int res = stub_->OnRemoteRequest(code, data, reply, option);
983 EXPECT_EQ(res, ERR_NONE);
984 }
985
986 /**
987 * @tc.name: TransIdClearAllSessions
988 * @tc.desc: test TransIdClearAllSessions
989 * @tc.type: FUNC
990 */
991 HWTEST_F(SceneSessionManagerStubTest, TransIdClearAllSessions, Function | SmallTest | Level2)
992 {
993 MessageParcel data;
994 MessageParcel reply;
995 MessageOption option;
996
997 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
998
999 uint32_t code =
1000 static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_CLEAR_ALL_SESSIONS);
1001
1002 int res = stub_->OnRemoteRequest(code, data, reply, option);
1003 EXPECT_EQ(res, ERR_NONE);
1004 }
1005
1006 /**
1007 * @tc.name: TransIdLockSession
1008 * @tc.desc: test TransIdLockSession
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(SceneSessionManagerStubTest, TransIdLockSession, Function | SmallTest | Level2)
1012 {
1013 MessageParcel data;
1014 MessageParcel reply;
1015 MessageOption option;
1016
1017 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
1018 int32_t x = 1;
1019 data.WriteInt32(x);
1020
1021 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_LOCK_SESSION);
1022
1023 int res = stub_->OnRemoteRequest(code, data, reply, option);
1024 EXPECT_EQ(res, ERR_NONE);
1025 }
1026
1027 /**
1028 * @tc.name: TransIdUnlockSession
1029 * @tc.desc: test TransIdUnlockSession
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(SceneSessionManagerStubTest, TransIdUnlockSession, Function | SmallTest | Level2)
1033 {
1034 MessageParcel data;
1035 MessageParcel reply;
1036 MessageOption option;
1037
1038 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
1039 int32_t x = 1;
1040 data.WriteInt32(x);
1041
1042 uint32_t code = static_cast<uint32_t>(ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_UNLOCK_SESSION);
1043
1044 int res = stub_->OnRemoteRequest(code, data, reply, option);
1045 EXPECT_EQ(res, ERR_NONE);
1046 }
1047
1048 /**
1049 * @tc.name: OnRemoteRequest01
1050 * @tc.desc: test TRANS_ID_REGISTER_WINDOW_MANAGER_AGENT
1051 * @tc.type: FUNC
1052 */
1053 HWTEST_F(SceneSessionManagerStubTest, OnRemoteRequest01, Function | SmallTest | Level2)
1054 {
1055 MessageParcel data;
1056 MessageParcel reply;
1057 MessageOption option;
1058
1059 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
1060 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1061 data.WriteUint32(static_cast<uint32_t>(type));
1062 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1063 data.WriteRemoteObject(windowManagerAgent->AsObject());
1064
1065 uint32_t code = static_cast<uint32_t>(
1066 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_REGISTER_WINDOW_MANAGER_AGENT);
1067
1068 int res = stub_->OnRemoteRequest(code, data, reply, option);
1069 EXPECT_EQ(res, 0);
1070 }
1071
1072 /**
1073 * @tc.name: OnRemoteRequest02
1074 * @tc.desc: test TRANS_ID_REGISTER_WINDOW_MANAGER_AGENT
1075 * @tc.type: FUNC
1076 */
1077 HWTEST_F(SceneSessionManagerStubTest, OnRemoteRequest02, Function | SmallTest | Level2)
1078 {
1079 MessageParcel data;
1080 MessageParcel reply;
1081 MessageOption option;
1082
1083 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
1084 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1085 data.WriteUint32(static_cast<uint32_t>(type));
1086 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1087 data.WriteRemoteObject(windowManagerAgent->AsObject());
1088
1089 uint32_t code = static_cast<uint32_t>(
1090 ISceneSessionManager::SceneSessionManagerMessage::TRANS_ID_UNREGISTER_WINDOW_MANAGER_AGENT);
1091
1092 int res = stub_->OnRemoteRequest(code, data, reply, option);
1093 EXPECT_EQ(res, 0);
1094 }
1095
1096 /**
1097 * @tc.name: HandleCreateAndConnectSpecificSession
1098 * @tc.desc: test HandleCreateAndConnectSpecificSession
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(SceneSessionManagerStubTest, HandleCreateAndConnectSpecificSession, Function | SmallTest | Level2)
1102 {
1103 if (stub_ == nullptr) {
1104 return;
1105 }
1106
1107 MessageParcel data;
1108 MessageParcel reply;
1109
1110 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1111 ASSERT_NE(nullptr, sessionStage);
1112 data.WriteRemoteObject(sessionStage->AsObject());
1113 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(sessionStage);
1114 ASSERT_NE(nullptr, eventChannel);
1115 data.WriteRemoteObject(eventChannel->AsObject());
1116 struct RSSurfaceNodeConfig surfaceNodeConfig;
1117 surfaceNodeConfig.SurfaceNodeName = "SurfaceNode";
1118 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
1119 surfaceNode->Marshalling(data);
1120 data.WriteBool(false);
1121 stub_->HandleCreateAndConnectSpecificSession(data, reply);
1122
1123 data.WriteRemoteObject(sessionStage->AsObject());
1124 data.WriteRemoteObject(eventChannel->AsObject());
1125 surfaceNode->Marshalling(data);
1126 data.WriteBool(true);
1127 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1128 ASSERT_NE(nullptr, property);
1129 property->SetTokenState(true);
1130 data.WriteStrongParcelable(property);
1131 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1132 ASSERT_NE(nullptr, windowManagerAgent);
1133 data.WriteRemoteObject(windowManagerAgent->AsObject());
1134
1135 int res = stub_->HandleCreateAndConnectSpecificSession(data, reply);
1136 EXPECT_EQ(res, ERR_INVALID_DATA);
1137 }
1138
1139 /**
1140 * @tc.name: HandleRecoverAndConnectSpecificSession
1141 * @tc.desc: test HandleRecoverAndConnectSpecificSession
1142 * @tc.type: FUNC
1143 */
1144 HWTEST_F(SceneSessionManagerStubTest, HandleRecoverAndConnectSpecificSession, Function | SmallTest | Level2)
1145 {
1146 if (stub_ == nullptr) {
1147 return;
1148 }
1149
1150 MessageParcel data;
1151 MessageParcel reply;
1152
1153 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1154 ASSERT_NE(nullptr, sessionStage);
1155 data.WriteRemoteObject(sessionStage->AsObject());
1156 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannel>::MakeSptr(sessionStage);
1157 ASSERT_NE(nullptr, eventChannel);
1158 data.WriteRemoteObject(eventChannel->AsObject());
1159 struct RSSurfaceNodeConfig surfaceNodeConfig;
1160 surfaceNodeConfig.SurfaceNodeName = "SurfaceNode";
1161 std::shared_ptr<RSSurfaceNode> surfaceNode = RSSurfaceNode::Create(surfaceNodeConfig, RSSurfaceNodeType::DEFAULT);
1162 surfaceNode->Marshalling(data);
1163 data.WriteBool(false);
1164 int res = stub_->HandleRecoverAndConnectSpecificSession(data, reply);
1165 EXPECT_EQ(res, ERR_INVALID_STATE);
1166
1167 data.WriteRemoteObject(sessionStage->AsObject());
1168 data.WriteRemoteObject(eventChannel->AsObject());
1169 surfaceNode->Marshalling(data);
1170 data.WriteBool(true);
1171 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1172 ASSERT_NE(nullptr, property);
1173 property->SetTokenState(true);
1174 data.WriteStrongParcelable(property);
1175 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1176 ASSERT_NE(nullptr, windowManagerAgent);
1177 data.WriteRemoteObject(windowManagerAgent->AsObject());
1178
1179 res = stub_->HandleRecoverAndConnectSpecificSession(data, reply);
1180 EXPECT_EQ(res, ERR_INVALID_STATE);
1181 }
1182
1183 /**
1184 * @tc.name: HandleDestroyAndDisconnectSpcificSession
1185 * @tc.desc: test HandleDestroyAndDisconnectSpcificSession
1186 * @tc.type: FUNC
1187 */
1188 HWTEST_F(SceneSessionManagerStubTest, HandleDestroyAndDisconnectSpcificSession, Function | SmallTest | Level2)
1189 {
1190 MessageParcel data;
1191 MessageParcel reply;
1192
1193 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1194 data.WriteUint32(static_cast<uint32_t>(type));
1195
1196 int res = stub_->HandleDestroyAndDisconnectSpcificSession(data, reply);
1197 EXPECT_EQ(res, ERR_NONE);
1198 }
1199
1200 /**
1201 * @tc.name: HandleDestroyAndDisconnectSpcificSessionWithDetachCallback
1202 * @tc.desc: test HandleDestroyAndDisconnectSpcificSessionWithDetachCallback
1203 * @tc.type: FUNC
1204 */
1205 HWTEST_F(SceneSessionManagerStubTest, HandleDestroyAndDisconnectSpcificSessionWithDetachCallback,
1206 Function | SmallTest | Level2)
1207 {
1208 MessageParcel data;
1209 MessageParcel reply;
1210
1211 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1212 data.WriteUint32(static_cast<uint32_t>(type));
1213 sptr<PatternDetachCallback> callback = sptr<PatternDetachCallback>::MakeSptr();
1214 data.WriteRemoteObject(callback->AsObject());
1215
1216 int res = stub_->HandleDestroyAndDisconnectSpcificSession(data, reply);
1217 EXPECT_EQ(res, ERR_NONE);
1218 }
1219
1220 /**
1221 * @tc.name: HandleRequestFocusStatus
1222 * @tc.desc: test HandleRequestFocusStatus
1223 * @tc.type: FUNC
1224 */
1225 HWTEST_F(SceneSessionManagerStubTest, HandleRequestFocusStatus, Function | SmallTest | Level2)
1226 {
1227 if (stub_ == nullptr) {
1228 return;
1229 }
1230
1231 MessageParcel data;
1232 MessageParcel reply;
1233
1234 int32_t persistentId = 65535;
1235 data.WriteInt32(persistentId);
1236 bool isFocused = true;
1237 data.WriteBool(isFocused);
1238
1239 int res = stub_->HandleRequestFocusStatus(data, reply);
1240 EXPECT_EQ(res, ERR_NONE);
1241 }
1242
1243 /**
1244 * @tc.name: HandleRequestFocusStatusBySA
1245 * @tc.desc: test HandleRequestFocusStatusBySA
1246 * @tc.type: FUNC
1247 */
1248 HWTEST_F(SceneSessionManagerStubTest, HandleRequestFocusStatusBySA, Function | SmallTest | Level2)
1249 {
1250 if (stub_ == nullptr) {
1251 return;
1252 }
1253
1254 MessageParcel data;
1255 MessageParcel reply;
1256
1257 int32_t persistentId = 65535;
1258 data.WriteInt32(persistentId);
1259 bool isFocused = true;
1260 data.WriteBool(isFocused);
1261
1262 int res = stub_->HandleRequestFocusStatusBySA(data, reply);
1263 EXPECT_EQ(res, ERR_INVALID_DATA);
1264 }
1265
1266 /**
1267 * @tc.name: HandleRegisterWindowManagerAgent
1268 * @tc.desc: test HandleRegisterWindowManagerAgent
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(SceneSessionManagerStubTest, HandleRegisterWindowManagerAgent, Function | SmallTest | Level2)
1272 {
1273 MessageParcel data;
1274 MessageParcel reply;
1275
1276 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1277 data.WriteUint32(static_cast<uint32_t>(type));
1278 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1279 data.WriteRemoteObject(windowManagerAgent->AsObject());
1280
1281 int res = stub_->HandleRegisterWindowManagerAgent(data, reply);
1282 EXPECT_EQ(res, ERR_NONE);
1283 }
1284
1285 /**
1286 * @tc.name: HandleUnregisterWindowManagerAgent
1287 * @tc.desc: test HandleUnregisterWindowManagerAgent
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(SceneSessionManagerStubTest, HandleUnregisterWindowManagerAgent, Function | SmallTest | Level2)
1291 {
1292 MessageParcel data;
1293 MessageParcel reply;
1294
1295 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1296 data.WriteUint32(static_cast<uint32_t>(type));
1297 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1298 data.WriteRemoteObject(windowManagerAgent->AsObject());
1299
1300 int res = stub_->HandleUnregisterWindowManagerAgent(data, reply);
1301 EXPECT_EQ(res, ERR_NONE);
1302 }
1303
1304 /**
1305 * @tc.name: HandleSkipSnapshotForAppProcess
1306 * @tc.desc: test HandleSkipSnapshotForAppProcess
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F(SceneSessionManagerStubTest, HandleSkipSnapshotForAppProcess, Function | SmallTest | Level2)
1310 {
1311 MessageParcel data;
1312 MessageParcel reply;
1313
1314 data.WriteInt32(123);
1315 data.WriteBool(true);
1316
1317 int res = stub_->HandleSkipSnapshotForAppProcess(data, reply);
1318 EXPECT_EQ(res, ERR_NONE);
1319 }
1320
1321 /**
1322 * @tc.name: HandleGetFocusSessionInfo
1323 * @tc.desc: test HandleGetFocusSessionInfo
1324 * @tc.type: FUNC
1325 */
1326 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionInfo, Function | SmallTest | Level2)
1327 {
1328 MessageParcel data;
1329 MessageParcel reply;
1330 data.WriteUint64(0);
1331 int res = stub_->HandleGetFocusSessionInfo(data, reply);
1332 EXPECT_EQ(res, ERR_NONE);
1333 }
1334
1335 /**
1336 * @tc.name: HandleGetFocusSessionInfo1
1337 * @tc.desc: test HandleGetFocusSessionInfo
1338 * @tc.type: FUNC
1339 */
1340 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionInfo1, Function | SmallTest | Level2)
1341 {
1342 MessageParcel data;
1343 MessageParcel reply;
1344 int res = stub_->HandleGetFocusSessionInfo(data, reply);
1345 EXPECT_EQ(res, ERR_INVALID_DATA);
1346 }
1347
1348 /**
1349 * @tc.name: HandleGetFocusSessionElement
1350 * @tc.desc: test HandleGetFocusSessionElement
1351 * @tc.type: FUNC
1352 */
1353 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionElement, Function | SmallTest | Level2)
1354 {
1355 MessageParcel data;
1356 MessageParcel reply;
1357 data.WriteUint64(0);
1358 int res = stub_->HandleGetFocusSessionElement(data, reply);
1359 EXPECT_EQ(res, ERR_NONE);
1360 }
1361
1362 /**
1363 * @tc.name: HandleGetFocusSessionElement1
1364 * @tc.desc: test HandleGetFocusSessionElement
1365 * @tc.type: FUNC
1366 */
1367 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionElement1, Function | SmallTest | Level2)
1368 {
1369 MessageParcel data;
1370 MessageParcel reply;
1371 int res = stub_->HandleGetFocusSessionElement(data, reply);
1372 EXPECT_EQ(res, ERR_INVALID_DATA);
1373 }
1374
1375 /**
1376 * @tc.name: HandleSetSessionLabel
1377 * @tc.desc: test HandleSetSessionLabel
1378 * @tc.type: FUNC
1379 */
1380 HWTEST_F(SceneSessionManagerStubTest, HandleSetSessionLabel, Function | SmallTest | Level2)
1381 {
1382 MessageParcel data;
1383 MessageParcel reply;
1384
1385 sptr<IRemoteObject> token = nullptr;
1386 data.WriteRemoteObject(token);
1387 std::string label = "TestLabel";
1388 data.WriteString(label);
1389 int result = stub_->HandleSetSessionLabel(data, reply);
1390 EXPECT_EQ(result, ERR_NONE);
1391 }
1392
1393 /**
1394 * @tc.name: HandleSetSessionIcon
1395 * @tc.desc: test HandleSetSessionIcon
1396 * @tc.type: FUNC
1397 */
1398 HWTEST_F(SceneSessionManagerStubTest, HandleSetSessionIcon, Function | SmallTest | Level2)
1399 {
1400 if (stub_ == nullptr) {
1401 return;
1402 }
1403
1404 MessageParcel data;
1405 MessageParcel reply;
1406
1407 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1408 data.WriteRemoteObject(windowManagerAgent->AsObject());
1409
1410 int res = stub_->HandleSetSessionIcon(data, reply);
1411 EXPECT_EQ(res, ERR_INVALID_DATA);
1412 }
1413
1414 /**
1415 * @tc.name: HandleIsValidSessionIds
1416 * @tc.desc: test HandleIsValidSessionIds
1417 * @tc.type: FUNC
1418 */
1419 HWTEST_F(SceneSessionManagerStubTest, HandleIsValidSessionIds, Function | SmallTest | Level2)
1420 {
1421 MessageParcel data;
1422 MessageParcel reply;
1423
1424 std::vector<int32_t> points {0, 0};
1425 data.WriteInt32Vector(points);
1426 int res = stub_->HandleIsValidSessionIds(data, reply);
1427 EXPECT_EQ(res, ERR_NONE);
1428 }
1429
1430 /**
1431 * @tc.name: HandleGetSessionInfos
1432 * @tc.desc: test HandleGetSessionInfos
1433 * @tc.type: FUNC
1434 */
1435 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionInfos, Function | SmallTest | Level2)
1436 {
1437 if (stub_ == nullptr) {
1438 return;
1439 }
1440
1441 MessageParcel data;
1442 MessageParcel reply;
1443
1444 data.WriteString16(static_cast<std::u16string>(u"123"));
1445 int res = stub_->HandleGetSessionInfos(data, reply);
1446 EXPECT_EQ(res, ERR_INVALID_DATA);
1447 }
1448
1449 /**
1450 * @tc.name: HandleGetSessionInfo
1451 * @tc.desc: test HandleGetSessionInfo
1452 * @tc.type: FUNC
1453 */
1454 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionInfo, Function | SmallTest | Level2)
1455 {
1456 if (stub_ == nullptr) {
1457 return;
1458 }
1459
1460 MessageParcel data;
1461 MessageParcel reply;
1462
1463 data.WriteString16(static_cast<std::u16string>(u"123"));
1464 int res = stub_->HandleGetSessionInfo(data, reply);
1465 EXPECT_EQ(res, ERR_INVALID_DATA);
1466
1467 data.WriteString16(static_cast<std::u16string>(u"123"));
1468 data.WriteInt32(123);
1469 res = stub_->HandleGetSessionInfo(data, reply);
1470 EXPECT_EQ(res, ERR_NONE);
1471 }
1472
1473 /**
1474 * @tc.name: HandleGetSessionInfo2
1475 * @tc.desc: test HandleGetSessionInfo2
1476 * @tc.type: FUNC
1477 */
1478 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionInfo2, Function | SmallTest | Level2)
1479 {
1480 MessageParcel data;
1481 MessageParcel reply;
1482
1483 data.WriteString16(static_cast<std::u16string>(u"TestDeviceId"));
1484 data.WriteInt32(123456789);
1485 int result = stub_->HandleGetSessionInfo(data, reply);
1486 EXPECT_EQ(result, ERR_NONE);
1487 }
1488
1489 /**
1490 * @tc.name: HandleDumpSessionAll
1491 * @tc.desc: test HandleDumpSessionAll
1492 * @tc.type: FUNC
1493 */
1494 HWTEST_F(SceneSessionManagerStubTest, HandleDumpSessionAll, Function | SmallTest | Level2)
1495 {
1496 MessageParcel data;
1497 MessageParcel reply;
1498
1499 int res = stub_->HandleDumpSessionAll(data, reply);
1500 EXPECT_EQ(res, ERR_NONE);
1501 }
1502
1503 /**
1504 * @tc.name: HandleDumpSessionWithId
1505 * @tc.desc: test HandleDumpSessionWithId
1506 * @tc.type: FUNC
1507 */
1508 HWTEST_F(SceneSessionManagerStubTest, HandleDumpSessionWithId, Function | SmallTest | Level2)
1509 {
1510 MessageParcel data;
1511 MessageParcel reply;
1512
1513 int res = stub_->HandleDumpSessionWithId(data, reply);
1514 EXPECT_EQ(res, ERR_INVALID_DATA);
1515
1516 int32_t x = 1;
1517 data.WriteInt32(x);
1518 res = stub_->HandleDumpSessionWithId(data, reply);
1519 EXPECT_EQ(res, ERR_NONE);
1520 }
1521
1522 /**
1523 * @tc.name: HandleGetFocusSessionToken
1524 * @tc.desc: test HandleGetFocusSessionToken
1525 * @tc.type: FUNC
1526 */
1527 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionToken, Function | SmallTest | Level2)
1528 {
1529 MessageParcel data;
1530 MessageParcel reply;
1531 data.WriteUint64(0);
1532 int res = stub_->HandleGetFocusSessionToken(data, reply);
1533 EXPECT_EQ(res, ERR_NONE);
1534 }
1535
1536 /**
1537 * @tc.name: HandleGetFocusSessionToken1
1538 * @tc.desc: test HandleGetFocusSessionToken
1539 * @tc.type: FUNC
1540 */
1541 HWTEST_F(SceneSessionManagerStubTest, HandleGetFocusSessionToken1, Function | SmallTest | Level2)
1542 {
1543 MessageParcel data;
1544 MessageParcel reply;
1545 int res = stub_->HandleGetFocusSessionToken(data, reply);
1546 EXPECT_EQ(res, ERR_INVALID_DATA);
1547 }
1548
1549 /**
1550 * @tc.name: HandleCheckWindowId
1551 * @tc.desc: test HandleCheckWindowId
1552 * @tc.type: FUNC
1553 */
1554 HWTEST_F(SceneSessionManagerStubTest, HandleCheckWindowId, Function | SmallTest | Level2)
1555 {
1556 if (stub_ == nullptr) {
1557 return;
1558 }
1559
1560 MessageParcel data;
1561 MessageParcel reply;
1562
1563 int32_t windowId = 1000;
1564 SessionInfo info;
1565 info.abilityName_ = "HandleCheckWindowId";
1566 info.bundleName_ = "HandleCheckWindowId1";
1567 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
1568 SceneSessionManager::GetInstance().sceneSessionMap_[windowId] = sceneSession;
1569 data.WriteInt32(windowId);
1570
1571 int res = stub_->HandleCheckWindowId(data, reply);
1572 EXPECT_EQ(res, ERR_INVALID_DATA);
1573 }
1574
1575 /**
1576 * @tc.name: HandleSetGestureNavigationEnabled
1577 * @tc.desc: test HandleSetGestureNavigationEnabled
1578 * @tc.type: FUNC
1579 */
1580 HWTEST_F(SceneSessionManagerStubTest, HandleSetGestureNavigationEnabled, Function | SmallTest | Level2)
1581 {
1582 MessageParcel data;
1583 MessageParcel reply;
1584
1585 data.WriteBool(false);
1586
1587 int res = stub_->HandleSetGestureNavigationEnabled(data, reply);
1588 EXPECT_EQ(res, ERR_NONE);
1589 }
1590
1591 /**
1592 * @tc.name: HandleGetAccessibilityWindowInfo
1593 * @tc.desc: test HandleGetAccessibilityWindowInfo
1594 * @tc.type: FUNC
1595 */
1596 HWTEST_F(SceneSessionManagerStubTest, HandleGetAccessibilityWindowInfo, Function | SmallTest | Level2)
1597 {
1598 MessageParcel data;
1599 MessageParcel reply;
1600
1601 WindowManagerAgentType type = WindowManagerAgentType::WINDOW_MANAGER_AGENT_TYPE_FOCUS;
1602 data.WriteUint32(static_cast<uint32_t>(type));
1603
1604 int res = stub_->HandleGetAccessibilityWindowInfo(data, reply);
1605 EXPECT_EQ(res, ERR_NONE);
1606 }
1607
1608 /**
1609 * @tc.name: HandleGetUnreliableWindowInfo
1610 * @tc.desc: test HandleGetUnreliableWindowInfo
1611 * @tc.type: FUNC
1612 */
1613 HWTEST_F(SceneSessionManagerStubTest, HandleGetUnreliableWindowInfo, Function | SmallTest | Level2)
1614 {
1615 MessageParcel data;
1616 MessageParcel reply;
1617
1618 int32_t windowId = 0;
1619 data.WriteInt32(windowId);
1620
1621 int res = stub_->HandleGetUnreliableWindowInfo(data, reply);
1622 EXPECT_EQ(res, ERR_NONE);
1623 }
1624
1625 /**
1626 * @tc.name: HandleSetSessionContinueState1
1627 * @tc.desc: test HandleSetSessionContinueState1
1628 * @tc.type: FUNC
1629 */
1630 HWTEST_F(SceneSessionManagerStubTest, HandleSetSessionContinueState1, Function | SmallTest | Level2)
1631 {
1632 MessageParcel data;
1633 MessageParcel reply;
1634
1635 int32_t x = 0;
1636 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1637 data.WriteRemoteObject(windowManagerAgent->AsObject());
1638 data.WriteInt32(x);
1639
1640 int res = stub_->HandleSetSessionContinueState(data, reply);
1641 EXPECT_EQ(res, ERR_NONE);
1642 }
1643
1644 /**
1645 * @tc.name: HandleGetSessionDump
1646 * @tc.desc: test HandleGetSessionDump
1647 * @tc.type: FUNC
1648 */
1649 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionDump, Function | SmallTest | Level2)
1650 {
1651 if (stub_ == nullptr) {
1652 return;
1653 }
1654
1655 MessageParcel data;
1656 MessageParcel reply;
1657
1658 std::vector<std::string> params = {"-a"};
1659 data.WriteStringVector(params);
1660 stub_->HandleGetSessionDump(data, reply);
1661
1662 params.clear();
1663 params.push_back("-w");
1664 params.push_back("23456");
1665 data.WriteStringVector(params);
1666 stub_->HandleGetSessionDump(data, reply);
1667
1668 params.clear();
1669 data.WriteStringVector(params);
1670
1671 int res = stub_->HandleGetSessionDump(data, reply);
1672 EXPECT_EQ(res, ERR_NONE);
1673 }
1674
1675 /**
1676 * @tc.name: HandleUpdateSessionAvoidAreaListener
1677 * @tc.desc: test HandleUpdateSessionAvoidAreaListener
1678 * @tc.type: FUNC
1679 */
1680 HWTEST_F(SceneSessionManagerStubTest, HandleUpdateSessionAvoidAreaListener, Function | SmallTest | Level2)
1681 {
1682 if (stub_ == nullptr) {
1683 return;
1684 }
1685
1686 MessageParcel data;
1687 MessageParcel reply;
1688
1689 int32_t persistentId = 65535;
1690 data.WriteInt32(persistentId);
1691 bool haveAvoidAreaListener = false;
1692 data.WriteBool(haveAvoidAreaListener);
1693
1694 int res = stub_->HandleUpdateSessionAvoidAreaListener(data, reply);
1695 EXPECT_EQ(res, ERR_NONE);
1696 }
1697
1698 /**
1699 * @tc.name: HandleGetSessionSnapshot
1700 * @tc.desc: test HandleGetSessionSnapshot
1701 * @tc.type: FUNC
1702 */
1703 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionSnapshot, Function | SmallTest | Level2)
1704 {
1705 if (stub_ == nullptr) {
1706 return;
1707 }
1708
1709 MessageParcel data;
1710 MessageParcel reply;
1711
1712 data.WriteString16(static_cast<std::u16string>(u"123"));
1713 int32_t persistentId = 65535;
1714 data.WriteInt32(persistentId);
1715 bool isLowResolution = false;
1716 data.WriteBool(isLowResolution);
1717
1718 int res = stub_->HandleGetSessionSnapshot(data, reply);
1719 EXPECT_EQ(res, ERR_NONE);
1720 }
1721
1722 /**
1723 * @tc.name: HandleGetSessionSnapshotById
1724 * @tc.desc: test HandleGetSessionSnapshotById
1725 * @tc.type: FUNC
1726 */
1727 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionSnapshotById, Function | SmallTest | Level2)
1728 {
1729 if (stub_ == nullptr) {
1730 return;
1731 }
1732 MessageParcel data;
1733 MessageParcel reply;
1734 int32_t persistentId = -1;
1735 data.WriteInt32(persistentId);
1736 int res = stub_->HandleGetSessionSnapshotById(data, reply);
1737 EXPECT_EQ(res, ERR_NONE);
1738 }
1739
1740 /**
1741 * @tc.name: HandleBindDialogTarget
1742 * @tc.desc: test HandleBindDialogTarget
1743 * @tc.type: FUNC
1744 */
1745 HWTEST_F(SceneSessionManagerStubTest, HandleBindDialogTarget, Function | SmallTest | Level2)
1746 {
1747 if (stub_ == nullptr) {
1748 return;
1749 }
1750
1751 MessageParcel data;
1752 MessageParcel reply;
1753
1754 uint64_t persistentId = 65535;
1755 data.WriteUint64(persistentId);
1756 sptr<IWindowManagerAgent> windowManagerAgent = sptr<WindowManagerAgent>::MakeSptr();
1757 data.WriteRemoteObject(windowManagerAgent->AsObject());
1758
1759 int res = stub_->HandleBindDialogTarget(data, reply);
1760 EXPECT_EQ(res, ERR_NONE);
1761 }
1762
1763 /**
1764 * @tc.name: HandleNotifyDumpInfoResult
1765 * @tc.desc: test HandleNotifyDumpInfoResult
1766 * @tc.type: FUNC
1767 */
1768 HWTEST_F(SceneSessionManagerStubTest, HandleNotifyDumpInfoResult, Function | SmallTest | Level2)
1769 {
1770 if (stub_ == nullptr) {
1771 return;
1772 }
1773
1774 MessageParcel data;
1775 MessageParcel reply;
1776
1777 uint32_t vectorSize = 128;
1778 data.WriteUint32(vectorSize);
1779 stub_->HandleNotifyDumpInfoResult(data, reply);
1780
1781 std::vector<std::string> info = {"-a", "-b123", "-c3456789", ""};
1782 vectorSize = static_cast<uint32_t>(info.size());
1783 data.WriteUint32(vectorSize);
1784 uint32_t curSize;
1785 for (const auto& elem : info) {
1786 const char* curInfo = elem.c_str();
1787 curSize = static_cast<uint32_t>(strlen(curInfo));
1788 data.WriteUint32(curSize);
1789 if (curSize != 0) {
1790 data.WriteRawData(curInfo, curSize);
1791 }
1792 }
1793
1794 int res = stub_->HandleNotifyDumpInfoResult(data, reply);
1795 EXPECT_EQ(res, ERR_NONE);
1796 }
1797
1798 /**
1799 * @tc.name: HandleUnregisterCollaborator
1800 * @tc.desc: test HandleUnregisterCollaborator
1801 * @tc.type: FUNC
1802 */
1803 HWTEST_F(SceneSessionManagerStubTest, HandleUnregisterCollaborator, Function | SmallTest | Level2)
1804 {
1805 if (stub_ == nullptr) {
1806 return;
1807 }
1808
1809 MessageParcel data;
1810 MessageParcel reply;
1811
1812 int res = stub_->HandleUnregisterCollaborator(data, reply);
1813 EXPECT_EQ(res, ERR_INVALID_DATA);
1814
1815 int32_t type = CollaboratorType::RESERVE_TYPE;
1816 data.WriteInt32(type);
1817 res = stub_->HandleUnregisterCollaborator(data, reply);
1818 EXPECT_EQ(res, ERR_NONE);
1819 }
1820
1821 /**
1822 * @tc.name: HandleUpdateSessionTouchOutsideListener
1823 * @tc.desc: test HandleUpdateSessionTouchOutsideListener
1824 * @tc.type: FUNC
1825 */
1826 HWTEST_F(SceneSessionManagerStubTest, HandleUpdateSessionTouchOutsideListener, Function | SmallTest | Level2)
1827 {
1828 if (stub_ == nullptr) {
1829 return;
1830 }
1831
1832 MessageParcel data;
1833 MessageParcel reply;
1834
1835 int32_t persistentId = 65535;
1836 data.WriteInt32(persistentId);
1837 bool haveAvoidAreaListener = true;
1838 data.WriteBool(haveAvoidAreaListener);
1839
1840 int res = stub_->HandleUpdateSessionTouchOutsideListener(data, reply);
1841 EXPECT_EQ(res, ERR_NONE);
1842 }
1843
1844 /**
1845 * @tc.name: HandleRaiseWindowToTop
1846 * @tc.desc: test HandleRaiseWindowToTop
1847 * @tc.type: FUNC
1848 */
1849 HWTEST_F(SceneSessionManagerStubTest, HandleRaiseWindowToTop, Function | SmallTest | Level2)
1850 {
1851 if (stub_ == nullptr) {
1852 return;
1853 }
1854
1855 MessageParcel data;
1856 MessageParcel reply;
1857
1858 int32_t persistentId = 65535;
1859 data.WriteInt32(persistentId);
1860
1861 int res = stub_->HandleRaiseWindowToTop(data, reply);
1862 EXPECT_EQ(res, ERR_NONE);
1863 }
1864
1865 /**
1866 * @tc.name: HandleNotifyWindowExtensionVisibilityChange
1867 * @tc.desc: test HandleNotifyWindowExtensionVisibilityChange
1868 * @tc.type: FUNC
1869 */
1870 HWTEST_F(SceneSessionManagerStubTest, HandleNotifyWindowExtensionVisibilityChange, Function | SmallTest | Level2)
1871 {
1872 if (stub_ == nullptr) {
1873 return;
1874 }
1875
1876 MessageParcel data;
1877 MessageParcel reply;
1878
1879 int res = stub_->HandleNotifyWindowExtensionVisibilityChange(data, reply);
1880 EXPECT_EQ(res, ERR_INVALID_DATA);
1881
1882 int32_t pid = 123;
1883 data.WriteInt32(pid);
1884 res = stub_->HandleNotifyWindowExtensionVisibilityChange(data, reply);
1885 EXPECT_EQ(res, ERR_INVALID_DATA);
1886
1887 int32_t uid = 1231;
1888 data.WriteInt32(pid);
1889 data.WriteInt32(uid);
1890 res = stub_->HandleNotifyWindowExtensionVisibilityChange(data, reply);
1891 EXPECT_EQ(res, ERR_INVALID_DATA);
1892
1893 bool visible = true;
1894 data.WriteInt32(pid);
1895 data.WriteInt32(uid);
1896 data.WriteBool(visible);
1897 res = stub_->HandleNotifyWindowExtensionVisibilityChange(data, reply);
1898 EXPECT_EQ(res, ERR_NONE);
1899 }
1900
1901 /**
1902 * @tc.name: HandleGetTopWindowId
1903 * @tc.desc: test HandleGetTopWindowId
1904 * @tc.type: FUNC
1905 */
1906 HWTEST_F(SceneSessionManagerStubTest, HandleGetTopWindowId, Function | SmallTest | Level2)
1907 {
1908 if (stub_ == nullptr) {
1909 return;
1910 }
1911
1912 MessageParcel data;
1913 MessageParcel reply;
1914
1915 uint32_t mainWinId = 65535;
1916 data.WriteUint32(mainWinId);
1917
1918 int res = stub_->HandleGetTopWindowId(data, reply);
1919 EXPECT_EQ(res, ERR_NONE);
1920 }
1921
1922 /**
1923 * @tc.name: HandleShiftAppWindowFocus
1924 * @tc.desc: test HandleShiftAppWindowFocus
1925 * @tc.type: FUNC
1926 */
1927 HWTEST_F(SceneSessionManagerStubTest, HandleShiftAppWindowFocus, Function | SmallTest | Level2)
1928 {
1929 if (stub_ == nullptr) {
1930 return;
1931 }
1932
1933 MessageParcel data;
1934 MessageParcel reply;
1935
1936 int32_t sourcePersistentId = 12345;
1937 data.WriteInt32(sourcePersistentId);
1938 int32_t targetPersistentId = 65535;
1939 data.WriteInt32(targetPersistentId);
1940
1941 int res = stub_->HandleShiftAppWindowFocus(data, reply);
1942 EXPECT_EQ(res, ERR_NONE);
1943 }
1944
1945 /**
1946 * @tc.name: HandleAddExtensionWindowStageToSCB
1947 * @tc.desc: test HandleAddExtensionWindowStageToSCB
1948 * @tc.type: FUNC
1949 */
1950 HWTEST_F(SceneSessionManagerStubTest, HandleAddExtensionWindowStageToSCB, Function | SmallTest | Level2)
1951 {
1952 ASSERT_NE(stub_, nullptr);
1953
1954 MessageParcel data;
1955 MessageParcel reply;
1956
1957 int res = stub_->HandleAddExtensionWindowStageToSCB(data, reply);
1958 EXPECT_EQ(res, ERR_INVALID_DATA);
1959
1960 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1961 ASSERT_NE(nullptr, sessionStage);
1962 data.WriteRemoteObject(sessionStage->AsObject());
1963 res = stub_->HandleAddExtensionWindowStageToSCB(data, reply);
1964 EXPECT_EQ(res, ERR_INVALID_DATA);
1965
1966 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1967 ASSERT_NE(token, nullptr);
1968 data.WriteRemoteObject(token);
1969 res = stub_->HandleAddExtensionWindowStageToSCB(data, reply);
1970 EXPECT_EQ(res, ERR_INVALID_DATA);
1971
1972 ASSERT_NE(nullptr, sessionStage);
1973 data.WriteRemoteObject(sessionStage->AsObject());
1974 ASSERT_NE(token, nullptr);
1975 data.WriteRemoteObject(token);
1976 data.WriteUint64(12345);
1977 res = stub_->HandleAddExtensionWindowStageToSCB(data, reply);
1978 EXPECT_EQ(res, ERR_INVALID_DATA);
1979
1980 data.WriteRemoteObject(sessionStage->AsObject());
1981 ASSERT_NE(token, nullptr);
1982 data.WriteRemoteObject(token);
1983 data.WriteUint64(12345);
1984 data.WriteBool(false);
1985 res = stub_->HandleAddExtensionWindowStageToSCB(data, reply);
1986 EXPECT_EQ(res, ERR_NONE);
1987 }
1988
1989 /**
1990 * @tc.name: HandleRemoveExtensionWindowStageFromSCB
1991 * @tc.desc: test HandleRemoveExtensionWindowStageFromSCB
1992 * @tc.type: FUNC
1993 */
1994 HWTEST_F(SceneSessionManagerStubTest, HandleRemoveExtensionWindowStageFromSCB, Function | SmallTest | Level2)
1995 {
1996 MessageParcel data;
1997 MessageParcel reply;
1998
1999 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
2000 ASSERT_NE(sessionStage, nullptr);
2001 data.WriteRemoteObject(sessionStage->AsObject());
2002 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
2003 ASSERT_NE(token, nullptr);
2004 data.WriteRemoteObject(token);
2005
2006 sptr<SceneSessionManager> stub = sptr<SceneSessionManager>::MakeSptr();
2007 stub->remoteExtSessionMap_.clear();
2008 stub->remoteExtSessionMap_.insert(std::make_pair(sessionStage->AsObject(), token));
2009 int res = stub->HandleRemoveExtensionWindowStageFromSCB(data, reply);
2010 usleep(WAIT_SYNC_IN_NS);
2011 EXPECT_EQ(res, ERR_INVALID_DATA);
2012
2013 ASSERT_NE(sessionStage, nullptr);
2014 data.WriteRemoteObject(sessionStage->AsObject());
2015 ASSERT_NE(token, nullptr);
2016 data.WriteRemoteObject(token);
2017 data.WriteBool(false);
2018 res = stub->HandleRemoveExtensionWindowStageFromSCB(data, reply);
2019 usleep(WAIT_SYNC_IN_NS);
2020 EXPECT_EQ(res, ERR_NONE);
2021 }
2022
2023 /**
2024 * @tc.name: HandleUpdateModalExtensionRect
2025 * @tc.desc: test HandleUpdateModalExtensionRect
2026 * @tc.type: FUNC
2027 */
2028 HWTEST_F(SceneSessionManagerStubTest, HandleUpdateModalExtensionRect, Function | SmallTest | Level2)
2029 {
2030 ASSERT_NE(stub_, nullptr);
2031
2032 MessageParcel data;
2033 MessageParcel reply;
2034
2035 sptr<IRemoteObject> token = nullptr;
2036 data.WriteRemoteObject(token);
2037 Rect rect { 1, 2, 3, 4 };
2038 data.WriteInt32(rect.posX_);
2039 data.WriteInt32(rect.posY_);
2040 data.WriteInt32(rect.width_);
2041 data.WriteInt32(rect.height_);
2042
2043 int res = stub_->HandleUpdateModalExtensionRect(data, reply);
2044 EXPECT_EQ(res, ERR_INVALID_DATA);
2045 }
2046
2047 /**
2048 * @tc.name: HandleProcessModalExtensionPointDown
2049 * @tc.desc: test HandleProcessModalExtensionPointDown
2050 * @tc.type: FUNC
2051 */
2052 HWTEST_F(SceneSessionManagerStubTest, HandleProcessModalExtensionPointDown, Function | SmallTest | Level2)
2053 {
2054 ASSERT_NE(stub_, nullptr);
2055
2056 MessageParcel data;
2057 MessageParcel reply;
2058
2059 sptr<IRemoteObject> token = nullptr;
2060 data.WriteRemoteObject(token);
2061 int32_t posX = 114;
2062 data.WriteInt32(posX);
2063 int32_t posY = 514;
2064 data.WriteInt32(posY);
2065
2066 int res = stub_->HandleProcessModalExtensionPointDown(data, reply);
2067 EXPECT_EQ(res, ERR_INVALID_DATA);
2068 }
2069
2070 /**
2071 * @tc.name: HandleAddOrRemoveSecureSession
2072 * @tc.desc: test HandleAddOrRemoveSecureSession
2073 * @tc.type: FUNC
2074 */
2075 HWTEST_F(SceneSessionManagerStubTest, HandleAddOrRemoveSecureSession, Function | SmallTest | Level2)
2076 {
2077 MessageParcel data;
2078 MessageParcel reply;
2079
2080 int res = stub_->HandleAddOrRemoveSecureSession(data, reply);
2081 EXPECT_EQ(res, ERR_INVALID_DATA);
2082
2083 data.WriteInt32(15);
2084 res = stub_->HandleAddOrRemoveSecureSession(data, reply);
2085 EXPECT_EQ(res, ERR_INVALID_DATA);
2086
2087 data.WriteInt32(15);
2088 data.WriteBool(true);
2089 res = stub_->HandleAddOrRemoveSecureSession(data, reply);
2090 EXPECT_EQ(res, ERR_NONE);
2091 }
2092
2093 /**
2094 * @tc.name: HandleGetUIContentRemoteObj
2095 * @tc.desc: test HandleGetUIContentRemoteObj
2096 * @tc.type: FUNC
2097 */
2098 HWTEST_F(SceneSessionManagerStubTest, HandleGetUIContentRemoteObj, Function | SmallTest | Level2)
2099 {
2100 MessageParcel data;
2101 MessageParcel reply;
2102
2103 int res = stub_->HandleGetUIContentRemoteObj(data, reply);
2104 EXPECT_EQ(res, ERR_INVALID_DATA);
2105 data.WriteInt32(1);
2106 res = stub_->HandleGetUIContentRemoteObj(data, reply);
2107 EXPECT_EQ(res, ERR_NONE);
2108 }
2109
2110 /**
2111 * @tc.name: HandleGetHostWindowRect
2112 * @tc.desc: test HandleGetHostWindowRect
2113 * @tc.type: FUNC
2114 */
2115 HWTEST_F(SceneSessionManagerStubTest, HandleGetHostWindowRect, Function | SmallTest | Level2)
2116 {
2117 if (stub_ == nullptr) {
2118 return;
2119 }
2120
2121 MessageParcel data;
2122 MessageParcel reply;
2123
2124 int32_t hostWindowId = 65535;
2125 data.WriteInt32(hostWindowId);
2126
2127 int res = stub_->HandleGetHostWindowRect(data, reply);
2128 EXPECT_EQ(res, ERR_NONE);
2129 }
2130
2131 /**
2132 * @tc.name: HandleGetCallingWindowWindowStatus
2133 * @tc.desc: test HandleGetCallingWindowWindowStatus
2134 * @tc.type: FUNC
2135 */
2136 HWTEST_F(SceneSessionManagerStubTest, HandleGetCallingWindowWindowStatus, Function | SmallTest | Level2)
2137 {
2138 if (stub_ == nullptr) {
2139 return;
2140 }
2141
2142 MessageParcel data;
2143 MessageParcel reply;
2144
2145 int32_t persistentId = 65535;
2146 data.WriteInt32(persistentId);
2147
2148 int res = stub_->HandleGetCallingWindowWindowStatus(data, reply);
2149 EXPECT_EQ(res, ERR_INVALID_DATA);
2150 }
2151
2152 /**
2153 * @tc.name: HandleGetCallingWindowRect
2154 * @tc.desc: test HandleGetCallingWindowRect
2155 * @tc.type: FUNC
2156 */
2157 HWTEST_F(SceneSessionManagerStubTest, HandleGetCallingWindowRect, Function | SmallTest | Level2)
2158 {
2159 if (stub_ == nullptr) {
2160 return;
2161 }
2162
2163 MessageParcel data;
2164 MessageParcel reply;
2165
2166 int32_t persistentId = 65535;
2167 data.WriteInt32(persistentId);
2168
2169 int res = stub_->HandleGetCallingWindowRect(data, reply);
2170 EXPECT_EQ(res, ERR_INVALID_DATA);
2171 }
2172
2173 /**
2174 * @tc.name: HandleGetSessionInfoByContinueSessionId
2175 * @tc.desc: test HandleGetSessionInfoByContinueSessionId
2176 * @tc.type: FUNC
2177 */
2178 HWTEST_F(SceneSessionManagerStubTest, HandleGetSessionInfoByContinueSessionId, Function | SmallTest | Level2)
2179 {
2180 MessageParcel data;
2181 MessageParcel reply;
2182
2183 int res = stub_->HandleGetSessionInfoByContinueSessionId(data, reply);
2184 EXPECT_EQ(res, ERR_INVALID_DATA);
2185 data.WriteString("test_01");
2186 res = stub_->HandleGetSessionInfoByContinueSessionId(data, reply);
2187 EXPECT_EQ(res, ERR_NONE);
2188 }
2189
2190 /**
2191 * @tc.name: HandleUpdateExtWindowFlags
2192 * @tc.desc: test HandleUpdateExtWindowFlags
2193 * @tc.type: FUNC
2194 */
2195 HWTEST_F(SceneSessionManagerStubTest, HandleUpdateExtWindowFlags, Function | SmallTest | Level2)
2196 {
2197 MessageParcel data;
2198 MessageParcel reply;
2199
2200 sptr<IRemoteObject> token = nullptr;
2201 data.WriteRemoteObject(token);
2202 data.WriteInt32(7);
2203 data.WriteInt32(7);
2204
2205 int res = stub_->HandleUpdateExtWindowFlags(data, reply);
2206 EXPECT_EQ(res, ERR_INVALID_DATA);
2207 }
2208
2209 /**
2210 * @tc.name: HandleGetWindowStyleType
2211 * @tc.desc: test HandleGetWindowStyleType
2212 * @tc.type: FUNC
2213 */
2214 HWTEST_F(SceneSessionManagerStubTest, HandleGetWindowStyleType, Function | SmallTest | Level2)
2215 {
2216 MessageParcel data;
2217 MessageParcel reply;
2218 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
2219 int res = stub_->HandleGetWindowStyleType(data, reply);
2220 EXPECT_EQ(res, ERR_NONE);
2221 }
2222
2223 /**
2224 * @tc.name: HandleSetProcessWatermark
2225 * @tc.desc: test HandleSetProcessWatermark
2226 * @tc.type: FUNC
2227 */
2228 HWTEST_F(SceneSessionManagerStubTest, HandleSetProcessWatermark, Function | SmallTest | Level2)
2229 {
2230 MessageParcel data;
2231 MessageParcel reply;
2232
2233 data.WriteInt32(123);
2234 data.WriteString("SetProcessWatermarkName");
2235 data.WriteBool(true);
2236
2237 int res = stub_->HandleSetProcessWatermark(data, reply);
2238 EXPECT_EQ(res, ERR_NONE);
2239 }
2240
2241 /**
2242 * @tc.name: HandleGetProcessSurfaceNodeIdByPersistentId
2243 * @tc.desc: test HandleGetProcessSurfaceNodeIdByPersistentId
2244 * @tc.type: FUNC
2245 */
2246 HWTEST_F(SceneSessionManagerStubTest, HandleGetProcessSurfaceNodeIdByPersistentId, Function | SmallTest | Level2)
2247 {
2248 MessageParcel data;
2249 MessageParcel reply;
2250 int32_t pid = 123;
2251 std::vector<int32_t> persistentIds = {1, 2, 3};
2252 std::vector<uint64_t> surfaceNodeIds;
2253 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
2254 data.WriteInt32(pid);
2255 data.WriteInt32Vector(persistentIds);
2256 data.WriteUInt64Vector(surfaceNodeIds);
2257 int res = stub_->HandleGetProcessSurfaceNodeIdByPersistentId(data, reply);
2258 EXPECT_EQ(res, ERR_NONE);
2259 }
2260
2261 /**
2262 * @tc.name: HandleSkipSnapshotByUserIdAndBundleNames
2263 * @tc.desc: test HandleSkipSnapshotByUserIdAndBundleNames
2264 * @tc.type: FUNC
2265 */
2266 HWTEST_F(SceneSessionManagerStubTest, HandleSkipSnapshotByUserIdAndBundleNames, Function | SmallTest | Level2)
2267 {
2268 MessageParcel data;
2269 MessageParcel reply;
2270 int32_t userId = 100;
2271 std::vector<std::string> bundleNameList = {"a", "b", "c"};
2272 data.WriteInterfaceToken(SceneSessionManagerStub::GetDescriptor());
2273 data.WriteInt32(userId);
2274 data.WriteStringVector(bundleNameList);
2275 int res = stub_->HandleSkipSnapshotByUserIdAndBundleNames(data, reply);
2276 EXPECT_EQ(res, ERR_NONE);
2277 }
2278
2279 /**
2280 * @tc.name: HandleUpdateSessionScreenLock
2281 * @tc.desc: test HandleUpdateSessionScreenLock
2282 * @tc.type: FUNC
2283 */
2284 HWTEST_F(SceneSessionManagerStubTest, HandleUpdateSessionScreenLock, Function | SmallTest | Level2)
2285 {
2286 MessageParcel data;
2287 MessageParcel reply;
2288 data.WriteString("");
2289 data.WriteBool(true);
2290 int res = stub_->HandleUpdateSessionScreenLock(data, reply);
2291 EXPECT_EQ(res, ERR_NONE);
2292 }
2293
2294 /**
2295 * @tc.name: HandleAddSkipSelfWhenShowOnVirtualScreenList
2296 * @tc.desc: test HandleAddSkipSelfWhenShowOnVirtualScreenList
2297 * @tc.type: FUNC
2298 */
2299 HWTEST_F(SceneSessionManagerStubTest, HandleAddSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
2300 {
2301 MessageParcel data;
2302 MessageParcel reply;
2303 data.WriteUint64(1u);
2304 data.WriteInt32(1);
2305 int res = stub_->HandleAddSkipSelfWhenShowOnVirtualScreenList(data, reply);
2306 EXPECT_EQ(res, ERR_NONE);
2307 }
2308
2309 /**
2310 * @tc.name: HandleRemoveSkipSelfWhenShowOnVirtualScreenList
2311 * @tc.desc: test HandleRemoveSkipSelfWhenShowOnVirtualScreenList
2312 * @tc.type: FUNC
2313 */
2314 HWTEST_F(SceneSessionManagerStubTest, HandleRemoveSkipSelfWhenShowOnVirtualScreenList, Function | SmallTest | Level2)
2315 {
2316 MessageParcel data;
2317 MessageParcel reply;
2318 data.WriteUint64(1u);
2319 data.WriteInt32(1);
2320 int res = stub_->HandleRemoveSkipSelfWhenShowOnVirtualScreenList(data, reply);
2321 EXPECT_EQ(res, ERR_NONE);
2322 }
2323
2324 /**
2325 * @tc.name: HandleIsPcWindow
2326 * @tc.desc: test HandleIsPcWindow
2327 * @tc.type: FUNC
2328 */
2329 HWTEST_F(SceneSessionManagerStubTest, HandleIsPcWindow, Function | SmallTest | Level2)
2330 {
2331 MessageParcel data;
2332 MessageParcel reply;
2333 int res = stub_->HandleIsPcWindow(data, reply);
2334 EXPECT_EQ(res, ERR_NONE);
2335 }
2336
2337 /**
2338 * @tc.name: HandleIsPcOrPadFreeMultiWindowMode
2339 * @tc.desc: test HandleIsPcOrPadFreeMultiWindowMode
2340 * @tc.type: FUNC
2341 */
2342 HWTEST_F(SceneSessionManagerStubTest, HandleIsPcOrPadFreeMultiWindowMode, Function | SmallTest | Level2)
2343 {
2344 MessageParcel data;
2345 MessageParcel reply;
2346 int res = stub_->HandleIsPcOrPadFreeMultiWindowMode(data, reply);
2347 EXPECT_EQ(res, ERR_NONE);
2348 }
2349
2350 /**
2351 * @tc.name: HandleIsWindowRectAutoSave
2352 * @tc.desc: test HandleIsWindowRectAutoSave
2353 * @tc.type: FUNC
2354 */
2355 HWTEST_F(SceneSessionManagerStubTest, HandleIsWindowRectAutoSave, Function | SmallTest | Level2)
2356 {
2357 MessageParcel data;
2358 MessageParcel reply;
2359 std::string key = "com.example.recposentryEntryAbility";
2360 int persistentId = 1;
2361 data.WriteString(key);
2362 data.WriteInt32(persistentId);
2363 int res = stub_->HandleIsWindowRectAutoSave(data, reply);
2364 EXPECT_EQ(res, ERR_NONE);
2365 }
2366
2367 /**
2368 * @tc.name: HandleGetDisplayIdByWindowId
2369 * @tc.desc: test HandleGetDisplayIdByWindowId
2370 * @tc.type: FUNC
2371 */
2372 HWTEST_F(SceneSessionManagerStubTest, HandleGetDisplayIdByWindowId, Function | SmallTest | Level2)
2373 {
2374 MessageParcel data;
2375 MessageParcel reply;
2376 const std::vector<uint64_t> windowIds = {1, 2};
2377 data.WriteUInt64Vector(windowIds);
2378
2379 int res = stub_->HandleGetDisplayIdByWindowId(data, reply);
2380 EXPECT_EQ(res, ERR_NONE);
2381 }
2382
2383 /**
2384 * @tc.name: HandleRegisterCollaborator
2385 * @tc.desc: test HandleRegisterCollaborator
2386 * @tc.type: FUNC
2387 */
2388 HWTEST_F(SceneSessionManagerStubTest, HandleRegisterCollaborator, Function | SmallTest | Level2)
2389 {
2390 MessageParcel data;
2391 MessageParcel reply;
2392
2393 auto res = stub_->HandleRegisterCollaborator(data, reply);
2394 EXPECT_EQ(res, ERR_INVALID_DATA);
2395
2396 int32_t type = CollaboratorType::RESERVE_TYPE;
2397 data.WriteInt32(type);
2398 res = stub_->HandleRegisterCollaborator(data, reply);
2399 EXPECT_EQ(res, ERR_INVALID_DATA);
2400 }
2401
2402 /**
2403 * @tc.name: HandleSetGlobalDragResizeType
2404 * @tc.desc: test HandleSetGlobalDragResizeType
2405 * @tc.type: FUNC
2406 */
2407 HWTEST_F(SceneSessionManagerStubTest, HandleSetGlobalDragResizeType, Function | SmallTest | Level2)
2408 {
2409 MessageParcel data;
2410 MessageParcel reply;
2411 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
2412 data.WriteUint32(static_cast<uint32_t>(dragResizeType));
2413 int res = stub_->HandleSetGlobalDragResizeType(data, reply);
2414 EXPECT_EQ(res, ERR_NONE);
2415 }
2416
2417 /**
2418 * @tc.name: HandleGetGlobalDragResizeType
2419 * @tc.desc: test HandleGetGlobalDragResizeType
2420 * @tc.type: FUNC
2421 */
2422 HWTEST_F(SceneSessionManagerStubTest, HandleGetGlobalDragResizeType, Function | SmallTest | Level2)
2423 {
2424 MessageParcel data;
2425 MessageParcel reply;
2426 int res = stub_->HandleGetGlobalDragResizeType(data, reply);
2427 EXPECT_EQ(res, ERR_NONE);
2428 }
2429
2430 /**
2431 * @tc.name: HandleSetAppDragResizeType
2432 * @tc.desc: test HandleSetAppDragResizeType
2433 * @tc.type: FUNC
2434 */
2435 HWTEST_F(SceneSessionManagerStubTest, HandleSetAppDragResizeType, Function | SmallTest | Level2)
2436 {
2437 MessageParcel data;
2438 MessageParcel reply;
2439 DragResizeType dragResizeType = DragResizeType::RESIZE_EACH_FRAME;
2440 const std::string bundleName = "test";
2441 data.WriteString(bundleName);
2442 data.WriteUint32(static_cast<uint32_t>(dragResizeType));
2443 int res = stub_->HandleSetAppDragResizeType(data, reply);
2444 EXPECT_EQ(res, ERR_NONE);
2445 }
2446
2447 /**
2448 * @tc.name: HandleSetParentWindow
2449 * @tc.desc: test HandleSetParentWindow
2450 * @tc.type: FUNC
2451 */
2452 HWTEST_F(SceneSessionManagerStubTest, HandleSetParentWindow, Function | SmallTest | Level2)
2453 {
2454 MessageParcel data;
2455 MessageParcel reply;
2456 int32_t subWindowId = 1;
2457 int32_t newParentWindowId = 2;
2458 data.WriteInt32(subWindowId);
2459 data.WriteInt32(newParentWindowId);
2460 int res = stub_->HandleSetParentWindow(data, reply);
2461 EXPECT_EQ(res, ERR_NONE);
2462 }
2463
2464 /**
2465 * @tc.name: HandleGetAppDragResizeType
2466 * @tc.desc: test HandleGetAppDragResizeType
2467 * @tc.type: FUNC
2468 */
2469 HWTEST_F(SceneSessionManagerStubTest, HandleGetAppDragResizeType, Function | SmallTest | Level2)
2470 {
2471 MessageParcel data;
2472 MessageParcel reply;
2473 const std::string bundleName = "test";
2474 data.WriteString(bundleName);
2475 int res = stub_->HandleGetAppDragResizeType(data, reply);
2476 EXPECT_EQ(res, ERR_NONE);
2477 }
2478
2479 /**
2480 * @tc.name: HandleminiMizeByWindowId
2481 * @tc.desc: test HandleMinimizeByWindowId
2482 * @tc.type: FUNC
2483 */
2484 HWTEST_F(SceneSessionManagerStubTest, HandleMinimizeByWindowId, Function | SmallTest | Level2)
2485 {
2486 MessageParcel data;
2487 MessageParcel reply;
2488 std::vector<int32_t> windowIds;
2489 data.WriteInt32Vector(windowIds);
2490 int res = stub_->HandleMinimizeByWindowId(data, reply);
2491 EXPECT_EQ(res, ERR_NONE);
2492 }
2493 }
2494 }
2495 }