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
25using namespace testing::ext;
26using namespace std;
27using namespace OHOS::HiviewDFX;
28namespace OHOS {
29namespace Developtools {
30namespace HiPerf {
31class OptionTest : public testing::Test {
32public:
33    static void SetUpTestCase(void);
34    static void TearDownTestCase(void);
35    void SetUp();
36    void TearDown();
37};
38
39void OptionTest::SetUpTestCase() {}
40
41void OptionTest::TearDownTestCase() {}
42
43void 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
50void OptionTest::TearDown()
51{
52    Option::ClearMainOptions();
53}
54
55/**
56 * @tc.name: TestRegisterMainOption
57 * @tc.desc:
58 * @tc.type: FUNC
59 */
60HWTEST_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 */
83HWTEST_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 */
105HWTEST_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 */
117HWTEST_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 */
179HWTEST_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
188    EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ERROR_NAME, intValue),
189              true);
190    EXPECT_EQ(intValue, OPTION_INT_VALUE);
191
192    // two arg
193    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, intValue), true);
194    EXPECT_EQ(intValue, OPTION_INT_VALUE);
195
196    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ERROR_NAME, intValue),
197              true);
198    EXPECT_EQ(intValue, OPTION_INT_VALUE);
199
200    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
201              false);
202    EXPECT_EQ(intValue, OPTION_INT_VALUE);
203
204    // two error arg
205    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, intValue), true);
206    EXPECT_EQ(intValue, OPTION_INT_VALUE);
207
208    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ERROR_NAME, intValue),
209              true);
210    EXPECT_EQ(intValue, OPTION_INT_VALUE);
211
212
213    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
214              false);
215    EXPECT_EQ(intValue, OPTION_INT_VALUE);
216}
217/**
218 * @tc.name: TestGetOptionInt
219 * @tc.desc:
220 * @tc.type: FUNC
221 */
222HWTEST_F(OptionTest, GetOptionInt2, TestSize.Level1)
223{
224    int intValue;
225    std::vector<std::string> args;
226
227    // mix arg
228    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_NAME, intValue), true);
229    EXPECT_EQ(intValue, OPTION_INT_VALUE);
230
231    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_ERROR_NAME, intValue),
232              true);
233    EXPECT_EQ(intValue, OPTION_INT_VALUE);
234
235    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_NAME, intValue), true);
236    EXPECT_EQ(intValue, OPTION_INT_VALUE);
237
238    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ERROR_NAME, intValue),
239              true);
240    EXPECT_EQ(intValue, OPTION_INT_VALUE);
241
242    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ILLEGAL_NAME, intValue),
243              false);
244    EXPECT_EQ(intValue, OPTION_INT_VALUE);
245
246    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_ILLEGAL_VALUE, OPTION_NAME, intValue),
247              false);
248    EXPECT_EQ(intValue, OPTION_INT_VALUE);
249}
250
251/**
252 * @tc.name: TestGetOptionString
253 * @tc.desc:
254 * @tc.type: FUNC
255 */
256HWTEST_F(OptionTest, GetOptionString, TestSize.Level1)
257{
258    std::string stringValue;
259    std::vector<std::string> args;
260
261    // one arg
262    EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_NAME, stringValue), true);
263    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
264    stringValue.clear();
265
266    EXPECT_EQ(Option::GetOptionValue(args = ONE_ARGS_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
267              true);
268    EXPECT_EQ(stringValue.empty(), true);
269    stringValue.clear();
270
271    // two arg
272    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_NAME, stringValue), true);
273    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
274    stringValue.clear();
275
276    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
277              true);
278    EXPECT_EQ(stringValue.empty(), true);
279    stringValue.clear();
280
281    EXPECT_EQ(Option::GetOptionValue(args = TWO_ARGS_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
282              false);
283    EXPECT_EQ(stringValue.empty(), true);
284    stringValue.clear();
285
286    // two error arg
287    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_NAME, stringValue), true);
288    EXPECT_EQ(stringValue.empty(), true);
289    stringValue.clear();
290
291    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
292              true);
293    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
294    stringValue.clear();
295
296    EXPECT_EQ(Option::GetOptionValue(args = TWO_ERROR_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
297              false);
298    EXPECT_EQ(stringValue.empty(), true);
299    stringValue.clear();
300}
301
302/**
303 * @tc.name: TestGetOptionString
304 * @tc.desc:
305 * @tc.type: FUNC
306 */
307HWTEST_F(OptionTest, GetOptionString2, TestSize.Level1)
308{
309    std::string stringValue;
310    std::vector<std::string> args;
311
312    // mix arg
313    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_NAME, stringValue), true);
314    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
315    stringValue.clear();
316
317    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_1_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
318              true);
319    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
320    stringValue.clear();
321
322    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_NAME, stringValue), true);
323    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
324    stringValue.clear();
325
326    EXPECT_EQ(Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ERROR_NAME, stringValue),
327              true);
328    EXPECT_EQ(stringValue, OPTION_STRING_VALUE);
329    stringValue.clear();
330
331    EXPECT_EQ(
332        Option::GetOptionValue(args = MIX_ARGS_2_WITH_VALUE, OPTION_ILLEGAL_NAME, stringValue),
333        false);
334    EXPECT_EQ(stringValue.empty(), true);
335    stringValue.clear();
336}
337
338/**
339 * @tc.name: TestGetOptionStrings
340 * @tc.desc:
341 * @tc.type: FUNC
342 */
343HWTEST_F(OptionTest, GetOptionStrings, TestSize.Level1)
344{
345    std::vector<std::string> stringValues;
346    const std::vector<std::string> constargs = {OPTION_NAME, OPTION_STRING_THREE_VALUES,
347                                                OPTION_ERROR_NAME};
348    std::vector<std::string> args;
349    EXPECT_EQ(Option::GetOptionValue(args = constargs, OPTION_NAME, stringValues), true);
350    EXPECT_EQ(stringValues.size(), 3u);
351
352    // if is error name , value should same as we passed
353    // in this case it should be 3 from last test case
354    args = constargs;
355    EXPECT_EQ(Option::GetOptionValue(args = constargs, OPTION_ERROR_NAME, stringValues), false);
356    EXPECT_EQ(stringValues.size(), 3u);
357}
358
359/**
360 * @tc.name: TestGetOptionStringss
361 * @tc.desc:
362 * @tc.type: FUNC
363 */
364HWTEST_F(OptionTest, GetOptionStringss, TestSize.Level1)
365{
366    std::vector<std::vector<std::string>> stringValuess;
367    const std::vector<std::string> constArgs = {
368        OPTION_NAME,
369        OPTION_STRING_THREE_VALUES,
370        OPTION_ERROR_NAME,
371        OPTION_NAME,
372        OPTION_STRING_THREE_VALUES,
373        OPTION_NAME,
374        OPTION_STRING_THREE_VALUES,
375        OPTION_NAME,
376        OPTION_STRING_THREE_VALUES,
377        OPTION_NAME_ONLY,
378    };
379    std::vector<std::string> args;
380
381    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, stringValuess), true);
382    EXPECT_EQ(stringValuess.size(), 4u);
383
384    // OPTION_NAME will be use like value, so result size is 1
385    args = constArgs;
386    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_ERROR_NAME, stringValuess), true);
387    EXPECT_EQ(stringValuess.size(), 1u);
388
389    args = constArgs;
390    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME_ONLY, stringValuess), false);
391    // last time it cahnge to 1
392    EXPECT_EQ(stringValuess.size(), 1u);
393
394    args = constArgs;
395    // void name
396    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME_VOID, stringValuess), true);
397    EXPECT_EQ(stringValuess.size(), 1u);
398}
399
400/**
401 * @tc.name: TestGetOptionInts
402 * @tc.desc:
403 * @tc.type: FUNC
404 */
405HWTEST_F(OptionTest, GetOptionInts, TestSize.Level1)
406{
407    std::vector<int> intValues;
408    const std::vector<std::string> constArgs = {OPTION_NAME, OPTION_STRING_THREE_VALUES,
409                                                OPTION_ERROR_NAME};
410    const std::vector<std::string> constIllegalArgs = {
411        OPTION_NAME, OPTION_STRING_THREE_ILLEGAL_VALUES, OPTION_ERROR_NAME};
412    std::vector<std::string> args;
413
414    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, intValues), true);
415    EXPECT_EQ(intValues.size(), 3u);
416
417    // should still same , not incress
418    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_NAME, intValues), true);
419    EXPECT_EQ(intValues.size(), 3u);
420
421    // should not change if false
422    EXPECT_EQ(Option::GetOptionValue(args = constArgs, OPTION_ERROR_NAME, intValues), false);
423    EXPECT_EQ(intValues.size(), 3u);
424
425    // should not change if false
426    EXPECT_EQ(Option::GetOptionValue(args = constIllegalArgs, OPTION_NAME, intValues), false);
427    EXPECT_EQ(intValues.size(), 3u);
428}
429
430/**
431 * @tc.name: TestGetValueFromStringBool
432 * @tc.desc:
433 * @tc.type: FUNC
434 */
435HWTEST_F(OptionTest, TestGetValueFromStringBool, TestSize.Level1)
436{
437    bool boolValue;
438    EXPECT_EQ(Option::GetValueFromString(OPTION_NAME, OPTION_NAME, boolValue), true);
439    EXPECT_EQ(boolValue, true);
440}
441
442/**
443 * @tc.name: TestGetValueFromStringInt
444 * @tc.desc:
445 * @tc.type: FUNC
446 */
447HWTEST_F(OptionTest, TestGetValueFromStringInt, TestSize.Level1)
448{
449    int intValue;
450    EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_VALUE, OPTION_NAME, intValue), true);
451    EXPECT_EQ(intValue, 3);
452}
453
454/**
455 * @tc.name: TestGetValueFromStringFloat
456 * @tc.desc:
457 * @tc.type: FUNC
458 */
459HWTEST_F(OptionTest, TestGetValueFromStringFloat, TestSize.Level1)
460{
461    float floatValue;
462    EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_VALUE, OPTION_NAME, floatValue), true);
463    EXPECT_EQ(floatValue, 3.0);
464}
465
466/**
467 * @tc.name: TestGetValueFromStringString
468 * @tc.desc:
469 * @tc.type: FUNC
470 */
471HWTEST_F(OptionTest, TestGetValueFromStringString, TestSize.Level1)
472{
473    std::string stringValue;
474    EXPECT_EQ(Option::GetValueFromString(OPTION_NAME, OPTION_NAME, stringValue), true);
475    EXPECT_EQ(stringValue, OPTION_NAME);
476}
477
478/**
479 * @tc.name: TestGetValueFromStringInts
480 * @tc.desc:
481 * @tc.type: FUNC
482 */
483HWTEST_F(OptionTest, TestGetValueFromStringInts, TestSize.Level1)
484{
485    std::vector<int> values;
486    EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_THREE_VALUES, OPTION_NAME, values), true);
487    EXPECT_EQ(values.size(), 3u);
488}
489
490/**
491 * @tc.name: TestGetValueFromStringStrings
492 * @tc.desc:
493 * @tc.type: FUNC
494 */
495HWTEST_F(OptionTest, TestGetValueFromStringStrings, TestSize.Level1)
496{
497    std::vector<std::string> values;
498    EXPECT_EQ(Option::GetValueFromString(OPTION_STRING_THREE_VALUES, OPTION_NAME, values), true);
499    EXPECT_EQ(values.size(), 3u);
500}
501
502/**
503 * @tc.name: TestGetOptionTrackedCommand
504 * @tc.desc:
505 * @tc.type: FUNC
506 */
507HWTEST_F(OptionTest, TestGetOptionTrackedCommand, TestSize.Level1)
508{
509    std::vector<std::string> args;
510    args = {OPTION_NAME, OPTION_STRING_THREE_VALUES, OPTION_ERROR_NAME};
511    std::vector<std::string> trackedCommand;
512    EXPECT_EQ(Option::GetOptionTrackedCommand(args, trackedCommand), true);
513    EXPECT_EQ(trackedCommand.size(), 3u);
514    EXPECT_EQ(args.size(), 0u);
515}
516} // namespace HiPerf
517} // namespace Developtools
518} // namespace OHOS
519