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 "iremote_object_mocker.h"
21 #include "mock/mock_session_stub.h"
22 #include "session/host/include/zidl/session_stub.h"
23 #include "ability_start_setting.h"
24 #include "parcel/accessibility_event_info_parcel.h"
25 #include "session/host/include/zidl/session_ipc_interface_code.h"
26 #include "want.h"
27 #include "ws_common.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace Rosen {
34 namespace {
35 const std::string UNDEFINED = "undefined";
36 }
37
38 namespace OHOS::Accessibility {
39 class AccessibilityEventInfo;
40 }
41 class SessionStubTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47
48 private:
49 sptr<SessionStub> session_ = nullptr;
50 };
51
SetUpTestCase()52 void SessionStubTest::SetUpTestCase()
53 {
54 }
55
TearDownTestCase()56 void SessionStubTest::TearDownTestCase()
57 {
58 }
59
SetUp()60 void SessionStubTest::SetUp()
61 {
62 session_ = sptr<SessionStubMocker>::MakeSptr();
63 EXPECT_NE(nullptr, session_);
64 }
65
TearDown()66 void SessionStubTest::TearDown()
67 {
68 session_ = nullptr;
69 }
70
71 namespace {
72 /**
73 * @tc.name: OnRemoteRequest01
74 * @tc.desc: sessionStub OnRemoteRequest01
75 * @tc.type: FUNC
76 * @tc.require: #I6JLSI
77 */
78 HWTEST_F(SessionStubTest, OnRemoteRequest01, Function | SmallTest | Level2)
79 {
80 uint32_t code = 1;
81 MessageParcel data;
82 MessageParcel reply;
83 MessageOption option = {MessageOption::TF_SYNC};
84 auto res = session_->OnRemoteRequest(code, data, reply, option);
85 ASSERT_EQ(ERR_NONE, res);
86 data.WriteInterfaceToken(u"OHOS.ISession");
87 res = session_->OnRemoteRequest(code, data, reply, option);
88 ASSERT_EQ(ERR_NONE, res);
89 }
90
91 /**
92 * @tc.name: ProcessRemoteRequestTest01
93 * @tc.desc: sessionStub ProcessRemoteRequestTest01
94 * @tc.type: FUNC
95 * @tc.require: #I6JLSI
96 */
97 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest01, Function | SmallTest | Level2)
98 {
99 MessageParcel data;
100 MessageParcel reply;
101 MessageOption option = {MessageOption::TF_SYNC};
102 data.WriteBool(true);
103 auto res = session_->ProcessRemoteRequest(
104 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
105 ASSERT_EQ(ERR_NONE, res);
106
107 data.WriteBool(false);
108 data.WriteBool(true);
109 data.WriteString("");
110 res = session_->ProcessRemoteRequest(
111 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_FOREGROUND), data, reply, option);
112 ASSERT_EQ(ERR_NONE, res);
113
114 data.WriteBool(true);
115 data.WriteString("");
116 res = session_->ProcessRemoteRequest(
117 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKGROUND), data, reply, option);
118 ASSERT_EQ(ERR_NONE, res);
119
120 data.WriteBool(true);
121 data.WriteString("");
122 res = session_->ProcessRemoteRequest(
123 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DISCONNECT), data, reply, option);
124 ASSERT_EQ(ERR_NONE, res);
125 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
126 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
127 res = session_->ProcessRemoteRequest(
128 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_CONNECT), data, reply, option);
129 ASSERT_EQ(ERR_INVALID_DATA, res);
130 ASSERT_EQ(data.WriteUint32(100), true);
131 res = session_->ProcessRemoteRequest(
132 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SESSION_EVENT), data, reply, option);
133 ASSERT_EQ(ERR_NONE, res);
134 AAFwk::Want options;
135 EXPECT_NE(data.WriteString("HandleSessionException"), false);
136 EXPECT_NE(data.WriteParcelable(&options), false);
137 EXPECT_NE(data.WriteBool(false), false);
138 EXPECT_NE(data.WriteInt32(33), false);
139 res = session_->ProcessRemoteRequest(
140 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TERMINATE), data, reply, option);
141 ASSERT_EQ(ERR_NONE, res);
142 res = session_->ProcessRemoteRequest(
143 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_SESSION_RECT), data, reply, option);
144 ASSERT_EQ(ERR_NONE, res);
145 res = session_->ProcessRemoteRequest(
146 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_TO_APP_TOP), data, reply, option);
147 ASSERT_EQ(ERR_NONE, res);
148 }
149
150 /**
151 * @tc.name: ProcessRemoteRequestTest02
152 * @tc.desc: sessionStub ProcessRemoteRequestTest02
153 * @tc.type: FUNC
154 * @tc.require: #I6JLSI
155 */
156 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest02, Function | SmallTest | Level2)
157 {
158 MessageParcel data;
159 MessageParcel reply;
160 MessageOption option = {MessageOption::TF_SYNC};
161 data.WriteBool(true);
162 auto res = session_->ProcessRemoteRequest(
163 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_WINDOW_ANIMATION_FLAG), data, reply, option);
164 ASSERT_EQ(ERR_NONE, res);
165 res = session_->ProcessRemoteRequest(
166 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RAISE_APP_MAIN_WINDOW), data, reply, option);
167 ASSERT_EQ(ERR_NONE, res);
168 data.WriteBool(true);
169 res = session_->ProcessRemoteRequest(
170 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_BACKPRESSED), data, reply, option);
171 ASSERT_EQ(ERR_NONE, res);
172 res = session_->ProcessRemoteRequest(
173 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_MARK_PROCESSED), data, reply, option);
174 ASSERT_EQ(ERR_INVALID_DATA, res);
175 res = session_->ProcessRemoteRequest(
176 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_MAXIMIZE_MODE), data, reply, option);
177 ASSERT_EQ(ERR_INVALID_DATA, res);
178 res = session_->ProcessRemoteRequest(
179 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_MAXIMIZE_MODE), data, reply, option);
180 ASSERT_EQ(ERR_NONE, res);
181 res = session_->ProcessRemoteRequest(
182 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NEED_AVOID), data, reply, option);
183 ASSERT_EQ(ERR_INVALID_DATA, res);
184 res = session_->ProcessRemoteRequest(
185 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_GET_AVOID_AREA), data, reply, option);
186 ASSERT_EQ(ERR_INVALID_DATA, res);
187 res = session_->ProcessRemoteRequest(
188 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_ASPECT_RATIO), data, reply, option);
189 ASSERT_EQ(ERR_INVALID_DATA, res);
190 res = session_->ProcessRemoteRequest(
191 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_CUSTOM_ANIMATION), data, reply, option);
192 ASSERT_EQ(ERR_NONE, res);
193 res = session_->ProcessRemoteRequest(
194 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_EXTENSION_DATA), data, reply, option);
195 ASSERT_EQ(ERR_INVALID_VALUE, res);
196 res = session_->ProcessRemoteRequest(
197 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_DIED), data, reply, option);
198 ASSERT_EQ(ERR_NONE, res);
199 data.WriteInt32(1);
200 res = session_->ProcessRemoteRequest(
201 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_TIMEOUT), data, reply, option);
202 ASSERT_EQ(ERR_NONE, res);
203 }
204
205 /**
206 * @tc.name: ProcessRemoteRequestTest03
207 * @tc.desc: sessionStub ProcessRemoteRequestTest03
208 * @tc.type: FUNC
209 * @tc.require: #I6JLSI
210 */
211 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest03, Function | SmallTest | Level2)
212 {
213 MessageParcel data;
214 MessageParcel reply;
215 MessageOption option = {MessageOption::TF_SYNC};
216 data.WriteBool(true);
217 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
218 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
219 ASSERT_EQ(data.WriteUint32(1), true);
220 AAFwk::Want options;
221 EXPECT_NE(data.WriteString("HandleSessionException"), false);
222 EXPECT_NE(data.WriteParcelable(&options), false);
223 ASSERT_EQ(data.WriteUint64(2), true);
224 auto res = session_->ProcessRemoteRequest(
225 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SHOW), data, reply, option);
226 ASSERT_EQ(ERR_INVALID_DATA, res);
227 res = session_->ProcessRemoteRequest(
228 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_HIDE), data, reply, option);
229 ASSERT_EQ(ERR_NONE, res);
230 res = session_->ProcessRemoteRequest(
231 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_DRAWING_COMPLETED), data, reply, option);
232 ASSERT_EQ(ERR_NONE, res);
233 res = session_->ProcessRemoteRequest(
234 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_APP_REMOVE_STARTING_WINDOW), data, reply, option);
235 ASSERT_EQ(ERR_NONE, res);
236 res = session_->ProcessRemoteRequest(
237 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_RECTCHANGE_LISTENER_REGISTERED),
238 data,
239 reply,
240 option);
241 ASSERT_EQ(ERR_NONE, res);
242 res = session_->ProcessRemoteRequest(
243 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_LANDSCAPE_MULTI_WINDOW), data, reply, option);
244 ASSERT_EQ(ERR_NONE, res);
245 res = session_->ProcessRemoteRequest(
246 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ACTIVE_PENDING_SESSION), data, reply, option);
247 ASSERT_EQ(ERR_INVALID_DATA, res);
248 MessageParcel tmp;
249 tmp.WriteUint32(1);
250 res = session_->ProcessRemoteRequest(
251 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRANSFER_ABILITY_RESULT), tmp, reply, option);
252 ASSERT_EQ(ERR_INVALID_VALUE, res);
253 }
254
255 /**
256 * @tc.name: ProcessRemoteRequestTest04
257 * @tc.desc: sessionStub ProcessRemoteRequestTest04
258 * @tc.type: FUNC
259 * @tc.require: #I6JLSI
260 */
261 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest04, Function | SmallTest | Level2)
262 {
263 MessageParcel data;
264 MessageParcel reply;
265 MessageOption option = {MessageOption::TF_SYNC};
266 ASSERT_EQ(data.WriteInt32(1), true);
267 ASSERT_EQ(data.WriteInt32(2), true);
268 auto res = session_->ProcessRemoteRequest(
269 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_PROCESS_POINT_DOWN_SESSION), data, reply, option);
270 ASSERT_EQ(ERR_NONE, res);
271 res = session_->ProcessRemoteRequest(
272 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SEND_POINTEREVENT_FOR_MOVE_DRAG), data, reply, option);
273 ASSERT_EQ(ERR_INVALID_DATA, res);
274 res = session_->ProcessRemoteRequest(
275 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
276 ASSERT_EQ(ERR_INVALID_DATA, res);
277 res = session_->ProcessRemoteRequest(
278 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
279 ASSERT_EQ(ERR_INVALID_DATA, res);
280 res = session_->ProcessRemoteRequest(
281 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_ADJUST_KEYBOARD_LAYOUT), data, reply, option);
282 ASSERT_EQ(ERR_INVALID_DATA, res);
283 res = session_->ProcessRemoteRequest(
284 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_ASYNC_ON), data, reply, option);
285 ASSERT_EQ(ERR_NONE, res);
286 res = session_->ProcessRemoteRequest(
287 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_SYNC_ON), data, reply, option);
288 ASSERT_EQ(ERR_NONE, res);
289 res = session_->ProcessRemoteRequest(
290 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TRIGGER_BIND_MODAL_UI_EXTENSION), data, reply, option);
291 ASSERT_EQ(ERR_NONE, res);
292 }
293
294 /**
295 * @tc.name: ProcessRemoteRequestTest05
296 * @tc.desc: sessionStub ProcessRemoteRequestTest05
297 * @tc.type: FUNC
298 * @tc.require: #I6JLSI
299 */
300 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest05, Function | SmallTest | Level2)
301 {
302 MessageParcel data;
303 MessageParcel reply;
304 MessageOption option = {MessageOption::TF_SYNC};
305 data.WriteBool(true);
306 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
307 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
308 ASSERT_EQ(data.WriteUint32(1), true);
309 AAFwk::Want options;
310 EXPECT_NE(data.WriteString("HandleSessionException"), false);
311 EXPECT_NE(data.WriteParcelable(&options), false);
312 ASSERT_EQ(data.WriteUint64(2), true);
313 auto res = session_->ProcessRemoteRequest(
314 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_PIP_WINDOW_PREPARE_CLOSE), data, reply, option);
315 ASSERT_EQ(ERR_NONE, res);
316 res = session_->ProcessRemoteRequest(
317 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_LAYOUT_FULL_SCREEN_CHANGE), data, reply, option);
318 ASSERT_EQ(ERR_NONE, res);
319 res = session_->ProcessRemoteRequest(
320 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_RESTORE_MAIN_WINDOW), data, reply, option);
321 ASSERT_EQ(ERR_NONE, res);
322 res = session_->ProcessRemoteRequest(
323 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_DIALOG_SESSION_BACKGESTURE_ENABLE),
324 data,
325 reply,
326 option);
327 ASSERT_EQ(ERR_NONE, res);
328 }
329
330 /**
331 * @tc.name: ProcessRemoteRequestTest06
332 * @tc.desc: sessionStub ProcessRemoteRequestTest06
333 * @tc.type: FUNC
334 * @tc.require: #I6JLSI
335 */
336 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest06, Function | SmallTest | Level2)
337 {
338 MessageParcel data;
339 MessageParcel reply;
340 MessageOption option = {MessageOption::TF_SYNC};
341 AAFwk::Want want;
342 data.WriteParcelable(&want);
343 data.WriteBool(true);
344 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
345 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
346 ASSERT_EQ(data.WriteUint32(1), true);
347 ASSERT_EQ(data.WriteUint32(1), true);
348 AAFwk::Want options;
349 EXPECT_NE(data.WriteString("HandleSessionException"), false);
350 EXPECT_NE(data.WriteString("HandleSessionException"), false);
351 EXPECT_NE(data.WriteParcelable(&options), false);
352 ASSERT_EQ(data.WriteUint64(2), true);
353 auto res = session_->ProcessRemoteRequest(
354 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_EXCEPTION), data, reply, option);
355 ASSERT_EQ(ERR_NONE, res);
356 ASSERT_EQ(data.WriteUint32(1), true);
357 res = session_->ProcessRemoteRequest(
358 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CALLING_SESSION_ID), data, reply, option);
359 ASSERT_EQ(ERR_NONE, res);
360 ASSERT_EQ(data.WriteInt32(1), true);
361 res = session_->ProcessRemoteRequest(
362 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_CUSTOM_DECOR_HEIGHT), data, reply, option);
363 ASSERT_EQ(ERR_NONE, res);
364 }
365
366 /**
367 * @tc.name: ProcessRemoteRequestTest07
368 * @tc.desc: sessionStub ProcessRemoteRequestTest07
369 * @tc.type: FUNC
370 * @tc.require: #I6JLSI
371 */
372 HWTEST_F(SessionStubTest, ProcessRemoteRequestTest07, Function | SmallTest | Level2)
373 {
374 MessageParcel data;
375 MessageParcel reply;
376 MessageOption option = {MessageOption::TF_SYNC};
377 ASSERT_EQ(data.WriteInt32(1), true);
378 ASSERT_EQ(data.WriteInt32(1), true);
379 ASSERT_EQ(data.WriteUint32(1), true);
380 ASSERT_EQ(data.WriteUint32(1), true);
381 ASSERT_EQ(data.WriteUint32(1), true);
382 auto res = session_->ProcessRemoteRequest(
383 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_RECT), data, reply, option);
384 ASSERT_EQ(ERR_NONE, res);
385 ASSERT_EQ(data.WriteUint32(1), true);
386 ASSERT_EQ(data.WriteInt32(1), true);
387 res = session_->ProcessRemoteRequest(
388 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_PIP_CONTROL_STATUS), data, reply, option);
389 ASSERT_EQ(ERR_NONE, res);
390 ASSERT_EQ(data.WriteBool(true), true);
391 ASSERT_EQ(data.WriteBool(true), true);
392 res = session_->ProcessRemoteRequest(
393 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_TITLE_AND_DOCK_HOVER_SHOW_CHANGE), data, reply, option);
394 ASSERT_EQ(ERR_NONE, res);
395 ASSERT_EQ(data.WriteBool(true), true);
396 ASSERT_EQ(data.WriteBool(false), true);
397 res = session_->ProcessRemoteRequest(
398 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_RECT_AUTO_SAVE), data, reply, option);
399 ASSERT_EQ(ERR_NONE, res);
400 ASSERT_EQ(data.WriteInt32(1), true);
401 res = session_->ProcessRemoteRequest(
402 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_NOTIFY_EXTENSION_EVENT_ASYNC), data, reply, option);
403 ASSERT_EQ(ERR_NONE, res);
404 ASSERT_EQ(data.WriteFloat(1.0f), true);
405 res = session_->ProcessRemoteRequest(
406 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_WINDOW_CORNER_RADIUS), data, reply, option);
407 ASSERT_EQ(ERR_NONE, res);
408 ASSERT_EQ(data.WriteBool(true), true);
409 res = session_->ProcessRemoteRequest(
410 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_SET_FOLLOW_PARENT_MULTI_SCREEN_POLICY),
411 data, reply, option);
412 ASSERT_EQ(ERR_NONE, res);
413 ASSERT_EQ(data.WriteString("test"), true);
414 res = session_->ProcessRemoteRequest(
415 static_cast<uint32_t>(SessionInterfaceCode::TRANS_ID_UPDATE_FLAG), data, reply, option);
416 ASSERT_EQ(ERR_NONE, res);
417 }
418
419 /**
420 * @tc.name: sessionStubTest02
421 * @tc.desc: sessionStub sessionStubTest02
422 * @tc.type: FUNC
423 * @tc.require: #I6JLSI
424 */
425 HWTEST_F(SessionStubTest, sessionStubTest02, Function | SmallTest | Level2)
426 {
427 MessageParcel data;
428 MessageParcel reply;
429 data.WriteBool(true);
430 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
431 EXPECT_NE(data.WriteRemoteObject(iRemoteObjectMocker), false);
432 ASSERT_EQ(data.WriteUint32(1), true);
433 AAFwk::Want options;
434 EXPECT_NE(data.WriteString("HandleSessionException"), false);
435 EXPECT_NE(data.WriteParcelable(&options), false);
436 ASSERT_EQ(data.WriteUint64(2), true);
437 auto res = session_->HandleRaiseAboveTarget(data, reply);
438 ASSERT_EQ(ERR_NONE, res);
439 res = session_->HandleRaiseAppMainWindowToTop(data, reply);
440 ASSERT_EQ(ERR_NONE, res);
441 res = session_->HandleBackPressed(data, reply);
442 if (!data.ReadBool()) {
443 ASSERT_EQ(ERR_INVALID_DATA, res);
444 }
445 res = session_->HandleGetGlobalMaximizeMode(data, reply);
446 ASSERT_EQ(ERR_NONE, res);
447 res = session_->HandleUpdateWindowSceneAfterCustomAnimation(data, reply);
448 ASSERT_EQ(ERR_NONE, res);
449 res = session_->HandleNotifyExtensionDied(data, reply);
450 ASSERT_EQ(ERR_NONE, res);
451 res = session_->HandleGetStatusBarHeight(data, reply);
452 ASSERT_EQ(ERR_NONE, res);
453 }
454
455 /**
456 * @tc.name: sessionStubTest03
457 * @tc.desc: sessionStub sessionStubTest03
458 * @tc.type: FUNC
459 * @tc.require: #I6JLSI
460 */
461 HWTEST_F(SessionStubTest, sessionStubTest03, Function | SmallTest | Level2)
462 {
463 MessageParcel data;
464 MessageParcel reply;
465
466 ASSERT_EQ(data.WriteUint32(1), true);
467 auto res = session_->HandleSetGlobalMaximizeMode(data, reply);
468 ASSERT_EQ(ERR_NONE, res);
469 res = session_->HandleTransferExtensionData(data, reply);
470 ASSERT_EQ(ERR_INVALID_VALUE, res);
471 ASSERT_EQ(data.WriteInt32(2), true);
472 res = session_->HandleMarkProcessed(data, reply);
473 ASSERT_EQ(ERR_NONE, res);
474 ASSERT_EQ(data.WriteBool(true), true);
475 res = session_->HandleNeedAvoid(data, reply);
476 ASSERT_EQ(ERR_NONE, res);
477 ASSERT_EQ(data.WriteUint32(2), true);
478 ASSERT_EQ(data.WriteInt32(0), true);
479 ASSERT_EQ(data.WriteInt32(0), true);
480 ASSERT_EQ(data.WriteInt32(10), true);
481 ASSERT_EQ(data.WriteInt32(10), true);
482 ASSERT_EQ(data.WriteInt32(12), true);
483 res = session_->HandleGetAvoidAreaByType(data, reply);
484 ASSERT_EQ(ERR_NONE, res);
485 ASSERT_EQ(data.WriteFloat(2.0f), true);
486 res = session_->HandleSetAspectRatio(data, reply);
487 ASSERT_EQ(ERR_NONE, res);
488 ASSERT_EQ(data.WriteInt32(2), true);
489 res = session_->HandleNotifyExtensionTimeout(data, reply);
490 ASSERT_EQ(ERR_NONE, res);
491 ASSERT_EQ(data.WriteInt32(2), true);
492 AAFwk::Want want;
493 data.WriteParcelable(&want);
494 res = session_->HandleTransferAbilityResult(data, reply);
495 ASSERT_EQ(ERR_NONE, res);
496 }
497
498 /**
499 * @tc.name: HandleTriggerBindModalUIExtension001
500 * @tc.desc: sessionStub sessionStubTest
501 * @tc.type: FUNC
502 * @tc.require: #I6JLSI
503 */
504 HWTEST_F(SessionStubTest, HandleTriggerBindModalUIExtension001, Function | SmallTest | Level2)
505 {
506 MessageParcel data;
507 MessageParcel reply;
508 data.WriteBool(true);
509 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
510 auto res = session_->HandleTriggerBindModalUIExtension(data, reply);
511 ASSERT_EQ(ERR_NONE, res);
512 }
513
514 /**
515 * @tc.name: HandleTransferAccessibilityEvent002
516 * @tc.desc: sessionStub sessionStubTest
517 * @tc.type: FUNC
518 * @tc.require: #I6JLSI
519 */
520 HWTEST_F(SessionStubTest, HandleTransferAccessibilityEvent003, Function | SmallTest | Level2)
521 {
522 MessageParcel data;
523 MessageParcel reply;
524 data.WriteBool(true);
525 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
526 auto res = session_->HandleTransferAccessibilityEvent(data, reply);
527 ASSERT_EQ(ERR_INVALID_DATA, res);
528 }
529
530 /**
531 * @tc.name: HandleNotifyPiPWindowPrepareClose003
532 * @tc.desc: sessionStub sessionStubTest
533 * @tc.type: FUNC
534 * @tc.require: #I6JLSI
535 */
536 HWTEST_F(SessionStubTest, HandleNotifyPiPWindowPrepareClose003, Function | SmallTest | Level2)
537 {
538 MessageParcel data;
539 MessageParcel reply;
540 data.WriteBool(true);
541 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
542 auto res = session_->HandleNotifyPiPWindowPrepareClose(data, reply);
543 ASSERT_EQ(ERR_NONE, res);
544 }
545
546 /**
547 * @tc.name: HandleUpdatePiPRect001
548 * @tc.desc: sessionStub sessionStubTest
549 * @tc.type: FUNC
550 * @tc.require: #I6JLSI
551 */
552 HWTEST_F(SessionStubTest, HandleUpdatePiPRect001, Function | SmallTest | Level2)
553 {
554 MessageParcel data;
555 MessageParcel reply;
556 float width = 0.55;
557 float height = 0.55;
558 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
559 data.WriteInt32(-1);
560 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
561 data.WriteInt32(10);
562 data.WriteInt32(-1);
563 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
564 data.WriteInt32(10);
565 data.WriteInt32(20);
566 data.WriteUint32(width);
567 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
568 data.WriteInt32(10);
569 data.WriteInt32(20);
570 data.WriteUint32(30);
571 data.WriteUint32(height);
572 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
573 }
574
575 /**
576 * @tc.name: HandleUpdatePiPRect002
577 * @tc.desc: sessionStub sessionStubTest
578 * @tc.type: FUNC
579 * @tc.require: #I6JLSI
580 */
581 HWTEST_F(SessionStubTest, HandleUpdatePiPRect002, Function | SmallTest | Level2)
582 {
583 MessageParcel data;
584 MessageParcel reply;
585 data.WriteInt32(10);
586 data.WriteInt32(20);
587 data.WriteUint32(30);
588 data.WriteUint32(40);
589 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleUpdatePiPRect(data, reply));
590 data.WriteInt32(10);
591 data.WriteInt32(20);
592 data.WriteUint32(30);
593 data.WriteUint32(40);
594 data.WriteUint32(3);
595 ASSERT_EQ(ERR_NONE, session_->HandleUpdatePiPRect(data, reply));
596 }
597
598 /**
599 * @tc.name: HandleUpdatePiPControlStatus
600 * @tc.desc: sessionStub sessionStubTest
601 * @tc.type: FUNC
602 * @tc.require: #I6JLSI
603 */
604 HWTEST_F(SessionStubTest, HandleUpdatePiPControlStatus, Function | SmallTest | Level2)
605 {
606 ASSERT_NE(session_, nullptr);
607 MessageParcel data;
608 MessageParcel reply;
609 uint32_t controlType = -1;
610 int32_t status = 1;
611 data.WriteUint32(controlType);
612 data.WriteInt32(status);
613 auto res = session_->HandleUpdatePiPControlStatus(data, reply);
614 ASSERT_EQ(ERR_INVALID_DATA, res);
615 data.WriteUint32(10);
616 data.WriteInt32(status);
617 res = session_->HandleUpdatePiPControlStatus(data, reply);
618 ASSERT_EQ(ERR_INVALID_DATA, res);
619 data.WriteUint32(2);
620 data.WriteInt32(-4);
621 res = session_->HandleUpdatePiPControlStatus(data, reply);
622 ASSERT_EQ(ERR_INVALID_DATA, res);
623 data.WriteUint32(2);
624 data.WriteInt32(4);
625 res = session_->HandleUpdatePiPControlStatus(data, reply);
626 ASSERT_EQ(ERR_INVALID_DATA, res);
627 data.WriteUint32(2);
628 data.WriteInt32(1);
629 res = session_->HandleUpdatePiPControlStatus(data, reply);
630 ASSERT_EQ(ERR_NONE, res);
631 }
632
633 /**
634 * @tc.name: HandleSetAutoStartPiP
635 * @tc.desc: sessionStub sessionStubTest
636 * @tc.type: FUNC
637 * @tc.require: #I6JLSI
638 */
639 HWTEST_F(SessionStubTest, HandleSetAutoStartPiP, Function | SmallTest | Level2)
640 {
641 ASSERT_NE(session_, nullptr);
642 MessageParcel data;
643 MessageParcel reply;
644 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetAutoStartPiP(data, reply));
645 bool isAutoStartValid = true;
646 uint32_t priority = 0;
647 uint32_t width = 0;
648 uint32_t height = 0;
649 data.WriteInt32(10);
650 ASSERT_EQ(ERR_INVALID_DATA, session_->HandleSetAutoStartPiP(data, reply));
651 data.WriteBool(isAutoStartValid);
652 data.WriteUint32(priority);
653 data.WriteUint32(width);
654 data.WriteUint32(height);
655 ASSERT_EQ(ERR_NONE, session_->HandleSetAutoStartPiP(data, reply));
656 }
657
658 /**
659 * @tc.name: HandleProcessPointDownSession006
660 * @tc.desc: sessionStub sessionStubTest
661 * @tc.type: FUNC
662 * @tc.require: #I6JLSI
663 */
664 HWTEST_F(SessionStubTest, HandleProcessPointDownSession006, Function | SmallTest | Level2)
665 {
666 MessageParcel data;
667 MessageParcel reply;
668 data.WriteInt32(10);
669 data.WriteInt32(20);
670 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
671 auto res = session_->HandleProcessPointDownSession(data, reply);
672 ASSERT_EQ(ERR_NONE, res);
673 }
674
675 /**
676 * @tc.name: HandleSendPointerEvenForMoveDrag007
677 * @tc.desc: sessionStub sessionStubTest
678 * @tc.type: FUNC
679 * @tc.require: #I6JLSI
680 */
681 HWTEST_F(SessionStubTest, HandleSendPointerEvenForMoveDrag007, Function | SmallTest | Level2)
682 {
683 MessageParcel data;
684 MessageParcel reply;
685 data.WriteBool(true);
686 sptr<IRemoteObjectMocker> iRemoteObjectMocker = sptr<IRemoteObjectMocker>::MakeSptr();
687 auto res = session_->HandleSendPointerEvenForMoveDrag(data, reply);
688 ASSERT_EQ(ERR_INVALID_DATA, res);
689 }
690
691 /**
692 * @tc.name: HandleNotifySyncOn012
693 * @tc.desc: sessionStub sessionStubTest
694 * @tc.type: FUNC
695 * @tc.require: #I6JLSI
696 */
697 HWTEST_F(SessionStubTest, HandleNotifySyncOn012, Function | SmallTest | Level2)
698 {
699 MessageParcel data;
700 MessageParcel reply;
701 data.WriteBool(true);
702 auto res = session_->HandleNotifySyncOn(data, reply);
703 ASSERT_EQ(ERR_NONE, res);
704 }
705
706 /**
707 * @tc.name: HandleNotifyAsyncOn013
708 * @tc.desc: sessionStub sessionStubTest
709 * @tc.type: FUNC
710 * @tc.require: #I6JLSI
711 */
712 HWTEST_F(SessionStubTest, HandleNotifyAsyncOn013, Function | SmallTest | Level2)
713 {
714 MessageParcel data;
715 MessageParcel reply;
716 data.WriteBool(true);
717 auto res = session_->HandleNotifyAsyncOn(data, reply);
718 ASSERT_EQ(ERR_NONE, res);
719 }
720
721 /**
722 * @tc.name: HandleNotifyExtensionTimeout014
723 * @tc.desc: sessionStub sessionStubTest
724 * @tc.type: FUNC
725 * @tc.require: #I6JLSI
726 */
727 HWTEST_F(SessionStubTest, HandleNotifyExtensionTimeout014, Function | SmallTest | Level2)
728 {
729 MessageParcel data;
730 MessageParcel reply;
731 data.WriteBool(true);
732 auto res = session_->HandleNotifyExtensionTimeout(data, reply);
733 ASSERT_EQ(ERR_NONE, res);
734 }
735
736 /**
737 * @tc.name: HandleGetAppForceLandscapeConfig
738 * @tc.desc: sessionStub sessionStubTest
739 * @tc.type: FUNC
740 * @tc.require: #I6JLSI
741 */
742 HWTEST_F(SessionStubTest, HandleGetAppForceLandscapeConfig, Function | SmallTest | Level2)
743 {
744 MessageParcel data;
745 MessageParcel reply;
746 ASSERT_NE(session_, nullptr);
747 auto res = session_->HandleGetAppForceLandscapeConfig(data, reply);
748 ASSERT_EQ(ERR_NONE, res);
749 }
750
751 /**
752 * @tc.name: HandleSetDialogSessionBackGestureEnabled01
753 * @tc.desc: sessionStub sessionStubTest
754 * @tc.type: FUNC
755 * @tc.require: #I6JLSI
756 */
757 HWTEST_F(SessionStubTest, HandleSetDialogSessionBackGestureEnabled01, Function | SmallTest | Level2)
758 {
759 MessageParcel data;
760 MessageParcel reply;
761 data.WriteBool(true);
762 auto res = session_->HandleSetDialogSessionBackGestureEnabled(data, reply);
763 ASSERT_EQ(ERR_NONE, res);
764 }
765
766 /**
767 * @tc.name: HandleRequestFocus
768 * @tc.desc: sessionStub HandleRequestFocusTest
769 * @tc.type: FUNC
770 * @tc.require: #IAPLFA
771 */
772 HWTEST_F(SessionStubTest, HandleRequestFocus, Function | SmallTest | Level2)
773 {
774 MessageParcel data;
775 MessageParcel reply;
776 data.WriteBool(false);
777 ASSERT_NE(session_, nullptr);
778 auto res = session_->HandleRequestFocus(data, reply);
779 ASSERT_EQ(0, res);
780 }
781
782 /**
783 * @tc.name: HandleSyncSessionEvent1
784 * @tc.desc: sessionStub HandleSyncSessionEvent
785 * @tc.type: FUNC
786 */
787 HWTEST_F(SessionStubTest, HandleSyncSessionEvent1, Function | SmallTest | Level2)
788 {
789 MessageParcel data;
790 MessageParcel reply;
791
792 data.WriteUint32(static_cast<uint32_t>(SessionEvent::EVENT_MAXIMIZE));
793 auto result = session_->HandleSyncSessionEvent(data, reply);
794 ASSERT_EQ(result, ERR_NONE);
795 }
796
797 /**
798 * @tc.name: HandleSyncSessionEvent2
799 * @tc.desc: sessionStub HandleSyncSessionEvent
800 * @tc.type: FUNC
801 */
802 HWTEST_F(SessionStubTest, HandleSyncSessionEvent2, Function | SmallTest | Level2)
803 {
804 MessageParcel data;
805 MessageParcel reply;
806
807 data.WriteUint32(0xFFFFFFFF);
808 auto result = session_->HandleSyncSessionEvent(data, reply);
809 ASSERT_EQ(result, ERR_NONE);
810
811 result = session_->HandleSyncSessionEvent(data, reply);
812 ASSERT_EQ(result, ERR_INVALID_DATA);
813 }
814
815 /**
816 * @tc.name: GetIsMidScene
817 * @tc.desc: sessionStub GetIsMidScene
818 * @tc.type: FUNC
819 */
820 HWTEST_F(SessionStubTest, GetIsMidScene, Function | SmallTest | Level2)
821 {
822 MessageParcel data;
823 MessageParcel reply;
824
825 auto result = session_->HandleGetIsMidScene(data, reply);
826 ASSERT_EQ(result, ERR_NONE);
827 }
828
829 /**
830 * @tc.name: HandleNotifyFrameLayoutFinish
831 * @tc.desc: sessionStub HandleNotifyFrameLayoutFinish
832 * @tc.type: FUNC
833 */
834 HWTEST_F(SessionStubTest, HandleNotifyFrameLayoutFinish, Function | SmallTest | Level2)
835 {
836 MessageParcel data;
837 MessageParcel reply;
838
839 auto result = session_->HandleNotifyFrameLayoutFinish(data, reply);
840 ASSERT_EQ(result, ERR_NONE);
841 }
842
843 /**
844 * @tc.name: HandleSyncSessionEvent
845 * @tc.desc: sessionStub HandleSyncSessionEvent
846 * @tc.type: FUNC
847 */
848 HWTEST_F(SessionStubTest, HandleSyncSessionEvent, Function | SmallTest | Level2)
849 {
850 MessageParcel data;
851 MessageParcel reply;
852
853 auto result = session_->HandleSyncSessionEvent(data, reply);
854 ASSERT_EQ(result, ERR_INVALID_DATA);
855 }
856
857 /**
858 * @tc.name: HandlePendingSessionActivation
859 * @tc.desc: sessionStub HandlePendingSessionActivation
860 * @tc.type: FUNC
861 */
862 HWTEST_F(SessionStubTest, HandlePendingSessionActivation, Function | SmallTest | Level2)
863 {
864 MessageParcel data;
865 MessageParcel reply;
866
867 auto result = session_->HandlePendingSessionActivation(data, reply);
868 ASSERT_EQ(result, ERR_INVALID_DATA);
869 }
870
871 /**
872 * @tc.name: HandleGetGlobalScaledRect
873 * @tc.desc: sessionStub HandleGetGlobalScaledRect
874 * @tc.type: FUNC
875 */
876 HWTEST_F(SessionStubTest, HandleGetGlobalScaledRect, Function | SmallTest | Level2)
877 {
878 MessageParcel data;
879 MessageParcel reply;
880
881 auto result = session_->HandleGetGlobalScaledRect(data, reply);
882 ASSERT_EQ(result, ERR_NONE);
883 }
884
885 /**
886 * @tc.name: HandleGetAllAvoidAreas
887 * @tc.desc: sessionStub HandleGetAllAvoidAreas
888 * @tc.type: FUNC
889 */
890 HWTEST_F(SessionStubTest, HandleGetAllAvoidAreas, Function | SmallTest | Level2)
891 {
892 MessageParcel data;
893 MessageParcel reply;
894
895 auto result = session_->HandleGetAllAvoidAreas(data, reply);
896 ASSERT_EQ(result, ERR_NONE);
897 }
898
899 /**
900 * @tc.name: HandleIsStartMoving
901 * @tc.desc: sessionStub HandleIsStartMoving
902 * @tc.type: FUNC
903 */
904 HWTEST_F(SessionStubTest, HandleIsStartMoving, Function | SmallTest | Level2)
905 {
906 MessageParcel data;
907 MessageParcel reply;
908
909 auto result = session_->HandleIsStartMoving(data, reply);
910 ASSERT_EQ(result, ERR_NONE);
911 }
912
913 /**
914 * @tc.name: HandleSetSessionLabelAndIcon01
915 * @tc.desc: HandleSetSessionLabelAndIcon
916 * @tc.type: FUNC
917 */
918 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon01, Function | SmallTest | Level2)
919 {
920 MessageParcel data;
921 MessageParcel reply;
922 std::shared_ptr<Media::PixelMap> icon = std::make_shared<Media::PixelMap>();
923 data.WriteParcelable(icon.get());
924
925 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
926 ASSERT_EQ(ERR_INVALID_DATA, res);
927 }
928
929 /**
930 * @tc.name: HandleSetSessionLabelAndIcon02
931 * @tc.desc: HandleSetSessionLabelAndIcon
932 * @tc.type: FUNC
933 */
934 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon02, Function | SmallTest | Level2)
935 {
936 MessageParcel data;
937 MessageParcel reply;
938 std::string label = "demo label";
939 data.WriteString(label);
940 std::shared_ptr<Media::PixelMap> icon = nullptr;
941 data.WriteParcelable(icon.get());
942
943 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
944 ASSERT_EQ(ERR_INVALID_DATA, res);
945 }
946
947 /**
948 * @tc.name: HandleSetSessionLabelAndIcon03
949 * @tc.desc: HandleSetSessionLabelAndIcon
950 * @tc.type: FUNC
951 */
952 HWTEST_F(SessionStubTest, HandleSetSessionLabelAndIcon03, Function | SmallTest | Level2)
953 {
954 MessageParcel data;
955 MessageParcel reply;
956 std::string label = "demo label";
957 data.WriteString(label);
958 const uint32_t color[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80};
959 uint32_t len = sizeof(color) / sizeof(color[0]);
960 Media::InitializationOptions opts;
961 opts.size.width = 2;
962 opts.size.height = 3;
963 opts.pixelFormat = Media::PixelFormat::UNKNOWN;
964 opts.alphaType = Media::AlphaType::IMAGE_ALPHA_TYPE_OPAQUE;
965 std::shared_ptr<Media::PixelMap> icon = Media::PixelMap::Create(color, len, 0, opts.size.width, opts);
966 data.WriteParcelable(icon.get());
967
968 auto res = session_->HandleSetSessionLabelAndIcon(data, reply);
969 ASSERT_EQ(ERR_NONE, res);
970 }
971
972 /**
973 * @tc.name: HandleGetCrossAxisState
974 * @tc.desc: HandleGetCrossAxisState
975 * @tc.type: FUNC
976 */
977 HWTEST_F(SessionStubTest, HandleGetCrossAxisState, Function | SmallTest | Level2)
978 {
979 MessageParcel data;
980 MessageParcel reply;
981 sptr<SessionStubMocker> session = sptr<SessionStubMocker>::MakeSptr();
982 EXPECT_CALL(*session, GetCrossAxisState(_)).
983 WillOnce(DoAll(SetArgReferee<0>(CrossAxisState::STATE_CROSS), Return(WSError::WS_OK)));
984 session->HandleGetCrossAxisState(data, reply);
985 uint32_t state = 0;
986 reply.ReadUint32(state);
987 ASSERT_EQ(state, static_cast<uint32_t>(CrossAxisState::STATE_CROSS));
988 }
989
990 /**
991 * @tc.name: HandleContainerModalEvent
992 * @tc.desc: sessionStub HandleContainerModalEvent
993 * @tc.type: FUNC
994 */
995 HWTEST_F(SessionStubTest, HandleContainerModalEvent, Function | SmallTest | Level2)
996 {
997 MessageParcel data;
998 MessageParcel reply;
999 data.WriteString("name");
1000 data.WriteString("value");
1001 auto result = session_->HandleContainerModalEvent(data, reply);
1002 ASSERT_EQ(result, ERR_NONE);
1003 result = session_->HandleContainerModalEvent(data, reply);
1004 ASSERT_EQ(result, ERR_INVALID_DATA);
1005 }
1006
1007 /**
1008 * @tc.name: GetIsHighlighted
1009 * @tc.desc: sessionStub GetIsHighlighted
1010 * @tc.type: FUNC
1011 */
1012 HWTEST_F(SessionStubTest, GetIsHighlighted, Function | SmallTest | Level2)
1013 {
1014 MessageParcel data;
1015 MessageParcel reply;
1016 auto result = session_->HandleGetIsHighlighted(data, reply);
1017 ASSERT_EQ(result, ERR_NONE);
1018 }
1019 }
1020 } // namespace Rosen
1021 } // namespace OHOS