1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #define private public
19 #define protected public
20 #include "accessibility_ability_command.h"
21 #undef private
22 #undef protected
23 #include "accessibility_ability_command_common_test.h"
24
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::AAFwk;
28
29 extern void MockSetBrightnessDiscount(bool mockRet);
30
31 namespace OHOS {
32 namespace AAFwk {
33 class AccessibilityAbilityShellCommandFirstTest : public ::testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39
40 std::string cmdHelp_ = "help";
41 std::string cmdEnable_ = "enable";
42 std::string cmdDisable_ = "disable";
43 std::string cmdsetShortKeyState_ = "setShortKeyState";
44 std::string cmdsetMouseKeyState_ = "setMouseKeyState";
45 std::string cmdsetCaptionState_ = "setCaptionState";
46 std::string cmdsSetMouseAutoClick_ = "setMouseAutoClick";
47 std::string cmdsetShortKeyTarget_ = "setShortKeyTarget";
48 std::string cmdsetHighContrastTextState_ = "setHighContrastTextState";
49 std::string cmdsetInvertColorState_ = "setInvertColorState";
50 std::string cmdsetDaltonizationColorFilter_ = "setDaltonizationColorFilter";
51 std::string cmdsetContentTimeout_ = "setContentTimeout";
52 std::string cmdsetAnimationOffState_ = "setAnimationOffState";
53 std::string cmdsetBrightnessDiscount_ = "setBrightnessDiscount";
54 std::string cmdsetAudioMonoState_ = "setAudioMonoState";
55 std::string cmdsetAudioBalance_ = "setAudioBalance";
56 std::string cmdSetScreenMagnificationState_ = "setScreenMagnificationState";
57 };
58
SetUpTestCase()59 void AccessibilityAbilityShellCommandFirstTest::SetUpTestCase()
60 {}
61
TearDownTestCase()62 void AccessibilityAbilityShellCommandFirstTest::TearDownTestCase()
63 {}
64
SetUp()65 void AccessibilityAbilityShellCommandFirstTest::SetUp()
66 {
67 // reset optind to 0
68 optind = 0;
69 }
70
TearDown()71 void AccessibilityAbilityShellCommandFirstTest::TearDown()
72 {}
73
74 /**
75 * @tc.number: AccessibilityAbilityShellCommand_init_0100
76 * @tc.name: init
77 * @tc.desc: Test whether init is called normally.
78 */
79 HWTEST_F(AccessibilityAbilityShellCommandFirstTest, AccessibilityAbilityShellCommand_init_0100, TestSize.Level1)
80 {
81 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_init_0100 start";
82 char* argv[] = {
83 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
84 };
85 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
86 AccessibilityAbilityShellCommand cmd(argc, argv);
87 EXPECT_EQ(cmd.init(), OHOS::ERR_OK);
88 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_init_0100 end";
89 }
90
91 /**
92 * @tc.number: AccessibilityAbilityShellCommand_CreateMessageMap_0100
93 * @tc.name: CreateMessageMap
94 * @tc.desc: Test whether CreateMessageMap is called normally.
95 */
96 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
97 AccessibilityAbilityShellCommand_CreateMessageMap_0100, TestSize.Level1)
98 {
99 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CreateMessageMap_0100 start";
100 char* argv[] = {
101 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
102 };
103 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
104 AccessibilityAbilityShellCommand cmd(argc, argv);
105 EXPECT_EQ(cmd.CreateMessageMap(), OHOS::ERR_OK);
106 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CreateMessageMap_0100 end";
107 }
108
109 /**
110 * @tc.number: AccessibilityAbilityShellCommand_RunAsHelpCommand_0100
111 * @tc.name: RunAsHelpCommand
112 * @tc.desc: Test whether RunAsHelpCommand is called normally.
113 */
114 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
115 AccessibilityAbilityShellCommand_RunAsHelpCommand_0100, TestSize.Level1)
116 {
117 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsHelpCommand_0100 start";
118 char* argv[] = {
119 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
120 (char*)cmdHelp_.c_str(),
121 };
122 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
123 AccessibilityAbilityShellCommand cmd(argc, argv);
124 EXPECT_EQ(cmd.RunAsHelpCommand(), OHOS::ERR_OK);
125 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_HELP_MSG);
126 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsHelpCommand_0100 end";
127 }
128
129 /**
130 * @tc.number: AccessibilityAbilityShellCommand_GetEnabledAbilities_0100
131 * @tc.name: GetEnabledAbilities
132 * @tc.desc: Test whether GetEnabledAbilities is called normally.
133 */
134 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
135 AccessibilityAbilityShellCommand_GetEnabledAbilities_0100, TestSize.Level1)
136 {
137 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetEnabledAbilities_0100 start";
138 AccessibilityCommandArgument argument;
139 std::vector<std::string> enabledAbilities;
140 char* argv[] = {
141 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
142 };
143 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
144 AccessibilityAbilityShellCommand cmd(argc, argv);
145 enabledAbilities = cmd.GetEnabledAbilities();
146 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetEnabledAbilities_0100 end";
147 }
148
149 /**
150 * @tc.number: AccessibilityAbilityShellCommand_GetInstalledAbilities_0100
151 * @tc.name: GetInstalledAbilities
152 * @tc.desc: Test whether GetInstalledAbilities is called normally.
153 */
154 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
155 AccessibilityAbilityShellCommand_GetInstalledAbilities_0100, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetInstalledAbilities_0100 start";
158 AccessibilityCommandArgument argument;
159 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
160 char* argv[] = {
161 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
162 };
163 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
164 AccessibilityAbilityShellCommand cmd(argc, argv);
165 installedAbilities = cmd.GetInstalledAbilities();
166 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetInstalledAbilities_0100 end";
167 }
168
169 /**
170 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0100
171 * @tc.name: CheckAbilityArgument
172 * @tc.desc: Test whether CheckAbilityArgument is called normally.
173 */
174 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
175 AccessibilityAbilityShellCommand_CheckAbilityArgument_0100, TestSize.Level1)
176 {
177 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0100 start";
178 AccessibilityCommandArgument argument;
179 argument.abilityArgumentNum = 0;
180 std::string resultMessage;
181 char* argv[] = {
182 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
183 };
184 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
185 AccessibilityAbilityShellCommand cmd(argc, argv);
186 ErrCode result = cmd.CheckAbilityArgument(argument, resultMessage);
187 EXPECT_EQ(result, false);
188 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
189 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0100 end";
190 }
191
192 /**
193 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0200
194 * @tc.name: CheckAbilityArgument
195 * @tc.desc: Test whether CheckAbilityArgument is called normally.
196 */
197 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
198 AccessibilityAbilityShellCommand_CheckAbilityArgument_0200, TestSize.Level1)
199 {
200 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0200 start";
201 AccessibilityCommandArgument argument;
202 argument.abilityArgumentNum = 2;
203 std::string resultMessage;
204 char* argv[] = {
205 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
206 };
207 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
208 AccessibilityAbilityShellCommand cmd(argc, argv);
209 ErrCode result = cmd.CheckAbilityArgument(argument, resultMessage);
210 EXPECT_EQ(result, false);
211 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
212 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0200 end";
213 }
214
215 /**
216 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0300
217 * @tc.name: CheckAbilityArgument
218 * @tc.desc: Test whether CheckAbilityArgument is called normally.
219 */
220 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
221 AccessibilityAbilityShellCommand_CheckAbilityArgument_0300, TestSize.Level1)
222 {
223 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0300 start";
224 AccessibilityCommandArgument argument;
225 argument.abilityArgumentNum = 1;
226 argument.abilityName[0] = '-';
227 std::string resultMessage;
228 char* argv[] = {
229 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
230 };
231 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
232 AccessibilityAbilityShellCommand cmd(argc, argv);
233 ErrCode result = cmd.CheckAbilityArgument(argument, resultMessage);
234 EXPECT_EQ(result, false);
235 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
236 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0300 end";
237 }
238
239 /**
240 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0400
241 * @tc.name: CheckAbilityArgument
242 * @tc.desc: Test whether CheckAbilityArgument is called normally.
243 */
244 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
245 AccessibilityAbilityShellCommand_CheckAbilityArgument_0400, TestSize.Level1)
246 {
247 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0400 start";
248 AccessibilityCommandArgument argument;
249 argument.abilityArgumentNum = 1;
250 argument.abilityName = "ability";
251 std::string resultMessage;
252 char* argv[] = {
253 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
254 };
255 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
256 AccessibilityAbilityShellCommand cmd(argc, argv);
257 ErrCode result = cmd.CheckAbilityArgument(argument, resultMessage);
258 EXPECT_EQ(result, true);
259 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0400 end";
260 }
261
262 /**
263 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0100
264 * @tc.name: CheckBundleArgument
265 * @tc.desc: Test whether CheckBundleArgument is called normally.
266 */
267 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
268 AccessibilityAbilityShellCommand_CheckBundleArgument_0100, TestSize.Level1)
269 {
270 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0100 start";
271 AccessibilityCommandArgument argument;
272 argument.bundleArgumentNum = 0;
273 std::string resultMessage;
274 char* argv[] = {
275 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
276 };
277 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
278 AccessibilityAbilityShellCommand cmd(argc, argv);
279 ErrCode result = cmd.CheckBundleArgument(argument, resultMessage);
280 EXPECT_EQ(result, false);
281 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
282 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0100 end";
283 }
284
285 /**
286 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0200
287 * @tc.name: CheckBundleArgument
288 * @tc.desc: Test whether CheckAbilityArgument is called normally.
289 */
290 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
291 AccessibilityAbilityShellCommand_CheckBundleArgument_0200, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0200 start";
294 AccessibilityCommandArgument argument;
295 argument.bundleArgumentNum = 2;
296 std::string resultMessage;
297 char* argv[] = {
298 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
299 };
300 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
301 AccessibilityAbilityShellCommand cmd(argc, argv);
302 ErrCode result = cmd.CheckBundleArgument(argument, resultMessage);
303 EXPECT_EQ(result, false);
304 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
305 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0200 end";
306 }
307
308 /**
309 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0300
310 * @tc.name: CheckBundleArgument
311 * @tc.desc: Test whether CheckBundleArgument is called normally.
312 */
313 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
314 AccessibilityAbilityShellCommand_CheckBundleArgument_0300, TestSize.Level1)
315 {
316 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0300 start";
317 AccessibilityCommandArgument argument;
318 argument.bundleArgumentNum = 1;
319 argument.bundleName[0] = '-';
320 std::string resultMessage;
321 char* argv[] = {
322 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
323 };
324 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
325 AccessibilityAbilityShellCommand cmd(argc, argv);
326 ErrCode result = cmd.CheckBundleArgument(argument, resultMessage);
327 EXPECT_EQ(result, false);
328 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
329 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0300 end";
330 }
331
332 /**
333 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0400
334 * @tc.name: CheckBundleArgument
335 * @tc.desc: Test whether CheckBundleArgument is called normally.
336 */
337 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
338 AccessibilityAbilityShellCommand_CheckBundleArgument_0400, TestSize.Level1)
339 {
340 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0400 start";
341 AccessibilityCommandArgument argument;
342 argument.bundleArgumentNum = 1;
343 argument.bundleName = "bundle";
344 std::string resultMessage;
345 char* argv[] = {
346 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
347 };
348 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
349 AccessibilityAbilityShellCommand cmd(argc, argv);
350 ErrCode result = cmd.CheckBundleArgument(argument, resultMessage);
351 EXPECT_EQ(result, true);
352 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0400 end";
353 }
354
355 /**
356 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100
357 * @tc.name: CheckCapabilitiesArgument
358 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
359 */
360 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
361 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100, TestSize.Level1)
362 {
363 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100 start";
364 AccessibilityCommandArgument argument;
365 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
366 argument.capabilityNamesArgumentNum = 0;
367 std::string resultMessage;
368 char* argv[] = {
369 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
370 };
371 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
372 AccessibilityAbilityShellCommand cmd(argc, argv);
373 ErrCode result = cmd.CheckCapabilitiesArgument(argument, installedAbilities, resultMessage);
374 EXPECT_EQ(result, false);
375 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
376 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100 end";
377 }
378
379 /**
380 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200
381 * @tc.name: CheckCapabilitiesArgument
382 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
383 */
384 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
385 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200, TestSize.Level1)
386 {
387 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200 start";
388 AccessibilityCommandArgument argument;
389 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
390 argument.capabilityNamesArgumentNum = 2;
391 std::string resultMessage;
392 char* argv[] = {
393 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
394 };
395 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
396 AccessibilityAbilityShellCommand cmd(argc, argv);
397 ErrCode result = cmd.CheckCapabilitiesArgument(argument, installedAbilities, resultMessage);
398 EXPECT_EQ(result, false);
399 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
400 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200 end";
401 }
402
403 /**
404 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300
405 * @tc.name: CheckCapabilitiesArgument
406 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
407 */
408 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
409 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300, TestSize.Level1)
410 {
411 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300 start";
412 AccessibilityCommandArgument argument;
413 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
414 argument.capabilityNamesArgumentNum = 1;
415 argument.capabilityNames[0] = '-';
416 std::string resultMessage;
417 char* argv[] = {
418 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
419 };
420 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
421 AccessibilityAbilityShellCommand cmd(argc, argv);
422 ErrCode result = cmd.CheckCapabilitiesArgument(argument, installedAbilities, resultMessage);
423 EXPECT_EQ(result, false);
424 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
425 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300 end";
426 }
427
428 /**
429 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400
430 * @tc.name: CheckCapabilitiesArgument
431 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
432 */
433 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
434 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400, TestSize.Level1)
435 {
436 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400 start";
437 AccessibilityCommandArgument argument;
438 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
439 argument.capabilityNamesArgumentNum = 1;
440 argument.capabilityNames = "capability";
441 std::string resultMessage;
442 char* argv[] = {
443 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
444 };
445 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
446 AccessibilityAbilityShellCommand cmd(argc, argv);
447 ErrCode result = cmd.CheckCapabilitiesArgument(argument, installedAbilities, resultMessage);
448 EXPECT_EQ(result, true);
449 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400 end";
450 }
451
452 /**
453 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100
454 * @tc.name: CheckSetCommandArgument
455 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(totalArgumentNum > 1)
456 */
457 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
458 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100, TestSize.Level1)
459 {
460 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100 start";
461 AccessibilityCommandArgument argument;
462 argument.setArgumentNum = 2;
463 argument.unknownArgumentNum = 1;
464 std::string resultMessage;
465 char* argv[] = {
466 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
467 };
468 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
469 AccessibilityAbilityShellCommand cmd(argc, argv);
470 ErrCode result = cmd.CheckSetCommandArgument(argument, resultMessage);
471 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
472 EXPECT_EQ(resultMessage, ": and exist duplicated arguments.and exist unknown arguments ");
473 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100 end";
474 }
475
476 /**
477 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200
478 * @tc.name: CheckSetCommandArgument
479 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(unknownArgumentNum > 0)
480 */
481 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
482 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200, TestSize.Level1)
483 {
484 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200 start";
485 AccessibilityCommandArgument argument;
486 argument.setArgumentNum = 0;
487 argument.unknownArgumentNum = 1;
488 std::string resultMessage;
489 char* argv[] = {
490 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
491 };
492 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
493 AccessibilityAbilityShellCommand cmd(argc, argv);
494 ErrCode result = cmd.CheckSetCommandArgument(argument, resultMessage);
495 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
496 EXPECT_EQ(resultMessage, ": unknown arguments ");
497 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200 end";
498 }
499
500 /**
501 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300
502 * @tc.name: CheckSetCommandArgument
503 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(setArgumentNum = 0)
504 */
505 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
506 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300, TestSize.Level1)
507 {
508 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300 start";
509 AccessibilityCommandArgument argument;
510 argument.setArgumentNum = 0;
511 argument.unknownArgumentNum = 0;
512 std::string resultMessage;
513 char* argv[] = {
514 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
515 };
516 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
517 AccessibilityAbilityShellCommand cmd(argc, argv);
518 ErrCode result = cmd.CheckSetCommandArgument(argument, resultMessage);
519 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
520 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
521 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300 end";
522 }
523
524 /**
525 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400
526 * @tc.name: CheckSetCommandArgument
527 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(OHOS::ERR_OK)
528 */
529 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
530 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400, TestSize.Level1)
531 {
532 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400 start";
533 AccessibilityCommandArgument argument;
534 argument.setArgumentNum = 1;
535 argument.unknownArgumentNum = 0;
536 std::string resultMessage;
537 char* argv[] = {
538 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
539 };
540 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
541 AccessibilityAbilityShellCommand cmd(argc, argv);
542 ErrCode result = cmd.CheckSetCommandArgument(argument, resultMessage);
543 EXPECT_EQ(result, OHOS::ERR_OK);
544 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400 end";
545 }
546
547 /**
548 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100
549 * @tc.name: MakeEnableCommandArgumentFromCmd
550 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(optind < 0)
551 */
552 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
553 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100, TestSize.Level1)
554 {
555 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100 start";
556 AccessibilityCommandArgument argument;
557 optind = -1;
558 char* argv[] = {
559 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
560 };
561 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
562 AccessibilityAbilityShellCommand cmd(argc, argv);
563 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
564 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
565 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100 end";
566 }
567
568 /**
569 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200
570 * @tc.name: MakeEnableCommandArgumentFromCmd
571 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option = -1)
572 */
573 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
574 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200, TestSize.Level1)
575 {
576 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200 start";
577 AccessibilityCommandArgument argument;
578 char* argv[] = {
579 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
580 (char*)cmdEnable_.c_str(),
581 (char*)" ",
582 };
583 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
584 AccessibilityAbilityShellCommand cmd(argc, argv);
585 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
586 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
587 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
588 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200 end";
589 }
590
591 /**
592 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300
593 * @tc.name: MakeEnableCommandArgumentFromCmd
594 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -a requires a value)
595 */
596 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
597 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300, TestSize.Level1)
598 {
599 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300 start";
600 AccessibilityCommandArgument argument;
601 char* argv[] = {
602 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
603 (char*)cmdEnable_.c_str(),
604 (char*)"-a",
605 (char*)" ",
606 };
607 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
608 AccessibilityAbilityShellCommand cmd(argc, argv);
609 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
610 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
611 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
612 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300 end";
613 }
614
615 /**
616 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400
617 * @tc.name: MakeEnableCommandArgumentFromCmd
618 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -b requires a value)
619 */
620 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
621 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400, TestSize.Level1)
622 {
623 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400 start";
624 AccessibilityCommandArgument argument;
625 char* argv[] = {
626 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
627 (char*)cmdEnable_.c_str(),
628 (char*)"-a",
629 (char*)"ability",
630 (char*)"-b",
631 (char*)" ",
632 };
633 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
634 AccessibilityAbilityShellCommand cmd(argc, argv);
635 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
636 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
637 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
638 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400 end";
639 }
640
641 /**
642 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500
643 * @tc.name: MakeEnableCommandArgumentFromCmd
644 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -c requires a value)
645 */
646 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
647 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500, TestSize.Level1)
648 {
649 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500 start";
650 AccessibilityCommandArgument argument;
651 char* argv[] = {
652 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
653 (char*)cmdEnable_.c_str(),
654 (char*)"-a",
655 (char*)"ability",
656 (char*)"-b",
657 (char*)"bundle",
658 (char*)"-c",
659 (char*)" ",
660 };
661 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
662 AccessibilityAbilityShellCommand cmd(argc, argv);
663 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
664 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
665 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
666 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500 end";
667 }
668
669 /**
670 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600
671 * @tc.name: MakeEnableCommandArgumentFromCmd
672 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.
673 * (CheckEnableCommandArgument = OHOS::ERR_INVALID_VALUE)
674 */
675 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
676 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600, TestSize.Level1)
677 {
678 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600 start";
679 AccessibilityCommandArgument argument;
680 char* argv[] = {
681 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
682 (char*)cmdEnable_.c_str(),
683 (char*)"-a",
684 (char*)"ability",
685 (char*)"-b",
686 (char*)"bundle",
687 (char*)"-c",
688 (char*)"capabilities",
689 (char*)"-v",
690 (char*)"value",
691 (char*)" ",
692 };
693 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
694 AccessibilityAbilityShellCommand cmd(argc, argv);
695 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
696 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
697 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT +
698 "and exist unknown arguments.-v ");
699 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600 end";
700 }
701
702 /**
703 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700
704 * @tc.name: MakeEnableCommandArgumentFromCmd
705 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.
706 * (CheckEnableCommandArgument = OHOS::ERR_INVALID_VALUE)
707 */
708 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
709 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700, TestSize.Level1)
710 {
711 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700 start";
712 AccessibilityCommandArgument argument;
713 char* argv[] = {
714 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
715 (char*)cmdEnable_.c_str(),
716 (char*)"-a",
717 (char*)"ability",
718 (char*)"-b",
719 (char*)"bundle",
720 (char*)"-c",
721 (char*)"capabilities",
722 (char*)" ",
723 };
724 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
725 AccessibilityAbilityShellCommand cmd(argc, argv);
726 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
727 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
728 EXPECT_EQ(cmd.resultReceiver_, "enable: the auxiliary application bundle/ability" +
729 ACCESSIBILITY_ABILITY_NOT_FOUND);
730 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700 end";
731 }
732
733 /**
734 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0100
735 * @tc.name: CheckParamValidity
736 * @tc.desc: Test whether CheckParamValidity is called normally.(return true)
737 */
738 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
739 AccessibilityAbilityShellCommand_CheckParamValidity_0100, TestSize.Level1)
740 {
741 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0100 start";
742 Accessibility::AccessibilityAbilityInitParams params;
743 params.name = "ability";
744 params.bundleName = "bundle";
745 Accessibility::AccessibilityAbilityInfo abilityInfo(params);
746 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
747 installedAbilities.push_back(abilityInfo);
748 AccessibilityCommandArgument argument;
749 argument.abilityArgumentNum = 1;
750 argument.abilityName = "ability";
751 argument.bundleArgumentNum = 1;
752 argument.bundleName = "bundle";
753 std::string resultMessage;
754 char* argv[] = {
755 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
756 };
757 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
758 AccessibilityAbilityShellCommand cmd(argc, argv);
759 bool result = cmd.CheckParamValidity(argument, installedAbilities, resultMessage);
760 EXPECT_EQ(result, true);
761 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0100 end";
762 }
763
764 /**
765 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0200
766 * @tc.name: CheckParamValidity
767 * @tc.desc: Test whether CheckParamValidity is called normally.(isExisted = false)
768 */
769 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
770 AccessibilityAbilityShellCommand_CheckParamValidity_0200, TestSize.Level1)
771 {
772 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0200 start";
773 Accessibility::AccessibilityAbilityInitParams params;
774 params.name = "ability";
775 params.bundleName = "bundle";
776 Accessibility::AccessibilityAbilityInfo abilityInfo(params);
777 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
778 installedAbilities.push_back(abilityInfo);
779 AccessibilityCommandArgument argument;
780 std::string resultMessage;
781 char* argv[] = {
782 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
783 };
784 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
785 AccessibilityAbilityShellCommand cmd(argc, argv);
786 bool result = cmd.CheckParamValidity(argument, installedAbilities, resultMessage);
787 EXPECT_EQ(result, false);
788 EXPECT_EQ(resultMessage, "the auxiliary application " + argument.bundleName + "/" +
789 argument.abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
790 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0200 end";
791 }
792
793 /**
794 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0300
795 * @tc.name: CheckParamValidity
796 * @tc.desc: Test whether CheckParamValidity is called normally.(invalidCapabilityNames.empty() = false)
797 */
798 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
799 AccessibilityAbilityShellCommand_CheckParamValidity_0300, TestSize.Level1)
800 {
801 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0300 start";
802 Accessibility::AccessibilityAbilityInitParams params;
803 params.name = "ability";
804 params.bundleName = "bundle";
805 params.staticCapabilities = 1;
806 Accessibility::AccessibilityAbilityInfo abilityInfo(params);
807 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
808 installedAbilities.push_back(abilityInfo);
809 AccessibilityCommandArgument argument;
810 argument.abilityArgumentNum = 1;
811 argument.abilityName = "ability";
812 argument.bundleArgumentNum = 1;
813 argument.bundleName = "bundle";
814 argument.capabilityNamesArgumentNum = 1;
815 argument.capabilityNames = "capability";
816 std::string resultMessage;
817 char* argv[] = {
818 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
819 };
820 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
821 AccessibilityAbilityShellCommand cmd(argc, argv);
822 bool result = cmd.CheckParamValidity(argument, installedAbilities, resultMessage);
823 EXPECT_EQ(result, false);
824 EXPECT_EQ(resultMessage, "the capabilities capability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
825 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0300 end";
826 }
827
828 /**
829 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100
830 * @tc.name: CheckEnableCommandArgument
831 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(totalArgumentNum > 3)
832 */
833 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
834 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100, TestSize.Level1)
835 {
836 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100 start";
837 AccessibilityCommandArgument argument;
838 argument.abilityArgumentNum = 2;
839 argument.bundleArgumentNum = 1;
840 argument.capabilityNamesArgumentNum = 1;
841 argument.unknownArgumentNum = 1;
842 std::string resultMessage;
843 char* argv[] = {
844 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
845 };
846 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
847 AccessibilityAbilityShellCommand cmd(argc, argv);
848 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
849 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
850 EXPECT_EQ(resultMessage, ": and exist duplicated argumentsand exist unknown arguments.");
851 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
852 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100 end";
853 }
854
855 /**
856 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200
857 * @tc.name: CheckEnableCommandArgument
858 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(unknownArgumentNum > 0)
859 */
860 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
861 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200, TestSize.Level1)
862 {
863 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200 start";
864 AccessibilityCommandArgument argument;
865 argument.unknownArgumentNum = 1;
866 std::string resultMessage;
867 char* argv[] = {
868 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
869 };
870 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
871 AccessibilityAbilityShellCommand cmd(argc, argv);
872 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
873 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
874 EXPECT_EQ(resultMessage, ": unknown arguments.");
875 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200 end";
876 }
877
878 /**
879 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300
880 * @tc.name: CheckEnableCommandArgument
881 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckAbilityArgument = false)
882 */
883 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
884 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300, TestSize.Level1)
885 {
886 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300 start";
887 AccessibilityCommandArgument argument;
888 argument.abilityArgumentNum = 0;
889 argument.abilityName = "ability";
890 argument.bundleArgumentNum = 1;
891 argument.bundleName = "bundle";
892 argument.capabilityNamesArgumentNum = 1;
893 argument.capabilityNames = "capabilities";
894 argument.unknownArgumentNum = 0;
895 std::string resultMessage;
896 char* argv[] = {
897 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
898 };
899 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
900 AccessibilityAbilityShellCommand cmd(argc, argv);
901 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
902 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
903 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
904 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300 end";
905 }
906
907 /**
908 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400
909 * @tc.name: CheckEnableCommandArgument
910 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckBundleArgument = false)
911 */
912 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
913 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400, TestSize.Level1)
914 {
915 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400 start";
916 AccessibilityCommandArgument argument;
917 argument.abilityArgumentNum = 1;
918 argument.abilityName = "ability";
919 argument.bundleArgumentNum = 0;
920 argument.bundleName = "bundle";
921 argument.capabilityNamesArgumentNum = 1;
922 argument.capabilityNames = "capabilities";
923 argument.unknownArgumentNum = 0;
924 std::string resultMessage;
925 char* argv[] = {
926 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
927 };
928 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
929 AccessibilityAbilityShellCommand cmd(argc, argv);
930 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
931 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
932 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
933 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400 end";
934 }
935
936 /**
937 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500
938 * @tc.name: CheckEnableCommandArgument
939 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckCapabilitiesArgument = false)
940 */
941 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
942 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500, TestSize.Level1)
943 {
944 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500 start";
945 AccessibilityCommandArgument argument;
946 argument.abilityArgumentNum = 1;
947 argument.abilityName = "ability";
948 argument.bundleArgumentNum = 1;
949 argument.bundleName = "bundle";
950 argument.capabilityNamesArgumentNum = 0;
951 argument.capabilityNames = "capabilities";
952 argument.unknownArgumentNum = 0;
953 std::string resultMessage;
954 char* argv[] = {
955 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
956 };
957 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
958 AccessibilityAbilityShellCommand cmd(argc, argv);
959 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
960 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
961 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
962 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500 end";
963 }
964
965 /**
966 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600
967 * @tc.name: CheckEnableCommandArgument
968 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckParamValidity = false)
969 */
970 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
971 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600, TestSize.Level1)
972 {
973 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600 start";
974 AccessibilityCommandArgument argument;
975 argument.abilityArgumentNum = 1;
976 argument.abilityName = "ability";
977 argument.bundleArgumentNum = 1;
978 argument.bundleName = "bundle";
979 argument.capabilityNamesArgumentNum = 1;
980 argument.capabilityNames = "capabilities";
981 argument.unknownArgumentNum = 0;
982 std::string resultMessage;
983 char* argv[] = {
984 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
985 };
986 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
987 AccessibilityAbilityShellCommand cmd(argc, argv);
988 ErrCode result = cmd.CheckEnableCommandArgument(argument, resultMessage);
989 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
990 EXPECT_EQ(resultMessage, ": the auxiliary application bundle/ability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
991 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600 end";
992 }
993
994 /**
995 * @tc.number: AccessibilityAbilityShellCommand_RunAsEnableAbility_0100
996 * @tc.name: RunAsEnableAbility
997 * @tc.desc: Test whether RunAsEnableAbility is called normally.
998 * (MakeEnableCommandArgumentFromCmd = false)
999 */
1000 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1001 AccessibilityAbilityShellCommand_RunAsEnableAbility_0100, TestSize.Level1)
1002 {
1003 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsEnableAbility_0100 start";
1004 char* argv[] = {
1005 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1006 };
1007 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1008 AccessibilityAbilityShellCommand cmd(argc, argv);
1009 ErrCode result = cmd.RunAsEnableAbility();
1010 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1011 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY);
1012 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsEnableAbility_0100 end";
1013 }
1014
1015 /**
1016 * @tc.number: AccessibilityAbilityShellCommand_RunAsDisableAbility_0100
1017 * @tc.name: RunAsDisableAbility
1018 * @tc.desc: Test whether RunAsDisableAbility is called normally.
1019 * (MakeDisableCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1020 */
1021 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1022 AccessibilityAbilityShellCommand_RunAsDisableAbility_0100, TestSize.Level1)
1023 {
1024 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsDisableAbility_0100 start";
1025 char* argv[] = {
1026 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1027 };
1028 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1029 AccessibilityAbilityShellCommand cmd(argc, argv);
1030 ErrCode result = cmd.RunAsDisableAbility();
1031 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1032 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY);
1033 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsDisableAbility_0100 end";
1034 }
1035
1036 /**
1037 * @tc.number: AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100
1038 * @tc.name: RunAsGetEnabledAbilities
1039 * @tc.desc: Test whether RunAsGetEnabledAbilities is called normally.(enabledAbilities is empty)
1040 */
1041 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1042 AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100, TestSize.Level1)
1043 {
1044 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100 start";
1045 char* argv[] = {
1046 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1047 };
1048 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1049 AccessibilityAbilityShellCommand cmd(argc, argv);
1050 ErrCode result = cmd.RunAsGetEnabledAbilities();
1051 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1052 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100 end";
1053 }
1054
1055 /**
1056 * @tc.number: AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100
1057 * @tc.name: RunAsGetInstalledAbilities
1058 * @tc.desc: Test whether RunAsGetInstalledAbilities is called normally.(installedAbilities is empty)
1059 */
1060 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1061 AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100, TestSize.Level1)
1062 {
1063 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100 start";
1064 char* argv[] = {
1065 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1066 };
1067 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1068 AccessibilityAbilityShellCommand cmd(argc, argv);
1069 cmd.abilityClientPtr_ = nullptr;
1070 ErrCode result = cmd.RunAsGetInstalledAbilities();
1071 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1072 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100 end";
1073 }
1074
1075 /**
1076 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100
1077 * @tc.name: RunAsSetScreenMagnificationState
1078 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.
1079 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1080 */
1081 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1082 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100, TestSize.Level1)
1083 {
1084 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 start";
1085 char* argv[] = {
1086 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1087 };
1088 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1089 AccessibilityAbilityShellCommand cmd(argc, argv);
1090 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1091 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1092 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1093 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 end";
1094 }
1095
1096 /**
1097 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200
1098 * @tc.name: RunAsSetScreenMagnificationState
1099 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(OHOS::ERR_OK)
1100 */
1101 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1102 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200, TestSize.Level1)
1103 {
1104 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1105 char* argv[] = {
1106 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1107 (char*)cmdsetShortKeyState_.c_str(),
1108 (char*)"-v",
1109 (char*)"0",
1110 (char*)" ",
1111 };
1112 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1113 AccessibilityAbilityShellCommand cmd(argc, argv);
1114 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1115 EXPECT_EQ(result, OHOS::ERR_OK);
1116 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n");
1117 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 end";
1118 }
1119
1120 /**
1121 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300
1122 * @tc.name: RunAsSetScreenMagnificationState
1123 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(value is invalid)
1124 */
1125 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1126 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300, TestSize.Level1)
1127 {
1128 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1129 char* argv[] = {
1130 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1131 (char*)cmdsetShortKeyState_.c_str(),
1132 (char*)"-v",
1133 (char*)"2",
1134 (char*)" ",
1135 };
1136 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1137 AccessibilityAbilityShellCommand cmd(argc, argv);
1138 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1139 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1140 EXPECT_EQ(cmd.resultReceiver_, "setScreenMagnificationState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1141 "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1142 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300 end";
1143 }
1144
1145 /**
1146 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100
1147 * @tc.name: RunAsSetShortKeyState
1148 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1149 */
1150 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1151 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100, TestSize.Level1)
1152 {
1153 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 start";
1154 char* argv[] = {
1155 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1156 (char*)cmdsetShortKeyState_.c_str(),
1157 (char*)"-v",
1158 (char*)"0",
1159 (char*)" ",
1160 };
1161 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1162 AccessibilityAbilityShellCommand cmd(argc, argv);
1163 ErrCode result = cmd.RunAsSetShortKeyState();
1164 EXPECT_EQ(result, OHOS::ERR_OK);
1165 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1166 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 end";
1167 }
1168
1169 /**
1170 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200
1171 * @tc.name: RunAsSetShortKeyState
1172 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1173 */
1174 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1175 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200, TestSize.Level1)
1176 {
1177 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 start";
1178 char* argv[] = {
1179 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1180 (char*)cmdsetShortKeyState_.c_str(),
1181 (char*)"-v",
1182 (char*)"1",
1183 (char*)" ",
1184 };
1185 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1186 AccessibilityAbilityShellCommand cmd(argc, argv);
1187 ErrCode result = cmd.RunAsSetShortKeyState();
1188 EXPECT_EQ(result, OHOS::ERR_OK);
1189 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1190 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 end";
1191 }
1192
1193 /**
1194 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300
1195 * @tc.name: RunAsSetShortKeyState
1196 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(value is invalid)
1197 */
1198 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1199 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300, TestSize.Level1)
1200 {
1201 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 start";
1202 char* argv[] = {
1203 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1204 (char*)cmdsetShortKeyState_.c_str(),
1205 (char*)"-v",
1206 (char*)"2",
1207 (char*)" ",
1208 };
1209 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1210 AccessibilityAbilityShellCommand cmd(argc, argv);
1211 ErrCode result = cmd.RunAsSetShortKeyState();
1212 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1213 EXPECT_EQ(cmd.resultReceiver_, "setShortKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1214 "\n" + ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1215 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 end";
1216 }
1217
1218 /**
1219 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400
1220 * @tc.name: RunAsSetShortKeyState
1221 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.
1222 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1223 */
1224 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1225 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400, TestSize.Level1)
1226 {
1227 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 start";
1228 char* argv[] = {
1229 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1230 };
1231 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1232 AccessibilityAbilityShellCommand cmd(argc, argv);
1233 ErrCode result = cmd.RunAsSetShortKeyState();
1234 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1235 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1236 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 end";
1237 }
1238
1239 /**
1240 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100
1241 * @tc.name: RunAsSetMouseKeyState
1242 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1243 */
1244 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1245 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100, TestSize.Level1)
1246 {
1247 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 start";
1248 char* argv[] = {
1249 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1250 (char*)cmdsetMouseKeyState_.c_str(),
1251 (char*)"-v",
1252 (char*)"0",
1253 (char*)" ",
1254 };
1255 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1256 AccessibilityAbilityShellCommand cmd(argc, argv);
1257 ErrCode result = cmd.RunAsSetMouseKeyState();
1258 EXPECT_EQ(result, OHOS::ERR_OK);
1259 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1260 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 end";
1261 }
1262
1263 /**
1264 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200
1265 * @tc.name: RunAsSetMouseKeyState
1266 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1267 */
1268 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1269 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200, TestSize.Level1)
1270 {
1271 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 start";
1272 char* argv[] = {
1273 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1274 (char*)cmdsetMouseKeyState_.c_str(),
1275 (char*)"-v",
1276 (char*)"1",
1277 (char*)" ",
1278 };
1279 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1280 AccessibilityAbilityShellCommand cmd(argc, argv);
1281 ErrCode result = cmd.RunAsSetMouseKeyState();
1282 EXPECT_EQ(result, OHOS::ERR_OK);
1283 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1284 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 end";
1285 }
1286
1287 /**
1288 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300
1289 * @tc.name: RunAsSetMouseKeyState
1290 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(value is invalid)
1291 */
1292 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1293 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300, TestSize.Level1)
1294 {
1295 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 start";
1296 char* argv[] = {
1297 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1298 (char*)cmdsetMouseKeyState_.c_str(),
1299 (char*)"-v",
1300 (char*)"2",
1301 (char*)" ",
1302 };
1303 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1304 AccessibilityAbilityShellCommand cmd(argc, argv);
1305 ErrCode result = cmd.RunAsSetMouseKeyState();
1306 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1307 EXPECT_EQ(cmd.resultReceiver_, "setMouseKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1308 "\n" + ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1309 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 end";
1310 }
1311
1312 /**
1313 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400
1314 * @tc.name: RunAsSetMouseKeyState
1315 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.
1316 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1317 */
1318 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1319 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400, TestSize.Level1)
1320 {
1321 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 start";
1322 char* argv[] = {
1323 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1324 };
1325 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1326 AccessibilityAbilityShellCommand cmd(argc, argv);
1327 ErrCode result = cmd.RunAsSetMouseKeyState();
1328 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1329 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1330 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 end";
1331 }
1332
1333 /**
1334 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100
1335 * @tc.name: RunAsSetCaptionState
1336 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1337 */
1338 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1339 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100, TestSize.Level1)
1340 {
1341 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 start";
1342 char* argv[] = {
1343 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1344 (char*)cmdsetCaptionState_.c_str(),
1345 (char*)"-v",
1346 (char*)"0",
1347 (char*)" ",
1348 };
1349 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1350 AccessibilityAbilityShellCommand cmd(argc, argv);
1351 ErrCode result = cmd.RunAsSetCaptionState();
1352 EXPECT_EQ(result, OHOS::ERR_OK);
1353 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1354 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 end";
1355 }
1356
1357 /**
1358 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200
1359 * @tc.name: RunAsSetCaptionState
1360 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1361 */
1362 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1363 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200, TestSize.Level1)
1364 {
1365 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 start";
1366 char* argv[] = {
1367 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1368 (char*)cmdsetCaptionState_.c_str(),
1369 (char*)"-v",
1370 (char*)"1",
1371 (char*)" ",
1372 };
1373 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1374
1375 AccessibilityAbilityShellCommand cmd(argc, argv);
1376 ErrCode result = cmd.RunAsSetCaptionState();
1377 EXPECT_EQ(result, OHOS::ERR_OK);
1378 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1379 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 end";
1380 }
1381
1382 /**
1383 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300
1384 * @tc.name: RunAsSetCaptionState
1385 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(value is invalid)
1386 */
1387 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1388 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300, TestSize.Level1)
1389 {
1390 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 start";
1391 char* argv[] = {
1392 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1393 (char*)cmdsetCaptionState_.c_str(),
1394 (char*)"-v",
1395 (char*)"2",
1396 (char*)" ",
1397 };
1398 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1399 AccessibilityAbilityShellCommand cmd(argc, argv);
1400 ErrCode result = cmd.RunAsSetCaptionState();
1401 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1402 EXPECT_EQ(cmd.resultReceiver_, "setCaptionState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1403 "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1404 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 end";
1405 }
1406
1407 /**
1408 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400
1409 * @tc.name: RunAsSetCaptionState
1410 * @tc.desc: Test whether RunAsSetCaptionState is called normally.
1411 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1412 */
1413 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1414 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400, TestSize.Level1)
1415 {
1416 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 start";
1417 char* argv[] = {
1418 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1419 };
1420 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1421 AccessibilityAbilityShellCommand cmd(argc, argv);
1422 ErrCode result = cmd.RunAsSetCaptionState();
1423 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1424 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1425 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 end";
1426 }
1427
1428 /**
1429 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100
1430 * @tc.name: RunAsSetMouseAutoClick
1431 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1432 */
1433 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1434 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100, TestSize.Level1)
1435 {
1436 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 start";
1437 char* argv[] = {
1438 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1439 (char*)cmdsSetMouseAutoClick_.c_str(),
1440 (char*)"-v",
1441 (char*)"1000",
1442 (char*)" ",
1443 };
1444 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1445 AccessibilityAbilityShellCommand cmd(argc, argv);
1446 ErrCode result = cmd.RunAsSetMouseAutoClick();
1447 EXPECT_EQ(result, OHOS::ERR_OK);
1448 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1449 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 end";
1450 }
1451
1452 /**
1453 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200
1454 * @tc.name: RunAsSetMouseAutoClick
1455 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1456 */
1457 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1458 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200, TestSize.Level1)
1459 {
1460 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 start";
1461 char* argv[] = {
1462 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1463 (char*)cmdsSetMouseAutoClick_.c_str(),
1464 (char*)"-v",
1465 (char*)"5000",
1466 (char*)" ",
1467 };
1468 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1469 AccessibilityAbilityShellCommand cmd(argc, argv);
1470 ErrCode result = cmd.RunAsSetMouseAutoClick();
1471 EXPECT_EQ(result, OHOS::ERR_OK);
1472 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1473 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 end";
1474 }
1475
1476 /**
1477 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300
1478 * @tc.name: RunAsSetMouseAutoClick
1479 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(value is invalid)
1480 */
1481 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1482 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300, TestSize.Level1)
1483 {
1484 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 start";
1485 char* argv[] = {
1486 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1487 (char*)cmdsSetMouseAutoClick_.c_str(),
1488 (char*)"-v",
1489 (char*)"5001",
1490 (char*)" ",
1491 };
1492 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1493 AccessibilityAbilityShellCommand cmd(argc, argv);
1494 ErrCode result = cmd.RunAsSetMouseAutoClick();
1495 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1496 EXPECT_EQ(cmd.resultReceiver_, "setMouseAutoClick: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1497 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1498 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 end";
1499 }
1500
1501 /**
1502 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400
1503 * @tc.name: RunAsSetMouseAutoClick
1504 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.
1505 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1506 */
1507 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1508 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400, TestSize.Level1)
1509 {
1510 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 start";
1511 char* argv[] = {
1512 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1513 };
1514 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1515 AccessibilityAbilityShellCommand cmd(argc, argv);
1516 ErrCode result = cmd.RunAsSetMouseAutoClick();
1517 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1518 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1519 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 end";
1520 }
1521
1522 /**
1523 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100
1524 * @tc.name: RunAsSetShortKeyTarget
1525 * @tc.desc: Test whether RunAsSetShortKeyTarget is called normally.
1526 * (MakeSetShortKeyTargetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1527 */
1528 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1529 AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100, TestSize.Level1)
1530 {
1531 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 start";
1532 char* argv[] = {
1533 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1534 };
1535 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1536 AccessibilityAbilityShellCommand cmd(argc, argv);
1537 ErrCode result = cmd.RunAsSetShortKeyTarget();
1538 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1539 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET);
1540 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 end";
1541 }
1542
1543 /**
1544 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100
1545 * @tc.name: RunAsSetHighContrastTextState
1546 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1547 */
1548 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1549 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100, TestSize.Level1)
1550 {
1551 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 start";
1552 char* argv[] = {
1553 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1554 (char*)cmdsetHighContrastTextState_.c_str(),
1555 (char*)"-v",
1556 (char*)"0",
1557 (char*)" ",
1558 };
1559 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1560 AccessibilityAbilityShellCommand cmd(argc, argv);
1561 ErrCode result = cmd.RunAsSetHighContrastTextState();
1562 EXPECT_EQ(result, OHOS::ERR_OK);
1563 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1564 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 end";
1565 }
1566
1567 /**
1568 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200
1569 * @tc.name: RunAsSetHighContrastTextState
1570 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1571 */
1572 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1573 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200, TestSize.Level1)
1574 {
1575 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 start";
1576 char* argv[] = {
1577 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1578 (char*)cmdsetHighContrastTextState_.c_str(),
1579 (char*)"-v",
1580 (char*)"1",
1581 (char*)" ",
1582 };
1583 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1584 AccessibilityAbilityShellCommand cmd(argc, argv);
1585 ErrCode result = cmd.RunAsSetHighContrastTextState();
1586 EXPECT_EQ(result, OHOS::ERR_OK);
1587 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1588 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 end";
1589 }
1590
1591 /**
1592 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300
1593 * @tc.name: RunAsSetHighContrastTextState
1594 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(value is invalid)
1595 */
1596 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1597 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300, TestSize.Level1)
1598 {
1599 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 start";
1600 char* argv[] = {
1601 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1602 (char*)cmdsetHighContrastTextState_.c_str(),
1603 (char*)"-v",
1604 (char*)"2",
1605 (char*)" ",
1606 };
1607 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1608 AccessibilityAbilityShellCommand cmd(argc, argv);
1609 ErrCode result = cmd.RunAsSetHighContrastTextState();
1610 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1611 EXPECT_EQ(cmd.resultReceiver_, "setHighContrastTextState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1612 "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1613 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 end";
1614 }
1615
1616 /**
1617 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400
1618 * @tc.name: RunAsSetHighContrastTextState
1619 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.
1620 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1621 */
1622 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1623 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400, TestSize.Level1)
1624 {
1625 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 start";
1626 char* argv[] = {
1627 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1628 };
1629 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1630 AccessibilityAbilityShellCommand cmd(argc, argv);
1631 ErrCode result = cmd.RunAsSetHighContrastTextState();
1632 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1633 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1634 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 end";
1635 }
1636
1637 /**
1638 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100
1639 * @tc.name: RunAsSetInvertColorState
1640 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1641 */
1642 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1643 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100, TestSize.Level1)
1644 {
1645 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 start";
1646 char* argv[] = {
1647 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1648 (char*)cmdsetInvertColorState_.c_str(),
1649 (char*)"-v",
1650 (char*)"0",
1651 (char*)" ",
1652 };
1653 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1654 AccessibilityAbilityShellCommand cmd(argc, argv);
1655 ErrCode result = cmd.RunAsSetInvertColorState();
1656 EXPECT_EQ(result, OHOS::ERR_OK);
1657 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1658 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 end";
1659 }
1660
1661 /**
1662 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200
1663 * @tc.name: RunAsSetInvertColorState
1664 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1665 */
1666 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1667 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200, TestSize.Level1)
1668 {
1669 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 start";
1670 char* argv[] = {
1671 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1672 (char*)cmdsetInvertColorState_.c_str(),
1673 (char*)"-v",
1674 (char*)"1",
1675 (char*)" ",
1676 };
1677 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1678 AccessibilityAbilityShellCommand cmd(argc, argv);
1679 ErrCode result = cmd.RunAsSetInvertColorState();
1680 EXPECT_EQ(result, OHOS::ERR_OK);
1681 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1682 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 end";
1683 }
1684
1685 /**
1686 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300
1687 * @tc.name: RunAsSetInvertColorState
1688 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(value is invalid)
1689 */
1690 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1691 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300, TestSize.Level1)
1692 {
1693 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 start";
1694 char* argv[] = {
1695 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1696 (char*)cmdsetInvertColorState_.c_str(),
1697 (char*)"-v",
1698 (char*)"2",
1699 (char*)" ",
1700 };
1701 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1702 AccessibilityAbilityShellCommand cmd(argc, argv);
1703 ErrCode result = cmd.RunAsSetInvertColorState();
1704 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1705 EXPECT_EQ(cmd.resultReceiver_, "setInvertColorState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1706 "\n" + ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1707 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 end";
1708 }
1709
1710 /**
1711 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400
1712 * @tc.name: RunAsSetInvertColorState
1713 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.
1714 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1715 */
1716 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1717 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400, TestSize.Level1)
1718 {
1719 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 start";
1720 char* argv[] = {
1721 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1722 };
1723 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1724 AccessibilityAbilityShellCommand cmd(argc, argv);
1725 ErrCode result = cmd.RunAsSetInvertColorState();
1726 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1727 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1728 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 end";
1729 }
1730
1731 /**
1732 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100
1733 * @tc.name: RunAsSetDaltonizationColorFilter
1734 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1735 */
1736 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1737 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100, TestSize.Level1)
1738 {
1739 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 start";
1740 char* argv[] = {
1741 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1742 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1743 (char*)"-v",
1744 (char*)"0",
1745 (char*)" ",
1746 };
1747 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1748 AccessibilityAbilityShellCommand cmd(argc, argv);
1749 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1750 EXPECT_EQ(result, OHOS::ERR_OK);
1751 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1752 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 end";
1753 }
1754
1755 /**
1756 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200
1757 * @tc.name: RunAsSetDaltonizationColorFilter
1758 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1759 */
1760 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1761 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200, TestSize.Level1)
1762 {
1763 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 start";
1764 char* argv[] = {
1765 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1766 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1767 (char*)"-v",
1768 (char*)"1",
1769 (char*)" ",
1770 };
1771 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1772 AccessibilityAbilityShellCommand cmd(argc, argv);
1773 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1774 EXPECT_EQ(result, OHOS::ERR_OK);
1775 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1776 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 end";
1777 }
1778
1779 /**
1780 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300
1781 * @tc.name: RunAsSetDaltonizationColorFilter
1782 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1783 */
1784 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1785 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300, TestSize.Level1)
1786 {
1787 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 start";
1788 char* argv[] = {
1789 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1790 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1791 (char*)"-v",
1792 (char*)"2",
1793 (char*)" ",
1794 };
1795 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1796 AccessibilityAbilityShellCommand cmd(argc, argv);
1797 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1798 EXPECT_EQ(result, OHOS::ERR_OK);
1799 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1800 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 end";
1801 }
1802
1803 /**
1804 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400
1805 * @tc.name: RunAsSetDaltonizationColorFilter
1806 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1807 */
1808 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1809 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400, TestSize.Level1)
1810 {
1811 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 start";
1812 char* argv[] = {
1813 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1814 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1815 (char*)"-v",
1816 (char*)"3",
1817 (char*)" ",
1818 };
1819 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1820 AccessibilityAbilityShellCommand cmd(argc, argv);
1821 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1822 EXPECT_EQ(result, OHOS::ERR_OK);
1823 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1824 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 end";
1825 }
1826
1827 /**
1828 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500
1829 * @tc.name: RunAsSetDaltonizationColorFilter
1830 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(value is invalid)
1831 */
1832 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1833 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500, TestSize.Level1)
1834 {
1835 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 start";
1836 char* argv[] = {
1837 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1838 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1839 (char*)"-v",
1840 (char*)"4",
1841 (char*)" ",
1842 };
1843 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1844 AccessibilityAbilityShellCommand cmd(argc, argv);
1845 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1846 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1847 EXPECT_EQ(cmd.resultReceiver_, "setDaltonizationColorFilter: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1848 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 end";
1849 }
1850
1851 /**
1852 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600
1853 * @tc.name: RunAsSetDaltonizationColorFilter
1854 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.
1855 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1856 */
1857 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1858 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600, TestSize.Level1)
1859 {
1860 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 start";
1861 char* argv[] = {
1862 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1863 };
1864 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1865 AccessibilityAbilityShellCommand cmd(argc, argv);
1866 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1867 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1868 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER);
1869 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 end";
1870 }
1871
1872 /**
1873 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100
1874 * @tc.name: RunAsSetContentTimeout
1875 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
1876 */
1877 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1878 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100, TestSize.Level1)
1879 {
1880 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 start";
1881 char* argv[] = {
1882 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1883 (char*)cmdsetContentTimeout_.c_str(),
1884 (char*)"-v",
1885 (char*)"0",
1886 (char*)" ",
1887 };
1888 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1889 AccessibilityAbilityShellCommand cmd(argc, argv);
1890 ErrCode result = cmd.RunAsSetContentTimeout();
1891 EXPECT_EQ(result, OHOS::ERR_OK);
1892 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
1893 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 end";
1894 }
1895
1896 /**
1897 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200
1898 * @tc.name: RunAsSetContentTimeout
1899 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
1900 */
1901 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1902 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200, TestSize.Level1)
1903 {
1904 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 start";
1905 char* argv[] = {
1906 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1907 (char*)cmdsetContentTimeout_.c_str(),
1908 (char*)"-v",
1909 (char*)"5000",
1910 (char*)" ",
1911 };
1912 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1913
1914 AccessibilityAbilityShellCommand cmd(argc, argv);
1915 ErrCode result = cmd.RunAsSetContentTimeout();
1916 EXPECT_EQ(result, OHOS::ERR_OK);
1917 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
1918 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 end";
1919 }
1920
1921 /**
1922 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300
1923 * @tc.name: RunAsSetContentTimeout
1924 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(value is invalid)
1925 */
1926 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1927 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300, TestSize.Level1)
1928 {
1929 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 start";
1930 char* argv[] = {
1931 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1932 (char*)cmdsetContentTimeout_.c_str(),
1933 (char*)"-v",
1934 (char*)"5001",
1935 (char*)" ",
1936 };
1937 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1938 AccessibilityAbilityShellCommand cmd(argc, argv);
1939 ErrCode result = cmd.RunAsSetContentTimeout();
1940 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1941 EXPECT_EQ(cmd.resultReceiver_, "setContentTimeout: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1942 "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
1943 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 end";
1944 }
1945
1946 /**
1947 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400
1948 * @tc.name: RunAsSetContentTimeout
1949 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.
1950 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1951 */
1952 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1953 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400, TestSize.Level1)
1954 {
1955 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 start";
1956 char* argv[] = {
1957 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1958 };
1959 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1960 AccessibilityAbilityShellCommand cmd(argc, argv);
1961 ErrCode result = cmd.RunAsSetContentTimeout();
1962 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1963 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
1964 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 end";
1965 }
1966
1967 /**
1968 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100
1969 * @tc.name: RunAsSetAnimationOffState
1970 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
1971 */
1972 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1973 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100, TestSize.Level1)
1974 {
1975 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 start";
1976 char* argv[] = {
1977 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1978 (char*)cmdsetAnimationOffState_.c_str(),
1979 (char*)"-v",
1980 (char*)"0",
1981 (char*)" ",
1982 };
1983 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1984 AccessibilityAbilityShellCommand cmd(argc, argv);
1985 ErrCode result = cmd.RunAsSetAnimationOffState();
1986 EXPECT_EQ(result, OHOS::ERR_OK);
1987 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
1988 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 end";
1989 }
1990
1991 /**
1992 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200
1993 * @tc.name: RunAsSetAnimationOffState
1994 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
1995 */
1996 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
1997 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200, TestSize.Level1)
1998 {
1999 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 start";
2000 char* argv[] = {
2001 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2002 (char*)cmdsetAnimationOffState_.c_str(),
2003 (char*)"-v",
2004 (char*)"1",
2005 (char*)" ",
2006 };
2007 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2008 AccessibilityAbilityShellCommand cmd(argc, argv);
2009 ErrCode result = cmd.RunAsSetAnimationOffState();
2010 EXPECT_EQ(result, OHOS::ERR_OK);
2011 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
2012 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 end";
2013 }
2014
2015 /**
2016 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300
2017 * @tc.name: RunAsSetAnimationOffState
2018 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(value is invalid)
2019 */
2020 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2021 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300, TestSize.Level1)
2022 {
2023 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 start";
2024 char* argv[] = {
2025 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2026 (char*)cmdsetAnimationOffState_.c_str(),
2027 (char*)"-v",
2028 (char*)"2",
2029 (char*)" ",
2030 };
2031 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2032 AccessibilityAbilityShellCommand cmd(argc, argv);
2033 ErrCode result = cmd.RunAsSetAnimationOffState();
2034 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2035 EXPECT_EQ(cmd.resultReceiver_, "setAnimationOffState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2036 "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2037 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 end";
2038 }
2039
2040 /**
2041 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400
2042 * @tc.name: RunAsSetAnimationOffState
2043 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.
2044 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2045 */
2046 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2047 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400, TestSize.Level1)
2048 {
2049 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 start";
2050 char* argv[] = {
2051 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2052 };
2053 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2054 AccessibilityAbilityShellCommand cmd(argc, argv);
2055 ErrCode result = cmd.RunAsSetAnimationOffState();
2056 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2057 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2058 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 end";
2059 }
2060
2061 /**
2062 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100
2063 * @tc.name: RunAsSetBrightnessDiscount
2064 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2065 * 2.ret is not Accessibility::RET_OK
2066 */
2067 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2068 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100, TestSize.Level1)
2069 {
2070 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 start";
2071 char* argv[] = {
2072 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2073 (char*)cmdsetBrightnessDiscount_.c_str(),
2074 (char*)"-v",
2075 (char*)"0",
2076 (char*)" ",
2077 };
2078 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2079
2080 AccessibilityAbilityShellCommand cmd(argc, argv);
2081 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2082 MockSetBrightnessDiscount(false);
2083 EXPECT_EQ(result, OHOS::ERR_OK);
2084 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n");
2085 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 end";
2086 }
2087
2088 /**
2089 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200
2090 * @tc.name: RunAsSetBrightnessDiscount
2091 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2092 * 2.ret is Accessibility::RET_OK
2093 */
2094 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2095 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200, TestSize.Level1)
2096 {
2097 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 start";
2098 char* argv[] = {
2099 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2100 (char*)cmdsetBrightnessDiscount_.c_str(),
2101 (char*)"-v",
2102 (char*)"100",
2103 (char*)" ",
2104 };
2105 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2106 AccessibilityAbilityShellCommand cmd(argc, argv);
2107 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2108 MockSetBrightnessDiscount(true);
2109 EXPECT_EQ(result, OHOS::ERR_OK);
2110 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG);
2111 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 end";
2112 }
2113
2114 /**
2115 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300
2116 * @tc.name: RunAsSetBrightnessDiscount
2117 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.(value is invalid)
2118 */
2119 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2120 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300, TestSize.Level1)
2121 {
2122 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 start";
2123 char* argv[] = {
2124 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2125 (char*)cmdsetBrightnessDiscount_.c_str(),
2126 (char*)"-v",
2127 (char*)"101",
2128 (char*)" ",
2129 };
2130 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2131 AccessibilityAbilityShellCommand cmd(argc, argv);
2132 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2133 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2134 EXPECT_EQ(cmd.resultReceiver_, "setSetBrightnessDiscount: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2135 "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2136 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 end";
2137 }
2138
2139 /**
2140 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400
2141 * @tc.name: RunAsSetBrightnessDiscount
2142 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.
2143 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2144 */
2145 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2146 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400, TestSize.Level1)
2147 {
2148 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 start";
2149 char* argv[] = {
2150 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2151 };
2152 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2153 AccessibilityAbilityShellCommand cmd(argc, argv);
2154 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2155 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2156 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2157 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 end";
2158 }
2159
2160 /**
2161 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100
2162 * @tc.name: RunAsSetAudioMonoState
2163 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2164 */
2165 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2166 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100, TestSize.Level1)
2167 {
2168 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 start";
2169 char* argv[] = {
2170 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2171 (char*)cmdsetAudioMonoState_.c_str(),
2172 (char*)"-v",
2173 (char*)"0",
2174 (char*)" ",
2175 };
2176 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2177 AccessibilityAbilityShellCommand cmd(argc, argv);
2178 ErrCode result = cmd.RunAsSetAudioMonoState();
2179 EXPECT_EQ(result, OHOS::ERR_OK);
2180 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2181 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 end";
2182 }
2183
2184 /**
2185 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200
2186 * @tc.name: RunAsSetAudioMonoState
2187 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2188 */
2189 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2190 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200, TestSize.Level1)
2191 {
2192 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 start";
2193 char* argv[] = {
2194 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2195 (char*)cmdsetAudioMonoState_.c_str(),
2196 (char*)"-v",
2197 (char*)"1",
2198 (char*)" ",
2199 };
2200 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2201 AccessibilityAbilityShellCommand cmd(argc, argv);
2202 ErrCode result = cmd.RunAsSetAudioMonoState();
2203 EXPECT_EQ(result, OHOS::ERR_OK);
2204 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2205 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 end";
2206 }
2207
2208 /**
2209 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300
2210 * @tc.name: RunAsSetAudioMonoState
2211 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(value is invalid)
2212 */
2213 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2214 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300, TestSize.Level1)
2215 {
2216 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 start";
2217 char* argv[] = {
2218 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2219 (char*)cmdsetAudioMonoState_.c_str(),
2220 (char*)"-v",
2221 (char*)"2",
2222 (char*)" ",
2223 };
2224 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2225 AccessibilityAbilityShellCommand cmd(argc, argv);
2226 ErrCode result = cmd.RunAsSetAudioMonoState();
2227 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2228 EXPECT_EQ(cmd.resultReceiver_, "setAudioMonoState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2229 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2230 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 end";
2231 }
2232
2233 /**
2234 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400
2235 * @tc.name: RunAsSetAudioMonoState
2236 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.
2237 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2238 */
2239 HWTEST_F(AccessibilityAbilityShellCommandFirstTest,
2240 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400, TestSize.Level1)
2241 {
2242 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 start";
2243 char* argv[] = {
2244 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2245 };
2246 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2247 AccessibilityAbilityShellCommand cmd(argc, argv);
2248 ErrCode result = cmd.RunAsSetAudioMonoState();
2249 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2250 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2251 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 end";
2252 }
2253 } // namespace AAFwk
2254 } // namespace OHOS
2255