1 /*
2 * Copyright (C) 2023 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 "hitrace_dump.h"
17
18 #include <cstdio>
19 #include <dirent.h>
20 #include <fcntl.h>
21 #include <fstream>
22 #include <gtest/gtest.h>
23 #include <iostream>
24 #include <map>
25 #include <memory>
26 #include <string>
27 #include <unistd.h>
28 #include <vector>
29
30 #include "common_define.h"
31 #include "common_utils.h"
32 #include "hilog/log.h"
33 #include "parameters.h"
34 #include "securec.h"
35
36 using namespace OHOS::HiviewDFX::Hitrace;
37 using namespace testing::ext;
38 using OHOS::HiviewDFX::HiLog;
39
40 namespace {
41 #ifdef LOG_DOMAIN
42 #undef LOG_DOMAIN
43 #define LOG_DOMAIN 0xD002D33
44 #endif
45 #ifdef LOG_TAG
46 #undef LOG_TAG
47 #define LOG_TAG "HitraceTest"
48 #endif
49 const int BUFFER_SIZE = 255;
50 constexpr uint32_t SLEEP_TIME = 10; // sleep 10ms
51 constexpr uint32_t TWO_SEC = 2;
52 constexpr uint32_t TEN_SEC = 10;
53 constexpr uint32_t MAX_RATIO_UNIT = 1000;
54 constexpr int DEFAULT_FULL_TRACE_LENGTH = 30;
55 const std::string TRACE_SNAPSHOT_PREFIX = "trace_";
56 const std::string TRACE_RECORDING_PREFIX = "record_trace_";
57 const std::string TRACE_CACHE_PREFIX = "cache_trace_";
58 struct FileWithTime {
59 std::string filename;
60 time_t ctime;
61 uint64_t fileSize;
62 };
63 enum TRACE_TYPE : uint8_t {
64 TRACE_SNAPSHOT = 0,
65 TRACE_RECORDING = 1,
66 TRACE_CACHE = 2,
67 };
68 std::map<TRACE_TYPE, std::string> tracePrefixMap = {
69 {TRACE_SNAPSHOT, TRACE_SNAPSHOT_PREFIX},
70 {TRACE_RECORDING, TRACE_RECORDING_PREFIX},
71 {TRACE_CACHE, TRACE_CACHE_PREFIX},
72 };
73
TraverseFiles(std::vector<std::string> files,std::string outputFileName)74 bool TraverseFiles(std::vector<std::string> files, std::string outputFileName)
75 {
76 int i = 1;
77 bool isExists = false;
78 for (std::vector<std::string>::iterator iter = files.begin(); iter != files.end(); iter++) {
79 isExists |= (strcmp(iter->c_str(), outputFileName.c_str()) == 0);
80 HILOG_INFO(LOG_CORE, "ret.outputFile%{public}d: %{public}s", i++, iter->c_str());
81 }
82 return isExists;
83 }
84
HasProcessWithName(const std::string & name)85 int HasProcessWithName(const std::string& name)
86 {
87 std::array<char, BUFFER_SIZE> buffer;
88 std::unique_ptr<FILE, decltype(&pclose)> pipe(popen("ps -ef | grep HitraceDump", "r"), pclose);
89 if (pipe == nullptr) {
90 HILOG_ERROR(LOG_CORE, "Error: run command failed.");
91 return -1;
92 }
93 while (fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr) {
94 std::string line(buffer.data());
95 size_t found = line.rfind(name);
96 if (found != std::string::npos && (found == line.length() - name.length() ||
97 line[found + name.length()] == ' ')) {
98 return 1;
99 }
100 }
101 return 0;
102 }
103
GetFileStatInfo(const std::string & filePath)104 struct stat GetFileStatInfo(const std::string& filePath)
105 {
106 struct stat fileStat;
107 if (stat(filePath.c_str(), &fileStat) != 0) {
108 HILOG_ERROR(LOG_CORE, "Error getting file status: %{public}d.", errno);
109 }
110 return fileStat;
111 }
112
GetTraceFilesInDir(const TRACE_TYPE & traceType)113 std::vector<FileWithTime> GetTraceFilesInDir(const TRACE_TYPE& traceType)
114 {
115 struct stat fileStat;
116 std::vector<FileWithTime> fileList;
117 for (const auto &entry : std::filesystem::directory_iterator(TRACE_FILE_DEFAULT_DIR)) {
118 if (!entry.is_regular_file()) {
119 continue;
120 }
121 std::string fileName = entry.path().filename().string();
122 if (fileName.substr(0, tracePrefixMap[traceType].size()) == tracePrefixMap[traceType]) {
123 if (stat((TRACE_FILE_DEFAULT_DIR + fileName).c_str(), &fileStat) == 0) {
124 fileList.push_back({TRACE_FILE_DEFAULT_DIR + fileName, fileStat.st_ctime,
125 static_cast<uint64_t>(fileStat.st_size)});
126 }
127 }
128 }
129 std::sort(fileList.begin(), fileList.end(), [](const FileWithTime& a, const FileWithTime& b) {
130 return a.ctime < b.ctime;
131 });
132 return fileList;
133 }
134
DeleteTraceFileInDir(const std::vector<FileWithTime> fileLists)135 void DeleteTraceFileInDir(const std::vector<FileWithTime> fileLists)
136 {
137 for (size_t i = 0; i < fileLists.size(); ++i) {
138 if (remove(fileLists[i].filename.c_str()) == 0) {
139 GTEST_LOG_(INFO) << "remove " << fileLists[i].filename.c_str() << " success.";
140 } else {
141 GTEST_LOG_(INFO) << "remove " << fileLists[i].filename.c_str() << " fail.";
142 }
143 }
144 }
145
InitFileFromDir()146 void InitFileFromDir()
147 {
148 DeleteTraceFileInDir(GetTraceFilesInDir(TRACE_CACHE));
149 DeleteTraceFileInDir(GetTraceFilesInDir(TRACE_SNAPSHOT));
150 }
151
152 class HitraceDumpTest : public testing::Test {
153 public:
SetUpTestCase(void)154 static void SetUpTestCase(void) {}
TearDownTestCase(void)155 static void TearDownTestCase(void) {}
156 void SetUp();
TearDown()157 void TearDown() {}
158 };
159
SetUp()160 void HitraceDumpTest::SetUp()
161 {
162 CloseTrace();
163 }
164
165 /**
166 * @tc.name: GetTraceModeTest_001
167 * @tc.desc: test trace state for OpenTrace and CloseTrace
168 * @tc.type: FUNC
169 */
170 HWTEST_F(HitraceDumpTest, GetTraceModeTest_001, TestSize.Level0)
171 {
172 // check OpenTrace(tagGroup)
173 const std::vector<std::string> tagGroups = {"scene_performance"};
174 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
175 uint8_t traceMode = GetTraceMode();
176 ASSERT_EQ(traceMode, TraceMode::OPEN);
177
178 // check close trace
179 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
180 traceMode = GetTraceMode();
181 ASSERT_EQ(traceMode, TraceMode::CLOSE);
182
183 // check OpenTrace(args)
184 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
185 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
186 traceMode = GetTraceMode();
187 ASSERT_EQ(traceMode, TraceMode::OPEN);
188
189 // check close trace
190 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
191 traceMode = GetTraceMode();
192 ASSERT_EQ(traceMode, TraceMode::CLOSE);
193 }
194
195 /**
196 * @tc.name: GetTraceModeTest_002
197 * @tc.desc: test trace state for RecordOn and RecordOff
198 * @tc.type: FUNC
199 */
200 HWTEST_F(HitraceDumpTest, GetTraceModeTest_002, TestSize.Level0)
201 {
202 const std::vector<std::string> tagGroups = {"scene_performance"};
203 ASSERT_EQ(OpenTrace(tagGroups), TraceErrorCode::SUCCESS);
204 ASSERT_EQ(RecordTraceOn(), TraceErrorCode::SUCCESS);
205 uint8_t traceMode = GetTraceMode();
206 ASSERT_EQ(traceMode, TraceMode::OPEN | TraceMode::RECORD);
207
208 TraceRetInfo ret = RecordTraceOff();
209 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS);
210 traceMode = GetTraceMode();
211 ASSERT_EQ(traceMode, TraceMode::OPEN);
212
213 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
214 traceMode = GetTraceMode();
215 ASSERT_EQ(traceMode, TraceMode::CLOSE);
216 }
217
218 /**
219 * @tc.name: GetTraceModeTest_003
220 * @tc.desc: test trace state for CacheOn and CacheOff
221 * @tc.type: FUNC
222 */
223 HWTEST_F(HitraceDumpTest, GetTraceModeTest_003, TestSize.Level0)
224 {
225 const std::vector<std::string> tagGroups = {"scene_performance"};
226 ASSERT_EQ(OpenTrace(tagGroups), TraceErrorCode::SUCCESS);
227 ASSERT_EQ(CacheTraceOn(), TraceErrorCode::SUCCESS);
228 uint8_t traceMode = GetTraceMode();
229 ASSERT_EQ(traceMode, TraceMode::OPEN | TraceMode::CACHE);
230
231 ASSERT_EQ(CacheTraceOff(), TraceErrorCode::SUCCESS);
232 traceMode = GetTraceMode();
233 ASSERT_EQ(traceMode, TraceMode::OPEN);
234
235 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
236 traceMode = GetTraceMode();
237 ASSERT_EQ(traceMode, TraceMode::CLOSE);
238 }
239
240 /**
241 * @tc.name: DumpTraceTest_001
242 * @tc.desc: Test DumpTrace(int maxDuration) for valid input.
243 * The no arg version DumpTrace() is implicitly tested in other tests.
244 * @tc.type: FUNC
245 */
246 HWTEST_F(HitraceDumpTest, DumpTraceTest_001, TestSize.Level0)
247 {
248 const std::vector<std::string> tagGroups = {"default"};
249 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
250 sleep(1); // wait 1s
251 int maxDuration = 1;
252 TraceRetInfo ret = DumpTrace(maxDuration);
253 ASSERT_EQ(static_cast<int>(ret.errorCode), static_cast<int>(TraceErrorCode::SUCCESS));
254 ASSERT_GT(ret.outputFiles.size(), 0);
255 ASSERT_EQ(ret.tags, tagGroups);
256 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
257 }
258
259 /**
260 * @tc.name: DumpTraceTest_002
261 * @tc.desc: Test DumpTrace(int maxDuration) for invalid input.
262 * @tc.type: FUNC
263 */
264 HWTEST_F(HitraceDumpTest, DumpTraceTest_002, TestSize.Level0)
265 {
266 const std::vector<std::string> tagGroups = {"default"};
267 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
268 sleep(1); // wait 1s
269 int maxDuration = -1;
270 TraceRetInfo ret = DumpTrace(maxDuration);
271 ASSERT_TRUE(ret.errorCode == TraceErrorCode::INVALID_MAX_DURATION);
272 ASSERT_TRUE(ret.outputFiles.empty());
273 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
274 }
275
276 /**
277 * @tc.name: DumpTraceTest_003
278 * @tc.desc: Test DumpTrace(int maxDuration, uint64_t happenTime) for valid input.
279 * @tc.type: FUNC
280 */
281 HWTEST_F(HitraceDumpTest, DumpTraceTest_003, TestSize.Level0)
282 {
283 const std::vector<std::string> tagGroups = {"scene_performance"};
284 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
285 sleep(TWO_SEC); // need at least one second of trace in cpu due to the input unit of 1 second to avoid OUT_OF_TIME.
286 uint64_t traceEndTime = static_cast<uint64_t>(std::time(nullptr));
287 TraceRetInfo ret = DumpTrace(0, traceEndTime);
288 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
289 ASSERT_TRUE(ret.outputFiles.size() > 0);
290 ASSERT_EQ(ret.tags, tagGroups);
291 ASSERT_GE(ret.coverDuration, TWO_SEC - 1);
292 ASSERT_GE(ret.coverRatio, MAX_RATIO_UNIT * (TWO_SEC - 1) / DEFAULT_FULL_TRACE_LENGTH);
293 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
294
295 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
296 sleep(TWO_SEC);
297 traceEndTime = static_cast<uint64_t>(std::time(nullptr));
298 ret = DumpTrace(TEN_SEC, traceEndTime);
299 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(ret.errorCode);
300 ASSERT_TRUE(ret.outputFiles.size() > 0);
301 ASSERT_EQ(ret.tags, tagGroups);
302 ASSERT_GE(ret.coverDuration, TWO_SEC - 1);
303 ASSERT_GE(ret.coverRatio, MAX_RATIO_UNIT * (TWO_SEC - 1) / TEN_SEC);
304 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
305 }
306
307 /**
308 * @tc.name: DumpTraceTest_004
309 * @tc.desc: Test DumpTrace(int maxDuration, uint64_t happenTime) for invalid input.
310 * @tc.type: FUNC
311 */
312 HWTEST_F(HitraceDumpTest, DumpTraceTest_004, TestSize.Level0)
313 {
314 const std::vector<std::string> tagGroups = {"default"};
315 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
316 sleep(1); // wait 1s
317 uint64_t traceEndTime = static_cast<uint64_t>(std::time(nullptr)) + 10; // current time + 10 seconds
318 TraceRetInfo ret = DumpTrace(0, traceEndTime);
319 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
320 ASSERT_FALSE(ret.outputFiles.empty());
321 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
322
323 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
324 sleep(1); // wait 1s
325 traceEndTime = 10; // 1970-01-01 08:00:10
326 int maxDuration = -1;
327 ret = DumpTrace(maxDuration, traceEndTime);
328 ASSERT_TRUE(ret.errorCode == TraceErrorCode::INVALID_MAX_DURATION);
329 ASSERT_TRUE(ret.outputFiles.empty());
330 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
331
332 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
333 sleep(1); // wait 1s
334 traceEndTime = static_cast<uint64_t>(std::time(nullptr)) + 10; // current time + 10 seconds
335 maxDuration = -1;
336 ret = DumpTrace(maxDuration, traceEndTime);
337 ASSERT_TRUE(ret.errorCode == TraceErrorCode::INVALID_MAX_DURATION);
338 ASSERT_TRUE(ret.outputFiles.empty());
339 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
340 }
341
342 /**
343 * @tc.name: DumpTraceTest_005
344 * @tc.desc: Test DumpTrace(int maxDuration, uint64_t happenTime) for OUT_OF_TIME.
345 * @tc.type: FUNC
346 */
347 HWTEST_F(HitraceDumpTest, DumpTraceTest_005, TestSize.Level0)
348 {
349 const std::vector<std::string> tagGroups = {"scene_performance"};
350 InitFileFromDir();
351 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
352 sleep(1); // wait 1s
353 uint64_t traceEndTime = 1;
354 TraceRetInfo ret = DumpTrace(0, traceEndTime);
355 ASSERT_TRUE(ret.errorCode == TraceErrorCode::OUT_OF_TIME);
356 ASSERT_TRUE(ret.outputFiles.empty());
357 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
358
359 InitFileFromDir();
360 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
361 sleep(1); // wait 1s
362 traceEndTime = 10; // 1970-01-01 08:00:10
363 uint64_t maxDuration = 10;
364 ret = DumpTrace(maxDuration, traceEndTime);
365 ASSERT_TRUE(ret.errorCode == TraceErrorCode::OUT_OF_TIME);
366 ASSERT_TRUE(ret.outputFiles.empty());
367 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
368
369 InitFileFromDir();
370 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
371 sleep(TWO_SEC);
372 traceEndTime = static_cast<uint64_t>(std::time(nullptr)) - 20; // current time - 20 seconds
373 ret = DumpTrace(0, traceEndTime);
374 ASSERT_TRUE(ret.errorCode == TraceErrorCode::OUT_OF_TIME);
375 ASSERT_TRUE(ret.outputFiles.empty());
376 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
377
378 InitFileFromDir();
379 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
380 sleep(TWO_SEC);
381 traceEndTime = static_cast<uint64_t>(std::time(nullptr)) - 20; // current time - 20 seconds
382 ret = DumpTrace(TEN_SEC, traceEndTime);
383 ASSERT_TRUE(ret.errorCode == TraceErrorCode::OUT_OF_TIME);
384 ASSERT_TRUE(ret.outputFiles.empty());
385 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
386 }
387
388 /**
389 * @tc.name: DumpTraceTest_006
390 * @tc.desc: Test DumpTrace(int maxDuration, uint64_t happenTime) for maxDuration is bigger than boot_time
391 * @tc.type: FUNC
392 */
393 HWTEST_F(HitraceDumpTest, DumpTraceTest_006, TestSize.Level0)
394 {
395 const std::vector<std::string> tagGroups = {"scene_performance"};
396 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
397 sleep(TWO_SEC);
398 uint64_t traceEndTime = static_cast<uint64_t>(std::time(nullptr)); // current time
399
400 TraceRetInfo ret = DumpTrace(INT_MAX, traceEndTime);
401 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS);
402 ASSERT_TRUE(!ret.outputFiles.empty());
403 ASSERT_EQ(ret.tags, tagGroups);
404 ASSERT_GE(ret.coverDuration, TWO_SEC - 1);
405 ASSERT_GE(ret.coverRatio, MAX_RATIO_UNIT * (TWO_SEC - 1) / DEFAULT_FULL_TRACE_LENGTH);
406 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
407 }
408
409 /**
410 * @tc.name: DumpTraceTest_007
411 * @tc.desc: Test DumpTrace(int maxDuration, uint64_t happenTime) for INVALID_MAX_DURATION.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(HitraceDumpTest, DumpTraceTest_007, TestSize.Level0)
415 {
416 const std::vector<std::string> tagGroups = {"default"};
417 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
418 sleep(TWO_SEC);
419 uint64_t traceEndTime = static_cast<uint64_t>(std::time(nullptr));
420 TraceRetInfo ret = DumpTrace(-1, traceEndTime);
421 ASSERT_TRUE(ret.errorCode == TraceErrorCode::INVALID_MAX_DURATION) << "errorCode: "
422 << static_cast<int>(ret.errorCode);
423 ASSERT_TRUE(ret.outputFiles.empty());
424 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
425 }
426
427 /**
428 * @tc.name: DumpTraceTest_008
429 * @tc.desc: Test Test DumpTrace(int maxDuration) for check process is recycled.
430 * @tc.type: FUNC
431 */
432 HWTEST_F(HitraceDumpTest, DumpTraceTest_008, TestSize.Level0)
433 {
434 const std::vector<std::string> tagGroups = {"default"};
435 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
436 for (int i = 0; i < 10; i++) {
437 int maxDuration = 1;
438 TraceRetInfo ret = DumpTrace(maxDuration);
439 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
440 sleep(1);
441 ASSERT_TRUE(HasProcessWithName("HitraceDump") == 0);
442 }
443 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
444 }
445
446 /**
447 * @tc.name: DumpTraceTest_009
448 * @tc.desc: Test DumpTrace() result in cache_on is opening 8s and slice time is 5s.
449 * The no arg version DumpTrace() is implicitly tested in other tests.
450 * @tc.type: FUNC
451 */
452 HWTEST_F(HitraceDumpTest, DumpTraceTest_009, TestSize.Level0)
453 {
454 const std::vector<std::string> tagGroups = {"default"};
455 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
456 // total cache filesize limit: 800MB, sliceduration: 5s
457 ASSERT_TRUE(CacheTraceOn(800, 5) == TraceErrorCode::SUCCESS);
458 sleep(8); // wait 8s
459 ASSERT_TRUE(CacheTraceOff() == TraceErrorCode::SUCCESS);
460 sleep(2); // wait 2s
461 TraceRetInfo ret = DumpTrace();
462 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(ret.errorCode);
463 for (int i = 0; i < ret.outputFiles.size(); i++) {
464 GTEST_LOG_(INFO) << "outputFiles:" << ret.outputFiles[i].c_str();
465 }
466 ASSERT_TRUE(ret.outputFiles.size() >= 3); // compare file count
467 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
468 }
469
470 /**
471 * @tc.name: DumpTraceTest_010
472 * @tc.desc: Test DumpTrace() result in cache_on is opening 40s and slice time is 10s.
473 * The no arg version DumpTrace() is implicitly tested in other tests.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(HitraceDumpTest, DumpTraceTest_010, TestSize.Level0)
477 {
478 const std::vector<std::string> tagGroups = {"default"};
479 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
480 // total cache filesize limit: 800MB, sliceduration: 10s
481 ASSERT_TRUE(CacheTraceOn(800, 10) == TraceErrorCode::SUCCESS);
482 sleep(40); // wait 40s, over 30s
483 TraceRetInfo ret = DumpTrace();
484 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(ret.errorCode);
485 for (int i = 0; i < ret.outputFiles.size(); i++) {
486 GTEST_LOG_(INFO) << "outputFiles:" << ret.outputFiles[i].c_str();
487 }
488 ASSERT_TRUE(ret.outputFiles.size() >= 3); // compare file count
489 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
490 }
491
492 /**
493 * @tc.name: DumpTraceTest_011
494 * @tc.desc: Test result when calling DumpTrace() twice with cache_on is opening 20s and slice time is 5s.
495 * The no arg version DumpTrace() is implicitly tested in other tests.
496 * @tc.type: FUNC
497 */
498 HWTEST_F(HitraceDumpTest, DumpTraceTest_011, TestSize.Level0)
499 {
500 const std::vector<std::string> tagGroups = {"default"};
501 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
502 // total cache filesize limit: 800MB, sliceduration: 5s
503 ASSERT_TRUE(CacheTraceOn(800, 5) == TraceErrorCode::SUCCESS);
504 sleep(8); // wait 8s
505 TraceRetInfo ret = DumpTrace();
506 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS);
507 for (int i = 0; i < ret.outputFiles.size(); i++) {
508 GTEST_LOG_(INFO) << "outputFiles:" << ret.outputFiles[i].c_str();
509 }
510 ASSERT_TRUE(ret.outputFiles.size() >= 2); // compare file count
511 sleep(1);
512 TraceRetInfo retNext = DumpTrace();
513 ASSERT_EQ(retNext.errorCode, TraceErrorCode::SUCCESS);
514 for (int i = 0; i < retNext.outputFiles.size(); i++) {
515 GTEST_LOG_(INFO) << "outputFiles:" << retNext.outputFiles[i].c_str();
516 }
517 ASSERT_TRUE(retNext.outputFiles.size() >= 3); // compare file count
518 ASSERT_EQ(CloseTrace(), TraceErrorCode::SUCCESS);
519 }
520
521 /**
522 * @tc.name: DumpForServiceMode_001
523 * @tc.desc: Correct capturing trace using default OpenTrace.
524 * @tc.type: FUNC
525 */
526 HWTEST_F(HitraceDumpTest, DumpForServiceMode_001, TestSize.Level0)
527 {
528 const std::vector<std::string> tagGroups = {"scene_performance"};
529 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
530
531 TraceRetInfo ret = DumpTrace();
532 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
533 ASSERT_TRUE(ret.outputFiles.size() > 0);
534 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
535 }
536
537 /**
538 * @tc.name: DumpForServiceMode_002
539 * @tc.desc: Test invalid tag groups for default OpenTrace.
540 * @tc.type: FUNC
541 */
542 HWTEST_F(HitraceDumpTest, DumpForServiceMode_002, TestSize.Level0)
543 {
544 const std::vector<std::string> tagGroups;
545 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::TAG_ERROR);
546
547 const std::vector<std::string> tagGroups1 = {"scene_performance1"};
548 ASSERT_TRUE(OpenTrace(tagGroups1) == TraceErrorCode::TAG_ERROR);
549 TraceRetInfo ret = DumpTrace();
550 ASSERT_TRUE(ret.errorCode == TraceErrorCode::WRONG_TRACE_MODE);
551 ASSERT_TRUE(ret.outputFiles.empty());
552 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
553 }
554
555 /**
556 * @tc.name: DumpForServiceMode_003
557 * @tc.desc: Enable the service mode in CMD_MODE.
558 * @tc.type: FUNC
559 */
560 HWTEST_F(HitraceDumpTest, DumpForServiceMode_003, TestSize.Level0)
561 {
562 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
563 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
564
565 const std::vector<std::string> tagGroups = {"scene_performance"};
566 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::WRONG_TRACE_MODE);
567
568 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
569
570 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
571
572 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::WRONG_TRACE_MODE);
573
574 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
575 }
576
577 /**
578 * @tc.name: DumpForServiceMode_004
579 * @tc.desc: Invalid parameter verification in CMD_MODE.
580 * @tc.type: FUNC
581 */
582 HWTEST_F(HitraceDumpTest, DumpForServiceMode_004, TestSize.Level0)
583 {
584 const std::vector<std::string> tagGroups = {"scene_performance"};
585 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
586 ASSERT_TRUE(access(TRACE_FILE_DEFAULT_DIR.c_str(), F_OK) == 0) << "/data/log/hitrace not exists.";
587
588 SetSysInitParamTags(123);
589 ASSERT_TRUE(SetCheckParam() == false);
590
591 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
592 }
593
594 /**
595 * @tc.name: DumpForServiceMode_005
596 * @tc.desc: Test TRACE_IS_OCCUPIED.
597 * @tc.type: FUNC
598 */
599 HWTEST_F(HitraceDumpTest, DumpForServiceMode_005, TestSize.Level0)
600 {
601 const std::vector<std::string> tagGroups = {"scene_performance"};
602 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
603
604 SetSysInitParamTags(123);
605 OHOS::system::SetParameter("debug.hitrace.tags.enableflags", std::to_string(0));
606 ASSERT_TRUE(DumpTrace().errorCode == TraceErrorCode::TRACE_IS_OCCUPIED);
607
608 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
609 }
610
611 /**
612 * @tc.name: DumpForServiceMode_006
613 * @tc.desc: Test mix calling RecordTraceOn & RecordTraceOff in opening cache and closing cache.
614 * The no arg version DumpTrace() is implicitly tested in other tests.
615 * @tc.type: FUNC
616 */
617 HWTEST_F(HitraceDumpTest, DumpForServiceMode_006, TestSize.Level0)
618 {
619 const std::vector<std::string> tagGroups = {"default"};
620 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
621 ASSERT_TRUE(CacheTraceOn() == TraceErrorCode::SUCCESS);
622 ASSERT_TRUE(CacheTraceOn() == TraceErrorCode::WRONG_TRACE_MODE);
623 ASSERT_TRUE(RecordTraceOn() == TraceErrorCode::WRONG_TRACE_MODE);
624 TraceRetInfo ret = RecordTraceOff();
625 ASSERT_TRUE(ret.errorCode == TraceErrorCode::WRONG_TRACE_MODE);
626 ASSERT_TRUE(CacheTraceOff() == TraceErrorCode::SUCCESS);
627 ASSERT_TRUE(CacheTraceOff() == TraceErrorCode::WRONG_TRACE_MODE);
628 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
629 ASSERT_TRUE(CacheTraceOn() == TraceErrorCode::WRONG_TRACE_MODE);
630 ASSERT_TRUE(CacheTraceOff() == TraceErrorCode::WRONG_TRACE_MODE);
631 }
632
633 /**
634 * @tc.name: DumpForServiceMode_007
635 * @tc.desc: Test all tag groups for default OpenTrace.
636 * @tc.type: FUNC
637 */
638 HWTEST_F(HitraceDumpTest, DumpForServiceMode_007, TestSize.Level0)
639 {
640 ASSERT_TRUE(OpenTrace("default") == TraceErrorCode::SUCCESS);
641 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
642 ASSERT_TRUE(OpenTrace("scene_performance") == TraceErrorCode::SUCCESS);
643 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
644 ASSERT_TRUE(OpenTrace("telemetry") == TraceErrorCode::SUCCESS);
645 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
646 }
647
648 /**
649 * @tc.name: DumpForCmdMode_001
650 * @tc.desc: The correct usage of grasping trace in CMD_MODE.
651 * @tc.type: FUNC
652 */
653 HWTEST_F(HitraceDumpTest, DumpForCmdMode_001, TestSize.Level0)
654 {
655 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
656 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
657
658 TraceErrorCode retCode = RecordTraceOn();
659 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
660 sleep(1);
661
662 TraceRetInfo ret = RecordTraceOff();
663 ASSERT_EQ(ret.errorCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
664 ASSERT_GE(ret.outputFiles.size(), 0);
665
666 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
667 }
668
669 /**
670 * @tc.name: DumpForCmdMode_002
671 * @tc.desc: Specifies the path of the command in CMD_MODE.
672 * @tc.type: FUNC
673 */
674 HWTEST_F(HitraceDumpTest, DumpForCmdMode_002, TestSize.Level0)
675 {
676 std::string filePathName = "/data/local/tmp/mytrace.sys";
677 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1 output:" + filePathName;
678 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
679 TraceErrorCode retCode = RecordTraceOn();
680 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
681 sleep(1);
682
683 TraceRetInfo ret = RecordTraceOff();
684 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
685
686 ASSERT_TRUE(TraverseFiles(ret.outputFiles, filePathName))
687 << "unspport set outputfile, default generate file in /data/log/hitrace.";
688
689 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
690 }
691
692 /**
693 * @tc.name: DumpForCmdMode_003
694 * @tc.desc: Invalid args verification in CMD_MODE.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(HitraceDumpTest, DumpForCmdMode_003, TestSize.Level0)
698 {
699 std::string args = "clockType:boot bufferSize:1024 overwrite:1 ";
700 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
701 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
702
703 args = "tags:hdc clockType:boot bufferSize:1024 overwrite:1 descriptions:123";
704 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::TAG_ERROR);
705
706 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
707 }
708
709 /**
710 * @tc.name: DumpForCmdMode_004
711 * @tc.desc: The CMD_MODE cannot be interrupted by the SERVICE_MODE.
712 * @tc.type: FUNC
713 */
714 HWTEST_F(HitraceDumpTest, DumpForCmdMode_004, TestSize.Level0)
715 {
716 std::string args = "tags:memory clockType:boot1 bufferSize:1024 overwrite:0";
717 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
718
719 const std::vector<std::string> tagGroups = {"scene_performance"};
720 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::WRONG_TRACE_MODE);
721
722 TraceErrorCode retCode = RecordTraceOn();
723 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
724 sleep(1);
725
726 TraceRetInfo ret = RecordTraceOff();
727 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
728 ASSERT_TRUE(ret.outputFiles.size() > 0);
729
730 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
731
732 args = "tags:memory clockType: bufferSize:1024 overwrite:1";
733 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
734 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
735
736 args = "tags:memory clockType:perf bufferSize:1024 overwrite:1";
737 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
738 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
739 }
740
741 /**
742 * @tc.name: DumpForCmdMode_005
743 * @tc.desc: Enable the cmd mode in non-close mode.
744 * @tc.type: FUNC
745 */
746 HWTEST_F(HitraceDumpTest, DumpForCmdMode_005, TestSize.Level0)
747 {
748 const std::vector<std::string> tagGroups = {"scene_performance"};
749 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
750 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
751 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::WRONG_TRACE_MODE);
752 TraceErrorCode retCode = RecordTraceOn();
753 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
754 ASSERT_EQ(GetTraceMode(), TraceMode::OPEN | TraceMode::RECORD);
755 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
756 }
757
758 /**
759 * @tc.name: DumpForCmdMode_006
760 * @tc.desc: Test the CMD_MODE when there's extra space in args.
761 * @tc.type: FUNC
762 */
763 HWTEST_F(HitraceDumpTest, DumpForCmdMode_006, TestSize.Level0)
764 {
765 std::string args = "tags: sched clockType: boot bufferSize:1024 overwrite: 1";
766 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
767 TraceErrorCode retCode = RecordTraceOn();
768 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
769 sleep(1);
770
771 TraceRetInfo ret = RecordTraceOff();
772 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
773 ASSERT_TRUE(ret.outputFiles.size() > 0);
774
775 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
776 }
777
778 /**
779 * @tc.name: DumpForCmdMode_007
780 * @tc.desc: Test the CMD_MODE when set fileLimit in args.
781 * @tc.type: FUNC
782 */
783 HWTEST_F(HitraceDumpTest, DumpForCmdMode_007, TestSize.Level0)
784 {
785 std::string args = "tags:sched,ace,app,disk,distributeddatamgr,freq,graphic,idle,irq,load,mdfs,mmc,";
786 args += "notification,ohos,pagecache,regulators,sync,ufs,workq,zaudio,zcamera,zimage,zmedia ";
787 args += "clockType: boot bufferSize:1024 overwrite: 1 fileLimit: 2 fileSize: 51200";
788 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
789
790 TraceErrorCode retCode = RecordTraceOn();
791 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
792 sleep(1);
793
794 TraceRetInfo ret = RecordTraceOff();
795 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
796 ASSERT_TRUE(ret.outputFiles.size() > 0);
797
798 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
799 }
800
801 /**
802 * @tc.name: DumpForCmdMode_008
803 * @tc.desc: Test the CMD_MODE when there's extra space in args.
804 * @tc.type: FUNC
805 */
806 HWTEST_F(HitraceDumpTest, DumpForCmdMode_008, TestSize.Level0)
807 {
808 std::string filePathName = "/data/local/tmp/mylongtrace.sys";
809 std::string args = "tags:sched,ace,app,disk,distributeddatamgr,freq,graphic,idle,irq,load,mdfs,mmc,";
810 args += "notification,ohos,pagecache,regulators,sync,ufs,workq,zaudio,zcamera,zimage,zmedia ";
811 args += "clockType: boot bufferSize:1024 overwrite: 1 output:" + filePathName;
812 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
813
814 TraceErrorCode retCode = RecordTraceOn();
815 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
816 if (remove(filePathName.c_str()) == 0) {
817 HILOG_INFO(LOG_CORE, "Delete mylongtrace.sys success.");
818 } else {
819 HILOG_ERROR(LOG_CORE, "Delete mylongtrace.sys failed.");
820 }
821 sleep(SLEEP_TIME);
822
823 TraceRetInfo ret = RecordTraceOff();
824 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
825 ASSERT_TRUE(ret.outputFiles.size() > 0);
826
827 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
828 }
829
830 /**
831 * @tc.name: DumpForCmdMode_009
832 * @tc.desc: Test the CMD_MODE when set fileLimit in args.
833 * @tc.type: FUNC
834 */
835 HWTEST_F(HitraceDumpTest, DumpForCmdMode_009, TestSize.Level0)
836 {
837 std::string args = "tags:sched,ace,app,disk,distributeddatamgr,freq,graphic,idle,irq,load,mdfs,mmc,";
838 args += "notification,ohos,pagecache,regulators,sync,ufs,workq,zaudio,zcamera,zimage,zmedia ";
839 args += "clockType: boot bufferSize:1024 overwrite: 1 fileLimit: 2";
840 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
841
842 TraceErrorCode retCode = RecordTraceOn();
843 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
844 sleep(1);
845
846 TraceRetInfo ret = RecordTraceOff();
847 ASSERT_TRUE(ret.errorCode == TraceErrorCode::SUCCESS);
848 ASSERT_TRUE(ret.outputFiles.size() > 0);
849
850 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
851 }
852
853 /**
854 * @tc.name: DumpForCmdMode_010
855 * @tc.desc: Test the multi-process task CMD_MODE when set fileLimit in args.
856 * @tc.type: FUNC
857 */
858 HWTEST_F(HitraceDumpTest, DumpForCmdMode_010, TestSize.Level0)
859 {
860 std::string args = "tags:sched,ace,app,disk,distributeddatamgr,freq,graphic,idle,irq,load,mdfs,mmc,";
861 args += "notification,ohos,pagecache,regulators,sync,ufs,workq,zaudio,zcamera,zimage,zmedia ";
862 args += "clockType: boot bufferSize:1024 overwrite: 1 fileLimit: 2";
863 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
864
865 pid_t pid = fork();
866 if (pid < 0) {
867 HILOG_ERROR(LOG_CORE, "fork error.");
868 } else if (pid == 0) {
869 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::WRONG_TRACE_MODE);
870 _exit(EXIT_SUCCESS);
871 }
872
873 TraceErrorCode retCode = RecordTraceOn();
874 ASSERT_EQ(retCode, TraceErrorCode::SUCCESS) << "errorCode: " << static_cast<int>(retCode);
875 sleep(1);
876 TraceRetInfo ret = RecordTraceOff();
877 ASSERT_EQ(static_cast<int>(ret.errorCode), static_cast<int>(TraceErrorCode::SUCCESS));
878 ASSERT_TRUE(ret.outputFiles.size() > 0);
879
880 ASSERT_EQ(CloseTrace(), TraceErrorCode::SUCCESS);
881 }
882
883 /**
884 * @tc.name: DumpForCmdMode_011
885 * @tc.desc: Test the multi-process task SERVICE_MODE and Enable the cmd mode in non-close mode.
886 * @tc.type: FUNC
887 */
888 HWTEST_F(HitraceDumpTest, DumpForCmdMode_011, TestSize.Level0)
889 {
890 const std::vector<std::string> tagGroups = {"scene_performance"};
891 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
892
893 pid_t pid = fork();
894 if (pid < 0) {
895 HILOG_ERROR(LOG_CORE, "fork error.");
896 } else if (pid == 0) {
897 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::WRONG_TRACE_MODE);
898 _exit(EXIT_SUCCESS);
899 }
900
901 std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
902 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::WRONG_TRACE_MODE);
903 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
904 }
905
906 /**
907 * @tc.name: DumpForCmdMode_012
908 * @tc.desc: Test saved_events_format regenerate.
909 * @tc.type: FUNC
910 */
911 HWTEST_F(HitraceDumpTest, DumpForCmdMode_012, TestSize.Level0)
912 {
913 std::string args = "tags: sched clockType: boot bufferSize:1024 overwrite: 1";
914 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
915 sleep(1);
916 struct stat beforeStat = GetFileStatInfo(TRACE_FILE_DEFAULT_DIR + TRACE_SAVED_EVENTS_FORMAT);
917 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
918 ASSERT_TRUE(OpenTrace(args) == TraceErrorCode::SUCCESS);
919 sleep(1);
920 struct stat afterStat = GetFileStatInfo(TRACE_FILE_DEFAULT_DIR + TRACE_SAVED_EVENTS_FORMAT);
921 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
922 ASSERT_TRUE(afterStat.st_ctime != beforeStat.st_ctime);
923 }
924
925 /**
926 * @tc.name: ParammeterCheck_001
927 * @tc.desc: Check parameter after interface call.
928 * @tc.type: FUNC
929 */
930 HWTEST_F(HitraceDumpTest, ParammeterCheck_001, TestSize.Level0)
931 {
932 const std::vector<std::string> tagGroups = {"scene_performance"};
933 ASSERT_TRUE(OpenTrace(tagGroups) == TraceErrorCode::SUCCESS);
934
935 // check Property("debug.hitrace.tags.enableflags")
936 uint64_t openTags = OHOS::system::GetUintParameter<uint64_t>(TRACE_TAG_ENABLE_FLAGS, 0);
937 ASSERT_TRUE(openTags > 0);
938
939 ASSERT_TRUE(CloseTrace() == TraceErrorCode::SUCCESS);
940
941 // check Property("debug.hitrace.tags.enableflags")
942 uint64_t closeTags = OHOS::system::GetUintParameter<uint64_t>(TRACE_TAG_ENABLE_FLAGS, 0);
943 ASSERT_TRUE(closeTags == 0);
944 }
945
946 /**
947 * @tc.name: TraceFilesTableTest_001
948 * @tc.desc: Check files table.
949 * @tc.type: FUNC
950 */
951 HWTEST_F(HitraceDumpTest, TraceFilesTableTest_001, TestSize.Level0)
952 {
953 std::vector<std::pair<std::string, int>> data = {{"1", 1}, {"2", 2}, {"3", 3}};
954 SetTraceFilesTable(data);
955 std::vector<std::pair<std::string, int>> traceFilesTable = GetTraceFilesTable();
956 ASSERT_EQ(data.size(), traceFilesTable.size());
957 for (size_t index = 0; index < data.size() - 1; index++) {
958 EXPECT_EQ(data[index].first, traceFilesTable[index].first);
959 EXPECT_EQ(data[index].second, traceFilesTable[index].second);
960 }
961 }
962 } // namespace
963