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