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