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