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 ErrCode result = cmd.RunAsGetInstalledAbilities();
1194 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1195 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsGetInstalledAbilities_0100 end";
1196 }
1197
1198 /**
1199 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100
1200 * @tc.name: RunAsSetScreenMagnificationState
1201 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.
1202 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1203 */
1204 HWTEST_F(AccessibilityAbilityShellCommandTest,
1205 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100, TestSize.Level1)
1206 {
1207 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 start";
1208 char* argv[] = {
1209 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1210 };
1211 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1212 AccessibilityAbilityShellCommand cmd(argc, argv);
1213 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1214 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1215 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1216 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0100 end";
1217 }
1218
1219 /**
1220 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200
1221 * @tc.name: RunAsSetScreenMagnificationState
1222 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(OHOS::ERR_OK)
1223 */
1224 HWTEST_F(AccessibilityAbilityShellCommandTest,
1225 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200, TestSize.Level1)
1226 {
1227 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1228 char* argv[] = {
1229 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1230 (char*)cmdsetShortKeyState_.c_str(),
1231 (char*)"-v",
1232 (char*)"0",
1233 (char*)" ",
1234 };
1235 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1236 AccessibilityAbilityShellCommand cmd(argc, argv);
1237 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1238 EXPECT_EQ(result, OHOS::ERR_OK);
1239 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SCREEN_MAGNIFICATION_STATE_OK + "\n");
1240 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 end";
1241 }
1242
1243 /**
1244 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300
1245 * @tc.name: RunAsSetScreenMagnificationState
1246 * @tc.desc: Test whether RunAsSetScreenMagnificationState is called normally.(value is invalid)
1247 */
1248 HWTEST_F(AccessibilityAbilityShellCommandTest,
1249 AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300, TestSize.Level1)
1250 {
1251 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0200 start";
1252 char* argv[] = {
1253 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1254 (char*)cmdsetShortKeyState_.c_str(),
1255 (char*)"-v",
1256 (char*)"2",
1257 (char*)" ",
1258 };
1259 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1260 AccessibilityAbilityShellCommand cmd(argc, argv);
1261 ErrCode result = cmd.RunAsSetScreenMagnificationState();
1262 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1263 EXPECT_EQ(cmd.resultReceiver_, "setScreenMagnificationState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1264 "\n" + ACCESSIBILITY_HELP_MSG_SET_SCREEN_MAGNIFICATION_STATE);
1265 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetScreenMagnificationState_0300 end";
1266 }
1267
1268 /**
1269 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100
1270 * @tc.name: RunAsSetShortKeyState
1271 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1272 */
1273 HWTEST_F(AccessibilityAbilityShellCommandTest,
1274 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100, TestSize.Level1)
1275 {
1276 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 start";
1277 char* argv[] = {
1278 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1279 (char*)cmdsetShortKeyState_.c_str(),
1280 (char*)"-v",
1281 (char*)"0",
1282 (char*)" ",
1283 };
1284 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1285 AccessibilityAbilityShellCommand cmd(argc, argv);
1286 ErrCode result = cmd.RunAsSetShortKeyState();
1287 EXPECT_EQ(result, OHOS::ERR_OK);
1288 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1289 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0100 end";
1290 }
1291
1292 /**
1293 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200
1294 * @tc.name: RunAsSetShortKeyState
1295 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(OHOS::ERR_OK)
1296 */
1297 HWTEST_F(AccessibilityAbilityShellCommandTest,
1298 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200, TestSize.Level1)
1299 {
1300 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 start";
1301 char* argv[] = {
1302 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1303 (char*)cmdsetShortKeyState_.c_str(),
1304 (char*)"-v",
1305 (char*)"1",
1306 (char*)" ",
1307 };
1308 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1309 AccessibilityAbilityShellCommand cmd(argc, argv);
1310 ErrCode result = cmd.RunAsSetShortKeyState();
1311 EXPECT_EQ(result, OHOS::ERR_OK);
1312 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_SHORT_KEY_STATE_OK + "\n");
1313 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0200 end";
1314 }
1315
1316 /**
1317 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300
1318 * @tc.name: RunAsSetShortKeyState
1319 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.(value is invalid)
1320 */
1321 HWTEST_F(AccessibilityAbilityShellCommandTest,
1322 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300, TestSize.Level1)
1323 {
1324 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 start";
1325 char* argv[] = {
1326 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1327 (char*)cmdsetShortKeyState_.c_str(),
1328 (char*)"-v",
1329 (char*)"2",
1330 (char*)" ",
1331 };
1332 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1333 AccessibilityAbilityShellCommand cmd(argc, argv);
1334 ErrCode result = cmd.RunAsSetShortKeyState();
1335 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1336 EXPECT_EQ(cmd.resultReceiver_, "setShortKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1337 "\n" + ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1338 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0300 end";
1339 }
1340
1341 /**
1342 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400
1343 * @tc.name: RunAsSetShortKeyState
1344 * @tc.desc: Test whether RunAsSetShortKeyState is called normally.
1345 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1346 */
1347 HWTEST_F(AccessibilityAbilityShellCommandTest,
1348 AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400, TestSize.Level1)
1349 {
1350 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 start";
1351 char* argv[] = {
1352 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1353 };
1354 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1355 AccessibilityAbilityShellCommand cmd(argc, argv);
1356 ErrCode result = cmd.RunAsSetShortKeyState();
1357 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1358 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_STATE);
1359 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyState_0400 end";
1360 }
1361
1362 /**
1363 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100
1364 * @tc.name: RunAsSetMouseKeyState
1365 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1366 */
1367 HWTEST_F(AccessibilityAbilityShellCommandTest,
1368 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100, TestSize.Level1)
1369 {
1370 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 start";
1371 char* argv[] = {
1372 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1373 (char*)cmdsetMouseKeyState_.c_str(),
1374 (char*)"-v",
1375 (char*)"0",
1376 (char*)" ",
1377 };
1378 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1379 AccessibilityAbilityShellCommand cmd(argc, argv);
1380 ErrCode result = cmd.RunAsSetMouseKeyState();
1381 EXPECT_EQ(result, OHOS::ERR_OK);
1382 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1383 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0100 end";
1384 }
1385
1386 /**
1387 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200
1388 * @tc.name: RunAsSetMouseKeyState
1389 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(OHOS::ERR_OK)
1390 */
1391 HWTEST_F(AccessibilityAbilityShellCommandTest,
1392 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200, TestSize.Level1)
1393 {
1394 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 start";
1395 char* argv[] = {
1396 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1397 (char*)cmdsetMouseKeyState_.c_str(),
1398 (char*)"-v",
1399 (char*)"1",
1400 (char*)" ",
1401 };
1402 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1403 AccessibilityAbilityShellCommand cmd(argc, argv);
1404 ErrCode result = cmd.RunAsSetMouseKeyState();
1405 EXPECT_EQ(result, OHOS::ERR_OK);
1406 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_MOUSE_KEY_STATE_OK + "\n");
1407 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0200 end";
1408 }
1409
1410 /**
1411 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300
1412 * @tc.name: RunAsSetMouseKeyState
1413 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.(value is invalid)
1414 */
1415 HWTEST_F(AccessibilityAbilityShellCommandTest,
1416 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300, TestSize.Level1)
1417 {
1418 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 start";
1419 char* argv[] = {
1420 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1421 (char*)cmdsetMouseKeyState_.c_str(),
1422 (char*)"-v",
1423 (char*)"2",
1424 (char*)" ",
1425 };
1426 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1427 AccessibilityAbilityShellCommand cmd(argc, argv);
1428 ErrCode result = cmd.RunAsSetMouseKeyState();
1429 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1430 EXPECT_EQ(cmd.resultReceiver_, "setMouseKeyState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1431 "\n" + ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1432 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0300 end";
1433 }
1434
1435 /**
1436 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400
1437 * @tc.name: RunAsSetMouseKeyState
1438 * @tc.desc: Test whether RunAsSetMouseKeyState is called normally.
1439 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1440 */
1441 HWTEST_F(AccessibilityAbilityShellCommandTest,
1442 AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400, TestSize.Level1)
1443 {
1444 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 start";
1445 char* argv[] = {
1446 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1447 };
1448 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1449 AccessibilityAbilityShellCommand cmd(argc, argv);
1450 ErrCode result = cmd.RunAsSetMouseKeyState();
1451 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1452 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_MOUSE_KEY_STATE);
1453 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseKeyState_0400 end";
1454 }
1455
1456 /**
1457 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100
1458 * @tc.name: RunAsSetCaptionState
1459 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1460 */
1461 HWTEST_F(AccessibilityAbilityShellCommandTest,
1462 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100, TestSize.Level1)
1463 {
1464 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 start";
1465 char* argv[] = {
1466 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1467 (char*)cmdsetCaptionState_.c_str(),
1468 (char*)"-v",
1469 (char*)"0",
1470 (char*)" ",
1471 };
1472 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1473 AccessibilityAbilityShellCommand cmd(argc, argv);
1474 ErrCode result = cmd.RunAsSetCaptionState();
1475 EXPECT_EQ(result, OHOS::ERR_OK);
1476 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1477 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0100 end";
1478 }
1479
1480 /**
1481 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200
1482 * @tc.name: RunAsSetCaptionState
1483 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(OHOS::ERR_OK)
1484 */
1485 HWTEST_F(AccessibilityAbilityShellCommandTest,
1486 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200, TestSize.Level1)
1487 {
1488 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 start";
1489 char* argv[] = {
1490 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1491 (char*)cmdsetCaptionState_.c_str(),
1492 (char*)"-v",
1493 (char*)"1",
1494 (char*)" ",
1495 };
1496 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1497
1498 AccessibilityAbilityShellCommand cmd(argc, argv);
1499 ErrCode result = cmd.RunAsSetCaptionState();
1500 EXPECT_EQ(result, OHOS::ERR_OK);
1501 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CAPTION_STATE_OK + "\n");
1502 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0200 end";
1503 }
1504
1505 /**
1506 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300
1507 * @tc.name: RunAsSetCaptionState
1508 * @tc.desc: Test whether RunAsSetCaptionState is called normally.(value is invalid)
1509 */
1510 HWTEST_F(AccessibilityAbilityShellCommandTest,
1511 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300, TestSize.Level1)
1512 {
1513 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 start";
1514 char* argv[] = {
1515 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1516 (char*)cmdsetCaptionState_.c_str(),
1517 (char*)"-v",
1518 (char*)"2",
1519 (char*)" ",
1520 };
1521 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1522 AccessibilityAbilityShellCommand cmd(argc, argv);
1523 ErrCode result = cmd.RunAsSetCaptionState();
1524 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1525 EXPECT_EQ(cmd.resultReceiver_, "setCaptionState: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1526 "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1527 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0300 end";
1528 }
1529
1530 /**
1531 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400
1532 * @tc.name: RunAsSetCaptionState
1533 * @tc.desc: Test whether RunAsSetCaptionState is called normally.
1534 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1535 */
1536 HWTEST_F(AccessibilityAbilityShellCommandTest,
1537 AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400, TestSize.Level1)
1538 {
1539 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 start";
1540 char* argv[] = {
1541 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1542 };
1543 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1544 AccessibilityAbilityShellCommand cmd(argc, argv);
1545 ErrCode result = cmd.RunAsSetCaptionState();
1546 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1547 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CAPTION_STATE);
1548 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetCaptionState_0400 end";
1549 }
1550
1551 /**
1552 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100
1553 * @tc.name: RunAsSetMouseAutoClick
1554 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1555 */
1556 HWTEST_F(AccessibilityAbilityShellCommandTest,
1557 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100, TestSize.Level1)
1558 {
1559 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 start";
1560 char* argv[] = {
1561 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1562 (char*)cmdssetMouseAutoClick_.c_str(),
1563 (char*)"-v",
1564 (char*)"1000",
1565 (char*)" ",
1566 };
1567 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1568 AccessibilityAbilityShellCommand cmd(argc, argv);
1569 ErrCode result = cmd.RunAsSetMouseAutoClick();
1570 EXPECT_EQ(result, OHOS::ERR_OK);
1571 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1572 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0100 end";
1573 }
1574
1575 /**
1576 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200
1577 * @tc.name: RunAsSetMouseAutoClick
1578 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(OHOS::ERR_OK)
1579 */
1580 HWTEST_F(AccessibilityAbilityShellCommandTest,
1581 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200, TestSize.Level1)
1582 {
1583 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 start";
1584 char* argv[] = {
1585 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1586 (char*)cmdssetMouseAutoClick_.c_str(),
1587 (char*)"-v",
1588 (char*)"5000",
1589 (char*)" ",
1590 };
1591 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1592 AccessibilityAbilityShellCommand cmd(argc, argv);
1593 ErrCode result = cmd.RunAsSetMouseAutoClick();
1594 EXPECT_EQ(result, OHOS::ERR_OK);
1595 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUTO_CLICK_TIME_OK + "\n");
1596 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0200 end";
1597 }
1598
1599 /**
1600 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300
1601 * @tc.name: RunAsSetMouseAutoClick
1602 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.(value is invalid)
1603 */
1604 HWTEST_F(AccessibilityAbilityShellCommandTest,
1605 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300, TestSize.Level1)
1606 {
1607 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 start";
1608 char* argv[] = {
1609 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1610 (char*)cmdssetMouseAutoClick_.c_str(),
1611 (char*)"-v",
1612 (char*)"5001",
1613 (char*)" ",
1614 };
1615 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1616 AccessibilityAbilityShellCommand cmd(argc, argv);
1617 ErrCode result = cmd.RunAsSetMouseAutoClick();
1618 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1619 EXPECT_EQ(cmd.resultReceiver_, "setMouseAutoClick: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1620 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1621 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0300 end";
1622 }
1623
1624 /**
1625 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400
1626 * @tc.name: RunAsSetMouseAutoClick
1627 * @tc.desc: Test whether RunAsSetMouseAutoClick is called normally.
1628 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1629 */
1630 HWTEST_F(AccessibilityAbilityShellCommandTest,
1631 AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400, TestSize.Level1)
1632 {
1633 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 start";
1634 char* argv[] = {
1635 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1636 };
1637 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1638 AccessibilityAbilityShellCommand cmd(argc, argv);
1639 ErrCode result = cmd.RunAsSetMouseAutoClick();
1640 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1641 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_AUTO_CLICK_TIME);
1642 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetMouseAutoClick_0400 end";
1643 }
1644
1645 /**
1646 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100
1647 * @tc.name: RunAsSetShortKeyTarget
1648 * @tc.desc: Test whether RunAsSetShortKeyTarget is called normally.
1649 * (MakeSetShortKeyTargetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1650 */
1651 HWTEST_F(AccessibilityAbilityShellCommandTest,
1652 AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100, TestSize.Level1)
1653 {
1654 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 start";
1655 char* argv[] = {
1656 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1657 };
1658 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1659 AccessibilityAbilityShellCommand cmd(argc, argv);
1660 ErrCode result = cmd.RunAsSetShortKeyTarget();
1661 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1662 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_SHORT_KEY_TARGET);
1663 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetShortKeyTarget_0100 end";
1664 }
1665
1666 /**
1667 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100
1668 * @tc.name: RunAsSetHighContrastTextState
1669 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1670 */
1671 HWTEST_F(AccessibilityAbilityShellCommandTest,
1672 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100, TestSize.Level1)
1673 {
1674 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 start";
1675 char* argv[] = {
1676 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1677 (char*)cmdsetHighContrastTextState_.c_str(),
1678 (char*)"-v",
1679 (char*)"0",
1680 (char*)" ",
1681 };
1682 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1683 AccessibilityAbilityShellCommand cmd(argc, argv);
1684 ErrCode result = cmd.RunAsSetHighContrastTextState();
1685 EXPECT_EQ(result, OHOS::ERR_OK);
1686 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1687 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0100 end";
1688 }
1689
1690 /**
1691 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200
1692 * @tc.name: RunAsSetHighContrastTextState
1693 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(OHOS::ERR_OK)
1694 */
1695 HWTEST_F(AccessibilityAbilityShellCommandTest,
1696 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200, TestSize.Level1)
1697 {
1698 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 start";
1699 char* argv[] = {
1700 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1701 (char*)cmdsetHighContrastTextState_.c_str(),
1702 (char*)"-v",
1703 (char*)"1",
1704 (char*)" ",
1705 };
1706 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1707 AccessibilityAbilityShellCommand cmd(argc, argv);
1708 ErrCode result = cmd.RunAsSetHighContrastTextState();
1709 EXPECT_EQ(result, OHOS::ERR_OK);
1710 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_HIGH_CONTRAST_TEXT_STATE_OK + "\n");
1711 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0200 end";
1712 }
1713
1714 /**
1715 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300
1716 * @tc.name: RunAsSetHighContrastTextState
1717 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.(value is invalid)
1718 */
1719 HWTEST_F(AccessibilityAbilityShellCommandTest,
1720 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300, TestSize.Level1)
1721 {
1722 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 start";
1723 char* argv[] = {
1724 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1725 (char*)cmdsetHighContrastTextState_.c_str(),
1726 (char*)"-v",
1727 (char*)"2",
1728 (char*)" ",
1729 };
1730 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1731 AccessibilityAbilityShellCommand cmd(argc, argv);
1732 ErrCode result = cmd.RunAsSetHighContrastTextState();
1733 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1734 EXPECT_EQ(cmd.resultReceiver_, "setHighContrastTextState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1735 "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1736 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0300 end";
1737 }
1738
1739 /**
1740 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400
1741 * @tc.name: RunAsSetHighContrastTextState
1742 * @tc.desc: Test whether RunAsSetHighContrastTextState is called normally.
1743 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1744 */
1745 HWTEST_F(AccessibilityAbilityShellCommandTest,
1746 AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400, TestSize.Level1)
1747 {
1748 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 start";
1749 char* argv[] = {
1750 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1751 };
1752 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1753 AccessibilityAbilityShellCommand cmd(argc, argv);
1754 ErrCode result = cmd.RunAsSetHighContrastTextState();
1755 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1756 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_HIGH_CONTRAST_TEXT_STATE);
1757 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetHighContrastTextState_0400 end";
1758 }
1759
1760 /**
1761 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100
1762 * @tc.name: RunAsSetInvertColorState
1763 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1764 */
1765 HWTEST_F(AccessibilityAbilityShellCommandTest,
1766 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100, TestSize.Level1)
1767 {
1768 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 start";
1769 char* argv[] = {
1770 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1771 (char*)cmdsetInvertColorState_.c_str(),
1772 (char*)"-v",
1773 (char*)"0",
1774 (char*)" ",
1775 };
1776 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1777 AccessibilityAbilityShellCommand cmd(argc, argv);
1778 ErrCode result = cmd.RunAsSetInvertColorState();
1779 EXPECT_EQ(result, OHOS::ERR_OK);
1780 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1781 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0100 end";
1782 }
1783
1784 /**
1785 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200
1786 * @tc.name: RunAsSetInvertColorState
1787 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(OHOS::ERR_OK)
1788 */
1789 HWTEST_F(AccessibilityAbilityShellCommandTest,
1790 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200, TestSize.Level1)
1791 {
1792 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 start";
1793 char* argv[] = {
1794 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1795 (char*)cmdsetInvertColorState_.c_str(),
1796 (char*)"-v",
1797 (char*)"1",
1798 (char*)" ",
1799 };
1800 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1801 AccessibilityAbilityShellCommand cmd(argc, argv);
1802 ErrCode result = cmd.RunAsSetInvertColorState();
1803 EXPECT_EQ(result, OHOS::ERR_OK);
1804 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_INVERT_COLOR_STATE_OK + "\n");
1805 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0200 end";
1806 }
1807
1808 /**
1809 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300
1810 * @tc.name: RunAsSetInvertColorState
1811 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.(value is invalid)
1812 */
1813 HWTEST_F(AccessibilityAbilityShellCommandTest,
1814 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300, TestSize.Level1)
1815 {
1816 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 start";
1817 char* argv[] = {
1818 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1819 (char*)cmdsetInvertColorState_.c_str(),
1820 (char*)"-v",
1821 (char*)"2",
1822 (char*)" ",
1823 };
1824 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1825 AccessibilityAbilityShellCommand cmd(argc, argv);
1826 ErrCode result = cmd.RunAsSetInvertColorState();
1827 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1828 EXPECT_EQ(cmd.resultReceiver_, "setInvertColorState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
1829 "\n" + ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1830 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0300 end";
1831 }
1832
1833 /**
1834 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400
1835 * @tc.name: RunAsSetInvertColorState
1836 * @tc.desc: Test whether RunAsSetInvertColorState is called normally.
1837 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1838 */
1839 HWTEST_F(AccessibilityAbilityShellCommandTest,
1840 AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400, TestSize.Level1)
1841 {
1842 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 start";
1843 char* argv[] = {
1844 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1845 };
1846 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1847 AccessibilityAbilityShellCommand cmd(argc, argv);
1848 ErrCode result = cmd.RunAsSetInvertColorState();
1849 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1850 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_INVERT_COLOR_STATE);
1851 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetInvertColorState_0400 end";
1852 }
1853
1854 /**
1855 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100
1856 * @tc.name: RunAsSetDaltonizationColorFilter
1857 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1858 */
1859 HWTEST_F(AccessibilityAbilityShellCommandTest,
1860 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100, TestSize.Level1)
1861 {
1862 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 start";
1863 char* argv[] = {
1864 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1865 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1866 (char*)"-v",
1867 (char*)"0",
1868 (char*)" ",
1869 };
1870 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1871 AccessibilityAbilityShellCommand cmd(argc, argv);
1872 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1873 EXPECT_EQ(result, OHOS::ERR_OK);
1874 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1875 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0100 end";
1876 }
1877
1878 /**
1879 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200
1880 * @tc.name: RunAsSetDaltonizationColorFilter
1881 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1882 */
1883 HWTEST_F(AccessibilityAbilityShellCommandTest,
1884 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200, TestSize.Level1)
1885 {
1886 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 start";
1887 char* argv[] = {
1888 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1889 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1890 (char*)"-v",
1891 (char*)"1",
1892 (char*)" ",
1893 };
1894 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1895 AccessibilityAbilityShellCommand cmd(argc, argv);
1896 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1897 EXPECT_EQ(result, OHOS::ERR_OK);
1898 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1899 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0200 end";
1900 }
1901
1902 /**
1903 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300
1904 * @tc.name: RunAsSetDaltonizationColorFilter
1905 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1906 */
1907 HWTEST_F(AccessibilityAbilityShellCommandTest,
1908 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300, TestSize.Level1)
1909 {
1910 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 start";
1911 char* argv[] = {
1912 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1913 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1914 (char*)"-v",
1915 (char*)"2",
1916 (char*)" ",
1917 };
1918 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1919 AccessibilityAbilityShellCommand cmd(argc, argv);
1920 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1921 EXPECT_EQ(result, OHOS::ERR_OK);
1922 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1923 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0300 end";
1924 }
1925
1926 /**
1927 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400
1928 * @tc.name: RunAsSetDaltonizationColorFilter
1929 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(OHOS::ERR_OK)
1930 */
1931 HWTEST_F(AccessibilityAbilityShellCommandTest,
1932 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400, TestSize.Level1)
1933 {
1934 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 start";
1935 char* argv[] = {
1936 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1937 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1938 (char*)"-v",
1939 (char*)"3",
1940 (char*)" ",
1941 };
1942 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1943 AccessibilityAbilityShellCommand cmd(argc, argv);
1944 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1945 EXPECT_EQ(result, OHOS::ERR_OK);
1946 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_DALTONIZATIONZATION_COLOR_FILTER_OK + "\n");
1947 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0400 end";
1948 }
1949
1950 /**
1951 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500
1952 * @tc.name: RunAsSetDaltonizationColorFilter
1953 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.(value is invalid)
1954 */
1955 HWTEST_F(AccessibilityAbilityShellCommandTest,
1956 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500, TestSize.Level1)
1957 {
1958 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 start";
1959 char* argv[] = {
1960 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1961 (char*)cmdsetDaltonizationColorFilter_.c_str(),
1962 (char*)"-v",
1963 (char*)"4",
1964 (char*)" ",
1965 };
1966 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1967 AccessibilityAbilityShellCommand cmd(argc, argv);
1968 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1969 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1970 EXPECT_EQ(cmd.resultReceiver_, "setDaltonizationColorFilter: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID);
1971 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0500 end";
1972 }
1973
1974 /**
1975 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600
1976 * @tc.name: RunAsSetDaltonizationColorFilter
1977 * @tc.desc: Test whether RunAsSetDaltonizationColorFilter is called normally.
1978 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
1979 */
1980 HWTEST_F(AccessibilityAbilityShellCommandTest,
1981 AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600, TestSize.Level1)
1982 {
1983 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 start";
1984 char* argv[] = {
1985 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
1986 };
1987 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
1988 AccessibilityAbilityShellCommand cmd(argc, argv);
1989 ErrCode result = cmd.RunAsSetDaltonizationColorFilter();
1990 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1991 EXPECT_EQ(cmd.resultReceiver_, "\n"+ACCESSIBILITY_HELP_MSG_SET_DALTONIZATION_COLOR_FILTER);
1992 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetDaltonizationColorFilter_0600 end";
1993 }
1994
1995 /**
1996 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100
1997 * @tc.name: RunAsSetContentTimeout
1998 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
1999 */
2000 HWTEST_F(AccessibilityAbilityShellCommandTest,
2001 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100, TestSize.Level1)
2002 {
2003 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 start";
2004 char* argv[] = {
2005 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2006 (char*)cmdsetContentTimeout_.c_str(),
2007 (char*)"-v",
2008 (char*)"0",
2009 (char*)" ",
2010 };
2011 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2012 AccessibilityAbilityShellCommand cmd(argc, argv);
2013 ErrCode result = cmd.RunAsSetContentTimeout();
2014 EXPECT_EQ(result, OHOS::ERR_OK);
2015 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
2016 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0100 end";
2017 }
2018
2019 /**
2020 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200
2021 * @tc.name: RunAsSetContentTimeout
2022 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(OHOS::ERR_OK)
2023 */
2024 HWTEST_F(AccessibilityAbilityShellCommandTest,
2025 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200, TestSize.Level1)
2026 {
2027 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 start";
2028 char* argv[] = {
2029 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2030 (char*)cmdsetContentTimeout_.c_str(),
2031 (char*)"-v",
2032 (char*)"5000",
2033 (char*)" ",
2034 };
2035 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2036
2037 AccessibilityAbilityShellCommand cmd(argc, argv);
2038 ErrCode result = cmd.RunAsSetContentTimeout();
2039 EXPECT_EQ(result, OHOS::ERR_OK);
2040 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_CONTENT_TIME_OK + "\n");
2041 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0200 end";
2042 }
2043
2044 /**
2045 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300
2046 * @tc.name: RunAsSetContentTimeout
2047 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.(value is invalid)
2048 */
2049 HWTEST_F(AccessibilityAbilityShellCommandTest,
2050 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300, TestSize.Level1)
2051 {
2052 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 start";
2053 char* argv[] = {
2054 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2055 (char*)cmdsetContentTimeout_.c_str(),
2056 (char*)"-v",
2057 (char*)"5001",
2058 (char*)" ",
2059 };
2060 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2061 AccessibilityAbilityShellCommand cmd(argc, argv);
2062 ErrCode result = cmd.RunAsSetContentTimeout();
2063 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2064 EXPECT_EQ(cmd.resultReceiver_, "setContentTimeout: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2065 "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
2066 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0300 end";
2067 }
2068
2069 /**
2070 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400
2071 * @tc.name: RunAsSetContentTimeout
2072 * @tc.desc: Test whether RunAsSetContentTimeout is called normally.
2073 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2074 */
2075 HWTEST_F(AccessibilityAbilityShellCommandTest,
2076 AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400, TestSize.Level1)
2077 {
2078 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 start";
2079 char* argv[] = {
2080 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2081 };
2082 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2083 AccessibilityAbilityShellCommand cmd(argc, argv);
2084 ErrCode result = cmd.RunAsSetContentTimeout();
2085 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2086 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_CONTENT_TIME_OUT);
2087 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetContentTimeout_0400 end";
2088 }
2089
2090 /**
2091 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100
2092 * @tc.name: RunAsSetAnimationOffState
2093 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
2094 */
2095 HWTEST_F(AccessibilityAbilityShellCommandTest,
2096 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100, TestSize.Level1)
2097 {
2098 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 start";
2099 char* argv[] = {
2100 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2101 (char*)cmdsetAnimationOffState_.c_str(),
2102 (char*)"-v",
2103 (char*)"0",
2104 (char*)" ",
2105 };
2106 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2107 AccessibilityAbilityShellCommand cmd(argc, argv);
2108 ErrCode result = cmd.RunAsSetAnimationOffState();
2109 EXPECT_EQ(result, OHOS::ERR_OK);
2110 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
2111 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0100 end";
2112 }
2113
2114 /**
2115 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200
2116 * @tc.name: RunAsSetAnimationOffState
2117 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(OHOS::ERR_OK)
2118 */
2119 HWTEST_F(AccessibilityAbilityShellCommandTest,
2120 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200, TestSize.Level1)
2121 {
2122 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 start";
2123 char* argv[] = {
2124 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2125 (char*)cmdsetAnimationOffState_.c_str(),
2126 (char*)"-v",
2127 (char*)"1",
2128 (char*)" ",
2129 };
2130 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2131 AccessibilityAbilityShellCommand cmd(argc, argv);
2132 ErrCode result = cmd.RunAsSetAnimationOffState();
2133 EXPECT_EQ(result, OHOS::ERR_OK);
2134 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_ANIMATION_OFF_STATE_OK + "\n");
2135 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0200 end";
2136 }
2137
2138 /**
2139 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300
2140 * @tc.name: RunAsSetAnimationOffState
2141 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.(value is invalid)
2142 */
2143 HWTEST_F(AccessibilityAbilityShellCommandTest,
2144 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300, TestSize.Level1)
2145 {
2146 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 start";
2147 char* argv[] = {
2148 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2149 (char*)cmdsetAnimationOffState_.c_str(),
2150 (char*)"-v",
2151 (char*)"2",
2152 (char*)" ",
2153 };
2154 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2155 AccessibilityAbilityShellCommand cmd(argc, argv);
2156 ErrCode result = cmd.RunAsSetAnimationOffState();
2157 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2158 EXPECT_EQ(cmd.resultReceiver_, "setAnimationOffState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2159 "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2160 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0300 end";
2161 }
2162
2163 /**
2164 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400
2165 * @tc.name: RunAsSetAnimationOffState
2166 * @tc.desc: Test whether RunAsSetAnimationOffState is called normally.
2167 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2168 */
2169 HWTEST_F(AccessibilityAbilityShellCommandTest,
2170 AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400, TestSize.Level1)
2171 {
2172 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 start";
2173 char* argv[] = {
2174 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2175 };
2176 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2177 AccessibilityAbilityShellCommand cmd(argc, argv);
2178 ErrCode result = cmd.RunAsSetAnimationOffState();
2179 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2180 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_ANIMATION_OFF_STATE);
2181 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAnimationOffState_0400 end";
2182 }
2183
2184 /**
2185 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100
2186 * @tc.name: RunAsSetBrightnessDiscount
2187 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2188 * 2.ret is not Accessibility::RET_OK
2189 */
2190 HWTEST_F(AccessibilityAbilityShellCommandTest,
2191 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100, TestSize.Level1)
2192 {
2193 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 start";
2194 char* argv[] = {
2195 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2196 (char*)cmdsetBrightnessDiscount_.c_str(),
2197 (char*)"-v",
2198 (char*)"0",
2199 (char*)" ",
2200 };
2201 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2202
2203 AccessibilityAbilityShellCommand cmd(argc, argv);
2204 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2205 MockSetBrightnessDiscount(false);
2206 EXPECT_EQ(result, OHOS::ERR_OK);
2207 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_OK + "\n");
2208 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0100 end";
2209 }
2210
2211 /**
2212 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200
2213 * @tc.name: RunAsSetBrightnessDiscount
2214 * @tc.desc: 1.Test whether RunAsSetBrightnessDiscount is called normally.(OHOS::ERR_OK)
2215 * 2.ret is Accessibility::RET_OK
2216 */
2217 HWTEST_F(AccessibilityAbilityShellCommandTest,
2218 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200, TestSize.Level1)
2219 {
2220 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 start";
2221 char* argv[] = {
2222 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2223 (char*)cmdsetBrightnessDiscount_.c_str(),
2224 (char*)"-v",
2225 (char*)"100",
2226 (char*)" ",
2227 };
2228 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2229 AccessibilityAbilityShellCommand cmd(argc, argv);
2230 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2231 MockSetBrightnessDiscount(true);
2232 EXPECT_EQ(result, OHOS::ERR_OK);
2233 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_BRIGHTNESS_DISCOUNT_NG);
2234 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0200 end";
2235 }
2236
2237 /**
2238 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300
2239 * @tc.name: RunAsSetBrightnessDiscount
2240 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.(value is invalid)
2241 */
2242 HWTEST_F(AccessibilityAbilityShellCommandTest,
2243 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300, TestSize.Level1)
2244 {
2245 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 start";
2246 char* argv[] = {
2247 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2248 (char*)cmdsetBrightnessDiscount_.c_str(),
2249 (char*)"-v",
2250 (char*)"101",
2251 (char*)" ",
2252 };
2253 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2254 AccessibilityAbilityShellCommand cmd(argc, argv);
2255 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2256 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2257 EXPECT_EQ(cmd.resultReceiver_, "setSetBrightnessDiscount: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2258 "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2259 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0300 end";
2260 }
2261
2262 /**
2263 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400
2264 * @tc.name: RunAsSetBrightnessDiscount
2265 * @tc.desc: Test whether RunAsSetBrightnessDiscount is called normally.
2266 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2267 */
2268 HWTEST_F(AccessibilityAbilityShellCommandTest,
2269 AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400, TestSize.Level1)
2270 {
2271 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 start";
2272 char* argv[] = {
2273 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2274 };
2275 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2276 AccessibilityAbilityShellCommand cmd(argc, argv);
2277 ErrCode result = cmd.RunAsSetBrightnessDiscount();
2278 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2279 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_BRIGHTNESS_DISCOUNT);
2280 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetBrightnessDiscount_0400 end";
2281 }
2282
2283 /**
2284 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100
2285 * @tc.name: RunAsSetAudioMonoState
2286 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2287 */
2288 HWTEST_F(AccessibilityAbilityShellCommandTest,
2289 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100, TestSize.Level1)
2290 {
2291 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 start";
2292 char* argv[] = {
2293 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2294 (char*)cmdsetAudioMonoState_.c_str(),
2295 (char*)"-v",
2296 (char*)"0",
2297 (char*)" ",
2298 };
2299 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2300 AccessibilityAbilityShellCommand cmd(argc, argv);
2301 ErrCode result = cmd.RunAsSetAudioMonoState();
2302 EXPECT_EQ(result, OHOS::ERR_OK);
2303 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2304 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0100 end";
2305 }
2306
2307 /**
2308 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200
2309 * @tc.name: RunAsSetAudioMonoState
2310 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(OHOS::ERR_OK)
2311 */
2312 HWTEST_F(AccessibilityAbilityShellCommandTest,
2313 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200, TestSize.Level1)
2314 {
2315 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 start";
2316 char* argv[] = {
2317 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2318 (char*)cmdsetAudioMonoState_.c_str(),
2319 (char*)"-v",
2320 (char*)"1",
2321 (char*)" ",
2322 };
2323 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2324 AccessibilityAbilityShellCommand cmd(argc, argv);
2325 ErrCode result = cmd.RunAsSetAudioMonoState();
2326 EXPECT_EQ(result, OHOS::ERR_OK);
2327 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_MONO_STATE_OK + "\n");
2328 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0200 end";
2329 }
2330
2331 /**
2332 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300
2333 * @tc.name: RunAsSetAudioMonoState
2334 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.(value is invalid)
2335 */
2336 HWTEST_F(AccessibilityAbilityShellCommandTest,
2337 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300, TestSize.Level1)
2338 {
2339 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 start";
2340 char* argv[] = {
2341 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2342 (char*)cmdsetAudioMonoState_.c_str(),
2343 (char*)"-v",
2344 (char*)"2",
2345 (char*)" ",
2346 };
2347 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2348 AccessibilityAbilityShellCommand cmd(argc, argv);
2349 ErrCode result = cmd.RunAsSetAudioMonoState();
2350 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2351 EXPECT_EQ(cmd.resultReceiver_, "setAudioMonoState: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2352 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2353 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0300 end";
2354 }
2355
2356 /**
2357 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400
2358 * @tc.name: RunAsSetAudioMonoState
2359 * @tc.desc: Test whether RunAsSetAudioMonoState is called normally.
2360 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2361 */
2362 HWTEST_F(AccessibilityAbilityShellCommandTest,
2363 AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400, TestSize.Level1)
2364 {
2365 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 start";
2366 char* argv[] = {
2367 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2368 };
2369 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2370 AccessibilityAbilityShellCommand cmd(argc, argv);
2371 ErrCode result = cmd.RunAsSetAudioMonoState();
2372 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2373 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_MONO_STATE);
2374 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioMonoState_0400 end";
2375 }
2376
2377 /**
2378 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100
2379 * @tc.name: RunAsSetAudioBalance
2380 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
2381 */
2382 HWTEST_F(AccessibilityAbilityShellCommandTest,
2383 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100, TestSize.Level1)
2384 {
2385 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 start";
2386 char* argv[] = {
2387 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2388 (char*)cmdsetAudioBalance_.c_str(),
2389 (char*)"-v",
2390 (char*)"-100",
2391 (char*)" ",
2392 };
2393 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2394 AccessibilityAbilityShellCommand cmd(argc, argv);
2395 ErrCode result = cmd.RunAsSetAudioBalance();
2396 EXPECT_EQ(result, OHOS::ERR_OK);
2397 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n");
2398 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 end";
2399 }
2400
2401 /**
2402 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200
2403 * @tc.name: RunAsSetAudioBalance
2404 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
2405 */
2406 HWTEST_F(AccessibilityAbilityShellCommandTest,
2407 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200, TestSize.Level1)
2408 {
2409 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 start";
2410 char* argv[] = {
2411 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2412 (char*)cmdsetAudioBalance_.c_str(),
2413 (char*)"-v",
2414 (char*)"100",
2415 (char*)" ",
2416 };
2417 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2418 AccessibilityAbilityShellCommand cmd(argc, argv);
2419 ErrCode result = cmd.RunAsSetAudioBalance();
2420 EXPECT_EQ(result, OHOS::ERR_OK);
2421 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK + "\n");
2422 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 end";
2423 }
2424
2425 /**
2426 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300
2427 * @tc.name: RunAsSetAudioBalance
2428 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(value is invalid)
2429 */
2430 HWTEST_F(AccessibilityAbilityShellCommandTest,
2431 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300, TestSize.Level1)
2432 {
2433 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 start";
2434 char* argv[] = {
2435 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2436 (char*)cmdsetAudioBalance_.c_str(),
2437 (char*)"-v",
2438 (char*)"101",
2439 (char*)" ",
2440 };
2441 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2442 AccessibilityAbilityShellCommand cmd(argc, argv);
2443 ErrCode result = cmd.RunAsSetAudioBalance();
2444 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2445 EXPECT_EQ(cmd.resultReceiver_, "setAudioBalance: "+ ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
2446 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
2447 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 end";
2448 }
2449
2450 /**
2451 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400
2452 * @tc.name: RunAsSetAudioBalance
2453 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.
2454 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2455 */
2456 HWTEST_F(AccessibilityAbilityShellCommandTest,
2457 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400, TestSize.Level1)
2458 {
2459 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 start";
2460 char* argv[] = {
2461 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2462 };
2463 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2464 AccessibilityAbilityShellCommand cmd(argc, argv);
2465 ErrCode result = cmd.RunAsSetAudioBalance();
2466 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2467 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
2468 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 end";
2469 }
2470
2471 /**
2472 * @tc.number: AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100
2473 * @tc.name: MakeSetShortKeyTargetCommandArgumentFromCmd
2474 * @tc.desc: Test whether MakeSetShortKeyTargetCommandArgumentFromCmd is called normally.
2475 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,MakeCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
2476 */
2477 HWTEST_F(AccessibilityAbilityShellCommandTest,
2478 AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100, TestSize.Level1)
2479 {
2480 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 start";
2481 AccessibilityCommandArgument argument;
2482 optind = 5;
2483 std::string resultMessage;
2484 char* argv[] = {
2485 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2486 (char*)cmdsetShortKeyTarget_.c_str(),
2487 (char*)"-a",
2488 (char*)"ability",
2489 (char*)"-b",
2490 (char*)"bundle",
2491 (char*)" ",
2492 };
2493 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2494 AccessibilityAbilityShellCommand cmd(argc, argv);
2495 ErrCode result = cmd.MakeSetShortKeyTargetCommandArgumentFromCmd(argument);
2496 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2497 EXPECT_EQ(cmd.resultReceiver_, "setShortkeyTarget: " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
2498 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 end";
2499 }
2500
2501 /**
2502 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100
2503 * @tc.name: MakeSetCommandArgumentFromCmd
2504 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(OHOS::ERR_OK)
2505 */
2506 HWTEST_F(AccessibilityAbilityShellCommandTest,
2507 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100, TestSize.Level1)
2508 {
2509 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 start";
2510 AccessibilityCommandArgument argument;
2511 std::string resultMessage;
2512 char* argv[] = {
2513 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2514 (char*)cmdsetShortKeyState_.c_str(),
2515 (char*)"-v",
2516 (char*)"0",
2517 (char*)" ",
2518 };
2519 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2520 AccessibilityAbilityShellCommand cmd(argc, argv);
2521 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2522 EXPECT_EQ(result, OHOS::ERR_OK);
2523 EXPECT_EQ(cmd.resultReceiver_, ": ");
2524 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 end";
2525 }
2526
2527 /**
2528 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200
2529 * @tc.name: MakeSetCommandArgumentFromCmd
2530 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(optind < 0)
2531 */
2532 HWTEST_F(AccessibilityAbilityShellCommandTest,
2533 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200, TestSize.Level1)
2534 {
2535 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 start";
2536 AccessibilityCommandArgument argument;
2537 optind = -1;
2538 char* argv[] = {
2539 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2540 };
2541 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2542 AccessibilityAbilityShellCommand cmd(argc, argv);
2543 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2544 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2545 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 end";
2546 }
2547
2548 /**
2549 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300
2550 * @tc.name: MakeSetCommandArgumentFromCmd
2551 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = -1)
2552 */
2553 HWTEST_F(AccessibilityAbilityShellCommandTest,
2554 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300, TestSize.Level1)
2555 {
2556 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 start";
2557 AccessibilityCommandArgument argument;
2558 char* argv[] = {
2559 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2560 (char*)cmdsetShortKeyState_.c_str(),
2561 };
2562 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2563 AccessibilityAbilityShellCommand cmd(argc, argv);
2564 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2565 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2566 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
2567 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 end";
2568 }
2569
2570 /**
2571 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400
2572 * @tc.name: MakeSetCommandArgumentFromCmd
2573 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = ?)
2574 */
2575 HWTEST_F(AccessibilityAbilityShellCommandTest,
2576 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400, TestSize.Level1)
2577 {
2578 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 start";
2579 AccessibilityCommandArgument argument;
2580 char* argv[] = {
2581 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2582 (char*)cmdsetShortKeyState_.c_str(),
2583 (char*)"-v",
2584 (char*)" ",
2585 };
2586 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2587 AccessibilityAbilityShellCommand cmd(argc, argv);
2588 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2589 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2590 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE);
2591 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 end";
2592 }
2593
2594 /**
2595 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500
2596 * @tc.name: MakeSetCommandArgumentFromCmd
2597 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = default)
2598 */
2599 HWTEST_F(AccessibilityAbilityShellCommandTest,
2600 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500, TestSize.Level1)
2601 {
2602 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 start";
2603 AccessibilityCommandArgument argument;
2604 char* argv[] = {
2605 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2606 (char*)cmdsetShortKeyState_.c_str(),
2607 (char*)"-a",
2608 (char*)" ",
2609 };
2610 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2611 AccessibilityAbilityShellCommand cmd(argc, argv);
2612 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
2613 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2614 EXPECT_EQ(cmd.resultReceiver_, ": unknown arguments -a ");
2615 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 end";
2616 }
2617
2618 /**
2619 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100
2620 * @tc.name: MakeCommandArgumentFromCmd
2621 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK)
2622 */
2623 HWTEST_F(AccessibilityAbilityShellCommandTest,
2624 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100, TestSize.Level1)
2625 {
2626 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 start";
2627 AccessibilityCommandArgument argument;
2628 optind = 5;
2629 char* argv[] = {
2630 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2631 (char*)cmdsetShortKeyTarget_.c_str(),
2632 (char*)"-a",
2633 (char*)"ability",
2634 (char*)"-b",
2635 (char*)"bundle",
2636 (char*)" ",
2637 };
2638 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2639 AccessibilityAbilityShellCommand cmd(argc, argv);
2640 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2641 EXPECT_EQ(result, OHOS::ERR_OK);
2642 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 end";
2643 }
2644
2645 /**
2646 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200
2647 * @tc.name: MakeCommandArgumentFromCmd
2648 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK，option a b)
2649 */
2650 HWTEST_F(AccessibilityAbilityShellCommandTest,
2651 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200, TestSize.Level1)
2652 {
2653 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 start";
2654 AccessibilityCommandArgument argument;
2655 char* argv[] = {
2656 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2657 (char*)cmdsetShortKeyTarget_.c_str(),
2658 (char*)"-a",
2659 (char*)"ability",
2660 (char*)"-b",
2661 (char*)"bundle",
2662 (char*)"-v",
2663 (char*)"value",
2664 (char*)" ",
2665 };
2666 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2667 AccessibilityAbilityShellCommand cmd(argc, argv);
2668 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2669 EXPECT_EQ(result, OHOS::ERR_OK);
2670 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 end";
2671 }
2672
2673 /**
2674 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300
2675 * @tc.name: MakeCommandArgumentFromCmd
2676 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(missing options)
2677 */
2678 HWTEST_F(AccessibilityAbilityShellCommandTest,
2679 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300, TestSize.Level1)
2680 {
2681 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 start";
2682 AccessibilityCommandArgument argument;
2683 char* argv[] = {
2684 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2685 (char*)cmdsetShortKeyTarget_.c_str(),
2686 (char*)" ",
2687 };
2688 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2689 AccessibilityAbilityShellCommand cmd(argc, argv);
2690 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2691 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2692 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
2693 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 end";
2694 }
2695
2696 /**
2697 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400
2698 * @tc.name: MakeCommandArgumentFromCmd
2699 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_ABILITY)
2700 */
2701 HWTEST_F(AccessibilityAbilityShellCommandTest,
2702 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400, TestSize.Level1)
2703 {
2704 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 start";
2705 AccessibilityCommandArgument argument;
2706 char* argv[] = {
2707 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2708 (char*)cmdsetShortKeyTarget_.c_str(),
2709 (char*)"-a",
2710 (char*)" ",
2711 };
2712 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2713 AccessibilityAbilityShellCommand cmd(argc, argv);
2714 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2715 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2716 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
2717 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 end";
2718 }
2719
2720 /**
2721 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500
2722 * @tc.name: MakeCommandArgumentFromCmd
2723 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_BUNDLE)
2724 */
2725 HWTEST_F(AccessibilityAbilityShellCommandTest,
2726 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500, TestSize.Level1)
2727 {
2728 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 start";
2729 AccessibilityCommandArgument argument;
2730 char* argv[] = {
2731 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2732 (char*)cmdsetShortKeyTarget_.c_str(),
2733 (char*)"-a",
2734 (char*)"ability",
2735 (char*)"-b",
2736 (char*)" ",
2737 };
2738 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2739 AccessibilityAbilityShellCommand cmd(argc, argv);
2740 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2741 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2742 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
2743 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 end";
2744 }
2745
2746 /**
2747 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600
2748 * @tc.name: MakeCommandArgumentFromCmd
2749 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(optind = -1)
2750 */
2751 HWTEST_F(AccessibilityAbilityShellCommandTest,
2752 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600, TestSize.Level1)
2753 {
2754 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 start";
2755 AccessibilityCommandArgument argument;
2756 optind = -1;
2757 char* argv[] = {
2758 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2759 };
2760 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2761 AccessibilityAbilityShellCommand cmd(argc, argv);
2762 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
2763 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2764 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 end";
2765 }
2766
2767 /**
2768 * @tc.number: AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100
2769 * @tc.name: MakeDisableCommandArgumentFromCmd
2770 * @tc.desc: Test whether MakeDisableCommandArgumentFromCmd is called normally.
2771 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,CheckDisableCommandArgument = OHOS::ERR_INVALID_VALUE)
2772 */
2773 HWTEST_F(AccessibilityAbilityShellCommandTest,
2774 AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100, TestSize.Level1)
2775 {
2776 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 start";
2777 AccessibilityCommandArgument argument;
2778 argument.abilityArgumentNum = 1;
2779 argument.abilityName = "ability";
2780 argument.bundleArgumentNum = 1;
2781 argument.bundleName = "bundle";
2782 argument.capabilityNamesArgumentNum = 0;
2783 argument.unknownArgumentNum = 0;
2784 char* argv[] = {
2785 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2786 (char*)cmddisable_.c_str(),
2787 (char*)"-a",
2788 (char*)"ability",
2789 (char*)"-b",
2790 (char*)"bundle",
2791 (char*)" ",
2792 };
2793 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2794 AccessibilityAbilityShellCommand cmd(argc, argv);
2795 ErrCode result = cmd.MakeDisableCommandArgumentFromCmd(argument);
2796 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2797 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 end";
2798 }
2799
2800 /**
2801 * @tc.number: AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100
2802 * @tc.name: CheckDisableCommandArgument
2803 * @tc.desc: Test whether CheckDisableCommandArgument is called normally.
2804 * (CheckCommandArgument = OHOS::ERR_INVALID_VALUE)
2805 */
2806 HWTEST_F(AccessibilityAbilityShellCommandTest,
2807 AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100, TestSize.Level1)
2808 {
2809 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 start";
2810 AccessibilityCommandArgument argument;
2811 std::string resultMessage;
2812 argument.abilityArgumentNum = 1;
2813 argument.abilityName = "ability";
2814 argument.bundleArgumentNum = 1;
2815 argument.bundleName = "bundle";
2816 argument.capabilityNamesArgumentNum = 0;
2817 argument.unknownArgumentNum = 0;
2818 char* argv[] = {
2819 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2820 };
2821 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2822 AccessibilityAbilityShellCommand cmd(argc, argv);
2823 ErrCode result = cmd.CheckDisableCommandArgument(argument,resultMessage);
2824 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2825 EXPECT_EQ(resultMessage, ": the auxiliary application bundle/ability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
2826 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 end";
2827 }
2828
2829 /**
2830 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0100
2831 * @tc.name: CheckCommandArgument
2832 * @tc.desc: Test whether CheckCommandArgument is called normally.(totalArgumentNum > 2)
2833 */
2834 HWTEST_F(AccessibilityAbilityShellCommandTest,
2835 AccessibilityAbilityShellCommand_CheckCommandArgument_0100, TestSize.Level1)
2836 {
2837 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 start";
2838 AccessibilityCommandArgument argument;
2839 std::string resultMessage;
2840 argument.abilityArgumentNum = 2;
2841 argument.abilityName = "ability";
2842 argument.bundleArgumentNum = 1;
2843 argument.bundleName = "bundle";
2844 argument.capabilityNamesArgumentNum = 0;
2845 argument.unknownArgumentNum = 1;
2846 char* argv[] = {
2847 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2848 };
2849 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2850 AccessibilityAbilityShellCommand cmd(argc, argv);
2851 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2852 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2853 EXPECT_EQ(resultMessage, ": and exist duplicated arguments.and exist unknown arguments ");
2854 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
2855 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 end";
2856 }
2857
2858 /**
2859 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0200
2860 * @tc.name: CheckCommandArgument
2861 * @tc.desc: Test whether CheckCommandArgument is called normally.(unknownArgumentNum > 0)
2862 */
2863 HWTEST_F(AccessibilityAbilityShellCommandTest,
2864 AccessibilityAbilityShellCommand_CheckCommandArgument_0200, TestSize.Level1)
2865 {
2866 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 start";
2867 AccessibilityCommandArgument argument;
2868 std::string resultMessage;
2869 argument.abilityArgumentNum = 0;
2870 argument.abilityName = "ability";
2871 argument.bundleArgumentNum = 0;
2872 argument.bundleName = "bundle";
2873 argument.capabilityNamesArgumentNum = 0;
2874 argument.unknownArgumentNum = 1;
2875 char* argv[] = {
2876 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2877 };
2878 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2879 AccessibilityAbilityShellCommand cmd(argc, argv);
2880 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2881 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2882 EXPECT_EQ(resultMessage, ": unknown arguments ");
2883 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 end";
2884 }
2885
2886 /**
2887 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0300
2888 * @tc.name: CheckCommandArgument
2889 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckAbilityArgument = false)
2890 */
2891 HWTEST_F(AccessibilityAbilityShellCommandTest,
2892 AccessibilityAbilityShellCommand_CheckCommandArgument_0300, TestSize.Level1)
2893 {
2894 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 start";
2895 AccessibilityCommandArgument argument;
2896 std::string resultMessage;
2897 argument.abilityArgumentNum = 0;
2898 argument.abilityName = "ability";
2899 argument.bundleArgumentNum = 1;
2900 argument.bundleName = "bundle";
2901 argument.capabilityNamesArgumentNum = 1;
2902 argument.unknownArgumentNum = 0;
2903 char* argv[] = {
2904 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2905 };
2906 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2907 AccessibilityAbilityShellCommand cmd(argc, argv);
2908 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2909 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2910 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
2911 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 end";
2912 }
2913
2914 /**
2915 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0400
2916 * @tc.name: CheckCommandArgument
2917 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckBundleArgument = false)
2918 */
2919 HWTEST_F(AccessibilityAbilityShellCommandTest,
2920 AccessibilityAbilityShellCommand_CheckCommandArgument_0400, TestSize.Level1)
2921 {
2922 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 start";
2923 AccessibilityCommandArgument argument;
2924 std::string resultMessage;
2925 argument.abilityArgumentNum = 1;
2926 argument.abilityName = "ability";
2927 argument.bundleArgumentNum = 0;
2928 argument.bundleName = "bundle";
2929 argument.capabilityNamesArgumentNum = 1;
2930 argument.unknownArgumentNum = 0;
2931 char* argv[] = {
2932 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2933 };
2934 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2935 AccessibilityAbilityShellCommand cmd(argc, argv);
2936 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2937 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2938 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
2939 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 end";
2940 }
2941
2942 /**
2943 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0500
2944 * @tc.name: CheckCommandArgument
2945 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckParamValidity = false)
2946 */
2947 HWTEST_F(AccessibilityAbilityShellCommandTest,
2948 AccessibilityAbilityShellCommand_CheckCommandArgument_0500, TestSize.Level1)
2949 {
2950 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 start";
2951 AccessibilityCommandArgument argument;
2952 std::string resultMessage;
2953 argument.abilityArgumentNum = 1;
2954 argument.abilityName = "ability";
2955 argument.bundleArgumentNum = 1;
2956 argument.bundleName = "bundle";
2957 argument.capabilityNamesArgumentNum = 0;
2958 argument.unknownArgumentNum = 0;
2959 char* argv[] = {
2960 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
2961 };
2962 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
2963 AccessibilityAbilityShellCommand cmd(argc, argv);
2964 ErrCode result = cmd.CheckCommandArgument(argument,resultMessage);
2965 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2966 EXPECT_EQ(resultMessage, ": the auxiliary application " +
2967 argument.bundleName + "/" + argument.abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
2968 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 end";
2969 }
2970 } // namespace AAFwk
2971 } // namespace OHOS
2972