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
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 */
222 HWTEST_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 */
256 HWTEST_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 */
307 HWTEST_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 */
343 HWTEST_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 */
364 HWTEST_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 */
405 HWTEST_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 */
435 HWTEST_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 */
447 HWTEST_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 */
459 HWTEST_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 */
471 HWTEST_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 */
483 HWTEST_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 */
495 HWTEST_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 */
507 HWTEST_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