1 /*
2 * Copyright (c) 2022 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 #include "ability_command.h"
20 #include "ability_manager_client.h"
21 #undef private
22 #include "ability_manager_interface.h"
23 #include "hilog_wrapper.h"
24 #include "mock_ability_manager_stub.h"
25
26 using namespace testing::ext;
27 using namespace OHOS;
28 using namespace OHOS::AAFwk;
29
30 namespace {
31 const std::string STRING_CLASS_NAME = "ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010";
32 const std::string STRING_USER_TESTRUNNER = "JSUserTestRunner";
33 const std::string STRING_PACKAGENAME = "com.example.myapplication";
34 const std::string STRING_PACKAGENAME1 = "com.example.myapplication1";
35 const std::string STRING_BUNDLENAME = "com.example.myapplication";
36 const std::string STRING_MODULENAME = "com.example.myapplication.MyApplication";
37 const std::string CLASS = "class";
38 const std::string UNITTEST = "unittest";
39 const std::string UNITTEST1 = "unittest1";
40 const std::string TIME = "20";
41 const std::string ANYKEY = "123";
42 const std::string ANYVALUE = "999999999";
43 } // namespace
44
45 class AbilityCommandTest : public ::testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp() override;
50 void TearDown() override;
51
52 void MakeMockObjects() const;
53
54 std::string cmd_ = "test";
55 };
56
SetUpTestCase()57 void AbilityCommandTest::SetUpTestCase()
58 {}
59
TearDownTestCase()60 void AbilityCommandTest::TearDownTestCase()
61 {}
62
SetUp()63 void AbilityCommandTest::SetUp()
64 {
65 // reset optind to 0
66 optind = 0;
67
68 // make mock objects
69 MakeMockObjects();
70 }
71
TearDown()72 void AbilityCommandTest::TearDown()
73 {}
74
MakeMockObjects() const75 void AbilityCommandTest::MakeMockObjects() const
76 {
77 // mock a stub
78 auto managerStubPtr = sptr<IAbilityManager>(new MockAbilityManagerStub());
79
80 // set the mock stub
81 auto managerClientPtr = AbilityManagerClient::GetInstance();
82 managerClientPtr->proxy_ = managerStubPtr;
83 }
84
85 /**
86 * @tc.number: Ability_Command_Test_0100
87 * @tc.name: ExecCommand
88 * @tc.desc: Verify the "aa test -" command.
89 */
90 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0100, Function | MediumTest | Level1)
91 {
92 HILOG_INFO("Ability_Command_Test_0100 is called");
93 char* argv[] = {
94 (char*)TOOL_NAME.c_str(),
95 (char*)cmd_.c_str(),
96 (char*)"-",
97 };
98 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
99
100 AbilityManagerShellCommand cmd(argc, argv);
101 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
102 }
103
104 /**
105 * @tc.number: Ability_Command_Test_0200
106 * @tc.name: ExecCommand
107 * @tc.desc: Verify the "aa test -zxmy" command.
108 */
109 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0200, Function | MediumTest | Level1)
110 {
111 HILOG_INFO("Ability_Command_Test_0200 is called");
112 char* argv[] = {
113 (char*)TOOL_NAME.c_str(),
114 (char*)cmd_.c_str(),
115 (char*)"-zxmy",
116 };
117 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
118
119 AbilityManagerShellCommand cmd(argc, argv);
120 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
121 }
122
123 /**
124 * @tc.number: Ability_Command_Test_0300
125 * @tc.name: ExecCommand
126 * @tc.desc: Verify the "aa test -h" command.
127 */
128 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0300, Function | MediumTest | Level1)
129 {
130 HILOG_INFO("Ability_Command_Test_0300 is called");
131 char* argv[] = {
132 (char*)TOOL_NAME.c_str(),
133 (char*)cmd_.c_str(),
134 (char*)"-h",
135 };
136 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
137
138 AbilityManagerShellCommand cmd(argc, argv);
139 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
140 }
141
142 /**
143 * @tc.number: Ability_Command_Test_0400
144 * @tc.name: ExecCommand
145 * @tc.desc: Verify the "aa test -help" command.
146 */
147 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0400, Function | MediumTest | Level1)
148 {
149 HILOG_INFO("Ability_Command_Test_0400 is called");
150 char* argv[] = {
151 (char*)TOOL_NAME.c_str(),
152 (char*)cmd_.c_str(),
153 (char*)"-help",
154 };
155 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
156
157 AbilityManagerShellCommand cmd(argc, argv);
158 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
159 }
160
161 /**
162 * @tc.number: Ability_Command_Test_0500
163 * @tc.name: ExecCommand
164 * @tc.desc: Verify the "aa test -b" command.
165 */
166 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0500, Function | MediumTest | Level1)
167 {
168 HILOG_INFO("Ability_Command_Test_0500 is called");
169 char* argv[] = {
170 (char*)TOOL_NAME.c_str(),
171 (char*)cmd_.c_str(),
172 (char*)"-b",
173 };
174 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
175
176 AbilityManagerShellCommand cmd(argc, argv);
177 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
178 }
179
180 /**
181 * @tc.number: Ability_Command_Test_0600
182 * @tc.name: ExecCommand
183 * @tc.desc: Verify the "aa test -s" command.
184 */
185 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0600, Function | MediumTest | Level1)
186 {
187 HILOG_INFO("Ability_Command_Test_0600 is called");
188 char* argv[] = {
189 (char*)TOOL_NAME.c_str(),
190 (char*)cmd_.c_str(),
191 (char*)"-s",
192 };
193 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
194
195 AbilityManagerShellCommand cmd(argc, argv);
196 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
197 }
198
199 /**
200 * @tc.number: Ability_Command_Test_0700
201 * @tc.name: ExecCommand
202 * @tc.desc: Verify the "aa test -s 123456 aaaaaaaaaaaaaa" command.
203 */
204 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0700, Function | MediumTest | Level1)
205 {
206 HILOG_INFO("Ability_Command_Test_0700 is called");
207 char* argv[] = {
208 (char*)TOOL_NAME.c_str(),
209 (char*)cmd_.c_str(),
210 (char*)"-s",
211 (char*)"123456",
212 (char*)"aaaaaaaaaaaaaa",
213 };
214 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
215
216 AbilityManagerShellCommand cmd(argc, argv);
217 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
218 }
219
220 /**
221 * @tc.number: Ability_Command_Test_0800
222 * @tc.name: ExecCommand
223 * @tc.desc: Verify the "aa test -b com.example.myapplication -l" command.
224 */
225 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0800, Function | MediumTest | Level1)
226 {
227 HILOG_INFO("Ability_Command_Test_0800 is called");
228 char* argv[] = {
229 (char*)TOOL_NAME.c_str(),
230 (char*)cmd_.c_str(),
231 (char*)"-b",
232 (char*)STRING_BUNDLENAME.c_str(),
233 (char*)"-l",
234 };
235 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
236
237 AbilityManagerShellCommand cmd(argc, argv);
238 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
239 }
240
241 /**
242 * @tc.number: Ability_Command_Test_0900
243 * @tc.name: ExecCommand
244 * @tc.desc: Verify the "aa test -b com.example.myapplication" command.
245 */
246 HWTEST_F(AbilityCommandTest, Ability_Command_Test_0900, Function | MediumTest | Level1)
247 {
248 HILOG_INFO("Ability_Command_Test_0900 is called");
249 char* argv[] = {
250 (char*)TOOL_NAME.c_str(),
251 (char*)cmd_.c_str(),
252 (char*)"-b",
253 (char*)STRING_BUNDLENAME.c_str(),
254 };
255 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
256
257 AbilityManagerShellCommand cmd(argc, argv);
258 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
259 }
260
261 /**
262 * @tc.number: Ability_Command_Test_1000
263 * @tc.name: ExecCommand
264 * @tc.desc: Verify the "aa test -s unittest" command.
265 */
266 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1000, Function | MediumTest | Level1)
267 {
268 HILOG_INFO("Ability_Command_Test_1000 is called");
269 char* argv[] = {
270 (char*)TOOL_NAME.c_str(),
271 (char*)cmd_.c_str(),
272 (char*)"-s",
273 (char*)UNITTEST.c_str(),
274 };
275 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
276
277 AbilityManagerShellCommand cmd(argc, argv);
278 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
279 }
280
281 /**
282 * @tc.number: Ability_Command_Test_1100
283 * @tc.name: ExecCommand
284 * @tc.desc: Verify the "aa test -s class" command.
285 */
286 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1100, Function | MediumTest | Level1)
287 {
288 HILOG_INFO("Ability_Command_Test_1100 is called");
289 char* argv[] = {
290 (char*)TOOL_NAME.c_str(),
291 (char*)cmd_.c_str(),
292 (char*)"-s",
293 (char*)CLASS.c_str(),
294 };
295 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
296
297 AbilityManagerShellCommand cmd(argc, argv);
298 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
299 }
300
301 /**
302 * @tc.number: Ability_Command_Test_1200
303 * @tc.name: ExecCommand
304 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittest" command.
305 */
306 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1200, Function | MediumTest | Level1)
307 {
308 HILOG_INFO("Ability_Command_Test_1200 is called");
309 char* argv[] = {
310 (char*)TOOL_NAME.c_str(),
311 (char*)cmd_.c_str(),
312 (char*)"-b",
313 (char*)STRING_BUNDLENAME.c_str(),
314 (char*)"-s",
315 (char*)UNITTEST.c_str(),
316 };
317 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
318
319 AbilityManagerShellCommand cmd(argc, argv);
320 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
321 }
322
323 /**
324 * @tc.number: Ability_Command_Test_1300
325 * @tc.name: ExecCommand
326 * @tc.desc: Verify the "aa test -b com.example.myapplication -s class" command.
327 */
328 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1300, Function | MediumTest | Level1)
329 {
330 HILOG_INFO("Ability_Command_Test_1300 is called");
331 char* argv[] = {
332 (char*)TOOL_NAME.c_str(),
333 (char*)cmd_.c_str(),
334 (char*)"-b",
335 (char*)STRING_BUNDLENAME.c_str(),
336 (char*)"-s",
337 (char*)CLASS.c_str(),
338 };
339 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
340
341 AbilityManagerShellCommand cmd(argc, argv);
342 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
343 }
344
345 /**
346 * @tc.number: Ability_Command_Test_1400
347 * @tc.name: ExecCommand
348 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittest JSUserTestRunner" command.
349 */
350 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1400, Function | MediumTest | Level1)
351 {
352 HILOG_INFO("Ability_Command_Test_1400 is called");
353 char* argv[] = {
354 (char*)TOOL_NAME.c_str(),
355 (char*)cmd_.c_str(),
356 (char*)"-b",
357 (char*)STRING_BUNDLENAME.c_str(),
358 (char*)"-s",
359 (char*)UNITTEST.c_str(),
360 (char*)STRING_USER_TESTRUNNER.c_str(),
361 };
362 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
363
364 AbilityManagerShellCommand cmd(argc, argv);
365 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
366 }
367
368 /**
369 * @tc.number: Ability_Command_Test_1500
370 * @tc.name: ExecCommand
371 * @tc.desc: Verify the "aa test -b com.example.myapplication -s class
372 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010" command.
373 */
374 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1500, Function | MediumTest | Level1)
375 {
376 HILOG_INFO("Ability_Command_Test_1500 is called");
377 char* argv[] = {
378 (char*)TOOL_NAME.c_str(),
379 (char*)cmd_.c_str(),
380 (char*)"-b",
381 (char*)STRING_BUNDLENAME.c_str(),
382 (char*)"-s",
383 (char*)CLASS.c_str(),
384 (char*)STRING_CLASS_NAME.c_str(),
385 };
386 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
387
388 AbilityManagerShellCommand cmd(argc, argv);
389 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
390 }
391
392 /**
393 * @tc.number: Ability_Command_Test_1600
394 * @tc.name: ExecCommand
395 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittst JSUserTestRunner -s class
396 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
397 */
398 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1600, Function | MediumTest | Level1)
399 {
400 HILOG_INFO("Ability_Command_Test_1600 is called");
401 char* argv[] = {
402 (char*)TOOL_NAME.c_str(),
403 (char*)cmd_.c_str(),
404 (char*)"-b",
405 (char*)STRING_BUNDLENAME.c_str(),
406 (char*)"-s",
407 (char*)UNITTEST.c_str(),
408 (char*)STRING_USER_TESTRUNNER.c_str(),
409 (char*)"-s",
410 (char*)CLASS.c_str(),
411 (char*)STRING_CLASS_NAME.c_str(),
412 (char*)"-w",
413 (char*)TIME.c_str(),
414 };
415 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
416
417 AbilityManagerShellCommand cmd(argc, argv);
418
419 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
420 }
421
422 /**
423 * @tc.number: Ability_Command_Test_1700
424 * @tc.name: ExecCommand
425 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittst JSUserTestRunner -s class
426 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w" command.
427 */
428 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1700, Function | MediumTest | Level1)
429 {
430 HILOG_INFO("Ability_Command_Test_1700 is called");
431 char* argv[] = {
432 (char*)TOOL_NAME.c_str(),
433 (char*)cmd_.c_str(),
434 (char*)"-b",
435 (char*)STRING_BUNDLENAME.c_str(),
436 (char*)"-s",
437 (char*)UNITTEST.c_str(),
438 (char*)STRING_USER_TESTRUNNER.c_str(),
439 (char*)"-s",
440 (char*)CLASS.c_str(),
441 (char*)STRING_CLASS_NAME.c_str(),
442 (char*)"-w",
443 };
444 int argc = sizeof(argv) / sizeof(argv[0]);
445
446 AbilityManagerShellCommand cmd(argc, argv);
447 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
448 }
449
450 /**
451 * @tc.number: Ability_Command_Test_1800
452 * @tc.name: ExecCommand
453 * @tc.desc: Verify the "aa test -b com.example.myapplication1 -s unittst JSUserTestRunner -s class
454 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
455 */
456 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1800, Function | MediumTest | Level1)
457 {
458 HILOG_INFO("Ability_Command_Test_1800 is called");
459 char* argv[] = {
460 (char*)TOOL_NAME.c_str(),
461 (char*)cmd_.c_str(),
462 (char*)"-b",
463 (char*)STRING_PACKAGENAME1.c_str(),
464 (char*)"-s",
465 (char*)UNITTEST.c_str(),
466 (char*)STRING_USER_TESTRUNNER.c_str(),
467 (char*)"-s",
468 (char*)CLASS.c_str(),
469 (char*)STRING_CLASS_NAME.c_str(),
470 (char*)"-w",
471 (char*)"20",
472 };
473 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
474
475 AbilityManagerShellCommand cmd(argc, argv);
476 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
477 }
478
479 /**
480 * @tc.number: Ability_Command_Test_1900
481 * @tc.name: ExecCommand
482 * @tc.desc: Verify the "aa test -b com.example.myapplication1 -s unittst1 JSUserTestRunner -w 20" command.
483 */
484 HWTEST_F(AbilityCommandTest, Ability_Command_Test_1900, Function | MediumTest | Level1)
485 {
486 HILOG_INFO("Ability_Command_Test_1900 is called");
487 char* argv[] = {
488 (char*)TOOL_NAME.c_str(),
489 (char*)cmd_.c_str(),
490 (char*)"-b",
491 (char*)STRING_PACKAGENAME1.c_str(),
492 (char*)"-s",
493 (char*)UNITTEST1.c_str(),
494 (char*)STRING_USER_TESTRUNNER.c_str(),
495 (char*)"-s",
496 (char*)CLASS.c_str(),
497 (char*)STRING_CLASS_NAME.c_str(),
498 (char*)"-w",
499 (char*)"20",
500 };
501 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
502
503 AbilityManagerShellCommand cmd(argc, argv);
504 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
505 }
506
507 /**
508 * @tc.number: Ability_Command_Test_2000
509 * @tc.name: ExecCommand
510 * @tc.desc: Verify the "aa test -b com.example.myapplication1 -s unittst1 JSUserTestRunner -s class
511 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010" command.
512 */
513 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2000, Function | MediumTest | Level1)
514 {
515 HILOG_INFO("Ability_Command_Test_2000 is called");
516 char* argv[] = {
517 (char*)TOOL_NAME.c_str(),
518 (char*)cmd_.c_str(),
519 (char*)"-b",
520 (char*)STRING_PACKAGENAME1.c_str(),
521 (char*)"-s",
522 (char*)UNITTEST1.c_str(),
523 (char*)STRING_USER_TESTRUNNER.c_str(),
524 };
525 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
526
527 AbilityManagerShellCommand cmd(argc, argv);
528 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
529 }
530
531 /**
532 * @tc.number: Ability_Command_Test_2100
533 * @tc.name: ExecCommand
534 * @tc.desc: Verify the "aa test -p1 com.example.myapplication -s unittst1 JSUserTestRunner -s class
535 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
536 */
537 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2100, Function | MediumTest | Level1)
538 {
539 HILOG_INFO("Ability_Command_Test_2100 is called");
540 char* argv[] = {
541 (char*)TOOL_NAME.c_str(),
542 (char*)cmd_.c_str(),
543 (char*)"-b1",
544 (char*)STRING_BUNDLENAME.c_str(),
545 (char*)"-s",
546 (char*)UNITTEST.c_str(),
547 (char*)STRING_USER_TESTRUNNER.c_str(),
548 (char*)"-s",
549 (char*)CLASS.c_str(),
550 (char*)STRING_CLASS_NAME.c_str(),
551 (char*)"-w",
552 (char*)TIME.c_str(),
553 };
554 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
555
556 AbilityManagerShellCommand cmd(argc, argv);
557 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
558 }
559
560 /**
561 * @tc.number: Ability_Command_Test_2200
562 * @tc.name: ExecCommand
563 * @tc.desc: Verify the "aa test -p1 com.example.myapplication -s1 unittst1 JSUserTestRunner -s class
564 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
565 */
566 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2200, Function | MediumTest | Level1)
567 {
568 HILOG_INFO("Ability_Command_Test_2200 is called");
569 char* argv[] = {
570 (char*)TOOL_NAME.c_str(),
571 (char*)cmd_.c_str(),
572 (char*)"-b",
573 (char*)STRING_BUNDLENAME.c_str(),
574 (char*)"-s1",
575 (char*)UNITTEST.c_str(),
576 (char*)STRING_USER_TESTRUNNER.c_str(),
577 (char*)"-s",
578 (char*)CLASS.c_str(),
579 (char*)STRING_CLASS_NAME.c_str(),
580 (char*)"-w",
581 (char*)TIME.c_str(),
582 };
583 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
584
585 AbilityManagerShellCommand cmd(argc, argv);
586 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
587 }
588
589 /**
590 * @tc.number: Ability_Command_Test_2300
591 * @tc.name: ExecCommand
592 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittst JSUserTestRunner -s class
593 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
594 */
595 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2300, Function | MediumTest | Level1)
596 {
597 HILOG_INFO("Ability_Command_Test_2300 is called");
598 char* argv[] = {
599 (char*)TOOL_NAME.c_str(),
600 (char*)cmd_.c_str(),
601 (char*)"-b",
602 (char*)STRING_BUNDLENAME.c_str(),
603 (char*)"-p",
604 (char*)STRING_PACKAGENAME.c_str(),
605 (char*)"-m",
606 (char*)STRING_MODULENAME.c_str(),
607 (char*)"-s",
608 (char*)UNITTEST.c_str(),
609 (char*)STRING_USER_TESTRUNNER.c_str(),
610 (char*)"-s",
611 (char*)CLASS.c_str(),
612 (char*)STRING_CLASS_NAME.c_str(),
613 (char*)"-w",
614 (char*)TIME.c_str(),
615 };
616 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
617
618 AbilityManagerShellCommand cmd(argc, argv);
619 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
620 }
621
622 /**
623 * @tc.number: Ability_Command_Test_2400
624 * @tc.name: ExecCommand
625 * @tc.desc: Verify the "aa test -b com.example.myapplication -b -s unittst JSUserTestRunner -s class
626 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
627 */
628 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2400, Function | MediumTest | Level1)
629 {
630 HILOG_INFO("Ability_Command_Test_2400 is called");
631 char* argv[] = {
632 (char*)TOOL_NAME.c_str(),
633 (char*)cmd_.c_str(),
634 (char*)"-b",
635 (char*)STRING_BUNDLENAME.c_str(),
636 (char*)"-p",
637 (char*)"-m",
638 (char*)STRING_MODULENAME.c_str(),
639 (char*)"-s",
640 (char*)UNITTEST.c_str(),
641 (char*)STRING_USER_TESTRUNNER.c_str(),
642 (char*)"-s",
643 (char*)CLASS.c_str(),
644 (char*)STRING_CLASS_NAME.c_str(),
645 (char*)"-w",
646 (char*)TIME.c_str(),
647 };
648 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
649
650 AbilityManagerShellCommand cmd(argc, argv);
651 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
652 }
653
654 /**
655 * @tc.number: Ability_Command_Test_2500
656 * @tc.name: ExecCommand
657 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittst JSUserTestRunner -s class
658 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
659 */
660 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2500, Function | MediumTest | Level1)
661 {
662 HILOG_INFO("Ability_Command_Test_2500 is called");
663 char* argv[] = {
664 (char*)TOOL_NAME.c_str(),
665 (char*)cmd_.c_str(),
666 (char*)"-b",
667 (char*)STRING_BUNDLENAME.c_str(),
668 (char*)"-p",
669 (char*)STRING_PACKAGENAME.c_str(),
670 (char*)"-m",
671 (char*)"-s",
672 (char*)UNITTEST.c_str(),
673 (char*)STRING_USER_TESTRUNNER.c_str(),
674 (char*)"-s",
675 (char*)CLASS.c_str(),
676 (char*)STRING_CLASS_NAME.c_str(),
677 (char*)"-w",
678 (char*)TIME.c_str(),
679 };
680 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
681
682 AbilityManagerShellCommand cmd(argc, argv);
683 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
684 }
685
686 /**
687 * @tc.number: Ability_Command_Test_2600
688 * @tc.name: ExecCommand
689 * @tc.desc: Verify the "aa test -b com.example.myapplication -s unittst JSUserTestRunner -s class
690 * ohos.acts.aafwk.ability.test.ConstructorTest#testDataAbilityOtherFunction0010 -w 20" command.
691 */
692 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2600, Function | MediumTest | Level1)
693 {
694 HILOG_INFO("Ability_Command_Test_2600 is called");
695 char* argv[] = {
696 (char*)TOOL_NAME.c_str(),
697 (char*)cmd_.c_str(),
698 (char*)"-b",
699 (char*)STRING_BUNDLENAME.c_str(),
700 (char*)"-p",
701 (char*)STRING_PACKAGENAME.c_str(),
702 (char*)"-m",
703 (char*)STRING_MODULENAME.c_str(),
704 (char*)"-s",
705 (char*)UNITTEST.c_str(),
706 (char*)STRING_USER_TESTRUNNER.c_str(),
707 (char*)"-s",
708 (char*)CLASS.c_str(),
709 (char*)STRING_CLASS_NAME.c_str(),
710 (char*)"-s",
711 (char*)"-w",
712 (char*)TIME.c_str(),
713 };
714 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
715
716 AbilityManagerShellCommand cmd(argc, argv);
717 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
718 }
719
720 /**
721 * @tc.number: Ability_Command_Test_2700
722 * @tc.name: GetAbilityManagerService
723 * @tc.desc: Get Ability Manager Service
724 */
725 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2700, Function | MediumTest | Level1)
726 {
727 HILOG_INFO("Ability_Command_Test_2700 is called");
728 char* argv[] = {
729 (char*)TOOL_NAME.c_str(),
730 (char*)cmd_.c_str(),
731 };
732 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
733
734 AbilityManagerShellCommand cmd(argc, argv);
735 auto ret = cmd.GetAbilityManagerService();
736 EXPECT_NE(ret, nullptr);
737 }
738
739 /**
740 * @tc.number: Ability_Command_Test_2800
741 * @tc.name: ExecCommand
742 * @tc.desc: Verify the "aa test -c" command.
743 */
744 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2800, Function | MediumTest | Level1)
745 {
746 HILOG_INFO("Ability_Command_Test_2800 is called");
747 char* argv[] = {
748 (char*)TOOL_NAME.c_str(),
749 (char*)cmd_.c_str(),
750 (char*)"-c",
751 };
752 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
753
754 AbilityManagerShellCommand cmd(argc, argv);
755 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
756 }
757
758 /**
759 * @tc.number: Ability_Command_Test_2900
760 * @tc.name: ExecCommand
761 * @tc.desc: Verify the "aa test -c or --client" command.
762 */
763 HWTEST_F(AbilityCommandTest, Ability_Command_Test_2900, Function | MediumTest | Level1)
764 {
765 HILOG_INFO("Ability_Command_Test_2900 is called");
766 char* argv[] = {
767 (char*)TOOL_NAME.c_str(),
768 (char*)cmd_.c_str(),
769 (char*)"-c",
770 (char*)"--client",
771 };
772 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
773
774 AbilityManagerShellCommand cmd(argc, argv);
775 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
776 }
777
778 /**
779 * @tc.number: Ability_Command_Test_3000
780 * @tc.name: ExecCommand
781 * @tc.desc: Verify the "aa test -u" command.
782 */
783 HWTEST_F(AbilityCommandTest, Ability_Command_Test_3000, Function | MediumTest | Level1)
784 {
785 HILOG_INFO("Ability_Command_Test_3000 is called");
786 char* argv[] = {
787 (char*)TOOL_NAME.c_str(),
788 (char*)cmd_.c_str(),
789 (char*)"-u",
790 };
791 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
792
793 AbilityManagerShellCommand cmd(argc, argv);
794 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
795 }
796
797
798 /**
799 * @tc.number: Ability_Command_Test_3100
800 * @tc.name: ExecCommand
801 * @tc.desc: Verify the "aa test -u or userId" command.
802 */
803 HWTEST_F(AbilityCommandTest, Ability_Command_Test_3100, Function | MediumTest | Level1)
804 {
805 HILOG_INFO("Ability_Command_Test_3100 is called");
806 char* argv[] = {
807 (char*)TOOL_NAME.c_str(),
808 (char*)cmd_.c_str(),
809 (char*)"-u",
810 (char*)"-userId",
811 };
812 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
813
814 AbilityManagerShellCommand cmd(argc, argv);
815 EXPECT_EQ(cmd.RunAsTestCommand(), OHOS::ERR_INVALID_VALUE);
816 }
817
818 /**
819 * @tc.number: Ability_Command_Test_3200
820 * @tc.name: ExecCommand
821 * @tc.desc: Verify the "aa test -s" command.
822 */
823 HWTEST_F(AbilityCommandTest, Ability_Command_Test_3200, Function | MediumTest | Level1)
824 {
825 HILOG_INFO("Ability_Command_Test_3200 is called");
826 char* argv[] = {
827 (char*)TOOL_NAME.c_str(),
828 (char*)cmd_.c_str(),
829 (char*)"-s",
830 };
831 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
832
833 AbilityManagerShellCommand cmd(argc, argv);
834 Want want;
835 std::string windowMode;
836 EXPECT_EQ(cmd.MakeWantFromCmd(want, windowMode), OHOS::ERR_INVALID_VALUE);
837 }
838
839 /**
840 * @tc.number: Ability_Command_Test_3300
841 * @tc.name: ExecCommand
842 * @tc.desc: Verify the "aa test -m" command.
843 */
844 HWTEST_F(AbilityCommandTest, Ability_Command_Test_3300, Function | MediumTest | Level1)
845 {
846 HILOG_INFO("Ability_Command_Test_3300 is called");
847 char* argv[] = {
848 (char*)TOOL_NAME.c_str(),
849 (char*)cmd_.c_str(),
850 (char*)"-m",
851 };
852 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
853
854 AbilityManagerShellCommand cmd(argc, argv);
855 Want want;
856 std::string windowMode;
857 EXPECT_EQ(cmd.MakeWantFromCmd(want, windowMode), OHOS::ERR_INVALID_VALUE);
858 }
859