1 /*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #define private public
19 #define protected public
20 #include "accessibility_ability_command.h"
21 #undef private
22 #undef protected
23 #include "accessibility_ability_command_common_test.h"
24
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::AAFwk;
28
29 namespace OHOS {
30 namespace AAFwk {
31 class AccessibilityAbilityShellCommandSecondTest : public ::testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37
38 std::string cmdHelp_ = "help";
39 std::string cmdEnable_ = "enable";
40 std::string cmdDisable_ = "disable";
41 std::string cmdsetShortKeyState_ = "setShortKeyState";
42 std::string cmdsetMouseKeyState_ = "setMouseKeyState";
43 std::string cmdsetCaptionState_ = "setCaptionState";
44 std::string cmdsSetMouseAutoClick_ = "setMouseAutoClick";
45 std::string cmdsetShortKeyTarget_ = "setShortKeyTarget";
46 std::string cmdsetHighContrastTextState_ = "setHighContrastTextState";
47 std::string cmdsetInvertColorState_ = "setInvertColorState";
48 std::string cmdsetDaltonizationColorFilter_ = "setDaltonizationColorFilter";
49 std::string cmdsetContentTimeout_ = "setContentTimeout";
50 std::string cmdsetAnimationOffState_ = "setAnimationOffState";
51 std::string cmdsetBrightnessDiscount_ = "setBrightnessDiscount";
52 std::string cmdsetAudioMonoState_ = "setAudioMonoState";
53 std::string cmdsetAudioBalance_ = "setAudioBalance";
54 std::string cmdSetScreenMagnificationState_ = "setScreenMagnificationState";
55 };
56
SetUpTestCase()57 void AccessibilityAbilityShellCommandSecondTest::SetUpTestCase()
58 {}
59
TearDownTestCase()60 void AccessibilityAbilityShellCommandSecondTest::TearDownTestCase()
61 {}
62
SetUp()63 void AccessibilityAbilityShellCommandSecondTest::SetUp()
64 {
65 // reset optind to 0
66 optind = 0;
67 }
68
TearDown()69 void AccessibilityAbilityShellCommandSecondTest::TearDown()
70 {}
71 /**
72 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100
73 * @tc.name: RunAsSetAudioBalance
74 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
75 */
76 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
77 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 start";
80 char* argv[] = {
81 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
82 (char*)cmdsetAudioBalance_.c_str(),
83 (char*)"-v",
84 (char*)"-100",
85 (char*)" ",
86 };
87 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
88 AccessibilityAbilityShellCommand cmd(argc, argv);
89 ErrCode result = cmd.RunAsSetAudioBalance();
90 EXPECT_EQ(result, OHOS::ERR_OK);
91 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK);
92 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0100 end";
93 }
94
95 /**
96 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200
97 * @tc.name: RunAsSetAudioBalance
98 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(OHOS::ERR_OK)
99 */
100 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
101 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200, TestSize.Level1)
102 {
103 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 start";
104 char* argv[] = {
105 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
106 (char*)cmdsetAudioBalance_.c_str(),
107 (char*)"-v",
108 (char*)"100",
109 (char*)" ",
110 };
111 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
112 AccessibilityAbilityShellCommand cmd(argc, argv);
113 ErrCode result = cmd.RunAsSetAudioBalance();
114 EXPECT_EQ(result, OHOS::ERR_OK);
115 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_SET_AUDIO_BALANCE_OK);
116 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0200 end";
117 }
118
119 /**
120 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300
121 * @tc.name: RunAsSetAudioBalance
122 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.(value is invalid)
123 */
124 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
125 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300, TestSize.Level1)
126 {
127 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 start";
128 char* argv[] = {
129 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
130 (char*)cmdsetAudioBalance_.c_str(),
131 (char*)"-v",
132 (char*)"101",
133 (char*)" ",
134 };
135 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
136 AccessibilityAbilityShellCommand cmd(argc, argv);
137 ErrCode result = cmd.RunAsSetAudioBalance();
138 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
139 EXPECT_EQ(cmd.resultReceiver_, "setAudioBalance: " + ACCESSIBILITY_ABILITY_SET_VALUE_INVALID +
140 "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
141 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0300 end";
142 }
143
144 /**
145 * @tc.number: AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400
146 * @tc.name: RunAsSetAudioBalance
147 * @tc.desc: Test whether RunAsSetAudioBalance is called normally.
148 * (MakeSetCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
149 */
150 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
151 AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 start";
154 char* argv[] = {
155 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
156 };
157 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
158 AccessibilityAbilityShellCommand cmd(argc, argv);
159 ErrCode result = cmd.RunAsSetAudioBalance();
160 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
161 EXPECT_EQ(cmd.resultReceiver_, "\n" + ACCESSIBILITY_HELP_MSG_SET_AUDIO_BALANCE);
162 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_RunAsSetAudioBalance_0400 end";
163 }
164
165 /**
166 * @tc.number: AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100
167 * @tc.name: MakeSetShortKeyTargetCommandArgumentFromCmd
168 * @tc.desc: Test whether MakeSetShortKeyTargetCommandArgumentFromCmd is called normally.
169 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,MakeCommandArgumentFromCmd = OHOS::ERR_INVALID_VALUE)
170 */
171 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
172 AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100, TestSize.Level1)
173 {
174 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 start";
175 AccessibilityCommandArgument argument;
176 optind = 5;
177 std::string resultMessage;
178 char* argv[] = {
179 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
180 (char*)cmdsetShortKeyTarget_.c_str(),
181 (char*)"-a",
182 (char*)"ability",
183 (char*)"-b",
184 (char*)"bundle",
185 (char*)" ",
186 };
187 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
188 AccessibilityAbilityShellCommand cmd(argc, argv);
189 ErrCode result = cmd.MakeSetShortKeyTargetCommandArgumentFromCmd(argument);
190 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
191 EXPECT_EQ(cmd.resultReceiver_, "setShortkeyTarget: " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
192 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetShortKeyTargetCommandArgumentFromCmd_0100 end";
193 }
194
195 /**
196 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100
197 * @tc.name: MakeSetCommandArgumentFromCmd
198 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(OHOS::ERR_OK)
199 */
200 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
201 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100, TestSize.Level1)
202 {
203 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 start";
204 AccessibilityCommandArgument argument;
205 std::string resultMessage;
206 char* argv[] = {
207 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
208 (char*)cmdsetShortKeyState_.c_str(),
209 (char*)"-v",
210 (char*)"0",
211 (char*)" ",
212 };
213 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
214 AccessibilityAbilityShellCommand cmd(argc, argv);
215 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
216 EXPECT_EQ(result, OHOS::ERR_OK);
217 EXPECT_EQ(cmd.resultReceiver_, ": ");
218 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0100 end";
219 }
220
221 /**
222 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200
223 * @tc.name: MakeSetCommandArgumentFromCmd
224 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(optind < 0)
225 */
226 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
227 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200, TestSize.Level1)
228 {
229 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 start";
230 AccessibilityCommandArgument argument;
231 optind = -1;
232 char* argv[] = {
233 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
234 };
235 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
236 AccessibilityAbilityShellCommand cmd(argc, argv);
237 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
238 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
239 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0200 end";
240 }
241
242 /**
243 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300
244 * @tc.name: MakeSetCommandArgumentFromCmd
245 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = -1)
246 */
247 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
248 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300, TestSize.Level1)
249 {
250 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 start";
251 AccessibilityCommandArgument argument;
252 char* argv[] = {
253 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
254 (char*)cmdsetShortKeyState_.c_str(),
255 };
256 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
257 AccessibilityAbilityShellCommand cmd(argc, argv);
258 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
259 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
260 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
261 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0300 end";
262 }
263
264 /**
265 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400
266 * @tc.name: MakeSetCommandArgumentFromCmd
267 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = ?)
268 */
269 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
270 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400, TestSize.Level1)
271 {
272 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 start";
273 AccessibilityCommandArgument argument;
274 char* argv[] = {
275 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
276 (char*)cmdsetShortKeyState_.c_str(),
277 (char*)"-v",
278 (char*)" ",
279 };
280 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
281 AccessibilityAbilityShellCommand cmd(argc, argv);
282 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
283 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
284 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_SET_ARGUMENT_VALUE);
285 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0400 end";
286 }
287
288 /**
289 * @tc.number: AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500
290 * @tc.name: MakeSetCommandArgumentFromCmd
291 * @tc.desc: Test whether MakeSetCommandArgumentFromCmd is called normally.(option = default)
292 */
293 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
294 AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500, TestSize.Level1)
295 {
296 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 start";
297 AccessibilityCommandArgument argument;
298 char* argv[] = {
299 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
300 (char*)cmdsetShortKeyState_.c_str(),
301 (char*)"-a",
302 (char*)" ",
303 };
304 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
305 AccessibilityAbilityShellCommand cmd(argc, argv);
306 ErrCode result = cmd.MakeSetCommandArgumentFromCmd(argument);
307 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
308 EXPECT_EQ(cmd.resultReceiver_, ": unknown arguments -a ");
309 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeSetCommandArgumentFromCmd_0500 end";
310 }
311
312 /**
313 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100
314 * @tc.name: MakeCommandArgumentFromCmd
315 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK)
316 */
317 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
318 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100, TestSize.Level1)
319 {
320 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 start";
321 AccessibilityCommandArgument argument;
322 optind = 5;
323 char* argv[] = {
324 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
325 (char*)cmdsetShortKeyTarget_.c_str(),
326 (char*)"-a",
327 (char*)"ability",
328 (char*)"-b",
329 (char*)"bundle",
330 (char*)" ",
331 };
332 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
333 AccessibilityAbilityShellCommand cmd(argc, argv);
334 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
335 EXPECT_EQ(result, OHOS::ERR_OK);
336 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0100 end";
337 }
338
339 /**
340 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200
341 * @tc.name: MakeCommandArgumentFromCmd
342 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(return OHOS::ERR_OK，option a b)
343 */
344 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
345 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200, TestSize.Level1)
346 {
347 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 start";
348 AccessibilityCommandArgument argument;
349 char* argv[] = {
350 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
351 (char*)cmdsetShortKeyTarget_.c_str(),
352 (char*)"-a",
353 (char*)"ability",
354 (char*)"-b",
355 (char*)"bundle",
356 (char*)"-v",
357 (char*)"value",
358 (char*)" ",
359 };
360 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
361 AccessibilityAbilityShellCommand cmd(argc, argv);
362 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
363 EXPECT_EQ(result, OHOS::ERR_OK);
364 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0200 end";
365 }
366
367 /**
368 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300
369 * @tc.name: MakeCommandArgumentFromCmd
370 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(missing options)
371 */
372 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
373 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300, TestSize.Level1)
374 {
375 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 start";
376 AccessibilityCommandArgument argument;
377 char* argv[] = {
378 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
379 (char*)cmdsetShortKeyTarget_.c_str(),
380 (char*)" ",
381 };
382 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
383 AccessibilityAbilityShellCommand cmd(argc, argv);
384 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
385 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
386 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_HELP_MSG_NO_OPTION);
387 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0300 end";
388 }
389
390 /**
391 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400
392 * @tc.name: MakeCommandArgumentFromCmd
393 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_ABILITY)
394 */
395 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
396 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400, TestSize.Level1)
397 {
398 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 start";
399 AccessibilityCommandArgument argument;
400 char* argv[] = {
401 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
402 (char*)cmdsetShortKeyTarget_.c_str(),
403 (char*)"-a",
404 (char*)" ",
405 };
406 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
407 AccessibilityAbilityShellCommand cmd(argc, argv);
408 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
409 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
410 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT_VALUE);
411 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0400 end";
412 }
413
414 /**
415 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500
416 * @tc.name: MakeCommandArgumentFromCmd
417 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(NO_BUNDLE)
418 */
419 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
420 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500, TestSize.Level1)
421 {
422 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 start";
423 AccessibilityCommandArgument argument;
424 char* argv[] = {
425 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
426 (char*)cmdsetShortKeyTarget_.c_str(),
427 (char*)"-a",
428 (char*)"ability",
429 (char*)"-b",
430 (char*)" ",
431 };
432 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
433 AccessibilityAbilityShellCommand cmd(argc, argv);
434 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
435 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
436 EXPECT_EQ(cmd.resultReceiver_, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT_VALUE);
437 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0500 end";
438 }
439
440 /**
441 * @tc.number: AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600
442 * @tc.name: MakeCommandArgumentFromCmd
443 * @tc.desc: Test whether MakeCommandArgumentFromCmd is called normally.(optind = -1)
444 */
445 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
446 AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600, TestSize.Level1)
447 {
448 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 start";
449 AccessibilityCommandArgument argument;
450 optind = -1;
451 char* argv[] = {
452 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
453 };
454 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
455 AccessibilityAbilityShellCommand cmd(argc, argv);
456 ErrCode result = cmd.MakeCommandArgumentFromCmd(argument);
457 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
458 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeCommandArgumentFromCmd_0600 end";
459 }
460
461 /**
462 * @tc.number: AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100
463 * @tc.name: MakeDisableCommandArgumentFromCmd
464 * @tc.desc: Test whether MakeDisableCommandArgumentFromCmd is called normally.
465 * (MakeCommandArgumentFromCmd = OHOS::ERR_OK,CheckDisableCommandArgument = OHOS::ERR_INVALID_VALUE)
466 */
467 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
468 AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100, TestSize.Level1)
469 {
470 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 start";
471 AccessibilityCommandArgument argument;
472 argument.abilityArgumentNum = 1;
473 argument.abilityName = "ability";
474 argument.bundleArgumentNum = 1;
475 argument.bundleName = "bundle";
476 argument.capabilityNamesArgumentNum = 0;
477 argument.unknownArgumentNum = 0;
478 char* argv[] = {
479 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
480 (char*)cmdDisable_.c_str(),
481 (char*)"-a",
482 (char*)"ability",
483 (char*)"-b",
484 (char*)"bundle",
485 (char*)" ",
486 };
487 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
488 AccessibilityAbilityShellCommand cmd(argc, argv);
489 ErrCode result = cmd.MakeDisableCommandArgumentFromCmd(argument);
490 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
491 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_MakeDisableCommandArgumentFromCmd_0100 end";
492 }
493
494 /**
495 * @tc.number: AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100
496 * @tc.name: CheckDisableCommandArgument
497 * @tc.desc: Test whether CheckDisableCommandArgument is called normally.
498 * (CheckCommandArgument = OHOS::ERR_INVALID_VALUE)
499 */
500 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
501 AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100, TestSize.Level1)
502 {
503 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 start";
504 AccessibilityCommandArgument argument;
505 std::string resultMessage;
506 argument.abilityArgumentNum = 1;
507 argument.abilityName = "ability";
508 argument.bundleArgumentNum = 1;
509 argument.bundleName = "bundle";
510 argument.capabilityNamesArgumentNum = 0;
511 argument.unknownArgumentNum = 0;
512 char* argv[] = {
513 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
514 };
515 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
516 AccessibilityAbilityShellCommand cmd(argc, argv);
517 ErrCode result = cmd.CheckDisableCommandArgument(argument, resultMessage);
518 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
519 EXPECT_EQ(resultMessage, ": the auxiliary application bundle/ability" + ACCESSIBILITY_ABILITY_NOT_FOUND);
520 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckDisableCommandArgument_0100 end";
521 }
522
523 /**
524 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0100
525 * @tc.name: CheckCommandArgument
526 * @tc.desc: Test whether CheckCommandArgument is called normally.(totalArgumentNum > 2)
527 */
528 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
529 AccessibilityAbilityShellCommand_CheckCommandArgument_0100, TestSize.Level1)
530 {
531 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 start";
532 AccessibilityCommandArgument argument;
533 std::string resultMessage;
534 argument.abilityArgumentNum = 2;
535 argument.abilityName = "ability";
536 argument.bundleArgumentNum = 1;
537 argument.bundleName = "bundle";
538 argument.capabilityNamesArgumentNum = 0;
539 argument.unknownArgumentNum = 1;
540 char* argv[] = {
541 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
542 };
543 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
544 AccessibilityAbilityShellCommand cmd(argc, argv);
545 ErrCode result = cmd.CheckCommandArgument(argument, resultMessage);
546 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
547 EXPECT_EQ(resultMessage, ": and duplicated arguments exist.and unknown arguments exist.");
548 EXPECT_EQ(cmd.resultReceiver_, ACCESSIBILITY_ABILITY_TOO_MANY_ARGUMENT);
549 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0100 end";
550 }
551
552 /**
553 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0200
554 * @tc.name: CheckCommandArgument
555 * @tc.desc: Test whether CheckCommandArgument is called normally.(unknownArgumentNum > 0)
556 */
557 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
558 AccessibilityAbilityShellCommand_CheckCommandArgument_0200, TestSize.Level1)
559 {
560 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 start";
561 AccessibilityCommandArgument argument;
562 std::string resultMessage;
563 argument.abilityArgumentNum = 0;
564 argument.abilityName = "ability";
565 argument.bundleArgumentNum = 0;
566 argument.bundleName = "bundle";
567 argument.capabilityNamesArgumentNum = 0;
568 argument.unknownArgumentNum = 1;
569 char* argv[] = {
570 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
571 };
572 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
573 AccessibilityAbilityShellCommand cmd(argc, argv);
574 ErrCode result = cmd.CheckCommandArgument(argument, resultMessage);
575 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
576 EXPECT_EQ(resultMessage, ": unknown arguments exist.");
577 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0200 end";
578 }
579
580 /**
581 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0300
582 * @tc.name: CheckCommandArgument
583 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckAbilityArgument = false)
584 */
585 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
586 AccessibilityAbilityShellCommand_CheckCommandArgument_0300, TestSize.Level1)
587 {
588 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 start";
589 AccessibilityCommandArgument argument;
590 std::string resultMessage;
591 argument.abilityArgumentNum = 0;
592 argument.abilityName = "ability";
593 argument.bundleArgumentNum = 1;
594 argument.bundleName = "bundle";
595 argument.capabilityNamesArgumentNum = 1;
596 argument.unknownArgumentNum = 0;
597 char* argv[] = {
598 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
599 };
600 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
601 AccessibilityAbilityShellCommand cmd(argc, argv);
602 ErrCode result = cmd.CheckCommandArgument(argument, resultMessage);
603 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
604 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_ABILITY_ARGUMENT);
605 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0300 end";
606 }
607
608 /**
609 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0400
610 * @tc.name: CheckCommandArgument
611 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckBundleArgument = false)
612 */
613 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
614 AccessibilityAbilityShellCommand_CheckCommandArgument_0400, TestSize.Level1)
615 {
616 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 start";
617 AccessibilityCommandArgument argument;
618 std::string resultMessage;
619 argument.abilityArgumentNum = 1;
620 argument.abilityName = "ability";
621 argument.bundleArgumentNum = 0;
622 argument.bundleName = "bundle";
623 argument.capabilityNamesArgumentNum = 1;
624 argument.unknownArgumentNum = 0;
625 char* argv[] = {
626 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
627 };
628 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
629 AccessibilityAbilityShellCommand cmd(argc, argv);
630 ErrCode result = cmd.CheckCommandArgument(argument, resultMessage);
631 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
632 EXPECT_EQ(resultMessage, ": " + ACCESSIBILITY_ABILITY_NO_BUNDLE_ARGUMENT);
633 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0400 end";
634 }
635
636 /**
637 * @tc.number: AccessibilityAbilityShellCommand_CheckCommandArgument_0500
638 * @tc.name: CheckCommandArgument
639 * @tc.desc: Test whether CheckCommandArgument is called normally.(CheckParamValidity = false)
640 */
641 HWTEST_F(AccessibilityAbilityShellCommandSecondTest,
642 AccessibilityAbilityShellCommand_CheckCommandArgument_0500, TestSize.Level1)
643 {
644 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 start";
645 AccessibilityCommandArgument argument;
646 std::string resultMessage;
647 argument.abilityArgumentNum = 1;
648 argument.abilityName = "ability";
649 argument.bundleArgumentNum = 1;
650 argument.bundleName = "bundle";
651 argument.capabilityNamesArgumentNum = 0;
652 argument.unknownArgumentNum = 0;
653 char* argv[] = {
654 (char*)ACCESSIBILITY_TOOL_NAME.c_str(),
655 };
656 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
657 AccessibilityAbilityShellCommand cmd(argc, argv);
658 ErrCode result = cmd.CheckCommandArgument(argument, resultMessage);
659 EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
660 EXPECT_EQ(resultMessage, ": the auxiliary application " + argument.bundleName + "/" +
661 argument.abilityName + ACCESSIBILITY_ABILITY_NOT_FOUND);
662 GTEST_LOG_(INFO) << "AccessibilityAbilityShellCommand_CheckCommandArgument_0500 end";
663 }
664 } // namespace AAFwk
665 } // namespace OHOS