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 <map>
17 #include <gtest/gtest.h>
18 #include "accessible_ability_channel_proxy.h"
19 #include "mock_accessible_ability_channel_stub.h"
20 #include "accessibility_element_operator_callback_proxy.h"
21 #include "accessibility_operator.h"
22 #include "gesture_simulation.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace std;
27
28 namespace OHOS {
29 namespace Accessibility {
30 class AccessibleAbilityChannelProxyUnitTest : public ::testing::Test {
31 public:
AccessibleAbilityChannelProxyUnitTest()32 AccessibleAbilityChannelProxyUnitTest() {}
~AccessibleAbilityChannelProxyUnitTest()33 ~AccessibleAbilityChannelProxyUnitTest() {}
34
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp() override;
38 void TearDown() override;
39
40 std::shared_ptr<AccessibleAbilityChannelProxy> proxy_ = nullptr;
41 sptr<AccessibleAbilityChannelStubMock> mock_ = nullptr;
42 };
43
SetUpTestCase()44 void AccessibleAbilityChannelProxyUnitTest::SetUpTestCase()
45 {
46 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelProxyUnitTest Start ######################";
47 }
48
TearDownTestCase()49 void AccessibleAbilityChannelProxyUnitTest::TearDownTestCase()
50 {
51 GTEST_LOG_(INFO) << "###################### AccessibleAbilityChannelProxyUnitTest End ######################";
52 }
53
SetUp()54 void AccessibleAbilityChannelProxyUnitTest::SetUp()
55 {
56 GTEST_LOG_(INFO) << "SetUp";
57 mock_ = new AccessibleAbilityChannelStubMock();
58 proxy_ = std::make_shared<AccessibleAbilityChannelProxy>(mock_);
59 }
60
TearDown()61 void AccessibleAbilityChannelProxyUnitTest::TearDown()
62 {
63 GTEST_LOG_(INFO) << "TearDown";
64 mock_ = nullptr;
65 proxy_ = nullptr;
66 }
67
68 /**
69 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_001
70 * @tc.name: SearchElementInfoByAccessibilityId
71 * @tc.desc: Test function SearchElementInfoByAccessibilityId
72 */
73 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
74 AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_001, TestSize.Level1)
75 {
76 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_001 start";
77
78 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
79 .Times(1)
80 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
81
82 int accessibilityWindowId = 0;
83 long elementId = 0;
84 int requestId = 0;
85 int mode = 0;
86 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
87 sptr<IAccessibilityElementOperatorCallback> callback =
88 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
89
90 proxy_->SearchElementInfoByAccessibilityId(accessibilityWindowId, elementId, requestId, callback, mode);
91 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFO_BY_ACCESSIBILITYID, mock_->code_);
92
93 stub = nullptr;
94 callback = nullptr;
95
96 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_001 end";
97 }
98
99 /**
100 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_002
101 * @tc.name: SearchElementInfoByAccessibilityId
102 * @tc.desc: Test function SearchElementInfoByAccessibilityId
103 */
104 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
105 AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_002, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_002 start";
108
109 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
110 .Times(1)
111 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
112
113 int accessibilityWindowId = 0;
114 long elementId = 0;
115 int requestId = 0;
116 int mode = 0;
117 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
118 sptr<IAccessibilityElementOperatorCallback> callback =
119 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
120
121 proxy_->SearchElementInfoByAccessibilityId(accessibilityWindowId, elementId, requestId, callback, mode);
122 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFO_BY_ACCESSIBILITYID, mock_->code_);
123
124 stub = nullptr;
125 callback = nullptr;
126
127 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfoByAccessibilityId_002 end";
128 }
129
130 /**
131 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_001
132 * @tc.name: SearchElementInfosByText
133 * @tc.desc: Test function SearchElementInfosByText
134 */
135 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
136 AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_001, TestSize.Level1)
137 {
138 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_001 start";
139
140 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
141 .Times(1)
142 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
143
144 int accessibilityWindowId = 0;
145 long elementId = 0;
146 std::string text = "";
147 int requestId = 0;
148 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
149 sptr<IAccessibilityElementOperatorCallback> callback =
150 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
151
152 proxy_->SearchElementInfosByText(accessibilityWindowId, elementId, text, requestId, callback);
153 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFOS_BY_TEXT, mock_->code_);
154
155 stub = nullptr;
156 callback = nullptr;
157
158 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_001 end";
159 }
160
161 /**
162 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_002
163 * @tc.name: SearchElementInfosByText
164 * @tc.desc: Test function SearchElementInfosByText
165 */
166 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
167 AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_002, TestSize.Level1)
168 {
169 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_002 start";
170
171 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
172 .Times(1)
173 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
174
175 int accessibilityWindowId = 0;
176 long elementId = 0;
177 std::string text = "";
178 int requestId = 0;
179 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
180 sptr<IAccessibilityElementOperatorCallback> callback =
181 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
182
183 proxy_->SearchElementInfosByText(accessibilityWindowId, elementId, text, requestId, callback);
184 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEARCH_ELEMENTINFOS_BY_TEXT, mock_->code_);
185
186 stub = nullptr;
187 callback = nullptr;
188
189 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SearchElementInfosByText_002 end";
190 }
191
192 /**
193 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_001
194 * @tc.name: FindFocusedElementInfo
195 * @tc.desc: Test function FindFocusedElementInfo
196 */
197 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
198 AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_001, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_001 start";
201
202 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
203 .Times(1)
204 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
205
206 int accessibilityWindowId = 0;
207 long elementId = 0;
208 int focusType = 0;
209 int requestId = 0;
210 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
211 sptr<IAccessibilityElementOperatorCallback> callback =
212 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
213
214 proxy_->FindFocusedElementInfo(accessibilityWindowId, elementId, focusType, requestId, callback);
215 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::FIND_FOCUSED_ELEMENTINFO, mock_->code_);
216
217 stub = nullptr;
218 callback = nullptr;
219
220 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_001 end";
221 }
222
223 /**
224 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_002
225 * @tc.name: FindFocusedElementInfo
226 * @tc.desc: Test function FindFocusedElementInfo
227 */
228 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
229 AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_002, TestSize.Level1)
230 {
231 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_002 start";
232
233 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
234 .Times(1)
235 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
236
237 int accessibilityWindowId = 0;
238 long elementId = 0;
239 int focusType = 0;
240 int requestId = 0;
241 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
242 sptr<IAccessibilityElementOperatorCallback> callback =
243 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
244
245 proxy_->FindFocusedElementInfo(accessibilityWindowId, elementId, focusType, requestId, callback);
246 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::FIND_FOCUSED_ELEMENTINFO, mock_->code_);
247
248 stub = nullptr;
249 callback = nullptr;
250
251 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FindFocusedElementInfo_002 end";
252 }
253
254 /**
255 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_001
256 * @tc.name: FocusMoveSearch
257 * @tc.desc: Test function FocusMoveSearch
258 */
259 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
260 AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_001, TestSize.Level1)
261 {
262 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_001 start";
263
264 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
265 .Times(1)
266 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
267
268 int accessibilityWindowId = 0;
269 long elementId = 0;
270 int direction = 0;
271 int requestId = 0;
272 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
273 sptr<IAccessibilityElementOperatorCallback> callback =
274 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
275
276 proxy_->FocusMoveSearch(accessibilityWindowId, elementId, direction, requestId, callback);
277 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::FOCUS_MOVE_SEARCH, mock_->code_);
278
279 stub = nullptr;
280 callback = nullptr;
281
282 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_001 end";
283 }
284
285 /**
286 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_002
287 * @tc.name: FocusMoveSearch
288 * @tc.desc: Test function FocusMoveSearch
289 */
290 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
291 AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_002, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_002 start";
294
295 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
296 .Times(1)
297 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
298
299 int accessibilityWindowId = 0;
300 long elementId = 0;
301 int direction = 0;
302 int requestId = 0;
303 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
304 sptr<IAccessibilityElementOperatorCallback> callback =
305 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
306
307 proxy_->FocusMoveSearch(accessibilityWindowId, elementId, direction, requestId, callback);
308 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::FOCUS_MOVE_SEARCH, mock_->code_);
309
310 stub = nullptr;
311 callback = nullptr;
312
313 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_FocusMoveSearch_002 end";
314 }
315
316 /**
317 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_001
318 * @tc.name: ExecuteAction
319 * @tc.desc: Test function ExecuteAction
320 */
321 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
322 AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_001, TestSize.Level1)
323 {
324 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_001 start";
325
326 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
327 .Times(1)
328 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
329
330 int accessibilityWindowId = 0;
331 long elementId = 0;
332 int action = 0;
333 std::map<std::string, std::string> actionArguments {};
334 int requestId = 0;
335 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
336 sptr<IAccessibilityElementOperatorCallback> callback =
337 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
338
339 proxy_->ExecuteAction(accessibilityWindowId, elementId, action, actionArguments, requestId, callback);
340 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::PERFORM_ACTION, mock_->code_);
341
342 stub = nullptr;
343 callback = nullptr;
344
345 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_001 end";
346 }
347
348 /**
349 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_002
350 * @tc.name: ExecuteAction
351 * @tc.desc: Test function ExecuteAction
352 */
353 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
354 AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_002, TestSize.Level1)
355 {
356 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_002 start";
357
358 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
359 .Times(1)
360 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
361
362 int accessibilityWindowId = 0;
363 long elementId = 0;
364 int action = 0;
365 std::map<std::string, std::string> actionArguments {};
366 int requestId = 0;
367 sptr<AccessibilityOperator> stub = new AccessibilityOperator();
368 sptr<IAccessibilityElementOperatorCallback> callback =
369 new AccessibilityElementOperatorCallbackProxy(stub->AsObject());
370
371 proxy_->ExecuteAction(accessibilityWindowId, elementId, action, actionArguments, requestId, callback);
372 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::PERFORM_ACTION, mock_->code_);
373
374 stub = nullptr;
375 callback = nullptr;
376
377 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteAction_002 end";
378 }
379
380 /**
381 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_001
382 * @tc.name: GetWindows
383 * @tc.desc: Test function GetWindows
384 */
385 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
386 AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_001, TestSize.Level1)
387 {
388 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_001 start";
389
390 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
391 .Times(1)
392 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
393
394 proxy_->GetWindows();
395 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_WINDOWS, mock_->code_);
396
397 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_001 end";
398 }
399
400 /**
401 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_002
402 * @tc.name: GetWindows
403 * @tc.desc: Test function GetWindows
404 */
405 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
406 AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_002, TestSize.Level1)
407 {
408 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_002 start";
409
410 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
411 .Times(1)
412 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
413
414 proxy_->GetWindows();
415 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_WINDOWS, mock_->code_);
416
417 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetWindows_002 end";
418 }
419
420 /**
421 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_001
422 * @tc.name: ExecuteCommonAction
423 * @tc.desc: Test function ExecuteCommonAction
424 */
425 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
426 AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_001, TestSize.Level1)
427 {
428 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_001 start";
429
430 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
431 .Times(1)
432 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
433
434 int action = 0;
435
436 proxy_->ExecuteCommonAction(action);
437 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::EXECUTE_COMMON_ACTION, mock_->code_);
438
439 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_001 end";
440 }
441
442 /**
443 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_002
444 * @tc.name: ExecuteCommonAction
445 * @tc.desc: Test function ExecuteCommonAction
446 */
447 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
448 AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_002, TestSize.Level1)
449 {
450 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_002 start";
451
452 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
453 .Times(1)
454 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
455
456 int action = 0;
457
458 proxy_->ExecuteCommonAction(action);
459 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::EXECUTE_COMMON_ACTION, mock_->code_);
460
461 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ExecuteCommonAction_002 end";
462 }
463
464 /**
465 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_001
466 * @tc.name: SetOnKeyPressEventResult
467 * @tc.desc: Test function SetOnKeyPressEventResult
468 */
469 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
470 AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_001, TestSize.Level1)
471 {
472 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_001 start";
473
474 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
475 .Times(1)
476 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
477
478 bool handled = true;
479 int sequence = 0;
480
481 proxy_->SetOnKeyPressEventResult(handled, sequence);
482 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SET_ON_KEY_PRESS_EVENT_RESULT, mock_->code_);
483
484 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_001 end";
485 }
486
487 /**
488 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_002
489 * @tc.name: SetOnKeyPressEventResult
490 * @tc.desc: Test function SetOnKeyPressEventResult
491 */
492 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
493 AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_002, TestSize.Level1)
494 {
495 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_002 start";
496
497 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
498 .Times(1)
499 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
500
501 bool handled = true;
502 int sequence = 0;
503
504 proxy_->SetOnKeyPressEventResult(handled, sequence);
505 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SET_ON_KEY_PRESS_EVENT_RESULT, mock_->code_);
506
507 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetOnKeyPressEventResult_002 end";
508 }
509
510 /**
511 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_001
512 * @tc.name: GetDisplayResizeScale
513 * @tc.desc: Test function GetDisplayResizeScale
514 */
515 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
516 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_001, TestSize.Level1)
517 {
518 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_001 start";
519
520 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
521 .Times(1)
522 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
523
524 int displayId = 0;
525
526 proxy_->GetDisplayResizeScale(displayId);
527 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_SCALE, mock_->code_);
528
529 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_001 end";
530 }
531
532 /**
533 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_002
534 * @tc.name: GetDisplayResizeScale
535 * @tc.desc: Test function GetDisplayResizeScale
536 */
537 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
538 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_002, TestSize.Level1)
539 {
540 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_002 start";
541
542 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
543 .Times(1)
544 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
545
546 int displayId = 0;
547
548 proxy_->GetDisplayResizeScale(displayId);
549 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_SCALE, mock_->code_);
550
551 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeScale_002 end";
552 }
553
554 /**
555 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_001
556 * @tc.name: GetDisplayResizeCenterX
557 * @tc.desc: Test function GetDisplayResizeCenterX
558 */
559 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
560 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_001, TestSize.Level1)
561 {
562 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_001 start";
563
564 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
565 .Times(1)
566 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
567
568 int displayId = 0;
569
570 proxy_->GetDisplayResizeCenterX(displayId);
571 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_CETER_X, mock_->code_);
572
573 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_001 end";
574 }
575
576 /**
577 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_002
578 * @tc.name: GetDisplayResizeCenterX
579 * @tc.desc: Test function GetDisplayResizeCenterX
580 */
581 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
582 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_002, TestSize.Level1)
583 {
584 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_002 start";
585
586 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
587 .Times(1)
588 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
589
590 int displayId = 0;
591
592 proxy_->GetDisplayResizeCenterX(displayId);
593 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPALYRESIZE_CETER_X, mock_->code_);
594
595 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterX_002 end";
596 }
597
598 /**
599 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_001
600 * @tc.name: GetDisplayResizeCenterY
601 * @tc.desc: Test function GetDisplayResizeCenterY
602 */
603 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
604 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_001, TestSize.Level1)
605 {
606 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_001 start";
607
608 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
609 .Times(1)
610 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
611
612 int displayId = 0;
613
614 proxy_->GetDisplayResizeCenterY(displayId);
615 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_CETER_Y, mock_->code_);
616
617 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_001 end";
618 }
619
620 /**
621 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_002
622 * @tc.name: GetDisplayResizeCenterY
623 * @tc.desc: Test function GetDisplayResizeCenterY
624 */
625 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
626 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_002, TestSize.Level1)
627 {
628 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_002 start";
629
630 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
631 .Times(1)
632 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
633
634 int displayId = 0;
635
636 proxy_->GetDisplayResizeCenterY(displayId);
637 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_CETER_Y, mock_->code_);
638
639 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeCenterY_002 end";
640 }
641
642 /**
643 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_001
644 * @tc.name: GetDisplayResizeRect
645 * @tc.desc: Test function GetDisplayResizeRect
646 */
647 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
648 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_001, TestSize.Level1)
649 {
650 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_001 start";
651
652 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
653 .Times(1)
654 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
655
656 int displayId = 0;
657
658 proxy_->GetDisplayResizeRect(displayId);
659 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_RECT, mock_->code_);
660
661 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_001 end";
662 }
663
664 /**
665 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_002
666 * @tc.name: GetDisplayResizeRect
667 * @tc.desc: Test function GetDisplayResizeRect
668 */
669 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
670 AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_002, TestSize.Level1)
671 {
672 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_002 start";
673
674 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
675 .Times(1)
676 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
677
678 int displayId = 0;
679
680 proxy_->GetDisplayResizeRect(displayId);
681 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::GET_DISPLAYRESIZE_RECT, mock_->code_);
682
683 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_GetDisplayResizeRect_002 end";
684 }
685
686 /**
687 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_001
688 * @tc.name: ResetDisplayResize
689 * @tc.desc: Test function ResetDisplayResize
690 */
691 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
692 AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_001, TestSize.Level1)
693 {
694 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_001 start";
695
696 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
697 .Times(1)
698 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
699
700 int displayId = 0;
701 bool animate = true;
702
703 proxy_->ResetDisplayResize(displayId, animate);
704 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::RESET_DISPALYRESIZE, mock_->code_);
705
706 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_001 end";
707 }
708
709 /**
710 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_002
711 * @tc.name: ResetDisplayResize
712 * @tc.desc: Test function ResetDisplayResize
713 */
714 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
715 AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_002, TestSize.Level1)
716 {
717 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_002 start";
718
719 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
720 .Times(1)
721 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
722
723 int displayId = 0;
724 bool animate = true;
725
726 proxy_->ResetDisplayResize(displayId, animate);
727 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::RESET_DISPALYRESIZE, mock_->code_);
728
729 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_ResetDisplayResize_002 end";
730 }
731
732 /**
733 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_001
734 * @tc.name: SetDisplayResizeScaleAndCenter
735 * @tc.desc: Test function SetDisplayResizeScaleAndCenter
736 */
737 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
738 AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_001, TestSize.Level1)
739 {
740 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_001 start";
741
742 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
743 .Times(1)
744 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
745
746 int displayId = 0;
747 float scale = 0;
748 float centerX = 0;
749 float centerY = 0;
750 bool animate = true;
751
752 proxy_->SetDisplayResizeScaleAndCenter(displayId, scale, centerX, centerY, animate);
753 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SET_DISPLAYRESIZE_SCALE_AND_CENTER, mock_->code_);
754
755 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_001 end";
756 }
757
758 /**
759 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_002
760 * @tc.name: SetDisplayResizeScaleAndCenter
761 * @tc.desc: Test function SetDisplayResizeScaleAndCenter
762 */
763 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
764 AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_002, TestSize.Level1)
765 {
766 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_002 start";
767
768 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
769 .Times(1)
770 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
771
772 int displayId = 0;
773 float scale = 0;
774 float centerX = 0;
775 float centerY = 0;
776 bool animate = true;
777
778 proxy_->SetDisplayResizeScaleAndCenter(displayId, scale, centerX, centerY, animate);
779 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SET_DISPLAYRESIZE_SCALE_AND_CENTER, mock_->code_);
780
781 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SetDisplayResizeScaleAndCenter_002 end";
782 }
783
784 /**
785 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_001
786 * @tc.name: SendSimulateGesture
787 * @tc.desc: Test function SendSimulateGesture
788 */
789 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
790 AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_001, TestSize.Level1)
791 {
792 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_001 start";
793
794 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
795 .Times(1)
796 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeSendRequest));
797
798 int requestId = 0;
799 std::vector<GesturePathDefine> gestureSteps {};
800
801 proxy_->SendSimulateGesture(requestId, gestureSteps);
802 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEND_SIMULATE_GESTURE, mock_->code_);
803
804 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_001 end";
805 }
806
807 /**
808 * @tc.number: AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_002
809 * @tc.name: SendSimulateGesture
810 * @tc.desc: Test function SendSimulateGesture
811 */
812 HWTEST_F(AccessibleAbilityChannelProxyUnitTest,
813 AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_002, TestSize.Level1)
814 {
815 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_002 start";
816
817 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
818 .Times(1)
819 .WillOnce(Invoke(mock_.GetRefPtr(), &AccessibleAbilityChannelStubMock::InvokeErrorSendRequest));
820
821 int requestId = 0;
822 std::vector<GesturePathDefine> gestureSteps {};
823
824 proxy_->SendSimulateGesture(requestId, gestureSteps);
825 EXPECT_EQ((int)IAccessibleAbilityChannel::Message::SEND_SIMULATE_GESTURE, mock_->code_);
826
827 GTEST_LOG_(INFO) << "AccessibleAbilityChannelProxyUnitTest_Unittest_SendSimulateGesture_002 end";
828 }
829 } // namespace Accessibility
830 } // namespace OHOS
831