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
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::AAFwk;
27
28 namespace {
29 const std::string ACCESSIBILITY_TOOL_NAME = "accessibility";
30 const std::string ACCESSIBILITY_HELP_MSG =
31 "usage: accessibility <command>\n"
32 "these are common accessibility commands list:\n"
33 " help list available commands\n"
34 " enable enable ability with options\n"
35 " disable disable ability with options\n"
36 " list list the installed abilities info\n"
37 " setShortKeyState set the state of the short key configuration item\n"
38 " setMouseKeyState set the state of the mouse key configuration item\n"
39 " setCaptionState set the state of the caption configuration item\n"
40 " setMouseAutoClick set the time of the mouse auto click configuration item\n"
41 " setShortKeyTarget set the name of the short key target configuration item\n"
42 " setHighContrastTextState set the state of the high contrast text configuration item\n"
43 " setInvertColorState set the state of the invert color configuration item\n"
44 " setDaltonizationColorFilter set the type of the daltonization color filter configuration item\n"
45 " setContentTimeout set the time of the toast content duration configuration item\n"
46 " setAnimationOffState set the state of the animation off configuration item\n"
47 " setBrightnessDiscount set the discount of the screen brightness configuration item\n"
48 " setAudioMonoState set the state of the audio mono configuration item\n"
49 " setAudioBalance set the value of the audio balance configuration item\n";
50
51 const std::string ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK = "set screen magnification state successfully.";
52 const std::string ACCESSIBILITY_SET_SHORT_KEY_STATE_OK = "set short key state successfully.";
53 const std::string ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK = "set mouse key state successfully.";
54 const std::string ACCESSIBILITY_SET_CAPTION_STATE_OK = "set caption state successfully.";
55 const std::string ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK = "set mouse auto click time successfully.";
56 const std::string ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK = "set high contrast text state successfully.";
57 const std::string ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK = "set invert color state successfully.";
58 const std::string ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK =
59 "set daltonization color filter successfully.";
60 const std::string ACCESSIBILITY_SET_CONTENT_TIME_OK = "set content timeout successfully.";
61 const std::string ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK = "set animation off state successfully.";
62 const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK = "set brightness discount successfully.";
63 const std::string ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG = "error: failed to set brightness discount.\n";
64 const std::string ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK = "set audio mono state successfully.";
65 const std::string ACCESSIBILITY_SET_AUDIO_BALANCE_OK = "set audio balance successfully.";
66
67 const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT =
68 "argument -a <ability-name> or --ability=<ability-name> is required!";
69 const std::string ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT = "there are duplicate arguments.";
70 const std::string ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE = "option -a requires a value.";
71 const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT =
72 "argument -b <bundle-name> or --bundle=<bundle-name> is required!";
73 const std::string ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE = "option -b requires a value.";
74 const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT =
75 "argument -c <capabilities-abbr>"
76 " or --capabilities=<capabilities-abbr> is required!";
77 const std::string ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE = "option -c requires a value.";
78 const std::string ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE = "option -v requires a value.";
79 const std::string ACCESSIBILITY_ABILITY_SET_VALUE_INVALID = "value is invalid.";
80 const std::string ACCESSIBILITY_HELP_MSG_NO_OPTION = "missing options.";
81 const std::string ACCESSIBILITY_ABILITY_NOT_FOUND = " was not found!";
82 const std::string ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT = "there are too many arguments ";
83
84 const std::string ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE =
85 "usage: accessibility setScreenMagnificationState [-v <0 | 1> ]\n"
86 "set the state of the screen magnification configuration item\n";
87
88 const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE =
89 "usage: accessibility setShortKeyState [-v <0 | 1> ]\n"
90 "set the state of the short key configuration item\n";
91
92 const std::string ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE =
93 "usage: accessibility setMouseKeyState [-v <0 | 1> ]\n"
94 "set the state of the mouse key configuration item\n";
95
96 const std::string ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE =
97 "usage: accessibility setCaptionState [-v <0 | 1> ]\n"
98 "set the state of the caption configuration item\n";
99
100 const std::string ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME =
101 "usage: accessibility setMouseAutoClick [-v <time-value>]\n"
102 "the range of time-value is 1000 to 5000 and the default unit is ms\n"
103 "set the time of the mouse auto click configuration item\n";
104
105 const std::string ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET =
106 "usage: accessibility setShortKeyTarget -a <ability-name> -b <bundle-name>\n"
107 "set the name of the short key target configuration item\n";
108
109 const std::string ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE =
110 "usage: accessibility setHighContrastTextState [-v <0 | 1> ]\n"
111 "set the state of the high contrast text configuration item\n";
112
113 const std::string ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE =
114 "usage: accessibility setInvertColorState [-v <0 | 1>]\n"
115 "set the state of the invert color configuration item\n";
116
117 const std::string ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER =
118 "usage: accessibility setDaltonizationColorFilter [-v <0 | 1 | 2 | 3>]\n"
119 "normal = 0, protanomaly = 1, deuteranomaly = 2, tritanomaly = 3\n"
120 "set the type of the daltonization color filter configuration item\n";
121
122 const std::string ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT =
123 "usage: accessibility setContentTimeout [-v <time-value>]\n"
124 "the range of time-value is 0 to 5000 and the default unit is ms\n"
125 "set the time of the toast content duration configuration item\n";
126
127 const std::string ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE =
128 "usage: accessibility setAnimationOffState [-v <0 | 1>]\n"
129 "set the state of the animation off configuration item\n";
130
131 const std::string ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT =
132 "usage: accessibility setBrightnessDiscount [-v <discount-value>]\n"
133 "the percentage of discount-value is 0 to 100\n"
134 "set the discount of the screen brightness configuration item\n";
135
136 const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE =
137 "usage: accessibility setAudioMonoState [-v <0 | 1>]\n"
138 "set the state of the audio mono configuration item\n";
139
140 const std::string ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE =
141 "usage: accessibility setAudioBalance [-v <balance-value>]\n"
142 "the percentage of balance-value is -100 to 100\n"
143 "the negative values represent the left channel and positive values represent the right channel\n"
144 "set the value of the audio balance configuration item\n";
145
146 const std::string ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY =
147 "usage: accessibility enable [-a <ability-name>] [-b <bundle-name>] [-c <capabilities-abbr>]\n"
148 "enable the auxiliary application with bundle-name and ability-name and capabilities-abbr\n";
149
150 const std::string ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY =
151 "usage: accessibility disable [-a <ability-name>] [-b <bundle-name>]\n"
152 "disable the auxiliary application with bundle-name and ability-name\n";
153 } // namespace
154
155 extern void MockSetBrightnessDiscount(bool mockRet);
156
157 namespace OHOS {
158 namespace AAFwk {
159 class AccessibilityAbilityShellCommandTest : public ::testing::Test {
160 public:
161 static void SetUpTestCase(void);
162 static void TearDownTestCase(void);
163 void SetUp();
164 void TearDown();
165
166 std::string cmdhelp_ = "help";
167 std::string cmdenable_ = "enable";
168 std::string cmddisable_ = "disable";
169 std::string cmdsetShortKeyState_ = "setShortKeyState";
170 std::string cmdsetMouseKeyState_ = "setMouseKeyState";
171 std::string cmdsetCaptionState_ = "setCaptionState";
172 std::string cmdssetMouseAutoClick_ = "setMouseAutoClick";
173 std::string cmdsetShortKeyTarget_ = "setShortKeyTarget";
174 std::string cmdsetHighContrastTextState_ = "setHighContrastTextState";
175 std::string cmdsetInvertColorState_ = "setInvertColorState";
176 std::string cmdsetDaltonizationColorFilter_ = "setDaltonizationColorFilter";
177 std::string cmdsetContentTimeout_ = "setContentTimeout";
178 std::string cmdsetAnimationOffState_ = "setAnimationOffState";
179 std::string cmdsetBrightnessDiscount_ = "setBrightnessDiscount";
180 std::string cmdsetAudioMonoState_ = "setAudioMonoState";
181 std::string cmdsetAudioBalance_ = "setAudioBalance";
182 std::string cmdSetScreenMagnificationState_ = "setScreenMagnificationState";
183 };
184
SetUpTestCase()185 void AccessibilityAbilityShellCommandTest::SetUpTestCase()
186 {}
187
TearDownTestCase()188 void AccessibilityAbilityShellCommandTest::TearDownTestCase()
189 {}
190
SetUp()191 void AccessibilityAbilityShellCommandTest::SetUp()
192 {
193 // reset optind to 0
194 optind = 0;
195 }
196
TearDown()197 void AccessibilityAbilityShellCommandTest::TearDown()
198 {}
199
200 /**
201 * @tc.number: AccessibilityAbilityShellCommand_init_0100
202 * @tc.name: init
203 * @tc.desc: Test whether init is called normally.
204 */
205 HWTEST_F(AccessibilityAbilityShellCommandTest, AccessibilityAbilityShellCommand_init_0100, TestSize.Level1)
206 {
207 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_init_0100 start";
208 char* argv[] = {
209 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
210 };
211 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
212 AccessibilityAbilityShellCommand cmd(argc, argv);
213 EXPECT_EQ(cmd.init(), OHOS::ERR_OK);
214 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_init_0100 end";
215 }
216
217 /**
218 * @tc.number: AccessibilityAbilityShellCommand_CreateMessageMap_0100
219 * @tc.name: CreateMessageMap
220 * @tc.desc: Test whether CreateMessageMap is called normally.
221 */
222 HWTEST_F(AccessibilityAbilityShellCommandTest, AccessibilityAbilityShellCommand_CreateMessageMap_0100, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CreateMessageMap_0100 start";
225 char* argv[] = {
226 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
227 };
228 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
229 AccessibilityAbilityShellCommand cmd(argc, argv);
230 EXPECT_EQ(cmd.CreateMessageMap(), OHOS::ERR_OK);
231 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CreateMessageMap_0100 end";
232 }
233
234 /**
235 * @tc.number: AccessibilityAbilityShellCommand_RunAsHelpCommand_0100
236 * @tc.name: RunAsHelpCommand
237 * @tc.desc: Test whether RunAsHelpCommand is called normally.
238 */
239 HWTEST_F(AccessibilityAbilityShellCommandTest, AccessibilityAbilityShellCommand_RunAsHelpCommand_0100, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsHelpCommand_0100 start";
242 char* argv[] = {
243 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
244 (char*)cmdhelp_.c_str(),
245 };
246 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
247 AccessibilityAbilityShellCommand cmd(argc, argv);
248 EXPECT_EQ(cmd.RunAsHelpCommand(), OHOS::ERR_OK);
249 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_HELP_MSG);
250 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsHelpCommand_0100 end";
251 }
252
253 /**
254 * @tc.number: AccessibilityAbilityShellCommand_GetEnabledAbilities_0100
255 * @tc.name: GetEnabledAbilities
256 * @tc.desc: Test whether GetEnabledAbilities is called normally.
257 */
258 HWTEST_F(AccessibilityAbilityShellCommandTest,
259 AccessibilityAbilityShellCommand_GetEnabledAbilities_0100, TestSize.Level1)
260 {
261 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetEnabledAbilities_0100 start";
262 AccessibilityCommandArgument argument;
263 std::vector<std::string> enabledAbilities;
264 char* argv[] = {
265 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
266 };
267 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
268 AccessibilityAbilityShellCommand cmd(argc, argv);
269 enabledAbilities = cmd.GetEnabledAbilities();
270 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetEnabledAbilities_0100 end";
271 }
272
273 /**
274 * @tc.number: AccessibilityAbilityShellCommand_GetInstalledAbilities_0100
275 * @tc.name: GetInstalledAbilities
276 * @tc.desc: Test whether GetInstalledAbilities is called normally.
277 */
278 HWTEST_F(AccessibilityAbilityShellCommandTest,
279 AccessibilityAbilityShellCommand_GetInstalledAbilities_0100, TestSize.Level1)
280 {
281 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetInstalledAbilities_0100 start";
282 AccessibilityCommandArgument argument;
283 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities;
284 char* argv[] = {
285 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
286 };
287 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
288 AccessibilityAbilityShellCommand cmd(argc, argv);
289 installedAbilities = cmd.GetInstalledAbilities();
290 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_GetInstalledAbilities_0100 end";
291 }
292
293 /**
294 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0100
295 * @tc.name: CheckAbilityArgument
296 * @tc.desc: Test whether CheckAbilityArgument is called normally.
297 */
298 HWTEST_F(AccessibilityAbilityShellCommandTest,
299 AccessibilityAbilityShellCommand_CheckAbilityArgument_0100, TestSize.Level1)
300 {
301 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0100 start";
302 AccessibilityCommandArgument argument;
303 argument.abilityArgumentNum = 0;
304 std::string resultMessage;
305 char* argv[] = {
306 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
307 };
308 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
309 AccessibilityAbilityShellCommand cmd(argc, argv);
310 ErrCode result = cmd.CheckAbilityArgument(argument,resultMessage);
311 EXPECT_EQ(result, false);
312 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
313 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0100 end";
314 }
315
316 /**
317 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0200
318 * @tc.name: CheckAbilityArgument
319 * @tc.desc: Test whether CheckAbilityArgument is called normally.
320 */
321 HWTEST_F(AccessibilityAbilityShellCommandTest,
322 AccessibilityAbilityShellCommand_CheckAbilityArgument_0200, TestSize.Level1)
323 {
324 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0200 start";
325 AccessibilityCommandArgument argument;
326 argument.abilityArgumentNum = 2;
327 std::string resultMessage;
328 char* argv[] = {
329 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
330 };
331 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
332 AccessibilityAbilityShellCommand cmd(argc, argv);
333 ErrCode result = cmd.CheckAbilityArgument(argument,resultMessage);
334 EXPECT_EQ(result, false);
335 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
336 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0200 end";
337 }
338
339 /**
340 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0300
341 * @tc.name: CheckAbilityArgument
342 * @tc.desc: Test whether CheckAbilityArgument is called normally.
343 */
344 HWTEST_F(AccessibilityAbilityShellCommandTest,
345 AccessibilityAbilityShellCommand_CheckAbilityArgument_0300, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0300 start";
348 AccessibilityCommandArgument argument;
349 argument.abilityArgumentNum = 1;
350 argument.abilityName[0] = '-';
351 std::string resultMessage;
352 char* argv[] = {
353 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
354 };
355 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
356 AccessibilityAbilityShellCommand cmd(argc, argv);
357 ErrCode result = cmd.CheckAbilityArgument(argument,resultMessage);
358 EXPECT_EQ(result, false);
359 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
360 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0300 end";
361 }
362
363 /**
364 * @tc.number: AccessibilityAbilityShellCommand_CheckAbilityArgument_0400
365 * @tc.name: CheckAbilityArgument
366 * @tc.desc: Test whether CheckAbilityArgument is called normally.
367 */
368 HWTEST_F(AccessibilityAbilityShellCommandTest,
369 AccessibilityAbilityShellCommand_CheckAbilityArgument_0400, TestSize.Level1)
370 {
371 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0400 start";
372 AccessibilityCommandArgument argument;
373 argument.abilityArgumentNum = 1;
374 argument.abilityName = "ability";
375 std::string resultMessage;
376 char* argv[] = {
377 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
378 };
379 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
380 AccessibilityAbilityShellCommand cmd(argc, argv);
381 ErrCode result = cmd.CheckAbilityArgument(argument,resultMessage);
382 EXPECT_EQ(result, true);
383 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckAbilityArgument_0400 end";
384 }
385
386 /**
387 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0100
388 * @tc.name: CheckBundleArgument
389 * @tc.desc: Test whether CheckBundleArgument is called normally.
390 */
391 HWTEST_F(AccessibilityAbilityShellCommandTest,
392 AccessibilityAbilityShellCommand_CheckBundleArgument_0100, TestSize.Level1)
393 {
394 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0100 start";
395 AccessibilityCommandArgument argument;
396 argument.bundleArgumentNum = 0;
397 std::string resultMessage;
398 char* argv[] = {
399 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
400 };
401 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
402 AccessibilityAbilityShellCommand cmd(argc, argv);
403 ErrCode result = cmd.CheckBundleArgument(argument,resultMessage);
404 EXPECT_EQ(result, false);
405 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
406 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0100 end";
407 }
408
409 /**
410 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0200
411 * @tc.name: CheckBundleArgument
412 * @tc.desc: Test whether CheckAbilityArgument is called normally.
413 */
414 HWTEST_F(AccessibilityAbilityShellCommandTest,
415 AccessibilityAbilityShellCommand_CheckBundleArgument_0200, TestSize.Level1)
416 {
417 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0200 start";
418 AccessibilityCommandArgument argument;
419 argument.bundleArgumentNum = 2;
420 std::string resultMessage;
421 char* argv[] = {
422 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
423 };
424 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
425 AccessibilityAbilityShellCommand cmd(argc, argv);
426 ErrCode result = cmd.CheckBundleArgument(argument,resultMessage);
427 EXPECT_EQ(result, false);
428 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
429 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0200 end";
430 }
431
432 /**
433 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0300
434 * @tc.name: CheckBundleArgument
435 * @tc.desc: Test whether CheckBundleArgument is called normally.
436 */
437 HWTEST_F(AccessibilityAbilityShellCommandTest,
438 AccessibilityAbilityShellCommand_CheckBundleArgument_0300, TestSize.Level1)
439 {
440 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0300 start";
441 AccessibilityCommandArgument argument;
442 argument.bundleArgumentNum = 1;
443 argument.bundleName[0] = '-';
444 std::string resultMessage;
445 char* argv[] = {
446 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
447 };
448 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
449 AccessibilityAbilityShellCommand cmd(argc, argv);
450 ErrCode result = cmd.CheckBundleArgument(argument,resultMessage);
451 EXPECT_EQ(result, false);
452 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
453 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0300 end";
454 }
455
456 /**
457 * @tc.number: AccessibilityAbilityShellCommand_CheckBundleArgument_0400
458 * @tc.name: CheckBundleArgument
459 * @tc.desc: Test whether CheckBundleArgument is called normally.
460 */
461 HWTEST_F(AccessibilityAbilityShellCommandTest,
462 AccessibilityAbilityShellCommand_CheckBundleArgument_0400, TestSize.Level1)
463 {
464 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0400 start";
465 AccessibilityCommandArgument argument;
466 argument.bundleArgumentNum = 1;
467 argument.bundleName = "bundle";
468 std::string resultMessage;
469 char* argv[] = {
470 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
471 };
472 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
473 AccessibilityAbilityShellCommand cmd(argc, argv);
474 ErrCode result = cmd.CheckBundleArgument(argument,resultMessage);
475 EXPECT_EQ(result, true);
476 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckBundleArgument_0400 end";
477 }
478
479 /**
480 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100
481 * @tc.name: CheckCapabilitiesArgument
482 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
483 */
484 HWTEST_F(AccessibilityAbilityShellCommandTest,
485 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100, TestSize.Level1)
486 {
487 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100 start";
488 AccessibilityCommandArgument argument;
489 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
490 argument.capabilityNamesArgumentNum = 0;
491 std::string resultMessage;
492 char* argv[] = {
493 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
494 };
495 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
496 AccessibilityAbilityShellCommand cmd(argc, argv);
497 ErrCode result = cmd.CheckCapabilitiesArgument(argument,installedAbilities,resultMessage);
498 EXPECT_EQ(result, false);
499 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
500 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0100 end";
501 }
502
503 /**
504 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200
505 * @tc.name: CheckCapabilitiesArgument
506 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
507 */
508 HWTEST_F(AccessibilityAbilityShellCommandTest,
509 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200, TestSize.Level1)
510 {
511 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200 start";
512 AccessibilityCommandArgument argument;
513 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
514 argument.capabilityNamesArgumentNum = 2;
515 std::string resultMessage;
516 char* argv[] = {
517 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
518 };
519 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
520 AccessibilityAbilityShellCommand cmd(argc, argv);
521 ErrCode result = cmd.CheckCapabilitiesArgument(argument,installedAbilities,resultMessage);
522 EXPECT_EQ(result, false);
523 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_DUPLICATE_ARGUMENT);
524 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0200 end";
525 }
526
527 /**
528 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300
529 * @tc.name: CheckCapabilitiesArgument
530 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
531 */
532 HWTEST_F(AccessibilityAbilityShellCommandTest,
533 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300, TestSize.Level1)
534 {
535 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300 start";
536 AccessibilityCommandArgument argument;
537 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
538 argument.capabilityNamesArgumentNum = 1;
539 argument.capabilityNames[0] = '-';
540 std::string resultMessage;
541 char* argv[] = {
542 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
543 };
544 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
545 AccessibilityAbilityShellCommand cmd(argc, argv);
546 ErrCode result = cmd.CheckCapabilitiesArgument(argument,installedAbilities,resultMessage);
547 EXPECT_EQ(result, false);
548 EXPECT_EQ(resultMessage, ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
549 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0300 end";
550 }
551
552 /**
553 * @tc.number: AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400
554 * @tc.name: CheckCapabilitiesArgument
555 * @tc.desc: Test whether CheckCapabilitiesArgument is called normally.
556 */
557 HWTEST_F(AccessibilityAbilityShellCommandTest,
558 AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400, TestSize.Level1)
559 {
560 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400 start";
561 AccessibilityCommandArgument argument;
562 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
563 argument.capabilityNamesArgumentNum = 1;
564 argument.capabilityNames = "capability";
565 std::string resultMessage;
566 char* argv[] = {
567 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
568 };
569 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
570 AccessibilityAbilityShellCommand cmd(argc, argv);
571 ErrCode result = cmd.CheckCapabilitiesArgument(argument,installedAbilities,resultMessage);
572 EXPECT_EQ(result, true);
573 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCapabilitiesArgument_0400 end";
574 }
575
576 /**
577 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100
578 * @tc.name: CheckSetCommandArgument
579 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(totalArgumentNum > 1)
580 */
581 HWTEST_F(AccessibilityAbilityShellCommandTest,
582 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100, TestSize.Level1)
583 {
584 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100 start";
585 AccessibilityCommandArgument argument;
586 argument.setArgumentNum = 2;
587 argument.unknownArgumentNum = 1;
588 std::string resultMessage;
589 char* argv[] = {
590 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
591 };
592 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
593 AccessibilityAbilityShellCommand cmd(argc, argv);
594 ErrCode result = cmd.CheckSetCommandArgument(argument,resultMessage);
595 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
596 EXPECT_EQ(resultMessage, ": and exist duplicated arguments.and exist unknown arguments ");
597 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0100 end";
598 }
599
600 /**
601 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200
602 * @tc.name: CheckSetCommandArgument
603 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(unknownArgumentNum > 0)
604 */
605 HWTEST_F(AccessibilityAbilityShellCommandTest,
606 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200, TestSize.Level1)
607 {
608 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200 start";
609 AccessibilityCommandArgument argument;
610 argument.setArgumentNum = 0;
611 argument.unknownArgumentNum = 1;
612 std::string resultMessage;
613 char* argv[] = {
614 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
615 };
616 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
617 AccessibilityAbilityShellCommand cmd(argc, argv);
618 ErrCode result = cmd.CheckSetCommandArgument(argument,resultMessage);
619 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
620 EXPECT_EQ(resultMessage, ": unknown arguments ");
621 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0200 end";
622 }
623
624 /**
625 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300
626 * @tc.name: CheckSetCommandArgument
627 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(setArgumentNum = 0)
628 */
629 HWTEST_F(AccessibilityAbilityShellCommandTest,
630 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300, TestSize.Level1)
631 {
632 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300 start";
633 AccessibilityCommandArgument argument;
634 argument.setArgumentNum = 0;
635 argument.unknownArgumentNum = 0;
636 std::string resultMessage;
637 char* argv[] = {
638 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
639 };
640 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
641 AccessibilityAbilityShellCommand cmd(argc, argv);
642 ErrCode result = cmd.CheckSetCommandArgument(argument,resultMessage);
643 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
644 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
645 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0300 end";
646 }
647
648 /**
649 * @tc.number: AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400
650 * @tc.name: CheckSetCommandArgument
651 * @tc.desc: Test whether CheckSetCommandArgument is called normally.(OHOS::ERR_OK)
652 */
653 HWTEST_F(AccessibilityAbilityShellCommandTest,
654 AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400, TestSize.Level1)
655 {
656 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400 start";
657 AccessibilityCommandArgument argument;
658 argument.setArgumentNum = 1;
659 argument.unknownArgumentNum = 0;
660 std::string resultMessage;
661 char* argv[] = {
662 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
663 };
664 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
665 AccessibilityAbilityShellCommand cmd(argc, argv);
666 ErrCode result = cmd.CheckSetCommandArgument(argument,resultMessage);
667 EXPECT_EQ(result, OHOS::ERR_OK);
668 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckSetCommandArgument_0400 end";
669 }
670
671 /**
672 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100
673 * @tc.name: MakeEnableCommandArgumentFromCmd
674 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(optind < 0)
675 */
676 HWTEST_F(AccessibilityAbilityShellCommandTest,
677 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100, TestSize.Level1)
678 {
679 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100 start";
680 AccessibilityCommandArgument argument;
681 optind = -1;
682 char* argv[] = {
683 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
684 };
685 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
686 AccessibilityAbilityShellCommand cmd(argc, argv);
687 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
688 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
689 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0100 end";
690 }
691
692 /**
693 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200
694 * @tc.name: MakeEnableCommandArgumentFromCmd
695 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option = -1)
696 */
697 HWTEST_F(AccessibilityAbilityShellCommandTest,
698 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200, TestSize.Level1)
699 {
700 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200 start";
701 AccessibilityCommandArgument argument;
702 char* argv[] = {
703 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
704 (char*)cmdenable_.c_str(),
705 (char*)" ",
706 };
707 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
708 AccessibilityAbilityShellCommand cmd(argc, argv);
709 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
710 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
711 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
712 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0200 end";
713 }
714
715 /**
716 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300
717 * @tc.name: MakeEnableCommandArgumentFromCmd
718 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -a requires a value)
719 */
720 HWTEST_F(AccessibilityAbilityShellCommandTest,
721 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300, TestSize.Level1)
722 {
723 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300 start";
724 AccessibilityCommandArgument argument;
725 char* argv[] = {
726 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
727 (char*)cmdenable_.c_str(),
728 (char*)"-a",
729 (char*)" ",
730 };
731 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
732 AccessibilityAbilityShellCommand cmd(argc, argv);
733 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
734 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
735 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
736 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0300 end";
737 }
738
739 /**
740 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400
741 * @tc.name: MakeEnableCommandArgumentFromCmd
742 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -b requires a value)
743 */
744 HWTEST_F(AccessibilityAbilityShellCommandTest,
745 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400, TestSize.Level1)
746 {
747 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400 start";
748 AccessibilityCommandArgument argument;
749 char* argv[] = {
750 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
751 (char*)cmdenable_.c_str(),
752 (char*)"-a",
753 (char*)"ability",
754 (char*)"-b",
755 (char*)" ",
756 };
757 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
758 AccessibilityAbilityShellCommand cmd(argc, argv);
759 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
760 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
761 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
762 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0400 end";
763 }
764
765 /**
766 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500
767 * @tc.name: MakeEnableCommandArgumentFromCmd
768 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.(option -c requires a value)
769 */
770 HWTEST_F(AccessibilityAbilityShellCommandTest,
771 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500, TestSize.Level1)
772 {
773 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500 start";
774 AccessibilityCommandArgument argument;
775 char* argv[] = {
776 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
777 (char*)cmdenable_.c_str(),
778 (char*)"-a",
779 (char*)"ability",
780 (char*)"-b",
781 (char*)"bundle",
782 (char*)"-c",
783 (char*)" ",
784 };
785 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
786 AccessibilityAbilityShellCommand cmd(argc, argv);
787 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
788 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
789 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT_VALUE);
790 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0500 end";
791 }
792
793 /**
794 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600
795 * @tc.name: MakeEnableCommandArgumentFromCmd
796 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.
797 * (CheckEnableCommandArgument = OHOS::ERR_INVALID_VALUE)
798 */
799 HWTEST_F(AccessibilityAbilityShellCommandTest,
800 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600 start";
803 AccessibilityCommandArgument argument;
804 char* argv[] = {
805 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
806 (char*)cmdenable_.c_str(),
807 (char*)"-a",
808 (char*)"ability",
809 (char*)"-b",
810 (char*)"bundle",
811 (char*)"-c",
812 (char*)"capabilities",
813 (char*)"-v",
814 (char*)"value",
815 (char*)" ",
816 };
817 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
818 AccessibilityAbilityShellCommand cmd(argc, argv);
819 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
820 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
821 EXPECT_EQ(cmd.resultReceiver_, "enable: " + ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT
822 + "and exist unknown arguments.-v ");
823 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0600 end";
824 }
825
826 /**
827 * @tc.number: AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700
828 * @tc.name: MakeEnableCommandArgumentFromCmd
829 * @tc.desc: Test whether MakeEnableCommandArgumentFromCmd is called normally.
830 * (CheckEnableCommandArgument = OHOS::ERR_INVALID_VALUE)
831 */
832 HWTEST_F(AccessibilityAbilityShellCommandTest,
833 AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700, TestSize.Level1)
834 {
835 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700 start";
836 AccessibilityCommandArgument argument;
837 char* argv[] = {
838 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
839 (char*)cmdenable_.c_str(),
840 (char*)"-a",
841 (char*)"ability",
842 (char*)"-b",
843 (char*)"bundle",
844 (char*)"-c",
845 (char*)"capabilities",
846 (char*)" ",
847 };
848 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
849 AccessibilityAbilityShellCommand cmd(argc, argv);
850 ErrCode result = cmd.MakeEnableCommandArgumentFromCmd(argument);
851 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
852 EXPECT_EQ(cmd.resultReceiver_, "enable: the auxiliary application bundle/ability"
853 + ACCESSIBILITY_ABILITY_NOT_FOUND);
854 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeEnableCommandArgumentFromCmd_0700 end";
855 }
856
857 /**
858 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0100
859 * @tc.name: CheckParamValidity
860 * @tc.desc: Test whether CheckParamValidity is called normally.(return true)
861 */
862 HWTEST_F(AccessibilityAbilityShellCommandTest,
863 AccessibilityAbilityShellCommand_CheckParamValidity_0100, TestSize.Level1)
864 {
865 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0100 start";
866 Accessibility::AccessibilityAbilityInitParams params;
867 params.name = "ability";
868 params.bundleName = "bundle";
869 Accessibility::AccessibilityAbilityInfo abilityInfo(params) ;
870 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
871 installedAbilities.push_back(abilityInfo);
872 AccessibilityCommandArgument argument;
873 argument.abilityArgumentNum = 1;
874 argument.abilityName = "ability";
875 argument.bundleArgumentNum = 1;
876 argument.bundleName = "bundle";
877 std::string resultMessage;
878 char* argv[] = {
879 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
880 };
881 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
882 AccessibilityAbilityShellCommand cmd(argc, argv);
883 bool result = cmd.CheckParamValidity(argument,installedAbilities,resultMessage);
884 EXPECT_EQ(result, true);
885 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0100 end";
886 }
887
888 /**
889 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0200
890 * @tc.name: CheckParamValidity
891 * @tc.desc: Test whether CheckParamValidity is called normally.(isExisted = false)
892 */
893 HWTEST_F(AccessibilityAbilityShellCommandTest,
894 AccessibilityAbilityShellCommand_CheckParamValidity_0200, TestSize.Level1)
895 {
896 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0200 start";
897 Accessibility::AccessibilityAbilityInitParams params;
898 params.name = "ability";
899 params.bundleName = "bundle";
900 Accessibility::AccessibilityAbilityInfo abilityInfo(params) ;
901 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
902 installedAbilities.push_back(abilityInfo);
903 AccessibilityCommandArgument argument;
904 std::string resultMessage;
905 char* argv[] = {
906 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
907 };
908 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
909 AccessibilityAbilityShellCommand cmd(argc, argv);
910 bool result = cmd.CheckParamValidity(argument,installedAbilities,resultMessage);
911 EXPECT_EQ(result, false);
912 EXPECT_EQ(resultMessage, "the auxiliary application " +
913 argument.bundleName + "/" + argument.abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
914 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0200 end";
915 }
916
917 /**
918 * @tc.number: AccessibilityAbilityShellCommand_CheckParamValidity_0300
919 * @tc.name: CheckParamValidity
920 * @tc.desc: Test whether CheckParamValidity is called normally.(invalidCapabilityNames.empty() = false)
921 */
922 HWTEST_F(AccessibilityAbilityShellCommandTest,
923 AccessibilityAbilityShellCommand_CheckParamValidity_0300, TestSize.Level1)
924 {
925 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0300 start";
926 Accessibility::AccessibilityAbilityInitParams params;
927 params.name = "ability";
928 params.bundleName = "bundle";
929 params.staticCapabilities = 1;
930 Accessibility::AccessibilityAbilityInfo abilityInfo(params) ;
931 std::vector<Accessibility::AccessibilityAbilityInfo> installedAbilities ;
932 installedAbilities.push_back(abilityInfo);
933 AccessibilityCommandArgument argument;
934 argument.abilityArgumentNum = 1;
935 argument.abilityName = "ability";
936 argument.bundleArgumentNum = 1;
937 argument.bundleName = "bundle";
938 argument.capabilityNamesArgumentNum = 1;
939 argument.capabilityNames = "capability";
940 std::string resultMessage;
941 char* argv[] = {
942 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
943 };
944 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
945 AccessibilityAbilityShellCommand cmd(argc, argv);
946 bool result = cmd.CheckParamValidity(argument,installedAbilities,resultMessage);
947 EXPECT_EQ(result, false);
948 EXPECT_EQ(resultMessage, "the capabilities capability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
949 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckParamValidity_0300 end";
950 }
951
952 /**
953 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100
954 * @tc.name: CheckEnableCommandArgument
955 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(totalArgumentNum > 3)
956 */
957 HWTEST_F(AccessibilityAbilityShellCommandTest,
958 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100, TestSize.Level1)
959 {
960 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100 start";
961 AccessibilityCommandArgument argument;
962 argument.abilityArgumentNum = 2;
963 argument.bundleArgumentNum = 1;
964 argument.capabilityNamesArgumentNum = 1;
965 argument.unknownArgumentNum = 1;
966 std::string resultMessage;
967 char* argv[] = {
968 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
969 };
970 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
971 AccessibilityAbilityShellCommand cmd(argc, argv);
972 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
973 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
974 EXPECT_EQ(resultMessage, ": and exist duplicated argumentsand exist unknown arguments.");
975 EXPECT_EQ( cmd.resultReceiver_, ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
976 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0100 end";
977 }
978
979 /**
980 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200
981 * @tc.name: CheckEnableCommandArgument
982 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(unknownArgumentNum > 0)
983 */
984 HWTEST_F(AccessibilityAbilityShellCommandTest,
985 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200, TestSize.Level1)
986 {
987 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200 start";
988 AccessibilityCommandArgument argument;
989 argument.unknownArgumentNum = 1;
990 std::string resultMessage;
991 char* argv[] = {
992 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
993 };
994 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
995 AccessibilityAbilityShellCommand cmd(argc, argv);
996 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
997 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
998 EXPECT_EQ(resultMessage, ": unknown arguments.");
999 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0200 end";
1000 }
1001
1002 /**
1003 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300
1004 * @tc.name: CheckEnableCommandArgument
1005 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckAbilityArgument = false)
1006 */
1007 HWTEST_F(AccessibilityAbilityShellCommandTest,
1008 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300, TestSize.Level1)
1009 {
1010 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300 start";
1011 AccessibilityCommandArgument argument;
1012 argument.abilityArgumentNum = 0;
1013 argument.abilityName = "ability";
1014 argument.bundleArgumentNum = 1;
1015 argument.bundleName = "bundle";
1016 argument.capabilityNamesArgumentNum = 1;
1017 argument.capabilityNames = "capabilities";
1018 argument.unknownArgumentNum = 0;
1019 std::string resultMessage;
1020 char* argv[] = {
1021 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1022 };
1023 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1024 AccessibilityAbilityShellCommand cmd(argc, argv);
1025 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
1026 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1027 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
1028 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0300 end";
1029 }
1030
1031 /**
1032 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400
1033 * @tc.name: CheckEnableCommandArgument
1034 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckBundleArgument = false)
1035 */
1036 HWTEST_F(AccessibilityAbilityShellCommandTest,
1037 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400, TestSize.Level1)
1038 {
1039 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400 start";
1040 AccessibilityCommandArgument argument;
1041 argument.abilityArgumentNum = 1;
1042 argument.abilityName = "ability";
1043 argument.bundleArgumentNum = 0;
1044 argument.bundleName = "bundle";
1045 argument.capabilityNamesArgumentNum = 1;
1046 argument.capabilityNames = "capabilities";
1047 argument.unknownArgumentNum = 0;
1048 std::string resultMessage;
1049 char* argv[] = {
1050 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1051 };
1052 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1053 AccessibilityAbilityShellCommand cmd(argc, argv);
1054 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
1055 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1056 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
1057 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0400 end";
1058 }
1059
1060 /**
1061 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500
1062 * @tc.name: CheckEnableCommandArgument
1063 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckCapabilitiesArgument = false)
1064 */
1065 HWTEST_F(AccessibilityAbilityShellCommandTest,
1066 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500, TestSize.Level1)
1067 {
1068 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500 start";
1069 AccessibilityCommandArgument argument;
1070 argument.abilityArgumentNum = 1;
1071 argument.abilityName = "ability";
1072 argument.bundleArgumentNum = 1;
1073 argument.bundleName = "bundle";
1074 argument.capabilityNamesArgumentNum = 0;
1075 argument.capabilityNames = "capabilities";
1076 argument.unknownArgumentNum = 0;
1077 std::string resultMessage;
1078 char* argv[] = {
1079 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1080 };
1081 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1082 AccessibilityAbilityShellCommand cmd(argc, argv);
1083 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
1084 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1085 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_CAPABILITIES_ARGUMENT);
1086 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0500 end";
1087 }
1088
1089 /**
1090 * @tc.number: AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600
1091 * @tc.name: CheckEnableCommandArgument
1092 * @tc.desc: Test whether CheckEnableCommandArgument is called normally.(CheckParamValidity = false)
1093 */
1094 HWTEST_F(AccessibilityAbilityShellCommandTest,
1095 AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600, TestSize.Level1)
1096 {
1097 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600 start";
1098 AccessibilityCommandArgument argument;
1099 argument.abilityArgumentNum = 1;
1100 argument.abilityName = "ability";
1101 argument.bundleArgumentNum = 1;
1102 argument.bundleName = "bundle";
1103 argument.capabilityNamesArgumentNum = 1;
1104 argument.capabilityNames = "capabilities";
1105 argument.unknownArgumentNum = 0;
1106 std::string resultMessage;
1107 char* argv[] = {
1108 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1109 };
1110 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1111 AccessibilityAbilityShellCommand cmd(argc, argv);
1112 ErrCode result = cmd.CheckEnableCommandArgument(argument,resultMessage);
1113 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1114 EXPECT_EQ(resultMessage, ": the auxiliary application bundle/ability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
1115 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckEnableCommandArgument_0600 end";
1116 }
1117
1118 /**
1119 * @tc.number: AccessibilityAbilityShellCommand_RunAsEnableAbility_0100
1120 * @tc.name: RunAsEnableAbility
1121 * @tc.desc: Test whether RunAsEnableAbility is called normally.
1122 * (MakeEnableCommandArgumentFromCmd = false)
1123 */
1124 HWTEST_F(AccessibilityAbilityShellCommandTest,
1125 AccessibilityAbilityShellCommand_RunAsEnableAbility_0100, TestSize.Level1)
1126 {
1127 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsEnableAbility_0100 start";
1128 char* argv[] = {
1129 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1130 };
1131 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1132 AccessibilityAbilityShellCommand cmd(argc, argv);
1133 ErrCode result = cmd.RunAsEnableAbility();
1134 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1135 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_ENABLE_ABILITY);
1136 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsEnableAbility_0100 end";
1137 }
1138
1139 /**
1140 * @tc.number: AccessibilityAbilityShellCommand_RunAsDisableAbility_0100
1141 * @tc.name: RunAsDisableAbility
1142 * @tc.desc: Test whether RunAsDisableAbility is called normally.
1143 * (MakeDisableCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1144 */
1145 HWTEST_F(AccessibilityAbilityShellCommandTest,
1146 AccessibilityAbilityShellCommand_RunAsDisableAbility_0100, TestSize.Level1)
1147 {
1148 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsDisableAbility_0100 start";
1149 char* argv[] = {
1150 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1151 };
1152 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1153 AccessibilityAbilityShellCommand cmd(argc, argv);
1154 ErrCode result = cmd.RunAsDisableAbility();
1155 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1156 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_DISABLE_ABILITY);
1157 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsDisableAbility_0100 end";
1158 }
1159
1160 /**
1161 * @tc.number: AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100
1162 * @tc.name: RunAsGetEnabledAbilities
1163 * @tc.desc: Test whether RunAsGetEnabledAbilities is called normally.(enabledAbilities is empty)
1164 */
1165 HWTEST_F(AccessibilityAbilityShellCommandTest,
1166 AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100, TestSize.Level1)
1167 {
1168 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100 start";
1169 char* argv[] = {
1170 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1171 };
1172 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1173 AccessibilityAbilityShellCommand cmd(argc, argv);
1174 ErrCode result = cmd.RunAsGetEnabledAbilities();
1175 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1176 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetEnabledAbilities_0100 end";
1177 }
1178
1179 /**
1180 * @tc.number: AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100
1181 * @tc.name: RunAsGetInstalledAbilities
1182 * @tc.desc: Test whether RunAsGetInstalledAbilities is called normally.(installedAbilities is empty)
1183 */
1184 HWTEST_F(AccessibilityAbilityShellCommandTest,
1185 AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100, TestSize.Level1)
1186 {
1187 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100 start";
1188 char* argv[] = {
1189 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1190 };
1191 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1192 AccessibilityAbilityShellCommand cmd(argc, argv);
1193 cmd.abilityClientPtr_ = nullptr;
1194 ErrCode result = cmd.RunAsGetInstalledAbilities();
1195 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1196 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100 end";
1197 }
1198
1199 /**
1200 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100
1201 * @tc.name: RunAsSetScreenMagnificationState
1202 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.
1203 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1204 */
1205 HWTEST_F(AccessibilityAbilityShellCommandTest,
1206 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100, TestSize.Level1)
1207 {
1208 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 start";
1209 char* argv[] = {
1210 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1211 };
1212 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1213 AccessibilityAbilityShellCommand cmd(argc, argv);
1214 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1215 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1216 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1217 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 end";
1218 }
1219
1220 /**
1221 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200
1222 * @tc.name: RunAsSetScreenMagnificationState
1223 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(OHOS::ERR_OK)
1224 */
1225 HWTEST_F(AccessibilityAbilityShellCommandTest,
1226 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200, TestSize.Level1)
1227 {
1228 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1229 char* argv[] = {
1230 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1231 (char*)cmdsetShortKeyState_.c_str(),
1232 (char*)"-v",
1233 (char*)"0",
1234 (char*)" ",
1235 };
1236 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1237 AccessibilityAbilityShellCommand cmd(argc, argv);
1238 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1239 EXPECT_EQ(result, OHOS::ERR_OK);
1240 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n");
1241 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 end";
1242 }
1243
1244 /**
1245 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300
1246 * @tc.name: RunAsSetScreenMagnificationState
1247 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(value is invalid)
1248 */
1249 HWTEST_F(AccessibilityAbilityShellCommandTest,
1250 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300, TestSize.Level1)
1251 {
1252 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1253 char* argv[] = {
1254 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1255 (char*)cmdsetShortKeyState_.c_str(),
1256 (char*)"-v",
1257 (char*)"2",
1258 (char*)" ",
1259 };
1260 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1261 AccessibilityAbilityShellCommand cmd(argc, argv);
1262 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1263 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1264 EXPECT_EQ(cmd.resultReceiver_, "setScreenMagnificationState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1265 "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1266 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300 end";
1267 }
1268
1269 /**
1270 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100
1271 * @tc.name: RunAsSetShortKeyState
1272 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1273 */
1274 HWTEST_F(AccessibilityAbilityShellCommandTest,
1275 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100, TestSize.Level1)
1276 {
1277 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 start";
1278 char* argv[] = {
1279 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1280 (char*)cmdsetShortKeyState_.c_str(),
1281 (char*)"-v",
1282 (char*)"0",
1283 (char*)" ",
1284 };
1285 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1286 AccessibilityAbilityShellCommand cmd(argc, argv);
1287 ErrCode result = cmd.RunAsSetShortKeyState();
1288 EXPECT_EQ(result, OHOS::ERR_OK);
1289 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1290 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 end";
1291 }
1292
1293 /**
1294 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200
1295 * @tc.name: RunAsSetShortKeyState
1296 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1297 */
1298 HWTEST_F(AccessibilityAbilityShellCommandTest,
1299 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200, TestSize.Level1)
1300 {
1301 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 start";
1302 char* argv[] = {
1303 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1304 (char*)cmdsetShortKeyState_.c_str(),
1305 (char*)"-v",
1306 (char*)"1",
1307 (char*)" ",
1308 };
1309 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1310 AccessibilityAbilityShellCommand cmd(argc, argv);
1311 ErrCode result = cmd.RunAsSetShortKeyState();
1312 EXPECT_EQ(result, OHOS::ERR_OK);
1313 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1314 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 end";
1315 }
1316
1317 /**
1318 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300
1319 * @tc.name: RunAsSetShortKeyState
1320 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(value is invalid)
1321 */
1322 HWTEST_F(AccessibilityAbilityShellCommandTest,
1323 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300, TestSize.Level1)
1324 {
1325 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 start";
1326 char* argv[] = {
1327 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1328 (char*)cmdsetShortKeyState_.c_str(),
1329 (char*)"-v",
1330 (char*)"2",
1331 (char*)" ",
1332 };
1333 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1334 AccessibilityAbilityShellCommand cmd(argc, argv);
1335 ErrCode result = cmd.RunAsSetShortKeyState();
1336 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1337 EXPECT_EQ(cmd.resultReceiver_, "setShortKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1338 "\n" + ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1339 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 end";
1340 }
1341
1342 /**
1343 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400
1344 * @tc.name: RunAsSetShortKeyState
1345 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.
1346 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1347 */
1348 HWTEST_F(AccessibilityAbilityShellCommandTest,
1349 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400, TestSize.Level1)
1350 {
1351 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 start";
1352 char* argv[] = {
1353 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1354 };
1355 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1356 AccessibilityAbilityShellCommand cmd(argc, argv);
1357 ErrCode result = cmd.RunAsSetShortKeyState();
1358 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1359 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1360 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 end";
1361 }
1362
1363 /**
1364 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100
1365 * @tc.name: RunAsSetMouseKeyState
1366 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1367 */
1368 HWTEST_F(AccessibilityAbilityShellCommandTest,
1369 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100, TestSize.Level1)
1370 {
1371 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 start";
1372 char* argv[] = {
1373 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1374 (char*)cmdsetMouseKeyState_.c_str(),
1375 (char*)"-v",
1376 (char*)"0",
1377 (char*)" ",
1378 };
1379 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1380 AccessibilityAbilityShellCommand cmd(argc, argv);
1381 ErrCode result = cmd.RunAsSetMouseKeyState();
1382 EXPECT_EQ(result, OHOS::ERR_OK);
1383 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1384 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 end";
1385 }
1386
1387 /**
1388 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200
1389 * @tc.name: RunAsSetMouseKeyState
1390 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1391 */
1392 HWTEST_F(AccessibilityAbilityShellCommandTest,
1393 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200, TestSize.Level1)
1394 {
1395 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 start";
1396 char* argv[] = {
1397 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1398 (char*)cmdsetMouseKeyState_.c_str(),
1399 (char*)"-v",
1400 (char*)"1",
1401 (char*)" ",
1402 };
1403 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1404 AccessibilityAbilityShellCommand cmd(argc, argv);
1405 ErrCode result = cmd.RunAsSetMouseKeyState();
1406 EXPECT_EQ(result, OHOS::ERR_OK);
1407 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1408 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 end";
1409 }
1410
1411 /**
1412 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300
1413 * @tc.name: RunAsSetMouseKeyState
1414 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(value is invalid)
1415 */
1416 HWTEST_F(AccessibilityAbilityShellCommandTest,
1417 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300, TestSize.Level1)
1418 {
1419 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 start";
1420 char* argv[] = {
1421 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1422 (char*)cmdsetMouseKeyState_.c_str(),
1423 (char*)"-v",
1424 (char*)"2",
1425 (char*)" ",
1426 };
1427 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1428 AccessibilityAbilityShellCommand cmd(argc, argv);
1429 ErrCode result = cmd.RunAsSetMouseKeyState();
1430 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1431 EXPECT_EQ(cmd.resultReceiver_, "setMouseKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1432 "\n" + ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1433 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 end";
1434 }
1435
1436 /**
1437 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400
1438 * @tc.name: RunAsSetMouseKeyState
1439 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.
1440 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1441 */
1442 HWTEST_F(AccessibilityAbilityShellCommandTest,
1443 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400, TestSize.Level1)
1444 {
1445 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 start";
1446 char* argv[] = {
1447 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1448 };
1449 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1450 AccessibilityAbilityShellCommand cmd(argc, argv);
1451 ErrCode result = cmd.RunAsSetMouseKeyState();
1452 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1453 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1454 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 end";
1455 }
1456
1457 /**
1458 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100
1459 * @tc.name: RunAsSetCaptionState
1460 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1461 */
1462 HWTEST_F(AccessibilityAbilityShellCommandTest,
1463 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100, TestSize.Level1)
1464 {
1465 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 start";
1466 char* argv[] = {
1467 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1468 (char*)cmdsetCaptionState_.c_str(),
1469 (char*)"-v",
1470 (char*)"0",
1471 (char*)" ",
1472 };
1473 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1474 AccessibilityAbilityShellCommand cmd(argc, argv);
1475 ErrCode result = cmd.RunAsSetCaptionState();
1476 EXPECT_EQ(result, OHOS::ERR_OK);
1477 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1478 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 end";
1479 }
1480
1481 /**
1482 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200
1483 * @tc.name: RunAsSetCaptionState
1484 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1485 */
1486 HWTEST_F(AccessibilityAbilityShellCommandTest,
1487 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200, TestSize.Level1)
1488 {
1489 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 start";
1490 char* argv[] = {
1491 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1492 (char*)cmdsetCaptionState_.c_str(),
1493 (char*)"-v",
1494 (char*)"1",
1495 (char*)" ",
1496 };
1497 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1498
1499 AccessibilityAbilityShellCommand cmd(argc, argv);
1500 ErrCode result = cmd.RunAsSetCaptionState();
1501 EXPECT_EQ(result, OHOS::ERR_OK);
1502 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1503 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 end";
1504 }
1505
1506 /**
1507 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300
1508 * @tc.name: RunAsSetCaptionState
1509 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(value is invalid)
1510 */
1511 HWTEST_F(AccessibilityAbilityShellCommandTest,
1512 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300, TestSize.Level1)
1513 {
1514 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 start";
1515 char* argv[] = {
1516 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1517 (char*)cmdsetCaptionState_.c_str(),
1518 (char*)"-v",
1519 (char*)"2",
1520 (char*)" ",
1521 };
1522 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1523 AccessibilityAbilityShellCommand cmd(argc, argv);
1524 ErrCode result = cmd.RunAsSetCaptionState();
1525 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1526 EXPECT_EQ(cmd.resultReceiver_, "setCaptionState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1527 "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1528 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 end";
1529 }
1530
1531 /**
1532 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400
1533 * @tc.name: RunAsSetCaptionState
1534 * @tc.desc: Test whether RunAsSetCaptionState is called normally.
1535 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1536 */
1537 HWTEST_F(AccessibilityAbilityShellCommandTest,
1538 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400, TestSize.Level1)
1539 {
1540 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 start";
1541 char* argv[] = {
1542 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1543 };
1544 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1545 AccessibilityAbilityShellCommand cmd(argc, argv);
1546 ErrCode result = cmd.RunAsSetCaptionState();
1547 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1548 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1549 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 end";
1550 }
1551
1552 /**
1553 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100
1554 * @tc.name: RunAsSetMouseAutoClick
1555 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1556 */
1557 HWTEST_F(AccessibilityAbilityShellCommandTest,
1558 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100, TestSize.Level1)
1559 {
1560 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 start";
1561 char* argv[] = {
1562 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1563 (char*)cmdssetMouseAutoClick_.c_str(),
1564 (char*)"-v",
1565 (char*)"1000",
1566 (char*)" ",
1567 };
1568 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1569 AccessibilityAbilityShellCommand cmd(argc, argv);
1570 ErrCode result = cmd.RunAsSetMouseAutoClick();
1571 EXPECT_EQ(result, OHOS::ERR_OK);
1572 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1573 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 end";
1574 }
1575
1576 /**
1577 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200
1578 * @tc.name: RunAsSetMouseAutoClick
1579 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1580 */
1581 HWTEST_F(AccessibilityAbilityShellCommandTest,
1582 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200, TestSize.Level1)
1583 {
1584 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 start";
1585 char* argv[] = {
1586 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1587 (char*)cmdssetMouseAutoClick_.c_str(),
1588 (char*)"-v",
1589 (char*)"5000",
1590 (char*)" ",
1591 };
1592 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1593 AccessibilityAbilityShellCommand cmd(argc, argv);
1594 ErrCode result = cmd.RunAsSetMouseAutoClick();
1595 EXPECT_EQ(result, OHOS::ERR_OK);
1596 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1597 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 end";
1598 }
1599
1600 /**
1601 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300
1602 * @tc.name: RunAsSetMouseAutoClick
1603 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(value is invalid)
1604 */
1605 HWTEST_F(AccessibilityAbilityShellCommandTest,
1606 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300, TestSize.Level1)
1607 {
1608 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 start";
1609 char* argv[] = {
1610 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1611 (char*)cmdssetMouseAutoClick_.c_str(),
1612 (char*)"-v",
1613 (char*)"5001",
1614 (char*)" ",
1615 };
1616 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1617 AccessibilityAbilityShellCommand cmd(argc, argv);
1618 ErrCode result = cmd.RunAsSetMouseAutoClick();
1619 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1620 EXPECT_EQ(cmd.resultReceiver_, "setMouseAutoClick: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1621 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1622 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 end";
1623 }
1624
1625 /**
1626 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400
1627 * @tc.name: RunAsSetMouseAutoClick
1628 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.
1629 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1630 */
1631 HWTEST_F(AccessibilityAbilityShellCommandTest,
1632 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400, TestSize.Level1)
1633 {
1634 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 start";
1635 char* argv[] = {
1636 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1637 };
1638 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1639 AccessibilityAbilityShellCommand cmd(argc, argv);
1640 ErrCode result = cmd.RunAsSetMouseAutoClick();
1641 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1642 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1643 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 end";
1644 }
1645
1646 /**
1647 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100
1648 * @tc.name: RunAsSetShortKeyTarget
1649 * @tc.desc: Test whether RunAsSetShortKeyTarget is called normally.
1650 * (MakeSetShortKeyTargetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1651 */
1652 HWTEST_F(AccessibilityAbilityShellCommandTest,
1653 AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100, TestSize.Level1)
1654 {
1655 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 start";
1656 char* argv[] = {
1657 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1658 };
1659 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1660 AccessibilityAbilityShellCommand cmd(argc, argv);
1661 ErrCode result = cmd.RunAsSetShortKeyTarget();
1662 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1663 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET);
1664 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 end";
1665 }
1666
1667 /**
1668 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100
1669 * @tc.name: RunAsSetHighContrastTextState
1670 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1671 */
1672 HWTEST_F(AccessibilityAbilityShellCommandTest,
1673 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100, TestSize.Level1)
1674 {
1675 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 start";
1676 char* argv[] = {
1677 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1678 (char*)cmdsetHighContrastTextState_.c_str(),
1679 (char*)"-v",
1680 (char*)"0",
1681 (char*)" ",
1682 };
1683 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1684 AccessibilityAbilityShellCommand cmd(argc, argv);
1685 ErrCode result = cmd.RunAsSetHighContrastTextState();
1686 EXPECT_EQ(result, OHOS::ERR_OK);
1687 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1688 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 end";
1689 }
1690
1691 /**
1692 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200
1693 * @tc.name: RunAsSetHighContrastTextState
1694 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1695 */
1696 HWTEST_F(AccessibilityAbilityShellCommandTest,
1697 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200, TestSize.Level1)
1698 {
1699 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 start";
1700 char* argv[] = {
1701 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1702 (char*)cmdsetHighContrastTextState_.c_str(),
1703 (char*)"-v",
1704 (char*)"1",
1705 (char*)" ",
1706 };
1707 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1708 AccessibilityAbilityShellCommand cmd(argc, argv);
1709 ErrCode result = cmd.RunAsSetHighContrastTextState();
1710 EXPECT_EQ(result, OHOS::ERR_OK);
1711 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1712 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 end";
1713 }
1714
1715 /**
1716 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300
1717 * @tc.name: RunAsSetHighContrastTextState
1718 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(value is invalid)
1719 */
1720 HWTEST_F(AccessibilityAbilityShellCommandTest,
1721 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300, TestSize.Level1)
1722 {
1723 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 start";
1724 char* argv[] = {
1725 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1726 (char*)cmdsetHighContrastTextState_.c_str(),
1727 (char*)"-v",
1728 (char*)"2",
1729 (char*)" ",
1730 };
1731 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1732 AccessibilityAbilityShellCommand cmd(argc, argv);
1733 ErrCode result = cmd.RunAsSetHighContrastTextState();
1734 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1735 EXPECT_EQ(cmd.resultReceiver_, "setHighContrastTextState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1736 "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1737 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 end";
1738 }
1739
1740 /**
1741 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400
1742 * @tc.name: RunAsSetHighContrastTextState
1743 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.
1744 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1745 */
1746 HWTEST_F(AccessibilityAbilityShellCommandTest,
1747 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400, TestSize.Level1)
1748 {
1749 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 start";
1750 char* argv[] = {
1751 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1752 };
1753 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1754 AccessibilityAbilityShellCommand cmd(argc, argv);
1755 ErrCode result = cmd.RunAsSetHighContrastTextState();
1756 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1757 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1758 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 end";
1759 }
1760
1761 /**
1762 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100
1763 * @tc.name: RunAsSetInvertColorState
1764 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1765 */
1766 HWTEST_F(AccessibilityAbilityShellCommandTest,
1767 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100, TestSize.Level1)
1768 {
1769 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 start";
1770 char* argv[] = {
1771 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1772 (char*)cmdsetInvertColorState_.c_str(),
1773 (char*)"-v",
1774 (char*)"0",
1775 (char*)" ",
1776 };
1777 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1778 AccessibilityAbilityShellCommand cmd(argc, argv);
1779 ErrCode result = cmd.RunAsSetInvertColorState();
1780 EXPECT_EQ(result, OHOS::ERR_OK);
1781 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1782 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 end";
1783 }
1784
1785 /**
1786 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200
1787 * @tc.name: RunAsSetInvertColorState
1788 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1789 */
1790 HWTEST_F(AccessibilityAbilityShellCommandTest,
1791 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200, TestSize.Level1)
1792 {
1793 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 start";
1794 char* argv[] = {
1795 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1796 (char*)cmdsetInvertColorState_.c_str(),
1797 (char*)"-v",
1798 (char*)"1",
1799 (char*)" ",
1800 };
1801 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1802 AccessibilityAbilityShellCommand cmd(argc, argv);
1803 ErrCode result = cmd.RunAsSetInvertColorState();
1804 EXPECT_EQ(result, OHOS::ERR_OK);
1805 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1806 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 end";
1807 }
1808
1809 /**
1810 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300
1811 * @tc.name: RunAsSetInvertColorState
1812 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(value is invalid)
1813 */
1814 HWTEST_F(AccessibilityAbilityShellCommandTest,
1815 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300, TestSize.Level1)
1816 {
1817 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 start";
1818 char* argv[] = {
1819 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1820 (char*)cmdsetInvertColorState_.c_str(),
1821 (char*)"-v",
1822 (char*)"2",
1823 (char*)" ",
1824 };
1825 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1826 AccessibilityAbilityShellCommand cmd(argc, argv);
1827 ErrCode result = cmd.RunAsSetInvertColorState();
1828 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1829 EXPECT_EQ(cmd.resultReceiver_, "setInvertColorState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1830 "\n" + ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1831 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 end";
1832 }
1833
1834 /**
1835 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400
1836 * @tc.name: RunAsSetInvertColorState
1837 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.
1838 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1839 */
1840 HWTEST_F(AccessibilityAbilityShellCommandTest,
1841 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400, TestSize.Level1)
1842 {
1843 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 start";
1844 char* argv[] = {
1845 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1846 };
1847 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1848 AccessibilityAbilityShellCommand cmd(argc, argv);
1849 ErrCode result = cmd.RunAsSetInvertColorState();
1850 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1851 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1852 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 end";
1853 }
1854
1855 /**
1856 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100
1857 * @tc.name: RunAsSetDaltonizationColorFilter
1858 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1859 */
1860 HWTEST_F(AccessibilityAbilityShellCommandTest,
1861 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100, TestSize.Level1)
1862 {
1863 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 start";
1864 char* argv[] = {
1865 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1866 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1867 (char*)"-v",
1868 (char*)"0",
1869 (char*)" ",
1870 };
1871 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1872 AccessibilityAbilityShellCommand cmd(argc, argv);
1873 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1874 EXPECT_EQ(result, OHOS::ERR_OK);
1875 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1876 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 end";
1877 }
1878
1879 /**
1880 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200
1881 * @tc.name: RunAsSetDaltonizationColorFilter
1882 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1883 */
1884 HWTEST_F(AccessibilityAbilityShellCommandTest,
1885 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200, TestSize.Level1)
1886 {
1887 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 start";
1888 char* argv[] = {
1889 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1890 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1891 (char*)"-v",
1892 (char*)"1",
1893 (char*)" ",
1894 };
1895 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1896 AccessibilityAbilityShellCommand cmd(argc, argv);
1897 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1898 EXPECT_EQ(result, OHOS::ERR_OK);
1899 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1900 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 end";
1901 }
1902
1903 /**
1904 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300
1905 * @tc.name: RunAsSetDaltonizationColorFilter
1906 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1907 */
1908 HWTEST_F(AccessibilityAbilityShellCommandTest,
1909 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300, TestSize.Level1)
1910 {
1911 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 start";
1912 char* argv[] = {
1913 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1914 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1915 (char*)"-v",
1916 (char*)"2",
1917 (char*)" ",
1918 };
1919 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1920 AccessibilityAbilityShellCommand cmd(argc, argv);
1921 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1922 EXPECT_EQ(result, OHOS::ERR_OK);
1923 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1924 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 end";
1925 }
1926
1927 /**
1928 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400
1929 * @tc.name: RunAsSetDaltonizationColorFilter
1930 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1931 */
1932 HWTEST_F(AccessibilityAbilityShellCommandTest,
1933 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400, TestSize.Level1)
1934 {
1935 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 start";
1936 char* argv[] = {
1937 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1938 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1939 (char*)"-v",
1940 (char*)"3",
1941 (char*)" ",
1942 };
1943 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1944 AccessibilityAbilityShellCommand cmd(argc, argv);
1945 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1946 EXPECT_EQ(result, OHOS::ERR_OK);
1947 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1948 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 end";
1949 }
1950
1951 /**
1952 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500
1953 * @tc.name: RunAsSetDaltonizationColorFilter
1954 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(value is invalid)
1955 */
1956 HWTEST_F(AccessibilityAbilityShellCommandTest,
1957 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500, TestSize.Level1)
1958 {
1959 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 start";
1960 char* argv[] = {
1961 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1962 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1963 (char*)"-v",
1964 (char*)"4",
1965 (char*)" ",
1966 };
1967 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1968 AccessibilityAbilityShellCommand cmd(argc, argv);
1969 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1970 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1971 EXPECT_EQ(cmd.resultReceiver_, "setDaltonizationColorFilter: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1972 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 end";
1973 }
1974
1975 /**
1976 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600
1977 * @tc.name: RunAsSetDaltonizationColorFilter
1978 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.
1979 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1980 */
1981 HWTEST_F(AccessibilityAbilityShellCommandTest,
1982 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600, TestSize.Level1)
1983 {
1984 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 start";
1985 char* argv[] = {
1986 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1987 };
1988 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1989 AccessibilityAbilityShellCommand cmd(argc, argv);
1990 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1991 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1992 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER);
1993 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 end";
1994 }
1995
1996 /**
1997 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100
1998 * @tc.name: RunAsSetContentTimeout
1999 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
2000 */
2001 HWTEST_F(AccessibilityAbilityShellCommandTest,
2002 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100, TestSize.Level1)
2003 {
2004 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 start";
2005 char* argv[] = {
2006 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2007 (char*)cmdsetContentTimeout_.c_str(),
2008 (char*)"-v",
2009 (char*)"0",
2010 (char*)" ",
2011 };
2012 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2013 AccessibilityAbilityShellCommand cmd(argc, argv);
2014 ErrCode result = cmd.RunAsSetContentTimeout();
2015 EXPECT_EQ(result, OHOS::ERR_OK);
2016 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
2017 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 end";
2018 }
2019
2020 /**
2021 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200
2022 * @tc.name: RunAsSetContentTimeout
2023 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
2024 */
2025 HWTEST_F(AccessibilityAbilityShellCommandTest,
2026 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200, TestSize.Level1)
2027 {
2028 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 start";
2029 char* argv[] = {
2030 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2031 (char*)cmdsetContentTimeout_.c_str(),
2032 (char*)"-v",
2033 (char*)"5000",
2034 (char*)" ",
2035 };
2036 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2037
2038 AccessibilityAbilityShellCommand cmd(argc, argv);
2039 ErrCode result = cmd.RunAsSetContentTimeout();
2040 EXPECT_EQ(result, OHOS::ERR_OK);
2041 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
2042 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 end";
2043 }
2044
2045 /**
2046 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300
2047 * @tc.name: RunAsSetContentTimeout
2048 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(value is invalid)
2049 */
2050 HWTEST_F(AccessibilityAbilityShellCommandTest,
2051 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300, TestSize.Level1)
2052 {
2053 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 start";
2054 char* argv[] = {
2055 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2056 (char*)cmdsetContentTimeout_.c_str(),
2057 (char*)"-v",
2058 (char*)"5001",
2059 (char*)" ",
2060 };
2061 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2062 AccessibilityAbilityShellCommand cmd(argc, argv);
2063 ErrCode result = cmd.RunAsSetContentTimeout();
2064 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2065 EXPECT_EQ(cmd.resultReceiver_, "setContentTimeout: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2066 "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
2067 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 end";
2068 }
2069
2070 /**
2071 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400
2072 * @tc.name: RunAsSetContentTimeout
2073 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.
2074 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2075 */
2076 HWTEST_F(AccessibilityAbilityShellCommandTest,
2077 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400, TestSize.Level1)
2078 {
2079 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 start";
2080 char* argv[] = {
2081 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2082 };
2083 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2084 AccessibilityAbilityShellCommand cmd(argc, argv);
2085 ErrCode result = cmd.RunAsSetContentTimeout();
2086 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2087 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
2088 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 end";
2089 }
2090
2091 /**
2092 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100
2093 * @tc.name: RunAsSetAnimationOffState
2094 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
2095 */
2096 HWTEST_F(AccessibilityAbilityShellCommandTest,
2097 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100, TestSize.Level1)
2098 {
2099 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 start";
2100 char* argv[] = {
2101 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2102 (char*)cmdsetAnimationOffState_.c_str(),
2103 (char*)"-v",
2104 (char*)"0",
2105 (char*)" ",
2106 };
2107 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2108 AccessibilityAbilityShellCommand cmd(argc, argv);
2109 ErrCode result = cmd.RunAsSetAnimationOffState();
2110 EXPECT_EQ(result, OHOS::ERR_OK);
2111 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
2112 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 end";
2113 }
2114
2115 /**
2116 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200
2117 * @tc.name: RunAsSetAnimationOffState
2118 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
2119 */
2120 HWTEST_F(AccessibilityAbilityShellCommandTest,
2121 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200, TestSize.Level1)
2122 {
2123 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 start";
2124 char* argv[] = {
2125 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2126 (char*)cmdsetAnimationOffState_.c_str(),
2127 (char*)"-v",
2128 (char*)"1",
2129 (char*)" ",
2130 };
2131 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2132 AccessibilityAbilityShellCommand cmd(argc, argv);
2133 ErrCode result = cmd.RunAsSetAnimationOffState();
2134 EXPECT_EQ(result, OHOS::ERR_OK);
2135 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
2136 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 end";
2137 }
2138
2139 /**
2140 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300
2141 * @tc.name: RunAsSetAnimationOffState
2142 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(value is invalid)
2143 */
2144 HWTEST_F(AccessibilityAbilityShellCommandTest,
2145 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300, TestSize.Level1)
2146 {
2147 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 start";
2148 char* argv[] = {
2149 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2150 (char*)cmdsetAnimationOffState_.c_str(),
2151 (char*)"-v",
2152 (char*)"2",
2153 (char*)" ",
2154 };
2155 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2156 AccessibilityAbilityShellCommand cmd(argc, argv);
2157 ErrCode result = cmd.RunAsSetAnimationOffState();
2158 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2159 EXPECT_EQ(cmd.resultReceiver_, "setAnimationOffState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2160 "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2161 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 end";
2162 }
2163
2164 /**
2165 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400
2166 * @tc.name: RunAsSetAnimationOffState
2167 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.
2168 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2169 */
2170 HWTEST_F(AccessibilityAbilityShellCommandTest,
2171 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400, TestSize.Level1)
2172 {
2173 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 start";
2174 char* argv[] = {
2175 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2176 };
2177 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2178 AccessibilityAbilityShellCommand cmd(argc, argv);
2179 ErrCode result = cmd.RunAsSetAnimationOffState();
2180 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2181 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2182 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 end";
2183 }
2184
2185 /**
2186 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100
2187 * @tc.name: RunAsSetBrightnessDiscount
2188 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2189 * 2.ret is not Accessibility::RET_OK
2190 */
2191 HWTEST_F(AccessibilityAbilityShellCommandTest,
2192 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100, TestSize.Level1)
2193 {
2194 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 start";
2195 char* argv[] = {
2196 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2197 (char*)cmdsetBrightnessDiscount_.c_str(),
2198 (char*)"-v",
2199 (char*)"0",
2200 (char*)" ",
2201 };
2202 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2203
2204 AccessibilityAbilityShellCommand cmd(argc, argv);
2205 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2206 MockSetBrightnessDiscount(false);
2207 EXPECT_EQ(result, OHOS::ERR_OK);
2208 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n");
2209 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 end";
2210 }
2211
2212 /**
2213 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200
2214 * @tc.name: RunAsSetBrightnessDiscount
2215 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2216 * 2.ret is Accessibility::RET_OK
2217 */
2218 HWTEST_F(AccessibilityAbilityShellCommandTest,
2219 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200, TestSize.Level1)
2220 {
2221 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 start";
2222 char* argv[] = {
2223 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2224 (char*)cmdsetBrightnessDiscount_.c_str(),
2225 (char*)"-v",
2226 (char*)"100",
2227 (char*)" ",
2228 };
2229 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2230 AccessibilityAbilityShellCommand cmd(argc, argv);
2231 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2232 MockSetBrightnessDiscount(true);
2233 EXPECT_EQ(result, OHOS::ERR_OK);
2234 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG);
2235 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 end";
2236 }
2237
2238 /**
2239 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300
2240 * @tc.name: RunAsSetBrightnessDiscount
2241 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.(value is invalid)
2242 */
2243 HWTEST_F(AccessibilityAbilityShellCommandTest,
2244 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300, TestSize.Level1)
2245 {
2246 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 start";
2247 char* argv[] = {
2248 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2249 (char*)cmdsetBrightnessDiscount_.c_str(),
2250 (char*)"-v",
2251 (char*)"101",
2252 (char*)" ",
2253 };
2254 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2255 AccessibilityAbilityShellCommand cmd(argc, argv);
2256 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2257 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2258 EXPECT_EQ(cmd.resultReceiver_, "setSetBrightnessDiscount: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2259 "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2260 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 end";
2261 }
2262
2263 /**
2264 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400
2265 * @tc.name: RunAsSetBrightnessDiscount
2266 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.
2267 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2268 */
2269 HWTEST_F(AccessibilityAbilityShellCommandTest,
2270 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400, TestSize.Level1)
2271 {
2272 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 start";
2273 char* argv[] = {
2274 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2275 };
2276 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2277 AccessibilityAbilityShellCommand cmd(argc, argv);
2278 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2279 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2280 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2281 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 end";
2282 }
2283
2284 /**
2285 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100
2286 * @tc.name: RunAsSetAudioMonoState
2287 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2288 */
2289 HWTEST_F(AccessibilityAbilityShellCommandTest,
2290 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100, TestSize.Level1)
2291 {
2292 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 start";
2293 char* argv[] = {
2294 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2295 (char*)cmdsetAudioMonoState_.c_str(),
2296 (char*)"-v",
2297 (char*)"0",
2298 (char*)" ",
2299 };
2300 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2301 AccessibilityAbilityShellCommand cmd(argc, argv);
2302 ErrCode result = cmd.RunAsSetAudioMonoState();
2303 EXPECT_EQ(result, OHOS::ERR_OK);
2304 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2305 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 end";
2306 }
2307
2308 /**
2309 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200
2310 * @tc.name: RunAsSetAudioMonoState
2311 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2312 */
2313 HWTEST_F(AccessibilityAbilityShellCommandTest,
2314 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200, TestSize.Level1)
2315 {
2316 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 start";
2317 char* argv[] = {
2318 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2319 (char*)cmdsetAudioMonoState_.c_str(),
2320 (char*)"-v",
2321 (char*)"1",
2322 (char*)" ",
2323 };
2324 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2325 AccessibilityAbilityShellCommand cmd(argc, argv);
2326 ErrCode result = cmd.RunAsSetAudioMonoState();
2327 EXPECT_EQ(result, OHOS::ERR_OK);
2328 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2329 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 end";
2330 }
2331
2332 /**
2333 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300
2334 * @tc.name: RunAsSetAudioMonoState
2335 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(value is invalid)
2336 */
2337 HWTEST_F(AccessibilityAbilityShellCommandTest,
2338 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300, TestSize.Level1)
2339 {
2340 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 start";
2341 char* argv[] = {
2342 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2343 (char*)cmdsetAudioMonoState_.c_str(),
2344 (char*)"-v",
2345 (char*)"2",
2346 (char*)" ",
2347 };
2348 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2349 AccessibilityAbilityShellCommand cmd(argc, argv);
2350 ErrCode result = cmd.RunAsSetAudioMonoState();
2351 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2352 EXPECT_EQ(cmd.resultReceiver_, "setAudioMonoState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2353 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2354 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 end";
2355 }
2356
2357 /**
2358 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400
2359 * @tc.name: RunAsSetAudioMonoState
2360 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.
2361 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2362 */
2363 HWTEST_F(AccessibilityAbilityShellCommandTest,
2364 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400, TestSize.Level1)
2365 {
2366 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 start";
2367 char* argv[] = {
2368 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2369 };
2370 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2371 AccessibilityAbilityShellCommand cmd(argc, argv);
2372 ErrCode result = cmd.RunAsSetAudioMonoState();
2373 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2374 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2375 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 end";
2376 }
2377
2378 /**
2379 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100
2380 * @tc.name: RunAsSetAudioBalance
2381 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
2382 */
2383 HWTEST_F(AccessibilityAbilityShellCommandTest,
2384 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100, TestSize.Level1)
2385 {
2386 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 start";
2387 char* argv[] = {
2388 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2389 (char*)cmdsetAudioBalance_.c_str(),
2390 (char*)"-v",
2391 (char*)"-100",
2392 (char*)" ",
2393 };
2394 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2395 AccessibilityAbilityShellCommand cmd(argc, argv);
2396 ErrCode result = cmd.RunAsSetAudioBalance();
2397 EXPECT_EQ(result, OHOS::ERR_OK);
2398 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n");
2399 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 end";
2400 }
2401
2402 /**
2403 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200
2404 * @tc.name: RunAsSetAudioBalance
2405 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
2406 */
2407 HWTEST_F(AccessibilityAbilityShellCommandTest,
2408 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200, TestSize.Level1)
2409 {
2410 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 start";
2411 char* argv[] = {
2412 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2413 (char*)cmdsetAudioBalance_.c_str(),
2414 (char*)"-v",
2415 (char*)"100",
2416 (char*)" ",
2417 };
2418 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2419 AccessibilityAbilityShellCommand cmd(argc, argv);
2420 ErrCode result = cmd.RunAsSetAudioBalance();
2421 EXPECT_EQ(result, OHOS::ERR_OK);
2422 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n");
2423 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 end";
2424 }
2425
2426 /**
2427 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300
2428 * @tc.name: RunAsSetAudioBalance
2429 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(value is invalid)
2430 */
2431 HWTEST_F(AccessibilityAbilityShellCommandTest,
2432 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300, TestSize.Level1)
2433 {
2434 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 start";
2435 char* argv[] = {
2436 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2437 (char*)cmdsetAudioBalance_.c_str(),
2438 (char*)"-v",
2439 (char*)"101",
2440 (char*)" ",
2441 };
2442 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2443 AccessibilityAbilityShellCommand cmd(argc, argv);
2444 ErrCode result = cmd.RunAsSetAudioBalance();
2445 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2446 EXPECT_EQ(cmd.resultReceiver_, "setAudioBalance: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2447 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
2448 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 end";
2449 }
2450
2451 /**
2452 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400
2453 * @tc.name: RunAsSetAudioBalance
2454 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.
2455 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2456 */
2457 HWTEST_F(AccessibilityAbilityShellCommandTest,
2458 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400, TestSize.Level1)
2459 {
2460 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 start";
2461 char* argv[] = {
2462 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2463 };
2464 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2465 AccessibilityAbilityShellCommand cmd(argc, argv);
2466 ErrCode result = cmd.RunAsSetAudioBalance();
2467 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2468 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
2469 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 end";
2470 }
2471
2472 /**
2473 * @tc.number: AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100
2474 * @tc.name: MakeSetShortKeyTargetCommandArgumentFromCmd
2475 * @tc.desc: Test whether MakeSetShortKeyTargetCommandArgumentFromCmd is called normally.
2476 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,MakeCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2477 */
2478 HWTEST_F(AccessibilityAbilityShellCommandTest,
2479 AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100, TestSize.Level1)
2480 {
2481 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 start";
2482 AccessibilityCommandArgument argument;
2483 optind = 5;
2484 std::string resultMessage;
2485 char* argv[] = {
2486 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2487 (char*)cmdsetShortKeyTarget_.c_str(),
2488 (char*)"-a",
2489 (char*)"ability",
2490 (char*)"-b",
2491 (char*)"bundle",
2492 (char*)" ",
2493 };
2494 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2495 AccessibilityAbilityShellCommand cmd(argc, argv);
2496 ErrCode result = cmd.MakeSetShortKeyTargetCommandArgumentFromCmd(argument);
2497 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2498 EXPECT_EQ(cmd.resultReceiver_, "setShortkeyTarget: " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
2499 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 end";
2500 }
2501
2502 /**
2503 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100
2504 * @tc.name: MakeSetCommandArgumentFromCmd
2505 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(OHOS::ERR_OK)
2506 */
2507 HWTEST_F(AccessibilityAbilityShellCommandTest,
2508 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100, TestSize.Level1)
2509 {
2510 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 start";
2511 AccessibilityCommandArgument argument;
2512 std::string resultMessage;
2513 char* argv[] = {
2514 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2515 (char*)cmdsetShortKeyState_.c_str(),
2516 (char*)"-v",
2517 (char*)"0",
2518 (char*)" ",
2519 };
2520 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2521 AccessibilityAbilityShellCommand cmd(argc, argv);
2522 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2523 EXPECT_EQ(result, OHOS::ERR_OK);
2524 EXPECT_EQ(cmd.resultReceiver_, ": ");
2525 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 end";
2526 }
2527
2528 /**
2529 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200
2530 * @tc.name: MakeSetCommandArgumentFromCmd
2531 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(optind < 0)
2532 */
2533 HWTEST_F(AccessibilityAbilityShellCommandTest,
2534 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200, TestSize.Level1)
2535 {
2536 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 start";
2537 AccessibilityCommandArgument argument;
2538 optind = -1;
2539 char* argv[] = {
2540 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2541 };
2542 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2543 AccessibilityAbilityShellCommand cmd(argc, argv);
2544 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2545 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2546 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 end";
2547 }
2548
2549 /**
2550 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300
2551 * @tc.name: MakeSetCommandArgumentFromCmd
2552 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = -1)
2553 */
2554 HWTEST_F(AccessibilityAbilityShellCommandTest,
2555 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300, TestSize.Level1)
2556 {
2557 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 start";
2558 AccessibilityCommandArgument argument;
2559 char* argv[] = {
2560 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2561 (char*)cmdsetShortKeyState_.c_str(),
2562 };
2563 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2564 AccessibilityAbilityShellCommand cmd(argc, argv);
2565 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2566 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2567 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
2568 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 end";
2569 }
2570
2571 /**
2572 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400
2573 * @tc.name: MakeSetCommandArgumentFromCmd
2574 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = ?)
2575 */
2576 HWTEST_F(AccessibilityAbilityShellCommandTest,
2577 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400, TestSize.Level1)
2578 {
2579 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 start";
2580 AccessibilityCommandArgument argument;
2581 char* argv[] = {
2582 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2583 (char*)cmdsetShortKeyState_.c_str(),
2584 (char*)"-v",
2585 (char*)" ",
2586 };
2587 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2588 AccessibilityAbilityShellCommand cmd(argc, argv);
2589 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2590 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2591 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE);
2592 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 end";
2593 }
2594
2595 /**
2596 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500
2597 * @tc.name: MakeSetCommandArgumentFromCmd
2598 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = default)
2599 */
2600 HWTEST_F(AccessibilityAbilityShellCommandTest,
2601 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500, TestSize.Level1)
2602 {
2603 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 start";
2604 AccessibilityCommandArgument argument;
2605 char* argv[] = {
2606 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2607 (char*)cmdsetShortKeyState_.c_str(),
2608 (char*)"-a",
2609 (char*)" ",
2610 };
2611 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2612 AccessibilityAbilityShellCommand cmd(argc, argv);
2613 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2614 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2615 EXPECT_EQ(cmd.resultReceiver_, ": unknown arguments -a ");
2616 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 end";
2617 }
2618
2619 /**
2620 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100
2621 * @tc.name: MakeCommandArgumentFromCmd
2622 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK)
2623 */
2624 HWTEST_F(AccessibilityAbilityShellCommandTest,
2625 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100, TestSize.Level1)
2626 {
2627 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 start";
2628 AccessibilityCommandArgument argument;
2629 optind = 5;
2630 char* argv[] = {
2631 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2632 (char*)cmdsetShortKeyTarget_.c_str(),
2633 (char*)"-a",
2634 (char*)"ability",
2635 (char*)"-b",
2636 (char*)"bundle",
2637 (char*)" ",
2638 };
2639 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2640 AccessibilityAbilityShellCommand cmd(argc, argv);
2641 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2642 EXPECT_EQ(result, OHOS::ERR_OK);
2643 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 end";
2644 }
2645
2646 /**
2647 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200
2648 * @tc.name: MakeCommandArgumentFromCmd
2649 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK，option a b)
2650 */
2651 HWTEST_F(AccessibilityAbilityShellCommandTest,
2652 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200, TestSize.Level1)
2653 {
2654 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 start";
2655 AccessibilityCommandArgument argument;
2656 char* argv[] = {
2657 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2658 (char*)cmdsetShortKeyTarget_.c_str(),
2659 (char*)"-a",
2660 (char*)"ability",
2661 (char*)"-b",
2662 (char*)"bundle",
2663 (char*)"-v",
2664 (char*)"value",
2665 (char*)" ",
2666 };
2667 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2668 AccessibilityAbilityShellCommand cmd(argc, argv);
2669 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2670 EXPECT_EQ(result, OHOS::ERR_OK);
2671 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 end";
2672 }
2673
2674 /**
2675 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300
2676 * @tc.name: MakeCommandArgumentFromCmd
2677 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(missing options)
2678 */
2679 HWTEST_F(AccessibilityAbilityShellCommandTest,
2680 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300, TestSize.Level1)
2681 {
2682 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 start";
2683 AccessibilityCommandArgument argument;
2684 char* argv[] = {
2685 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2686 (char*)cmdsetShortKeyTarget_.c_str(),
2687 (char*)" ",
2688 };
2689 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2690 AccessibilityAbilityShellCommand cmd(argc, argv);
2691 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2692 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2693 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
2694 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 end";
2695 }
2696
2697 /**
2698 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400
2699 * @tc.name: MakeCommandArgumentFromCmd
2700 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_ABILITY)
2701 */
2702 HWTEST_F(AccessibilityAbilityShellCommandTest,
2703 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400, TestSize.Level1)
2704 {
2705 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 start";
2706 AccessibilityCommandArgument argument;
2707 char* argv[] = {
2708 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2709 (char*)cmdsetShortKeyTarget_.c_str(),
2710 (char*)"-a",
2711 (char*)" ",
2712 };
2713 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2714 AccessibilityAbilityShellCommand cmd(argc, argv);
2715 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2716 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2717 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
2718 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 end";
2719 }
2720
2721 /**
2722 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500
2723 * @tc.name: MakeCommandArgumentFromCmd
2724 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_BUNDLE)
2725 */
2726 HWTEST_F(AccessibilityAbilityShellCommandTest,
2727 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500, TestSize.Level1)
2728 {
2729 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 start";
2730 AccessibilityCommandArgument argument;
2731 char* argv[] = {
2732 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2733 (char*)cmdsetShortKeyTarget_.c_str(),
2734 (char*)"-a",
2735 (char*)"ability",
2736 (char*)"-b",
2737 (char*)" ",
2738 };
2739 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2740 AccessibilityAbilityShellCommand cmd(argc, argv);
2741 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2742 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2743 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
2744 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 end";
2745 }
2746
2747 /**
2748 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600
2749 * @tc.name: MakeCommandArgumentFromCmd
2750 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(optind = -1)
2751 */
2752 HWTEST_F(AccessibilityAbilityShellCommandTest,
2753 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600, TestSize.Level1)
2754 {
2755 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 start";
2756 AccessibilityCommandArgument argument;
2757 optind = -1;
2758 char* argv[] = {
2759 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2760 };
2761 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2762 AccessibilityAbilityShellCommand cmd(argc, argv);
2763 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2764 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2765 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 end";
2766 }
2767
2768 /**
2769 * @tc.number: AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100
2770 * @tc.name: MakeDisableCommandArgumentFromCmd
2771 * @tc.desc: Test whether MakeDisableCommandArgumentFromCmd is called normally.
2772 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,CheckDisableCommandArgument = OHOS::ERR_INVALID_VALUE)
2773 */
2774 HWTEST_F(AccessibilityAbilityShellCommandTest,
2775 AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100, TestSize.Level1)
2776 {
2777 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 start";
2778 AccessibilityCommandArgument argument;
2779 argument.abilityArgumentNum = 1;
2780 argument.abilityName = "ability";
2781 argument.bundleArgumentNum = 1;
2782 argument.bundleName = "bundle";
2783 argument.capabilityNamesArgumentNum = 0;
2784 argument.unknownArgumentNum = 0;
2785 char* argv[] = {
2786 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2787 (char*)cmddisable_.c_str(),
2788 (char*)"-a",
2789 (char*)"ability",
2790 (char*)"-b",
2791 (char*)"bundle",
2792 (char*)" ",
2793 };
2794 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2795 AccessibilityAbilityShellCommand cmd(argc, argv);
2796 ErrCode result = cmd.MakeDisableCommandArgumentFromCmd(argument);
2797 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2798 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 end";
2799 }
2800
2801 /**
2802 * @tc.number: AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100
2803 * @tc.name: CheckDisableCommandArgument
2804 * @tc.desc: Test whether CheckDisableCommandArgument is called normally.
2805 * (CheckCommandArgument = OHOS::ERR_INVALID_VALUE)
2806 */
2807 HWTEST_F(AccessibilityAbilityShellCommandTest,
2808 AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100, TestSize.Level1)
2809 {
2810 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 start";
2811 AccessibilityCommandArgument argument;
2812 std::string resultMessage;
2813 argument.abilityArgumentNum = 1;
2814 argument.abilityName = "ability";
2815 argument.bundleArgumentNum = 1;
2816 argument.bundleName = "bundle";
2817 argument.capabilityNamesArgumentNum = 0;
2818 argument.unknownArgumentNum = 0;
2819 char* argv[] = {
2820 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2821 };
2822 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2823 AccessibilityAbilityShellCommand cmd(argc, argv);
2824 ErrCode result = cmd.CheckDisableCommandArgument(argument,resultMessage);
2825 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2826 EXPECT_EQ(resultMessage, ": the auxiliary application bundle/ability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
2827 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 end";
2828 }
2829
2830 /**
2831 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0100
2832 * @tc.name: CheckCommandArgument
2833 * @tc.desc: Test whether CheckCommandArgument is called normally.(totalArgumentNum > 2)
2834 */
2835 HWTEST_F(AccessibilityAbilityShellCommandTest,
2836 AccessibilityAbilityShellCommand_CheckCommandArgument_0100, TestSize.Level1)
2837 {
2838 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 start";
2839 AccessibilityCommandArgument argument;
2840 std::string resultMessage;
2841 argument.abilityArgumentNum = 2;
2842 argument.abilityName = "ability";
2843 argument.bundleArgumentNum = 1;
2844 argument.bundleName = "bundle";
2845 argument.capabilityNamesArgumentNum = 0;
2846 argument.unknownArgumentNum = 1;
2847 char* argv[] = {
2848 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2849 };
2850 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2851 AccessibilityAbilityShellCommand cmd(argc, argv);
2852 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2853 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2854 EXPECT_EQ(resultMessage, ": and duplicated arguments exist.and unknown arguments exist.");
2855 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
2856 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 end";
2857 }
2858
2859 /**
2860 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0200
2861 * @tc.name: CheckCommandArgument
2862 * @tc.desc: Test whether CheckCommandArgument is called normally.(unknownArgumentNum > 0)
2863 */
2864 HWTEST_F(AccessibilityAbilityShellCommandTest,
2865 AccessibilityAbilityShellCommand_CheckCommandArgument_0200, TestSize.Level1)
2866 {
2867 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 start";
2868 AccessibilityCommandArgument argument;
2869 std::string resultMessage;
2870 argument.abilityArgumentNum = 0;
2871 argument.abilityName = "ability";
2872 argument.bundleArgumentNum = 0;
2873 argument.bundleName = "bundle";
2874 argument.capabilityNamesArgumentNum = 0;
2875 argument.unknownArgumentNum = 1;
2876 char* argv[] = {
2877 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2878 };
2879 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2880 AccessibilityAbilityShellCommand cmd(argc, argv);
2881 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2882 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2883 EXPECT_EQ(resultMessage, ": unknown arguments exist.");
2884 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 end";
2885 }
2886
2887 /**
2888 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0300
2889 * @tc.name: CheckCommandArgument
2890 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckAbilityArgument = false)
2891 */
2892 HWTEST_F(AccessibilityAbilityShellCommandTest,
2893 AccessibilityAbilityShellCommand_CheckCommandArgument_0300, TestSize.Level1)
2894 {
2895 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 start";
2896 AccessibilityCommandArgument argument;
2897 std::string resultMessage;
2898 argument.abilityArgumentNum = 0;
2899 argument.abilityName = "ability";
2900 argument.bundleArgumentNum = 1;
2901 argument.bundleName = "bundle";
2902 argument.capabilityNamesArgumentNum = 1;
2903 argument.unknownArgumentNum = 0;
2904 char* argv[] = {
2905 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2906 };
2907 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2908 AccessibilityAbilityShellCommand cmd(argc, argv);
2909 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2910 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2911 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
2912 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 end";
2913 }
2914
2915 /**
2916 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0400
2917 * @tc.name: CheckCommandArgument
2918 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckBundleArgument = false)
2919 */
2920 HWTEST_F(AccessibilityAbilityShellCommandTest,
2921 AccessibilityAbilityShellCommand_CheckCommandArgument_0400, TestSize.Level1)
2922 {
2923 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 start";
2924 AccessibilityCommandArgument argument;
2925 std::string resultMessage;
2926 argument.abilityArgumentNum = 1;
2927 argument.abilityName = "ability";
2928 argument.bundleArgumentNum = 0;
2929 argument.bundleName = "bundle";
2930 argument.capabilityNamesArgumentNum = 1;
2931 argument.unknownArgumentNum = 0;
2932 char* argv[] = {
2933 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2934 };
2935 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2936 AccessibilityAbilityShellCommand cmd(argc, argv);
2937 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2938 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2939 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
2940 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 end";
2941 }
2942
2943 /**
2944 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0500
2945 * @tc.name: CheckCommandArgument
2946 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckParamValidity = false)
2947 */
2948 HWTEST_F(AccessibilityAbilityShellCommandTest,
2949 AccessibilityAbilityShellCommand_CheckCommandArgument_0500, TestSize.Level1)
2950 {
2951 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 start";
2952 AccessibilityCommandArgument argument;
2953 std::string resultMessage;
2954 argument.abilityArgumentNum = 1;
2955 argument.abilityName = "ability";
2956 argument.bundleArgumentNum = 1;
2957 argument.bundleName = "bundle";
2958 argument.capabilityNamesArgumentNum = 0;
2959 argument.unknownArgumentNum = 0;
2960 char* argv[] = {
2961 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2962 };
2963 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2964 AccessibilityAbilityShellCommand cmd(argc, argv);
2965 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2966 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2967 EXPECT_EQ(resultMessage, ": the auxiliary application " +
2968 argument.bundleName + "/" + argument.abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
2969 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 end";
2970 }
2971 } // namespace AAFwk
2972 } // namespace OHOS
2973