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 <gmock/gmock.h>
18 #include <ipc_types.h>
19 #include <pointer_event.h>
20 #include <ui/rs_surface_node.h>
21 #include "ability_start_setting.h"
22 #include "iremote_object_mocker.h"
23 #include "mock/mock_session_stage.h"
24 #include "mock/mock_session_stub.h"
25 #include "mock/mock_window_event_channel.h"
26 #include "parcel/accessibility_event_info_parcel.h"
27 #include "session/host/include/zidl/session_ipc_interface_code.h"
28 #include "session/host/include/zidl/session_stub.h"
29 #include "transaction/rs_transaction.h"
30 #include "want.h"
31 #include "wm_common.h"
32 #include "ws_common.h"
33 #include "ui/rs_canvas_node.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS {
39 namespace Rosen {
40 namespace {
41 const std::string UNDEFINED = "undefined";
42 const uint32_t MAX_INT = -1;
43 }
44
45 namespace OHOS::Accessibility {
46 class AccessibilityEventInfo;
47 }
48 class SessionStubTest : public testing::Test {
49 public:
50 static void SetUpTestCase();
51 static void TearDownTestCase();
52 void SetUp() override;
53 void TearDown() override;
54
55 private:
56 sptr<SessionStub> session_ = nullptr;
57 };
58
SetUpTestCase()59 void SessionStubTest::SetUpTestCase() {}
60
TearDownTestCase()61 void SessionStubTest::TearDownTestCase() {}
62
SetUp()63 void SessionStubTest::SetUp()
64 {
65 session_ = sptr<SessionStubMocker>::MakeSptr();
66 EXPECT_NE(nullptr, session_);
67 }
68
TearDown()69 void SessionStubTest::TearDown()
70 {
71 session_ = nullptr;
72 }
73
74 namespace {
75 /**
76 * @tc.name: OnRemoteRequest01
77 * @tc.desc: sessionStub OnRemoteRequest01
78 * @tc.type: FUNC
79 * @tc.require: #I6JLSI
80 */
81 HWTEST_F(SessionStubTest, OnRemoteRequest01, TestSize.Level1)
82 {
83 uint32_t code = 1;
84 MessageParcel data;
85 MessageParcel reply;
86 MessageOption option = { MessageOption::TF_SYNC };
87 auto res = session_->OnRemoteRequest(code, data, reply, option);
88 ASSERT_EQ(ERR_NONE, res);
89 data.WriteInterfaceToken(u"OHOS.ISession");
90 res = session_->OnRemoteRequest(code, data, reply, option);
91 ASSERT_EQ(ERR_NONE, res);
92 }
93
94 /**
95 * @tc.name: ProcessRemoteRequestTest01
96 * @tc.desc: sessionStub ProcessRemoteRequestTest01
97 * @tc.type: FUNC
98 * @tc.require: #I6JLSI
99 */
100 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest01, TestSize.Level1)
101 {
102 MessageParcel data;
103 MessageParcel reply;
104 MessageOption option = { MessageOption::TF_SYNC };
105 data.WriteBool(true);
106 auto res = session_->ProcessRemoteRequest(
107 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
108 ASSERT_EQ(ERR_NONE, res);
109
110 data.WriteBool(false);
111 data.WriteBool(true);
112 data.WriteString("");
113 res = session_->ProcessRemoteRequest(
114 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_FOREGROUND), data, reply, option);
115 ASSERT_EQ(ERR_NONE, res);
116
117 data.WriteBool(true);
118 data.WriteString("");
119 res = session_->ProcessRemoteRequest(
120 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKGROUND), data, reply, option);
121 ASSERT_EQ(ERR_NONE, res);
122
123 data.WriteBool(true);
124 data.WriteString("");
125 res = session_->ProcessRemoteRequest(
126 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DISCONNECT), data, reply, option);
127 ASSERT_EQ(ERR_NONE, res);
128 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
129 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
130 res = session_->ProcessRemoteRequest(
131 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_CONNECT), data, reply, option);
132 ASSERT_EQ(ERR_INVALID_DATA, res);
133 ASSERT_EQ(data.WriteUint32(100), true);
134 res = session_->ProcessRemoteRequest(
135 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SESSION_EVENT), data, reply, option);
136 ASSERT_EQ(ERR_NONE, res);
137 AAFwk::Want options;
138 EXPECT_NE(data.WriteString("HandleSessionException"), false);
139 EXPECT_NE(data.WriteParcelable(&options), false);
140 EXPECT_NE(data.WriteBool(false), false);
141 EXPECT_NE(data.WriteInt32(33), false);
142 res = session_->ProcessRemoteRequest(
143 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TERMINATE), data, reply, option);
144 ASSERT_EQ(ERR_NONE, res);
145 res = session_->ProcessRemoteRequest(
146 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_SESSION_RECT), data, reply, option);
147 ASSERT_EQ(ERR_NONE, res);
148 res = session_->ProcessRemoteRequest(
149 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_TO_APP_TOP), data, reply, option);
150 ASSERT_EQ(ERR_NONE, res);
151 }
152
153 /**
154 * @tc.name: ProcessRemoteRequestTest02
155 * @tc.desc: sessionStub ProcessRemoteRequestTest02
156 * @tc.type: FUNC
157 * @tc.require: #I6JLSI
158 */
159 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest02, TestSize.Level1)
160 {
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option = { MessageOption::TF_SYNC };
164 data.WriteBool(true);
165 auto res = session_->ProcessRemoteRequest(
166 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
167 ASSERT_EQ(ERR_NONE, res);
168 res = session_->ProcessRemoteRequest(
169 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_APP_MAIN_WINDOW), data, reply, option);
170 ASSERT_EQ(ERR_NONE, res);
171 data.WriteBool(true);
172 res = session_->ProcessRemoteRequest(
173 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKPRESSED), data, reply, option);
174 ASSERT_EQ(ERR_NONE, res);
175 res = session_->ProcessRemoteRequest(
176 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_MARK_PROCESSED), data, reply, option);
177 ASSERT_EQ(ERR_INVALID_DATA, res);
178 res = session_->ProcessRemoteRequest(
179 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_MAXIMIZE_MODE), data, reply, option);
180 ASSERT_EQ(ERR_INVALID_DATA, res);
181 res = session_->ProcessRemoteRequest(
182 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_MAXIMIZE_MODE), data, reply, option);
183 ASSERT_EQ(ERR_NONE, res);
184 res = session_->ProcessRemoteRequest(
185 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NEED_AVOID), data, reply, option);
186 ASSERT_EQ(ERR_INVALID_DATA, res);
187 res = session_->ProcessRemoteRequest(
188 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_AVOID_AREA), data, reply, option);
189 ASSERT_EQ(ERR_INVALID_DATA, res);
190 res = session_->ProcessRemoteRequest(
191 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_ASPECT_RATIO), data, reply, option);
192 ASSERT_EQ(ERR_INVALID_DATA, res);
193 res = session_->ProcessRemoteRequest(
194 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_CUSTOM_ANIMATION), data, reply, option);
195 ASSERT_EQ(ERR_NONE, res);
196 res = session_->ProcessRemoteRequest(
197 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_EXTENSION_DATA), data, reply, option);
198 ASSERT_EQ(ERR_INVALID_VALUE, res);
199 res = session_->ProcessRemoteRequest(
200 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_DIED), data, reply, option);
201 ASSERT_EQ(ERR_NONE, res);
202 data.WriteInt32(1);
203 res = session_->ProcessRemoteRequest(
204 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_TIMEOUT), data, reply, option);
205 ASSERT_EQ(ERR_NONE, res);
206 }
207
208 /**
209 * @tc.name: ProcessRemoteRequestTest03
210 * @tc.desc: sessionStub ProcessRemoteRequestTest03
211 * @tc.type: FUNC
212 * @tc.require: #I6JLSI
213 */
214 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest03, TestSize.Level1)
215 {
216 MessageParcel data;
217 MessageParcel reply;
218 MessageOption option = { MessageOption::TF_SYNC };
219 data.WriteBool(true);
220 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
221 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
222 ASSERT_EQ(data.WriteUint32(1), true);
223 AAFwk::Want options;
224 EXPECT_NE(data.WriteString("HandleSessionException"), false);
225 EXPECT_NE(data.WriteParcelable(&options), false);
226 ASSERT_EQ(data.WriteUint64(2), true);
227 auto res =
228 session_->ProcessRemoteRequest(static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SHOW), data, reply, option);
229 ASSERT_EQ(ERR_INVALID_DATA, res);
230 res =
231 session_->ProcessRemoteRequest(static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_HIDE), data, reply, option);
232 ASSERT_EQ(ERR_NONE, res);
233 res = session_->ProcessRemoteRequest(
234 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DRAWING_COMPLETED), data, reply, option);
235 ASSERT_EQ(ERR_NONE, res);
236 res = session_->ProcessRemoteRequest(
237 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_APP_REMOVE_STARTING_WINDOW), data, reply, option);
238 ASSERT_EQ(ERR_NONE, res);
239 res = session_->ProcessRemoteRequest(
240 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_RECTCHANGE_LISTENER_REGISTERED),
241 data,
242 reply,
243 option);
244 ASSERT_EQ(ERR_NONE, res);
245 res = session_->ProcessRemoteRequest(
246 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_LANDSCAPE_MULTI_WINDOW), data, reply, option);
247 ASSERT_EQ(ERR_NONE, res);
248 res = session_->ProcessRemoteRequest(
249 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ACTIVE_PENDING_SESSION), data, reply, option);
250 ASSERT_EQ(ERR_INVALID_DATA, res);
251 MessageParcel tmp;
252 tmp.WriteUint32(1);
253 res = session_->ProcessRemoteRequest(
254 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_ABILITY_RESULT), tmp, reply, option);
255 ASSERT_EQ(ERR_INVALID_VALUE, res);
256 }
257
258 /**
259 * @tc.name: ProcessRemoteRequestTest04
260 * @tc.desc: sessionStub ProcessRemoteRequestTest04
261 * @tc.type: FUNC
262 * @tc.require: #I6JLSI
263 */
264 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest04, TestSize.Level1)
265 {
266 MessageParcel data;
267 MessageParcel reply;
268 MessageOption option = { MessageOption::TF_SYNC };
269 ASSERT_EQ(data.WriteInt32(1), true);
270 ASSERT_EQ(data.WriteInt32(2), true);
271 auto res = session_->ProcessRemoteRequest(
272 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_PROCESS_POINT_DOWN_SESSION), data, reply, option);
273 ASSERT_EQ(ERR_NONE, res);
274 res = session_->ProcessRemoteRequest(
275 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SEND_POINTEREVENT_FOR_MOVE_DRAG), data, reply, option);
276 ASSERT_EQ(ERR_INVALID_DATA, res);
277 res = session_->ProcessRemoteRequest(
278 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
279 ASSERT_EQ(ERR_INVALID_DATA, res);
280 res = session_->ProcessRemoteRequest(
281 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
282 ASSERT_EQ(ERR_INVALID_DATA, res);
283 res = session_->ProcessRemoteRequest(
284 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ADJUST_KEYBOARD_LAYOUT), data, reply, option);
285 ASSERT_EQ(ERR_INVALID_DATA, res);
286 res = session_->ProcessRemoteRequest(
287 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_ASYNC_ON), data, reply, option);
288 ASSERT_EQ(ERR_NONE, res);
289 res = session_->ProcessRemoteRequest(
290 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_SYNC_ON), data, reply, option);
291 ASSERT_EQ(ERR_NONE, res);
292 res = session_->ProcessRemoteRequest(
293 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRIGGER_BIND_MODAL_UI_EXTENSION), data, reply, option);
294 ASSERT_EQ(ERR_NONE, res);
295 }
296
297 /**
298 * @tc.name: ProcessRemoteRequestTest05
299 * @tc.desc: sessionStub ProcessRemoteRequestTest05
300 * @tc.type: FUNC
301 * @tc.require: #I6JLSI
302 */
303 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest05, TestSize.Level1)
304 {
305 MessageParcel data;
306 MessageParcel reply;
307 MessageOption option = { MessageOption::TF_SYNC };
308 data.WriteBool(true);
309 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
310 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
311 ASSERT_EQ(data.WriteUint32(1), true);
312 AAFwk::Want options;
313 EXPECT_NE(data.WriteString("HandleSessionException"), false);
314 EXPECT_NE(data.WriteParcelable(&options), false);
315 ASSERT_EQ(data.WriteUint64(2), true);
316 auto res = session_->ProcessRemoteRequest(
317 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_PIP_WINDOW_PREPARE_CLOSE), data, reply, option);
318 ASSERT_EQ(ERR_NONE, res);
319 res = session_->ProcessRemoteRequest(
320 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_LAYOUT_FULL_SCREEN_CHANGE), data, reply, option);
321 ASSERT_EQ(ERR_NONE, res);
322 res = session_->ProcessRemoteRequest(
323 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RESTORE_MAIN_WINDOW), data, reply, option);
324 ASSERT_EQ(ERR_NONE, res);
325 res = session_->ProcessRemoteRequest(
326 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_DIALOG_SESSION_BACKGESTURE_ENABLE),
327 data,
328 reply,
329 option);
330 ASSERT_EQ(ERR_NONE, res);
331 }
332
333 /**
334 * @tc.name: ProcessRemoteRequestTest06
335 * @tc.desc: sessionStub ProcessRemoteRequestTest06
336 * @tc.type: FUNC
337 * @tc.require: #I6JLSI
338 */
339 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest06, TestSize.Level1)
340 {
341 MessageParcel data;
342 MessageParcel reply;
343 MessageOption option = { MessageOption::TF_SYNC };
344 AAFwk::Want want;
345 data.WriteParcelable(&want);
346 data.WriteBool(true);
347 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
348 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
349 ASSERT_EQ(data.WriteUint32(1), true);
350 ASSERT_EQ(data.WriteUint32(1), true);
351 AAFwk::Want options;
352 EXPECT_NE(data.WriteString("HandleSessionException"), false);
353 EXPECT_NE(data.WriteString("HandleSessionException"), false);
354 EXPECT_NE(data.WriteParcelable(&options), false);
355 ASSERT_EQ(data.WriteUint64(2), true);
356 auto res = session_->ProcessRemoteRequest(
357 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_EXCEPTION), data, reply, option);
358 ASSERT_EQ(ERR_NONE, res);
359 ASSERT_EQ(data.WriteUint32(1), true);
360 res = session_->ProcessRemoteRequest(
361 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
362 ASSERT_EQ(ERR_NONE, res);
363 ASSERT_EQ(data.WriteInt32(1), true);
364 res = session_->ProcessRemoteRequest(
365 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
366 ASSERT_EQ(ERR_NONE, res);
367 }
368
369 /**
370 * @tc.name: ProcessRemoteRequestTest07
371 * @tc.desc: sessionStub ProcessRemoteRequestTest07
372 * @tc.type: FUNC
373 * @tc.require: #I6JLSI
374 */
375 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest07, TestSize.Level1)
376 {
377 MessageParcel data;
378 MessageParcel reply;
379 MessageOption option = { MessageOption::TF_SYNC };
380 ASSERT_EQ(data.WriteInt32(1), true);
381 ASSERT_EQ(data.WriteInt32(1), true);
382 ASSERT_EQ(data.WriteUint32(1), true);
383 ASSERT_EQ(data.WriteUint32(1), true);
384 ASSERT_EQ(data.WriteUint32(1), true);
385 auto res = session_->ProcessRemoteRequest(
386 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_RECT), data, reply, option);
387 ASSERT_EQ(ERR_NONE, res);
388 ASSERT_EQ(data.WriteUint32(1), true);
389 ASSERT_EQ(data.WriteInt32(1), true);
390 res = session_->ProcessRemoteRequest(
391 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_CONTROL_STATUS), data, reply, option);
392 ASSERT_EQ(ERR_NONE, res);
393 ASSERT_EQ(data.WriteBool(true), true);
394 ASSERT_EQ(data.WriteBool(true), true);
395 res = session_->ProcessRemoteRequest(
396 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TITLE_AND_DOCK_HOVER_SHOW_CHANGE), data, reply, option);
397 ASSERT_EQ(ERR_NONE, res);
398 ASSERT_EQ(data.WriteBool(true), true);
399 ASSERT_EQ(data.WriteBool(false), true);
400 res = session_->ProcessRemoteRequest(
401 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_RECT_AUTO_SAVE), data, reply, option);
402 ASSERT_EQ(ERR_NONE, res);
403 ASSERT_EQ(data.WriteInt32(1), true);
404 res = session_->ProcessRemoteRequest(
405 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_EVENT_ASYNC), data, reply, option);
406 ASSERT_EQ(ERR_NONE, res);
407 ASSERT_EQ(data.WriteFloat(1.0f), true);
408 res = session_->ProcessRemoteRequest(
409 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_CORNER_RADIUS), data, reply, option);
410 ASSERT_EQ(ERR_NONE, res);
411 ASSERT_EQ(data.WriteString("test"), true);
412 res = session_->ProcessRemoteRequest(
413 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_FLAG), data, reply, option);
414 ASSERT_EQ(ERR_NONE, res);
415 ASSERT_EQ(data.WriteBool(true), true);
416 res = session_->ProcessRemoteRequest(
417 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_FOLLOW_PARENT_MULTI_SCREEN_POLICY),
418 data,
419 reply,
420 option);
421 ASSERT_EQ(ERR_NONE, res);
422 ShadowsInfo shadowsInfo =
423 { 20.0, "#FF0000", 0.0, 0.0, true, true, true, true }; // 20.0 is shadow radius, 0.0 is shadow offset
424 ASSERT_EQ(data.WriteParcelable(&shadowsInfo), true);
425 res = session_->ProcessRemoteRequest(
426 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_SHADOWS), data, reply, option);
427 ASSERT_EQ(ERR_NONE, res);
428 }
429
430 /**
431 * @tc.name: ProcessRemoteRequestTest08
432 * @tc.desc: sessionStub ProcessRemoteRequestTest08
433 * @tc.type: FUNC
434 * @tc.require: #I6JLSI
435 */
436 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest08, TestSize.Level1)
437 {
438 MessageParcel data;
439 MessageParcel reply;
440 MessageOption option = { MessageOption::TF_SYNC };
441 FloatingBallTemplateInfo fbTemplateInfo {{1, "fb", "fb_content", "red"}, nullptr};
442 data.WriteParcelable(&fbTemplateInfo);
443 auto res = session_->ProcessRemoteRequest(
444 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_FLOATING_BALL), data, reply, option);
445 ASSERT_EQ(ERR_NONE, res);
446 data.WriteParcelable(nullptr);
447 res = session_->ProcessRemoteRequest(
448 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_FLOATING_BALL_PREPARE_CLOSE), data, reply, option);
449 ASSERT_EQ(ERR_NONE, res);
450 data.WriteParcelable(nullptr);
451 res = session_->ProcessRemoteRequest(
452 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_START_FLOATING_BALL_MAIN_WINDOW), data, reply, option);
453 ASSERT_EQ(ERR_INVALID_DATA, res);
454 data.WriteParcelable(nullptr);
455 res = session_->ProcessRemoteRequest(
456 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_FLOATING_BALL_WINDOW_ID), data, reply, option);
457 ASSERT_EQ(ERR_NONE, res);
458 data.WriteParcelable(nullptr);
459 res = session_->ProcessRemoteRequest(
460 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_ANCHOR_INFO), data, reply, option);
461 ASSERT_EQ(ERR_INVALID_DATA, res);
462 }
463
464 /**
465 * @tc.name: sessionStubTest02
466 * @tc.desc: sessionStub sessionStubTest02
467 * @tc.type: FUNC
468 * @tc.require: #I6JLSI
469 */
470 HWTEST_F(SessionStubTest, sessionStubTest02, TestSize.Level1)
471 {
472 MessageParcel data;
473 MessageParcel reply;
474 data.WriteBool(true);
475 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
476 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
477 ASSERT_EQ(data.WriteUint32(1), true);
478 AAFwk::Want options;
479 EXPECT_NE(data.WriteString("HandleSessionException"), false);
480 EXPECT_NE(data.WriteParcelable(&options), false);
481 ASSERT_EQ(data.WriteUint64(2), true);
482 auto res = session_->HandleRaiseAboveTarget(data, reply);
483 ASSERT_EQ(ERR_NONE, res);
484 res = session_->HandleRaiseAppMainWindowToTop(data, reply);
485 ASSERT_EQ(ERR_NONE, res);
486 res = session_->HandleBackPressed(data, reply);
487 if (!data.ReadBool()) {
488 ASSERT_EQ(ERR_INVALID_DATA, res);
489 }
490 res = session_->HandleGetGlobalMaximizeMode(data, reply);
491 ASSERT_EQ(ERR_NONE, res);
492 res = session_->HandleUpdateWindowSceneAfterCustomAnimation(data, reply);
493 ASSERT_EQ(ERR_NONE, res);
494 res = session_->HandleNotifyExtensionDied(data, reply);
495 ASSERT_EQ(ERR_NONE, res);
496 res = session_->HandleGetStatusBarHeight(data, reply);
497 ASSERT_EQ(ERR_NONE, res);
498 }
499
500 /**
501 * @tc.name: sessionStubTest03
502 * @tc.desc: sessionStub sessionStubTest03
503 * @tc.type: FUNC
504 * @tc.require: #I6JLSI
505 */
506 HWTEST_F(SessionStubTest, sessionStubTest03, TestSize.Level1)
507 {
508 MessageParcel data;
509 MessageParcel reply;
510
511 ASSERT_EQ(data.WriteUint32(1), true);
512 auto res = session_->HandleSetGlobalMaximizeMode(data, reply);
513 ASSERT_EQ(ERR_NONE, res);
514 res = session_->HandleTransferExtensionData(data, reply);
515 ASSERT_EQ(ERR_INVALID_VALUE, res);
516 ASSERT_EQ(data.WriteInt32(2), true);
517 res = session_->HandleMarkProcessed(data, reply);
518 ASSERT_EQ(ERR_NONE, res);
519 ASSERT_EQ(data.WriteBool(true), true);
520 res = session_->HandleNeedAvoid(data, reply);
521 ASSERT_EQ(ERR_NONE, res);
522 ASSERT_EQ(data.WriteUint32(2), true);
523 ASSERT_EQ(data.WriteInt32(0), true);
524 ASSERT_EQ(data.WriteInt32(0), true);
525 ASSERT_EQ(data.WriteInt32(10), true);
526 ASSERT_EQ(data.WriteInt32(10), true);
527 ASSERT_EQ(data.WriteInt32(12), true);
528 res = session_->HandleGetAvoidAreaByType(data, reply);
529 ASSERT_EQ(ERR_NONE, res);
530 ASSERT_EQ(data.WriteFloat(2.0f), true);
531 res = session_->HandleSetAspectRatio(data, reply);
532 ASSERT_EQ(ERR_NONE, res);
533 ASSERT_EQ(data.WriteInt32(2), true);
534 res = session_->HandleNotifyExtensionTimeout(data, reply);
535 ASSERT_EQ(ERR_NONE, res);
536 ASSERT_EQ(data.WriteInt32(2), true);
537 AAFwk::Want want;
538 data.WriteParcelable(&want);
539 res = session_->HandleTransferAbilityResult(data, reply);
540 ASSERT_EQ(ERR_NONE, res);
541 }
542
543 /**
544 * @tc.name: HandleTriggerBindModalUIExtension001
545 * @tc.desc: sessionStub sessionStubTest
546 * @tc.type: FUNC
547 * @tc.require: #I6JLSI
548 */
549 HWTEST_F(SessionStubTest, HandleTriggerBindModalUIExtension001, TestSize.Level1)
550 {
551 MessageParcel data;
552 MessageParcel reply;
553 data.WriteBool(true);
554 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
555 auto res = session_->HandleTriggerBindModalUIExtension(data, reply);
556 ASSERT_EQ(ERR_NONE, res);
557 }
558
559 /**
560 * @tc.name: HandleTransferAccessibilityEvent002
561 * @tc.desc: sessionStub sessionStubTest
562 * @tc.type: FUNC
563 * @tc.require: #I6JLSI
564 */
565 HWTEST_F(SessionStubTest, HandleTransferAccessibilityEvent003, TestSize.Level1)
566 {
567 MessageParcel data;
568 MessageParcel reply;
569 data.WriteBool(true);
570 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
571 auto res = session_->HandleTransferAccessibilityEvent(data, reply);
572 ASSERT_EQ(ERR_INVALID_DATA, res);
573 }
574
575 /**
576 * @tc.name: HandleNotifyPiPWindowPrepareClose003
577 * @tc.desc: sessionStub sessionStubTest
578 * @tc.type: FUNC
579 * @tc.require: #I6JLSI
580 */
581 HWTEST_F(SessionStubTest, HandleNotifyPiPWindowPrepareClose003, TestSize.Level1)
582 {
583 MessageParcel data;
584 MessageParcel reply;
585 data.WriteBool(true);
586 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
587 auto res = session_->HandleNotifyPiPWindowPrepareClose(data, reply);
588 ASSERT_EQ(ERR_NONE, res);
589 }
590
591 /**
592 * @tc.name: HandleUpdatePiPRect001
593 * @tc.desc: sessionStub sessionStubTest
594 * @tc.type: FUNC
595 * @tc.require: #I6JLSI
596 */
597 HWTEST_F(SessionStubTest, HandleUpdatePiPRect001, TestSize.Level1)
598 {
599 MessageParcel data;
600 MessageParcel reply;
601 float width = 0.55;
602 float height = 0.55;
603 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
604 data.WriteInt32(-1);
605 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
606 data.WriteInt32(10);
607 data.WriteInt32(-1);
608 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
609 data.WriteInt32(10);
610 data.WriteInt32(20);
611 data.WriteUint32(width);
612 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
613 data.WriteInt32(10);
614 data.WriteInt32(20);
615 data.WriteUint32(30);
616 data.WriteUint32(height);
617 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
618 }
619
620 /**
621 * @tc.name: HandleUpdatePiPRect002
622 * @tc.desc: sessionStub sessionStubTest
623 * @tc.type: FUNC
624 * @tc.require: #I6JLSI
625 */
626 HWTEST_F(SessionStubTest, HandleUpdatePiPRect002, TestSize.Level1)
627 {
628 MessageParcel data;
629 MessageParcel reply;
630 data.WriteInt32(10);
631 data.WriteInt32(20);
632 data.WriteUint32(30);
633 data.WriteUint32(40);
634 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
635 data.WriteInt32(10);
636 data.WriteInt32(20);
637 data.WriteUint32(30);
638 data.WriteUint32(40);
639 data.WriteUint32(3);
640 ASSERT_EQ(ERR_NONE, session_->HandleUpdatePiPRect(data, reply));
641 }
642
643 /**
644 * @tc.name: HandleUpdatePiPControlStatus
645 * @tc.desc: sessionStub sessionStubTest
646 * @tc.type: FUNC
647 * @tc.require: #I6JLSI
648 */
649 HWTEST_F(SessionStubTest, HandleUpdatePiPControlStatus, TestSize.Level1)
650 {
651 ASSERT_NE(session_, nullptr);
652 MessageParcel data;
653 MessageParcel reply;
654 uint32_t controlType = -1;
655 int32_t status = 1;
656 data.WriteUint32(controlType);
657 data.WriteInt32(status);
658 auto res = session_->HandleUpdatePiPControlStatus(data, reply);
659 ASSERT_EQ(ERR_INVALID_DATA, res);
660 data.WriteUint32(10);
661 data.WriteInt32(status);
662 res = session_->HandleUpdatePiPControlStatus(data, reply);
663 ASSERT_EQ(ERR_INVALID_DATA, res);
664 data.WriteUint32(2);
665 data.WriteInt32(-4);
666 res = session_->HandleUpdatePiPControlStatus(data, reply);
667 ASSERT_EQ(ERR_INVALID_DATA, res);
668 data.WriteUint32(2);
669 data.WriteInt32(4);
670 res = session_->HandleUpdatePiPControlStatus(data, reply);
671 ASSERT_EQ(ERR_INVALID_DATA, res);
672 data.WriteUint32(2);
673 data.WriteInt32(1);
674 res = session_->HandleUpdatePiPControlStatus(data, reply);
675 ASSERT_EQ(ERR_NONE, res);
676 }
677
678 /**
679 * @tc.name: HandleSetAutoStartPiP
680 * @tc.desc: sessionStub sessionStubTest
681 * @tc.type: FUNC
682 * @tc.require: #I6JLSI
683 */
684 HWTEST_F(SessionStubTest, HandleSetAutoStartPiP, TestSize.Level1)
685 {
686 ASSERT_NE(session_, nullptr);
687 MessageParcel data;
688 MessageParcel reply;
689 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetAutoStartPiP(data, reply));
690 bool isAutoStartValid = true;
691 uint32_t priority = 0;
692 uint32_t width = 0;
693 uint32_t height = 0;
694 data.WriteInt32(10);
695 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetAutoStartPiP(data, reply));
696 data.WriteBool(isAutoStartValid);
697 data.WriteUint32(priority);
698 data.WriteUint32(width);
699 data.WriteUint32(height);
700 ASSERT_EQ(ERR_NONE, session_->HandleSetAutoStartPiP(data, reply));
701 }
702
703 /**
704 * @tc.name: HandleUpdatePiPTemplateInfo
705 * @tc.desc: sessionStub sessionStubTest
706 * @tc.type: FUNC
707 * @tc.require: #I6JLSI
708 */
709 HWTEST_F(SessionStubTest, HandleUpdatePiPTemplateInfo, Function | SmallTest | Level2)
710 {
711 ASSERT_NE(session_, nullptr);
712 MessageParcel data;
713 MessageParcel reply;
714 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPTemplateInfo(data, reply));
715 PiPTemplateInfo templateInfo;
716 data.WriteParcelable(&templateInfo);
717 ASSERT_EQ(ERR_NONE, session_->HandleUpdatePiPTemplateInfo(data, reply));
718 }
719
720 /**
721 * @tc.name: HandleSetWindowTransitionAnimation
722 * @tc.desc: sessionStub sessionStubTest
723 * @tc.type: FUNC
724 * @tc.require: #I6JLSI
725 */
726 HWTEST_F(SessionStubTest, HandleSetWindowTransitionAnimation, Function | SmallTest | Level2)
727 {
728 ASSERT_NE(session_, nullptr);
729 MessageParcel data;
730 MessageParcel reply;
731
732 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetWindowTransitionAnimation(data, reply));
733
734 data.WriteInt32(10);
735 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetWindowTransitionAnimation(data, reply));
736
737 TransitionAnimation animation;
738 data.WriteUint32(static_cast<uint32_t>(WindowTransitionType::DESTROY));
739 data.WriteParcelable(&animation);
740 ASSERT_EQ(ERR_NONE, session_->HandleSetWindowTransitionAnimation(data, reply));
741 }
742
743 /**
744 * @tc.name: HandleProcessPointDownSession006
745 * @tc.desc: sessionStub sessionStubTest
746 * @tc.type: FUNC
747 * @tc.require: #I6JLSI
748 */
749 HWTEST_F(SessionStubTest, HandleProcessPointDownSession006, TestSize.Level1)
750 {
751 MessageParcel data;
752 MessageParcel reply;
753 data.WriteInt32(10);
754 data.WriteInt32(20);
755 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
756 auto res = session_->HandleProcessPointDownSession(data, reply);
757 ASSERT_EQ(ERR_NONE, res);
758 }
759
760 /**
761 * @tc.name: HandleSendPointerEvenForMoveDrag007
762 * @tc.desc: sessionStub sessionStubTest
763 * @tc.type: FUNC
764 * @tc.require: #I6JLSI
765 */
766 HWTEST_F(SessionStubTest, HandleSendPointerEvenForMoveDrag007, TestSize.Level1)
767 {
768 MessageParcel data;
769 MessageParcel reply;
770 data.WriteBool(true);
771 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
772 auto res = session_->HandleSendPointerEvenForMoveDrag(data, reply);
773 ASSERT_EQ(ERR_INVALID_DATA, res);
774 }
775
776 /**
777 * @tc.name: HandleNotifySyncOn012
778 * @tc.desc: sessionStub sessionStubTest
779 * @tc.type: FUNC
780 * @tc.require: #I6JLSI
781 */
782 HWTEST_F(SessionStubTest, HandleNotifySyncOn012, TestSize.Level1)
783 {
784 MessageParcel data;
785 MessageParcel reply;
786 data.WriteBool(true);
787 auto res = session_->HandleNotifySyncOn(data, reply);
788 ASSERT_EQ(ERR_NONE, res);
789 }
790
791 /**
792 * @tc.name: HandleNotifyAsyncOn013
793 * @tc.desc: sessionStub sessionStubTest
794 * @tc.type: FUNC
795 * @tc.require: #I6JLSI
796 */
797 HWTEST_F(SessionStubTest, HandleNotifyAsyncOn013, TestSize.Level1)
798 {
799 MessageParcel data;
800 MessageParcel reply;
801 data.WriteBool(true);
802 auto res = session_->HandleNotifyAsyncOn(data, reply);
803 ASSERT_EQ(ERR_NONE, res);
804 }
805
806 /**
807 * @tc.name: HandleNotifyExtensionTimeout014
808 * @tc.desc: sessionStub sessionStubTest
809 * @tc.type: FUNC
810 * @tc.require: #I6JLSI
811 */
812 HWTEST_F(SessionStubTest, HandleNotifyExtensionTimeout014, TestSize.Level1)
813 {
814 MessageParcel data;
815 MessageParcel reply;
816 data.WriteBool(true);
817 auto res = session_->HandleNotifyExtensionTimeout(data, reply);
818 ASSERT_EQ(ERR_NONE, res);
819 }
820
821 /**
822 * @tc.name: HandleGetAppForceLandscapeConfig
823 * @tc.desc: sessionStub sessionStubTest
824 * @tc.type: FUNC
825 * @tc.require: #I6JLSI
826 */
827 HWTEST_F(SessionStubTest, HandleGetAppForceLandscapeConfig, TestSize.Level1)
828 {
829 MessageParcel data;
830 MessageParcel reply;
831 ASSERT_NE(session_, nullptr);
832 auto res = session_->HandleGetAppForceLandscapeConfig(data, reply);
833 ASSERT_EQ(ERR_NONE, res);
834 }
835
836 /**
837 * @tc.name: HandleSetDialogSessionBackGestureEnabled01
838 * @tc.desc: sessionStub sessionStubTest
839 * @tc.type: FUNC
840 * @tc.require: #I6JLSI
841 */
842 HWTEST_F(SessionStubTest, HandleSetDialogSessionBackGestureEnabled01, TestSize.Level1)
843 {
844 MessageParcel data;
845 MessageParcel reply;
846 data.WriteBool(true);
847 auto res = session_->HandleSetDialogSessionBackGestureEnabled(data, reply);
848 ASSERT_EQ(ERR_NONE, res);
849 }
850
851 /**
852 * @tc.name: HandleRequestFocus
853 * @tc.desc: sessionStub HandleRequestFocusTest
854 * @tc.type: FUNC
855 * @tc.require: #IAPLFA
856 */
857 HWTEST_F(SessionStubTest, HandleRequestFocus, TestSize.Level1)
858 {
859 MessageParcel data;
860 MessageParcel reply;
861 data.WriteBool(false);
862 ASSERT_NE(session_, nullptr);
863 auto res = session_->HandleRequestFocus(data, reply);
864 ASSERT_EQ(0, res);
865 }
866
867 /**
868 * @tc.name: HandleSyncSessionEvent1
869 * @tc.desc: sessionStub HandleSyncSessionEvent
870 * @tc.type: FUNC
871 */
872 HWTEST_F(SessionStubTest, HandleSyncSessionEvent1, TestSize.Level1)
873 {
874 MessageParcel data;
875 MessageParcel reply;
876
877 data.WriteUint32(static_cast<uint32_t>(SessionEvent::EVENT_MAXIMIZE));
878 auto result = session_->HandleSyncSessionEvent(data, reply);
879 ASSERT_EQ(result, ERR_NONE);
880 }
881
882 /**
883 * @tc.name: HandleSyncSessionEvent2
884 * @tc.desc: sessionStub HandleSyncSessionEvent
885 * @tc.type: FUNC
886 */
887 HWTEST_F(SessionStubTest, HandleSyncSessionEvent2, TestSize.Level1)
888 {
889 MessageParcel data;
890 MessageParcel reply;
891
892 data.WriteUint32(0xFFFFFFFF);
893 auto result = session_->HandleSyncSessionEvent(data, reply);
894 ASSERT_EQ(result, ERR_NONE);
895
896 result = session_->HandleSyncSessionEvent(data, reply);
897 ASSERT_EQ(result, ERR_INVALID_DATA);
898 }
899
900 /**
901 * @tc.name: GetIsMidScene
902 * @tc.desc: sessionStub GetIsMidScene
903 * @tc.type: FUNC
904 */
905 HWTEST_F(SessionStubTest, GetIsMidScene, TestSize.Level1)
906 {
907 MessageParcel data;
908 MessageParcel reply;
909
910 auto result = session_->HandleGetIsMidScene(data, reply);
911 ASSERT_EQ(result, ERR_NONE);
912 }
913
914 /**
915 * @tc.name: HandleNotifyFrameLayoutFinish
916 * @tc.desc: sessionStub HandleNotifyFrameLayoutFinish
917 * @tc.type: FUNC
918 */
919 HWTEST_F(SessionStubTest, HandleNotifyFrameLayoutFinish, TestSize.Level1)
920 {
921 MessageParcel data;
922 MessageParcel reply;
923
924 auto result = session_->HandleNotifyFrameLayoutFinish(data, reply);
925 ASSERT_EQ(result, ERR_NONE);
926 }
927
928 /**
929 * @tc.name: HandleSnapshotUpdate
930 * @tc.desc: sessionStub HandleSnapshotUpdate
931 * @tc.type: FUNC
932 */
933 HWTEST_F(SessionStubTest, HandleSnapshotUpdate, TestSize.Level1)
934 {
935 MessageParcel data;
936 MessageParcel reply;
937
938 auto result = session_->HandleSnapshotUpdate(data, reply);
939 EXPECT_EQ(result, ERR_NONE);
940 }
941
942 /**
943 * @tc.name: HandleSyncSessionEvent
944 * @tc.desc: sessionStub HandleSyncSessionEvent
945 * @tc.type: FUNC
946 */
947 HWTEST_F(SessionStubTest, HandleSyncSessionEvent, TestSize.Level1)
948 {
949 MessageParcel data;
950 MessageParcel reply;
951
952 auto result = session_->HandleSyncSessionEvent(data, reply);
953 ASSERT_EQ(result, ERR_INVALID_DATA);
954 }
955
956 /**
957 * @tc.name: HandlePendingSessionActivation
958 * @tc.desc: sessionStub HandlePendingSessionActivation
959 * @tc.type: FUNC
960 */
961 HWTEST_F(SessionStubTest, HandlePendingSessionActivation, TestSize.Level1)
962 {
963 MessageParcel data;
964 MessageParcel reply;
965
966 auto result = session_->HandlePendingSessionActivation(data, reply);
967 ASSERT_EQ(result, ERR_INVALID_DATA);
968 }
969
970 /**
971 * @tc.name: WindowCreateParams
972 * @tc.desc: sessionStub WindowCreateParams
973 * @tc.type: FUNC
974 */
975 HWTEST_F(SessionStubTest, WindowCreateParams, TestSize.Level1)
976 {
977 MessageParcel data;
978 auto windowCreateParams = std::make_shared<WindowCreateParams>();
979 windowCreateParams->animationParams = std::make_shared<StartAnimationOptions>();
980 windowCreateParams->animationParams->animationType = AnimationType::FADE_IN;
981 windowCreateParams->animationSystemParams = std::make_shared<StartAnimationSystemOptions>();
982 data.WriteParcelable(windowCreateParams.get());
983 auto windowCreateParamsRead = std::make_shared<WindowCreateParams>();
984 windowCreateParamsRead.reset(data.ReadParcelable<WindowCreateParams>());
985 EXPECT_EQ(windowCreateParamsRead->animationParams->animationType, AnimationType::FADE_IN);
986 }
987
988 /**
989 * @tc.name: HandleGetGlobalScaledRect
990 * @tc.desc: sessionStub HandleGetGlobalScaledRect
991 * @tc.type: FUNC
992 */
993 HWTEST_F(SessionStubTest, HandleGetGlobalScaledRect, TestSize.Level1)
994 {
995 MessageParcel data;
996 MessageParcel reply;
997
998 auto result = session_->HandleGetGlobalScaledRect(data, reply);
999 ASSERT_EQ(result, ERR_NONE);
1000 }
1001
1002 /**
1003 * @tc.name: HandleGetAllAvoidAreas
1004 * @tc.desc: sessionStub HandleGetAllAvoidAreas
1005 * @tc.type: FUNC
1006 */
1007 HWTEST_F(SessionStubTest, HandleGetAllAvoidAreas, TestSize.Level1)
1008 {
1009 MessageParcel data;
1010 MessageParcel reply;
1011
1012 auto result = session_->HandleGetAllAvoidAreas(data, reply);
1013 ASSERT_EQ(result, ERR_NONE);
1014 }
1015
1016 /**
1017 * @tc.name: HandleIsStartMoving
1018 * @tc.desc: sessionStub HandleIsStartMoving
1019 * @tc.type: FUNC
1020 */
1021 HWTEST_F(SessionStubTest, HandleIsStartMoving, TestSize.Level1)
1022 {
1023 MessageParcel data;
1024 MessageParcel reply;
1025
1026 auto result = session_->HandleIsStartMoving(data, reply);
1027 ASSERT_EQ(result, ERR_NONE);
1028 }
1029
1030 /**
1031 * @tc.name: HandleSetSessionLabelAndIcon01
1032 * @tc.desc: HandleSetSessionLabelAndIcon
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon01, TestSize.Level1)
1036 {
1037 MessageParcel data;
1038 MessageParcel reply;
1039 std::shared_ptr<Media::PixelMap> icon = std::make_shared<Media::PixelMap>();
1040 data.WriteParcelable(icon.get());
1041
1042 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
1043 ASSERT_EQ(ERR_INVALID_DATA, res);
1044 }
1045
1046 /**
1047 * @tc.name: HandleSetSessionLabelAndIcon02
1048 * @tc.desc: HandleSetSessionLabelAndIcon
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon02, TestSize.Level1)
1052 {
1053 MessageParcel data;
1054 MessageParcel reply;
1055 std::string label = "demo label";
1056 data.WriteString(label);
1057 std::shared_ptr<Media::PixelMap> icon = nullptr;
1058 data.WriteParcelable(icon.get());
1059
1060 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
1061 ASSERT_EQ(ERR_INVALID_DATA, res);
1062 }
1063
1064 /**
1065 * @tc.name: HandleSetSessionLabelAndIcon03
1066 * @tc.desc: HandleSetSessionLabelAndIcon
1067 * @tc.type: FUNC
1068 */
1069 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon03, TestSize.Level1)
1070 {
1071 MessageParcel data;
1072 MessageParcel reply;
1073 std::string label = "demo label";
1074 data.WriteString(label);
1075 const uint32_t color[] = { 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 };
1076 uint32_t len = sizeof(color) / sizeof(color[0]);
1077 Media::InitializationOptions opts;
1078 opts.size.width = 2;
1079 opts.size.height = 3;
1080 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
1081 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
1082 std::shared_ptr<Media::PixelMap> icon = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
1083 data.WriteParcelable(icon.get());
1084
1085 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
1086 ASSERT_EQ(ERR_NONE, res);
1087 }
1088
1089 /**
1090 * @tc.name: HandleGetCrossAxisState
1091 * @tc.desc: HandleGetCrossAxisState
1092 * @tc.type: FUNC
1093 */
1094 HWTEST_F(SessionStubTest, HandleGetCrossAxisState, TestSize.Level1)
1095 {
1096 MessageParcel data;
1097 MessageParcel reply;
1098 sptr<SessionStubMocker> session = sptr<SessionStubMocker>::MakeSptr();
1099 EXPECT_CALL(*session, GetCrossAxisState(_))
1100 .WillOnce(DoAll(SetArgReferee<0>(CrossAxisState::STATE_CROSS), Return(WSError::WS_OK)));
1101 session->HandleGetCrossAxisState(data, reply);
1102 uint32_t state = 0;
1103 reply.ReadUint32(state);
1104 ASSERT_EQ(state, static_cast<uint32_t>(CrossAxisState::STATE_CROSS));
1105 }
1106
1107 /**
1108 * @tc.name: HandleContainerModalEvent
1109 * @tc.desc: sessionStub HandleContainerModalEvent
1110 * @tc.type: FUNC
1111 */
1112 HWTEST_F(SessionStubTest, HandleContainerModalEvent, TestSize.Level1)
1113 {
1114 MessageParcel data;
1115 MessageParcel reply;
1116 data.WriteString("name");
1117 data.WriteString("value");
1118 auto result = session_->HandleContainerModalEvent(data, reply);
1119 ASSERT_EQ(result, ERR_NONE);
1120 result = session_->HandleContainerModalEvent(data, reply);
1121 ASSERT_EQ(result, ERR_INVALID_DATA);
1122 }
1123
1124 /**
1125 * @tc.name: HandleUpdateRotationChangeListenerRegistered
1126 * @tc.desc: sessionStub HandleUpdateRotationChangeListenerRegistered
1127 * @tc.type: FUNC
1128 */
1129 HWTEST_F(SessionStubTest, HandleUpdateRotationChangeListenerRegistered, Function | SmallTest | Level2)
1130 {
1131 MessageParcel data;
1132 MessageParcel reply;
1133 data.WriteUint32(0);
1134 data.WriteBool(false);
1135 auto result = session_->HandleUpdateRotationChangeListenerRegistered(data, reply);
1136 ASSERT_EQ(result, ERR_NONE);
1137 result = session_->HandleUpdateRotationChangeListenerRegistered(data, reply);
1138 ASSERT_EQ(result, ERR_INVALID_DATA);
1139 }
1140
1141 /**
1142 * @tc.name: HandleUpdateScreenshotAppEventRegistered
1143 * @tc.desc: sessionStub HandleUpdateScreenshotAppEventRegistered
1144 * @tc.type: FUNC
1145 */
1146 HWTEST_F(SessionStubTest, HandleUpdateScreenshotAppEventRegistered, Function | SmallTest | Level2)
1147 {
1148 MessageParcel data;
1149 MessageParcel reply;
1150 MessageOption option;
1151 data.WriteInt32(0);
1152 data.WriteBool(false);
1153 auto result = session_->HandleUpdateScreenshotAppEventRegistered(data, reply);
1154 EXPECT_EQ(result, ERR_NONE);
1155
1156 data.WriteInterfaceToken(u"OHOS.ISession");
1157 uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_SCREEN_SHOT_APP_EVENT_REGISTERED);
1158 EXPECT_EQ(0, session_->OnRemoteRequest(code, data, reply, option));
1159 }
1160
1161 /**
1162 * @tc.name: HandleUpdateAcrossDisplaysChangeRegistered
1163 * @tc.desc: sessionStub HandleUpdateAcrossDisplaysChangeRegistered
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(SessionStubTest, HandleUpdateAcrossDisplaysChangeRegistered, Function | SmallTest | Level2)
1167 {
1168 MessageParcel data;
1169 MessageParcel reply;
1170 MessageOption option;
1171 data.WriteInt32(0);
1172 data.WriteBool(false);
1173 sptr<SessionStub> sessionStub = sptr<SessionStubMocker>::MakeSptr();
1174 ASSERT_NE(nullptr, sessionStub);
1175 auto result = sessionStub->HandleUpdateAcrossDisplaysChangeRegistered(data, reply);
1176 EXPECT_EQ(result, ERR_NONE);
1177
1178 data.WriteInterfaceToken(SessionStub::GetDescriptor());
1179 uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_ACROSS_DISPLAYS_REGISTERED);
1180 EXPECT_EQ(0, sessionStub->ProcessRemoteRequest(code, data, reply, option));
1181 }
1182
1183 /**
1184 * @tc.name: HandleIsMainWindowFullScreenAcrossDisplays
1185 * @tc.desc: sessionStub HandleIsMainWindowFullScreenAcrossDisplays
1186 * @tc.type: FUNC
1187 */
1188 HWTEST_F(SessionStubTest, HandleIsMainWindowFullScreenAcrossDisplays, Function | SmallTest | Level2)
1189 {
1190 MessageParcel data;
1191 MessageParcel reply;
1192 MessageOption option;
1193 data.WriteInt32(0);
1194 data.WriteBool(false);
1195 sptr<SessionStub> sessionStub = sptr<SessionStubMocker>::MakeSptr();
1196 ASSERT_NE(nullptr, sessionStub);
1197 auto result = sessionStub->HandleIsMainWindowFullScreenAcrossDisplays(data, reply);
1198 EXPECT_EQ(result, ERR_NONE);
1199
1200 data.WriteInterfaceToken(SessionStub::GetDescriptor());
1201 uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_MAIN_WINDOW_FULL_SCREEN_ACROSS_DISPLAYS);
1202 EXPECT_EQ(0, sessionStub->ProcessRemoteRequest(code, data, reply, option));
1203 }
1204
1205 /**
1206 * @tc.name: HandleNotifyKeyboardWillShowRegistered
1207 * @tc.desc: sessionStub HandleNotifyKeyboardWillShowRegistered
1208 * @tc.type: FUNC
1209 */
1210 HWTEST_F(SessionStubTest, HandleNotifyKeyboardWillShowRegistered, Function | SmallTest | Level2)
1211 {
1212 MessageParcel data;
1213 MessageParcel reply;
1214 auto result = session_->HandleNotifyKeyboardWillShowRegistered(data, reply);
1215 ASSERT_EQ(result, ERR_INVALID_DATA);
1216
1217 data.WriteBool(true);
1218 auto result1 = session_->HandleNotifyKeyboardWillShowRegistered(data, reply);
1219 ASSERT_EQ(result1, ERR_NONE);
1220 }
1221
1222 /**
1223 * @tc.name: HandleNotifyKeyboardWillHideRegistered
1224 * @tc.desc: sessionStub HandleNotifyKeyboardWillHideRegistered
1225 * @tc.type: FUNC
1226 */
1227 HWTEST_F(SessionStubTest, HandleNotifyKeyboardWillHideRegistered, Function | SmallTest | Level2)
1228 {
1229 MessageParcel data;
1230 MessageParcel reply;
1231 auto result = session_->HandleNotifyKeyboardWillHideRegistered(data, reply);
1232 ASSERT_EQ(result, ERR_INVALID_DATA);
1233
1234 data.WriteBool(true);
1235 auto result1 = session_->HandleNotifyKeyboardWillHideRegistered(data, reply);
1236 ASSERT_EQ(result1, ERR_NONE);
1237 }
1238
1239 /**
1240 * @tc.name: HandleGetTargetOrientationConfigInfo
1241 * @tc.desc: sessionStub HandleGetTargetOrientationConfigInfo
1242 * @tc.type: FUNC
1243 */
1244 HWTEST_F(SessionStubTest, HandleGetTargetOrientationConfigInfo, Function | SmallTest | Level2)
1245 {
1246 MessageParcel data;
1247 MessageParcel reply;
1248 data.WriteUint32(1);
1249 data.WriteUint32(1);
1250 data.WriteUint32(-1);
1251 data.WriteBool(true);
1252 data.WriteUint32(1);
1253 data.WriteUint32(1);
1254 data.WriteBool(true);
1255 data.WriteUint32(1);
1256 auto result = session_->HandleGetTargetOrientationConfigInfo(data, reply);
1257 EXPECT_EQ(result, ERR_INVALID_DATA);
1258 data.WriteUint32(1);
1259 data.WriteUint32(1);
1260 data.WriteUint32(1);
1261 data.WriteBool(true);
1262 data.WriteUint32(1);
1263 data.WriteUint32(1);
1264 data.WriteBool(true);
1265 data.WriteUint32(1);
1266 auto result1 = session_->HandleGetTargetOrientationConfigInfo(data, reply);
1267 EXPECT_EQ(result1, ERR_NONE);
1268 }
1269
1270 /**
1271 * @tc.name: GetIsHighlighted
1272 * @tc.desc: sessionStub GetIsHighlighted
1273 * @tc.type: FUNC
1274 */
1275 HWTEST_F(SessionStubTest, GetIsHighlighted, Function | SmallTest | Level2)
1276 {
1277 MessageParcel data;
1278 MessageParcel reply;
1279 auto result = session_->HandleGetIsHighlighted(data, reply);
1280 ASSERT_EQ(result, ERR_NONE);
1281 }
1282
1283 /**
1284 * @tc.name: HandleDefaultDensityEnabled
1285 * @tc.desc: sessionStub HandleDefaultDensityEnabled
1286 * @tc.type: FUNC
1287 */
1288 HWTEST_F(SessionStubTest, HandleDefaultDensityEnabled, Function | SmallTest | Level2)
1289 {
1290 MessageParcel data;
1291 MessageParcel reply;
1292 auto result = session_->HandleDefaultDensityEnabled(data, reply);
1293 ASSERT_EQ(result, ERR_INVALID_DATA);
1294 data.WriteBool(true);
1295 result = session_->HandleDefaultDensityEnabled(data, reply);
1296 ASSERT_EQ(result, ERR_NONE);
1297 }
1298
1299 /**
1300 * @tc.name: HandleForeground
1301 * @tc.desc: sessionStub HandleForeground
1302 * @tc.type: FUNC
1303 */
1304 HWTEST_F(SessionStubTest, HandleForeground, Function | SmallTest | Level2)
1305 {
1306 MessageParcel data;
1307 MessageParcel reply;
1308 auto result = session_->HandleForeground(data, reply);
1309 ASSERT_EQ(result, ERR_INVALID_DATA);
1310 data.WriteBool(true);
1311 sptr<WindowSessionProperty> propertyTest = nullptr;
1312 data.WriteParcelable(propertyTest);
1313 result = session_->HandleForeground(data, reply);
1314 ASSERT_EQ(result, ERR_INVALID_DATA);
1315 propertyTest = sptr<WindowSessionProperty>::MakeSptr();
1316 data.WriteBool(true);
1317 data.WriteParcelable(propertyTest);
1318 data.WriteBool(true);
1319 result = session_->HandleForeground(data, reply);
1320 ASSERT_EQ(result, ERR_INVALID_DATA);
1321 data.WriteBool(true);
1322 data.WriteParcelable(propertyTest);
1323 data.WriteBool(true);
1324 data.WriteString("HandleForegroundTest");
1325 result = session_->HandleForeground(data, reply);
1326 ASSERT_EQ(result, ERR_NONE);
1327 data.WriteBool(false);
1328 data.WriteBool(true);
1329 data.WriteString("HandleForegroundTest");
1330 result = session_->HandleForeground(data, reply);
1331 ASSERT_EQ(result, ERR_NONE);
1332 }
1333
1334 /**
1335 * @tc.name: HandleGetWaterfallMode
1336 * @tc.desc: sessionStub HandleGetWaterfallMode
1337 * @tc.type: FUNC
1338 */
1339 HWTEST_F(SessionStubTest, HandleGetWaterfallMode, Function | SmallTest | Level2)
1340 {
1341 MessageParcel data;
1342 MessageParcel reply;
1343 auto result = session_->HandleGetWaterfallMode(data, reply);
1344 ASSERT_EQ(result, ERR_NONE);
1345 }
1346
1347 /**
1348 * @tc.name: HandleKeyFrameAnimateEnd
1349 * @tc.desc: sessionStub HandleKeyFrameAnimateEnd
1350 * @tc.type: FUNC
1351 */
1352 HWTEST_F(SessionStubTest, HandleKeyFrameAnimateEnd, Function | SmallTest | Level2)
1353 {
1354 MessageParcel data;
1355 MessageParcel reply;
1356 auto result = session_->HandleKeyFrameAnimateEnd(data, reply);
1357 ASSERT_EQ(result, ERR_NONE);
1358 }
1359
1360 /**
1361 * @tc.name: HandleUpdateKeyFrameCloneNode
1362 * @tc.desc: sessionStub HandleUpdateKeyFrameCloneNode
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(SessionStubTest, HandleUpdateKeyFrameCloneNode, Function | SmallTest | Level2)
1366 {
1367 MessageParcel data;
1368 MessageParcel reply;
1369 auto rsCanvasNode = RSCanvasNode::Create();
1370 ASSERT_NE(rsCanvasNode, nullptr);
1371 ASSERT_EQ(rsCanvasNode->Marshalling(data), true);
1372 auto rsTransaction = std::make_shared<RSTransaction>();
1373 ASSERT_NE(rsTransaction, nullptr);
1374 ASSERT_EQ(data.WriteParcelable(rsTransaction.get()), true);
1375 auto result = session_->HandleUpdateKeyFrameCloneNode(data, reply);
1376 ASSERT_EQ(result, ERR_NONE);
1377 int32_t ret = 0;
1378 ASSERT_EQ(reply.ReadInt32(ret), true);
1379 ASSERT_EQ(ret, 0);
1380 }
1381
1382 /**
1383 * @tc.name: HandleNotifyDisableDelegatorChange
1384 * @tc.desc: sessionStub HandleNotifyDisableDelegatorChange
1385 * @tc.type: FUNC
1386 */
1387 HWTEST_F(SessionStubTest, HandleNotifyDisableDelegatorChange, Function | SmallTest | Level2)
1388 {
1389 MessageParcel data;
1390 MessageParcel reply;
1391 auto result = session_->HandleNotifyDisableDelegatorChange(data, reply);
1392 ASSERT_EQ(result, ERR_NONE);
1393 }
1394
1395 /**
1396 * @tc.name: HandleNotifyKeyboardDidHideRegistered
1397 * @tc.desc: sessionStub HandleNotifyKeyboardDidHideRegistered
1398 * @tc.type: FUNC
1399 */
1400 HWTEST_F(SessionStubTest, HandleNotifyKeyboardDidHideRegistered, Function | SmallTest | Level2)
1401 {
1402 MessageParcel data;
1403 MessageParcel reply;
1404 auto result = session_->HandleNotifyKeyboardDidHideRegistered(data, reply);
1405 ASSERT_EQ(result, ERR_INVALID_DATA);
1406 data.WriteBool(true);
1407 result = session_->HandleNotifyKeyboardDidHideRegistered(data, reply);
1408 ASSERT_EQ(result, ERR_NONE);
1409 }
1410
1411 /**
1412 * @tc.name: HandleNotifyKeyboardDidShowRegistered
1413 * @tc.desc: sessionStub HandleNotifyKeyboardDidShowRegistered
1414 * @tc.type: FUNC
1415 */
1416 HWTEST_F(SessionStubTest, HandleNotifyKeyboardDidShowRegistered, Function | SmallTest | Level2)
1417 {
1418 MessageParcel data;
1419 MessageParcel reply;
1420 auto result = session_->HandleNotifyKeyboardDidShowRegistered(data, reply);
1421 ASSERT_EQ(result, ERR_INVALID_DATA);
1422 data.WriteBool(true);
1423 result = session_->HandleNotifyKeyboardDidShowRegistered(data, reply);
1424 ASSERT_EQ(result, ERR_NONE);
1425 }
1426
1427 /**
1428 * @tc.name: HandleNotifyMainModalTypeChange
1429 * @tc.desc: sessionStub HandleNotifyMainModalTypeChange
1430 * @tc.type: FUNC
1431 */
1432 HWTEST_F(SessionStubTest, HandleNotifyMainModalTypeChange, Function | SmallTest | Level2)
1433 {
1434 MessageParcel data;
1435 MessageParcel reply;
1436 auto result = session_->HandleNotifyMainModalTypeChange(data, reply);
1437 ASSERT_EQ(result, ERR_INVALID_DATA);
1438 data.WriteBool(true);
1439 result = session_->HandleNotifyMainModalTypeChange(data, reply);
1440 ASSERT_EQ(result, ERR_NONE);
1441 }
1442
1443 /**
1444 * @tc.name: HandleNotifySubModalTypeChange
1445 * @tc.desc: sessionStub HandleNotifySubModalTypeChange
1446 * @tc.type: FUNC
1447 */
1448 HWTEST_F(SessionStubTest, HandleNotifySubModalTypeChange, Function | SmallTest | Level2)
1449 {
1450 MessageParcel data;
1451 MessageParcel reply;
1452 auto result = session_->HandleNotifySubModalTypeChange(data, reply);
1453 ASSERT_EQ(result, ERR_INVALID_DATA);
1454 data.WriteUint32(static_cast<uint32_t>(SubWindowModalType::TYPE_UNDEFINED));
1455 result = session_->HandleNotifySubModalTypeChange(data, reply);
1456 ASSERT_EQ(result, ERR_NONE);
1457 data.WriteUint32(static_cast<uint32_t>(SubWindowModalType::TYPE_TEXT_MENU) + 1);
1458 result = session_->HandleNotifySubModalTypeChange(data, reply);
1459 ASSERT_EQ(result, ERR_INVALID_DATA);
1460 }
1461
1462 /**
1463 * @tc.name: HandleSetFollowParentWindowLayoutEnabled
1464 * @tc.desc: sessionStub HandleSetFollowParentWindowLayoutEnabled
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(SessionStubTest, HandleSetFollowParentWindowLayoutEnabled, Function | SmallTest | Level2)
1468 {
1469 MessageParcel data;
1470 MessageParcel reply;
1471 auto result = session_->HandleSetFollowParentWindowLayoutEnabled(data, reply);
1472 ASSERT_EQ(result, ERR_INVALID_DATA);
1473 data.WriteBool(true);
1474 result = session_->HandleSetFollowParentWindowLayoutEnabled(data, reply);
1475 ASSERT_EQ(result, ERR_NONE);
1476 }
1477
1478 /**
1479 * @tc.name: HandleSetWindowAnchorInfo
1480 * @tc.desc: sessionStub HandleSetWindowAnchorInfo
1481 * @tc.type: FUNC
1482 */
1483 HWTEST_F(SessionStubTest, HandleSetWindowAnchorInfo, Function | SmallTest | Level2)
1484 {
1485 MessageParcel data;
1486 MessageParcel reply;
1487 auto result = session_->HandleSetWindowAnchorInfo(data, reply);
1488 ASSERT_EQ(result, ERR_INVALID_DATA);
1489
1490 WindowAnchorInfo windowAnchor;
1491 data.WriteParcelable(&windowAnchor);
1492 result = session_->HandleSetWindowAnchorInfo(data, reply);
1493 ASSERT_EQ(result, ERR_NONE);
1494 }
1495
1496 /**
1497 * @tc.name: HandleSetGestureBackEnabled
1498 * @tc.desc: sessionStub HandleSetGestureBackEnabled
1499 * @tc.type: FUNC
1500 */
1501 HWTEST_F(SessionStubTest, HandleSetGestureBackEnabled, Function | SmallTest | Level2)
1502 {
1503 MessageParcel data;
1504 MessageParcel reply;
1505 auto result = session_->HandleSetGestureBackEnabled(data, reply);
1506 ASSERT_EQ(result, ERR_INVALID_DATA);
1507 data.WriteBool(true);
1508 result = session_->HandleSetGestureBackEnabled(data, reply);
1509 ASSERT_EQ(result, ERR_NONE);
1510 }
1511
1512 /**
1513 * @tc.name: HandleSetSupportedWindowModes
1514 * @tc.desc: sessionStub HandleSetSupportedWindowModes
1515 * @tc.type: FUNC
1516 */
1517 HWTEST_F(SessionStubTest, HandleSetSupportedWindowModes, Function | SmallTest | Level2)
1518 {
1519 MessageParcel data;
1520 MessageParcel reply;
1521 std::vector<AppExecFwk::SupportWindowMode> supportedWindowModes = { AppExecFwk::SupportWindowMode::FULLSCREEN,
1522 AppExecFwk::SupportWindowMode::SPLIT,
1523 AppExecFwk::SupportWindowMode::FLOATING };
1524 auto result = session_->HandleSetSupportedWindowModes(data, reply);
1525 EXPECT_EQ(result, ERR_INVALID_DATA);
1526 uint32_t size = supportedWindowModes.size();
1527 data.WriteUint32(size);
1528 for (int i = 0; i < size; i++) {
1529 data.WriteInt32(static_cast<int32_t>(supportedWindowModes[i]));
1530 }
1531 result = session_->HandleSetSupportedWindowModes(data, reply);
1532 EXPECT_EQ(result, ERR_NONE);
1533 }
1534
1535 /**
1536 * @tc.name: HandleStartMovingWithCoordinate
1537 * @tc.desc: sessionStub HandleStartMovingWithCoordinate
1538 * @tc.type: FUNC
1539 */
1540 HWTEST_F(SessionStubTest, HandleStartMovingWithCoordinate, Function | SmallTest | Level2)
1541 {
1542 MessageParcel data;
1543 MessageParcel reply;
1544 auto result = session_->HandleStartMovingWithCoordinate(data, reply);
1545 EXPECT_EQ(result, ERR_INVALID_DATA);
1546 data.WriteInt32(0);
1547 result = session_->HandleStartMovingWithCoordinate(data, reply);
1548 EXPECT_EQ(result, ERR_INVALID_DATA);
1549 data.WriteInt32(0);
1550 data.WriteInt32(0);
1551 result = session_->HandleStartMovingWithCoordinate(data, reply);
1552 EXPECT_EQ(result, ERR_INVALID_DATA);
1553 data.WriteInt32(0);
1554 data.WriteInt32(0);
1555 data.WriteInt32(1);
1556 result = session_->HandleStartMovingWithCoordinate(data, reply);
1557 EXPECT_EQ(result, ERR_INVALID_DATA);
1558 data.WriteInt32(0);
1559 data.WriteInt32(0);
1560 data.WriteInt32(1);
1561 data.WriteInt32(1);
1562 result = session_->HandleStartMovingWithCoordinate(data, reply);
1563 EXPECT_EQ(result, ERR_INVALID_DATA);
1564 data.WriteInt32(0);
1565 data.WriteInt32(0);
1566 data.WriteInt32(1);
1567 data.WriteInt32(1);
1568 data.WriteUint64(0);
1569 result = session_->HandleStartMovingWithCoordinate(data, reply);
1570 EXPECT_EQ(result, ERR_NONE);
1571 }
1572
1573 /**q
1574 * @tc.name: HandleTransferAccessibilityEvent
1575 * @tc.desc: sessionStub HandleTransferAccessibilityEvent
1576 * @tc.type: FUNC
1577 */
1578 HWTEST_F(SessionStubTest, HandleTransferAccessibilityEvent, Function | SmallTest | Level2)
1579 {
1580 MessageParcel data;
1581 MessageParcel reply;
1582 data.WriteParcelable(nullptr);
1583 auto result = session_->HandleTransferAccessibilityEvent(data, reply);
1584 ASSERT_EQ(result, ERR_INVALID_DATA);
1585 Accessibility::AccessibilityEventInfo info;
1586 Accessibility::AccessibilityEventInfoParcel infoParcel(info);
1587 data.WriteParcelable(&infoParcel);
1588 result = session_->HandleTransferAccessibilityEvent(data, reply);
1589 ASSERT_EQ(result, ERR_INVALID_DATA);
1590 data.WriteParcelable(&infoParcel);
1591 data.WriteInt64(1);
1592 result = session_->HandleTransferAccessibilityEvent(data, reply);
1593 ASSERT_EQ(result, ERR_NONE);
1594 }
1595
1596 /**
1597 * @tc.name: HandleSetSubWindowSource
1598 * @tc.desc: test function : HandleSetSubWindowSource
1599 * @tc.type: FUNC
1600 */
1601 HWTEST_F(SessionStubTest, HandleSetSubWindowSource, Function | SmallTest | Level2)
1602 {
1603 MessageParcel data;
1604 MessageParcel reply;
1605 Accessibility::AccessibilityEventInfo info;
1606 Accessibility::AccessibilityEventInfoParcel infoParcel(info);
1607 auto result = session_->HandleSetSubWindowSource(data, reply);
1608 EXPECT_EQ(result, ERR_INVALID_DATA);
1609 data.WriteParcelable(&infoParcel);
1610 data.WriteUint32(1);
1611 result = session_->HandleSetSubWindowSource(data, reply);
1612 EXPECT_EQ(result, ERR_NONE);
1613 }
1614
1615 /**
1616 * @tc.name: HandleChangeKeyboardEffectOption01
1617 * @tc.desc: test function : HandleChangeKeyboardEffectOption
1618 * @tc.type: FUNC
1619 */
1620 HWTEST_F(SessionStubTest, HandleChangeKeyboardEffectOption01, Function | SmallTest | Level2)
1621 {
1622 MessageParcel data;
1623 MessageParcel reply;
1624 auto result = session_->HandleChangeKeyboardEffectOption(data, reply);
1625 ASSERT_EQ(result, ERR_INVALID_DATA);
1626
1627 KeyboardEffectOption effectOption;
1628 data.WriteParcelable(&effectOption);
1629 result = session_->HandleChangeKeyboardEffectOption(data, reply);
1630 EXPECT_EQ(result, ERR_NONE);
1631 }
1632
1633 /**
1634 * @tc.name: HandleChangeKeyboardEffectOption02
1635 * @tc.desc: test function : HandleChangeKeyboardEffectOption
1636 * @tc.type: FUNC
1637 */
1638 HWTEST_F(SessionStubTest, HandleChangeKeyboardEffectOption02, Function | SmallTest | Level2)
1639 {
1640 MessageParcel data;
1641 MessageParcel reply;
1642 KeyboardEffectOption effectOption;
1643 effectOption.viewMode_ = static_cast<KeyboardViewMode>(MAX_INT);
1644 data.WriteParcelable(&effectOption);
1645 auto result = session_->HandleChangeKeyboardEffectOption(data, reply);
1646 EXPECT_EQ(result, ERR_INVALID_DATA);
1647 }
1648
1649 /**
1650 * @tc.name: HandleChangeKeyboardEffectOption03
1651 * @tc.desc: test function : HandleChangeKeyboardEffectOption
1652 * @tc.type: FUNC
1653 */
1654 HWTEST_F(SessionStubTest, HandleChangeKeyboardEffectOption03, Function | SmallTest | Level2)
1655 {
1656 MessageParcel data;
1657 MessageParcel reply;
1658 KeyboardEffectOption effectOption;
1659 effectOption.flowLightMode_ = static_cast<KeyboardFlowLightMode>(MAX_INT);
1660 data.WriteParcelable(&effectOption);
1661 auto result = session_->HandleChangeKeyboardEffectOption(data, reply);
1662 EXPECT_EQ(result, ERR_INVALID_DATA);
1663 }
1664
1665 /**
1666 * @tc.name: HandleChangeKeyboardEffectOption04
1667 * @tc.desc: test function : HandleChangeKeyboardEffectOption
1668 * @tc.type: FUNC
1669 */
1670 HWTEST_F(SessionStubTest, HandleChangeKeyboardEffectOption04, Function | SmallTest | Level2)
1671 {
1672 MessageParcel data;
1673 MessageParcel reply;
1674 KeyboardEffectOption effectOption;
1675 effectOption.gradientMode_ = static_cast<KeyboardGradientMode>(MAX_INT);
1676 data.WriteParcelable(&effectOption);
1677 auto result = session_->HandleChangeKeyboardEffectOption(data, reply);
1678 EXPECT_EQ(result, ERR_INVALID_DATA);
1679 }
1680
1681 /**
1682 * @tc.name: HandleSetFrameRectForPartialZoomIn
1683 * @tc.desc: sessionStub sessionStubTest
1684 * @tc.type: FUNC
1685 * @tc.require: #I6JLSI
1686 */
1687 HWTEST_F(SessionStubTest, HandleSetFrameRectForPartialZoomIn, Function | SmallTest | Level2)
1688 {
1689 EXPECT_NE(session_, nullptr);
1690 MessageParcel data;
1691 MessageParcel reply;
1692
1693 EXPECT_EQ(session_->HandleSetFrameRectForPartialZoomIn(data, reply), ERR_INVALID_DATA);
1694
1695 bool res = data.WriteUint32(0);
1696 EXPECT_EQ(res, true);
1697 EXPECT_EQ(session_->HandleSetFrameRectForPartialZoomIn(data, reply), ERR_INVALID_DATA);
1698
1699 res = data.WriteInt32(0) && data.WriteUint32(0);
1700 EXPECT_EQ(res, true);
1701 EXPECT_EQ(session_->HandleSetFrameRectForPartialZoomIn(data, reply), ERR_INVALID_DATA);
1702
1703 res = data.WriteInt32(0) && data.WriteInt32(0) && data.WriteInt32(0);
1704 EXPECT_EQ(res, true);
1705 EXPECT_EQ(session_->HandleSetFrameRectForPartialZoomIn(data, reply), ERR_INVALID_DATA);
1706
1707 res = data.WriteInt32(0) && data.WriteInt32(0) && data.WriteUint32(0) && data.WriteUint32(0);
1708 EXPECT_EQ(res, true);
1709 EXPECT_EQ(session_->HandleSetFrameRectForPartialZoomIn(data, reply), ERR_NONE);
1710 }
1711
1712 /**
1713 * @tc.name: HandleUpdateFloatingBall
1714 * @tc.desc: sessionStub HandleUpdateFloatingBall
1715 * @tc.type: FUNC
1716 */
1717 HWTEST_F(SessionStubTest, HandleUpdateFloatingBall, Function | SmallTest | Level2)
1718 {
1719 MessageParcel data;
1720 MessageParcel reply;
1721 data.WriteParcelable(nullptr);
1722 auto result = session_->HandleUpdateFloatingBall(data, reply);
1723 ASSERT_EQ(result, ERR_INVALID_DATA);
1724
1725 FloatingBallTemplateInfo fbTemplateInfo {{1, "fb", "fb_content", "red"}, nullptr};
1726 data.WriteParcelable(&fbTemplateInfo);
1727 result = session_->HandleUpdateFloatingBall(data, reply);
1728 ASSERT_EQ(result, ERR_NONE);
1729 }
1730
1731 /**
1732 * @tc.name: HandleStopFloatingBall
1733 * @tc.desc: sessionStub HandleStopFloatingBall
1734 * @tc.type: FUNC
1735 */
1736 HWTEST_F(SessionStubTest, HandleStopFloatingBall, Function | SmallTest | Level2)
1737 {
1738 MessageParcel data;
1739 MessageParcel reply;
1740 data.WriteParcelable(nullptr);
1741 auto result = session_->HandleStopFloatingBall(data, reply);
1742 ASSERT_EQ(result, ERR_NONE);
1743 }
1744
1745 /**
1746 * @tc.name: HandleStartFloatingBallMainWindow
1747 * @tc.desc: sessionStub HandleStartFloatingBallMainWindow
1748 * @tc.type: FUNC
1749 */
1750 HWTEST_F(SessionStubTest, HandleStartFloatingBallMainWindow, Function | SmallTest | Level2)
1751 {
1752 MessageParcel data;
1753 MessageParcel reply;
1754
1755 data.WriteParcelable(nullptr);
1756 auto result = session_->HandleStartFloatingBallMainWindow(data, reply);
1757 ASSERT_EQ(result, ERR_INVALID_DATA);
1758
1759 std::shared_ptr<AAFwk::Want> want = std::make_shared<AAFwk::Want>();
1760 data.WriteParcelable(want.get());
1761 result = session_->HandleStartFloatingBallMainWindow(data, reply);
1762 ASSERT_EQ(result, ERR_NONE);
1763 }
1764
1765 /**
1766 * @tc.name: HandleGetFloatingBallWindowId
1767 * @tc.desc: sessionStub HandleGetFloatingBallWindowId
1768 * @tc.type: FUNC
1769 */
1770 HWTEST_F(SessionStubTest, HandleGetFloatingBallWindowId, Function | SmallTest | Level2)
1771 {
1772 MessageParcel data;
1773 MessageParcel reply;
1774 data.WriteParcelable(nullptr);
1775 auto result = session_->HandleGetFloatingBallWindowId(data, reply);
1776 ASSERT_EQ(result, ERR_NONE);
1777 }
1778
1779 /**
1780 * @tc.name: HandleUpdateGlobalDisplayRectFromClientWithInvalidRect
1781 * @tc.desc: Verify HandleUpdateGlobalDisplayRectFromClient with invalid rect
1782 * @tc.type: FUNC
1783 */
1784 HWTEST_F(SessionStubTest, HandleUpdateGlobalDisplayRectFromClientWithInvalidRect, TestSize.Level1)
1785 {
1786 uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_GLOBAL_DISPLAY_RECT);
1787 MessageParcel reply;
1788 MessageOption option;
1789 MessageParcel data;
1790 data.WriteInt32(100); // posX
1791 data.WriteInt32(200); // posY
1792 data.WriteInt32(300); // width
1793 // missing height
1794 EXPECT_EQ(ERR_INVALID_DATA, session_->ProcessRemoteRequest(code, data, reply, option));
1795 }
1796
1797 /**
1798 * @tc.name: HandleUpdateGlobalDisplayRectFromClientWithInvalidReason
1799 * @tc.desc: Verify that ProcessRemoteRequest rejects missing or invalid reason values
1800 * @tc.type: FUNC
1801 */
1802 HWTEST_F(SessionStubTest, HandleUpdateGlobalDisplayRectFromClientWithInvalidReason, TestSize.Level1)
1803 {
1804 constexpr uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_GLOBAL_DISPLAY_RECT);
1805 MessageOption option;
1806
__anon412fec3c0302(MessageParcel& data) 1807 auto writeRect = [](MessageParcel& data) {
1808 data.WriteInt32(10); // posX
1809 data.WriteInt32(20); // posY
1810 data.WriteInt32(300); // width
1811 data.WriteInt32(400); // height
1812 };
1813
1814 // Case 1: Missing reason field
1815 {
1816 MessageParcel data;
1817 MessageParcel reply;
1818 writeRect(data);
1819 EXPECT_EQ(session_->ProcessRemoteRequest(code, data, reply, option), ERR_INVALID_DATA);
1820 }
1821
1822 // Case 2: reason < SizeChangeReason::UNDEFINED
1823 {
1824 MessageParcel data;
1825 MessageParcel reply;
1826 writeRect(data);
1827 data.WriteUint32(static_cast<uint32_t>(SizeChangeReason::UNDEFINED) - 1);
1828 EXPECT_EQ(session_->ProcessRemoteRequest(code, data, reply, option), ERR_INVALID_DATA);
1829 }
1830
1831 // Case 3: reason == SizeChangeReason::END (boundary overflow)
1832 {
1833 MessageParcel data;
1834 MessageParcel reply;
1835 writeRect(data);
1836 data.WriteUint32(static_cast<uint32_t>(SizeChangeReason::END));
1837 EXPECT_EQ(session_->ProcessRemoteRequest(code, data, reply, option), ERR_INVALID_DATA);
1838 }
1839
1840 // Case 4: reason > SizeChangeReason::END
1841 {
1842 MessageParcel data;
1843 MessageParcel reply;
1844 writeRect(data);
1845 data.WriteUint32(static_cast<uint32_t>(SizeChangeReason::END) + 1);
1846 EXPECT_EQ(session_->ProcessRemoteRequest(code, data, reply, option), ERR_INVALID_DATA);
1847 }
1848 }
1849
1850 /**
1851 * @tc.name: HandleUpdateGlobalDisplayRectFromClientSuccess
1852 * @tc.desc: Verify that ProcessRemoteRequest accepts valid rect and reason data
1853 * @tc.type: FUNC
1854 */
1855 HWTEST_F(SessionStubTest, HandleUpdateGlobalDisplayRectFromClientSuccess, TestSize.Level1)
1856 {
1857 constexpr int32_t posX = 100;
1858 constexpr int32_t posY = 200;
1859 constexpr int32_t width = 300;
1860 constexpr int32_t height = 400;
1861 constexpr SizeChangeReason reason = SizeChangeReason::RESIZE;
1862 constexpr uint32_t code = static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_GLOBAL_DISPLAY_RECT);
1863
1864 MessageParcel data;
1865 MessageParcel reply;
1866 MessageOption option;
1867
1868 data.WriteInt32(posX);
1869 data.WriteInt32(posY);
1870 data.WriteInt32(width);
1871 data.WriteInt32(height);
1872 data.WriteUint32(static_cast<uint32_t>(reason));
1873
1874 EXPECT_EQ(session_->ProcessRemoteRequest(code, data, reply, option), ERR_NONE);
1875 }
1876
1877 /**
1878 * @tc.name: HandleConnect001
1879 * @tc.desc: sessionStub HandleConnect001
1880 * @tc.type: FUNC
1881 */
1882 HWTEST_F(SessionStubTest, HandleConnect001, Function | SmallTest | Level2)
1883 {
1884 MessageParcel data;
1885 MessageParcel reply;
1886
1887 auto result = session_->HandleConnect(data, reply);
1888 EXPECT_EQ(result, ERR_INVALID_DATA);
1889
1890 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1891 data.WriteRemoteObject(sessionStage->AsObject());
1892 result = session_->HandleConnect(data, reply);
1893 EXPECT_EQ(result, ERR_INVALID_DATA);
1894
1895 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
1896 data.WriteRemoteObject(sessionStage->AsObject());
1897 data.WriteRemoteObject(eventChannel->AsObject());
1898 result = session_->HandleConnect(data, reply);
1899 EXPECT_EQ(result, ERR_INVALID_DATA);
1900
1901 std::string surfaceNodeName = "HandleConnectTest";
1902 Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = surfaceNodeName};
1903 std::shared_ptr<Rosen::RSSurfaceNode> rsSurfaceNode;
1904 rsSurfaceNode = std::make_shared<Rosen::RSSurfaceNode>(surfaceNodeConfig, true);
1905 data.WriteRemoteObject(sessionStage->AsObject());
1906 data.WriteRemoteObject(eventChannel->AsObject());
1907 rsSurfaceNode->Marshalling(data);
1908 result = session_->HandleConnect(data, reply);
1909 EXPECT_EQ(result, ERR_INVALID_DATA);
1910
1911 data.WriteRemoteObject(sessionStage->AsObject());
1912 data.WriteRemoteObject(eventChannel->AsObject());
1913 rsSurfaceNode->Marshalling(data);
1914 data.WriteBool(false);
1915 result = session_->HandleConnect(data, reply);
1916 EXPECT_EQ(result, ERR_INVALID_DATA);
1917 }
1918
1919 /**
1920 * @tc.name: HandleConnect002
1921 * @tc.desc: sessionStub HandleConnect002
1922 * @tc.type: FUNC
1923 */
1924 HWTEST_F(SessionStubTest, HandleConnect002, Function | SmallTest | Level2)
1925 {
1926 MessageParcel data;
1927 MessageParcel reply;
1928
1929 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1930 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
1931 Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = "HandleConnectTest"};
1932 std::shared_ptr<Rosen::RSSurfaceNode> rsSurfaceNode;
1933 rsSurfaceNode = std::make_shared<Rosen::RSSurfaceNode>(surfaceNodeConfig, true);
1934
1935 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1936 EXPECT_NE(property, nullptr);
1937 property->SetTokenState(true);
1938 data.WriteRemoteObject(sessionStage->AsObject());
1939 data.WriteRemoteObject(eventChannel->AsObject());
1940 rsSurfaceNode->Marshalling(data);
1941 data.WriteBool(true);
1942 auto result = session_->HandleConnect(data, reply);
1943 EXPECT_EQ(result, ERR_INVALID_DATA);
1944
1945 data.WriteRemoteObject(sessionStage->AsObject());
1946 data.WriteRemoteObject(eventChannel->AsObject());
1947 rsSurfaceNode->Marshalling(data);
1948 data.WriteBool(true);
1949 data.WriteParcelable(property.GetRefPtr());
1950 result = session_->HandleConnect(data, reply);
1951 EXPECT_EQ(result, ERR_INVALID_DATA);
1952
1953 sptr<IRemoteObject> token = nullptr;
1954 data.WriteRemoteObject(sessionStage->AsObject());
1955 data.WriteRemoteObject(eventChannel->AsObject());
1956 rsSurfaceNode->Marshalling(data);
1957 data.WriteBool(true);
1958 data.WriteParcelable(property.GetRefPtr());
1959 data.WriteRemoteObject(token);
1960 result = session_->HandleConnect(data, reply);
1961 EXPECT_EQ(result, ERR_INVALID_DATA);
1962 }
1963
1964 /**
1965 * @tc.name: HandleConnect003
1966 * @tc.desc: sessionStub HandleConnect003
1967 * @tc.type: FUNC
1968 */
1969 HWTEST_F(SessionStubTest, HandleConnect003, Function | SmallTest | Level2)
1970 {
1971 MessageParcel data;
1972 MessageParcel reply;
1973
1974 sptr<ISessionStage> sessionStage = sptr<SessionStageMocker>::MakeSptr();
1975 sptr<IWindowEventChannel> eventChannel = sptr<WindowEventChannelMocker>::MakeSptr(sessionStage);
1976 Rosen::RSSurfaceNodeConfig surfaceNodeConfig = { .SurfaceNodeName = "HandleConnectTest"};
1977 std::shared_ptr<Rosen::RSSurfaceNode> rsSurfaceNode;
1978 rsSurfaceNode = std::make_shared<Rosen::RSSurfaceNode>(surfaceNodeConfig, true);
1979 sptr<WindowSessionProperty> property = sptr<WindowSessionProperty>::MakeSptr();
1980 property->SetTokenState(true);
1981
1982 sptr<IRemoteObject> token = sptr<IRemoteObjectMocker>::MakeSptr();
1983 data.WriteRemoteObject(sessionStage->AsObject());
1984 data.WriteRemoteObject(eventChannel->AsObject());
1985 rsSurfaceNode->Marshalling(data);
1986 data.WriteBool(true);
1987 data.WriteParcelable(property.GetRefPtr());
1988 data.WriteRemoteObject(token);
1989 auto result = session_->HandleConnect(data, reply);
1990 EXPECT_EQ(result, ERR_INVALID_DATA);
1991
1992 std::string identityToken = "HandleConnectTest";
1993 data.WriteRemoteObject(sessionStage->AsObject());
1994 data.WriteRemoteObject(eventChannel->AsObject());
1995 rsSurfaceNode->Marshalling(data);
1996 data.WriteBool(true);
1997 data.WriteParcelable(property.GetRefPtr());
1998 data.WriteRemoteObject(token);
1999 data.WriteString(identityToken);
2000 result = session_->HandleConnect(data, reply);
2001 EXPECT_EQ(result, ERR_NONE);
2002 }
2003 } // namespace
2004 } // namespace Rosen
2005 } // namespace OHOS