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