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 <cstdio>
17 #include <gtest/gtest.h>
18 #include "accessibility_common_helper.h"
19 #include "accessibility_element_operator_proxy.h"
20 #include "accessibility_element_operator_stub.h"
21 #include "accessibility_ut_helper.h"
22 #include "accessible_ability_connection.h"
23 #include "accessible_ability_manager_service.h"
24 #include "iservice_registry.h"
25 #include "mock_accessibility_account_data.h"
26 #include "mock_accessibility_element_operator_proxy.h"
27 #include "mock_accessibility_element_operator_stub.h"
28 #include "mock_accessible_ability_client_stub_impl.h"
29 #include "mock_accessible_ability_manager_service.h"
30 #include "mock_bundle_manager.h"
31 #include "utils.h"
32
33 using namespace testing;
34 using namespace testing::ext;
35
36 namespace OHOS {
37 namespace Accessibility {
38 namespace {
39 constexpr uint32_t SLEEP_TIME_2 = 2;
40 constexpr int32_t CHANNEL_ID = 2;
41 constexpr int32_t INVALID_ACCOUNT_ID = -1;
42 } // namespace
43
44 class AccessibilitySettingProviderTest : public ::testing::Test {
45 public:
AccessibilitySettingProviderTest()46 AccessibilitySettingProviderTest()
47 {}
~AccessibilitySettingProviderTest()48 ~AccessibilitySettingProviderTest()
49 {}
50
51 static void SetUpTestCase();
52 static void TearDownTestCase();
53 void SetUp() override;
54 void TearDown() override;
55
56 sptr<AccessibleAbilityConnection> connection_ = nullptr;
57 sptr<AppExecFwk::ElementName> elementName_ = nullptr;
58 sptr<IRemoteObject> obj_ = nullptr;
59 sptr<AccessibilityAccountData> accountData_ = nullptr;
60 };
61
SetUpTestCase()62 void AccessibilitySettingProviderTest::SetUpTestCase()
63 {
64 GTEST_LOG_(INFO) << "###################### AccessibilitySettingProviderTest Start ######################";
65 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
66 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
67 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
68 }
69
TearDownTestCase()70 void AccessibilitySettingProviderTest::TearDownTestCase()
71 {
72 GTEST_LOG_(INFO) << "###################### AccessibilitySettingProviderTest End ######################";
73 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
74 }
75
SetUp()76 void AccessibilitySettingProviderTest::SetUp()
77 {
78 GTEST_LOG_(INFO) << "SetUp";
79 // new Interaction proxy
80 sptr<AccessibilityElementOperatorStub> stub = new MockAccessibilityElementOperatorStub();
81 sptr<IAccessibilityElementOperator> proxy = new MockAccessibilityElementOperatorProxy(stub);
82 sptr<AccessibilityWindowConnection> connection = new AccessibilityWindowConnection(0, proxy, 0);
83
84 // new AAconnection
85 AccessibilityAbilityInitParams initParams;
86 initParams.abilityTypes = ACCESSIBILITY_ABILITY_TYPE_ALL;
87 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
88 abilityInfo->SetEventTypes(EventType::TYPES_ALL_MASK);
89 accountData_ = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
90 if (accountData_ != nullptr) {
91 accountData_->AddAccessibilityWindowConnection(0, connection);
92 }
93 connection_ = new AccessibleAbilityConnection(AccessibilityAbilityHelper::accountId_, 0, *abilityInfo);
94 elementName_ = new AppExecFwk::ElementName("1", "2", "3");
95 obj_ = new IPCObjectProxy(0);
96 if (obj_ != nullptr && connection_ != nullptr) {
97 connection_->OnAbilityConnectDoneSync(*elementName_, obj_);
98 }
99 }
100
TearDown()101 void AccessibilitySettingProviderTest::TearDown()
102 {
103 GTEST_LOG_(INFO) << "TearDown";
104 AccessibilityAbilityHelper::GetInstance().SetTestChannelId(INVALID_CHANNEL_ID);
105 if (accountData_) {
106 accountData_->RemoveAccessibilityWindowConnection(0);
107 }
108
109 if (connection_) {
110 connection_->OnAbilityDisconnectDoneSync(*elementName_);
111 }
112 connection_ = nullptr;
113 elementName_ = nullptr;
114 obj_ = nullptr;
115 accountData_ = nullptr;
116 }
117
118 /**
119 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001
120 * @tc.name: UpdateMouseAutoClick
121 * @tc.desc: Test function UpdateMouseAutoClick
122 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateMouseAutoClick_001, TestSize.Level1)123 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateMouseAutoClick_001, TestSize.Level1)
124 {
125 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 start";
126 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
127 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
128
129 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
130 EXPECT_EQ(ret, 0);
131 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateMouseAutoClick();
132 EXPECT_NE(stub_.GetRefPtr(), nullptr);
133 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateMouseAutoClick_001 end";
134 }
135
136 /**
137 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001
138 * @tc.name: UpdateShortkeyTarget
139 * @tc.desc: Test function UpdateShortkeyTarget
140 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)141 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyTarget_001, TestSize.Level1)
142 {
143 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 start";
144 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
145 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
146
147 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
148 EXPECT_EQ(ret, 0);
149 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyTarget();
150 EXPECT_NE(stub_.GetRefPtr(), nullptr);
151 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateShortkeyTarget_001 end";
152 }
153
154 /**
155 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001
156 * @tc.name: UpdateClickResponseTime
157 * @tc.desc: Test function UpdateClickResponseTime
158 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateClickResponseTime_001, TestSize.Level1)159 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateClickResponseTime_001, TestSize.Level1)
160 {
161 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 start";
162 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
163 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
164
165 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
166 EXPECT_EQ(ret, 0);
167 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateClickResponseTime();
168 EXPECT_NE(stub_.GetRefPtr(), nullptr);
169 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateClickResponseTime_001 end";
170 }
171
172 /**
173 * @tc.number: AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001
174 * @tc.name: UpdateIgnoreRepeatClickTime
175 * @tc.desc: Test function UpdateIgnoreRepeatClickTime
176 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateIgnoreRepeatClickTime_001, TestSize.Level1)177 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateIgnoreRepeatClickTime_001, TestSize.Level1)
178 {
179 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 start";
180 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
181 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
182
183 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
184 EXPECT_EQ(ret, 0);
185 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateIgnoreRepeatClickTime();
186 EXPECT_NE(stub_.GetRefPtr(), nullptr);
187 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_UpdateIgnoreRepeatClickTime_001 end";
188 }
189
190 /**
191 * @tc.number: AccessibleAbility_ManagerService_UnitTest_PackageRemoved_003
192 * @tc.name: PackageRemoved
193 * @tc.desc: Test function PackageRemoved
194 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)195 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, PackageRemoved_003, TestSize.Level1)
196 {
197 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 start";
198 std::string bundleName = "bundleName1";
199 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
200 sleep(SLEEP_TIME_1);
201 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
202 EXPECT_NE(stub_.GetRefPtr(), nullptr);
203 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_PackageRemoved_003 end";
204 }
205
206 /**
207 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetAbilityList_003
208 * @tc.name: GetAbilityList
209 * @tc.desc: Test function GetAbilityList
210 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)211 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetAbilityList_003, TestSize.Level1)
212 {
213 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetAbilityList_003 start";
214 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
215 uint32_t type = 0xFFFFFFFF;
216 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, -1, infos);
217 EXPECT_EQ(infos.size(), 0);
218 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(type, 5, infos);
219 EXPECT_EQ(infos.size(), 0);
220 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_GetAbilityList_003 end";
221 }
222
223 /**
224 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_001
225 * @tc.name: SetTargetAbility
226 * @tc.desc: Test function HIGH_CONTRAST_TEXT
227 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)228 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_001, TestSize.Level1)
229 {
230 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 start";
231 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
232 if (!accountData) {
233 GTEST_LOG_(INFO) << "current account data is null";
234 return;
235 }
236 accountData->GetConfig()->SetShortkeyTarget("HIGH_CONTRAST_TEXT");
237 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
238 EXPECT_FALSE(ret);
239 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_001 end";
240 }
241
242 /**
243 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_002
244 * @tc.name: SetTargetAbility
245 * @tc.desc: Test function INVERT_COLOR
246 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)247 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_002, TestSize.Level1)
248 {
249 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 start";
250 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
251 if (!accountData) {
252 GTEST_LOG_(INFO) << "current account data is null";
253 return;
254 }
255 accountData->GetConfig()->SetShortkeyTarget("INVERT_COLOR");
256 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
257 EXPECT_FALSE(ret);
258 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_002 end";
259 }
260
261 /**
262 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_003
263 * @tc.name: SetTargetAbility
264 * @tc.desc: Test function ANIMATION_OFF
265 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)266 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_003, TestSize.Level1)
267 {
268 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 start";
269 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
270 if (!accountData) {
271 GTEST_LOG_(INFO) << "current account data is null";
272 return;
273 }
274 accountData->GetConfig()->SetShortkeyTarget("ANIMATION_OFF");
275 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
276 EXPECT_FALSE(ret);
277 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_003 end";
278 }
279
280 /**
281 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_004
282 * @tc.name: SetTargetAbility
283 * @tc.desc: Test function SCREEN_MAGNIFICATION
284 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)285 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_004, TestSize.Level1)
286 {
287 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 start";
288 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
289 if (!accountData) {
290 GTEST_LOG_(INFO) << "current account data is null";
291 return;
292 }
293 accountData->GetConfig()->SetShortkeyTarget("SCREEN_MAGNIFICATION");
294 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
295 EXPECT_FALSE(ret);
296 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_004 end";
297 }
298
299 /**
300 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_005
301 * @tc.name: SetTargetAbility
302 * @tc.desc: Test function AUDIO_MONO
303 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)304 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_005, TestSize.Level1)
305 {
306 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 start";
307 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
308 if (!accountData) {
309 GTEST_LOG_(INFO) << "current account data is null";
310 return;
311 }
312 accountData->GetConfig()->SetShortkeyTarget("AUDIO_MONO");
313 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
314 EXPECT_FALSE(ret);
315 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_005 end";
316 }
317
318 /**
319 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_006
320 * @tc.name: SetTargetAbility
321 * @tc.desc: Test function MOUSE_KEY
322 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)323 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_006, TestSize.Level1)
324 {
325 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 start";
326 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
327 if (!accountData) {
328 GTEST_LOG_(INFO) << "current account data is null";
329 return;
330 }
331 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
332 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
333 EXPECT_FALSE(ret);
334 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_006 end";
335 }
336
337 /**
338 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_007
339 * @tc.name: SetTargetAbility
340 * @tc.desc: Test function CAPTION_STATE
341 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)342 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_007, TestSize.Level1)
343 {
344 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 start";
345 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
346 if (!accountData) {
347 GTEST_LOG_(INFO) << "current account data is null";
348 return;
349 }
350 accountData->GetConfig()->SetShortkeyTarget("CAPTION_STATE");
351 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
352 EXPECT_FALSE(ret);
353 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_007 end";
354 }
355
356 /**
357 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_008
358 * @tc.name: SetTargetAbility
359 * @tc.desc: Test function OTHERS
360 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)361 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_008, TestSize.Level1)
362 {
363 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 start";
364 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
365 if (!accountData) {
366 GTEST_LOG_(INFO) << "current account data is null";
367 return;
368 }
369 accountData->GetConfig()->SetShortkeyTarget("CONTENT_TIMEOUT");
370 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
371 EXPECT_FALSE(ret);
372 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_008 end";
373 }
374
375 /**
376 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_009
377 * @tc.name: SetTargetAbility
378 * @tc.desc: Test function ""
379 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)380 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_009, TestSize.Level1)
381 {
382 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 start";
383 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
384 if (!accountData) {
385 GTEST_LOG_(INFO) << "current account data is null";
386 return;
387 }
388 // set
389 accountData->GetConfig()->SetShortkeyTarget("");
390 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
391 EXPECT_FALSE(ret);
392 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_009 end";
393 }
394
395 /**
396 * @tc.number: AccessibleAbility_ManagerService_UnitTest_SetTargetAbility_010
397 * @tc.name: SetTargetAbility
398 * @tc.desc: Test function other account
399 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)400 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SetTargetAbility_010, TestSize.Level1)
401 {
402 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 start";
403 sleep(SLEEP_TIME_1);
404 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
405 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
406 if (!accountData) {
407 GTEST_LOG_(INFO) << "current account data is null";
408 return;
409 }
410 accountData->GetConfig()->SetShortkeyTarget("MOUSE_KEY");
411 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility();
412 EXPECT_FALSE(ret);
413 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_SetTargetAbility_010 end";
414 }
415
416 /**
417 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001
418 * @tc.name: AddAccountData
419 * @tc.desc: Test function add account
420 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddAccountData_001, TestSize.Level1)421 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, AddAccountData_001, TestSize.Level1)
422 {
423 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 start";
424 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
425 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
426 EXPECT_NE(accountData.GetRefPtr(), nullptr);
427
428 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
429 accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetAccountData(1);
430 EXPECT_EQ(accountData.GetRefPtr(), nullptr);
431 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_AddAccountData_001 end";
432 }
433
434 /**
435 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001
436 * @tc.name: FindInnerWindowId
437 * @tc.desc: Test function find inner windowId
438 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSize.Level1)439 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, FindInnerWindowId_001, TestSize.Level1)
440 {
441 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 start";
442 AccessibilityEventInfo event;
443 event.SetWindowId(1);
444 event.SetSource(1);
445 int32_t windowId = 1;
446 Singleton<AccessibleAbilityManagerService>::GetInstance().FindInnerWindowId(event, windowId);
447 EXPECT_EQ(windowId, 1);
448 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_FindInnerWindowId_001 end";
449 }
450
451 /**
452 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001
453 * @tc.name: GetFocusedWindowId
454 * @tc.desc: Test function find focused windowId
455 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetFocusedWindowId_001, TestSize.Level1)456 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetFocusedWindowId_001, TestSize.Level1)
457 {
458 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 start";
459 int32_t windowId = 1;
460 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetFocusedWindowId(windowId);
461 EXPECT_EQ(ret, RET_OK);
462 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_GetFocusedWindowId_001 end";
463 }
464
465 /**
466 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001
467 * @tc.name: InsertWindowIdEventPair
468 * @tc.desc: Test insert foucus window event.
469 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, TestSize.Level1)470 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, InsertWindowIdEventPair_001, TestSize.Level1)
471 {
472 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 start";
473 AccessibilityEventInfo event;
474 event.SetWindowId(1);
475 event.SetSource(1);
476 int32_t windowId = 1;
477 Singleton<AccessibleAbilityManagerService>::GetInstance().InsertWindowIdEventPair(windowId, event);
478 bool ret = Singleton<AccessibleAbilityManagerService>::GetInstance().CheckWindowIdEventExist(windowId);
479 EXPECT_TRUE(ret);
480 GTEST_LOG_(INFO) << "Accessible_Ability_Manager_ServiceUnittest_InsertWindowIdEventPair_001 end";
481 }
482
483 /**
484 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_OnAddSystemAbility_001
485 * @tc.name: OnAddSystemAbility
486 * @tc.desc: Test insert foucus window event.
487 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_001, TestSize.Level1)488 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_001, TestSize.Level1)
489 {
490 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 start";
491 TearDownTestCase();
492 std::string deviceId = "test";
493 Singleton<AccessibleAbilityManagerService>::GetInstance().OnAddSystemAbility(0, deviceId);
494 SetUpTestCase();
495 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_001 end";
496 }
497
498 /**
499 * @tc.number: Accessible_Ability_Manager_ServiceUnittest_OnAddSystemAbility_002
500 * @tc.name: OnAddSystemAbility
501 * @tc.desc: Test insert foucus window event. (SystemAbilityId not found)
502 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_002, TestSize.Level1)503 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnAddSystemAbility_002, TestSize.Level1)
504 {
505 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_002 start";
506 std::string deviceId = "test";
507 Singleton<AccessibleAbilityManagerService>::GetInstance().OnAddSystemAbility(7, deviceId);
508 GTEST_LOG_(INFO) << "AccessibleAbilityConnection_Unittest_OnAddSystemAbility_002 end";
509 }
510
511 /**
512 * @tc.number: AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003
513 * @tc.name: OnRemoveSystemAbility
514 * @tc.desc: Test function OnRemoveSystemAbility
515 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_003, TestSize.Level1)516 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnRemoveSystemAbility_003, TestSize.Level1)
517 {
518 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 start";
519 TearDownTestCase();
520 std::string deviceId = "test";
521 Singleton<AccessibleAbilityManagerService>::GetInstance().OnRemoveSystemAbility(0, deviceId);
522 SetUpTestCase();
523 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_OnRemoveSystemAbility_003 end";
524 }
525
526 /**
527 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_001
528 * @tc.name: SendEvent
529 * @tc.desc: Test function SendEvent
530 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)531 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_001, TestSize.Level1)
532 {
533 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 start";
534 TearDownTestCase();
535 AccessibilityEventInfo event;
536 Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
537 SetUpTestCase();
538 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_001 end";
539 }
540
541 /**
542 * @tc.number: AccessibleAbilityManagerServiceUnitTest_SendEvent_002
543 * @tc.name: SendEvent
544 * @tc.desc: Test function SendEvent
545 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)546 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, SendEvent_002, TestSize.Level1)
547 {
548 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 start";
549 AccessibilityEventInfo event;
550 sleep(SLEEP_TIME_1);
551 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
552 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().SendEvent(event);
553 EXPECT_EQ(ret, RET_OK);
554 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_SendEvent_002 end";
555 }
556
557
558 /**
559 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003
560 * @tc.name: DeregisterElementOperator
561 * @tc.desc: Test function DeregisterElementOperator
562 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_003, TestSize.Level1)563 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DeregisterElementOperator_003, TestSize.Level1)
564 {
565 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 start";
566 TearDownTestCase();
567 Singleton<AccessibleAbilityManagerService>::GetInstance().DeregisterElementOperator(0);
568 SetUpTestCase();
569 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DeregisterElementOperator_003 end";
570 }
571
572 /**
573 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002
574 * @tc.name: GetEnabledState
575 * @tc.desc: Test function GetEnabledState
576 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_002, TestSize.Level1)577 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledState_002, TestSize.Level1)
578 {
579 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 start";
580 TearDownTestCase();
581 bool ret = true;
582 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState();
583 EXPECT_EQ(ret, false);
584 SetUpTestCase();
585 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetEnabledState_002 end";
586 }
587
588 /**
589 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003
590 * @tc.name: GetTouchGuideState
591 * @tc.desc: Test function GetTouchGuideState
592 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_003, TestSize.Level1)593 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetTouchGuideState_003, TestSize.Level1)
594 {
595 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 start";
596 TearDownTestCase();
597 bool ret = true;
598 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState();
599 EXPECT_EQ(ret, false);
600 SetUpTestCase();
601 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetTouchGuideState_003 end";
602 }
603
604 /**
605 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetGestureState_003
606 * @tc.name: GetGestureState
607 * @tc.desc: Test function GetGestureState
608 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_003, TestSize.Level1)609 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetGestureState_003, TestSize.Level1)
610 {
611 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 start";
612 TearDownTestCase();
613 bool ret = true;
614 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState();
615 EXPECT_EQ(ret, false);
616 SetUpTestCase();
617 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetGestureState_003 end";
618 }
619
620 /**
621 * @tc.number: AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003
622 * @tc.name: GetKeyEventObserverState
623 * @tc.desc: Test function GetKeyEventObserverState
624 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_003, TestSize.Level1)625 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetKeyEventObserverState_003, TestSize.Level1)
626 {
627 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 start";
628 TearDownTestCase();
629 bool ret = true;
630 ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState();
631 EXPECT_EQ(ret, false);
632 SetUpTestCase();
633 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_GetKeyEventObserverState_003 end";
634 }
635
636 /*
637 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003
638 * @tc.name: GetEnabledAbilities
639 * @tc.desc: Test function GetEnabledAbilities
640 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_003, TestSize.Level1)641 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetEnabledAbilities_003, TestSize.Level1)
642 {
643 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 start";
644 TearDownTestCase();
645 std::vector<std::string> enabledAbilities;
646 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities);
647 EXPECT_EQ(ret, RET_ERR_NULLPTR);
648 SetUpTestCase();
649 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetEnabledAbilities_003 end";
650 }
651
652 /*
653 * @tc.number: AccessibleAbility_ManagerService_UnitTest_Dump_001
654 * @tc.name: Dump
655 * @tc.desc: Test function Dump
656 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_001, TestSize.Level1)657 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_001, TestSize.Level1)
658 {
659 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 start";
660 TearDownTestCase();
661 std::vector<std::u16string> args;
662 Singleton<AccessibleAbilityManagerService>::GetInstance().Dump(0, args);
663 SetUpTestCase();
664 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_001 end";
665 }
666
667 /*
668 * @tc.number: AccessibleAbility_ManagerService_UnitTest_Dump_002
669 * @tc.name: Dump
670 * @tc.desc: Test function Dump
671 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_002, TestSize.Level1)672 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, Dump_002, TestSize.Level1)
673 {
674 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_002 start";
675 std::vector<std::u16string> args;
676 Singleton<AccessibleAbilityManagerService>::GetInstance().Dump(0, args);
677 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_Dump_002 end";
678 }
679
680 /*
681 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003
682 * @tc.name: EnableUITestAbility
683 * @tc.desc: Test function EnableUITestAbility
684 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)685 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_003, TestSize.Level1)
686 {
687 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 start";
688 TearDownTestCase();
689 sptr<IRemoteObject> obj = nullptr;
690 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
691 EXPECT_EQ(ret, RET_ERR_NULLPTR);
692 SetUpTestCase();
693 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_003 end";
694 }
695
696 /*
697 * @tc.number: AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004
698 * @tc.name: EnableUITestAbility
699 * @tc.desc: Test function EnableUITestAbility
700 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)701 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, EnableUITestAbility_004, TestSize.Level1)
702 {
703 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 start";
704 sptr<IRemoteObject> obj = nullptr;
705 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj);
706 EXPECT_EQ(ret, RET_ERR_NULLPTR);
707 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_EnableUITestAbility_004 end";
708 }
709
710 /*
711 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableAbility_003
712 * @tc.name: DisableAbility
713 * @tc.desc: Test function DisableAbility
714 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_003, TestSize.Level1)715 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableAbility_003, TestSize.Level1)
716 {
717 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 start";
718 TearDownTestCase();
719 std::string name = "test";
720 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name);
721 EXPECT_EQ(ret, RET_ERR_NULLPTR);
722 SetUpTestCase();
723 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableAbility_003 end";
724 }
725
726 /*
727 * @tc.number: AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003
728 * @tc.name: DisableUITestAbility
729 * @tc.desc: Test function DisableUITestAbility
730 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_003, TestSize.Level1)731 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, DisableUITestAbility_003, TestSize.Level1)
732 {
733 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 start";
734 TearDownTestCase();
735 RetError ret = Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility();
736 EXPECT_EQ(ret, RET_ERR_NULLPTR);
737 SetUpTestCase();
738 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_DisableUITestAbility_003 end";
739 }
740
741 /**
742 * @tc.number: AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001
743 * @tc.name: RegisterStateObserver
744 * @tc.desc: Test function RegisterStateObserver
745 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateObserver_001, TestSize.Level1)746 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterStateObserver_001, TestSize.Level1)
747 {
748 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001 start";
749 TearDownTestCase();
750 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
751 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
752 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
753 EXPECT_EQ(ret, 0);
754 SetUpTestCase();
755 GTEST_LOG_(INFO) << "AccessibleAbilityManagerServiceUnitTest_Unittest_RegisterStateObserver_001 end";
756 }
757
758 /*
759 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001
760 * @tc.name: GetRealWindowAndElementId
761 * @tc.desc: Test function GetRealWindowAndElementId
762 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_001, TestSize.Level1)763 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_001, TestSize.Level1)
764 {
765 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001 start";
766 TearDownTestCase();
767 int32_t windowId = 0;
768 int64_t elementId = 0;
769 Singleton<AccessibleAbilityManagerService>::GetInstance().GetRealWindowAndElementId(windowId, elementId);
770 SetUpTestCase();
771 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_001 end";
772 }
773
774 /*
775 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002
776 * @tc.name: GetRealWindowAndElementId
777 * @tc.desc: Test function GetRealWindowAndElementId
778 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_002, TestSize.Level1)779 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetRealWindowAndElementId_002, TestSize.Level1)
780 {
781 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002 start";
782 int32_t windowId = 0;
783 int64_t elementId = 0;
784 Singleton<AccessibleAbilityManagerService>::GetInstance().GetRealWindowAndElementId(windowId, elementId);
785 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetRealWindowAndElementId_002 end";
786 }
787
788 /*
789 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001
790 * @tc.name: GetSceneBoardInnerWinId
791 * @tc.desc: Test function GetSceneBoardInnerWinId
792 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_001, TestSize.Level1)793 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_001, TestSize.Level1)
794 {
795 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001 start";
796 TearDownTestCase();
797 int32_t windowId = 0;
798 int64_t elementId = 0;
799 int32_t innerWid = 0;
800 Singleton<AccessibleAbilityManagerService>::GetInstance().GetSceneBoardInnerWinId(windowId, elementId, innerWid);
801 SetUpTestCase();
802 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_001 end";
803 }
804
805 /*
806 * @tc.number: AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002
807 * @tc.name: GetSceneBoardInnerWinId
808 * @tc.desc: Test function GetSceneBoardInnerWinId
809 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_002, TestSize.Level1)810 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, GetSceneBoardInnerWinId_002, TestSize.Level1)
811 {
812 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002 start";
813 TearDownTestCase();
814 int32_t windowId = 0;
815 int64_t elementId = 0;
816 int32_t innerWid = 0;
817 Singleton<AccessibleAbilityManagerService>::GetInstance().GetSceneBoardInnerWinId(windowId, elementId, innerWid);
818 SetUpTestCase();
819 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_GetSceneBoardInnerWinId_002 end";
820 }
821
822 /**
823 * @tc.number: Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001
824 * @tc.name: UpdateShortkeyMultiTarget
825 * @tc.desc: Test function UpdateShortkeyMultiTarget
826 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyMultiTarget_001, TestSize.Level1)827 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, UpdateShortkeyMultiTarget_001, TestSize.Level1)
828 {
829 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001 start";
830 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateShortkeyMultiTarget();
831 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_UpdateShortkeyMultiTarget_001 end";
832 }
833
834 /**
835 * @tc.number: Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001
836 * @tc.name: OnDeviceProvisioned
837 * @tc.desc: Test function OnDeviceProvisioned
838 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_001, TestSize.Level1)839 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_001, TestSize.Level1)
840 {
841 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001 start";
842 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
843 auto accountData = aams.GetCurrentAccountData();
844 ASSERT_TRUE(accountData);
845 std::string deviceId = "false";
846 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
847 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_001 end";
848 }
849
850 /**
851 * @tc.number: Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002
852 * @tc.name: OnDeviceProvisioned
853 * @tc.desc: Test function OnDeviceProvisioned
854 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_002, TestSize.Level1)855 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, OnDeviceProvisioned_002, TestSize.Level1)
856 {
857 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002 start";
858 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
859 aams.OnStop();
860 auto accountData = aams.GetCurrentAccountData();
861 if (!accountData) {
862 GTEST_LOG_(INFO) << "current account data is null";
863 }
864 std::string deviceId = "false";
865 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
866 aams.OnStart();
867 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_OnDeviceProvisioned_002 end";
868 }
869
870 /**
871 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001
872 * @tc.name: RegisterShortKeyEvent
873 * @tc.desc: Test function RegisterShortKeyEvent
874 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_001, TestSize.Level1)875 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_001, TestSize.Level1)
876 {
877 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001 start";
878 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
879 aams.OnStop();
880 auto accountData = aams.GetCurrentAccountData();
881 if (!accountData) {
882 GTEST_LOG_(INFO) << "current account data is null";
883 }
884 std::string deviceId = "false";
885 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
886 aams.OnStart();
887 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_001 end";
888 }
889
890 /**
891 * @tc.number: Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002
892 * @tc.name: RegisterShortKeyEvent
893 * @tc.desc: Test function RegisterShortKeyEvent
894 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_002, TestSize.Level1)895 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RegisterShortKeyEvent_002, TestSize.Level1)
896 {
897 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002 start";
898 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
899 auto accountData = aams.GetCurrentAccountData();
900 ASSERT_TRUE(accountData);
901 std::string deviceId = "false";
902 aams.OnAddSystemAbility(WINDOW_MANAGER_SERVICE_ID, deviceId);
903 GTEST_LOG_(INFO) << "Accessible_Ability_ManagerService_UnitTest_RegisterShortKeyEvent_002 end";
904 }
905
906 /**
907 * @tc.number: AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001
908 * @tc.name: RemoveRequestId
909 * @tc.desc: Test function AddRequestId RemoveRequestId
910 */
HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveRequestId_001, TestSize.Level1)911 HWTEST_F(AccessibleAbilityManagerServiceUnitTest, RemoveRequestId_001, TestSize.Level1)
912 {
913 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 start";
914 int32_t windowId = 1;
915 int32_t treeId = 2;
916 int32_t requestId = 3;
917 Singleton<AccessibleAbilityManagerService>::GetInstance().AddRequestId(windowId, treeId, requestId, nullptr);
918 Singleton<AccessibleAbilityManagerService>::GetInstance().RemoveRequestId(requestId);
919 GTEST_LOG_(INFO) << "AccessibleAbility_ManagerService_UnitTest_RemoveRequestId_001 end";
920 }
921
922 /**
923 * @tc.number: TouchEventInjector001
924 * @tc.name:TouchEventInjector
925 * @tc.desc: Check injected single tap event.
926 */
HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_001, TestSize.Level1)927 HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_001, TestSize.Level1)
928 {
929 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_001 start";
930 touchEventInjector_->SetNext(inputInterceptor_);
931
932 AccessibilityGesturePosition point {10.0f, 10.0f};
933 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
934 gesturePath->AddPosition(point);
935 gesturePath->SetDurationTime(100);
936
937 touchEventInjector_->InjectEvents(gesturePath);
938
939 sleep(SLEEP_TIME_2);
940 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
941 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
942 EXPECT_EQ(touchAction, expectValue);
943
944 expectValue = MMI::PointerEvent::POINTER_ACTION_UP;
945 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
946 EXPECT_EQ(touchAction, expectValue);
947 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
948 }
949
950 /**
951 * @tc.number: TouchEventInjector004
952 * @tc.name:TouchEventInjector
953 * @tc.desc: Check Some functional interface.
954 */
HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_004, TestSize.Level1)955 HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_004, TestSize.Level1)
956 {
957 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_004 start";
958
959 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
960 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
961 touchEventInjector_->SetNext(inputInterceptor_);
962 touchEventInjector_->OnPointerEvent(*event);
963 touchEventInjector_->DestroyEvents();
964 isDestroyEvents_ = AccessibilityAbilityHelper::GetInstance().GetDestroyState();
965 EXPECT_EQ(isDestroyEvents_, true);
966
967 MMI::PointerEvent touchevent = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
968 touchEventInjector_->OnPointerEvent(touchevent);
969 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
970 sleep(SLEEP_TIME_2);
971 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
972 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
973 EXPECT_EQ(touchAction, expectValue);
974
975 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_004 end";
976 }
977
978 /**
979 * @tc.number: TouchEventInjector005
980 * @tc.name:TouchEventInjector
981 * @tc.desc: Check destroy event before sendtouchevent.
982 */
HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_005, TestSize.Level1)983 HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_005, TestSize.Level1)
984 {
985 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_005 start";
986
987 touchEventInjector_->SetNext(inputInterceptor_);
988
989 AccessibilityGesturePosition point {10.0f, 10.0f};
990 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
991 gesturePath->AddPosition(point);
992 gesturePath->SetDurationTime(100000);
993
994 touchEventInjector_->InjectEvents(gesturePath);
995 sleep(SLEEP_TIME_1);
996 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
997 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
998 touchEventInjector_->DestroyEvents();
999 isDestroyEvents_ = AccessibilityAbilityHelper::GetInstance().GetDestroyState();
1000 EXPECT_EQ(isDestroyEvents_, true);
1001 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
1002 EXPECT_EQ(touchAction, expectValue);
1003
1004 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_005 end";
1005 }
1006
1007 /**
1008 * @tc.number: TouchEventInjector006
1009 * @tc.name:TouchEventInjector
1010 * @tc.desc: Check injected UP_THEN_RIGHT move event.
1011 */
HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_006, TestSize.Level1)1012 HWTEST_F(TouchEventInjectorTest, TouchEventInjector_Unittest_TouchEventInjector_006, TestSize.Level1)
1013 {
1014 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_006 start";
1015
1016 touchEventInjector_->SetNext(inputInterceptor_);
1017
1018 AccessibilityGesturePosition point1 {10.0f, 10.0f};
1019 AccessibilityGesturePosition point2 {10.0f, 20.0f};
1020 AccessibilityGesturePosition point3 {20.0f, 20.0f};
1021 std::shared_ptr<AccessibilityGestureInjectPath> gesturePath = std::make_shared<AccessibilityGestureInjectPath>();
1022 gesturePath->AddPosition(point1);
1023 gesturePath->AddPosition(point2);
1024 gesturePath->AddPosition(point3);
1025 gesturePath->SetDurationTime(200);
1026
1027 touchEventInjector_->InjectEvents(gesturePath);
1028 sleep(SLEEP_TIME_2);
1029 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1030 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_DOWN;
1031 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
1032 EXPECT_EQ(touchAction, expectValue);
1033 expectValue = MMI::PointerEvent::POINTER_ACTION_MOVE;
1034 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(2);
1035 EXPECT_EQ(touchAction, expectValue);
1036 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(3);
1037 EXPECT_EQ(touchAction, expectValue);
1038 expectValue = MMI::PointerEvent::POINTER_ACTION_UP;
1039 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(4);
1040 EXPECT_EQ(touchAction, expectValue);
1041 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
1042
1043 GTEST_LOG_(INFO) << "TouchEventInjector_Unittest_TouchEventInjector_006 end";
1044 }
1045
1046 /**
1047 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_001
1048 * @tc.name: OnPointerEvent
1049 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_DOWN timeout)
1050 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_001, TestSize.Level1)1051 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_001, TestSize.Level1)
1052 {
1053 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_001 start";
1054 if (!zoomGesture_) {
1055 return;
1056 }
1057 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1058 MMI::PointerEvent::POINTER_ACTION_DOWN);
1059 if (!event) {
1060 return;
1061 }
1062 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
1063 zoomGesture_->OnPointerEvent(*event);
1064 sleep(2);
1065 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1066 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_DOWN);
1067
1068 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_001 end";
1069 }
1070
1071 /**
1072 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_002
1073 * @tc.name: OnPointerEvent
1074 * @tc.desc: Test function OnPointerEvent(Tap once on the screen)
1075 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_002, TestSize.Level1)1076 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_002, TestSize.Level1)
1077 {
1078 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_002 start";
1079 if (!zoomGesture_) {
1080 return;
1081 }
1082 // Pointer down
1083 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1084 MMI::PointerEvent::POINTER_ACTION_DOWN);
1085 if (!eventDown) {
1086 return;
1087 }
1088 MMI::PointerEvent::PointerItem item;
1089 eventDown->AddPointerItem(item);
1090 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
1091 zoomGesture_->OnPointerEvent(*eventDown);
1092 // Pointer up
1093 std::shared_ptr<MMI::PointerEvent> eventUp = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1094 MMI::PointerEvent::POINTER_ACTION_UP);
1095 if (!eventUp) {
1096 return;
1097 }
1098 zoomGesture_->OnPointerEvent(*eventUp);
1099 sleep(2);
1100
1101 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1102 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_DOWN);
1103 touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
1104 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_UP);
1105
1106 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_002 end";
1107 }
1108
1109 /**
1110 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_003
1111 * @tc.name: OnPointerEvent
1112 * @tc.desc: Test function OnPointerEvent(3 Taps on the screen)
1113 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_003, TestSize.Level1)1114 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_003, TestSize.Level1)
1115 {
1116 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_003 start";
1117
1118 // start zoom
1119 TripleTaps();
1120 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1121 EXPECT_TRUE(zoomState);
1122 // stop zoom
1123 TripleTaps();
1124 zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1125 EXPECT_FALSE(zoomState);
1126
1127 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_003 end";
1128 }
1129
1130 /**
1131 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_004
1132 * @tc.name: OnPointerEvent
1133 * @tc.desc: Test function OnPointerEvent(transfer to sliding state)
1134 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_004, TestSize.Level1)1135 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_004, TestSize.Level1)
1136 {
1137 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_004 start";
1138
1139 // start zoom
1140 TripleTaps();
1141 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1142 EXPECT_TRUE(zoomState);
1143 // Pointer down
1144 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1145 MMI::PointerEvent::POINTER_ACTION_DOWN);
1146 if (!eventDown) {
1147 return;
1148 }
1149 MMI::PointerEvent::PointerItem item1;
1150 item1.SetDisplayX(10);
1151 item1.SetDisplayY(20);
1152 eventDown->AddPointerItem(item1);
1153
1154 MMI::PointerEvent::PointerItem item2;
1155 item2.SetDisplayX(40);
1156 item2.SetDisplayY(20);
1157 eventDown->AddPointerItem(item2);
1158 zoomGesture_->OnPointerEvent(*eventDown);
1159
1160 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_004 end";
1161 }
1162
1163 /**
1164 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_005
1165 * @tc.name: OnPointerEvent
1166 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_MOVE in sliding state)
1167 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_005, TestSize.Level1)1168 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_005, TestSize.Level1)
1169 {
1170 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_005 start";
1171
1172 // start zoom
1173 TripleTaps();
1174 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1175 EXPECT_TRUE(zoomState);
1176
1177 // Pointer down
1178 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1179 MMI::PointerEvent::POINTER_ACTION_DOWN);
1180 if (!eventDown) {
1181 return;
1182 }
1183 MMI::PointerEvent::PointerItem item1;
1184 item1.SetDisplayX(10);
1185 item1.SetDisplayY(20);
1186 eventDown->AddPointerItem(item1);
1187
1188 MMI::PointerEvent::PointerItem item2;
1189 item2.SetDisplayX(40);
1190 item2.SetDisplayY(20);
1191 eventDown->AddPointerItem(item2);
1192 zoomGesture_->OnPointerEvent(*eventDown);
1193
1194 // Pointer move
1195 std::shared_ptr<MMI::PointerEvent> eventMove = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1196 MMI::PointerEvent::POINTER_ACTION_MOVE);
1197 if (!eventMove) {
1198 return;
1199 }
1200 MMI::PointerEvent::PointerItem item3;
1201 item3.SetDisplayX(0);
1202 item3.SetDisplayY(50);
1203 eventMove->AddPointerItem(item3);
1204
1205 MMI::PointerEvent::PointerItem item4;
1206 item4.SetDisplayX(70);
1207 item4.SetDisplayY(50);
1208 eventMove->AddPointerItem(item4);
1209 zoomGesture_->OnPointerEvent(*eventMove);
1210 zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1211 EXPECT_TRUE(zoomState);
1212
1213 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_005 end";
1214 }
1215
1216 /**
1217 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_006
1218 * @tc.name: OnPointerEvent
1219 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_DOWN in sliding state)
1220 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_006, TestSize.Level1)1221 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_006, TestSize.Level1)
1222 {
1223 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_006 start";
1224
1225 // start zoom
1226 TripleTaps();
1227 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1228 EXPECT_TRUE(zoomState);
1229
1230 // Pointer down
1231 std::shared_ptr<MMI::PointerEvent> eventDown = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1232 MMI::PointerEvent::POINTER_ACTION_DOWN);
1233 if (!eventDown) {
1234 return;
1235 }
1236 MMI::PointerEvent::PointerItem item1;
1237 item1.SetDisplayX(10);
1238 item1.SetDisplayY(20);
1239 eventDown->AddPointerItem(item1);
1240
1241 MMI::PointerEvent::PointerItem item2;
1242 item2.SetDisplayX(40);
1243 item2.SetDisplayY(20);
1244 eventDown->AddPointerItem(item2);
1245 zoomGesture_->OnPointerEvent(*eventDown);
1246
1247 MMI::PointerEvent::PointerItem item3;
1248 item3.SetDisplayX(50);
1249 item3.SetDisplayY(25);
1250 eventDown->AddPointerItem(item3);
1251 zoomGesture_->OnPointerEvent(*eventDown);
1252
1253 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_006 end";
1254 }
1255
1256 /**
1257 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_007
1258 * @tc.name: OnPointerEvent
1259 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_UP in sliding state)
1260 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_007, TestSize.Level1)1261 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_007, TestSize.Level1)
1262 {
1263 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_007 start";
1264
1265 // start zoom
1266 TripleTaps();
1267 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1268 EXPECT_TRUE(zoomState);
1269
1270 // Pointer down
1271 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1272 MMI::PointerEvent::POINTER_ACTION_DOWN);
1273 if (!event) {
1274 return;
1275 }
1276 event->SetPointerId(1);
1277 MMI::PointerEvent::PointerItem item1;
1278 item1.SetPointerId(1);
1279 item1.SetDisplayX(10);
1280 item1.SetDisplayY(20);
1281 event->AddPointerItem(item1);
1282
1283 MMI::PointerEvent::PointerItem item2;
1284 item2.SetPointerId(2);
1285 item2.SetDisplayX(40);
1286 item2.SetDisplayY(20);
1287 event->AddPointerItem(item2);
1288
1289 MMI::PointerEvent::PointerItem item3;
1290 item3.SetPointerId(3);
1291 item3.SetDisplayX(50);
1292 item3.SetDisplayY(25);
1293 event->AddPointerItem(item3);
1294 zoomGesture_->OnPointerEvent(*event);
1295
1296 // Pointer up
1297 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1298 zoomGesture_->OnPointerEvent(*event);
1299
1300 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_007 end";
1301 }
1302
1303 /**
1304 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_008
1305 * @tc.name: OnPointerEvent
1306 * @tc.desc: Test function OnPointerEvent(sliding state->zoom state)
1307 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_008, TestSize.Level1)1308 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_008, TestSize.Level1)
1309 {
1310 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_008 start";
1311
1312 // start zoom
1313 TripleTaps();
1314 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1315 EXPECT_TRUE(zoomState);
1316
1317 // Pointer down
1318 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1319 MMI::PointerEvent::POINTER_ACTION_DOWN);
1320 if (!event) {
1321 return;
1322 }
1323 event->SetPointerId(1);
1324 MMI::PointerEvent::PointerItem item1;
1325 item1.SetPointerId(1);
1326 item1.SetDisplayX(10);
1327 item1.SetDisplayY(20);
1328 event->AddPointerItem(item1);
1329
1330 MMI::PointerEvent::PointerItem item2;
1331 item2.SetPointerId(2);
1332 item2.SetDisplayX(40);
1333 item2.SetDisplayY(20);
1334 event->AddPointerItem(item2);
1335 zoomGesture_->OnPointerEvent(*event);
1336
1337 // Pointer up
1338 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1339 zoomGesture_->OnPointerEvent(*event);
1340 // Pointer up
1341 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1342 event->SetPointerId(2);
1343 event->RemovePointerItem(1);
1344 zoomGesture_->OnPointerEvent(*event);
1345
1346 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_008 end";
1347 }
1348
1349 /**
1350 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_009
1351 * @tc.name: OnPointerEvent
1352 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in ready state)
1353 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_009, TestSize.Level1)1354 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_009, TestSize.Level1)
1355 {
1356 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_009 start";
1357 if (!zoomGesture_) {
1358 return;
1359 }
1360 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1361 MMI::PointerEvent::POINTER_ACTION_CANCEL);
1362 if (!event) {
1363 return;
1364 }
1365 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
1366 zoomGesture_->OnPointerEvent(*event);
1367 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1368 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_CANCEL);
1369
1370 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_009 end";
1371 }
1372
1373 /**
1374 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_010
1375 * @tc.name: OnPointerEvent
1376 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in zoom state)
1377 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_010, TestSize.Level1)1378 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_010, TestSize.Level1)
1379 {
1380 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_010 start";
1381 if (!zoomGesture_) {
1382 return;
1383 }
1384 // start zoom
1385 TripleTaps();
1386 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1387 EXPECT_TRUE(zoomState);
1388 // send cancel event
1389 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1390 MMI::PointerEvent::POINTER_ACTION_CANCEL);
1391 if (!event) {
1392 return;
1393 }
1394 AccessibilityAbilityHelper::GetInstance().ClearTouchEventActionVector();
1395 zoomGesture_->OnPointerEvent(*event);
1396 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1397 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_CANCEL);
1398
1399 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_010 end";
1400 }
1401
1402 /**
1403 * @tc.number: AccessibilityZoomGesture_Unittest_OnPointerEvent_011
1404 * @tc.name: OnPointerEvent
1405 * @tc.desc: Test function OnPointerEvent(POINTER_ACTION_CANCEL in sliding state)
1406 */
HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_011, TestSize.Level1)1407 HWTEST_F(AccessibilityZoomGestureUnitTest, AccessibilityZoomGesture_Unittest_OnPointerEvent_011, TestSize.Level1)
1408 {
1409 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_011 start";
1410
1411 // start zoom
1412 TripleTaps();
1413 bool zoomState = AccessibilityAbilityHelper::GetInstance().GetZoomState();
1414 EXPECT_TRUE(zoomState);
1415
1416 // Pointer down
1417 std::shared_ptr<MMI::PointerEvent> event = CreatePointerEvent(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN,
1418 MMI::PointerEvent::POINTER_ACTION_DOWN);
1419 if (!event) {
1420 return;
1421 }
1422 event->SetPointerId(1);
1423 MMI::PointerEvent::PointerItem item1;
1424 item1.SetPointerId(1);
1425 item1.SetDisplayX(10);
1426 item1.SetDisplayY(20);
1427 event->AddPointerItem(item1);
1428
1429 MMI::PointerEvent::PointerItem item2;
1430 item2.SetPointerId(2);
1431 item2.SetDisplayX(40);
1432 item2.SetDisplayY(20);
1433 event->AddPointerItem(item2);
1434 zoomGesture_->OnPointerEvent(*event);
1435
1436 // Pointer cancel
1437 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_CANCEL);
1438 zoomGesture_->OnPointerEvent(*event);
1439
1440 GTEST_LOG_(INFO) << "AccessibilityZoomGesture_Unittest_OnPointerEvent_011 end";
1441 }
1442 /**
1443 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_001
1444 * @tc.name: OnPointerEvent
1445 * @tc.desc: Test function OnPointerEvent
1446 * @tc.require: issueI5NTXC
1447 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_001, TestSize.Level1)1448 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_001, TestSize.Level1)
1449 {
1450 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_001 start";
1451 if (!mouseAutoclick_) {
1452 return;
1453 }
1454 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1455 if (!event) {
1456 return;
1457 }
1458 sptr<AccessibilityAccountData> accountData =
1459 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1460 if (!accountData) {
1461 return;
1462 }
1463 accountData->GetConfig()->SetMouseAutoClick(DELAY_TIME);
1464 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1465 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1466 MMI::PointerEvent::PointerItem item;
1467 event->AddPointerItem(item);
1468 mouseAutoclick_->OnPointerEvent(*event);
1469 sleep(2);
1470
1471 EXPECT_NE(event.get(), nullptr);
1472 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_001 end";
1473 }
1474
1475 /**
1476 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_002
1477 * @tc.name: OnPointerEvent
1478 * @tc.desc: Test function OnPointerEvent
1479 * @tc.require: issueI5NTXC
1480 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_002, TestSize.Level1)1481 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_002, TestSize.Level1)
1482 {
1483 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_002 start";
1484 if (!mouseAutoclick_) {
1485 return;
1486 }
1487 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1488 if (!event) {
1489 return;
1490 }
1491 sptr<AccessibilityAccountData> accountData =
1492 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1493 if (!accountData) {
1494 return;
1495 }
1496 accountData->GetConfig()->SetMouseAutoClick(DELAY_TIME);
1497 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1498 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1499 event->SetPointerId(1);
1500 MMI::PointerEvent::PointerItem item;
1501 item.SetPointerId(1);
1502 event->AddPointerItem(item);
1503 mouseAutoclick_->OnPointerEvent(*event);
1504
1505 MMI::PointerEvent::PointerItem item1;
1506 item1.SetPointerId(1);
1507 item1.SetDisplayX(1);
1508 item1.SetDisplayY(1);
1509 event->UpdatePointerItem(1, item1);
1510 mouseAutoclick_->OnPointerEvent(*event);
1511 sleep(2);
1512
1513 EXPECT_NE(event.get(), nullptr);
1514 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_002 end";
1515 }
1516
1517 /**
1518 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_003
1519 * @tc.name: OnPointerEvent
1520 * @tc.desc: Test function OnPointerEvent
1521 * @tc.require: issueI5NTXC
1522 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_003, TestSize.Level1)1523 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_003, TestSize.Level1)
1524 {
1525 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_003 start";
1526 if (!mouseAutoclick_) {
1527 return;
1528 }
1529 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1530 if (!event) {
1531 return;
1532 }
1533 sptr<AccessibilityAccountData> accountData =
1534 Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1535 if (!accountData) {
1536 return;
1537 }
1538 accountData->GetConfig()->SetMouseAutoClick(DELAY_TIME);
1539 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1540 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1541 event->SetPointerId(1);
1542 MMI::PointerEvent::PointerItem item;
1543 item.SetPointerId(1);
1544 event->AddPointerItem(item);
1545 mouseAutoclick_->OnPointerEvent(*event);
1546 mouseAutoclick_->OnPointerEvent(*event);
1547 sleep(2);
1548
1549 EXPECT_NE(event.get(), nullptr);
1550 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_003 end";
1551 }
1552
1553 /**
1554 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_004
1555 * @tc.name: OnPointerEvent
1556 * @tc.desc: Test function OnPointerEvent
1557 * @tc.require: issueI5NTXC
1558 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_004, TestSize.Level1)1559 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_004, TestSize.Level1)
1560 {
1561 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_004 start";
1562 if (!mouseAutoclick_) {
1563 return;
1564 }
1565 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1566 if (!event) {
1567 return;
1568 }
1569 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1570 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1571 MMI::PointerEvent::PointerItem item;
1572 event->AddPointerItem(item);
1573 mouseAutoclick_->OnPointerEvent(*event);
1574
1575 EXPECT_NE(event.get(), nullptr);
1576 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_004 end";
1577 }
1578
1579 /**
1580 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_005
1581 * @tc.name: OnPointerEvent
1582 * @tc.desc: Test function OnPointerEvent
1583 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_005, TestSize.Level1)1584 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_005, TestSize.Level1)
1585 {
1586 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_005 start";
1587 if (!mouseAutoclick_) {
1588 return;
1589 }
1590 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1591 if (!event) {
1592 return;
1593 }
1594 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
1595 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_MOVE);
1596 MMI::PointerEvent::PointerItem item;
1597 event->AddPointerItem(item);
1598 mouseAutoclick_->OnPointerEvent(*event);
1599
1600 EXPECT_NE(event.get(), nullptr);
1601 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_005 end";
1602 }
1603
1604 /**
1605 * @tc.number: AccessibilityMouseAutoclick_Unittest_OnPointerEvent_006
1606 * @tc.name: OnPointerEvent
1607 * @tc.desc: Test function OnPointerEvent
1608 */
HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_006, TestSize.Level1)1609 HWTEST_F(AccessibilityMouseAutoclickUnitTest, AccessibilityMouseAutoclick_Unittest_OnPointerEvent_006, TestSize.Level1)
1610 {
1611 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_006 start";
1612 if (!mouseAutoclick_) {
1613 return;
1614 }
1615 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
1616 if (!event) {
1617 return;
1618 }
1619 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
1620 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_UP);
1621 MMI::PointerEvent::PointerItem item;
1622 event->AddPointerItem(item);
1623 mouseAutoclick_->OnPointerEvent(*event);
1624
1625 EXPECT_NE(event.get(), nullptr);
1626 GTEST_LOG_(INFO) << "AccessibilityMouseAutoclick_Unittest_OnPointerEvent_006 end";
1627 }
1628
1629 /**
1630 * @tc.number: AccessibilityShortKey_Unittest_Register_001
1631 * @tc.name: Register
1632 * @tc.desc: Test function Register
1633 * @tc.require: issueI5NTXH
1634 */
HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_Register_001, TestSize.Level1)1635 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_Unittest_Register_001, TestSize.Level1)
1636 {
1637 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_Register_001 start";
1638 shortKey_->Unregister();
1639 shortKey_->Register();
1640 GTEST_LOG_(INFO) << "AccessibilityShortKey_Unittest_OnKeyEvent_001 end";
1641 }
1642
1643 /**
1644 * @tc.number: Accessibility_Short_Key_UnitTest_AccessibilityShortKey001
1645 * @tc.name: AccessibilityShortKey
1646 * @tc.desc: Test function AccessibilityShortKey(power key cancel)
1647 * @tc.require: issueI5NTXH
1648 */
HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_001, TestSize.Level1)1649 HWTEST_F(AccessibilityShortKeyUnitTest, AccessibilityShortKey_001, TestSize.Level1)
1650 {
1651 GTEST_LOG_(INFO) << "Accessibility_Short_Key_UnitTest_AccessibilityShortKey001 start";
1652 TearDownTestCase();
1653 sptr<AccessibilityShortKey> test = new (std::nothrow) AccessibilityShortKey();
1654 test = nullptr;
1655 SetUpTestCase();
1656 GTEST_LOG_(INFO) << "Accessibility_Short_Key_UnitTest_AccessibilityShortKey001 end";
1657 }
1658
1659 /**
1660 * @tc.number: OnPointerEvent001
1661 * @tc.name: OnPointerEvent
1662 * @tc.desc: Check the first down event.
1663 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_001, TestSize.Level1)1664 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_001, TestSize.Level1)
1665 {
1666 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_001 start";
1667 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
1668 touchGuider_->OnPointerEvent(*event);
1669 bool ret = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1670 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
1671 return true;
1672 } else {
1673 return false;
1674 }
1675 }), SLEEP_TIME_3);
1676 EXPECT_TRUE(ret);
1677 }
1678
1679 /**
1680 * @tc.number: OnPointerEvent002
1681 * @tc.name: OnPointerEvent
1682 * @tc.desc: Check the first up event.
1683 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_002, TestSize.Level1)1684 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_002, TestSize.Level1)
1685 {
1686 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 start";
1687 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
1688 touchGuider_->OnPointerEvent(*event);
1689 bool retOnPointerEvent2 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1690 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) == EventType::TYPE_TOUCH_BEGIN) {
1691 return true;
1692 } else {
1693 return false;
1694 }
1695 }), SLEEP_TIME_3);
1696 EXPECT_TRUE(retOnPointerEvent2);
1697
1698 // create
1699 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
1700 touchGuider_->OnPointerEvent(*event);
1701 retOnPointerEvent2 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1702 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
1703 EventType::TYPE_TOUCH_GUIDE_END) {
1704 return true;
1705 } else {
1706 return false;
1707 }
1708 }), SLEEP_TIME_3);
1709 EXPECT_TRUE(retOnPointerEvent2);
1710 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1);
1711 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
1712 int32_t expectValue = MMI::PointerEvent::POINTER_ACTION_HOVER_ENTER;
1713 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0);
1714 EXPECT_EQ(touchAction, expectValue);
1715 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
1716 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_GUIDE_BEGIN);
1717 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_002 end";
1718 }
1719
1720 /**
1721 * @tc.number: OnPointerEvent003
1722 * @tc.name: OnPointerEvent
1723 * @tc.desc: Check the event that down-up slowly.
1724 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_003, TestSize.Level1)1725 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_003, TestSize.Level1)
1726 {
1727 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 start";
1728
1729 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
1730 touchGuider_->OnPointerEvent(*event);
1731 bool retOnPointerEvent3 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1732 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
1733 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
1734 return true;
1735 } else {
1736 return false;
1737 }
1738 }), SLEEP_TIME_3);
1739 EXPECT_TRUE(retOnPointerEvent3);
1740 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
1741 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
1742 retOnPointerEvent3 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1743 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
1744 MMI::PointerEvent::POINTER_ACTION_HOVER_ENTER) {
1745 return true;
1746 } else {
1747 return false;
1748 }
1749 }), SLEEP_TIME_3);
1750 EXPECT_TRUE(retOnPointerEvent3);
1751
1752 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
1753 touchGuider_->OnPointerEvent(*event);
1754 retOnPointerEvent3 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1755 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) ==
1756 EventType::TYPE_TOUCH_GUIDE_END) {
1757 return true;
1758 } else {
1759 return false;
1760 }
1761 }), SLEEP_TIME_3);
1762 EXPECT_TRUE(retOnPointerEvent3);
1763 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
1764 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
1765
1766 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_003 end";
1767 }
1768
1769 /**
1770 * @tc.number: OnPointerEvent004
1771 * @tc.name: OnPointerEvent
1772 * @tc.desc: Check the event that move slowly with one finger.
1773 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_004, TestSize.Level1)1774 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_004, TestSize.Level1)
1775 {
1776 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 start";
1777 std::shared_ptr<MMI::PointerEvent> event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN);
1778 touchGuider_->OnPointerEvent(*event);
1779 bool retOnPointerEvent4 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1780 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(1) ==
1781 EventType::TYPE_TOUCH_GUIDE_BEGIN) {
1782 return true;
1783 } else {
1784 return false;
1785 }
1786 }), SLEEP_TIME_3);
1787 EXPECT_TRUE(retOnPointerEvent4);
1788 EventType eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0);
1789 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_BEGIN);
1790 retOnPointerEvent4 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1791 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) ==
1792 MMI::PointerEvent::POINTER_ACTION_HOVER_ENTER) {
1793 return true;
1794 } else {
1795 return false;
1796 }
1797 }), SLEEP_TIME_3);
1798 EXPECT_TRUE(retOnPointerEvent4);
1799
1800 event = CreateMoveEvent(1);
1801 touchGuider_->OnPointerEvent(*event);
1802 int32_t touchAction = AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(1);
1803 EXPECT_EQ(touchAction, MMI::PointerEvent::POINTER_ACTION_HOVER_MOVE);
1804
1805 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP);
1806 touchGuider_->OnPointerEvent(*event);
1807 retOnPointerEvent4 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1808 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(3) == EventType::TYPE_TOUCH_GUIDE_END) {
1809 return true;
1810 } else {
1811 return false;
1812 }
1813 }), SLEEP_TIME_3);
1814 EXPECT_TRUE(retOnPointerEvent4);
1815 eventType = AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(2);
1816 EXPECT_EQ(eventType, EventType::TYPE_TOUCH_END);
1817
1818 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_004 end";
1819 }
1820
1821 /**
1822 * @tc.number: OnPointerEvent005
1823 * @tc.name: OnPointerEvent
1824 * @tc.desc: Check the event that two fingers moving in same directions in touchGuiding state.
1825 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_005, TestSize.Level1)1826 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_005, TestSize.Level1)
1827 {
1828 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 start";
1829
1830 std::vector<MMI::PointerEvent::PointerItem> points = {};
1831 MMI::PointerEvent::PointerItem point = {};
1832 point.SetPointerId(1);
1833 MMI::PointerEvent::PointerItem otherPoint = {};
1834 SetTouchGuiderPoint(otherPoint, 2, 10, 10);
1835
1836 points.emplace_back(point);
1837 std::shared_ptr<MMI::PointerEvent> event =
1838 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_1, 0, 0);
1839 touchGuider_->OnPointerEvent(*event);
1840 bool retOnPointerEvent5 = TestEventType();
1841 EXPECT_TRUE(retOnPointerEvent5);
1842
1843 points.emplace_back(otherPoint);
1844 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, POINT_ID_2, 0, 0);
1845 touchGuider_->OnPointerEvent(*event);
1846 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, POINT_ID_2, 0, 0);
1847 touchGuider_->OnPointerEvent(*event);
1848 retOnPointerEvent5 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1849 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) !=
1850 MMI::PointerEvent::POINTER_ACTION_DOWN) {
1851 return true;
1852 } else {
1853 return false;
1854 }
1855 }), SLEEP_TIME_3);
1856 EXPECT_TRUE(retOnPointerEvent5);
1857
1858 points.clear();
1859 points.emplace_back(otherPoint);
1860 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_2, 0, 0);
1861 touchGuider_->OnPointerEvent(*event);
1862 points.clear();
1863 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_UP, points, POINT_ID_1, 0, 0);
1864 touchGuider_->OnPointerEvent(*event);
1865 retOnPointerEvent5 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1866 int32_t eventTypeSize =
1867 static_cast<int32_t>(AccessibilityAbilityHelper::GetInstance().GetEventTypeVector().size());
1868 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(eventTypeSize - 1) ==
1869 EventType::TYPE_TOUCH_END) {
1870 return true;
1871 } else {
1872 return false;
1873 }
1874 }), SLEEP_TIME_3);
1875 EXPECT_TRUE(retOnPointerEvent5);
1876
1877 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_005 end";
1878 }
1879
1880 /**
1881 * @tc.number: OnPointerEvent006
1882 * @tc.name: OnPointerEvent
1883 * @tc.desc: Check the event that multi-finger gesture.
1884 */
HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_006, TestSize.Level1)1885 HWTEST_F(TouchGuiderTest, TouchGuider_Unittest_OnPointerEvent_006, TestSize.Level1)
1886 {
1887 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 start";
1888
1889 std::vector<MMI::PointerEvent::PointerItem> points = {};
1890 MMI::PointerEvent::PointerItem point = {};
1891 point.SetPointerId(1);
1892 MMI::PointerEvent::PointerItem otherPoint = {};
1893 SetTouchGuiderPoint(otherPoint, 2, 10, 10);
1894 MMI::PointerEvent::PointerItem otherPoint1 = {};
1895 SetTouchGuiderPoint(otherPoint1, 3, 10, 10);
1896
1897 points.emplace_back(point);
1898 std::shared_ptr<MMI::PointerEvent> event =
1899 CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 1, 0, 0);
1900 touchGuider_->OnPointerEvent(*event);
1901 bool retOnPointerEvent6 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1902 if (AccessibilityAbilityHelper::GetInstance().GetEventTypeOfTargetIndex(0) ==
1903 EventType::TYPE_TOUCH_BEGIN) {
1904 return true;
1905 } else {
1906 return false;
1907 }
1908 }), SLEEP_TIME_3);
1909 EXPECT_TRUE(retOnPointerEvent6);
1910
1911 points.emplace_back(otherPoint);
1912 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 2, 0, 0);
1913 touchGuider_->OnPointerEvent(*event);
1914
1915 points.emplace_back(otherPoint1);
1916 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_DOWN, points, 3, 0, 0);
1917 touchGuider_->OnPointerEvent(*event);
1918
1919 event = CreateTouchEvent(MMI::PointerEvent::POINTER_ACTION_MOVE, points, 3, 0, 0);
1920 touchGuider_->OnPointerEvent(*event);
1921 retOnPointerEvent6 = AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1922 if (AccessibilityAbilityHelper::GetInstance().GetTouchEventActionOfTargetIndex(0) !=
1923 MMI::PointerEvent::POINTER_ACTION_DOWN) {
1924 return true;
1925 } else {
1926 return false;
1927 }
1928 }), SLEEP_TIME_3);
1929 EXPECT_TRUE(retOnPointerEvent6);
1930
1931 GTEST_LOG_(INFO) << "TouchGuider_Unittest_OnPointerEvent_006 end";
1932 }
1933 }
1934 }