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 "option_test.h"
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 #include <hilog/log.h>
22
23 #include "option.h"
24
25 using namespace testing::ext;
26 using namespace std;
27 using namespace OHOS::HiviewDFX;
28 namespace OHOS {
29 namespace Developtools {
30 namespace HiPerf {
31 class OptionTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
34 static void TearDownTestCase(void);
35 void SetUp();
36 void TearDown();
37 };
38
SetUpTestCase()39 void OptionTest::SetUpTestCase() {}
40
TearDownTestCase()41 void OptionTest::TearDownTestCase() {}
42
SetUp()43 void OptionTest::SetUp()
44 {
45 Option::RegisterMainOption(TEST_OPTION_CMD_1, TEST_OPTION_HELP, OptionAlwaysFalse);
46 Option::RegisterMainOption(TEST_OPTION_CMD_2, TEST_OPTION_HELP, OptionAlwaysFalse);
47 Option::RegisterMainOption(TEST_OPTION_CMD_3, TEST_OPTION_HELP, OptionAlwaysFalse);
48 }
49
TearDown()50 void OptionTest::TearDown()
51 {
52 Option::ClearMainOptions();
53 }
54
55 /**
56 * @tc.name: TestRegisterMainOption
57 * @tc.desc:
58 * @tc.type: FUNC
59 */
60 HWTEST_F(OptionTest, TestRegisterMainOption, TestSize.Level1)
61 {
62 EXPECT_EQ(
63 Option::RegisterMainOption(TEST_OPTION_CMD_NO_PREFIX, TEST_OPTION_HELP, OptionAlwaysFalse),
64 false);
65 EXPECT_EQ(
66 Option::RegisterMainOption(TEST_OPTION_CMD_ERR_PREFIX, TEST_OPTION_HELP, OptionAlwaysFalse),
67 false);
68 EXPECT_EQ(
69 Option::RegisterMainOption(TEST_OPTION_CMD_EMPTY, TEST_OPTION_HELP, OptionAlwaysFalse),
70 false);
71
72 EXPECT_EQ(Option::RegisterMainOption("-tf", TEST_OPTION_HELP, OptionAlwaysFalse), true);
73 EXPECT_EQ(Option::RegisterMainOption("-tf", TEST_OPTION_HELP, OptionAlwaysFalse), false);
74 EXPECT_EQ(Option::RegisterMainOption("-tt", TEST_OPTION_HELP, OptionAlwaysTrue), true);
75 EXPECT_EQ(Option::RegisterMainOption("-tt", TEST_OPTION_HELP, OptionAlwaysTrue), false);
76 }
77
78 /**
79 * @tc.name: TestFindMainOption
80 * @tc.desc:
81 * @tc.type: FUNC
82 */
83 HWTEST_F(OptionTest, TestFindMainOption, TestSize.Level1)
84 {
85 ASSERT_NE(Option::FindMainOption(TEST_OPTION_CMD_1), nullptr);
86 EXPECT_NE(Option::FindMainOption(TEST_OPTION_CMD_1)->help, TEST_OPTION_BRIEF);
87 EXPECT_EQ(Option::FindMainOption(TEST_OPTION_CMD_1)->help, TEST_OPTION_HELP);
88
89 ASSERT_NE(Option::FindMainOption(TEST_OPTION_CMD_2), nullptr);
90 EXPECT_NE(Option::FindMainOption(TEST_OPTION_CMD_2)->help, TEST_OPTION_BRIEF);
91 EXPECT_EQ(Option::FindMainOption(TEST_OPTION_CMD_2)->help, TEST_OPTION_HELP);
92
93 ASSERT_NE(Option::FindMainOption(TEST_OPTION_CMD_3), nullptr);
94 EXPECT_NE(Option::FindMainOption(TEST_OPTION_CMD_3)->help, TEST_OPTION_BRIEF);
95 EXPECT_EQ(Option::FindMainOption(TEST_OPTION_CMD_3)->help, TEST_OPTION_HELP);
96
97 EXPECT_EQ(Option::FindMainOption(TEST_NO_OPTION_CMD), nullptr);
98 }
99
100 /**
101 * @tc.name: TestGetMainOptions
102 * @tc.desc:
103 * @tc.type: FUNC
104 */
105 HWTEST_F(OptionTest, GetMainOptions, TestSize.Level1)
106 {
107 EXPECT_EQ(Option::GetMainOptions().size(), 3u);
108 Option::ClearMainOptions();
109 EXPECT_EQ(Option::GetMainOptions().size(), 0u);
110 }
111
112 /**
113 * @tc.name: TestGetOptionBool
114 * @tc.desc:
115 * @tc.type: FUNC
116 */
117 HWTEST_F(OptionTest, GetOptionBool, TestSize.Level1)
118 {
119 bool boolVal;
120 std::vector<std::string> args;
121
122 // one arg
123 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_NAME, boolVal), true);
124 EXPECT_EQ(args.size(), ONE_ARGS_WITH_VALUE.size() - 1u); // only one option should eat
125 EXPECT_EQ(boolVal, true);
126 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ERROR_NAME, boolVal), true);
127 EXPECT_EQ(boolVal, true);
128 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_NAME, boolVal), true);
129 EXPECT_EQ(boolVal, true);
130 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, boolVal),
131 false);
132 EXPECT_EQ(boolVal, true);
133
134 // two arg
135 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, boolVal), true);
136 EXPECT_EQ(args.size(), TWO_ARGS_WITH_VALUE.size() - 1u);
137 EXPECT_EQ(boolVal, true);
138 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ERROR_NAME, boolVal), true);
139 EXPECT_EQ(boolVal, true);
140 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, boolVal), true);
141 EXPECT_EQ(boolVal, true);
142 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, boolVal),
143 false);
144 EXPECT_EQ(boolVal, true);
145
146 // two error arg
147 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, boolVal), true);
148 EXPECT_EQ(boolVal, true);
149 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ERROR_NAME, boolVal),
150 true);
151 EXPECT_EQ(boolVal, true);
152 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, boolVal), true);
153 EXPECT_EQ(boolVal, true);
154 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ILLEGAL_NAME, boolVal),
155 false);
156 EXPECT_EQ(boolVal, true);
157
158 // mix arg
159 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_NAME, boolVal), true);
160 EXPECT_EQ(boolVal, true);
161 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_ERROR_NAME, boolVal),
162 true);
163 EXPECT_EQ(boolVal, true);
164 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_NAME, boolVal), true);
165 EXPECT_EQ(boolVal, true);
166 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ERROR_NAME, boolVal),
167 true);
168 EXPECT_EQ(boolVal, true);
169 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ILLEGAL_NAME, boolVal),
170 false);
171 EXPECT_EQ(boolVal, true);
172 }
173
174 /**
175 * @tc.name: TestGetOptionInt
176 * @tc.desc:
177 * @tc.type: FUNC
178 */
179 HWTEST_F(OptionTest, GetOptionInt, TestSize.Level1)
180 {
181 int intValue;
182 std::vector<std::string> args;
183
184 // one arg
185 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_NAME, intValue), true);
186 EXPECT_EQ(intValue, OPTION_INT_VALUE);
187 intValue = 0;
188
189 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ERROR_NAME, intValue),
190 true);
191 EXPECT_EQ(intValue, 0);
192 intValue = 0;
193
194 // two arg
195 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, intValue), true);
196 EXPECT_EQ(intValue, OPTION_INT_VALUE);
197 intValue = 0;
198
199 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ERROR_NAME, intValue),
200 true);
201 EXPECT_EQ(intValue, 0);
202 intValue = 0;
203
204 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
205 false);
206 EXPECT_EQ(intValue, 0);
207 intValue = 0;
208
209 // two error arg
210 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, intValue), true);
211 EXPECT_EQ(intValue, 0);
212 intValue = 0;
213
214 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ERROR_NAME, intValue),
215 true);
216 EXPECT_EQ(intValue, OPTION_INT_VALUE);
217 intValue = 0;
218
219 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
220 false);
221 EXPECT_EQ(intValue, 0);
222 intValue = 0;
223 }
224 /**
225 * @tc.name: TestGetOptionInt
226 * @tc.desc:
227 * @tc.type: FUNC
228 */
229 HWTEST_F(OptionTest, GetOptionInt2, TestSize.Level1)
230 {
231 int intValue;
232 std::vector<std::string> args;
233
234 // mix arg
235 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_NAME, intValue), true);
236 EXPECT_EQ(intValue, OPTION_INT_VALUE);
237 intValue = 0;
238
239 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_ERROR_NAME, intValue),
240 true);
241 EXPECT_EQ(intValue, OPTION_INT_VALUE);
242 intValue = 0;
243
244 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_NAME, intValue), true);
245 EXPECT_EQ(intValue, OPTION_INT_VALUE);
246 intValue = 0;
247
248 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ERROR_NAME, intValue),
249 true);
250 EXPECT_EQ(intValue, OPTION_INT_VALUE);
251 intValue = 0;
252
253 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
254 false);
255 EXPECT_EQ(intValue, 0);
256 intValue = 0;
257
258 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_ILLEGAL_VALUE, OPTION_NAME, intValue),
259 false);
260 EXPECT_EQ(intValue, 0);
261 intValue = 0;
262 }
263
264 /**
265 * @tc.name: TestGetOptionString
266 * @tc.desc:
267 * @tc.type: FUNC
268 */
269 HWTEST_F(OptionTest, GetOptionString, TestSize.Level1)
270 {
271 std::string stringValue;
272 std::vector<std::string> args;
273
274 // one arg
275 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_NAME, stringValue), true);
276 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
277 stringValue.clear();
278
279 EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
280 true);
281 EXPECT_EQ(stringValue.empty(), true);
282 stringValue.clear();
283
284 // two arg
285 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, stringValue), true);
286 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
287 stringValue.clear();
288
289 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
290 true);
291 EXPECT_EQ(stringValue.empty(), true);
292 stringValue.clear();
293
294 EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
295 false);
296 EXPECT_EQ(stringValue.empty(), true);
297 stringValue.clear();
298
299 // two error arg
300 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, stringValue), true);
301 EXPECT_EQ(stringValue.empty(), true);
302 stringValue.clear();
303
304 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
305 true);
306 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
307 stringValue.clear();
308
309 EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
310 false);
311 EXPECT_EQ(stringValue.empty(), true);
312 stringValue.clear();
313 }
314
315 /**
316 * @tc.name: TestGetOptionString
317 * @tc.desc:
318 * @tc.type: FUNC
319 */
320 HWTEST_F(OptionTest, GetOptionString2, TestSize.Level1)
321 {
322 std::string stringValue;
323 std::vector<std::string> args;
324
325 // mix arg
326 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_NAME, stringValue), true);
327 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
328 stringValue.clear();
329
330 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
331 true);
332 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
333 stringValue.clear();
334
335 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_NAME, stringValue), true);
336 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
337 stringValue.clear();
338
339 EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
340 true);
341 EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
342 stringValue.clear();
343
344 EXPECT_EQ(
345 Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
346 false);
347 EXPECT_EQ(stringValue.empty(), true);
348 stringValue.clear();
349 }
350
351 /**
352 * @tc.name: TestGetOptionStrings
353 * @tc.desc:
354 * @tc.type: FUNC
355 */
356 HWTEST_F(OptionTest, GetOptionStrings, TestSize.Level1)
357 {
358 std::vector<std::string> stringValues;
359 const std::vector<std::string> constargs = {OPTION_NAME, OPTION_STRING_THREE_VALUES,
360 OPTION_ERROR_NAME};
361 std::vector<std::string> args;
362 EXPECT_EQ(Option::GetOptionValue(args = constargs, OPTION_NAME, stringValues), true);
363 EXPECT_EQ(stringValues.size(), 3u);
364
365 // if is error name , value should same as we passed
366 // in this case it should be 3 from last test case
367 args = constargs;
368 EXPECT_EQ(Option::GetOptionValue(args = constargs, OPTION_ERROR_NAME, stringValues), false);
369 EXPECT_EQ(stringValues.size(), 3u);
370 }
371
372 /**
373 * @tc.name: TestGetOptionStringss
374 * @tc.desc:
375 * @tc.type: FUNC
376 */
377 HWTEST_F(OptionTest, GetOptionStringss, TestSize.Level1)
378 {
379 std::vector<std::vector<std::string>> stringValuess;
380 const std::vector<std::string> constArgs = {
381 OPTION_NAME,
382 OPTION_STRING_THREE_VALUES,
383 OPTION_ERROR_NAME,
384 OPTION_NAME,
385 OPTION_STRING_THREE_VALUES,
386 OPTION_NAME,
387 OPTION_STRING_THREE_VALUES,
388 OPTION_NAME,
389 OPTION_STRING_THREE_VALUES,
390 OPTION_NAME_ONLY,
391 };
392 std::vector<std::string> args;
393
394 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, stringValuess), true);
395 EXPECT_EQ(stringValuess.size(), 4u);
396
397 // OPTION_NAME will be use like value, so result size is 1
398 args = constArgs;
399 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_ERROR_NAME, stringValuess), true);
400 EXPECT_EQ(stringValuess.size(), 1u);
401
402 args = constArgs;
403 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME_ONLY, stringValuess), false);
404 // last time it cahnge to 1
405 EXPECT_EQ(stringValuess.size(), 1u);
406
407 args = constArgs;
408 // void name
409 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME_VOID, stringValuess), true);
410 EXPECT_EQ(stringValuess.size(), 1u);
411 }
412
413 /**
414 * @tc.name: TestGetOptionInts
415 * @tc.desc:
416 * @tc.type: FUNC
417 */
418 HWTEST_F(OptionTest, GetOptionInts, TestSize.Level1)
419 {
420 std::vector<int> intValues;
421 const std::vector<std::string> constArgs = {OPTION_NAME, OPTION_STRING_THREE_VALUES,
422 OPTION_ERROR_NAME};
423 const std::vector<std::string> constIllegalArgs = {
424 OPTION_NAME, OPTION_STRING_THREE_ILLEGAL_VALUES, OPTION_ERROR_NAME};
425 std::vector<std::string> args;
426
427 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, intValues), true);
428 EXPECT_EQ(intValues.size(), 3u);
429
430 // should still same , not incress
431 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, intValues), true);
432 EXPECT_EQ(intValues.size(), 3u);
433
434 // should not change if false
435 EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_ERROR_NAME, intValues), false);
436 EXPECT_EQ(intValues.size(), 3u);
437
438 // should not change if false
439 EXPECT_EQ(Option::GetOptionValue(args = constIllegalArgs, OPTION_NAME, intValues), false);
440 EXPECT_EQ(intValues.size(), 3u);
441 }
442
443 /**
444 * @tc.name: TestGetValueFromStringBool
445 * @tc.desc:
446 * @tc.type: FUNC
447 */
448 HWTEST_F(OptionTest, TestGetValueFromStringBool, TestSize.Level1)
449 {
450 bool boolValue;
451 EXPECT_EQ(Option::GetValueFromString(OPTION_NAME, OPTION_NAME, boolValue), true);
452 EXPECT_EQ(boolValue, true);
453 }
454
455 /**
456 * @tc.name: TestGetValueFromStringInt
457 * @tc.desc:
458 * @tc.type: FUNC
459 */
460 HWTEST_F(OptionTest, TestGetValueFromStringInt, TestSize.Level1)
461 {
462 int intValue;
463 EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_VALUE, OPTION_NAME, intValue), true);
464 EXPECT_EQ(intValue, 3);
465 }
466
467 /**
468 * @tc.name: TestGetValueFromStringFloat
469 * @tc.desc:
470 * @tc.type: FUNC
471 */
472 HWTEST_F(OptionTest, TestGetValueFromStringFloat, TestSize.Level1)
473 {
474 float floatValue;
475 EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_VALUE, OPTION_NAME, floatValue), true);
476 EXPECT_EQ(floatValue, 3.0);
477 }
478
479 /**
480 * @tc.name: TestGetValueFromStringString
481 * @tc.desc:
482 * @tc.type: FUNC
483 */
484 HWTEST_F(OptionTest, TestGetValueFromStringString, TestSize.Level1)
485 {
486 std::string stringValue;
487 EXPECT_EQ(Option::GetValueFromString(OPTION_NAME, OPTION_NAME, stringValue), true);
488 EXPECT_EQ(stringValue, OPTION_NAME);
489 }
490
491 /**
492 * @tc.name: TestGetValueFromStringInts
493 * @tc.desc:
494 * @tc.type: FUNC
495 */
496 HWTEST_F(OptionTest, TestGetValueFromStringInts, TestSize.Level1)
497 {
498 std::vector<int> values;
499 EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_THREE_VALUES, OPTION_NAME, values), true);
500 EXPECT_EQ(values.size(), 3u);
501 }
502
503 /**
504 * @tc.name: TestGetValueFromStringStrings
505 * @tc.desc:
506 * @tc.type: FUNC
507 */
508 HWTEST_F(OptionTest, TestGetValueFromStringStrings, TestSize.Level1)
509 {
510 std::vector<std::string> values;
511 EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_THREE_VALUES, OPTION_NAME, values), true);
512 EXPECT_EQ(values.size(), 3u);
513 }
514
515 /**
516 * @tc.name: TestGetOptionTrackedCommand
517 * @tc.desc:
518 * @tc.type: FUNC
519 */
520 HWTEST_F(OptionTest, TestGetOptionTrackedCommand, TestSize.Level1)
521 {
522 std::vector<std::string> args;
523 args = {OPTION_NAME, OPTION_STRING_THREE_VALUES, OPTION_ERROR_NAME};
524 std::vector<std::string> trackedCommand;
525 EXPECT_EQ(Option::GetOptionTrackedCommand(args, trackedCommand), true);
526 EXPECT_EQ(trackedCommand.size(), 3u);
527 EXPECT_EQ(args.size(), 0u);
528 }
529 } // namespace HiPerf
530 } // namespace Developtools
531 } // namespace OHOS
532