1 /*
2 * Copyright (C) 2022 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 "mock_accessible_ability_channel_stub_impl.h"
18 #include "accessibility_element_operator_callback_proxy.h"
19 #include "accessibility_operator.h"
20 #include "accessible_ability_channel_stub.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24 using namespace std;
25
26 namespace OHOS {
27 namespace Accessibility {
28 class AccessibleAbilityChannelStubUnitTest : public ::testing::Test {
29 public:
AccessibleAbilityChannelStubUnitTest()30 AccessibleAbilityChannelStubUnitTest() {}
~AccessibleAbilityChannelStubUnitTest()31 ~AccessibleAbilityChannelStubUnitTest() {}
32
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37
38 void WriteInterfaceToken(MessageParcel &data);
39 sptr<AccessibleAbilityChannelStubImplMock> stub_ = nullptr;
40 };
41
SetUpTestCase()42 void AccessibleAbilityChannelStubUnitTest::SetUpTestCase()
43 {
44 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelStubUnitTest Start ######################";
45 }
46
TearDownTestCase()47 void AccessibleAbilityChannelStubUnitTest::TearDownTestCase()
48 {
49 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelStubUnitTest End ######################";
50 }
51
SetUp()52 void AccessibleAbilityChannelStubUnitTest::SetUp()
53 {
54 GTEST_LOG_(INFO) << "SetUp";
55 stub_ = new AccessibleAbilityChannelStubImplMock();
56 }
57
TearDown()58 void AccessibleAbilityChannelStubUnitTest::TearDown()
59 {
60 GTEST_LOG_(INFO) << "TearDown";
61 stub_ = nullptr;
62 }
63
WriteInterfaceToken(MessageParcel & data)64 void AccessibleAbilityChannelStubUnitTest::WriteInterfaceToken(MessageParcel &data)
65 {
66 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest WriteInterfaceToken";
67 data.WriteInterfaceToken(AccessibleAbilityChannelStub::GetDescriptor());
68 }
69
70 /**
71 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_001
72 * @tc.name: OnRemoteRequest
73 * @tc.desc: Test function HandleSearchElementInfoByAccessibilityId
74 */
75 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
76 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_001, TestSize.Level1)
77 {
78 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_001 start";
79
80 MessageParcel data;
81 MessageParcel reply;
82 MessageOption option;
83 int accessibilityWindowId = 0;
84 long elementId = 0;
85 int requestId = 0;
86 int mode = 0;
87 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
88 sptr<IAccessibilityElementOperatorCallback> callback =
89 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
90
91 WriteInterfaceToken(data);
92 data.WriteInt32(accessibilityWindowId);
93 data.WriteInt64(elementId);
94 data.WriteInt32(requestId);
95 data.WriteRemoteObject(callback->AsObject());
96 data.WriteInt32(mode);
97
98 int res = stub_->OnRemoteRequest(
99 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFO_BY_ACCESSIBILITYID),
100 data, reply, option);
101 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
102 EXPECT_TRUE(reply.ReadBool());
103
104 stub = nullptr;
105 callback = nullptr;
106
107 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_001 end";
108 }
109
110 /**
111 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_002
112 * @tc.name: OnRemoteRequest
113 * @tc.desc: Test function HandleSearchElementInfosByText
114 */
115 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
116 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_002, TestSize.Level1)
117 {
118 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_002 start";
119
120 MessageParcel data;
121 MessageParcel reply;
122 MessageOption option;
123
124 int accessibilityWindowId = 0;
125 long elementId = 0;
126 std::string text = "";
127 int requestId = 0;
128 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
129 sptr<IAccessibilityElementOperatorCallback> callback =
130 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
131
132 WriteInterfaceToken(data);
133 data.WriteInt32(accessibilityWindowId);
134 data.WriteInt32(elementId);
135 data.WriteString(text);
136 data.WriteInt32(requestId);
137 data.WriteRemoteObject(callback->AsObject());
138
139 int res = stub_->OnRemoteRequest(
140 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFOS_BY_TEXT),
141 data, reply, option);
142 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
143 EXPECT_TRUE(reply.ReadBool());
144
145 stub = nullptr;
146 callback = nullptr;
147
148 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_002 end";
149 }
150
151 /**
152 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_003
153 * @tc.name: OnRemoteRequest
154 * @tc.desc: Test function HandleFindFocusedElementInfo
155 */
156 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
157 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_003, TestSize.Level1)
158 {
159 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_003 start";
160
161 MessageParcel data;
162 MessageParcel reply;
163 MessageOption option;
164
165 int accessibilityWindowId = 0;
166 long elementId = 0;
167 int focusType = 0;
168 int requestId = 0;
169 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
170 sptr<IAccessibilityElementOperatorCallback> callback =
171 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
172
173 WriteInterfaceToken(data);
174 data.WriteInt32(accessibilityWindowId);
175 data.WriteInt32(elementId);
176 data.WriteInt32(focusType);
177 data.WriteInt32(requestId);
178 data.WriteRemoteObject(callback->AsObject());
179
180 int res = stub_->OnRemoteRequest(
181 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::FIND_FOCUSED_ELEMENTINFO),
182 data, reply, option);
183 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
184 EXPECT_TRUE(reply.ReadBool());
185
186 stub = nullptr;
187 callback = nullptr;
188
189 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_003 end";
190 }
191
192 /**
193 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_004
194 * @tc.name: OnRemoteRequest
195 * @tc.desc: Test function HandleFocusMoveSearch
196 */
197 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
198 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_004, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_004 start";
201
202 MessageParcel data;
203 MessageParcel reply;
204 MessageOption option;
205
206 int accessibilityWindowId = 0;
207 long elementId = 0;
208 int direction = 0;
209 int requestId = 0;
210 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
211 sptr<IAccessibilityElementOperatorCallback> callback =
212 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
213
214 WriteInterfaceToken(data);
215 data.WriteInt32(accessibilityWindowId);
216 data.WriteInt32(elementId);
217 data.WriteInt32(direction);
218 data.WriteInt32(requestId);
219 data.WriteRemoteObject(callback->AsObject());
220
221 int res = stub_->OnRemoteRequest(
222 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::FOCUS_MOVE_SEARCH),
223 data, reply, option);
224 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
225 EXPECT_TRUE(reply.ReadBool());
226
227 stub = nullptr;
228 callback = nullptr;
229
230 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_004 end";
231 }
232
233 /**
234 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_005
235 * @tc.name: OnRemoteRequest
236 * @tc.desc: Test function HandleExecuteAction
237 */
238 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
239 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_005, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_005 start";
242
243 MessageParcel data;
244 MessageParcel reply;
245 MessageOption option;
246
247 int accessibilityWindowId = 0;
248 long elementId = 0;
249 int action = 0;
250 std::map<std::string, std::string> actionArguments {};
251 int requestId = 0;
252 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
253 sptr<IAccessibilityElementOperatorCallback> callback =
254 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
255
256 WriteInterfaceToken(data);
257 data.WriteInt32(accessibilityWindowId);
258 data.WriteInt32(elementId);
259 data.WriteInt32(action);
260
261 vector<string> actionArgumentsKey {};
262 vector<string> actionArgumentsValue {};
263 for (auto iter = actionArguments.begin(); iter != actionArguments.end(); iter++) {
264 actionArgumentsKey.push_back(iter->first);
265 actionArgumentsValue.push_back(iter->second);
266 }
267 data.WriteStringVector(actionArgumentsKey);
268 data.WriteStringVector(actionArgumentsValue);
269 data.WriteInt32(requestId);
270 data.WriteRemoteObject(callback->AsObject());
271
272 int res = stub_->OnRemoteRequest(
273 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::PERFORM_ACTION),
274 data, reply, option);
275 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
276 EXPECT_TRUE(reply.ReadBool());
277
278 stub = nullptr;
279 callback = nullptr;
280
281 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_005 end";
282 }
283
284 /**
285 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_006
286 * @tc.name: OnRemoteRequest
287 * @tc.desc: Test function HandleGetWindows
288 */
289 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
290 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_006, TestSize.Level1)
291 {
292 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_006 start";
293
294 MessageParcel data;
295 MessageParcel reply;
296 MessageOption option;
297
298 WriteInterfaceToken(data);
299
300 int res = stub_->OnRemoteRequest(
301 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::GET_WINDOWS),
302 data, reply, option);
303 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
304 EXPECT_EQ(reply.ReadInt32(), 1);
305
306 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_006 end";
307 }
308
309 /**
310 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_007
311 * @tc.name: OnRemoteRequest
312 * @tc.desc: Test function HandleExecuteCommonAction
313 */
314 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
315 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_007, TestSize.Level1)
316 {
317 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_007 start";
318
319 MessageParcel data;
320 MessageParcel reply;
321 MessageOption option;
322 int action = 0;
323
324 WriteInterfaceToken(data);
325 data.WriteInt32(action);
326
327 int res = stub_->OnRemoteRequest(
328 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::EXECUTE_COMMON_ACTION),
329 data, reply, option);
330 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
331 EXPECT_TRUE(reply.ReadBool());
332
333 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_007 end";
334 }
335
336 /**
337 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_009
338 * @tc.name: OnRemoteRequest
339 * @tc.desc: Test function HandleSetOnKeyPressEventResult
340 */
341 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
342 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_009, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_009 start";
345
346 MessageParcel data;
347 MessageParcel reply;
348 MessageOption option;
349 bool handled = true;
350 int sequence = 0;
351
352 WriteInterfaceToken(data);
353 data.WriteBool(handled);
354 data.WriteInt32(sequence);
355
356 int res = stub_->OnRemoteRequest(
357 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::SET_ON_KEY_PRESS_EVENT_RESULT),
358 data, reply, option);
359 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
360
361 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_009 end";
362 }
363
364 /**
365 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_010
366 * @tc.name: OnRemoteRequest
367 * @tc.desc: Test function HandleGetDisplayResizeScale
368 */
369 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
370 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_010, TestSize.Level1)
371 {
372 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_010 start";
373
374 MessageParcel data;
375 MessageParcel reply;
376 MessageOption option;
377 int displayId = 0;
378
379 WriteInterfaceToken(data);
380 data.WriteInt32(displayId);
381
382 int res = stub_->OnRemoteRequest(
383 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_SCALE), data, reply, option);
384 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
385 EXPECT_EQ(reply.ReadFloat(), 0);
386
387 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_010 end";
388 }
389
390 /**
391 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_011
392 * @tc.name: OnRemoteRequest
393 * @tc.desc: Test function HandleGetDisplayResizeCenterX
394 */
395 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
396 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_011, TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_011 start";
399
400 MessageParcel data;
401 MessageParcel reply;
402 MessageOption option;
403 int displayId = 0;
404
405 WriteInterfaceToken(data);
406 data.WriteInt32(displayId);
407
408 int res = stub_->OnRemoteRequest(
409 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_CETER_X), data, reply, option);
410 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
411 EXPECT_EQ(reply.ReadFloat(), 0);
412
413 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_011 end";
414 }
415
416 /**
417 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_012
418 * @tc.name: OnRemoteRequest
419 * @tc.desc: Test function HandleGetDisplayResizeCenterY
420 */
421 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
422 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_012, TestSize.Level1)
423 {
424 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_012 start";
425
426 MessageParcel data;
427 MessageParcel reply;
428 MessageOption option;
429 int displayId = 0;
430
431 WriteInterfaceToken(data);
432 data.WriteInt32(displayId);
433
434 int res = stub_->OnRemoteRequest(
435 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_CETER_Y), data, reply, option);
436 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
437 EXPECT_EQ(reply.ReadFloat(), 0);
438
439 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_012 end";
440 }
441
442 /**
443 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_013
444 * @tc.name: OnRemoteRequest
445 * @tc.desc: Test function HandleGetDisplayResizeRect
446 */
447 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
448 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_013, TestSize.Level1)
449 {
450 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_013 start";
451
452 MessageParcel data;
453 MessageParcel reply;
454 MessageOption option;
455 int displayId = 0;
456
457 WriteInterfaceToken(data);
458 data.WriteInt32(displayId);
459
460 int res = stub_->OnRemoteRequest(
461 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_RECT), data, reply, option);
462 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
463
464 sptr<Rect> result = reply.ReadStrongParcelable<Rect>();
465 EXPECT_NE(result, nullptr);
466 EXPECT_EQ(result->GetLeftTopXScreenPostion(), 1);
467 EXPECT_EQ(result->GetLeftTopYScreenPostion(), 1);
468
469 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_013 end";
470 }
471
472 /**
473 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_014
474 * @tc.name: OnRemoteRequest
475 * @tc.desc: Test function HandleResetDisplayResize
476 */
477 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
478 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_014, TestSize.Level1)
479 {
480 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_014 start";
481
482 MessageParcel data;
483 MessageParcel reply;
484 MessageOption option;
485 int displayId = 0;
486 bool animate = true;
487
488 WriteInterfaceToken(data);
489 data.WriteInt32(displayId);
490 data.WriteBool(animate);
491
492 int res = stub_->OnRemoteRequest(
493 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::RESET_DISPALYRESIZE), data, reply, option);
494 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
495 EXPECT_TRUE(reply.ReadBool());
496
497 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_014 end";
498 }
499
500 /**
501 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_015
502 * @tc.name: OnRemoteRequest
503 * @tc.desc: Test function HandleSetDisplayResizeScaleAndCenter
504 */
505 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
506 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_015, TestSize.Level1)
507 {
508 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_015 start";
509
510 MessageParcel data;
511 MessageParcel reply;
512 MessageOption option;
513
514 int displayId = 0;
515 float scale = 0;
516 float centerX = 0;
517 float centerY = 0;
518 bool animate = true;
519
520 WriteInterfaceToken(data);
521 data.WriteInt32(displayId);
522 data.WriteFloat(scale);
523 data.WriteFloat(centerX);
524 data.WriteFloat(centerY);
525 data.WriteBool(animate);
526
527 int res = stub_->OnRemoteRequest(
528 static_cast<uint32_t>(IAccessibleAbilityChannel::Message::SET_DISPLAYRESIZE_SCALE_AND_CENTER),
529 data, reply, option);
530 EXPECT_EQ(res, OHOS::Accessibility::NO_ERROR);
531 EXPECT_TRUE(reply.ReadBool());
532
533 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_015 end";
534 }
535
536 /**
537 * @tc.number: AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_018
538 * @tc.name: OnRemoteRequest
539 * @tc.desc: Test function OnRemoteRequest when code is error.
540 */
541 HWTEST_F(AccessibleAbilityChannelStubUnitTest,
542 AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_018, TestSize.Level1)
543 {
544 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_018 start";
545
546 MessageParcel data;
547 MessageParcel reply;
548 MessageOption option;
549 uint32_t errorCode = 0xFFFFFFFF;
550
551 WriteInterfaceToken(data);
552
553 int res = stub_->OnRemoteRequest(errorCode, data, reply, option);
554 EXPECT_NE(res, OHOS::Accessibility::NO_ERROR);
555
556 GTEST_LOG_(INFO) << "AccessibleAbilityChannelStubUnitTest_Unittest_OnRemoteRequest_018 end";
557 }
558 } // namespace Accessibility
559 } // namespace OHOS
560