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