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 <ipc_types.h>
18 #include <pointer_event.h>
19 #include "iremote_object_mocker.h"
20 #include "mock/mock_session_stub.h"
21 #include "session/host/include/zidl/session_stub.h"
22 #include "ability_start_setting.h"
23 #include "parcel/accessibility_event_info_parcel.h"
24 #include "session/host/include/zidl/session_ipc_interface_code.h"
25 #include "want.h"
26 #include "ws_common.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Rosen {
33 namespace {
34 const std::string UNDEFINED = "undefined";
35 }
36 
37 namespace OHOS::Accessibility {
38 class AccessibilityEventInfo;
39 }
40 class SessionStubTest : public testing::Test {
41 public:
42     static void SetUpTestCase();
43     static void TearDownTestCase();
44     void SetUp() override;
45     void TearDown() override;
46 
47 private:
48     sptr<SessionStub> session_ = nullptr;
49 };
50 
SetUpTestCase()51 void SessionStubTest::SetUpTestCase()
52 {
53 }
54 
TearDownTestCase()55 void SessionStubTest::TearDownTestCase()
56 {
57 }
58 
SetUp()59 void SessionStubTest::SetUp()
60 {
61     session_ = new (std::nothrow) SessionStubMocker();
62     EXPECT_NE(nullptr, session_);
63 }
64 
TearDown()65 void SessionStubTest::TearDown()
66 {
67     session_ = nullptr;
68 }
69 
70 namespace {
71 /**
72  * @tc.name: OnRemoteRequest01
73  * @tc.desc: sessionStub OnRemoteRequest01
74  * @tc.type: FUNC
75  * @tc.require: #I6JLSI
76  */
HWTEST_F(SessionStubTest, OnRemoteRequest01, Function | SmallTest | Level2)77 HWTEST_F(SessionStubTest, OnRemoteRequest01, Function | SmallTest | Level2)
78 {
79     uint32_t code = 1;
80     MessageParcel data;
81     MessageParcel reply;
82     MessageOption option = {MessageOption::TF_SYNC};
83     auto res = session_->OnRemoteRequest(code, data, reply, option);
84     ASSERT_EQ(ERR_NONE, res);
85     data.WriteInterfaceToken(u"OHOS.ISession");
86     res = session_->OnRemoteRequest(code, data, reply, option);
87     ASSERT_EQ(ERR_NONE, res);
88 }
89 
90 /**
91  * @tc.name: ProcessRemoteRequestTest01
92  * @tc.desc: sessionStub ProcessRemoteRequestTest01
93  * @tc.type: FUNC
94  * @tc.require: #I6JLSI
95  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest01, Function | SmallTest | Level2)96 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest01, Function | SmallTest | Level2)
97 {
98     MessageParcel data;
99     MessageParcel reply;
100     MessageOption option = {MessageOption::TF_SYNC};
101     data.WriteBool(true);
102     auto res = session_->ProcessRemoteRequest(
103         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
104     ASSERT_EQ(ERR_NONE, res);
105 
106     data.WriteBool(false);
107     data.WriteBool(true);
108     data.WriteString("");
109     res = session_->ProcessRemoteRequest(
110         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_FOREGROUND), data, reply, option);
111     ASSERT_EQ(ERR_NONE, res);
112 
113     data.WriteBool(true);
114     data.WriteString("");
115     res = session_->ProcessRemoteRequest(
116         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKGROUND), data, reply, option);
117     ASSERT_EQ(ERR_NONE, res);
118 
119     data.WriteBool(true);
120     data.WriteString("");
121     res = session_->ProcessRemoteRequest(
122         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DISCONNECT), data, reply, option);
123     ASSERT_EQ(ERR_NONE, res);
124     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
125     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
126     res = session_->ProcessRemoteRequest(
127         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_CONNECT), data, reply, option);
128     ASSERT_EQ(ERR_INVALID_DATA, res);
129     ASSERT_EQ(data.WriteUint32(1), true);
130     res = session_->ProcessRemoteRequest(
131         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SESSION_EVENT), data, reply, option);
132     ASSERT_EQ(ERR_NONE, res);
133     AAFwk::Want options;
134     EXPECT_NE(data.WriteString("HandleSessionException"), false);
135     EXPECT_NE(data.WriteParcelable(&options), false);
136     res = session_->ProcessRemoteRequest(
137         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TERMINATE), data, reply, option);
138     ASSERT_EQ(ERR_NONE, res);
139     res = session_->ProcessRemoteRequest(
140         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_SESSION_RECT), data, reply, option);
141     ASSERT_EQ(ERR_NONE, res);
142     res = session_->ProcessRemoteRequest(
143         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_TO_APP_TOP), data, reply, option);
144     ASSERT_EQ(ERR_NONE, res);
145 }
146 
147 /**
148  * @tc.name: ProcessRemoteRequestTest02
149  * @tc.desc: sessionStub ProcessRemoteRequestTest02
150  * @tc.type: FUNC
151  * @tc.require: #I6JLSI
152  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest02, Function | SmallTest | Level2)153 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest02, Function | SmallTest | Level2)
154 {
155     MessageParcel data;
156     MessageParcel reply;
157     MessageOption option = {MessageOption::TF_SYNC};
158     data.WriteBool(true);
159     data.WriteInt32(1);
160     auto res = session_->ProcessRemoteRequest(
161         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
162     ASSERT_EQ(ERR_NONE, res);
163     res = session_->ProcessRemoteRequest(
164         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_APP_MAIN_WINDOW), data, reply, option);
165     ASSERT_EQ(ERR_NONE, res);
166     res = session_->ProcessRemoteRequest(
167         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKPRESSED), data, reply, option);
168     ASSERT_EQ(ERR_NONE, res);
169     res = session_->ProcessRemoteRequest(
170         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_MARK_PROCESSED), data, reply, option);
171     ASSERT_EQ(ERR_INVALID_DATA, res);
172     res = session_->ProcessRemoteRequest(
173         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_MAXIMIZE_MODE), data, reply, option);
174     ASSERT_EQ(ERR_INVALID_DATA, res);
175     res = session_->ProcessRemoteRequest(
176         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_MAXIMIZE_MODE), data, reply, option);
177     ASSERT_EQ(ERR_NONE, res);
178     res = session_->ProcessRemoteRequest(
179         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NEED_AVOID), data, reply, option);
180     ASSERT_EQ(ERR_NONE, res);
181     res = session_->ProcessRemoteRequest(
182         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_AVOID_AREA), data, reply, option);
183     ASSERT_EQ(ERR_NONE, res);
184     res = session_->ProcessRemoteRequest(
185         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_ASPECT_RATIO), data, reply, option);
186     ASSERT_EQ(ERR_INVALID_DATA, res);
187     res = session_->ProcessRemoteRequest(
188         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_CUSTOM_ANIMATION), data, reply, option);
189     ASSERT_EQ(ERR_NONE, res);
190     res = session_->ProcessRemoteRequest(
191         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_EXTENSION_DATA), data, reply, option);
192     ASSERT_EQ(ERR_INVALID_VALUE, res);
193     res = session_->ProcessRemoteRequest(
194         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_DIED), data, reply, option);
195     ASSERT_EQ(ERR_NONE, res);
196     res = session_->ProcessRemoteRequest(
197         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_TIMEOUT), data, reply, option);
198     ASSERT_EQ(ERR_INVALID_DATA, res);
199 }
200 
201 /**
202  * @tc.name: ProcessRemoteRequestTest03
203  * @tc.desc: sessionStub ProcessRemoteRequestTest03
204  * @tc.type: FUNC
205  * @tc.require: #I6JLSI
206  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest03, Function | SmallTest | Level2)207 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest03, Function | SmallTest | Level2)
208 {
209     MessageParcel data;
210     MessageParcel reply;
211     MessageOption option = {MessageOption::TF_SYNC};
212     data.WriteBool(true);
213     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
214     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
215     ASSERT_EQ(data.WriteUint32(1), true);
216     AAFwk::Want options;
217     EXPECT_NE(data.WriteString("HandleSessionException"), false);
218     EXPECT_NE(data.WriteParcelable(&options), false);
219     ASSERT_EQ(data.WriteUint64(2), true);
220     auto res = session_->ProcessRemoteRequest(
221         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SHOW), data, reply, option);
222     ASSERT_EQ(ERR_INVALID_DATA, res);
223     res = session_->ProcessRemoteRequest(
224         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_HIDE), data, reply, option);
225     ASSERT_EQ(ERR_NONE, res);
226     res = session_->ProcessRemoteRequest(
227         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DRAWING_COMPLETED), data, reply, option);
228     ASSERT_EQ(ERR_NONE, res);
229     res = session_->ProcessRemoteRequest(
230         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_RECTCHANGE_LISTENER_REGISTERED),
231         data,
232         reply,
233         option);
234     ASSERT_EQ(ERR_NONE, res);
235     res = session_->ProcessRemoteRequest(
236         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_LANDSCAPE_MULTI_WINDOW), data, reply, option);
237     ASSERT_EQ(ERR_NONE, res);
238     res = session_->ProcessRemoteRequest(
239         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ACTIVE_PENDING_SESSION), data, reply, option);
240     ASSERT_EQ(ERR_INVALID_DATA, res);
241     MessageParcel tmp;
242     tmp.WriteUint32(1);
243     res = session_->ProcessRemoteRequest(
244         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_ABILITY_RESULT), tmp, reply, option);
245     ASSERT_EQ(ERR_INVALID_VALUE, res);
246 }
247 
248 /**
249  * @tc.name: ProcessRemoteRequestTest04
250  * @tc.desc: sessionStub ProcessRemoteRequestTest04
251  * @tc.type: FUNC
252  * @tc.require: #I6JLSI
253  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest04, Function | SmallTest | Level2)254 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest04, Function | SmallTest | Level2)
255 {
256     MessageParcel data;
257     MessageParcel reply;
258     MessageOption option = {MessageOption::TF_SYNC};
259     data.WriteBool(true);
260     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
261     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
262     ASSERT_EQ(data.WriteUint32(1), true);
263     AAFwk::Want options;
264     EXPECT_NE(data.WriteString("HandleSessionException"), false);
265     EXPECT_NE(data.WriteParcelable(&options), false);
266     ASSERT_EQ(data.WriteUint64(2), true);
267     auto res = session_->ProcessRemoteRequest(
268         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_PROCESS_POINT_DOWN_SESSION), data, reply, option);
269     ASSERT_EQ(ERR_NONE, res);
270     res = session_->ProcessRemoteRequest(
271         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SEND_POINTEREVENT_FOR_MOVE_DRAG), data, reply, option);
272     ASSERT_EQ(ERR_INVALID_DATA, res);
273     res = session_->ProcessRemoteRequest(
274         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_KEYBOARD_SESSION_GRAVITY), data, reply, option);
275     ASSERT_EQ(ERR_INVALID_DATA, res);
276     res = session_->ProcessRemoteRequest(
277         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
278     ASSERT_EQ(ERR_INVALID_DATA, res);
279     res = session_->ProcessRemoteRequest(
280         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
281     ASSERT_EQ(ERR_INVALID_DATA, res);
282     res = session_->ProcessRemoteRequest(
283         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ADJUST_KEYBOARD_LAYOUT), data, reply, option);
284     ASSERT_EQ(ERR_INVALID_DATA, res);
285     res = session_->ProcessRemoteRequest(
286         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_ASYNC_ON), data, reply, option);
287     ASSERT_EQ(ERR_NONE, res);
288     res = session_->ProcessRemoteRequest(
289         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_SYNC_ON), data, reply, option);
290     ASSERT_EQ(ERR_NONE, res);
291     res = session_->ProcessRemoteRequest(
292         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRIGGER_BIND_MODAL_UI_EXTENSION), data, reply, option);
293     ASSERT_EQ(ERR_NONE, res);
294 }
295 
296 /**
297  * @tc.name: ProcessRemoteRequestTest05
298  * @tc.desc: sessionStub ProcessRemoteRequestTest05
299  * @tc.type: FUNC
300  * @tc.require: #I6JLSI
301  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest05, Function | SmallTest | Level2)302 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest05, Function | SmallTest | Level2)
303 {
304     MessageParcel data;
305     MessageParcel reply;
306     MessageOption option = {MessageOption::TF_SYNC};
307     data.WriteBool(true);
308     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
309     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
310     ASSERT_EQ(data.WriteUint32(1), true);
311     AAFwk::Want options;
312     EXPECT_NE(data.WriteString("HandleSessionException"), false);
313     EXPECT_NE(data.WriteParcelable(&options), false);
314     ASSERT_EQ(data.WriteUint64(2), true);
315     auto res = session_->ProcessRemoteRequest(
316         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_PIP_WINDOW_PREPARE_CLOSE), data, reply, option);
317     ASSERT_EQ(ERR_NONE, res);
318     res = session_->ProcessRemoteRequest(
319         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_RECT), data, reply, option);
320     ASSERT_EQ(ERR_NONE, res);
321     res = session_->ProcessRemoteRequest(
322         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_CONTROL_STATUS), data, reply, option);
323     ASSERT_EQ(ERR_INVALID_DATA, res);
324     res = session_->ProcessRemoteRequest(
325         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_LAYOUT_FULL_SCREEN_CHANGE), data, reply, option);
326     ASSERT_EQ(ERR_NONE, res);
327     res = session_->ProcessRemoteRequest(
328         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TITLE_AND_DOCK_HOVER_SHOW_CHANGE), data, reply, option);
329     ASSERT_EQ(ERR_NONE, res);
330     res = session_->ProcessRemoteRequest(
331         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_DIALOG_SESSION_BACKGESTURE_ENABLE),
332         data,
333         reply,
334         option);
335     ASSERT_EQ(ERR_NONE, res);
336     res = session_->ProcessRemoteRequest(
337         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_EVENT_ASYNC), data, reply, option);
338     ASSERT_EQ(ERR_NONE, res);
339 }
340 
341 /**
342  * @tc.name: ProcessRemoteRequestTest06
343  * @tc.desc: sessionStub ProcessRemoteRequestTest06
344  * @tc.type: FUNC
345  * @tc.require: #I6JLSI
346  */
HWTEST_F(SessionStubTest, ProcessRemoteRequestTest06, Function | SmallTest | Level2)347 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest06, Function | SmallTest | Level2)
348 {
349     MessageParcel data;
350     MessageParcel reply;
351     MessageOption option = {MessageOption::TF_SYNC};
352     AAFwk::Want want;
353     data.WriteParcelable(&want);
354     data.WriteBool(true);
355     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
356     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
357     ASSERT_EQ(data.WriteUint32(1), true);
358     ASSERT_EQ(data.WriteUint32(1), true);
359     AAFwk::Want options;
360     EXPECT_NE(data.WriteString("HandleSessionException"), false);
361     EXPECT_NE(data.WriteString("HandleSessionException"), false);
362     EXPECT_NE(data.WriteParcelable(&options), false);
363     ASSERT_EQ(data.WriteUint64(2), true);
364     auto res = session_->ProcessRemoteRequest(
365         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_EXCEPTION), data, reply, option);
366     ASSERT_EQ(ERR_NONE, res);
367     ASSERT_EQ(data.WriteUint32(1), true);
368     ASSERT_EQ(data.WriteUint32(1), true);
369     res = session_->ProcessRemoteRequest(
370         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_KEYBOARD_SESSION_GRAVITY), data, reply, option);
371     ASSERT_EQ(ERR_NONE, res);
372     ASSERT_EQ(data.WriteUint32(1), true);
373     res = session_->ProcessRemoteRequest(
374         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
375     ASSERT_EQ(ERR_NONE, res);
376     ASSERT_EQ(data.WriteInt32(1), true);
377     res = session_->ProcessRemoteRequest(
378         static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
379     ASSERT_EQ(ERR_NONE, res);
380 }
381 
382 /**
383  * @tc.name: sessionStubTest02
384  * @tc.desc: sessionStub sessionStubTest02
385  * @tc.type: FUNC
386  * @tc.require: #I6JLSI
387  */
HWTEST_F(SessionStubTest, sessionStubTest02, Function | SmallTest | Level2)388 HWTEST_F(SessionStubTest, sessionStubTest02, Function | SmallTest | Level2)
389 {
390     MessageParcel data;
391     MessageParcel reply;
392     data.WriteBool(true);
393     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
394     EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
395     ASSERT_EQ(data.WriteUint32(1), true);
396     AAFwk::Want options;
397     EXPECT_NE(data.WriteString("HandleSessionException"), false);
398     EXPECT_NE(data.WriteParcelable(&options), false);
399     ASSERT_EQ(data.WriteUint64(2), true);
400     auto res = session_->HandleRaiseAboveTarget(data, reply);
401     ASSERT_EQ(ERR_NONE, res);
402     res = session_->HandleRaiseAppMainWindowToTop(data, reply);
403     ASSERT_EQ(ERR_NONE, res);
404     res = session_->HandleBackPressed(data, reply);
405     if (!data.ReadBool()) {
406         ASSERT_EQ(ERR_INVALID_DATA, res);
407     }
408     res = session_->HandleMarkProcessed(data, reply);
409     ASSERT_EQ(ERR_NONE, res);
410     res = session_->HandleGetGlobalMaximizeMode(data, reply);
411     ASSERT_EQ(ERR_NONE, res);
412     res = session_->HandleNeedAvoid(data, reply);
413     ASSERT_EQ(ERR_NONE, res);
414     res = session_->HandleGetAvoidAreaByType(data, reply);
415     ASSERT_EQ(ERR_NONE, res);
416     res = session_->HandleSetAspectRatio(data, reply);
417     ASSERT_EQ(ERR_NONE, res);
418     res = session_->HandleUpdateWindowSceneAfterCustomAnimation(data, reply);
419     ASSERT_EQ(ERR_NONE, res);
420     session_->HandleTransferAbilityResult(data, reply);
421     res = session_->HandleNotifyExtensionDied(data, reply);
422     ASSERT_EQ(ERR_NONE, res);
423     res = session_->HandleNotifyExtensionTimeout(data, reply);
424     ASSERT_EQ(ERR_NONE, res);
425     res = session_->HandleGetStatusBarHeight(data, reply);
426     ASSERT_EQ(ERR_NONE, res);
427     res = session_->HandleSetSystemEnableDrag(data, reply);
428     ASSERT_EQ(ERR_NONE, res);
429 }
430 
431 /**
432  * @tc.name: sessionStubTest03
433  * @tc.desc: sessionStub sessionStubTest03
434  * @tc.type: FUNC
435  * @tc.require: #I6JLSI
436  */
HWTEST_F(SessionStubTest, sessionStubTest03, Function | SmallTest | Level2)437 HWTEST_F(SessionStubTest, sessionStubTest03, Function | SmallTest | Level2)
438 {
439     MessageParcel data;
440     MessageParcel reply;
441 
442     ASSERT_EQ(data.WriteUint32(1), true);
443     auto res = session_->HandleSetGlobalMaximizeMode(data, reply);
444     ASSERT_EQ(ERR_NONE, res);
445     res = session_->HandleTransferExtensionData(data, reply);
446     ASSERT_EQ(ERR_INVALID_VALUE, res);
447 }
448 
449 /**
450  * @tc.name: HandleTriggerBindModalUIExtension001
451  * @tc.desc: sessionStub sessionStubTest
452  * @tc.type: FUNC
453  * @tc.require: #I6JLSI
454  */
HWTEST_F(SessionStubTest, HandleTriggerBindModalUIExtension001, Function | SmallTest | Level2)455 HWTEST_F(SessionStubTest, HandleTriggerBindModalUIExtension001, Function | SmallTest | Level2)
456 {
457     MessageParcel data;
458     MessageParcel reply;
459     data.WriteBool(true);
460     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
461     auto res = session_->HandleTriggerBindModalUIExtension(data, reply);
462     ASSERT_EQ(ERR_NONE, res);
463 }
464 
465 /**
466  * @tc.name: HandleTransferAccessibilityEvent002
467  * @tc.desc: sessionStub sessionStubTest
468  * @tc.type: FUNC
469  * @tc.require: #I6JLSI
470  */
HWTEST_F(SessionStubTest, HandleTransferAccessibilityEvent003, Function | SmallTest | Level2)471 HWTEST_F(SessionStubTest, HandleTransferAccessibilityEvent003, Function | SmallTest | Level2)
472 {
473     MessageParcel data;
474     MessageParcel reply;
475     data.WriteBool(true);
476     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
477     auto res = session_->HandleTransferAccessibilityEvent(data, reply);
478     ASSERT_EQ(ERR_INVALID_DATA, res);
479 }
480 
481 /**
482  * @tc.name: HandleNotifyPiPWindowPrepareClose003
483  * @tc.desc: sessionStub sessionStubTest
484  * @tc.type: FUNC
485  * @tc.require: #I6JLSI
486  */
HWTEST_F(SessionStubTest, HandleNotifyPiPWindowPrepareClose003, Function | SmallTest | Level2)487 HWTEST_F(SessionStubTest, HandleNotifyPiPWindowPrepareClose003, Function | SmallTest | Level2)
488 {
489     MessageParcel data;
490     MessageParcel reply;
491     data.WriteBool(true);
492     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
493     auto res = session_->HandleNotifyPiPWindowPrepareClose(data, reply);
494     ASSERT_EQ(ERR_NONE, res);
495 }
496 
497 /**
498  * @tc.name: HandleUpdatePiPRect001
499  * @tc.desc: sessionStub sessionStubTest
500  * @tc.type: FUNC
501  * @tc.require: #I6JLSI
502  */
HWTEST_F(SessionStubTest, HandleUpdatePiPRect001, Function | SmallTest | Level2)503 HWTEST_F(SessionStubTest, HandleUpdatePiPRect001, Function | SmallTest | Level2)
504 {
505     MessageParcel data;
506     MessageParcel reply;
507     float width = 0.55;
508     float height = 0.55;
509     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
510     data.WriteInt32(-1);
511     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
512     data.WriteInt32(10);
513     data.WriteInt32(-1);
514     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
515     data.WriteInt32(10);
516     data.WriteInt32(20);
517     data.WriteUint32(width);
518     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
519     data.WriteInt32(10);
520     data.WriteInt32(20);
521     data.WriteUint32(30);
522     data.WriteUint32(height);
523     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
524 }
525 
526 /**
527  * @tc.name: HandleUpdatePiPRect002
528  * @tc.desc: sessionStub sessionStubTest
529  * @tc.type: FUNC
530  * @tc.require: #I6JLSI
531  */
HWTEST_F(SessionStubTest, HandleUpdatePiPRect002, Function | SmallTest | Level2)532 HWTEST_F(SessionStubTest, HandleUpdatePiPRect002, Function | SmallTest | Level2)
533 {
534     MessageParcel data;
535     MessageParcel reply;
536     data.WriteInt32(10);
537     data.WriteInt32(20);
538     data.WriteUint32(30);
539     data.WriteUint32(40);
540     data.WriteUint32(22);
541     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
542     data.WriteInt32(10);
543     data.WriteInt32(20);
544     data.WriteUint32(30);
545     data.WriteUint32(40);
546     data.WriteUint32(3);
547     ASSERT_EQ(ERR_NONE, session_->HandleUpdatePiPRect(data, reply));
548 }
549 
550 /**
551  * @tc.name: HandleUpdatePiPControlStatus
552  * @tc.desc: sessionStub sessionStubTest
553  * @tc.type: FUNC
554  * @tc.require: #I6JLSI
555  */
HWTEST_F(SessionStubTest, HandleUpdatePiPControlStatus, Function | SmallTest | Level2)556 HWTEST_F(SessionStubTest, HandleUpdatePiPControlStatus, Function | SmallTest | Level2)
557 {
558     ASSERT_NE(session_, nullptr);
559     MessageParcel data;
560     MessageParcel reply;
561     uint32_t controlType = -1;
562     int32_t status = 1;
563     data.WriteUint32(controlType);
564     data.WriteInt32(status);
565     auto res = session_->HandleUpdatePiPControlStatus(data, reply);
566     ASSERT_EQ(ERR_INVALID_DATA, res);
567     data.WriteUint32(10);
568     data.WriteInt32(status);
569     res = session_->HandleUpdatePiPControlStatus(data, reply);
570     ASSERT_EQ(ERR_INVALID_DATA, res);
571     data.WriteUint32(2);
572     data.WriteInt32(-4);
573     res = session_->HandleUpdatePiPControlStatus(data, reply);
574     ASSERT_EQ(ERR_INVALID_DATA, res);
575     data.WriteUint32(2);
576     data.WriteInt32(4);
577     res = session_->HandleUpdatePiPControlStatus(data, reply);
578     ASSERT_EQ(ERR_INVALID_DATA, res);
579     data.WriteUint32(2);
580     data.WriteInt32(1);
581     res = session_->HandleUpdatePiPControlStatus(data, reply);
582     ASSERT_EQ(ERR_NONE, res);
583 }
584 
585 /**
586  * @tc.name: HandleSetAutoStartPiP
587  * @tc.desc: sessionStub sessionStubTest
588  * @tc.type: FUNC
589  * @tc.require: #I6JLSI
590  */
HWTEST_F(SessionStubTest, HandleSetAutoStartPiP, Function | SmallTest | Level2)591 HWTEST_F(SessionStubTest, HandleSetAutoStartPiP, Function | SmallTest | Level2)
592 {
593     ASSERT_NE(session_, nullptr);
594     MessageParcel data;
595     MessageParcel reply;
596     ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetAutoStartPiP(data, reply));
597     bool isAutoStartValid = true;
598     data.WriteInt32(isAutoStartValid);
599     ASSERT_EQ(ERR_NONE, session_->HandleSetAutoStartPiP(data, reply));
600 }
601 
602 /**
603  * @tc.name: HandleProcessPointDownSession006
604  * @tc.desc: sessionStub sessionStubTest
605  * @tc.type: FUNC
606  * @tc.require: #I6JLSI
607  */
HWTEST_F(SessionStubTest, HandleProcessPointDownSession006, Function | SmallTest | Level2)608 HWTEST_F(SessionStubTest, HandleProcessPointDownSession006, Function | SmallTest | Level2)
609 {
610     MessageParcel data;
611     MessageParcel reply;
612     data.WriteInt32(10);
613     data.WriteInt32(20);
614     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
615     auto res = session_->HandleProcessPointDownSession(data, reply);
616     ASSERT_EQ(ERR_NONE, res);
617 }
618 
619 /**
620  * @tc.name: HandleSendPointerEvenForMoveDrag007
621  * @tc.desc: sessionStub sessionStubTest
622  * @tc.type: FUNC
623  * @tc.require: #I6JLSI
624  */
HWTEST_F(SessionStubTest, HandleSendPointerEvenForMoveDrag007, Function | SmallTest | Level2)625 HWTEST_F(SessionStubTest, HandleSendPointerEvenForMoveDrag007, Function | SmallTest | Level2)
626 {
627     MessageParcel data;
628     MessageParcel reply;
629     data.WriteBool(true);
630     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
631     auto res = session_->HandleSendPointerEvenForMoveDrag(data, reply);
632     ASSERT_EQ(ERR_INVALID_DATA, res);
633 }
634 
635 /**
636  * @tc.name: HandleUpdateRectChangeListenerRegistered008
637  * @tc.desc: sessionStub sessionStubTest
638  * @tc.type: FUNC
639  * @tc.require: #I6JLSI
640  */
HWTEST_F(SessionStubTest, HandleUpdateRectChangeListenerRegistered008, Function | SmallTest | Level2)641 HWTEST_F(SessionStubTest, HandleUpdateRectChangeListenerRegistered008, Function | SmallTest | Level2)
642 {
643     MessageParcel data;
644     MessageParcel reply;
645     data.WriteBool(true);
646     sptr<IRemoteObjectMocker> iRemoteObjectMocker = new IRemoteObjectMocker();
647     auto res = session_->HandleUpdateRectChangeListenerRegistered(data, reply);
648     ASSERT_EQ(ERR_NONE, res);
649 }
650 
651 /**
652  * @tc.name: HandleNotifySyncOn012
653  * @tc.desc: sessionStub sessionStubTest
654  * @tc.type: FUNC
655  * @tc.require: #I6JLSI
656  */
HWTEST_F(SessionStubTest, HandleNotifySyncOn012, Function | SmallTest | Level2)657 HWTEST_F(SessionStubTest, HandleNotifySyncOn012, Function | SmallTest | Level2)
658 {
659     MessageParcel data;
660     MessageParcel reply;
661     data.WriteBool(true);
662     auto res = session_->HandleNotifySyncOn(data, reply);
663     ASSERT_EQ(ERR_NONE, res);
664 }
665 
666 /**
667  * @tc.name: HandleNotifyAsyncOn013
668  * @tc.desc: sessionStub sessionStubTest
669  * @tc.type: FUNC
670  * @tc.require: #I6JLSI
671  */
HWTEST_F(SessionStubTest, HandleNotifyAsyncOn013, Function | SmallTest | Level2)672 HWTEST_F(SessionStubTest, HandleNotifyAsyncOn013, Function | SmallTest | Level2)
673 {
674     MessageParcel data;
675     MessageParcel reply;
676     data.WriteBool(true);
677     auto res = session_->HandleNotifyAsyncOn(data, reply);
678     ASSERT_EQ(ERR_NONE, res);
679 }
680 
681 /**
682  * @tc.name: HandleNotifyExtensionTimeout014
683  * @tc.desc: sessionStub sessionStubTest
684  * @tc.type: FUNC
685  * @tc.require: #I6JLSI
686  */
HWTEST_F(SessionStubTest, HandleNotifyExtensionTimeout014, Function | SmallTest | Level2)687 HWTEST_F(SessionStubTest, HandleNotifyExtensionTimeout014, Function | SmallTest | Level2)
688 {
689     MessageParcel data;
690     MessageParcel reply;
691     data.WriteBool(true);
692     auto res = session_->HandleNotifyExtensionTimeout(data, reply);
693     ASSERT_EQ(ERR_NONE, res);
694 }
695 
696 /**
697  * @tc.name: HandleGetAppForceLandscapeConfig
698  * @tc.desc: sessionStub sessionStubTest
699  * @tc.type: FUNC
700  * @tc.require: #I6JLSI
701  */
HWTEST_F(SessionStubTest, HandleGetAppForceLandscapeConfig, Function | SmallTest | Level2)702 HWTEST_F(SessionStubTest, HandleGetAppForceLandscapeConfig, Function | SmallTest | Level2)
703 {
704     MessageParcel data;
705     MessageParcel reply;
706     ASSERT_NE(session_, nullptr);
707     auto res = session_->HandleGetAppForceLandscapeConfig(data, reply);
708     ASSERT_EQ(ERR_NONE, res);
709 }
710 
711 /**
712  * @tc.name: HandleUpdateSessionRect
713  * @tc.desc: test for HandleUpdateSessionRect
714  * @tc.type: FUNC
715  * @tc.require: #I6JLSI
716  */
HWTEST_F(SessionStubTest, HandleUpdateSessionRect, Function | SmallTest | Level2)717 HWTEST_F(SessionStubTest, HandleUpdateSessionRect, Function | SmallTest | Level2)
718 {
719     MessageParcel data;
720     MessageParcel reply;
721     ASSERT_NE(session_, nullptr);
722     data.WriteUint32(10);
723     data.WriteUint32(20);
724     data.WriteUint32(30);
725     data.WriteUint32(40);
726     data.WriteUint32(0);
727     data.WriteBool(true);
728     auto res = session_->HandleUpdateSessionRect(data, reply);
729     ASSERT_EQ(ERR_NONE, res);
730 }
731 
732 /**
733  * @tc.name: HandleSetDialogSessionBackGestureEnabled01
734  * @tc.desc: sessionStub sessionStubTest
735  * @tc.type: FUNC
736  * @tc.require: #I6JLSI
737  */
HWTEST_F(SessionStubTest, HandleSetDialogSessionBackGestureEnabled01, Function | SmallTest | Level2)738 HWTEST_F(SessionStubTest, HandleSetDialogSessionBackGestureEnabled01, Function | SmallTest | Level2)
739 {
740     MessageParcel data;
741     MessageParcel reply;
742     data.WriteBool(true);
743     auto res = session_->HandleSetDialogSessionBackGestureEnabled(data, reply);
744     ASSERT_EQ(ERR_NONE, res);
745 }
746 
747 /**
748  * @tc.name: HandleUpdatePropertyByAction01
749  * @tc.desc: sessionStub sessionStubTest
750  * @tc.type: FUNC
751  * @tc.require: #I6JLSI
752  */
HWTEST_F(SessionStubTest, HandleUpdatePropertyByAction01, Function | SmallTest | Level2)753 HWTEST_F(SessionStubTest, HandleUpdatePropertyByAction01, Function | SmallTest | Level2)
754 {
755     MessageParcel data;
756     MessageParcel reply;
757     data.WriteBool(true);
758     ASSERT_NE(session_, nullptr);
759     auto res = session_->HandleUpdatePropertyByAction(data, reply);
760     ASSERT_EQ(0, res);
761 }
762 
763 /**
764  * @tc.name: HandleUpdatePropertyByAction02
765  * @tc.desc: sessionStub sessionStubTest
766  * @tc.type: FUNC
767  * @tc.require: #I6JLSI
768  */
HWTEST_F(SessionStubTest, HandleUpdatePropertyByAction02, Function | SmallTest | Level2)769 HWTEST_F(SessionStubTest, HandleUpdatePropertyByAction02, Function | SmallTest | Level2)
770 {
771     MessageParcel data;
772     MessageParcel reply;
773     data.WriteBool(false);
774     ASSERT_NE(session_, nullptr);
775     auto res = session_->HandleUpdatePropertyByAction(data, reply);
776     ASSERT_EQ(0, res);
777 }
778 
779 /**
780  * @tc.name: HandleRequestFocus
781  * @tc.desc: sessionStub HandleRequestFocusTest
782  * @tc.type: FUNC
783  * @tc.require: #IAPLFA
784  */
HWTEST_F(SessionStubTest, HandleRequestFocus, Function | SmallTest | Level2)785 HWTEST_F(SessionStubTest, HandleRequestFocus, Function | SmallTest | Level2)
786 {
787     MessageParcel data;
788     MessageParcel reply;
789     data.WriteBool(false);
790     ASSERT_NE(session_, nullptr);
791     auto res = session_->HandleRequestFocus(data, reply);
792     ASSERT_EQ(0, res);
793 }
794 
795 /**
796  * @tc.name: HandleUpdateClientRect01
797  * @tc.desc: sessionStub sessionStubTest
798  * @tc.type: FUNC
799  */
HWTEST_F(SessionStubTest, HandleUpdateClientRect01, Function | SmallTest | Level2)800 HWTEST_F(SessionStubTest, HandleUpdateClientRect01, Function | SmallTest | Level2)
801 {
802     MessageParcel data;
803     MessageParcel reply;
804     ASSERT_NE(session_, nullptr);
805     auto res = session_->HandleUpdateClientRect(data, reply);
806     ASSERT_EQ(ERR_INVALID_DATA, res);
807 
808     data.WriteInt32(100);
809     data.WriteInt32(100);
810     data.WriteUint32(800);
811     data.WriteUint32(800);
812     res = session_->HandleUpdateClientRect(data, reply);
813     ASSERT_EQ(ERR_NONE, res);
814 }
815 }
816 } // namespace Rosen
817 } // namespace OHOS
818