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