1 /*
2 * Copyright (C) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include <optional>
18 #include "accessibility_setting.h"
19 #include "accessibility_helper.h"
20 #include "accessibility_window.h"
21 #include "AccessibilitySettingObserver_service.h"
22 #include "iservice_registry.h"
23 #include "mock_accessible_ability_client_stub_impl.h"
24 #include "mock_accessible_config_observer_proxy.h"
25 #include "mock_accessible__config_observer_stub.h"
26 #include "mock_accessible__observer_proxy.h"
27 #include "mock_accessible_observer_stub.h"
28 #include "mock_bundle.h"
29 #include "system_ability.h"
30
31 using namespace testing;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace Accessibility {
36 namespace {
37 constexpr uint32_t SLEEP_TIME_1 = 1;
38 constexpr uint32_t CONTENT_TIMEOUT_VALUE = 10;
39 constexpr int32_t MOUSE_AUTO_CLICK_VALUE = 3;
40 constexpr float BRIGHTNESS_DISCOUNT_VALUE = 0.1f;
41 constexpr float AUDIO_BALANCE_VALUE = 0.1f;
42 constexpr int32_t ACTIVE_WINDOW_VALUE = 2;
43 constexpr int32_t SHORT_KEY_TIMEOUT_BEFORE_USE = 3000; // ms
44 const std::string DEVICE_PROVISIONED = "device_provisioned";
45 } // namespace
46
47 class AccessibilitySettingObserverTest : public ::testing::Test {
48 public:
AccessibilitySettingObserverTest()49 AccessibilitySettingObserverTest()
50 {}
~AccessibilitySettingObserverTest()51 ~AccessibilitySettingObserverTest()
52 {}
53
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp() override;
57 void TearDown() override;
58
59 sptr<AccessibleAbilityClientStub> stub_ = nullptr;
60 void RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj);
61 };
62
SetUpTestCase()63 void AccessibilitySettingObserverTest::SetUpTestCase()
64 {
65 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest SetUpTestCase";
66 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStart();
67 AccessibilityCommonHelper::GetInstance().WaitForServicePublish();
68 }
69
TearDownTestCase()70 void AccessibilitySettingObserverTest::TearDownTestCase()
71 {
72 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest TearDownTestCase";
73 Singleton<AccessibleAbilityManagerService>::GetInstance().OnStop();
74 AccessibilityCommonHelper::GetInstance().SetIsServicePublished(false);
75 }
76
SetUp()77 void AccessibilitySettingObserverTest::SetUp()
78 {
79 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest SetUp";
80 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(AccessibilityAbilityHelper::accountId_);
81 stub_ = new MockAccessibleAbilityClientStubImpl();
82 }
83
TearDown()84 void AccessibilitySettingObserverTest::TearDown()
85 {
86 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest TearDown";
87 stub_ = nullptr;
88 }
89
RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj)90 void AccessibilitySettingObserverTest::RegisterAbilityConnectionClient(const sptr<IRemoteObject>& obj)
91 {
92 // add an ability connection client
93 AccessibilityAbilityInitParams initParams;
94 std::shared_ptr<AccessibilityAbilityInfo> abilityInfo = std::make_shared<AccessibilityAbilityInfo>(initParams);
95 AppExecFwk::ElementName elementName("deviceId", "bundleName", "name");
96 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
97 if (!accountData) {
98 GTEST_LOG_(INFO) << "current account data is null";
99 return;
100 }
101 accountData->AddInstalledAbility(*abilityInfo);
102 sptr<AccessibleAbilityConnection> connection =
103 new AccessibleAbilityConnection(accountData->GetAccountId(), 0, *abilityInfo);
104 connection->OnAbilityConnectDoneSync(elementName, obj);
105 sleep(SLEEP_TIME_1);
106 EXPECT_NE(abilityInfo.get(), nullptr);
107 }
108
109 /**
110 * @tc.number: AccessibilitySettingObserverTest_GetInstance_001
111 * @tc.name: GetInstance
112 * @tc.desc: Test function GetInstance
113 */
HWTEST_F(AccessibilitySettingObserverTest, GetInstance_001, TestSize.Level1)114 HWTEST_F(AccessibilitySettingObserverTest, GetInstance_001, TestSize.Level1)
115 {
116 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_GetInstance_001 start";
117
118 auto ins = &Singleton<AccessibleAbilityManagerService>::GetInstance();
119 EXPECT_TRUE(ins);
120
121 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_GetInstance_001 end";
122 }
123
124 /**
125 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_001
126 * @tc.name: RegisterStateCallback
127 * @tc.desc: Test function RegisterStateCallback
128 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterStateCallback_001, TestSize.Level1)129 HWTEST_F(AccessibilitySettingObserverTest, RegisterStateCallback_001, TestSize.Level1)
130 {
131 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_001 start";
132
133 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
134 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
135
136 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
137 EXPECT_EQ(ret, 0);
138
139 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_001 end";
140 }
141
142 /**
143 * @tc.number: AccessibilitySettingObserver_UnitTest_GetAbilityList_001
144 * @tc.name: GetAbilityList
145 * @tc.desc: Test function GetAbilityList
146 */
HWTEST_F(AccessibilitySettingObserverTest, GetAbilityList_001, TestSize.Level1)147 HWTEST_F(AccessibilitySettingObserverTest, GetAbilityList_001, TestSize.Level1)
148 {
149 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAbilityList_001 start";
150 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
151 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(
152 ACCESSIBILITY_ABILITY_TYPE_ALL, ABILITY_STATE_ENABLE, infos);
153 EXPECT_EQ(infos.size(), 0);
154
155 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_GetAbilityList_001 end";
156 }
157
158 /**
159 * @tc.number: AccessibilitySettingObserver_UnitTest_RegisterElementOperator_001
160 * @tc.name: RegisterElementOperator
161 * @tc.desc: Test function RegisterElementOperator AccessibilitySettingObserver
162 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_001, TestSize.Level1)163 HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_001, TestSize.Level1)
164 {
165 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_001 start";
166 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
167 auto accountData = aams.GetCurrentAccountData();
168 ASSERT_TRUE(accountData);
169 auto map = accountData->GetAsacConnections();
170 EXPECT_EQ(int(map.size()), 0);
171 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr, true));
172 sleep(SLEEP_TIME_1);
173 GTEST_LOG_(INFO) << "RegisterElementOperator OK";
174 map = accountData->GetAsacConnections();
175 EXPECT_EQ(int(map.size()), 1);
176
177 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_001 end";
178 }
179
180 /**
181 * @tc.number: AccessibilitySettingObserver_UnitTest_DeregisterElementOperator_001
182 * @tc.name: DeregisterElementOperator
183 * @tc.desc: Test function DeregisterElementOperator AccessibilitySettingObserver
184 */
HWTEST_F(AccessibilitySettingObserverTest, DeregisterElementOperator_001, TestSize.Level1)185 HWTEST_F(AccessibilitySettingObserverTest, DeregisterElementOperator_001, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DeregisterElementOperator_001 start";
188 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
189 auto accountData = aams.GetCurrentAccountData();
190 ASSERT_TRUE(accountData);
191 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
192 sleep(SLEEP_TIME_1);
193 auto map = accountData->GetAsacConnections();
194 EXPECT_EQ(int(map.size()), 0);
195
196 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DeregisterElementOperator_001 end";
197 }
198
199 /**
200 * @tc.number: AccessibilitySettingObserver_UnitTest_DeregisterElementOperator_002
201 * @tc.name: DeregisterElementOperator
202 * @tc.desc: Test function DeregisterElementOperator
203 */
HWTEST_F(AccessibilitySettingObserverTest, DeregisterElementOperator_002, TestSize.Level1)204 HWTEST_F(AccessibilitySettingObserverTest, DeregisterElementOperator_002, TestSize.Level1)
205 {
206 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DeregisterElementOperator_002 start";
207 auto &aams = Singleton<AccessibleAbilityManagerService>::GetInstance();
208 auto accountData = aams.GetCurrentAccountData();
209 ASSERT_TRUE(accountData);
210 EXPECT_EQ(RET_OK, aams.RegisterElementOperator(0, nullptr, true));
211 sleep(SLEEP_TIME_1);
212 EXPECT_EQ(RET_OK, aams.DeregisterElementOperator(0));
213 sleep(SLEEP_TIME_1);
214 auto map = accountData->GetAsacConnections();
215 EXPECT_EQ(int(map.size()), 0);
216
217 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DeregisterElementOperator_002 end";
218 }
219
220
221 /**
222 * @tc.number: AccessibilitySettingObserver_UnitTest_SetTouchEventInjector_001
223 * @tc.name: SetTouchEventInjector
224 * @tc.desc: Test function SetTouchEventInjector
225 */
HWTEST_F(AccessibilitySettingObserverTest, SetTouchEventInjector_001, TestSize.Level1)226 HWTEST_F(AccessibilitySettingObserverTest, SetTouchEventInjector_001, TestSize.Level1)
227 {
228 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_SetTouchEventInjector_001 start";
229 sptr<TouchEventInjector> touchEventInjector = new TouchEventInjector();
230 sleep(SLEEP_TIME_1);
231 Singleton<AccessibleAbilityManagerService>::GetInstance().SetTouchEventInjector(touchEventInjector);
232 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchEventInjector();
233 EXPECT_TRUE(ret);
234 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_SetTouchEventInjector_001 end";
235 }
236
237 /**
238 * @tc.number: AccessibilitySettingObserver_UnitTest_SetKeyEventFilter_001
239 * @tc.name: SetKeyEventFilter
240 * @tc.desc: Test function SetKeyEventFilter
241 */
HWTEST_F(AccessibilitySettingObserverTest, SetKeyEventFilter_001, TestSize.Level1)242 HWTEST_F(AccessibilitySettingObserverTest, SetKeyEventFilter_001, TestSize.Level1)
243 {
244 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_SetKeyEventFilter_001 start";
245 sptr<KeyEventFilter> keyEventFilter = new KeyEventFilter();
246 Singleton<AccessibleAbilityManagerService>::GetInstance().SetKeyEventFilter(keyEventFilter);
247 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventFilter();
248 EXPECT_TRUE(ret);
249 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_SetKeyEventFilter_001 end";
250 }
251
252 /**
253 * @tc.number: AccessibilitySettingObserver_UnitTest_RemovedUser_001
254 * @tc.name: RemovedUser
255 * @tc.desc: Test function RemovedUser
256 */
HWTEST_F(AccessibilitySettingObserverTest, RemovedUser_001, TestSize.Level1)257 HWTEST_F(AccessibilitySettingObserverTest, RemovedUser_001, TestSize.Level1)
258 {
259 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_RemovedUser_001 start";
260 RegisterAbilityConnectionClient(stub_);
261 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
262 ASSERT_TRUE(accountData);
263 EXPECT_TRUE(int(accountData->GetConnectedA11yAbilities().size()) >= 1);
264 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
265 // can't to check a11yAccountsData_ because it is private,and don't provite api.
266 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_RemovedUser_001 end";
267 }
268
269 /**
270 * @tc.number: AccessibilitySettingObserver_UnitTest_RemovedUser_002
271 * @tc.name: RemovedUser
272 * @tc.desc: Test function RemovedUser
273 */
HWTEST_F(AccessibilitySettingObserverTest, RemovedUser_002, TestSize.Level1)274 HWTEST_F(AccessibilitySettingObserverTest, RemovedUser_002, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_RemovedUser_002 start";
277 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(1);
278 sleep(SLEEP_TIME_1);
279 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(1);
280 sleep(SLEEP_TIME_1);
281 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
282 ASSERT_EQ(accountData->GetAccountId(), 1);
283 Singleton<AccessibleAbilityManagerService>::GetInstance().RemovedUser(1);
284 // can't to check a11yAccountsData_ because it is private,and don't provite api.
285 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_RemovedUser_002 end";
286 }
287
288 /**
289 * @tc.number: AccessibilitySettingObserver_UnitTest_GetBundleMgrProxy_001
290 * @tc.name: GetBundleMgrProxy
291 * @tc.desc: Test function GetBundleMgrProxy
292 */
HWTEST_F(AccessibilitySettingObserverTest, GetBundleMgrProxy_001, TestSize.Level1)293 HWTEST_F(AccessibilitySettingObserverTest, GetBundleMgrProxy_001, TestSize.Level1)
294 {
295 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetBundleMgrProxy_001 start";
296 auto ret = Singleton<AccessibleAbilityManagerService>::GetInstance().GetBundleMgrProxy();
297 EXPECT_TRUE(ret);
298 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetBundleMgrProxyr_001 end";
299 }
300
301 /**
302 * @tc.number: AccessibilitySettingObserver_UnitTest_PackageChanged_001
303 * @tc.name: PackageChanged
304 * @tc.desc: Test function PackageChanged
305 */
HWTEST_F(AccessibilitySettingObserverTest, PackageChanged_001, TestSize.Level1)306 HWTEST_F(AccessibilitySettingObserverTest, PackageChanged_001, TestSize.Level1)
307 {
308 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageChanged_001 start";
309 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
310 ASSERT_TRUE(accountData);
311 accountData->ClearInstalledAbility();
312 std::string bundleName = "bundle1";
313 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
314 GTEST_LOG_(INFO) << "PackageChanged end";
315 EXPECT_EQ(0, int(accountData->GetInstalledAbilities().size()));
316 GTEST_LOG_(INFO) << "GetInstalledAbilities end";
317 /* add install ability */
318 sleep(SLEEP_TIME_1);
319 RegisterAbilityConnectionClient(stub_);
320 sleep(SLEEP_TIME_1);
321 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
322 bundleName = "bundle2";
323 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageChanged(bundleName);
324 sleep(SLEEP_TIME_1);
325 EXPECT_EQ(1, int(accountData->GetInstalledAbilities().size()));
326 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageChanged_001 end";
327 }
328
329 /**
330 * @tc.number: AccessibilitySettingObserverTest_SetScreenMagnificationState_001
331 * @tc.name: SetScreenMagnificationState
332 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
333 */
HWTEST_F(AccessibilitySettingObserverTest, SetScreenMagnificationState_001, TestSize.Level1)334 HWTEST_F(AccessibilitySettingObserverTest, SetScreenMagnificationState_001, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetScreenMagnificationState_001 start";
337 bool state = true;
338 bool ret = false;
339 EXPECT_EQ(RET_ERR_NULLPTR,
340 Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
341 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(ret));
342 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetScreenMagnificationState_001 end";
343 }
344
345 /**
346 * @tc.number: AccessibilitySettingObserverTest_SetShortKeyState_001
347 * @tc.name: SetShortKeyState
348 * @tc.desc: Test function SetShortKeyState GetShortKeyState
349 * @tc.require: issueI5NTXH
350 */
HWTEST_F(AccessibilitySettingObserverTest, SetShortKeyState_001, TestSize.Level1)351 HWTEST_F(AccessibilitySettingObserverTest, SetShortKeyState_001, TestSize.Level1)
352 {
353 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortKeyState_001 start";
354 bool state = true;
355 bool ret = false;
356 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
357 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(ret));
358 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortKeyState_001 end";
359 }
360
361 /**
362 * @tc.number: AccessibilitySettingObserverTest_SetMouseKeyState_001
363 * @tc.name: SetMouseKeyState
364 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
365 * @tc.require: issueI5NTXA
366 */
HWTEST_F(AccessibilitySettingObserverTest, SetMouseKeyState_001, TestSize.Level1)367 HWTEST_F(AccessibilitySettingObserverTest, SetMouseKeyState_001, TestSize.Level1)
368 {
369 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseKeyState_001 start";
370 bool state = true;
371 bool ret = false;
372 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
373 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(ret));
374 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseKeyState_001 end";
375 }
376
377 /**
378 * @tc.number: AccessibilitySettingObserverTest_SetMouseAutoClick_001
379 * @tc.name: SetMouseAutoClick
380 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
381 * @tc.require: issueI5NTXC
382 */
HWTEST_F(AccessibilitySettingObserverTest, SetMouseAutoClick_001, TestSize.Level1)383 HWTEST_F(AccessibilitySettingObserverTest, SetMouseAutoClick_001, TestSize.Level1)
384 {
385 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseAutoClick_001 start";
386 int32_t ret = 0;
387 int32_t value = MOUSE_AUTO_CLICK_VALUE;
388 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
389 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(ret));
390 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseAutoClick_001 end";
391 }
392
393 /**
394 * @tc.number: AccessibilitySettingObserverTest_SetShortkeyTarget_001
395 * @tc.name: SetShortkeyTarget
396 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
397 * @tc.require: issueI5NTXH
398 */
HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyTarget_001, TestSize.Level1)399 HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyTarget_001, TestSize.Level1)
400 {
401 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortkeyTarget_001 start";
402 std::string name = "test";
403 std::string ret = "";
404 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
405 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(ret));
406 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortkeyTarget_001 end";
407 }
408
409 /**
410 * @tc.number: AccessibilitySettingObserverTest_SetHighContrastTextState_001
411 * @tc.name: SetHighContrastTextState
412 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
413 * @tc.require: issueI5NTX9
414 */
HWTEST_F(AccessibilitySettingObserverTest, SetHighContrastTextState_001, TestSize.Level1)415 HWTEST_F(AccessibilitySettingObserverTest, SetHighContrastTextState_001, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetHighContrastTextState_001 start";
418 bool state = true;
419 bool ret = false;
420 EXPECT_EQ(RET_ERR_NULLPTR,
421 Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
422 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(ret));
423 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetHighContrastTextState_001 end";
424 }
425
426 /**
427 * @tc.number: AccessibilitySettingObserverTest_SetDaltonizationState_001
428 * @tc.name: SetDaltonizationState
429 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
430 */
HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationState_001, TestSize.Level1)431 HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationState_001, TestSize.Level1)
432 {
433 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationState_001 start";
434 bool state = true;
435 bool ret = false;
436 EXPECT_EQ(RET_ERR_NULLPTR,
437 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
438 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(ret));
439 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationState_001 end";
440 }
441
442 /**
443 * @tc.number: AccessibilitySettingObserverTest_SetInvertColorState_001
444 * @tc.name: SetInvertColorState
445 * @tc.desc: Test function SetInvertColorState GetInvertColorState
446 * @tc.require: issueI5NTX7
447 */
HWTEST_F(AccessibilitySettingObserverTest, SetInvertColorState_001, TestSize.Level1)448 HWTEST_F(AccessibilitySettingObserverTest, SetInvertColorState_001, TestSize.Level1)
449 {
450 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetInvertColorState_001 start";
451 bool state = true;
452 bool ret = false;
453 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
454 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(ret));
455 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetInvertColorState_001 end";
456 }
457
458 /**
459 * @tc.number: AccessibilitySettingObserverTest_SetAnimationOffState_001
460 * @tc.name: SetAnimationOffState
461 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
462 * @tc.require: issueI5NTXG
463 */
HWTEST_F(AccessibilitySettingObserverTest, SetAnimationOffState_001, TestSize.Level1)464 HWTEST_F(AccessibilitySettingObserverTest, SetAnimationOffState_001, TestSize.Level1)
465 {
466 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAnimationOffState_001 start";
467 bool state = true;
468 bool ret = false;
469 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
470 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(ret));
471 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAnimationOffState_001 end";
472 }
473
474 /**
475 * @tc.number: AccessibilitySettingObserverTest_SetAudioMonoState_001
476 * @tc.name: SetAudioMonoState
477 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
478 */
HWTEST_F(AccessibilitySettingObserverTest, SetAudioMonoState_001, TestSize.Level1)479 HWTEST_F(AccessibilitySettingObserverTest, SetAudioMonoState_001, TestSize.Level1)
480 {
481 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioMonoState_001 start";
482 bool state = true;
483 bool ret = false;
484 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
485 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(ret));
486 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioMonoState_001 end";
487 }
488
489 /**
490 * @tc.number: AccessibilitySettingObserverTest_SetDaltonizationColorFilter_001
491 * @tc.name: SetDaltonizationColorFilter
492 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
493 * @tc.require: issueI5NTX8
494 */
HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationColorFilter_001, TestSize.Level1)495 HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationColorFilter_001, TestSize.Level1)
496 {
497 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationColorFilter_001 start";
498 uint32_t filter = 1;
499 EXPECT_EQ(RET_ERR_NULLPTR,
500 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
501 uint32_t ret = 0;
502 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(ret));
503 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationColorFilter_001 end";
504 }
505
506 /**
507 * @tc.number: AccessibilitySettingObserverTest_SetContentTimeout_001
508 * @tc.name: SetContentTimeout
509 * @tc.desc: Test function SetContentTimeout GetContentTimeout
510 * @tc.require: issueI5NTXF
511 */
HWTEST_F(AccessibilitySettingObserverTest, SetContentTimeout_001, TestSize.Level1)512 HWTEST_F(AccessibilitySettingObserverTest, SetContentTimeout_001, TestSize.Level1)
513 {
514 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetContentTimeout_001 start";
515 uint32_t value = CONTENT_TIMEOUT_VALUE;
516 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(value));
517 uint32_t ret = 0;
518 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(ret));
519 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetContentTimeout_001 end";
520 }
521
522 /**
523 * @tc.number: AccessibilitySettingObserverTest_SetBrightnessDiscount_001
524 * @tc.name: SetBrightnessDiscount
525 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
526 * @tc.require: issueI5NTXE
527 */
HWTEST_F(AccessibilitySettingObserverTest, SetBrightnessDiscount_001, TestSize.Level1)528 HWTEST_F(AccessibilitySettingObserverTest, SetBrightnessDiscount_001, TestSize.Level1)
529 {
530 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetBrightnessDiscount_001 start";
531 float value = BRIGHTNESS_DISCOUNT_VALUE;
532 RetError result = Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value);
533 EXPECT_EQ(RET_ERR_NULLPTR, result);
534 float ret = 0;
535 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(ret));
536 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetBrightnessDiscount_001 end";
537 }
538
539 /**
540 * @tc.number: AccessibilitySettingObserverTest_SetAudioBalance_001
541 * @tc.name: SetAudioBalance
542 * @tc.desc: Test function SetAudioBalance GetAudioBalance
543 */
HWTEST_F(AccessibilitySettingObserverTest, SetAudioBalance_001, TestSize.Level1)544 HWTEST_F(AccessibilitySettingObserverTest, SetAudioBalance_001, TestSize.Level1)
545 {
546 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioBalance_001 start";
547 EXPECT_EQ(RET_ERR_NULLPTR,
548 Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(AUDIO_BALANCE_VALUE));
549 float ret = 0;
550 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(ret));
551 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioBalance_001 end";
552 }
553
554 /**
555 * @tc.number: AccessibilitySettingObserverTest_SetClickResponseTime_001
556 * @tc.name: SetClickResponseTime
557 * @tc.desc: Test function SetClickResponseTime GetClickResponseTime
558 */
HWTEST_F(AccessibilitySettingObserverTest, SetClickResponseTime_001, TestSize.Level1)559 HWTEST_F(AccessibilitySettingObserverTest, SetClickResponseTime_001, TestSize.Level1)
560 {
561 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetClickResponseTime_001 start";
562 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetClickResponseTime(1));
563 uint32_t ret = 0;
564 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetClickResponseTime(ret));
565 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetClickResponseTime_001 end";
566 }
567
568 /**
569 * @tc.number: AccessibilitySettingObserverTest_SetIgnoreRepeatClickState_001
570 * @tc.name: SetIgnoreRepeatClickState
571 * @tc.desc: Test function SetIgnoreRepeatClickState GetIgnoreRepeatClickState
572 */
HWTEST_F(AccessibilitySettingObserverTest, SetIgnoreRepeatClickState_001, TestSize.Level1)573 HWTEST_F(AccessibilitySettingObserverTest, SetIgnoreRepeatClickState_001, TestSize.Level1)
574 {
575 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetIgnoreRepeatClickState_001 start";
576 EXPECT_EQ(RET_ERR_NULLPTR,
577 Singleton<AccessibleAbilityManagerService>::GetInstance().SetIgnoreRepeatClickState(true));
578 bool ret = false;
579 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetIgnoreRepeatClickState(ret));
580 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetIgnoreRepeatClickState_001 end";
581 }
582
583 /**
584 * @tc.number: AccessibilitySettingObserverTest_SetIgnoreRepeatClickTime_001
585 * @tc.name: SetIgnoreRepeatClickTime
586 * @tc.desc: Test function SetIgnoreRepeatClickTime GetIgnoreRepeatClickTime
587 */
HWTEST_F(AccessibilitySettingObserverTest, SetIgnoreRepeatClickTime_001, TestSize.Level1)588 HWTEST_F(AccessibilitySettingObserverTest, SetIgnoreRepeatClickTime_001, TestSize.Level1)
589 {
590 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetIgnoreRepeatClickTime_001 start";
591 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetIgnoreRepeatClickTime(1));
592 uint32_t ret = 0;
593 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetIgnoreRepeatClickTime(ret));
594 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetIgnoreRepeatClickTime_001 end";
595 }
596
597 /**
598 * @tc.number: AccessibilitySettingObserverTest_GetAllConfigs_001
599 * @tc.name: GetAllConfigs
600 * @tc.desc: Test function GetAllConfigs
601 */
HWTEST_F(AccessibilitySettingObserverTest, GetAllConfigs_001, TestSize.Level1)602 HWTEST_F(AccessibilitySettingObserverTest, GetAllConfigs_001, TestSize.Level1)
603 {
604 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAllConfigs_001 start";
605 AccessibilityConfigData data;
606 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(data);
607 EXPECT_NE(stub_.GetRefPtr(), nullptr);
608 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAllConfigs_001 end";
609 }
610
611 /**
612 * @tc.number: AccessibilitySettingObserverTest_SetCaptionState_001
613 * @tc.name: SetCaptionState
614 * @tc.desc: Test function SetCaptionState GetCaptionState
615 */
HWTEST_F(AccessibilitySettingObserverTest, SetCaptionState_001, TestSize.Level1)616 HWTEST_F(AccessibilitySettingObserverTest, SetCaptionState_001, TestSize.Level1)
617 {
618 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionState_001 start";
619 bool state = true;
620 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
621 bool ret = false;
622 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(ret));
623 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionState_001 end";
624 }
625
626 /**
627 * @tc.number: AccessibilitySettingObserverTest_GetEnabledState_001
628 * @tc.name: GetEnabledState
629 * @tc.desc: Test function GetEnabledState
630 */
HWTEST_F(AccessibilitySettingObserverTest, GetEnabledState_001, TestSize.Level1)631 HWTEST_F(AccessibilitySettingObserverTest, GetEnabledState_001, TestSize.Level1)
632 {
633 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetEnabledState_001 start";
634 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledState());
635 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetEnabledState_001 end";
636 }
637
638 /**
639 * @tc.number: AccessibilitySettingObserverTest_GetTouchGuideState_001
640 * @tc.name: GetTouchGuideState
641 * @tc.desc: Test function GetTouchGuideState
642 */
HWTEST_F(AccessibilitySettingObserverTest, GetTouchGuideState_001, TestSize.Level1)643 HWTEST_F(AccessibilitySettingObserverTest, GetTouchGuideState_001, TestSize.Level1)
644 {
645 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetTouchGuideState_001 start";
646 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
647 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetTouchGuideState_001 end";
648 }
649
650 /**
651 * @tc.number: AccessibilitySettingObserverTest_GetGestureState_001
652 * @tc.name: GetGestureState
653 * @tc.desc: Test function GetGestureState
654 */
HWTEST_F(AccessibilitySettingObserverTest, GetGestureState_001, TestSize.Level1)655 HWTEST_F(AccessibilitySettingObserverTest, GetGestureState_001, TestSize.Level1)
656 {
657 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetGestureState_001 start";
658 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
659 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetGestureState_001 end";
660 }
661
662 /**
663 * @tc.number: AccessibilitySettingObserverTest_GetKeyEventObserverState_001
664 * @tc.name: GetKeyEventObserverState
665 * @tc.desc: Test function GetKeyEventObserverState
666 */
HWTEST_F(AccessibilitySettingObserverTest, GetKeyEventObserverState_001, TestSize.Level1)667 HWTEST_F(AccessibilitySettingObserverTest, GetKeyEventObserverState_001, TestSize.Level1)
668 {
669 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetKeyEventObserverState_001 start";
670 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
671 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetKeyEventObserverState_001 end";
672 }
673
674 /**
675 * @tc.number: AccessibilitySettingObserverTest_GetActiveWindow_001
676 * @tc.name: GetActiveWindow
677 * @tc.desc: Test function GetActiveWindow
678 */
HWTEST_F(AccessibilitySettingObserverTest, GetActiveWindow_001, TestSize.Level1)679 HWTEST_F(AccessibilitySettingObserverTest, GetActiveWindow_001, TestSize.Level1)
680 {
681 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetActiveWindow_001 start";
682 Singleton<AccessibilityWindowManager>::GetInstance().SetActiveWindow(ACTIVE_WINDOW_VALUE);
683 EXPECT_EQ(ACTIVE_WINDOW_VALUE, Singleton<AccessibleAbilityManagerService>::GetInstance().GetActiveWindow());
684 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetActiveWindow_001 end";
685 }
686
687 /**
688 * @tc.number: AccessibilitySettingObserverTest_SetCaptionProperty_001
689 * @tc.name: SetCaptionProperty
690 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
691 */
HWTEST_F(AccessibilitySettingObserverTest, SetCaptionProperty_001, TestSize.Level1)692 HWTEST_F(AccessibilitySettingObserverTest, SetCaptionProperty_001, TestSize.Level1)
693 {
694 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionProperty_001 start";
695 AccessibilityConfig::CaptionProperty caption;
696 int scale = 1;
697 caption.SetFontScale(scale);
698 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
699
700 AccessibilityConfig::CaptionProperty res;
701 EXPECT_EQ(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(res));
702 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionProperty_001 end";
703 }
704
705 /**
706 * @tc.number: AccessibilitySettingObserver_UnitTest_PackageAdd_001
707 * @tc.name: PackageAdd
708 * @tc.desc: Test function PackageAdd
709 */
HWTEST_F(AccessibilitySettingObserverTest, PackageAdd_001, TestSize.Level1)710 HWTEST_F(AccessibilitySettingObserverTest, PackageAdd_001, TestSize.Level1)
711 {
712 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageAdd_001 start";
713
714 std::string bundleName = "bundleName1";
715 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
716 EXPECT_NE(stub_.GetRefPtr(), nullptr);
717 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageAdd_001 end";
718 }
719
720 /**
721 * @tc.number: AccessibilitySettingObserver_UnitTest_PackageRemoved_001
722 * @tc.name: PackageRemoved
723 * @tc.desc: Test function PackageRemoved
724 */
HWTEST_F(AccessibilitySettingObserverTest, PackageRemoved_001, TestSize.Level1)725 HWTEST_F(AccessibilitySettingObserverTest, PackageRemoved_001, TestSize.Level1)
726 {
727 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageRemoved_001 start";
728 std::string bundleName = "bundleName1";
729 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
730 EXPECT_NE(stub_.GetRefPtr(), nullptr);
731 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageRemoved_001 end";
732 }
733
734 /**
735 * @tc.number: AccessibilitySettingObserver_UnitTest_AddedUser_001
736 * @tc.name: AddedUser
737 * @tc.desc: Test function AddedUser
738 */
HWTEST_F(AccessibilitySettingObserverTest, AddedUser_001, TestSize.Level1)739 HWTEST_F(AccessibilitySettingObserverTest, AddedUser_001, TestSize.Level1)
740 {
741 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_AddedUser_001 start";
742 int32_t accountId = 1;
743 Singleton<AccessibleAbilityManagerService>::GetInstance().AddedUser(accountId);
744 EXPECT_NE(stub_.GetRefPtr(), nullptr);
745 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_AddedUser_001 end";
746 }
747
748 /**
749 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableShortKeyTargetAbility_001
750 * @tc.name: EnableShortKeyTargetAbility
751 * @tc.desc: Test function EnableShortKeyTargetAbility
752 */
HWTEST_F(AccessibilitySettingObserverTest, EnableShortKeyTargetAbility_001, TestSize.Level1)753 HWTEST_F(AccessibilitySettingObserverTest, EnableShortKeyTargetAbility_001, TestSize.Level1)
754 {
755 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableShortKeyTargetAbility_001 start";
756 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
757 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableShortKeyTargetAbility_001 end";
758 }
759
760 /**
761 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableShortKeyTargetAbility_001
762 * @tc.name: DisableShortKeyTargetAbility
763 * @tc.desc: Test function DisableShortKeyTargetAbility AccessibilitySettingObserver
764 */
HWTEST_F(AccessibilitySettingObserverTest, DisableShortKeyTargetAbility_001, TestSize.Level1)765 HWTEST_F(AccessibilitySettingObserverTest, DisableShortKeyTargetAbility_001, TestSize.Level1)
766 {
767 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableShortKeyTargetAbility_001 start";
768 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
769 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableShortKeyTargetAbility_001 end";
770 }
771
772 /**
773 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableAbility_001
774 * @tc.name: EnableAbility
775 * @tc.desc: Test function EnableAbility
776 */
HWTEST_F(AccessibilitySettingObserverTest, EnableAbility_001, TestSize.Level1)777 HWTEST_F(AccessibilitySettingObserverTest, EnableAbility_001, TestSize.Level1)
778 {
779 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableAbility_001 start";
780 std::string name = "test";
781 uint32_t capabilities = 1;
782 EXPECT_EQ(RET_ERR_NOT_INSTALLED,
783 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
784 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableAbility_001 end";
785 }
786
787 /*
788 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableAbility_001
789 * @tc.name: DisableAbility
790 * @tc.desc: Test function DisableAbility
791 */
HWTEST_F(AccessibilitySettingObserverTest, DisableAbility_001, TestSize.Level1)792 HWTEST_F(AccessibilitySettingObserverTest, DisableAbility_001, TestSize.Level1)
793 {
794 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableAbility_001 start";
795 std::string name = "test";
796 EXPECT_EQ(RET_ERR_NOT_ENABLED, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
797 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableAbility_001 end";
798 }
799
800 /*
801 * @tc.number: AccessibilitySettingObserver_UnitTest_GetEnabledAbilities_001
802 * @tc.name: GetEnabledAbilities
803 * @tc.desc: Test function GetEnabledAbilities
804 */
HWTEST_F(AccessibilitySettingObserverTest, GetEnabledAbilities_001, TestSize.Level1)805 HWTEST_F(AccessibilitySettingObserverTest, GetEnabledAbilities_001, TestSize.Level1)
806 {
807 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetEnabledAbilities_001 start";
808 std::vector<std::string> enabledAbilities;
809 EXPECT_EQ(RET_OK,
810 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
811 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetEnabledAbilities_001 end";
812 }
813
814 /*
815 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableUITestAbility_001
816 * @tc.name: EnableUITestAbility
817 * @tc.desc: Test function EnableUITestAbility
818 */
HWTEST_F(AccessibilitySettingObserverTest, EnableUITestAbility_001, TestSize.Level1)819 HWTEST_F(AccessibilitySettingObserverTest, EnableUITestAbility_001, TestSize.Level1)
820 {
821 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableUITestAbility_001 start";
822 sptr<IRemoteObject> obj;
823 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
824 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_001 end";
825 }
826
827 /*
828 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableUITestAbility_001
829 * @tc.name: DisableUITestAbility
830 * @tc.desc: Test function DisableUITestAbility
831 */
HWTEST_F(AccessibilitySettingObserverTest, DisableUITestAbility_001, TestSize.Level1)832 HWTEST_F(AccessibilitySettingObserverTest, DisableUITestAbility_001, TestSize.Level1)
833 {
834 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableUITestAbility_001 start";
835 EXPECT_EQ(RET_ERR_NO_CONNECTION, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility());
836 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableUITestAbility_001 end";
837 }
838
839 /**
840 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_001
841 * @tc.name: RegisterCaptionObserver
842 * @tc.desc: Test function RegisterCaptionObserver
843 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_001, TestSize.Level1)844 HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_001, TestSize.Level1)
845 {
846 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_001 start";
847
848 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
849 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
850
851 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
852 EXPECT_EQ(ret, 0);
853
854 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_001 end";
855 }
856
857 /*
858 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_001
859 * @tc.name: RegisterConfigObserver
860 * @tc.desc: Test function RegisterConfigObserver
861 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterConfigObserver_001, TestSize.Level1)862 HWTEST_F(AccessibilitySettingObserverTest, RegisterConfigObserver_001, TestSize.Level1)
863 {
864 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_001 start";
865
866 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
867 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
868
869 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
870 EXPECT_EQ(ret, 0);
871
872 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_001 end";
873 }
874
875 /*
876 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_001
877 * @tc.name: RegisterEnableAbilityListsObserver
878 * @tc.desc: Test function RegisterEnableAbilityListsObserver
879 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)880 HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_001, TestSize.Level1)
881 {
882 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_001 start";
883
884 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
885 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
886
887 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
888 EXPECT_NE(stub.GetRefPtr(), nullptr);
889 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_001 end";
890 }
891
892 /**
893 * @tc.number: AccessibilitySettingObserver_UnitTest_SwitchedUser_001
894 * @tc.name: SwitchedUser
895 * @tc.desc: Test function SwitchedUser
896 */
HWTEST_F(AccessibilitySettingObserverTest, SwitchedUser_001, TestSize.Level1)897 HWTEST_F(AccessibilitySettingObserverTest, SwitchedUser_001, TestSize.Level1)
898 {
899 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SwitchedUser_001 start";
900 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(100);
901 sleep(SLEEP_TIME_1);
902 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(2);
903 EXPECT_NE(stub_.GetRefPtr(), nullptr);
904 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SwitchedUser_001 end";
905 }
906
907 /**
908 * @tc.number: AccessibilitySettingObserver_UnitTest_GetAbilityList_002
909 * @tc.name: GetAbilityList
910 * @tc.desc: Test function GetAbilityList
911 */
HWTEST_F(AccessibilitySettingObserverTest, GetAbilityList_002, TestSize.Level1)912 HWTEST_F(AccessibilitySettingObserverTest, GetAbilityList_002, TestSize.Level1)
913 {
914 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAbilityList_002 start";
915 sleep(SLEEP_TIME_1);
916 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
917 std::vector<OHOS::Accessibility::AccessibilityAbilityInfo> infos;
918 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAbilityList(0xFFFFFFFF, 3, infos);
919 EXPECT_NE(stub_.GetRefPtr(), nullptr);
920 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_GetAbilityList_002 end";
921 }
922
923 /**
924 * @tc.number: AccessibilitySettingObserver_UnitTest_RegisterElementOperator_002
925 * @tc.name: RegisterElementOperator
926 * @tc.desc: Test function RegisterElementOperator
927 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_002, TestSize.Level1)928 HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_002, TestSize.Level1)
929 {
930 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_002 start";
931 sleep(SLEEP_TIME_1);
932 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
933 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, nullptr, true);
934 EXPECT_NE(stub_.GetRefPtr(), nullptr);
935 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_002 end";
936 }
937
938 /**
939 * @tc.number: AccessibilitySettingObserver_UnitTest_RegisterElementOperator_003
940 * @tc.name: RegisterElementOperator
941 * @tc.desc: Test function RegisterElementOperator
942 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_003, TestSize.Level1)943 HWTEST_F(AccessibilitySettingObserverTest, RegisterElementOperator_003, TestSize.Level1)
944 {
945 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_003 start";
946 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
947 ASSERT_TRUE(accountData);
948 sptr<IAccessibilityElementOperator> operation;
949 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation, true);
950 sleep(SLEEP_TIME_1);
951 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterElementOperator(0, operation, true);
952 auto map = accountData->GetAsacConnections();
953 EXPECT_EQ(int(map.size()), 1);
954 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterElementOperator_003 end";
955 }
956
957 /**
958 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateAccessibilityManagerService_001
959 * @tc.name: UpdateAccessibilityManagerService
960 * @tc.desc: Test function UpdateAccessibilityManagerService
961 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateAccessibilityManagerService_001, TestSize.Level1)962 HWTEST_F(AccessibilitySettingObserverTest, UpdateAccessibilityManagerService_001, TestSize.Level1)
963 {
964 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateAccessibilityManagerService_001 start";
965 sleep(SLEEP_TIME_1);
966 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
967 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAccessibilityManagerService();
968 EXPECT_NE(stub_.GetRefPtr(), nullptr);
969 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateAccessibilityManagerService_001 end";
970 }
971
972 /**
973 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_002
974 * @tc.name: RegisterStateCallback
975 * @tc.desc: Test function RegisterStateCallback
976 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterStateCallback_002, TestSize.Level1)977 HWTEST_F(AccessibilitySettingObserverTest, RegisterStateCallback_002, TestSize.Level1)
978 {
979 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_00 start";
980 sleep(SLEEP_TIME_1);
981 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
982 sptr<AccessibleAbilityManagerStateObserverStub> stub = new MockAccessibleAbilityManagerStateObserverStub();
983 sptr<IAccessibleAbilityManagerStateObserver> state = new MockAccessibleAbilityManagerStateObserverProxy(stub);
984
985 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterStateObserver(state);
986 EXPECT_EQ(ret, 0);
987
988 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterStateCallback_002 end";
989 }
990
991 /**
992 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_002
993 * @tc.name: RegisterCaptionObserver
994 * @tc.desc: Test function RegisterCaptionObserver
995 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_002, TestSize.Level1)996 HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_002, TestSize.Level1)
997 {
998 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_002 start";
999 sleep(SLEEP_TIME_1);
1000 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1001 sptr<MockAccessibleAbilityManagerCaptionObserverStub> stub = new MockAccessibleAbilityManagerCaptionObserverStub();
1002 sptr<IAccessibleAbilityManagerCaptionObserver> state = new MockAccessibleAbilityManagerCaptionObserverProxy(stub);
1003
1004 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(state);
1005 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1006
1007 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_002 end";
1008 }
1009
1010 /**
1011 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_003
1012 * @tc.name: RegisterCaptionObserver
1013 * @tc.desc: Test function RegisterCaptionObserver
1014 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_003, TestSize.Level1)1015 HWTEST_F(AccessibilitySettingObserverTest, RegisterCaptionObserver_003, TestSize.Level1)
1016 {
1017 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_003 start";
1018 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterCaptionObserver(nullptr);
1019 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1020
1021 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterCaptionObserver_003 end";
1022 }
1023
1024 /*
1025 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_002
1026 * @tc.name: RegisterEnableAbilityListsObserver
1027 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1028 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)1029 HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_002, TestSize.Level1)
1030 {
1031 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_002 start";
1032 sleep(SLEEP_TIME_1);
1033 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1034 sptr<MockAccessibilityEnableAbilityListsObserverStub> stub = new MockAccessibilityEnableAbilityListsObserverStub();
1035 sptr<IAccessibilityEnableAbilityListsObserver> state = new MockAccessibilityEnableAbilityListsObserverProxy(stub);
1036
1037 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(state);
1038 EXPECT_NE(stub.GetRefPtr(), nullptr);
1039 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_002 end";
1040 }
1041
1042 /*
1043 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_003
1044 * @tc.name: RegisterEnableAbilityListsObserver
1045 * @tc.desc: Test function RegisterEnableAbilityListsObserver
1046 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)1047 HWTEST_F(AccessibilitySettingObserverTest, RegisterEnableAbilityListsObserver_003, TestSize.Level1)
1048 {
1049 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_003 start";
1050 Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterEnableAbilityListsObserver(nullptr);
1051 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1052 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterEnableAbilityListsObserver_003 end";
1053 }
1054
1055 /**
1056 * @tc.number: AccessibilitySettingObserverTest_SetCaptionProperty_002
1057 * @tc.name: SetCaptionProperty
1058 * @tc.desc: Test function SetCaptionProperty GetCaptionProperty
1059 */
HWTEST_F(AccessibilitySettingObserverTest, SetCaptionProperty_002, TestSize.Level1)1060 HWTEST_F(AccessibilitySettingObserverTest, SetCaptionProperty_002, TestSize.Level1)
1061 {
1062 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionProperty_002 start";
1063 sleep(SLEEP_TIME_1);
1064 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1065 AccessibilityConfig::CaptionProperty caption;
1066 int scale = 1;
1067 caption.SetFontScale(scale);
1068 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionProperty(caption));
1069 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionProperty(caption));
1070 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionProperty_002 end";
1071 }
1072
1073 /**
1074 * @tc.number: AccessibilitySettingObserverTest_SetCaptionState_002
1075 * @tc.name: SetCaptionState
1076 * @tc.desc: Test function SetCaptionState GetCaptionState
1077 */
HWTEST_F(AccessibilitySettingObserverTest, SetCaptionState_002, TestSize.Level1)1078 HWTEST_F(AccessibilitySettingObserverTest, SetCaptionState_002, TestSize.Level1)
1079 {
1080 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionState_002 start";
1081 sleep(SLEEP_TIME_1);
1082 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1083 bool state = true;
1084 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetCaptionState(state));
1085 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetCaptionState(state));
1086 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetCaptionState_002 end";
1087 }
1088
1089 /**
1090 * @tc.number: AccessibilitySettingObserverTest_GetTouchGuideState_002
1091 * @tc.name: GetTouchGuideState
1092 * @tc.desc: Test function GetTouchGuideState
1093 */
HWTEST_F(AccessibilitySettingObserverTest, GetTouchGuideState_002, TestSize.Level1)1094 HWTEST_F(AccessibilitySettingObserverTest, GetTouchGuideState_002, TestSize.Level1)
1095 {
1096 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetTouchGuideState_002 start";
1097 sleep(SLEEP_TIME_1);
1098 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1099 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetTouchGuideState());
1100 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetTouchGuideState_002 end";
1101 }
1102
1103 /**
1104 * @tc.number: AccessibilitySettingObserverTest_GetGestureState_002
1105 * @tc.name: GetGestureState
1106 * @tc.desc: Test function GetGestureState
1107 */
HWTEST_F(AccessibilitySettingObserverTest, GetGestureState_002, TestSize.Level1)1108 HWTEST_F(AccessibilitySettingObserverTest, GetGestureState_002, TestSize.Level1)
1109 {
1110 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetGestureState_002 start";
1111 sleep(SLEEP_TIME_1);
1112 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1113 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetGestureState());
1114 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetGestureState_002 end";
1115 }
1116
1117 /**
1118 * @tc.number: AccessibilitySettingObserverTest_GetKeyEventObserverState_002
1119 * @tc.name: GetKeyEventObserverState
1120 * @tc.desc: Test function GetKeyEventObserverState
1121 */
HWTEST_F(AccessibilitySettingObserverTest, GetKeyEventObserverState_002, TestSize.Level1)1122 HWTEST_F(AccessibilitySettingObserverTest, GetKeyEventObserverState_002, TestSize.Level1)
1123 {
1124 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetKeyEventObserverState_002 start";
1125 sleep(SLEEP_TIME_1);
1126 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1127 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetKeyEventObserverState());
1128 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetKeyEventObserverState_002 end";
1129 }
1130
1131 /**
1132 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableAbility_002
1133 * @tc.name: EnableAbility
1134 * @tc.desc: Test function EnableAbility
1135 */
HWTEST_F(AccessibilitySettingObserverTest, EnableAbility_002, TestSize.Level1)1136 HWTEST_F(AccessibilitySettingObserverTest, EnableAbility_002, TestSize.Level1)
1137 {
1138 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableAbility_002 start";
1139 sleep(SLEEP_TIME_1);
1140 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1141 std::string name = "test";
1142 uint32_t capabilities = 1;
1143 EXPECT_EQ(RET_ERR_NULLPTR,
1144 Singleton<AccessibleAbilityManagerService>::GetInstance().EnableAbility(name, capabilities));
1145 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableAbility_002 end";
1146 }
1147
1148 /*
1149 * @tc.number: AccessibilitySettingObserver_UnitTest_GetEnabledAbilities_002
1150 * @tc.name: GetEnabledAbilities
1151 * @tc.desc: Test function GetEnabledAbilities
1152 */
HWTEST_F(AccessibilitySettingObserverTest, GetEnabledAbilities_002, TestSize.Level1)1153 HWTEST_F(AccessibilitySettingObserverTest, GetEnabledAbilities_002, TestSize.Level1)
1154 {
1155 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetEnabledAbilities_002 start";
1156 sleep(SLEEP_TIME_1);
1157 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1158 std::vector<std::string> enabledAbilities;
1159 EXPECT_EQ(RET_ERR_NULLPTR,
1160 Singleton<AccessibleAbilityManagerService>::GetInstance().GetEnabledAbilities(enabledAbilities));
1161 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_GetEnabledAbilities_002 end";
1162 }
1163
1164 /*
1165 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableAbility_002
1166 * @tc.name: DisableAbility
1167 * @tc.desc: Test function DisableAbility
1168 */
HWTEST_F(AccessibilitySettingObserverTest, DisableAbility_002, TestSize.Level1)1169 HWTEST_F(AccessibilitySettingObserverTest, DisableAbility_002, TestSize.Level1)
1170 {
1171 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableAbility_002 start";
1172 sleep(SLEEP_TIME_1);
1173 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1174 std::string name = "test";
1175 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().DisableAbility(name));
1176 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableAbility_002 end";
1177 }
1178
1179 /*
1180 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableUITestAbility_002
1181 * @tc.name: EnableUITestAbility
1182 * @tc.desc: Test function EnableUITestAbility
1183 */
HWTEST_F(AccessibilitySettingObserverTest, EnableUITestAbility_002, TestSize.Level1)1184 HWTEST_F(AccessibilitySettingObserverTest, EnableUITestAbility_002, TestSize.Level1)
1185 {
1186 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableUITestAbility_002 start";
1187 sleep(SLEEP_TIME_1);
1188 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1189 sptr<IRemoteObject> obj;
1190 EXPECT_EQ(RET_ERR_NULLPTR, Singleton<AccessibleAbilityManagerService>::GetInstance().EnableUITestAbility(obj));
1191 GTEST_LOG_(INFO) << "Accessib le_Ability_Manager_ServiceUnittest_EnableUITestAbility_002 end";
1192 }
1193
1194 /*
1195 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableUITestAbility_002
1196 * @tc.name: DisableUITestAbility
1197 * @tc.desc: Test function DisableUITestAbility
1198 */
HWTEST_F(AccessibilitySettingObserverTest, DisableUITestAbility_002, TestSize.Level1)1199 HWTEST_F(AccessibilitySettingObserverTest, DisableUITestAbility_002, TestSize.Level1)
1200 {
1201 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableUITestAbility_002 start";
1202 sleep(SLEEP_TIME_1);
1203 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1204 EXPECT_EQ(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableUITestAbility(), RET_ERR_NULLPTR);
1205 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableUITestAbility_002 end";
1206 }
1207
1208 /**
1209 * @tc.number: AccessibilitySettingObserver_UnitTest_EnableShortKeyTargetAbility_002
1210 * @tc.name: EnableShortKeyTargetAbility
1211 * @tc.desc: Test function EnableShortKeyTargetAbility
1212 */
HWTEST_F(AccessibilitySettingObserverTest, EnableShortKeyTargetAbility_002, TestSize.Level1)1213 HWTEST_F(AccessibilitySettingObserverTest, EnableShortKeyTargetAbility_002, TestSize.Level1)
1214 {
1215 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableShortKeyTargetAbility_002 start";
1216 sleep(SLEEP_TIME_1);
1217 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1218 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().EnableShortKeyTargetAbility());
1219 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_EnableShortKeyTargetAbility_002 end";
1220 }
1221
1222 /**
1223 * @tc.number: AccessibilitySettingObserver_UnitTest_DisableShortKeyTargetAbility_002
1224 * @tc.name: DisableShortKeyTargetAbility
1225 * @tc.desc: Test function DisableShortKeyTargetAbility
1226 */
HWTEST_F(AccessibilitySettingObserverTest, DisableShortKeyTargetAbility_002, TestSize.Level1)1227 HWTEST_F(AccessibilitySettingObserverTest, DisableShortKeyTargetAbility_002, TestSize.Level1)
1228 {
1229 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableShortKeyTargetAbility_002 start";
1230 sleep(SLEEP_TIME_1);
1231 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1232 EXPECT_FALSE(Singleton<AccessibleAbilityManagerService>::GetInstance().DisableShortKeyTargetAbility());
1233 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_DisableShortKeyTargetAbility_002 end";
1234 }
1235
1236 /**
1237 * @tc.number: AccessibilitySettingObserver_UnitTest_PackageRemoved_002
1238 * @tc.name: PackageRemoved
1239 * @tc.desc: Test function PackageRemoved
1240 */
HWTEST_F(AccessibilitySettingObserverTest, PackageRemoved_002, TestSize.Level1)1241 HWTEST_F(AccessibilitySettingObserverTest, PackageRemoved_002, TestSize.Level1)
1242 {
1243 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageRemoved_002 start";
1244 sleep(SLEEP_TIME_1);
1245 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1246 std::string bundleName = "bundleName1";
1247 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageRemoved(bundleName);
1248 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1249 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageRemoved_002 end";
1250 }
1251
1252 /**
1253 * @tc.number: AccessibilitySettingObserver_UnitTest_PackageAdd_002
1254 * @tc.name: PackageAdd
1255 * @tc.desc: Test function PackageAdd
1256 */
HWTEST_F(AccessibilitySettingObserverTest, PackageAdd_002, TestSize.Level1)1257 HWTEST_F(AccessibilitySettingObserverTest, PackageAdd_002, TestSize.Level1)
1258 {
1259 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageAdd_002 start";
1260 sleep(SLEEP_TIME_1);
1261 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1262 std::string bundleName = "bundleName1";
1263 Singleton<AccessibleAbilityManagerService>::GetInstance().PackageAdd(bundleName);
1264 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1265 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_ServiceUnittest_PackageAdd_002 end";
1266 }
1267
1268 /*
1269 * @tc.number: AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_002
1270 * @tc.name: RegisterConfigObserver
1271 * @tc.desc: Test function RegisterConfigObserver
1272 */
HWTEST_F(AccessibilitySettingObserverTest, RegisterConfigObserver_002, TestSize.Level1)1273 HWTEST_F(AccessibilitySettingObserverTest, RegisterConfigObserver_002, TestSize.Level1)
1274 {
1275 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_002 start";
1276 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(nullptr);
1277 EXPECT_EQ(ret, ERR_INVALID_VALUE);
1278 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_Unittest_RegisterConfigObserver_002 end";
1279 }
1280
1281 /**
1282 * @tc.number: AccessibilitySettingObserverTest_SetScreenMagnificationState_002
1283 * @tc.name: SetScreenMagnificationState
1284 * @tc.desc: Test function SetScreenMagnificationState GetScreenMagnificationState
1285 */
1286
HWTEST_F(AccessibilitySettingObserverTest, SetScreenMagnificationState_002, TestSize.Level1)1287 HWTEST_F(AccessibilitySettingObserverTest, SetScreenMagnificationState_002, TestSize.Level1)
1288 {
1289 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetScreenMagnificationState_000 start";
1290 sleep(SLEEP_TIME_1);
1291 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1292 bool state = true;
1293 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetScreenMagnificationState(state));
1294 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetScreenMagnificationState(state));
1295 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetScreenMagnificationState_002 end";
1296 }
1297
1298 /**
1299 * @tc.number: AccessibilitySettingObserverTest_SetShortKeyState_002
1300 * @tc.name: SetShortKeyState
1301 * @tc.desc: Test function SetShortKeyState GetShortKeyState
1302 * @tc.require: issueI5NTXH
1303 */
HWTEST_F(AccessibilitySettingObserverTest, SetShortKeyState_002, TestSize.Level1)1304 HWTEST_F(AccessibilitySettingObserverTest, SetShortKeyState_002, TestSize.Level1)
1305 {
1306 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortKeyState_002 start";
1307 sleep(SLEEP_TIME_1);
1308 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1309 bool state = true;
1310 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortKeyState(state));
1311 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortKeyState(state));
1312 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortKeyState_002 end";
1313 }
1314
1315 /**
1316 * @tc.number: AccessibilitySettingObserverTest_SetMouseKeyState_002
1317 * @tc.name: SetMouseKeyState
1318 * @tc.desc: Test function SetMouseKeyState GetMouseKeyState
1319 * @tc.require: issueI5NTXA
1320 */
HWTEST_F(AccessibilitySettingObserverTest, SetMouseKeyState_002, TestSize.Level1)1321 HWTEST_F(AccessibilitySettingObserverTest, SetMouseKeyState_002, TestSize.Level1)
1322 {
1323 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseKeyState_002 start";
1324 sleep(SLEEP_TIME_1);
1325 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1326 bool state = true;
1327 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseKeyState(state));
1328 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseKeyState(state));
1329 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseKeyState_002 end";
1330 }
1331
1332 /**
1333 * @tc.number: AccessibilitySettingObserver_UnitTest_SetSearchElementInfoByAccessibilityIdResult_001
1334 * @tc.name: SetSearchElementInfoByAccessibilityIdResult
1335 * @tc.desc: Test function SetSearchElementInfoByAccessibilityIdResult
1336 */
HWTEST_F(AccessibilitySettingObserverTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)1337 HWTEST_F(AccessibilitySettingObserverTest, SetSearchElementInfoByAccessibilityIdResult_001, TestSize.Level1)
1338 {
1339 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetSearchElementInfoByAccessibilityIdResult_001 start";
1340 std::vector<AccessibilityElementInfo> infos;
1341 int32_t requestId = 0;
1342 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1343 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1344 obj->SetSearchElementInfoByAccessibilityIdResult(infos, requestId);
1345 delete obj;
1346 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetSearchElementInfoByAccessibilityIdResult_001 end";
1347 }
1348
1349 /**
1350 * @tc.number: AccessibilitySettingObserver_UnitTest_SetSearchElementInfoByTextResult_001
1351 * @tc.name: SetSearchElementInfoByTextResult
1352 * @tc.desc: Test function SetSearchElementInfoByTextResult
1353 */
HWTEST_F(AccessibilitySettingObserverTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)1354 HWTEST_F(AccessibilitySettingObserverTest, SetSearchElementInfoByTextResult_001, TestSize.Level1)
1355 {
1356 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetSearchElementInfoByTextResult_001 start";
1357 std::vector<AccessibilityElementInfo> infos;
1358 int32_t requestId = 0;
1359 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1360 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1361 obj->SetSearchElementInfoByTextResult(infos, requestId);
1362 delete obj;
1363 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetSearchElementInfoByTextResult_001 end";
1364 }
1365
1366 /**
1367 * @tc.number: AccessibilitySettingObserver_UnitTest_SetFindFocusedElementInfoResult_001
1368 * @tc.name: SetFindFocusedElementInfoResult
1369 * @tc.desc: Test function SetFindFocusedElementInfoResult
1370 */
HWTEST_F(AccessibilitySettingObserverTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)1371 HWTEST_F(AccessibilitySettingObserverTest, SetFindFocusedElementInfoResult_001, TestSize.Level1)
1372 {
1373 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetFindFocusedElementInfoResult_001 start";
1374 AccessibilityElementInfo info;
1375 int32_t requestId = 0;
1376 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1377 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1378 obj->SetFindFocusedElementInfoResult(info, requestId);
1379 delete obj;
1380 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetFindFocusedElementInfoResult_001 end";
1381 }
1382
1383 /**
1384 * @tc.number: AccessibilitySettingObserver_UnitTest_SetFocusMoveSearchResult_001
1385 * @tc.name: SetFocusMoveSearchResult
1386 * @tc.desc: Test function SetFocusMoveSearchResult
1387 */
HWTEST_F(AccessibilitySettingObserverTest, SetFocusMoveSearchResult_001, TestSize.Level1)1388 HWTEST_F(AccessibilitySettingObserverTest, SetFocusMoveSearchResult_001, TestSize.Level1)
1389 {
1390 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetFocusMoveSearchResult_001 start";
1391 AccessibilityElementInfo info;
1392 int32_t requestId = 0;
1393 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1394 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1395 obj->SetFocusMoveSearchResult(info, requestId);
1396 delete obj;;
1397 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetFocusMoveSearchResult_001 end";
1398 }
1399
1400 /**
1401 * @tc.number: AccessibilitySettingObserver_UnitTest_SetExecuteActionResult_001
1402 * @tc.name: SetExecuteActionResult
1403 * @tc.desc: Test function SetExecuteActionResult
1404 */
HWTEST_F(AccessibilitySettingObserverTest, SetExecuteActionResult_001, TestSize.Level1)1405 HWTEST_F(AccessibilitySettingObserverTest, SetExecuteActionResult_001, TestSize.Level1)
1406 {
1407 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetExecuteActionResult_001 start";
1408 AccessibilityElementInfo info;
1409 int32_t requestId = 0;
1410 bool succeeded = true;
1411 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1412 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1413 obj->SetExecuteActionResult(succeeded, requestId);
1414 delete obj;;
1415 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetExecuteActionResult_001 end";
1416 }
1417
1418 /**
1419 * @tc.number: AccessibilitySettingObserver_UnitTest_SetCursorPositionResult_001
1420 * @tc.name: SetCursorPositionResult
1421 * @tc.desc: Test function SetCursorPositionResult
1422 */
HWTEST_F(AccessibilitySettingObserverTest, SetCursorPositionResult_001, TestSize.Level1)1423 HWTEST_F(AccessibilitySettingObserverTest, SetCursorPositionResult_001, TestSize.Level1)
1424 {
1425 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetCursorPositionResult_001 start";
1426 AccessibilityElementInfo info;
1427 int32_t requestId = 0;
1428 int32_t cursorPosition = 0;
1429 AccessibleAbilityManagerService::ElementOperatorCallbackImpl *obj = new
1430 AccessibleAbilityManagerService::ElementOperatorCallbackImpl();
1431 obj->SetCursorPositionResult(cursorPosition, requestId);
1432 delete obj;
1433
1434 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetCursorPositionResult_001 end";
1435 }
1436
1437 /**
1438 * @tc.number: AccessibilitySettingObserver_UnitTest_SetShortkeyMultiTarget_001
1439 * @tc.name: SetShortkeyMultiTarget
1440 * @tc.desc: Test function SetShortkeyMultiTarget
1441 */
HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyMultiTarget_001, TestSize.Level1)1442 HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyMultiTarget_001, TestSize.Level1)
1443 {
1444 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetShortkeyMultiTarget_001 start";
1445 std::vector<std::string> name;
1446 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
1447 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_SetShortkeyMultiTarget_001 end";
1448 }
1449
1450 /**
1451 * @tc.number: AccessibilitySettingObserver_UnitTest_GetShortkeyMultiTarget_001
1452 * @tc.name: GetShortkeyMultiTarget
1453 * @tc.desc: Test function GetShortkeyMultiTarget
1454 */
HWTEST_F(AccessibilitySettingObserverTest, GetShortkeyMultiTarget_001, TestSize.Level1)1455 HWTEST_F(AccessibilitySettingObserverTest, GetShortkeyMultiTarget_001, TestSize.Level1)
1456 {
1457 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_GetShortkeyMultiTarget_001 start";
1458 std::vector<std::string> name;
1459 Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyMultiTarget(name);
1460 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_GetShortkeyMultiTarget_001 end";
1461 }
1462
1463 /**OnShortKeyProcess
1464 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_001
1465 * @tc.name: OnShortKeyProcess
1466 * @tc.desc: Test function OnShortKeyProcess
1467 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_001, TestSize.Level1)1468 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_001, TestSize.Level1)
1469 {
1470 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_001 start";
1471 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1472 sleep(SLEEP_TIME_1);
1473 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1474 EXPECT_TRUE(Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData() == nullptr);
1475 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_001 end";
1476 }
1477
1478 /**OnShortKeyProcess
1479 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_002
1480 * @tc.name: OnShortKeyProcess
1481 * @tc.desc: Test function OnShortKeyProcess
1482 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_002, TestSize.Level1)1483 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_002, TestSize.Level1)
1484 {
1485 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_001 start";
1486 std::shared_ptr<AccessibilitySettingProvider> service =
1487 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1488 if (service == nullptr) {
1489 GTEST_LOG_(INFO) << "service is nullptr";
1490 return;
1491 }
1492 service->PutBoolValue(DEVICE_PROVISIONED, false, true);
1493
1494 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1495 if (accountData == nullptr) {
1496 GTEST_LOG_(INFO) << "accountData is nullptr";
1497 return;
1498 }
1499
1500 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1501 EXPECT_EQ(accountData->GetConfig()->GetShortKeyTimeout(), SHORT_KEY_TIMEOUT_BEFORE_USE);
1502 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_002 end";
1503 }
1504
1505 /**OnShortKeyProcess
1506 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_003
1507 * @tc.name: OnShortKeyProcess
1508 * @tc.desc: Test function OnShortKeyProcess
1509 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_003, TestSize.Level1)1510 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_003, TestSize.Level1)
1511 {
1512 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_003 start";
1513 std::shared_ptr<AccessibilitySettingProvider> service =
1514 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1515 if (service == nullptr) {
1516 GTEST_LOG_(INFO) << "service is nullptr";
1517 return;
1518 }
1519 service->PutBoolValue(DEVICE_PROVISIONED, true, true);
1520
1521 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1522 if (accountData == nullptr) {
1523 GTEST_LOG_(INFO) << "accountData is nullptr";
1524 return;
1525 }
1526
1527 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1528 EXPECT_EQ(accountData->GetConfig()->GetShortKeyTimeout(), SHORT_KEY_TIMEOUT_BEFORE_USE);
1529 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_003 end";
1530 }
1531
1532 /**OnShortKeyProcess
1533 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_004
1534 * @tc.name: OnShortKeyProcess
1535 * @tc.desc: Test function OnShortKeyProcess
1536 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_004, TestSize.Level1)1537 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_004, TestSize.Level1)
1538 {
1539 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_004 start";
1540 std::shared_ptr<AccessibilitySettingProvider> service =
1541 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1542 if (service == nullptr) {
1543 GTEST_LOG_(INFO) << "service is nullptr";
1544 return;
1545 }
1546 service->PutBoolValue(DEVICE_PROVISIONED, true, true);
1547
1548 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1549 if (accountData == nullptr) {
1550 GTEST_LOG_(INFO) << "accountData is nullptr";
1551 return;
1552 }
1553
1554 std::vector<std::string> name;
1555 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
1556 EXPECT_EQ(accountData->GetConfig()->GetShortkeyMultiTarget().size(), 0);
1557
1558 size_t size = accountData->GetConfig()->GetEnabledAccessibilityServices().size();
1559 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1560 EXPECT_EQ(accountData->GetConfig()->GetEnabledAccessibilityServices().size(), size);
1561 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_004 end";
1562 }
1563
1564 /**OnShortKeyProcess
1565 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_005
1566 * @tc.name: OnShortKeyProcess
1567 * @tc.desc: Test function OnShortKeyProcess
1568 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_005, TestSize.Level1)1569 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_005, TestSize.Level1)
1570 {
1571 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_005 start";
1572 std::shared_ptr<AccessibilitySettingProvider> service =
1573 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1574 if (service == nullptr) {
1575 GTEST_LOG_(INFO) << "service is nullptr";
1576 return;
1577 }
1578 service->PutBoolValue(DEVICE_PROVISIONED, true, true);
1579
1580 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1581 if (accountData == nullptr) {
1582 GTEST_LOG_(INFO) << "accountData is nullptr";
1583 return;
1584 }
1585
1586 std::vector<std::string> name;
1587 name.push_back("test1");
1588 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
1589 EXPECT_EQ(accountData->GetConfig()->GetShortkeyMultiTarget().size(), 1);
1590
1591 size_t size = accountData->GetConfig()->GetEnabledAccessibilityServices().size();
1592 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1593 EXPECT_EQ(accountData->GetConfig()->GetEnabledAccessibilityServices().size(), size);
1594 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_005 end";
1595 }
1596
1597 /**OnShortKeyProcess
1598 * @tc.number: AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_006
1599 * @tc.name: OnShortKeyProcess
1600 * @tc.desc: Test function OnShortKeyProcess
1601 */
HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_006, TestSize.Level1)1602 HWTEST_F(AccessibilitySettingObserverTest, OnShortKeyProcess_006, TestSize.Level1)
1603 {
1604 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_006 start";
1605 std::shared_ptr<AccessibilitySettingProvider> service =
1606 AccessibilitySettingProvider::GetInstance(POWER_MANAGER_SERVICE_ID);
1607 if (service == nullptr) {
1608 GTEST_LOG_(INFO) << "service is nullptr";
1609 return;
1610 }
1611 service->PutBoolValue(DEVICE_PROVISIONED, true, true);
1612
1613 auto accountData = Singleton<AccessibleAbilityManagerService>::GetInstance().GetCurrentAccountData();
1614 if (accountData == nullptr) {
1615 GTEST_LOG_(INFO) << "accountData is nullptr";
1616 return;
1617 }
1618
1619 std::vector<std::string> name;
1620 name.push_back("test1");
1621 name.push_back("test2");
1622 Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyMultiTarget(name);
1623 EXPECT_EQ(accountData->GetConfig()->GetShortkeyMultiTarget().size(), 2);
1624
1625 size_t size = accountData->GetConfig()->GetEnabledAccessibilityServices().size();
1626 Singleton<AccessibleAbilityManagerService>::GetInstance().OnShortKeyProcess();
1627 EXPECT_EQ(accountData->GetConfig()->GetEnabledAccessibilityServices().size(), size);
1628 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_OnShortKeyProcess_006 end";
1629 }
1630
1631 /**
1632 * @tc.number: AccessibilitySettingObserverTest_SetMouseAutoClick_002
1633 * @tc.name: SetMouseAutoClick
1634 * @tc.desc: Test function SetMouseAutoClick GetMouseAutoClick
1635 * @tc.require: issueI5NTXC
1636 */
HWTEST_F(AccessibilitySettingObserverTest, SetMouseAutoClick_002, TestSize.Level1)1637 HWTEST_F(AccessibilitySettingObserverTest, SetMouseAutoClick_002, TestSize.Level1)
1638 {
1639 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseAutoClick_002 start";
1640 sleep(SLEEP_TIME_1);
1641 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1642 int32_t value = MOUSE_AUTO_CLICK_VALUE;
1643 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetMouseAutoClick(value));
1644 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetMouseAutoClick(value));
1645 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetMouseAutoClick_002 end";
1646 }
1647
1648 /**
1649 * @tc.number: AccessibilitySettingObserverTest_SetShortkeyTarget_002
1650 * @tc.name: SetShortkeyTarget
1651 * @tc.desc: Test function SetShortkeyTarget GetShortkeyTarget
1652 * @tc.require: issueI5NTXH
1653 */
HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyTarget_002, TestSize.Level1)1654 HWTEST_F(AccessibilitySettingObserverTest, SetShortkeyTarget_002, TestSize.Level1)
1655 {
1656 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortkeyTarget_002 start";
1657 sleep(SLEEP_TIME_1);
1658 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1659 std::string name = "test";
1660 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetShortkeyTarget(name));
1661 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetShortkeyTarget(name));
1662 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetShortkeyTarget_002 end";
1663 }
1664
1665 /**
1666 * @tc.number: AccessibilitySettingObserverTest_SetHighContrastTextState_002
1667 * @tc.name: SetHighContrastTextState
1668 * @tc.desc: Test function SetHighContrastTextState GetHighContrastTextState
1669 * @tc.require: issueI5NTX9
1670 */
HWTEST_F(AccessibilitySettingObserverTest, SetHighContrastTextState_002, TestSize.Level1)1671 HWTEST_F(AccessibilitySettingObserverTest, SetHighContrastTextState_002, TestSize.Level1)
1672 {
1673 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetHighContrastTextState_002 start";
1674 sleep(SLEEP_TIME_1);
1675 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1676 bool state = true;
1677 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetHighContrastTextState(state));
1678 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetHighContrastTextState(state));
1679 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetHighContrastTextState_002 end";
1680 }
1681
1682 /**
1683 * @tc.number: AccessibilitySettingObserverTest_SetDaltonizationState_002
1684 * @tc.name: SetDaltonizationState
1685 * @tc.desc: Test function SetDaltonizationState GetDaltonizationState
1686 */
HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationState_002, TestSize.Level1)1687 HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationState_002, TestSize.Level1)
1688 {
1689 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationState_002 start";
1690 sleep(SLEEP_TIME_1);
1691 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1692 bool state = true;
1693 EXPECT_NE(RET_OK,
1694 Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationState(state));
1695 EXPECT_NE(RET_OK,
1696 Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationState(state));
1697 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationState_002 end";
1698 }
1699
1700 /**
1701 * @tc.number: AccessibilitySettingObserverTest_SetInvertColorState_002
1702 * @tc.name: SetInvertColorState
1703 * @tc.desc: Test function SetInvertColorState GetInvertColorState
1704 * @tc.require: issueI5NTX7
1705 */
HWTEST_F(AccessibilitySettingObserverTest, SetInvertColorState_002, TestSize.Level1)1706 HWTEST_F(AccessibilitySettingObserverTest, SetInvertColorState_002, TestSize.Level1)
1707 {
1708 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetInvertColorState_002 start";
1709 sleep(SLEEP_TIME_1);
1710 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1711 bool state = true;
1712 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetInvertColorState(state));
1713 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetInvertColorState(state));
1714 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetInvertColorState_002 end";
1715 }
1716
1717 /**
1718 * @tc.number: AccessibilitySettingObserverTest_SetAnimationOffState_002
1719 * @tc.name: SetAnimationOffState
1720 * @tc.desc: Test function SetAnimationOffState GetAnimationOffState
1721 * @tc.require: issueI5NTXG
1722 */
HWTEST_F(AccessibilitySettingObserverTest, SetAnimationOffState_002, TestSize.Level1)1723 HWTEST_F(AccessibilitySettingObserverTest, SetAnimationOffState_002, TestSize.Level1)
1724 {
1725 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAnimationOffState_002 start";
1726 sleep(SLEEP_TIME_1);
1727 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1728 bool state = true;
1729 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAnimationOffState(state));
1730 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAnimationOffState(state));
1731 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAnimationOffState_002 end";
1732 }
1733
1734 /**
1735 * @tc.number: AccessibilitySettingObserverTest_SetAudioMonoState_002
1736 * @tc.name: SetAudioMonoState
1737 * @tc.desc: Test function SetAudioMonoState GetAudioMonoState
1738 */
HWTEST_F(AccessibilitySettingObserverTest, SetAudioMonoState_002, TestSize.Level1)1739 HWTEST_F(AccessibilitySettingObserverTest, SetAudioMonoState_002, TestSize.Level1)
1740 {
1741 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioMonoState_002 start";
1742 sleep(SLEEP_TIME_1);
1743 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1744 bool state = true;
1745 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioMonoState(state));
1746 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioMonoState(state));
1747 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioMonoState_002 end";
1748 }
1749
1750 /**
1751 * @tc.number: AccessibilitySettingObserverTest_SetDaltonizationColorFilter_002
1752 * @tc.name: SetDaltonizationColorFilter
1753 * @tc.desc: Test function SetDaltonizationColorFilter GetDaltonizationColorFilter
1754 * @tc.require: issueI5NTX8
1755 */
HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationColorFilter_002, TestSize.Level1)1756 HWTEST_F(AccessibilitySettingObserverTest, SetDaltonizationColorFilter_002, TestSize.Level1)
1757 {
1758 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationColorFilter_002 start";
1759 sleep(SLEEP_TIME_1);
1760 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1761 uint32_t filter = 1;
1762 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetDaltonizationColorFilter(filter));
1763 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetDaltonizationColorFilter(filter));
1764 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetDaltonizationColorFilter_002 end";
1765 }
1766
1767 /**
1768 * @tc.number: AccessibilitySettingObserverTest_SetContentTimeout_002
1769 * @tc.name: SetContentTimeout
1770 * @tc.desc: Test function SetContentTimeout GetContentTimeout
1771 * @tc.require: issueI5NTXF
1772 */
HWTEST_F(AccessibilitySettingObserverTest, SetContentTimeout_002, TestSize.Level1)1773 HWTEST_F(AccessibilitySettingObserverTest, SetContentTimeout_002, TestSize.Level1)
1774 {
1775 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetContentTimeout_002 start";
1776 sleep(SLEEP_TIME_1);
1777 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1778 uint32_t time = CONTENT_TIMEOUT_VALUE;
1779 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetContentTimeout(time));
1780 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetContentTimeout(time));
1781 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetContentTimeout_002 end";
1782 }
1783
1784 /**
1785 * @tc.number: AccessibilitySettingObserverTest_SetBrightnessDiscount_002
1786 * @tc.name: SetBrightnessDiscount
1787 * @tc.desc: Test function SetBrightnessDiscount GetBrightnessDiscount
1788 * @tc.require: issueI5NTXE
1789 */
HWTEST_F(AccessibilitySettingObserverTest, SetBrightnessDiscount_002, TestSize.Level1)1790 HWTEST_F(AccessibilitySettingObserverTest, SetBrightnessDiscount_002, TestSize.Level1)
1791 {
1792 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetBrightnessDiscount_002 start";
1793 sleep(SLEEP_TIME_1);
1794 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1795 float value = BRIGHTNESS_DISCOUNT_VALUE;
1796 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetBrightnessDiscount(value));
1797 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetBrightnessDiscount(value));
1798 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetBrightnessDiscount_002 end";
1799 }
1800
1801 /**
1802 * @tc.number: AccessibilitySettingObserverTest_SetAudioBalance_002
1803 * @tc.name: SetAudioBalance
1804 * @tc.desc: Test function SetAudioBalance GetAudioBalance
1805 */
HWTEST_F(AccessibilitySettingObserverTest, SetAudioBalance_002, TestSize.Level1)1806 HWTEST_F(AccessibilitySettingObserverTest, SetAudioBalance_002, TestSize.Level1)
1807 {
1808 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioBalance_002 start";
1809 sleep(SLEEP_TIME_1);
1810 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1811 float value = AUDIO_BALANCE_VALUE;
1812 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().SetAudioBalance(value));
1813 EXPECT_NE(RET_OK, Singleton<AccessibleAbilityManagerService>::GetInstance().GetAudioBalance(value));
1814 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_SetAudioBalance_002 end";
1815 }
1816
1817 /**
1818 * @tc.number: AccessibilitySettingObserverTest_GetAllConfigs_002
1819 * @tc.name: GetAllConfigs
1820 * @tc.desc: Test function GetAllConfigs
1821 */
HWTEST_F(AccessibilitySettingObserverTest, GetAllConfigs_002, TestSize.Level1)1822 HWTEST_F(AccessibilitySettingObserverTest, GetAllConfigs_002, TestSize.Level1)
1823 {
1824 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAllConfigs_002 start";
1825 sleep(SLEEP_TIME_1);
1826 Singleton<AccessibleAbilityManagerService>::GetInstance().SwitchedUser(-1);
1827 std::shared_ptr<AccessibilityConfigData> data = std::make_shared<AccessibilityConfigData>();
1828 Singleton<AccessibleAbilityManagerService>::GetInstance().GetAllConfigs(*data);
1829 EXPECT_NE(data.get(), nullptr);
1830 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_GetAllConfigs_002 end";
1831 }
1832
1833 /**
1834 * @tc.number: AccessibilitySettingObserverTest_OnRemoveSystemAbility_001
1835 * @tc.name: OnRemoveSystemAbility
1836 * @tc.desc: Test function OnRemoveSystemAbility
1837 */
HWTEST_F(AccessibilitySettingObserverTest, OnRemoveSystemAbility_001, TestSize.Level1)1838 HWTEST_F(AccessibilitySettingObserverTest, OnRemoveSystemAbility_001, TestSize.Level1)
1839 {
1840 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_OnRemoveSystemAbility_001 start";
1841 int32_t systemAbilityId = 1;
1842 std::string deviceId = "test";
1843 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1844 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
1845 EXPECT_TRUE(ins.IsServiceReady());
1846 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_OnRemoveSystemAbility_001 end";
1847 }
1848
1849 /**
1850 * @tc.number: AccessibilitySettingObserverTest_OnRemoveSystemAbility_002
1851 * @tc.name: OnRemoveSystemAbility
1852 * @tc.desc: Test function OnRemoveSystemAbility
1853 */
HWTEST_F(AccessibilitySettingObserverTest, OnRemoveSystemAbility_002, TestSize.Level1)1854 HWTEST_F(AccessibilitySettingObserverTest, OnRemoveSystemAbility_002, TestSize.Level1)
1855 {
1856 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_OnRemoveSystemAbility_002 start";
1857 auto &ins = Singleton<AccessibleAbilityManagerService>::GetInstance();
1858 EXPECT_TRUE(ins.IsServiceReady());
1859 int32_t systemAbilityId = SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN;
1860 std::string deviceId = "test";
1861 ins.OnRemoveSystemAbility(systemAbilityId, deviceId);
1862 AccessibilityCommonHelper::GetInstance().WaitForLoop(std::bind([]() -> bool {
1863 if (Singleton<AccessibleAbilityManagerService>::GetInstance().IsServiceReady() == false) {
1864 return true;
1865 } else {
1866 return false;
1867 }
1868 }), SLEEP_TIME_1);
1869 EXPECT_FALSE(ins.IsServiceReady());
1870 GTEST_LOG_(INFO) << "AccessibilitySettingObserverTest_OnRemoveSystemAbility_002 end";
1871 }
1872
1873 /**
1874 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateConfigState_001
1875 * @tc.name: UpdateConfigState
1876 * @tc.desc: Test function UpdateConfigState
1877 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateConfigState_001, TestSize.Level1)1878 HWTEST_F(AccessibilitySettingObserverTest, UpdateConfigState_001, TestSize.Level1)
1879 {
1880 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateConfigState_001 start";
1881 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1882 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1883
1884 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1885 EXPECT_EQ(ret, 0);
1886 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateConfigState();
1887 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1888 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateConfigState_001 end";
1889 }
1890
1891 /**
1892 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateAudioBalance_001
1893 * @tc.name: UpdateAudioBalance
1894 * @tc.desc: Test function UpdateAudioBalance
1895 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateAudioBalance_001, TestSize.Level1)1896 HWTEST_F(AccessibilitySettingObserverTest, UpdateAudioBalance_001, TestSize.Level1)
1897 {
1898 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateAudioBalance_001 start";
1899 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1900 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1901
1902 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1903 EXPECT_EQ(ret, 0);
1904 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateAudioBalance();
1905 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1906 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateAudioBalance_001 end";
1907 }
1908
1909 /**
1910 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateBrightnessDiscount_001
1911 * @tc.name: UpdateBrightnessDiscount
1912 * @tc.desc: Test function UpdateBrightnessDiscount
1913 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateBrightnessDiscount_001, TestSize.Level1)1914 HWTEST_F(AccessibilitySettingObserverTest, UpdateBrightnessDiscount_001, TestSize.Level1)
1915 {
1916 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateBrightnessDiscount_001 start";
1917 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1918 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1919
1920 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1921 EXPECT_EQ(ret, 0);
1922 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateBrightnessDiscount();
1923 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1924 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateBrightnessDiscount_001 end";
1925 }
1926
1927 /**
1928 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateContentTimeout_001
1929 * @tc.name: UpdateContentTimeout
1930 * @tc.desc: Test function UpdateContentTimeout
1931 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateContentTimeout_001, TestSize.Level1)1932 HWTEST_F(AccessibilitySettingObserverTest, UpdateContentTimeout_001, TestSize.Level1)
1933 {
1934 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateContentTimeout_001 start";
1935 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1936 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1937
1938 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1939 EXPECT_EQ(ret, 0);
1940 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateContentTimeout();
1941 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1942 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateContentTimeout_001 end";
1943 }
1944
1945 /**
1946 * @tc.number: AccessibilitySettingObserver_UnitTest_UpdateDaltonizationColorFilter_001
1947 * @tc.name: UpdateDaltonizationColorFilter
1948 * @tc.desc: Test function UpdateDaltonizationColorFilter
1949 */
HWTEST_F(AccessibilitySettingObserverTest, UpdateDaltonizationColorFilter_001, TestSize.Level1)1950 HWTEST_F(AccessibilitySettingObserverTest, UpdateDaltonizationColorFilter_001, TestSize.Level1)
1951 {
1952 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateDaltonizationColorFilter_001 start";
1953 sptr<MockAccessibleAbilityManagerConfigObserverStub> stub = new MockAccessibleAbilityManagerConfigObserverStub();
1954 sptr<IAccessibleAbilityManagerConfigObserver> state = new MockAccessibleAbilityManagerConfigObserverProxy(stub);
1955
1956 uint32_t ret = Singleton<AccessibleAbilityManagerService>::GetInstance().RegisterConfigObserver(state);
1957 EXPECT_EQ(ret, 0);
1958 Singleton<AccessibleAbilityManagerService>::GetInstance().UpdateDaltonizationColorFilter();
1959 EXPECT_NE(stub_.GetRefPtr(), nullptr);
1960 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_UnitTest_UpdateDaltonizationColorFilter_001 end";
1961 }
1962
1963
1964 /**
1965 * @tc.number: AccessibilitySettingObserver_Unittest_SetAvailableFunctions002
1966 * @tc.name: SetAvailableFunctions
1967 * @tc.desc: Check the set available Functions.
1968 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions002, TestSize.Level1)1969 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions002,
1970 TestSize.Level1)
1971 {
1972 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions002 start";
1973
1974 uint32_t availableFunctions2 = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
1975 inputInterceptor_->SetAvailableFunctions(availableFunctions2);
1976
1977 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions002 end";
1978 }
1979
1980 /**
1981 * @tc.number: AccessibilitySettingObserver_Unittest_SetAvailableFunctions003
1982 * @tc.name: SetAvailableFunctions
1983 * @tc.desc: Check the set available Functions.
1984 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions003, TestSize.Level1)1985 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions003,
1986 TestSize.Level1)
1987 {
1988 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions003 start";
1989
1990 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_TOUCH_EXPLORATION;
1991
1992 inputInterceptor_->SetAvailableFunctions(availableFunctions);
1993
1994 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions003 end";
1995 }
1996
1997 /**
1998 * @tc.number: AccessibilitySettingObserver_Unittest_SetAvailableFunctions004
1999 * @tc.name: SetAvailableFunctions
2000 * @tc.desc: Check the set available Functions.
2001 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions004, TestSize.Level1)2002 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions004,
2003 TestSize.Level1)
2004 {
2005 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions004 start";
2006 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION;
2007 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2008
2009 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions004 end";
2010 }
2011
2012 /**
2013 * @tc.number: AccessibilitySettingObserver_Unittest_SetAvailableFunctions005
2014 * @tc.name: SetAvailableFunctions
2015 * @tc.desc: Check the set available Functions.
2016 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions005, TestSize.Level1)2017 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions005,
2018 TestSize.Level1)
2019 {
2020 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions005 start";
2021 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_SCREEN_MAGNIFICATION |
2022 AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK |
2023 AccessibilityInputInterceptor::FEATURE_MOUSE_KEY;
2024 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2025
2026 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions005 end";
2027 }
2028
2029 /**
2030 * @tc.number: AccessibilitySettingObserver_Unittest_SetAvailableFunctions006
2031 * @tc.name: SetAvailableFunctions
2032 * @tc.desc: Check the set available Functions.
2033 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions006, TestSize.Level1)2034 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_SetAvailableFunctions006,
2035 TestSize.Level1)
2036 {
2037 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions006 start";
2038 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_MOUSE_AUTOCLICK;
2039 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2040 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_SetAvailableFunctions006 end";
2041 }
2042
2043 /**
2044 * @tc.number: AccessibilitySettingObserver_Unittest_OnTouchEvent001
2045 * @tc.name: OnTouchEvent
2046 * @tc.desc: Check the on touch event.
2047 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent001, TestSize.Level1)2048 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent001, TestSize.Level1)
2049 {
2050 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent001 start";
2051
2052 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
2053 inputInterceptor_->OnPointerEvent(*event);
2054
2055 EXPECT_NE(event.get(), nullptr);
2056 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent001 end";
2057 }
2058
2059 /**
2060 * @tc.number: AccessibilitySettingObserver_Unittest_OnTouchEvent002
2061 * @tc.name: InterceptPointerEventCallBack
2062 * @tc.desc: Check the on touch event.
2063 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent002, TestSize.Level1)2064 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent002, TestSize.Level1)
2065 {
2066 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent002 start";
2067 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
2068 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2069
2070 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
2071 MMI::PointerEvent::PointerItem item = {};
2072
2073 item.SetPointerId(1);
2074 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
2075 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
2076 event->AddPointerItem(item);
2077
2078 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
2079 if (inputEventConsumer != nullptr) {
2080 inputEventConsumer->OnInputEvent(event);
2081 }
2082 /* wait ProcessTouchEvent */
2083 sleep(SLEEP_TIME_3);
2084 EXPECT_NE(event.get(), nullptr);
2085 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent002 end";
2086 }
2087
2088 /**
2089 * @tc.number: AccessibilitySettingObserver_Unittest_OnTouchEvent003
2090 * @tc.name: InterceptPointerEventCallBack
2091 * @tc.desc: Check the on touch event.
2092 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent003, TestSize.Level1)2093 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnTouchEvent003, TestSize.Level1)
2094 {
2095 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent003 start";
2096 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
2097 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2098
2099 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
2100 MMI::PointerEvent::PointerItem item = {};
2101
2102 item.SetPointerId(1);
2103 item.SetDisplayX(1);
2104 item.SetDisplayY(1);
2105 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
2106 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
2107 event->AddPointerItem(item);
2108
2109 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
2110 if (inputEventConsumer != nullptr) {
2111 inputEventConsumer->OnInputEvent(event);
2112 }
2113 /* wait ProcessTouchEvent */
2114 sleep(SLEEP_TIME_3);
2115
2116 EXPECT_NE(event.get(), nullptr);
2117 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnTouchEvent003 end";
2118 }
2119
2120 /**
2121 * @tc.number: AccessibilitySettingObserver_Unittest_OnMouseEvent1
2122 * @tc.name: OnMouseEvent
2123 * @tc.desc: Check the on mouse event.
2124 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnMouseEvent1, TestSize.Level1)2125 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnMouseEvent1, TestSize.Level1)
2126 {
2127 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnMouseEvent1 start";
2128
2129 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
2130 MMI::PointerEvent::PointerItem item = {};
2131
2132 item.SetPointerId(1);
2133 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
2134 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
2135 event->AddPointerItem(item);
2136
2137 EXPECT_NE(event.get(), nullptr);
2138 inputInterceptor_->OnPointerEvent(*event);
2139 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnMouseEvent1 end";
2140 }
2141
2142 /**
2143 * @tc.number: AccessibilitySettingObserver_Unittest_OnMouseEvent002
2144 * @tc.name: InterceptPointerEventCallBack
2145 * @tc.desc: Check the on mouse event.
2146 */
HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnMouseEvent002, TestSize.Level1)2147 HWTEST_F(AccessibilitySettingObserver, AccessibilitySettingObserver_Unittest_OnMouseEvent002, TestSize.Level1)
2148 {
2149 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnMouseEvent002 start";
2150 uint32_t availableFunctions = AccessibilityInputInterceptor::FEATURE_INJECT_TOUCH_EVENTS;
2151 inputInterceptor_->SetAvailableFunctions(availableFunctions);
2152
2153 std::shared_ptr<MMI::PointerEvent> event = MMI::PointerEvent::Create();
2154 MMI::PointerEvent::PointerItem item = {};
2155
2156 item.SetPointerId(1);
2157 event->SetSourceType(MMI::PointerEvent::SOURCE_TYPE_MOUSE);
2158 event->SetPointerAction(MMI::PointerEvent::POINTER_ACTION_DOWN);
2159 event->AddPointerItem(item);
2160
2161 auto inputEventConsumer = MMI::MockInputManager::GetInputEventConsumer();
2162 if (inputEventConsumer != nullptr) {
2163 inputEventConsumer->OnInputEvent(event);
2164 }
2165 /* wait ProcessMouseEvent */
2166 sleep(SLEEP_TIME_3);
2167 EXPECT_NE(event.get(), nullptr);
2168 GTEST_LOG_(INFO) << "AccessibilitySettingObserver_Unittest_OnMouseEvent002 end";
2169 }
2170 } // namespace Accessibility
2171 } // namespace OHOS