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