1 /*
2 * Copyright (c) 2021-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 #define protected public
20 #include "ability_command.h"
21 #undef protected
22 #undef private
23 #include "mock_ability_manager_stub.h"
24 #define private public
25 #include "ability_manager_client.h"
26 #undef private
27 #include "ability_manager_interface.h"
28 #include "hilog_tag_wrapper.h"
29
30 using namespace testing::ext;
31 using namespace OHOS;
32 using namespace OHOS::AAFwk;
33
34 class AaCommandTest : public ::testing::Test {
35 public:
36 static void SetUpTestCase();
37 static void TearDownTestCase();
38 void SetUp() override;
39 void TearDown() override;
40
41 void MakeMockObjects() const;
42 };
43
SetUpTestCase()44 void AaCommandTest::SetUpTestCase()
45 {}
46
TearDownTestCase()47 void AaCommandTest::TearDownTestCase()
48 {}
49
SetUp()50 void AaCommandTest::SetUp()
51 {
52 // reset optind to 0
53 optind = 0;
54
55 // make mock objects
56 MakeMockObjects();
57 }
58
TearDown()59 void AaCommandTest::TearDown()
60 {}
61
MakeMockObjects() const62 void AaCommandTest::MakeMockObjects() const
63 {
64 // mock a stub
65 auto managerStubPtr = sptr<IAbilityManager>(new MockAbilityManagerStub());
66
67 // set the mock stub
68 auto managerClientPtr = AbilityManagerClient::GetInstance();
69 managerClientPtr->proxy_ = managerStubPtr;
70 }
71
72 /**
73 * @tc.number: Aa_Command_0100
74 * @tc.name: ExecCommand
75 * @tc.desc: Verify the "aa" command.
76 */
77 HWTEST_F(AaCommandTest, Aa_Command_0100, Function | MediumTest | Level1)
78 {
79 char* argv[] = {
80 (char*)TOOL_NAME.c_str(),
81 (char*)"",
82 };
83 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
84
85 AbilityManagerShellCommand cmd(argc, argv);
86 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG);
87 }
88
89 /**
90 * @tc.number: Aa_Command_0200
91 * @tc.name: ExecCommand
92 * @tc.desc: Verify the "aa xxx" command.
93 */
94 HWTEST_F(AaCommandTest, Aa_Command_0200, Function | MediumTest | Level1)
95 {
96 char* argv[] = {
97 (char*)TOOL_NAME.c_str(),
98 (char*)"xxx",
99 (char*)"",
100 };
101 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
102
103 AbilityManagerShellCommand cmd(argc, argv);
104 EXPECT_EQ(cmd.ExecCommand(), cmd.GetCommandErrorMsg() + HELP_MSG);
105 }
106
107 /**
108 * @tc.number: Aa_Command_0300
109 * @tc.name: ExecCommand
110 * @tc.desc: Verify the "aa -xxx" command.
111 */
112 HWTEST_F(AaCommandTest, Aa_Command_0300, Function | MediumTest | Level1)
113 {
114 char* argv[] = {
115 (char*)TOOL_NAME.c_str(),
116 (char*)"-xxx",
117 (char*)"",
118 };
119 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
120
121 AbilityManagerShellCommand cmd(argc, argv);
122 EXPECT_EQ(cmd.ExecCommand(), cmd.GetCommandErrorMsg() + HELP_MSG);
123 }
124
125 /**
126 * @tc.number: Aa_Command_0400
127 * @tc.name: ExecCommand
128 * @tc.desc: Verify the "aa --xxx" command.
129 */
130 HWTEST_F(AaCommandTest, Aa_Command_0400, Function | MediumTest | Level1)
131 {
132 char* argv[] = {
133 (char*)TOOL_NAME.c_str(),
134 (char*)"--xxx",
135 (char*)"",
136 };
137 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
138
139 AbilityManagerShellCommand cmd(argc, argv);
140 EXPECT_EQ(cmd.ExecCommand(), cmd.GetCommandErrorMsg() + HELP_MSG);
141 }
142
143 /**
144 * @tc.number: Aa_Command_0500
145 * @tc.name: ExecCommand
146 * @tc.desc: Verify the "aa help" command.
147 */
148 HWTEST_F(AaCommandTest, Aa_Command_0500, Function | MediumTest | Level1)
149 {
150 char* argv[] = {
151 (char*)TOOL_NAME.c_str(),
152 (char*)"help",
153 (char*)"",
154 };
155 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
156
157 AbilityManagerShellCommand cmd(argc, argv);
158 EXPECT_EQ(cmd.ExecCommand(), HELP_MSG);
159 }
160
161 /**
162 * @tc.number: Aa_Command_0600
163 * @tc.name: MatchOrderString
164 * @tc.desc: Verify MatchOrderString Function.
165 */
166 HWTEST_F(AaCommandTest, Aa_Command_0600, Function | MediumTest | Level1)
167 {
168 TAG_LOGI(AAFwkTag::TEST, "Ability_Command_Test_3400 is called");
169 char* argv[] = { (char*)TOOL_NAME.c_str() };
170 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
171
172 AbilityManagerShellCommand cmd(argc, argv);
173 const std::regex regexFirst(R"(^(profile|dumpheap).*)");
174 std::string command = "";
175 EXPECT_EQ(cmd.MatchOrderString(regexFirst, command), false);
176 }
177
178 /**
179 * @tc.number: Aa_Command_0700
180 * @tc.name: MatchOrderString
181 * @tc.desc: Verify MatchOrderString Function.
182 */
183 HWTEST_F(AaCommandTest, Aa_Command_0700, Function | MediumTest | Level1)
184 {
185 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_0700 is called");
186 char* argv[] = { (char*)TOOL_NAME.c_str() };
187 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
188
189 AbilityManagerShellCommand cmd(argc, argv);
190 const std::regex regexFirst(R"(^(profile|dumpheap).*)");
191 std::string command = "test";
192 EXPECT_EQ(cmd.MatchOrderString(regexFirst, command), false);
193 }
194
195 /**
196 * @tc.number: Aa_Command_0800
197 * @tc.name: MatchOrderString
198 * @tc.desc: Verify MatchOrderString Function.
199 */
200 HWTEST_F(AaCommandTest, Aa_Command_0800, Function | MediumTest | Level1)
201 {
202 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_0800 is called");
203 char* argv[] = { (char*)TOOL_NAME.c_str() };
204 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
205
206 AbilityManagerShellCommand cmd(argc, argv);
207 const std::regex regexFirst(R"(^(profile|dumpheap).*)");
208 std::string command = "profile";
209 EXPECT_EQ(cmd.MatchOrderString(regexFirst, command), true);
210 }
211
212 /**
213 * @tc.number: Aa_Command_0900
214 * @tc.name: CheckPerfCmdString
215 * @tc.desc: Verify CheckPerfCmdString Function.
216 */
217 HWTEST_F(AaCommandTest, Aa_Command_0900, Function | MediumTest | Level1)
218 {
219 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_0900 is called");
220 char* argv[] = { (char*)TOOL_NAME.c_str() };
221 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
222
223 AbilityManagerShellCommand cmd(argc, argv);
224 std::string command = "";
225 constexpr int32_t len = 0;
226 EXPECT_EQ(cmd.CheckPerfCmdString(nullptr, len, command), false);
227 }
228
229 /**
230 * @tc.number: Aa_Command_1000
231 * @tc.name: CheckPerfCmdString
232 * @tc.desc: Verify CheckPerfCmdString Function.
233 */
234 HWTEST_F(AaCommandTest, Aa_Command_1000, Function | MediumTest | Level1)
235 {
236 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1000 is called");
237 char* argv[] = { (char*)TOOL_NAME.c_str() };
238 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
239
240 AbilityManagerShellCommand cmd(argc, argv);
241 std::string command = "";
242 const char* optarg = "test";
243 constexpr int32_t len = 0;
244 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
245 }
246
247 /**
248 * @tc.number: Aa_Command_1100
249 * @tc.name: CheckPerfCmdString
250 * @tc.desc: Verify CheckPerfCmdString Function.
251 */
252 HWTEST_F(AaCommandTest, Aa_Command_1100, Function | MediumTest | Level1)
253 {
254 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1100 is called");
255 char* argv[] = { (char*)TOOL_NAME.c_str() };
256 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
257
258 AbilityManagerShellCommand cmd(argc, argv);
259 std::string command = "";
260 const char* optarg = "test";
261 constexpr int32_t len = 32;
262 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
263 }
264
265 /**
266 * @tc.number: Aa_Command_1200
267 * @tc.name: CheckPerfCmdString
268 * @tc.desc: Verify CheckPerfCmdString Function.
269 */
270 HWTEST_F(AaCommandTest, Aa_Command_1200, Function | MediumTest | Level1)
271 {
272 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1200 is called");
273 char* argv[] = { (char*)TOOL_NAME.c_str() };
274 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
275
276 AbilityManagerShellCommand cmd(argc, argv);
277 std::string command = "";
278 const char* optarg = "test";
279 constexpr int32_t len = 32;
280 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
281 }
282
283 /**
284 * @tc.number: Aa_Command_1300
285 * @tc.name: CheckPerfCmdString
286 * @tc.desc: Verify CheckPerfCmdString Function.
287 */
288 HWTEST_F(AaCommandTest, Aa_Command_1300, Function | MediumTest | Level1)
289 {
290 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1300 is called");
291 char* argv[] = { (char*)TOOL_NAME.c_str() };
292 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
293
294 AbilityManagerShellCommand cmd(argc, argv);
295 std::string command = "";
296 const char* optarg = "profile jsperf";
297 constexpr int32_t len = 32;
298 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), true);
299 }
300
301 /**
302 * @tc.number: Aa_Command_1400
303 * @tc.name: CheckPerfCmdString
304 * @tc.desc: Verify CheckPerfCmdString Function.
305 */
306 HWTEST_F(AaCommandTest, Aa_Command_1400, Function | MediumTest | Level1)
307 {
308 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1400 is called");
309 char* argv[] = { (char*)TOOL_NAME.c_str() };
310 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
311
312 AbilityManagerShellCommand cmd(argc, argv);
313 std::string command = "";
314 const char* optarg = "profile jsperf abc";
315 constexpr int32_t len = 32;
316 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
317 }
318
319 /**
320 * @tc.number: Aa_Command_1500
321 * @tc.name: CheckPerfCmdString
322 * @tc.desc: Verify CheckPerfCmdString Function.
323 */
324 HWTEST_F(AaCommandTest, Aa_Command_1500, Function | MediumTest | Level1)
325 {
326 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1500 is called");
327 char* argv[] = { (char*)TOOL_NAME.c_str() };
328 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
329
330 AbilityManagerShellCommand cmd(argc, argv);
331 std::string command = "";
332 const char* optarg = "profile abcd";
333 constexpr int32_t len = 32;
334 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
335 }
336
337 /**
338 * @tc.number: Aa_Command_1600
339 * @tc.name: CheckPerfCmdString
340 * @tc.desc: Verify CheckPerfCmdString Function.
341 */
342 HWTEST_F(AaCommandTest, Aa_Command_1600, Function | MediumTest | Level1)
343 {
344 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1600 is called");
345 char* argv[] = { (char*)TOOL_NAME.c_str() };
346 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
347
348 AbilityManagerShellCommand cmd(argc, argv);
349 std::string command = "";
350 const char* optarg = " profile abcd";
351 constexpr int32_t len = 32;
352 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), false);
353 }
354
355 /**
356 * @tc.number: Aa_Command_1700
357 * @tc.name: CheckPerfCmdString
358 * @tc.desc: Verify CheckPerfCmdString Function.
359 */
360 HWTEST_F(AaCommandTest, Aa_Command_1700, Function | MediumTest | Level1)
361 {
362 TAG_LOGI(AAFwkTag::TEST, "Aa_Command_1700 is called");
363 char* argv[] = { (char*)TOOL_NAME.c_str() };
364 int argc = sizeof(argv) / sizeof(argv[0]) - 1;
365
366 AbilityManagerShellCommand cmd(argc, argv);
367 std::string command = "";
368 const char* optarg = "sleep 100";
369 constexpr int32_t len = 32;
370 EXPECT_EQ(cmd.CheckPerfCmdString(optarg, len, command), true);
371 }