1 /*
2 * Copyright (C) 2024 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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <string>
19 #include <unistd.h>
20
21 #include "common_define.h"
22 #include "common_utils.h"
23 #include "trace_json_parser.h"
24
25 using namespace testing::ext;
26 using namespace std;
27
28 namespace OHOS {
29 namespace HiviewDFX {
30 namespace Hitrace {
31 class HitraceUtilsTest : public testing::Test {
32 public:
33 static void SetUpTestCase(void);
TearDownTestCase(void)34 static void TearDownTestCase(void) {}
SetUp()35 void SetUp() {}
TearDown()36 void TearDown() {}
37 };
38
39 std::string g_traceRootPath;
40
SetUpTestCase()41 void HitraceUtilsTest::SetUpTestCase()
42 {
43 if (access((DEBUGFS_TRACING_DIR + TRACE_MARKER_NODE).c_str(), F_OK) != -1) {
44 g_traceRootPath = DEBUGFS_TRACING_DIR;
45 } else if (access((TRACEFS_DIR + TRACE_MARKER_NODE).c_str(), F_OK) != -1) {
46 g_traceRootPath = TRACEFS_DIR;
47 } else {
48 GTEST_LOG_(ERROR) << "Error: Finding trace folder failed.";
49 }
50 }
51
52 namespace {
53 /**
54 * @tc.name: CommonUtilsTest001
55 * @tc.desc: Test canonicalizeSpecPath(), enter an existing file path.
56 * @tc.type: FUNC
57 */
58 HWTEST_F(HitraceUtilsTest, CommonUtilsTest001, TestSize.Level2)
59 {
60 // prepare a file
61 std::string filePath = "/data/local/tmp/tmp.txt";
62 if (access(filePath.c_str(), F_OK) != 0) {
63 int fd = open(filePath.c_str(), O_CREAT);
64 close(fd);
65 }
66 ASSERT_TRUE(CanonicalizeSpecPath(filePath.c_str()) == filePath);
67 filePath = "/data/local/tmp/tmp1.txt";
68 if (access(filePath.c_str(), F_OK) != 0) {
69 ASSERT_TRUE(CanonicalizeSpecPath(filePath.c_str()) == filePath);
70 }
71 // prepare a file
72 filePath = "../tmp2.txt";
73 if (access(filePath.c_str(), F_OK) != 0) {
74 ASSERT_TRUE(CanonicalizeSpecPath(filePath.c_str()) == "");
75 }
76 }
77
78 /**
79 * @tc.name: CommonUtilsTest002
80 * @tc.desc: Test MarkClockSync().
81 * @tc.type: FUNC
82 */
83 HWTEST_F(HitraceUtilsTest, CommonUtilsTest002, TestSize.Level2)
84 {
85 ASSERT_TRUE(MarkClockSync(g_traceRootPath));
86 }
87
88 /**
89 * @tc.name: CommonUtilsTest003
90 * @tc.desc: Test IsNumber().
91 * @tc.type: FUNC
92 */
93 HWTEST_F(HitraceUtilsTest, CommonUtilsTest003, TestSize.Level2)
94 {
95 ASSERT_TRUE(IsNumber("1234"));
96 ASSERT_FALSE(IsNumber("123ABC"));
97 }
98
99 /**
100 * @tc.name: CommonUtilsTest004
101 * @tc.desc: Test GetCpuProcessors/ReadCurrentCpuFrequencies function
102 * @tc.type: FUNC
103 */
104 HWTEST_F(HitraceUtilsTest, CommonUtilsTest004, TestSize.Level2)
105 {
106 ASSERT_TRUE(GetCpuProcessors() > 1);
107 std::string freqStr;
108 ReadCurrentCpuFrequencies(freqStr);
109 GTEST_LOG_(INFO) << freqStr;
110 ASSERT_TRUE(freqStr.find("cpu_id=") != std::string::npos);
111 ASSERT_TRUE(freqStr.find("state=") != std::string::npos);
112 }
113
114 /**
115 * @tc.name: JsonParserTest001
116 * @tc.desc: Test TraceJsonParser function, parse json infos step by step, check all data and every step state.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(HitraceUtilsTest, JsonParserTest001, TestSize.Level2)
120 {
121 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
122 ASSERT_TRUE(jsonParser->GetAllTagInfos().empty());
123 ASSERT_TRUE(jsonParser->GetTagGroups().empty());
124 ASSERT_TRUE(jsonParser->GetBaseFmtPath().empty());
125
126 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_BUFSZ_INFO));
127 ASSERT_TRUE(jsonParser->GetTagGroups().empty());
128 ASSERT_TRUE(jsonParser->GetBaseFmtPath().empty());
129 ASSERT_TRUE(jsonParser->GetAllTagInfos().empty());
130 ASSERT_EQ(jsonParser->GetSnapShotBufSzKb(), 0);
131
132 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_BASE_INFO));
133 ASSERT_TRUE(jsonParser->GetTagGroups().empty());
134 ASSERT_TRUE(jsonParser->GetBaseFmtPath().empty());
135 auto tags = jsonParser->GetAllTagInfos();
136 ASSERT_FALSE(tags.empty());
137 ASSERT_FALSE(tags.find("sched") == tags.end());
138 ASSERT_TRUE(tags["sched"].enablePath.empty());
139 ASSERT_TRUE(tags["sched"].formatPath.empty());
140
141 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_ENABLE_INFO));
142 tags = jsonParser->GetAllTagInfos();
143 ASSERT_FALSE(tags.find("sched") == tags.end());
144 ASSERT_FALSE(tags["sched"].enablePath.empty());
145 ASSERT_TRUE(tags["sched"].formatPath.empty());
146
147 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_FORMAT_INFO));
148 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty()) << "base format path size:" <<
149 jsonParser->GetBaseFmtPath().size();
150 tags = jsonParser->GetAllTagInfos();
151 ASSERT_FALSE(tags.find("sched") == tags.end());
152 ASSERT_FALSE(tags["sched"].enablePath.empty());
153 ASSERT_FALSE(tags["sched"].formatPath.empty());
154
155 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_GROUP_INFO));
156 ASSERT_FALSE(jsonParser->GetTagGroups().empty());
157 }
158
159 /**
160 * @tc.name: JsonParserTest002
161 * @tc.desc: Test TraceJsonParser function, if only parse format infos, tag base infos should also be parsed.
162 * @tc.type: FUNC
163 */
164 HWTEST_F(HitraceUtilsTest, JsonParserTest002, TestSize.Level2)
165 {
166 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
167 ASSERT_TRUE(jsonParser->ParseTraceJson(TRACE_TAG_FORMAT_INFO));
168 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty()) << "base format path size:" <<
169 jsonParser->GetBaseFmtPath().size();
170
171 auto tags = jsonParser->GetAllTagInfos();
172 ASSERT_FALSE(tags.empty());
173 ASSERT_FALSE(tags.find("sched") == tags.end());
174 ASSERT_TRUE(tags["sched"].enablePath.empty());
175 ASSERT_FALSE(tags["sched"].formatPath.empty());
176 }
177
178 /**
179 * @tc.name: JsonParserTest003
180 * @tc.desc: Test TraceJsonParser function, check parse format infos, base format info should not be parsed twice.
181 * @tc.type: FUNC
182 */
183 HWTEST_F(HitraceUtilsTest, JsonParserTest003, TestSize.Level2)
184 {
185 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
186 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_FORMAT_INFO));
187 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty()) << "base format path size:" <<
188 jsonParser->GetBaseFmtPath().size();
189
190 int basePathCnt1 = jsonParser->GetBaseFmtPath().size();
191 GTEST_LOG_(INFO) << "base format path size:" << basePathCnt1;
192 jsonParser->ParseTraceJson(PARSE_TRACE_FORMAT_INFO);
193 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty()) << "base format path size:" <<
194 jsonParser->GetBaseFmtPath().size();
195 int basePathCnt2 = jsonParser->GetBaseFmtPath().size();
196 GTEST_LOG_(INFO) << "base format path size:" << basePathCnt2;
197
198 ASSERT_EQ(basePathCnt1, basePathCnt2);
199 }
200
201 /**
202 * @tc.name: JsonParserTest004
203 * @tc.desc: Test TraceJsonParser function. call it as same as hitrace command.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(HitraceUtilsTest, JsonParserTest004, TestSize.Level2)
207 {
208 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
209 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_BASE_INFO));
210 ASSERT_TRUE(jsonParser->GetTagGroups().empty());
211 ASSERT_TRUE(jsonParser->GetBaseFmtPath().empty());
212 auto tags = jsonParser->GetAllTagInfos();
213 ASSERT_FALSE(tags.empty());
214 ASSERT_FALSE(tags.find("sched") == tags.end());
215 ASSERT_TRUE(tags["sched"].enablePath.empty());
216 ASSERT_TRUE(tags["sched"].formatPath.empty());
217 }
218
219 /**
220 * @tc.name: JsonParserTest005
221 * @tc.desc: Test TraceJsonParser function. call it as same as hitrace dump record mode.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(HitraceUtilsTest, JsonParserTest005, TestSize.Level2)
225 {
226 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
227 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_TRACE_GROUP_INFO));
228 ASSERT_EQ(jsonParser->GetSnapShotBufSzKb(), 0);
229 auto groups = jsonParser->GetTagGroups();
230 ASSERT_FALSE(groups.empty());
231 ASSERT_FALSE(groups.find("default") == groups.end());
232 ASSERT_FALSE(groups.find("scene_performance") == groups.end());
233 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty());
234 auto tags = jsonParser->GetAllTagInfos();
235 ASSERT_FALSE(tags.empty());
236 ASSERT_FALSE(tags.find("sched") == tags.end());
237 ASSERT_FALSE(tags["sched"].enablePath.empty());
238 ASSERT_FALSE(tags["sched"].formatPath.empty());
239 }
240
241 /**
242 * @tc.name: JsonParserTest006
243 * @tc.desc: Test TraceJsonParser function. call it as same as hitrace dump service mode.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(HitraceUtilsTest, JsonParserTest006, TestSize.Level2)
247 {
248 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
249 ASSERT_TRUE(jsonParser->ParseTraceJson(PARSE_ALL_INFO));
250 ASSERT_EQ(jsonParser->GetSnapShotBufSzKb(), 0);
251 auto groups = jsonParser->GetTagGroups();
252 ASSERT_FALSE(groups.empty());
253 ASSERT_FALSE(groups.find("default") == groups.end());
254 ASSERT_FALSE(groups.find("scene_performance") == groups.end());
255 ASSERT_FALSE(jsonParser->GetBaseFmtPath().empty());
256 auto tags = jsonParser->GetAllTagInfos();
257 ASSERT_FALSE(tags.empty());
258 ASSERT_FALSE(tags.find("sched") == tags.end());
259 ASSERT_FALSE(tags["sched"].enablePath.empty());
260 ASSERT_FALSE(tags["sched"].formatPath.empty());
261 }
262
263 /**
264 * @tc.name: JsonParserTest007
265 * @tc.desc: Test TraceJsonParser function. call it as same as trace aging.
266 * @tc.type: FUNC
267 */
268 HWTEST_F(HitraceUtilsTest, JsonParserTest007, TestSize.Level2)
269 {
270 std::shared_ptr<TraceJsonParser> jsonParser = std::make_shared<TraceJsonParser>();
271 ASSERT_TRUE(jsonParser->ParseTraceJson(TRACE_SNAPSHOT_FILE_AGE));
272 ASSERT_TRUE(jsonParser->GetSnapShotFileAge());
273 }
274
275 /**
276 * @tc.name: StringToNumberTest
277 * @tc.desc: Test StringToInt/StringToInt64/StringToUint64/StringToDouble function.
278 * @tc.type: FUNC
279 */
280 HWTEST_F(HitraceUtilsTest, StringToNumberTest, TestSize.Level2)
281 {
282 std::string traceParamsStr = "123";
283 int paramsInt = 0;
284 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
285 EXPECT_EQ(paramsInt, 123); // 123: test value
286 traceParamsStr = "-123";
287 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
288 EXPECT_EQ(paramsInt, -123); // -123: test value
289 traceParamsStr = "2147483647";
290 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
291 EXPECT_EQ(paramsInt, INT_MAX);
292 traceParamsStr = "-2147483648";
293 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
294 EXPECT_EQ(paramsInt, INT_MIN);
295
296 traceParamsStr = "1234567890";
297 int64_t paramsInt64 = 0;
298 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
299 EXPECT_EQ(paramsInt64, 1234567890); // 1234567890: test value
300 traceParamsStr = "-1234567890";
301 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
302 EXPECT_EQ(paramsInt64, -1234567890); // -1234567890: test value
303 traceParamsStr = "9223372036854775807";
304 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
305 EXPECT_EQ(paramsInt64, LLONG_MAX);
306 traceParamsStr = "-9223372036854775808";
307 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
308 EXPECT_EQ(paramsInt64, LLONG_MIN);
309
310 traceParamsStr = "1234567890";
311 uint64_t paramsUint64 = 0;
312 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
313 EXPECT_EQ(paramsUint64, 1234567890); // 1234567890: test value
314 traceParamsStr = "18446744073709551615";
315 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
316 EXPECT_EQ(paramsUint64, ULLONG_MAX);
317
318 traceParamsStr = "1234567890.123456";
319 double paramsDouble = 0;
320 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
321 EXPECT_EQ(paramsDouble, 1234567890.123456); // 1234567890.123456: test value
322 traceParamsStr = "-1234567890.123456";
323 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
324 EXPECT_EQ(paramsDouble, -1234567890.123456); // -1234567890.123456: test value
325 traceParamsStr = ".1";
326 EXPECT_TRUE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
327 EXPECT_EQ(paramsDouble, 0.1); // 0.1: test value
328 }
329
330 /**
331 * @tc.name: StringToIntErrorTest
332 * @tc.desc: Test StringToInt function.
333 * @tc.type: FUNC
334 */
335 HWTEST_F(HitraceUtilsTest, StringToIntErrorTest, TestSize.Level2)
336 {
337 std::string traceParamsStr = "a123";
338 int paramsInt = 0;
339 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
340 traceParamsStr = "12a3";
341 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
342 traceParamsStr = "";
343 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
344 traceParamsStr = "abc";
345 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
346 traceParamsStr = ".1";
347 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
348 traceParamsStr = "1.1";
349 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
350 traceParamsStr = "2147483648";
351 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
352 traceParamsStr = "-2147483649";
353 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt(traceParamsStr, paramsInt));
354 }
355
356 /**
357 * @tc.name: StringToInt64ErrorTest
358 * @tc.desc: Test StringToInt64 function.
359 * @tc.type: FUNC
360 */
361 HWTEST_F(HitraceUtilsTest, StringToInt64ErrorTest, TestSize.Level2)
362 {
363 std::string traceParamsStr = "a123";
364 int64_t paramsInt64 = 0;
365 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
366 traceParamsStr = "12a3";
367 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
368 traceParamsStr = "";
369 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
370 traceParamsStr = "abc";
371 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
372 traceParamsStr = ".1";
373 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
374 traceParamsStr = "1.1";
375 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
376 traceParamsStr = "9223372036854775808";
377 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
378 traceParamsStr = "-9223372036854775809";
379 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToInt64(traceParamsStr, paramsInt64));
380 }
381
382 /**
383 * @tc.name: StringToUint64ErrorTest
384 * @tc.desc: Test StringToUint64 function.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(HitraceUtilsTest, StringToUint64ErrorTest, TestSize.Level2)
388 {
389 std::string traceParamsStr = "-1234567890";
390 uint64_t paramsUint64 = 0;
391 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
392 traceParamsStr = "a123";
393 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
394 traceParamsStr = "";
395 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
396 traceParamsStr = "12a3";
397 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
398 traceParamsStr = "abc";
399 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
400 traceParamsStr = ".1";
401 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
402 traceParamsStr = "1.1";
403 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
404 traceParamsStr = "18446744073709551616";
405 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToUint64(traceParamsStr, paramsUint64));
406 }
407
408 /**
409 * @tc.name: StringToDoubleErrorTest
410 * @tc.desc: Test StringToDouble function.
411 * @tc.type: FUNC
412 */
413 HWTEST_F(HitraceUtilsTest, StringToDoubleErrorTest, TestSize.Level2)
414 {
415 std::string traceParamsStr = "a123";
416 double paramsDouble = 0;
417 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
418 traceParamsStr = "12a3";
419 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
420 traceParamsStr = "";
421 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
422 traceParamsStr = "abc";
423 EXPECT_FALSE(OHOS::HiviewDFX::Hitrace::StringToDouble(traceParamsStr, paramsDouble));
424 }
425 } // namespace
426 } // namespace Hitrace
427 } // namespace HiviewDFX
428 } // namespace OHOS