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 #include "ability_command.h"
19 #include "string_ex.h"
20
21 using namespace testing::ext;
22 using namespace OHOS;
23 using namespace OHOS::AAFwk;
24
25 namespace {
26 const std::string STRING_SEPERATOR = "\n";
27 const std::string STRING_RECORD_ID = "0";
28 const size_t SIZE_ONE = 1;
29 } // namespace
30
31 class AaCommandDumpsysModuleTest : public ::testing::Test {
32 public:
33 static void SetUpTestCase();
34 static void TearDownTestCase();
35 void SetUp() override;
36 void TearDown() override;
37
38 std::string cmd_ = "dump";
39 };
40
SetUpTestCase()41 void AaCommandDumpsysModuleTest::SetUpTestCase()
42 {}
43
TearDownTestCase()44 void AaCommandDumpsysModuleTest::TearDownTestCase()
45 {}
46
SetUp()47 void AaCommandDumpsysModuleTest::SetUp()
48 {
49 // reset optind to 0
50 optind = 0;
51 }
52
TearDown()53 void AaCommandDumpsysModuleTest::TearDown()
54 {}
55
56 /**
57 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0100
58 * @tc.name: ExecCommand
59 * @tc.desc: Verify the "aa dump -a" command.
60 */
61 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0100, Function | MediumTest | Level1)
62 {
63 char *argv[] = {
64 (char *)TOOL_NAME.c_str(),
65 (char *)cmd_.c_str(),
66 (char *)"-a",
67 (char *)"",
68 };
69 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
70
71 AbilityManagerShellCommand cmd(argc, argv);
72 auto result = cmd.ExecCommand();
73 EXPECT_NE(result, HELP_MSG_DUMPSYS);
74
75 std::vector<std::string> lines;
76 SplitStr(result, " ", lines);
77 EXPECT_GT(lines.size(), SIZE_ONE);
78 }
79
80 /**
81 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0200
82 * @tc.name: ExecCommand
83 * @tc.desc: Verify the "aa dump --all" command.
84 */
85 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0200, Function | MediumTest | Level1)
86 {
87 char *argv[] = {
88 (char *)TOOL_NAME.c_str(),
89 (char *)cmd_.c_str(),
90 (char *)"--all",
91 (char *)"",
92 };
93 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
94
95 AbilityManagerShellCommand cmd(argc, argv);
96 auto result = cmd.ExecCommand();
97 EXPECT_NE(result, HELP_MSG_DUMPSYS);
98
99 std::vector<std::string> lines;
100 SplitStr(result, " ", lines);
101 EXPECT_GT(lines.size(), SIZE_ONE);
102 }
103
104 /**
105 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0300
106 * @tc.name: ExecCommand
107 * @tc.desc: Verify the "aa dump -l" command.
108 */
109 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0300, Function | MediumTest | Level1)
110 {
111 char *argv[] = {
112 (char *)TOOL_NAME.c_str(),
113 (char *)cmd_.c_str(),
114 (char *)"-l",
115 (char *)"",
116 };
117 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
118
119 AbilityManagerShellCommand cmd(argc, argv);
120 auto result = cmd.ExecCommand();
121 EXPECT_NE(result, HELP_MSG_DUMPSYS);
122
123 std::vector<std::string> lines;
124 SplitStr(result, " ", lines);
125 EXPECT_GT(lines.size(), SIZE_ONE);
126 }
127
128 /**
129 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0400
130 * @tc.name: ExecCommand
131 * @tc.desc: Verify the "aa dump --mission-list" command.
132 */
133 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0400, Function | MediumTest | Level1)
134 {
135 char *argv[] = {
136 (char *)TOOL_NAME.c_str(),
137 (char *)cmd_.c_str(),
138 (char *)"--mission-list",
139 (char *)"",
140 };
141 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
142
143 AbilityManagerShellCommand cmd(argc, argv);
144 auto result = cmd.ExecCommand();
145 EXPECT_NE(result, HELP_MSG_DUMPSYS);
146
147 std::vector<std::string> lines;
148 SplitStr(result, " ", lines);
149 EXPECT_GT(lines.size(), SIZE_ONE);
150 }
151
152 /**
153 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0500
154 * @tc.name: ExecCommand
155 * @tc.desc: Verify the "aa dump -i" command.
156 */
157 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0500, Function | MediumTest | Level1)
158 {
159 char *argv[] = {
160 (char *)TOOL_NAME.c_str(),
161 (char *)cmd_.c_str(),
162 (char *)"-i",
163 (char *)STRING_RECORD_ID.c_str(),
164 (char *)"",
165 };
166 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
167
168 AbilityManagerShellCommand cmd(argc, argv);
169 auto result = cmd.ExecCommand();
170 EXPECT_NE(result, HELP_MSG_DUMPSYS);
171
172 std::vector<std::string> lines;
173 SplitStr(result, " ", lines);
174 EXPECT_GE(lines.size(), SIZE_ONE);
175 }
176
177 /**
178 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0600
179 * @tc.name: ExecCommand
180 * @tc.desc: Verify the "aa dump --ability" command.
181 */
182 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0600, Function | MediumTest | Level1)
183 {
184 char *argv[] = {
185 (char *)TOOL_NAME.c_str(),
186 (char *)cmd_.c_str(),
187 (char *)"--ability",
188 (char *)STRING_RECORD_ID.c_str(),
189 (char *)"",
190 };
191 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
192
193 AbilityManagerShellCommand cmd(argc, argv);
194 auto result = cmd.ExecCommand();
195 EXPECT_NE(result, HELP_MSG_DUMPSYS);
196
197 std::vector<std::string> lines;
198 SplitStr(result, " ", lines);
199 EXPECT_GE(lines.size(), SIZE_ONE);
200 }
201
202 /**
203 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0700
204 * @tc.name: ExecCommand
205 * @tc.desc: Verify the "aa dump -e" command.
206 */
207 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0700, Function | MediumTest | Level1)
208 {
209 char *argv[] = {
210 (char *)TOOL_NAME.c_str(),
211 (char *)cmd_.c_str(),
212 (char *)"-e",
213 (char *)"",
214 };
215 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
216
217 AbilityManagerShellCommand cmd(argc, argv);
218 auto result = cmd.ExecCommand();
219 EXPECT_NE(result, HELP_MSG_DUMPSYS);
220
221 std::vector<std::string> lines;
222 SplitStr(result, " ", lines);
223 EXPECT_GT(lines.size(), SIZE_ONE);
224 }
225
226 /**
227 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0800
228 * @tc.name: ExecCommand
229 * @tc.desc: Verify the "aa dump --extension" command.
230 */
231 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0800, Function | MediumTest | Level1)
232 {
233 char *argv[] = {
234 (char *)TOOL_NAME.c_str(),
235 (char *)cmd_.c_str(),
236 (char *)"--extension",
237 (char *)"",
238 };
239 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
240
241 AbilityManagerShellCommand cmd(argc, argv);
242 auto result = cmd.ExecCommand();
243 EXPECT_NE(result, HELP_MSG_DUMPSYS);
244
245 std::vector<std::string> lines;
246 SplitStr(result, " ", lines);
247 EXPECT_GT(lines.size(), SIZE_ONE);
248 }
249
250 /**
251 * @tc.number: Aa_Command_Dumpsys_ModuleTest_0900
252 * @tc.name: ExecCommand
253 * @tc.desc: Verify the "aa dump -p" command.
254 */
255 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_0900, Function | MediumTest | Level1)
256 {
257 char *argv[] = {
258 (char *)TOOL_NAME.c_str(),
259 (char *)cmd_.c_str(),
260 (char *)"-p",
261 (char *)"",
262 };
263 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
264
265 AbilityManagerShellCommand cmd(argc, argv);
266 auto result = cmd.ExecCommand();
267 EXPECT_NE(result, HELP_MSG_DUMPSYS);
268
269 std::vector<std::string> lines;
270 SplitStr(result, " ", lines);
271 EXPECT_GE(lines.size(), SIZE_ONE);
272 }
273
274 /**
275 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1000
276 * @tc.name: ExecCommand
277 * @tc.desc: Verify the "aa dump --pending" command.
278 */
279 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1000, Function | MediumTest | Level1)
280 {
281 char *argv[] = {
282 (char *)TOOL_NAME.c_str(),
283 (char *)cmd_.c_str(),
284 (char *)"--pending",
285 (char *)"",
286 };
287 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
288
289 AbilityManagerShellCommand cmd(argc, argv);
290 auto result = cmd.ExecCommand();
291 EXPECT_NE(result, HELP_MSG_DUMPSYS);
292
293 std::vector<std::string> lines;
294 SplitStr(result, " ", lines);
295 EXPECT_GE(lines.size(), SIZE_ONE);
296 }
297
298 /**
299 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1100
300 * @tc.name: ExecCommand
301 * @tc.desc: Verify the "aa dump -r" command.
302 */
303 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1100, Function | MediumTest | Level1)
304 {
305 char *argv[] = {
306 (char *)TOOL_NAME.c_str(),
307 (char *)cmd_.c_str(),
308 (char *)"-r",
309 (char *)"",
310 };
311 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
312
313 AbilityManagerShellCommand cmd(argc, argv);
314 auto result = cmd.ExecCommand();
315 EXPECT_NE(result, HELP_MSG_DUMPSYS);
316
317 std::vector<std::string> lines;
318 SplitStr(result, " ", lines);
319 // expect that no information showup since no permission
320 EXPECT_LE(lines.size(), SIZE_ONE);
321 }
322
323 /**
324 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1200
325 * @tc.name: ExecCommand
326 * @tc.desc: Verify the "aa dump --process" command.
327 */
328 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1200, Function | MediumTest | Level1)
329 {
330 char *argv[] = {
331 (char *)TOOL_NAME.c_str(),
332 (char *)cmd_.c_str(),
333 (char *)"--process",
334 (char *)"",
335 };
336 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
337
338 AbilityManagerShellCommand cmd(argc, argv);
339 auto result = cmd.ExecCommand();
340 EXPECT_NE(result, HELP_MSG_DUMPSYS);
341
342 std::vector<std::string> lines;
343 SplitStr(result, " ", lines);
344 // expect that no information showup since no permission
345 EXPECT_LE(lines.size(), SIZE_ONE);
346 }
347
348 /**
349 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1300
350 * @tc.name: ExecCommand
351 * @tc.desc: Verify the "aa dump -d" command.
352 */
353 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1300, Function | MediumTest | Level1)
354 {
355 char *argv[] = {
356 (char *)TOOL_NAME.c_str(),
357 (char *)cmd_.c_str(),
358 (char *)"-d",
359 (char *)"",
360 };
361 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
362
363 AbilityManagerShellCommand cmd(argc, argv);
364 auto result = cmd.ExecCommand();
365 EXPECT_NE(result, HELP_MSG_DUMPSYS);
366
367 std::vector<std::string> lines;
368 SplitStr(result, " ", lines);
369 EXPECT_GE(lines.size(), SIZE_ONE);
370 }
371
372 /**
373 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1400
374 * @tc.name: ExecCommand
375 * @tc.desc: Verify the "aa dump --data" command.
376 */
377 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1400, Function | MediumTest | Level1)
378 {
379 char *argv[] = {
380 (char *)TOOL_NAME.c_str(),
381 (char *)cmd_.c_str(),
382 (char *)"--data",
383 (char *)"",
384 };
385 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
386
387 AbilityManagerShellCommand cmd(argc, argv);
388 auto result = cmd.ExecCommand();
389 EXPECT_NE(result, HELP_MSG_DUMPSYS);
390
391 std::vector<std::string> lines;
392 SplitStr(result, " ", lines);
393 EXPECT_GE(lines.size(), SIZE_ONE);
394 }
395
396 /**
397 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1500
398 * @tc.name: ExecCommand
399 * @tc.desc: Verify the "aa dump -c" command.
400 */
401 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1500, Function | MediumTest | Level1)
402 {
403 char *argv[] = {
404 (char *)TOOL_NAME.c_str(),
405 (char *)cmd_.c_str(),
406 (char *)"-c",
407 (char *)"",
408 };
409 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
410
411 AbilityManagerShellCommand cmd(argc, argv);
412 auto result = cmd.ExecCommand();
413 EXPECT_NE(result, HELP_MSG_DUMPSYS);
414
415 std::vector<std::string> lines;
416 SplitStr(result, " ", lines);
417 EXPECT_GT(lines.size(), SIZE_ONE);
418 }
419
420 /**
421 * @tc.number: Aa_Command_Dumpsys_ModuleTest_1600
422 * @tc.name: ExecCommand
423 * @tc.desc: Verify the "aa dump --client" command.
424 */
425 HWTEST_F(AaCommandDumpsysModuleTest, Aa_Command_Dumpsys_ModuleTest_1600, Function | MediumTest | Level1)
426 {
427 char *argv[] = {
428 (char *)TOOL_NAME.c_str(),
429 (char *)cmd_.c_str(),
430 (char *)"--client",
431 (char *)"",
432 };
433 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
434
435 AbilityManagerShellCommand cmd(argc, argv);
436 auto result = cmd.ExecCommand();
437 EXPECT_NE(result, HELP_MSG_DUMPSYS);
438
439 std::vector<std::string> lines;
440 SplitStr(result, " ", lines);
441 EXPECT_GT(lines.size(), SIZE_ONE);
442 }
443