1 /*
2  * Copyright (C) 2022 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 <fstream>
17 #include <regex>
18 #include <string>
19 #include <fcntl.h>
20 #include <gtest/gtest.h>
21 #include <hilog/log.h>
22 #include "securec.h"
23 #include "hitrace_meter.h"
24 #include "hitrace_osal.h"
25 #include "parameters.h"
26 #include "hitrace/tracechain.h"
27 
28 using namespace testing::ext;
29 using namespace std;
30 using namespace OHOS::HiviewDFX;
31 using namespace OHOS::HiviewDFX::HitraceOsal;
32 
33 #define EXPECTANTLY(exp) (__builtin_expect(!!(exp), true))
34 
35 namespace OHOS {
36 namespace HiviewDFX {
37 namespace HitraceTest {
38 const string TRACE_MARKER_PATH = "trace_marker";
39 const string TRACING_ON_PATH = "tracing_on";
40 const string TRACING_ON = "tracing_on";
41 const string TRACE_PATH = "trace";
42 const string TRACE_PROPERTY = "debug.hitrace.tags.enableflags";
43 const string KEY_RO_DEBUGGABLE = "ro.debuggable";
44 const string KEY_APP_NUMBER = "debug.hitrace.app_number";
45 const string LABEL_HEADER = "|H:";
46 const string VERTICAL_LINE = "|";
47 
48 constexpr uint64_t TRACE_INVALIDATE_TAG = 0x1000000;
49 constexpr uint32_t SLEEP_ONE_SECOND = 1;
50 #undef LOG_DOMAIN
51 #define LOG_DOMAIN 0xD002D33
52 
53 #undef LOG_TAG
54 #define LOG_TAG "Hitrace_TEST"
55 const uint64_t TAG = HITRACE_TAG_OHOS;
56 constexpr const int OUTPACE_DEFAULT_CACHE_SIZE = 33 * 1024;
57 constexpr int HITRACEID_LEN = 64;
58 constexpr int BUFFER_LEN = 640;
59 constexpr int DIVISOR = 10;
60 static string g_traceRootPath;
61 static int g_pid;
62 CachedHandle g_cachedHandle;
63 CachedHandle g_appPidCachedHandle;
64 
65 bool SetProperty(const string& property, const string& value);
66 string GetProperty(const string& property, const string& value);
67 bool CleanTrace();
68 bool CleanFtrace();
69 bool SetFtrace(const string& filename, bool enabled);
70 
71 class HitraceNDKTest : public testing::Test {
72 public:
73     static void SetUpTestCase(void);
74     static void TearDownTestCase(void);
75     void SetUp();
TearDown()76     void TearDown() {}
77 };
78 
SetUpTestCase()79 void  HitraceNDKTest::SetUpTestCase()
80 {
81     g_pid = getpid();
82     const string debugfsDir = "/sys/kernel/debug/tracing/";
83     const string tracefsDir = "/sys/kernel/tracing/";
84     if (access((debugfsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
85         g_traceRootPath = debugfsDir;
86     } else if (access((tracefsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
87         g_traceRootPath = tracefsDir;
88     } else {
89         HILOG_ERROR(LOG_CORE, "Error: Finding trace folder failed");
90     }
91     CleanFtrace();
92 }
93 
TearDownTestCase()94 void HitraceNDKTest::TearDownTestCase()
95 {
96     SetProperty(TRACE_PROPERTY, "0");
97     SetFtrace(TRACING_ON, false);
98     CleanTrace();
99 }
100 
SetUp()101 void HitraceNDKTest::SetUp()
102 {
103     ASSERT_TRUE(CleanTrace());
104     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
105     string value = to_string(TAG);
106     SetProperty(TRACE_PROPERTY, value);
107     HILOG_INFO(LOG_CORE, "current tag is %{public}s", GetProperty(TRACE_PROPERTY, "0").c_str());
108     ASSERT_TRUE(GetProperty(TRACE_PROPERTY, "-123") == value);
109     UpdateTraceLabel();
110 }
111 
SetProperty(const string & property,const string & value)112 bool SetProperty(const string& property, const string& value)
113 {
114     bool result = false;
115     result = OHOS::system::SetParameter(property, value);
116     if (!result) {
117         HILOG_ERROR(LOG_CORE, "Error: setting %s failed", property.c_str());
118         return false;
119     }
120     return true;
121 }
122 
GetProperty(const string & property,const string & value)123 string GetProperty(const string& property, const string& value)
124 {
125     return OHOS::system::GetParameter(property, value);
126 }
127 
GetTimeDuration(int64_t time1,int64_t time2,int64_t diffRange)128 bool GetTimeDuration(int64_t time1, int64_t time2, int64_t diffRange)
129 {
130     int64_t duration = time2 - time1;
131     return (duration > 0) && (duration <= diffRange ? true : false);
132 }
133 
Trim(string & s)134 string& Trim(string& s)
135 {
136     if (s.empty()) {
137         return s;
138     }
139     s.erase(0, s.find_first_not_of(" "));
140     s.erase(s.find_last_not_of(" ") + 1);
141     return s;
142 }
143 
GetTimeStamp(string str)144 int64_t GetTimeStamp(string str)
145 {
146     if (str == "") {
147         return 0;
148     }
149     int64_t time;
150     Trim(str);
151     time = atol(str.erase(str.find("."), 1).c_str());
152     return time;
153 }
154 
GetRecord(HiTraceId hiTraceId)155 string GetRecord(HiTraceId hiTraceId)
156 {
157     std::string record;
158     char buf[HITRACEID_LEN] = {0};
159     int bytes = snprintf_s(buf, sizeof(buf), sizeof(buf) - 1, "[%llx,%llx,%llx]#",
160         hiTraceId.GetChainId(), hiTraceId.GetSpanId(), hiTraceId.GetParentSpanId());
161     if (EXPECTANTLY(bytes > 0)) {
162         record += buf;
163     }
164     std::transform(record.cbegin(), record.cend(), record.begin(), [](unsigned char c) { return tolower(c); });
165     return record;
166 }
167 
FindResult(string & str,const vector<string> & list)168 bool FindResult(string& str, const vector<string>& list)
169 {
170     for (int i = list.size() - 1; i >= 0; i--) {
171         std::string ele = list[i];
172         if (ele.find(str) != std::string::npos) {
173             return true;
174         }
175     }
176     return false;
177 }
178 
GetTraceResult(const char type,const string & traceName,const HiTraceId * hiTraceId,const int taskId,const vector<string> & list)179 bool GetTraceResult(const char type, const string& traceName, const HiTraceId* hiTraceId,
180                     const int taskId, const vector<string>& list)
181 {
182     if (list.empty()) {
183         return false;
184     }
185 
186     std::string prefix;
187     std::string chainStr = "";
188     std::string str;
189 
190     if (hiTraceId != nullptr) {
191         chainStr = GetRecord(*hiTraceId);
192     }
193 
194     if (type == 'B') {
195         prefix = "tracing_mark_write: B|";
196         str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr + traceName;
197     } else if (type == 'E') {
198         prefix = "tracing_mark_write: E|";
199         str = prefix + std::to_string(g_pid) + VERTICAL_LINE;
200     } else if (type == 'S') {
201         prefix = "tracing_mark_write: S|";
202         str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr
203         + traceName + " " + to_string(taskId);
204     } else if (type == 'F') {
205         prefix = "tracing_mark_write: F|";
206         str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr
207         + traceName + " " + to_string(taskId);
208     } else if (type == 'C') {
209         prefix = "tracing_mark_write: C|";
210         str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr + traceName;
211     } else {
212         return false;
213     }
214     return FindResult(str, list);
215 }
216 
WriteStrToFileInner(const string & fileName,const string & str)217 static bool WriteStrToFileInner(const string& fileName, const string& str)
218 {
219     if (g_traceRootPath == "") {
220         HILOG_ERROR(LOG_CORE, "Error: trace path not found.");
221         return false;
222     }
223     ofstream out;
224     out.open(fileName, ios::out);
225     out << str;
226     out.close();
227     return true;
228 }
229 
WriteStringToFile(const std::string & filename,const std::string & str)230 static bool WriteStringToFile(const std::string& filename, const std::string& str)
231 {
232     bool ret = false;
233     if (access((g_traceRootPath + filename).c_str(), W_OK) == 0) {
234         if (WriteStrToFileInner(g_traceRootPath + filename, str)) {
235             ret = true;
236         }
237     }
238 
239     return ret;
240 }
241 
CleanTrace()242 bool CleanTrace()
243 {
244     if (g_traceRootPath.empty()) {
245         HILOG_ERROR(LOG_CORE, "Error: trace path not found.");
246         return false;
247     }
248     ofstream ofs;
249     ofs.open(g_traceRootPath + TRACE_PATH, ofstream::out);
250     if (!ofs.is_open()) {
251         HILOG_ERROR(LOG_CORE, "Error: opening trace path failed.");
252         return false;
253     }
254     ofs << "";
255     ofs.close();
256     return true;
257 }
258 
ReadFile(const string & filename)259 static stringstream ReadFile(const string& filename)
260 {
261     stringstream ss;
262     char resolvedPath[PATH_MAX] = { 0 };
263     if (realpath(filename.c_str(), resolvedPath) == nullptr) {
264         fprintf(stderr, "Error: _fullpath %s failed", filename.c_str());
265         return ss;
266     }
267     ifstream fin(resolvedPath);
268     if (!fin.is_open()) {
269         fprintf(stderr, "opening file: %s failed!", filename.c_str());
270         return ss;
271     }
272     ss << fin.rdbuf();
273     fin.close();
274     return ss;
275 }
276 
IsFileExisting(const string & filename)277 static bool IsFileExisting(const string& filename)
278 {
279     return access(filename.c_str(), F_OK) != -1;
280 }
281 
SetFtrace(const string & filename,bool enabled)282 bool SetFtrace(const string& filename, bool enabled)
283 {
284     return WriteStringToFile(filename, enabled ? "1" : "0");
285 }
286 
CleanFtrace()287 bool CleanFtrace()
288 {
289     return WriteStringToFile("events/enable", "0");
290 }
291 
ReadFile2string(const string & filename)292 vector<string> ReadFile2string(const string& filename)
293 {
294     vector<string> list;
295     if (IsFileExisting(filename)) {
296         stringstream ss = ReadFile(filename);
297         string line;
298         while (getline(ss, line)) {
299             list.emplace_back(move(line));
300         }
301     }
302     return list;
303 }
304 
ReadTrace()305 vector<string> ReadTrace()
306 {
307     return ReadFile2string(g_traceRootPath + TRACE_PATH);
308 }
309 
RunCmd(const string & cmdstr)310 bool RunCmd(const string& cmdstr)
311 {
312     FILE *fp = popen(cmdstr.c_str(), "r");
313     if (fp == nullptr) {
314         return false;
315     }
316     pclose(fp);
317     return true;
318 }
319 
320 /**
321  * @tc.name: HiTraceNDKTest_StartTrace_001
322  * @tc.desc: tracing_mark_write file node normal output start tracing and end tracing.
323  * @tc.type: FUNC
324  */
325 HWTEST_F(HitraceNDKTest, StartTrace_001, TestSize.Level0)
326 {
327     std::string traceName = "HitraceStartTrace001";
328     ASSERT_TRUE(CleanTrace());
329     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
330     StartTrace(TAG, traceName);
331     FinishTrace(TAG);
332     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
333     vector<string> list = ReadTrace();
334     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
335     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
336     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
337     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
338 }
339 
340 /**
341  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_001
342  * @tc.desc: Testing AddHitraceMeterMarker function
343  * @tc.type: FUNC
344  */
345 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_001, TestSize.Level0)
346 {
347     std::string traceName = "AddHitraceMeterMarker001";
348     ASSERT_TRUE(CleanTrace());
349     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
350     SetReloadPid(true);
351     SetAddHitraceMeterMarker(TAG, traceName);
352     FinishTrace(TAG);
353     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
354     vector<string> list = ReadTrace();
355     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
356     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
357     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
358     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
359 
360     traceName.resize(520);
361     SetReloadPid(false);
362     SetpidHasReload(false);
363     SetAddHitraceMeterMarker(TAG, traceName);
364     SetAddTraceMarkerLarge(traceName, 1);
365     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
366     list.clear();
367     list = ReadTrace();
368     isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
369     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
370 }
371 
372 /**
373  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_002
374  * @tc.desc: Testing AddHitraceMeterMarker function
375  * @tc.type: FUNC
376  */
377 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_002, TestSize.Level0)
378 {
379     std::string traceName = "AddHitraceMeterMarker002";
380     ASSERT_TRUE(CleanTrace());
381     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
382     SetAppFd(1);
383     SetAddHitraceMeterMarker(TAG, traceName);
384     FinishTrace(TAG);
385     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
386     vector<string> list = ReadTrace();
387     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
388     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
389     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
390     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
391     SetAppFd(-1);
392 }
393 
394 /**
395  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_003
396  * @tc.desc: Testing AddHitraceMeterMarker function
397  * @tc.type: FUNC
398  */
399 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_003, TestSize.Level0)
400 {
401     std::string traceName = "AddHitraceMeterMarker003";
402     ASSERT_TRUE(CleanTrace());
403     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
404     SetWriteToTraceMarker("B|3728|H:AddHitraceMeterMarker003", 0);
405     SetWriteToTraceMarker("B|3728|H:AddHitraceMeterMarker003", 640);
406     FinishTraceDebug(false, TAG);
407 }
408 
409 /**
410  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_004
411  * @tc.desc: Testing AddHitraceMeterMarker function
412  * @tc.type: FUNC
413  */
414 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_004, TestSize.Level0)
415 {
416     string traceName = "AddHitraceMeterMarker004";
417     ASSERT_TRUE(CleanTrace());
418     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
419     int var = 1;
420     StartTraceArgs(HITRACE_TAG_ZAUDIO, traceName.c_str(), var);
421     FinishTrace(HITRACE_TAG_ZAUDIO);
422     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
423 }
424 
425 /**
426  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_005
427  * @tc.desc: Testing AddHitraceMeterMarker function
428  * @tc.type: FUNC
429  */
430 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_005, TestSize.Level0)
431 {
432     std::string traceName = "HitraceStartTrace005";
433     string fileName;
434     int fileSize = 100 * 1024 * 1024; // 100M
435 
436     ASSERT_TRUE(CleanTrace());
437     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
438 
439     SetWriteAppTrace(FLAG_MAIN_THREAD, traceName, 0, true);
440     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
441     SetWriteAppTrace(FLAG_MAIN_THREAD, "", 0, true);
442     SetWriteAppTrace(FLAG_MAIN_THREAD, traceName, 0, true);
443     SetWriteAppTrace(FLAG_MAIN_THREAD, traceName, 0, false);
444 
445     StartTrace(TAG, traceName);
446     SetWriteAppTrace(FLAG_ALL_THREAD, traceName, 0, true);
447     traceName.insert(traceName.size() - 1, "a", 32729);
448     SetWriteAppTrace(FLAG_ALL_THREAD, traceName, 0, false);
449     SetWriteAppTrace(FLAG_MAIN_THREAD, traceName, 0, true);
450 
451     FinishTrace(TAG);
452     ret = StopCaptureAppTrace();
453     ASSERT_TRUE(ret == RetType::RET_SUCC);
454     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
455 
456     vector<string> list = ReadTrace();
457     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
458     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
459     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
460     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
461 }
462 
463 /**
464  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_006
465  * @tc.desc: Testing AddHitraceMeterMarker function
466  * @tc.type: FUNC
467  */
468 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_006, TestSize.Level0)
469 {
470     std::string traceName = "HitraceStartTrace006";
471     string fileName;
472     int fileSize = 100 * 1024 * 1024; // 100M
473     ASSERT_TRUE(CleanTrace());
474     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
475 
476     SetWriteAppTrace(FLAG_ALL_THREAD, traceName, 0, true);
477 
478     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
479     ASSERT_TRUE(ret == RetType::RET_SUCC);
480     ret = StopCaptureAppTrace();
481     ASSERT_TRUE(ret == RetType::RET_SUCC);
482 }
483 
484 /**
485  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_007
486  * @tc.desc: Testing AddHitraceMeterMarker function
487  * @tc.type: FUNC
488  */
489 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_007, TestSize.Level0)
490 {
491     std::string traceName = "HitraceStartTrace007";
492 
493     StartTrace(TAG, traceName);
494     ASSERT_TRUE(CleanTrace());
495     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
496     GetSetMainThreadInfo();
497     GetSetCommStr();
498     SetTraceBuffer(32775);
499     FinishTrace(TAG);
500 
501     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
502     vector<string> list = ReadTrace();
503     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
504     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
505     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
506     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
507 }
508 
509 /**
510  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_008
511  * @tc.desc: Testing AddHitraceMeterMarker function
512  * @tc.type: FUNC
513  */
514 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_008, TestSize.Level0)
515 {
516     std::string traceName = "HitraceStartTrace008";
517 
518     ASSERT_TRUE(CleanTrace());
519     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
520 
521     SetAddHitraceMeterMarker(TAG, traceName);
522     FinishTrace(TAG);
523     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
524     vector<string> list = ReadTrace();
525     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
526     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
527     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
528     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
529 }
530 
531 /**
532  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_009
533  * @tc.desc: Testing AddHitraceMeterMarker function
534  * @tc.type: FUNC
535  */
536 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_009, TestSize.Level0)
537 {
538     std::string traceName = "HitraceStartTrace009";
539     while (traceName.length() <= BUFFER_LEN) {
540         traceName += std::to_string(arc4random() % DIVISOR);
541     }
542     ASSERT_TRUE(CleanTrace());
543     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
544 
545     SetAddHitraceMeterMarker(TAG, traceName);
546     FinishTrace(TAG);
547     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
548     vector<string> list = ReadTrace();
549     bool isStartSuc = GetTraceResult('B', traceName.substr(0, BUFFER_LEN), nullptr, 0, list);
550     ASSERT_FALSE(isStartSuc) << "Hitrace find \"B|pid|" + traceName + "\" from trace.";
551     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
552     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
553 }
554 
555 /**
556  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_010
557  * @tc.desc: Testing AddHitraceMeterMarker function
558  * @tc.type: FUNC
559  */
560 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_010, TestSize.Level0)
561 {
562     std::string traceName = "HitraceStartTrace010";
563 
564     StartTrace(TAG, traceName);
565     ASSERT_TRUE(CleanTrace());
566     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
567     GetSetMainThreadInfo();
568     GetSetCommStr();
569     SetTraceBuffer(OUTPACE_DEFAULT_CACHE_SIZE);
570     FinishTrace(TAG);
571 
572     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
573     vector<string> list = ReadTrace();
574     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
575     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
576     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
577     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
578 }
579 
580 /**
581  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_011
582  * @tc.desc: Testing AddHitraceMeterMarker function
583  * @tc.type: FUNC
584  */
585 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_011, TestSize.Level0)
586 {
587     std::string traceName = "HitraceStartTrace011";
588 
589     ASSERT_TRUE(CleanTrace());
590     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
591     bool isWriteLog = false;
592     SetWriteOnceLog(LOG_DEBUG, "write debug log", isWriteLog);
593     SetAddHitraceMeterMarker(TAG, traceName);
594     FinishTrace(TAG);
595 
596     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
597     vector<string> list = ReadTrace();
598     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
599     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
600     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
601     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
602 }
603 
604 /**
605  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_012
606  * @tc.desc: Testing AddHitraceMeterMarker function
607  * @tc.type: FUNC
608  */
609 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_012, TestSize.Level0)
610 {
611     std::string traceName = "HitraceStartTrace012";
612 
613     StartTrace(TAG, traceName);
614     ASSERT_TRUE(CleanTrace());
615     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
616     GetSetMainThreadInfo();
617     GetSetCommStr();
618     FinishTrace(TAG);
619 
620     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
621     vector<string> list = ReadTrace();
622     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
623     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
624     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
625     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
626 }
627 
628 /**
629  * @tc.name: HiTraceNDKTest_AddHitraceMeterMarker_013
630  * @tc.desc: Testing AddHitraceMeterMarker function
631  * @tc.type: FUNC
632  */
633 HWTEST_F(HitraceNDKTest, AddHitraceMeterMarker_013, TestSize.Level0)
634 {
635     std::string traceName = "HitraceStartTrace013";
636     string fileName;
637     int fileSize = 100 * 1024 * 1024; // 100M
638 
639     ASSERT_TRUE(CleanTrace());
640     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
641 
642     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
643     StartTrace(TAG, traceName);
644     SetMarkerType(FLAG_MAIN_THREAD, traceName, 0, true);
645 
646     FinishTrace(TAG);
647     ret = StopCaptureAppTrace();
648     ASSERT_TRUE(ret == RetType::RET_SUCC);
649     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
650 
651     vector<string> list = ReadTrace();
652     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
653     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
654     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
655     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
656 }
657 
658 /**
659  * @tc.name: HiTraceNDKTest_StartHiTraceIdTest_001
660  * @tc.desc: tracing_mark_write file node normal output  hitraceId.
661  * @tc.type: FUNC
662  */
663 HWTEST_F(HitraceNDKTest, StartHiTraceIdTest_001, TestSize.Level0)
664 {
665     std::string traceName = "StartHiTraceIdTest001";
666     ASSERT_TRUE(CleanTrace());
667     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
668     HiTraceId hiTraceId = HiTraceChain::Begin(traceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
669     StartTrace(TAG, traceName);
670     FinishTrace(TAG);
671     HiTraceChain::End(hiTraceId);
672     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
673     vector<string> list = ReadTrace();
674     bool isStartSuc = GetTraceResult('B', traceName, &hiTraceId, 0, list);
675     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
676     bool isFinishSuc = GetTraceResult('E', traceName, &hiTraceId, 0, list);
677     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
678 }
679 
680 /**
681  * @tc.name: HiTraceNDKTest_StartHiTraceIdTest_002
682  * @tc.desc: tracing_mark_write file node large output  hitraceId.
683  * @tc.type: FUNC
684  */
685 HWTEST_F(HitraceNDKTest, StartHiTraceIdTest_002, TestSize.Level0)
686 {
687     std::string longTraceName = "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
688     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
689     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
690     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
691     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
692     longTraceName += "StartHiTraceIdTest002";
693     ASSERT_TRUE(CleanTrace());
694     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
695     HiTraceId hiTraceId = HiTraceChain::Begin(longTraceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
696     StartTrace(TAG, longTraceName, SLEEP_ONE_SECOND);
697     FinishTrace(TAG);
698     HiTraceChain::End(hiTraceId);
699     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
700     vector<string> list = ReadTrace();
701     bool isStartSuc = GetTraceResult('B', longTraceName, &hiTraceId, 0, list);
702     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + longTraceName + "\" from trace.";
703 
704     bool isFinishSuc = GetTraceResult('E', longTraceName, &hiTraceId, 0, list);
705     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
706 }
707 
708 /**
709  * @tc.name: HiTraceNDKTest_StartAsyncHiTraceIdTest_001
710  * @tc.desc: tracing_mark_write file node normal output start trace and end trace
711  * @tc.type: FUNC
712  */
713 HWTEST_F(HitraceNDKTest, StartAsyncHiTraceIdTest_001, TestSize.Level0)
714 {
715     string traceName = "StartAsyncHiTraceIdTest001";
716     int taskId = 123;
717     ASSERT_TRUE(CleanTrace());
718     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
719     HiTraceId hiTraceId = HiTraceChain::Begin(traceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
720     StartAsyncTrace(TAG, traceName, taskId);
721     FinishAsyncTrace(TAG, traceName, taskId);
722     HiTraceChain::End(hiTraceId);
723     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
724     vector<string> list = ReadTrace();
725     bool isStartSuc = GetTraceResult('S', traceName, &hiTraceId, taskId, list);
726     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
727     bool isFinishSuc = GetTraceResult('F', traceName, &hiTraceId, taskId, list);
728     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
729 }
730 
731 /**
732  * @tc.name: HiTraceNDKTest_StartTrace_002
733  * @tc.desc: tracing_mark_write file node has no output.
734  * @tc.type: FUNC
735  */
736 HWTEST_F(HitraceNDKTest, StartTrace_002, TestSize.Level0)
737 {
738     std::string longTraceName = "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
739     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
740     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
741     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
742     longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
743     longTraceName += "StartHiTraceIdTest002";
744     ASSERT_TRUE(CleanTrace());
745     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
746     StartTrace(TAG, longTraceName);
747     FinishTrace(TAG);
748     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
749     vector<string> list = ReadTrace();
750     bool isStartSuc = GetTraceResult('B', longTraceName, nullptr, 0, list);
751     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + longTraceName + "\" from trace.";
752     bool isFinishSuc = GetTraceResult('E', longTraceName, nullptr, 0, list);
753     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
754 }
755 
756 /**
757   * @tc.name: HiTraceNDKTest_StartTrace_003
758   * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
759   * @tc.type: FUNC
760   */
761 HWTEST_F(HitraceNDKTest, StartTrace_003, TestSize.Level0)
762 {
763     string traceName = "StartTraceTest003 %s";
764     ASSERT_TRUE(CleanTrace());
765     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
766     StartTrace(TAG, traceName);
767     FinishTrace(TAG);
768     vector<string> list = ReadTrace();
769     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
770     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
771     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
772     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
773 
774     ASSERT_TRUE(CleanTrace());
775     list.clear();
776     traceName = "StartTraceTest003 %p";
777     StartTrace(TAG, traceName);
778     FinishTrace(TAG);
779     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
780     list = ReadTrace();
781     isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
782     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
783     isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
784     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
785 }
786 
787 /**
788  * @tc.name: HiTraceNDKTest_StartTrace_004
789  * @tc.desc: test Input and output interval 1ms execution, time fluctuation 1ms
790  * @tc.type: FUNC
791  */
792 HWTEST_F(HitraceNDKTest, StartTrace_004, TestSize.Level0)
793 {
794     string traceName = "StartTraceTest004";
795     ASSERT_TRUE(CleanTrace());
796     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
797     StartTrace(TAG, traceName);
798     usleep(1000);
799     FinishTrace(TAG);
800     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
801     vector<string> list = ReadTrace();
802     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
803     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
804     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
805     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
806 }
807 
808 /**
809  * @tc.name: HiTraceNDKTest_StartTrace_005
810  * @tc.desc: tracing_mark_write file node normal output start trace and end trace
811  * @tc.type: FUNC
812  */
813 HWTEST_F(HitraceNDKTest, StartTrace_005, TestSize.Level0)
814 {
815     string traceName = "asyncTraceTest005";
816     int taskId = 123;
817     ASSERT_TRUE(CleanTrace());
818     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
819     StartAsyncTrace(TAG, traceName, taskId);
820     FinishAsyncTrace(TAG, traceName, taskId);
821     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
822     vector<string> list = ReadTrace();
823     bool isStartSuc = GetTraceResult('S', traceName, nullptr, taskId, list);
824     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
825     bool isFinishSuc = GetTraceResult('F', traceName, nullptr, taskId, list);
826     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
827 }
828 
829 /**
830  * @tc.name: HiTraceNDKTest_StartTrace_006
831  * @tc.desc: tracing_mark_write file node normal output start trace and end trace
832  * @tc.type: FUNC
833  */
834 HWTEST_F(HitraceNDKTest, StartTrace_006, TestSize.Level0)
835 {
836     string traceName = "countTraceTest006";
837     int count = 1;
838     ASSERT_TRUE(CleanTrace());
839     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
840     CountTrace(TAG, traceName, count);
841     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
842     vector<string> list = ReadTrace();
843     bool isCountSuc = GetTraceResult('C', traceName, nullptr, count, list);
844     ASSERT_TRUE(isCountSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
845 }
846 
847 /**
848  * @tc.name: HiTraceNDKTest_StartTrace_007
849  * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
850  * @tc.type: FUNC
851  */
852 HWTEST_F(HitraceNDKTest, StartTrace_007, TestSize.Level1)
853 {
854     string traceName = "StartTraceTest007";
855     ASSERT_TRUE(CleanTrace());
856     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
857     StartTrace(TRACE_INVALIDATE_TAG, traceName);
858     FinishTrace(TRACE_INVALIDATE_TAG);
859     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
860     vector<string> list = ReadTrace();
861     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
862     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
863     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
864     EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
865 }
866 
867 /**
868  * @tc.name: HiTraceNDKTest_StartTrace_008
869  * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
870  * @tc.type: FUNC
871  */
872 HWTEST_F(HitraceNDKTest, StartTrace_008, TestSize.Level1)
873 {
874     string traceName = "StartTraceTest008 %s";
875     ASSERT_TRUE(CleanTrace());
876     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
877     StartTrace(TRACE_INVALIDATE_TAG, traceName);
878     FinishTrace(TRACE_INVALIDATE_TAG);
879     vector<string> list = ReadTrace();
880     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
881     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
882     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
883     EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
884 
885     ASSERT_TRUE(CleanTrace());
886     list.clear();
887     traceName = "StartTraceTest008 %p";
888     StartTrace(TRACE_INVALIDATE_TAG, traceName);
889     FinishTrace(TRACE_INVALIDATE_TAG);
890     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
891     list = ReadTrace();
892     isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
893     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
894     isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
895     EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
896 }
897 
898 /**
899  * @tc.name: HiTraceNDKTest_StartTrace_009
900  * @tc.desc: tracing_mark_write file node normal output start trace and end trace
901  * @tc.type: FUNC
902  */
903 HWTEST_F(HitraceNDKTest, StartTrace_009, TestSize.Level1)
904 {
905     string traceName = "asyncTraceTest009";
906     int taskId = 123;
907     ASSERT_TRUE(CleanTrace());
908     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
909     StartAsyncTrace(TRACE_INVALIDATE_TAG, traceName, taskId);
910     FinishAsyncTrace(TRACE_INVALIDATE_TAG, traceName, taskId);
911     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
912     vector<string> list = ReadTrace();
913     bool isStartSuc = GetTraceResult('S', traceName, nullptr, taskId, list);
914     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
915     bool isFinishSuc = GetTraceResult('F', traceName, nullptr, taskId, list);
916     EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
917 }
918 
919 /**
920  * @tc.name: HiTraceNDKTest_StartTrace_010
921  * @tc.desc: tracing_mark_write file node normal output start trace and end trace
922  * @tc.type: FUNC
923  */
924 HWTEST_F(HitraceNDKTest, StartTrace_010, TestSize.Level1)
925 {
926     string traceName = "countTraceTest010";
927     int count = 1;
928     ASSERT_TRUE(CleanTrace());
929     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
930     CountTrace(TRACE_INVALIDATE_TAG, traceName, count);
931     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
932     vector<string> list = ReadTrace();
933     bool isStartSuc = GetTraceResult('C', traceName, nullptr, count, list);
934     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
935 }
936 
937 /**
938  * @tc.name: HiTraceNDKTest_StartTrace_011
939  * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
940  * @tc.type: FUNC
941  */
942 HWTEST_F(HitraceNDKTest, StartTrace_011, TestSize.Level1)
943 {
944     ASSERT_TRUE(CleanTrace());
945     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
946     StartTraceDebug(true, TAG, "StartTraceTest011");
947     FinishTraceDebug(true, TAG);
948 }
949 
950 /**
951   * @tc.name: HiTraceNDKTest_StartTrace_012
952   * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
953   * @tc.type: FUNC
954   */
955 HWTEST_F(HitraceNDKTest, StartTrace_012, TestSize.Level1)
956 {
957     ASSERT_TRUE(CleanTrace());
958     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
959     StartTraceDebug(true, TAG, "StartTraceTest012 %s");
960     FinishTraceDebug(true, TAG);
961 }
962 
963 /**
964  * @tc.name: HiTraceNDKTest_StartTrace_013
965  * @tc.desc: Testing StartAsyncTraceDebug and FinishAsyncTraceDebug functions
966  * @tc.type: FUNC
967  */
968 HWTEST_F(HitraceNDKTest, StartTrace_013, TestSize.Level1)
969 {
970     ASSERT_TRUE(CleanTrace());
971     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
972     StartAsyncTraceDebug(true, TAG, "asyncTraceTest013", 123);
973     FinishAsyncTraceDebug(true, TAG, "asyncTraceTest013", 123);
974     StartAsyncTraceDebug(false, TAG, "asyncTraceTest013", 123);
975     FinishAsyncTraceDebug(false, TAG, "asyncTraceTest013", 123);
976 }
977 
978 /**
979  * @tc.name: HiTraceNDKTest_StartTrace_014
980  * @tc.desc: Testing CountTraceDebug function
981  * @tc.type: FUNC
982  */
983 HWTEST_F(HitraceNDKTest, StartTrace_014, TestSize.Level1)
984 {
985     ASSERT_TRUE(CleanTrace());
986     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
987     CountTraceDebug(true, TAG, "countTraceTest014", 1);
988     CountTraceDebug(false, TAG, "countTraceTest014", 1);
989 }
990 
991 /**
992  * @tc.name: HiTraceNDKTest_StartTrace_015
993  * @tc.desc: Testing MiddleTrace function
994  * @tc.type: FUNC
995  */
996 HWTEST_F(HitraceNDKTest, StartTrace_015, TestSize.Level1)
997 {
998     ASSERT_TRUE(CleanTrace());
999     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1000     MiddleTrace(TAG, "MiddleTraceTest015", "050tseTecarTelddiM");
1001 }
1002 
1003 /**
1004  * @tc.name: HiTraceNDKTest_StartTrace_016
1005  * @tc.desc: Testing MiddleTraceDebug function
1006  * @tc.type: FUNC
1007  */
1008 HWTEST_F(HitraceNDKTest, StartTrace_016, TestSize.Level1)
1009 {
1010     ASSERT_TRUE(CleanTrace());
1011     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1012     MiddleTraceDebug(true, TAG, "MiddleTraceTest016", "061tseTecarTelddiM");
1013     MiddleTraceDebug(false, TAG, "MiddleTraceTest016", "061tseTecarTelddiM");
1014 }
1015 
1016 /**
1017  * @tc.name: HiTraceNDKTest_StartTrace_017
1018  * @tc.desc: tracing_mark_write file node normal output start tracing and end tracing with args
1019  * @tc.type: FUNC
1020  */
1021 HWTEST_F(HitraceNDKTest, StartTrace_017, TestSize.Level1)
1022 {
1023     string traceName = "StartTraceTest017-%d";
1024     ASSERT_TRUE(CleanTrace());
1025     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1026     int var = 1;
1027     StartTraceArgs(TAG, traceName.c_str(), var);
1028     FinishTrace(TAG);
1029     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1030     vector<string> list = ReadTrace();
1031 
1032     bool isStartSuc = GetTraceResult('B', traceName.replace(18, 2, to_string(var)), nullptr, 0, list);
1033     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
1034     bool isFinishSuc = GetTraceResult('E', traceName.replace(18, 2, to_string(var)), nullptr, 0, list);
1035     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
1036 }
1037 
1038 /**
1039  * @tc.name: HiTraceNDKTest_StartTrace_018
1040  * @tc.desc: tracing_mark_write file node normal output start trace and end trace async with args
1041  * @tc.type: FUNC
1042  */
1043 HWTEST_F(HitraceNDKTest, StartTrace_018, TestSize.Level1)
1044 {
1045     string traceName = "asyncTraceTest018-%d";
1046     int taskId = 123;
1047     ASSERT_TRUE(CleanTrace());
1048     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1049     int var = 1;
1050     StartAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
1051     FinishAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
1052     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1053     vector<string> list = ReadTrace();
1054     bool isStartSuc = GetTraceResult('S', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
1055     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
1056     bool isFinishSuc = GetTraceResult('F', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
1057     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|" + traceName + "\" from trace.";
1058 }
1059 
1060 /**
1061  * @tc.name: HiTraceNDKTest_StartTrace_019
1062  * @tc.desc: Testing StartTraceArgsDebug function
1063  * @tc.type: FUNC
1064  */
1065 HWTEST_F(HitraceNDKTest, StartTrace_019, TestSize.Level1)
1066 {
1067     ASSERT_TRUE(CleanTrace());
1068     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1069     int var = 1;
1070     StartTraceArgsDebug(true, TAG, "StartTraceTest019-%d", var);
1071     FinishTrace(TAG);
1072     StartTraceArgsDebug(false, TAG, "StartTraceTest019-%d", var);
1073 }
1074 
1075 /**
1076  * @tc.name: HiTraceNDKTest_StartTrace_020
1077  * @tc.desc: Testing StartAsyncTraceArgsDebug and FinishAsyncTraceArgsDebug function
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(HitraceNDKTest, StartTrace_020, TestSize.Level1)
1081 {
1082     ASSERT_TRUE(CleanTrace());
1083     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1084     int var = 1;
1085     StartAsyncTraceArgsDebug(true, TAG, 123, "asyncTraceTest020-%d", var);
1086     FinishAsyncTraceArgsDebug(true, TAG, 123, "asyncTraceTest020-%d", var);
1087 
1088     SetTraceDisabled(true);
1089     StartAsyncTraceArgsDebug(false, TAG, 123, "asyncTraceTest020-%d", var);
1090     FinishAsyncTraceArgsDebug(false, TAG, 123, "asyncTraceTest020-%d", var);
1091     SetTraceDisabled(false);
1092 }
1093 
1094 /**
1095  * @tc.name: HiTraceNDKTest_StartTraceWrapper_001
1096  * @tc.desc: Testing StartTraceWrapper function
1097  * @tc.type: FUNC
1098  */
1099 HWTEST_F(HitraceNDKTest, StartTraceWrapper_001, TestSize.Level0)
1100 {
1101     string traceName = "StartTraceWrapper001";
1102     ASSERT_TRUE(CleanTrace());
1103     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1104     StartTraceWrapper(TAG, traceName.c_str());
1105     FinishTrace(TAG);
1106     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1107     vector<string> list = ReadTrace();
1108     bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
1109     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
1110     bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
1111     ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
1112 }
1113 
1114 /**
1115  * @tc.name: HiTraceNDKTest_StartAsyncTraceWrapper
1116  * @tc.desc: Testing  StartAsyncTraceWrapper function
1117  * @tc.type: FUNC
1118  */
1119 HWTEST_F(HitraceNDKTest, StartAsyncTraceWrapper_001, TestSize.Level1)
1120 {
1121     string traceName = "StartAsyncTraceWrapper009";
1122     int taskId = 123;
1123     ASSERT_TRUE(CleanTrace());
1124     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1125     StartAsyncTraceWrapper(TRACE_INVALIDATE_TAG, traceName.c_str(), taskId);
1126     FinishAsyncTraceWrapper(TRACE_INVALIDATE_TAG, traceName.c_str(), taskId);
1127     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1128     vector<string> list = ReadTrace();
1129     bool isStartSuc = GetTraceResult('S', traceName, nullptr, 0, list);
1130     EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
1131     bool isFinishSuc = GetTraceResult('F', traceName, nullptr, 0, list);
1132     EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"F|pid|" + traceName + "\" from trace.";
1133 }
1134 
1135 /**
1136  * @tc.name: HiTraceNDKTest_CountTraceWrapper_001
1137  * @tc.desc: Testing CountTraceWrapper function
1138  * @tc.type: FUNC
1139  */
1140 HWTEST_F(HitraceNDKTest, CountTraceWrapper_001, TestSize.Level0)
1141 {
1142     string traceName = "CountTraceWrapper001";
1143     int count = 1;
1144     ASSERT_TRUE(CleanTrace());
1145     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1146     CountTraceWrapper(TAG, traceName.c_str(), count);
1147     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1148     vector<string> list = ReadTrace();
1149     bool isStartSuc = GetTraceResult('C', traceName, nullptr, count, list);
1150     ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
1151 }
1152 
1153 /**
1154  * @tc.name: HiTraceNDKTest_StartTrace_021
1155  * @tc.desc: Testing SetTraceDisabled function
1156  * @tc.type: FUNC
1157  */
1158 HWTEST_F(HitraceNDKTest, StartTrace_021, TestSize.Level1)
1159 {
1160     ASSERT_TRUE(CleanTrace());
1161     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1162     SetTraceDisabled(true);
1163 }
1164 
1165 /**
1166  * @tc.name: HiTraceNDKTest_StartTrace_022
1167  * @tc.desc: Testing SetTraceDisabled function
1168  * @tc.type: FUNC
1169  */
1170 HWTEST_F(HitraceNDKTest, StartTrace_022, TestSize.Level1)
1171 {
1172     ASSERT_TRUE(CleanTrace());
1173     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
1174     ASSERT_TRUE(SetProperty(TRACE_PROPERTY, "0"));
1175     SetCachedHandleAndAppPidCachedHandle(nullptr, nullptr);
1176     SetCachedHandleAndAppPidCachedHandle(nullptr, (CachedHandle)0xf7696e60);
1177     SetCachedHandleAndAppPidCachedHandle((CachedHandle)0xf7c8c130, nullptr);
1178 }
1179 
1180 /**
1181  * @tc.name: HiTraceNDKTest_StartTrace_023
1182  * @tc.desc: Testing IsAppValid function
1183  * @tc.type: FUNC
1184  */
1185 HWTEST_F(HitraceNDKTest, StartTrace_023, TestSize.Level1)
1186 {
1187     ASSERT_TRUE(CleanTrace());
1188     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1189     SetProperty(KEY_RO_DEBUGGABLE, "true");
1190     SetProperty(KEY_APP_NUMBER, "1");
1191     StartTrace(TRACE_INVALIDATE_TAG, "StartTraceTest023");
1192     FinishTrace(TRACE_INVALIDATE_TAG);
1193 }
1194 
1195 /**
1196  * @tc.name: HiTraceNDKTest_StartTrace_024
1197  * @tc.desc: Testing trace cmd function
1198  * @tc.type: FUNC
1199  */
1200 HWTEST_F(HitraceNDKTest, StartTrace_024, TestSize.Level1)
1201 {
1202     ASSERT_TRUE(CleanTrace());
1203     ASSERT_TRUE(RunCmd("hitrace -h > /data/local/tmp/test1.txt"));
1204     ASSERT_TRUE(RunCmd("hitrace -l > /data/local/tmp/test2.txt"));
1205     ASSERT_TRUE(RunCmd("hitrace --list_categories > /data/local/tmp/test3.txt"));
1206     ASSERT_TRUE(RunCmd("hitrace --trace_begin > /data/local/tmp/test4.txt"));
1207     ASSERT_TRUE(RunCmd("hitrace --trace_dump > /data/local/tmp/test5.txt"));
1208     ASSERT_TRUE(RunCmd("hitrace --trace_finish > /data/local/tmp/test6.txt"));
1209     ASSERT_TRUE(RunCmd("hitrace --hlep > /data/local/tmp/test7.txt"));
1210     ASSERT_TRUE(RunCmd("hitrace -a > /data/local/tmp/test8.txt"));
1211     ASSERT_TRUE(RunCmd("hitrace --trace_clock > /data/local/tmp/test9.txt"));
1212     ASSERT_TRUE(RunCmd("hitrace -t a > /data/local/tmp/test10.txt"));
1213     ASSERT_TRUE(RunCmd("hitrace -t -1 > /data/local/tmp/test11.txt"));
1214     ASSERT_TRUE(RunCmd("hitrace --time a > /data/local/tmp/test12.txt"));
1215     ASSERT_TRUE(RunCmd("hitrace --time -1 > /data/local/tmp/test13.txt"));
1216     ASSERT_TRUE(RunCmd("hitrace -b a > /data/local/tmp/test14.txt"));
1217     ASSERT_TRUE(RunCmd("hitrace -b -1 > /data/local/tmp/test15.txt"));
1218     ASSERT_TRUE(RunCmd("hitrace --buffer_size a > /data/local/tmp/test16.txt"));
1219     ASSERT_TRUE(RunCmd("hitrace --buffer_size -1 > /data/local/tmp/test17.txt"));
1220     ASSERT_TRUE(RunCmd("hitrace -z --time 1 --buffer_size 10240 --trace_clock clock ohos > /data/local/tmp/trace01"));
1221     ASSERT_TRUE(RunCmd("hitrace -z -t 1 -b 10240 --trace_clock clock --overwrite ohos > /data/local/tmp/trace02"));
1222     ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock boot ohos > /data/local/tmp/trace03"));
1223     ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock global ohos > /data/local/tmp/trace04"));
1224     ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock mono ohos > /data/local/tmp/trace05"));
1225     ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock uptime ohos > /data/local/tmp/trace06"));
1226     ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock perf ohos > /data/local/tmp/trace07"));
1227     ASSERT_TRUE(RunCmd("hitrace -b 2048 -t 10 -o /data/local/tmp/test20.txt sched"));
1228     ASSERT_TRUE(RunCmd("hitrace -b 2048 -t 10 -o /data/local/tmp/test21 load"));
1229     ASSERT_TRUE(RunCmd("hitrace --trace_begin --record app > /data/local/tmp/test22.txt"));
1230     ASSERT_TRUE(RunCmd("hitrace --trace_finish --record > /data/local/tmp/test23.txt"));
1231     ASSERT_TRUE(RunCmd("hitrace --trace_begin --record app --file_size 10240 > /data/local/tmp/test24.txt"));
1232     ASSERT_TRUE(RunCmd("hitrace --trace_begin --record app --file_size 102400 > /data/local/tmp/test25.txt"));
1233     ASSERT_TRUE(RunCmd("hitrace --trace_finish --record > /data/local/tmp/test26.txt"));
1234     ASSERT_TRUE(RunCmd("hitrace --start_bgsrv > /data/local/tmp/test27.txt"));
1235     ASSERT_TRUE(RunCmd("hitrace --dump_bgsrv > /data/local/tmp/test28.txt"));
1236     ASSERT_TRUE(RunCmd("hitrace --stop_bgsrv > /data/local/tmp/test29.txt"));
1237     ASSERT_TRUE(RunCmd("hitrace -t 3 -b 10240 --text app --output /data/local/tmp/trace.txt"));
1238     ASSERT_TRUE(RunCmd("hitrace -t 3 -b 10240 --raw app > /data/local/tmp/test30.txt"));
1239     ASSERT_TRUE(RunCmd("hitrace -t 3 -b 10240 --raw app --file_size 102400 > /data/local/tmp/test31.txt"));
1240     ASSERT_TRUE(RunCmd("hitrace --trace_finish_nodump > /data/local/tmp/test3.txt"));
1241 }
1242 
1243 /**
1244  * @tc.name: HiTraceNDKTest_StartTrace_025
1245  * @tc.desc: Testing bytrace cmd function
1246  * @tc.type: FUNC
1247  */
1248 HWTEST_F(HitraceNDKTest, StartTrace_025, TestSize.Level1)
1249 {
1250     ASSERT_TRUE(CleanTrace());
1251     ASSERT_TRUE(RunCmd("bytrace -h > /data/local/tmp/test1.txt"));
1252     ASSERT_TRUE(RunCmd("bytrace -l > /data/local/tmp/test2.txt"));
1253     ASSERT_TRUE(RunCmd("bytrace --list_categories > /data/local/tmp/test3.txt"));
1254     ASSERT_TRUE(RunCmd("bytrace --trace_begin > /data/local/tmp/test4.txt"));
1255     ASSERT_TRUE(RunCmd("bytrace --trace_dump > /data/local/tmp/test5.txt"));
1256     ASSERT_TRUE(RunCmd("bytrace --trace_finish > /data/local/tmp/test6.txt"));
1257     ASSERT_TRUE(RunCmd("bytrace --hlep > /data/local/tmp/test7.txt"));
1258     ASSERT_TRUE(RunCmd("bytrace -a > /data/local/tmp/test8.txt"));
1259     ASSERT_TRUE(RunCmd("bytrace --trace_clock > /data/local/tmp/test9.txt"));
1260     ASSERT_TRUE(RunCmd("bytrace -t a > /data/local/tmp/test10.txt"));
1261     ASSERT_TRUE(RunCmd("bytrace -t -1 > /data/local/tmp/test11.txt"));
1262     ASSERT_TRUE(RunCmd("bytrace --time a > /data/local/tmp/test12.txt"));
1263     ASSERT_TRUE(RunCmd("bytrace --time -1 > /data/local/tmp/test13.txt"));
1264     ASSERT_TRUE(RunCmd("bytrace -b a > /data/local/tmp/test14.txt"));
1265     ASSERT_TRUE(RunCmd("bytrace -b -1 > /data/local/tmp/test15.txt"));
1266     ASSERT_TRUE(RunCmd("bytrace --buffer_size a > /data/local/tmp/test16.txt"));
1267     ASSERT_TRUE(RunCmd("bytrace --buffer_size -1 > /data/local/tmp/test17.txt"));
1268     ASSERT_TRUE(RunCmd("bytrace -z --time 1 --buffer_size 10240 --trace_clock clock ohos > /data/local/tmp/trace01"));
1269     ASSERT_TRUE(RunCmd("bytrace -z -t 1 -b 10240 --trace_clock clock --overwrite ohos > /data/local/tmp/trace02"));
1270     ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock boot ohos > /data/local/tmp/trace03"));
1271     ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock global ohos > /data/local/tmp/trace04"));
1272     ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock mono ohos > /data/local/tmp/trace05"));
1273     ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock uptime ohos > /data/local/tmp/trace06"));
1274     ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock perf ohos > /data/local/tmp/trace07"));
1275     ASSERT_TRUE(RunCmd("bytrace -b 2048 -t 10 -o /data/local/tmp/test20.txt sched"));
1276     ASSERT_TRUE(RunCmd("bytrace -b 2048 -t 10 -o /data/local/tmp/test21 load"));
1277     ASSERT_TRUE(RunCmd("bytrace --trace_begin --record app > /data/local/tmp/test22.txt"));
1278     ASSERT_TRUE(RunCmd("bytrace --trace_finish --record > /data/local/tmp/test23.txt"));
1279     ASSERT_TRUE(RunCmd("bytrace --trace_begin --record app --file_size 10240 > /data/local/tmp/test24.txt"));
1280     ASSERT_TRUE(RunCmd("bytrace --trace_begin --record app --file_size 102400 > /data/local/tmp/test25.txt"));
1281     ASSERT_TRUE(RunCmd("bytrace --trace_finish --record > /data/local/tmp/test26.txt"));
1282     ASSERT_TRUE(RunCmd("bytrace --start_bgsrv > /data/local/tmp/test27.txt"));
1283     ASSERT_TRUE(RunCmd("bytrace --dump_bgsrv > /data/local/tmp/test28.txt"));
1284     ASSERT_TRUE(RunCmd("bytrace --stop_bgsrv > /data/local/tmp/test29.txt"));
1285     ASSERT_TRUE(RunCmd("bytrace -t 3 -b 10240 --text app --output /data/local/tmp/trace.txt"));
1286     ASSERT_TRUE(RunCmd("bytrace -t 3 -b 10240 --raw app > /data/local/tmp/test30.txt"));
1287     ASSERT_TRUE(RunCmd("bytrace -t 3 -b 10240 --raw app --file_size 102400 > /data/local/tmp/test31.txt"));
1288     ASSERT_TRUE(RunCmd("bytrace --trace_finish_nodump > /data/local/tmp/test3.txt"));
1289 }
1290 
1291 /**
1292  * @tc.name: HiTraceNDKTest_StartTrace_026
1293  * @tc.desc: Testing IsTagEnabled
1294  * @tc.type: FUNC
1295  */
1296 HWTEST_F(HitraceNDKTest, StartTrace_026, TestSize.Level1)
1297 {
1298     const std::string keyTraceTag = "debug.hitrace.tags.enableflags";
1299     ASSERT_TRUE(SetProperty(keyTraceTag, std::to_string(HITRACE_TAG_USB | HITRACE_TAG_HDF)));
1300     ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_USB));
1301     ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_HDF));
1302     ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_ZAUDIO));
1303     ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_GLOBAL_RESMGR));
1304     ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_POWER));
1305 }
1306 
1307 /**
1308  * @tc.name: HiTraceNDKTest_StartTrace_027
1309  * @tc.desc: Testing IsTagEnabled with multiple tags
1310  * @tc.type: FUNC
1311  */
1312 HWTEST_F(HitraceNDKTest, StartTrace_027, TestSize.Level1)
1313 {
1314     const std::string keyTraceTag = "debug.hitrace.tags.enableflags";
1315     ASSERT_TRUE(SetProperty(keyTraceTag, std::to_string(HITRACE_TAG_ZIMAGE | HITRACE_TAG_HDF | HITRACE_TAG_ZAUDIO)));
1316     ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_USB));
1317     ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_HDF));
1318     ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ZAUDIO | HITRACE_TAG_HDF));
1319     ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ZAUDIO | HITRACE_TAG_HDF | HITRACE_TAG_ZIMAGE));
1320     ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_POWER));
1321 }
1322 
1323 /**
1324  * @tc.name: HiTraceNDKTest_StartTrace_028
1325  * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
1326  * @tc.type: FUNC
1327  */
1328 HWTEST_F(HitraceNDKTest, StartTrace_028, TestSize.Level1)
1329 {
1330     ASSERT_TRUE(CleanTrace());
1331     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1332     StartTraceDebug(false, TAG, "StartTraceTest028");
1333     FinishTraceDebug(true, TAG);
1334 }
1335 
1336 /**
1337  * @tc.name: HiTraceNDKTest_StartTrace_029
1338  * @tc.desc: tracing_mark_write file node normal output start trace and end trace async with args
1339  * @tc.type: FUNC
1340  */
1341 HWTEST_F(HitraceNDKTest, StartTrace_029, TestSize.Level1)
1342 {
1343     string traceName = "asyncTraceTest029-%d";
1344     int taskId = 123;
1345     ASSERT_TRUE(CleanTrace());
1346     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1347     int var = 1;
1348     StartAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
1349     FinishAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
1350     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
1351     vector<string> list = ReadTrace();
1352     bool isStartSuc = GetTraceResult('S', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
1353     ASSERT_FALSE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
1354     bool isFinishSuc = GetTraceResult('F', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
1355     ASSERT_FALSE(isFinishSuc) << "Hitrace Can't find \"F|pid|" + traceName + "\" from trace.";
1356 }
1357 
1358 /**
1359  * @tc.name: HiTraceNDKTest_StartCaptureAppTrace_001
1360  * @tc.desc: Testing IsTagEnabled with multiple tags
1361  * @tc.type: FUNC
1362  */
1363 HWTEST_F(HitraceNDKTest, StartCaptureAppTrace_001, TestSize.Level1)
1364 {
1365     std::string traceName = "StartCaptureAppTrace001";
1366     string fileName;
1367     int fileSize = 100 * 1024 * 1024; // 100M
1368     ASSERT_TRUE(CleanTrace());
1369     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
1370 
1371     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
1372     ASSERT_TRUE(ret == RetType::RET_SUCC);
1373     ret = StopCaptureAppTrace();
1374     ASSERT_TRUE(ret == RetType::RET_SUCC);
1375 
1376     // exception scence
1377     ret = StartCaptureAppTrace((TraceFlag)3, TAG, fileSize, fileName);
1378     ASSERT_TRUE(ret != RetType::RET_SUCC);
1379     ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TRACE_INVALIDATE_TAG, fileSize, fileName);
1380     ASSERT_TRUE(ret != RetType::RET_SUCC);
1381     ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, 0, fileName);
1382     ASSERT_TRUE(ret != RetType::RET_SUCC);
1383 
1384     ret = StopCaptureAppTrace();
1385     ASSERT_TRUE(ret != RetType::RET_SUCC);
1386     ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
1387 }
1388 
1389 /**
1390  * @tc.name: HiTraceNDKTest_StartCaptureAppTrace_002
1391  * @tc.desc: Testing IsTagEnabled with multiple tags
1392  * @tc.type: FUNC
1393  */
1394 HWTEST_F(HitraceNDKTest, StartCaptureAppTrace_002, TestSize.Level1)
1395 {
1396     string fileName;
1397     int fileSize = 100 * 1024 * 1024; // 100M
1398     ASSERT_TRUE(CleanTrace());
1399     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
1400 
1401     SetAppFd(1);
1402     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
1403     ASSERT_FALSE(ret == RetType::RET_SUCC);
1404     SetAppFd(-2);
1405     ret = StopCaptureAppTrace();
1406     SetAppFd(-1);
1407     ASSERT_FALSE(ret == RetType::RET_SUCC);
1408 
1409     ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, 1, fileSize, fileName);
1410     ASSERT_FALSE(ret == RetType::RET_SUCC);
1411     ret = StopCaptureAppTrace();
1412     ASSERT_FALSE(ret == RetType::RET_SUCC);
1413 }
1414 
1415 /**
1416  * @tc.name: HiTraceNDKTest_StartCaptureAppTrace_003
1417  * @tc.desc: Testing IsTagEnabled with multiple tags
1418  * @tc.type: FUNC
1419  */
1420 HWTEST_F(HitraceNDKTest, StartCaptureAppTrace_003, TestSize.Level1)
1421 {
1422     const char* filePath = "";
1423     ASSERT_TRUE(CleanTrace());
1424     SetGetProcData(filePath);
1425 }
1426 
1427 /**
1428  * @tc.name: StartCaptureAppTrace_004
1429  * @tc.desc: Testing IsTagEnabled with multiple tags
1430  * @tc.type: FUNC
1431  */
1432 HWTEST_F(HitraceNDKTest, StartCaptureAppTrace_004, TestSize.Level1)
1433 {
1434     string fileName;
1435     int fileSize = 100 * 1024 * 1024; // 100M
1436     ASSERT_TRUE(CleanTrace());
1437     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
1438 
1439     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
1440     SetappTracePrefix("");
1441     GetSetCommStr();
1442     ASSERT_TRUE(ret == RetType::RET_SUCC);
1443 
1444     ret = StopCaptureAppTrace();
1445     ASSERT_TRUE(ret == RetType::RET_SUCC);
1446 }
1447 
1448 /**
1449  * @tc.name: HiTraceNDKTest_StartCaptureAppTrace_005
1450  * @tc.desc: Testing IsTagEnabled with multiple tags
1451  * @tc.type: FUNC
1452  */
1453 HWTEST_F(HitraceNDKTest, StartCaptureAppTrace_005, TestSize.Level1)
1454 {
1455     string fileName;
1456     int fileSize = 100 * 1024 * 1024; // 100M
1457     ASSERT_TRUE(CleanTrace());
1458     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
1459 
1460     SetAppFd(1);
1461     int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, fileName);
1462     ASSERT_FALSE(ret == RetType::RET_SUCC);
1463     SetAppFd(-2);
1464     SetWriteAppTraceLong(OUTPACE_DEFAULT_CACHE_SIZE, fileName, 0);
1465     ret = StopCaptureAppTrace();
1466     SetAppFd(-1);
1467     ASSERT_FALSE(ret == RetType::RET_SUCC);
1468 }
1469 
1470 /**
1471  * @tc.name: HiTraceNDKTest_HitraceMeterFmtScoped_001
1472  * @tc.desc: Testing IsTagEnabled with multiple tags
1473  * @tc.type: FUNC
1474  */
1475 HWTEST_F(HitraceNDKTest, HitraceMeterFmtScoped_001, TestSize.Level1)
1476 {
1477     string traceName = "HitraceMeterFmtScoped001";
1478     const char* name = "TestHitraceMeterFmtScoped";
1479     int taskId = 123;
1480     ASSERT_TRUE(CleanTrace());
1481     ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
1482     StartAsyncTrace(TAG, traceName, taskId);
1483     SetTraceDisabled(true);
1484     HitraceMeterFmtScoped(TAG, name);
1485     SetTraceDisabled(false);
1486     HitraceMeterFmtScoped(TAG, name);
1487     FinishAsyncTrace(TAG, traceName, taskId);
1488 }
1489 
1490 /**
1491  * @tc.name: HiTraceNDKTest_HitracePerfScoped_001
1492  * @tc.desc: Testing IsTagEnabled with multiple tags
1493  * @tc.type: FUNC
1494  */
1495 HWTEST_F(HitraceNDKTest, HitracePerfScoped_001, TestSize.Level1)
1496 {
1497     std::string traceName = "HitracePerfScoped001";
1498     ASSERT_TRUE(CleanTrace());
1499     HitracePerfScoped hitrace(true, TAG, traceName);
1500     hitrace.SetHitracePerfScoped(-1, -1);
1501     HitracePerfScoped(true, TAG, traceName);
1502     HitracePerfScoped(false, TAG, traceName);
1503 }
1504 
1505 /**
1506  * @tc.name: HiTraceNDKTest_HitracePerfScoped_002
1507  * @tc.desc: Testing IsTagEnabled with multiple tags
1508  * @tc.type: FUNC
1509  */
1510 HWTEST_F(HitraceNDKTest, HitracePerfScoped_002, TestSize.Level1)
1511 {
1512     std::string traceName = "HitracePerfScoped002";
1513     ASSERT_TRUE(CleanTrace());
1514     HitracePerfScoped hitrace(true, TAG, traceName);
1515     hitrace.SetHitracePerfScoped(0, 0);
1516 }
1517 
1518 /**
1519  * @tc.name: HiTraceNDKTest_HitraceOsal_001
1520  * @tc.desc: Testing IsTagEnabled with multiple tags
1521  * @tc.type: FUNC
1522  */
1523 HWTEST_F(HitraceNDKTest, HitraceOsal_001, TestSize.Level1)
1524 {
1525     ASSERT_TRUE(CleanTrace());
1526     SetPropertyInner("", "0");
1527     SetPropertyInner(TRACE_PROPERTY, "0");
1528     GetPropertyInner(TRACE_PROPERTY, "0");
1529     RefreshBinderServices();
1530     RefreshHalServices();
1531 }
1532 
1533 /**
1534  * @tc.name: HiTraceNDKTest_HitraceOsal_002
1535  * @tc.desc: Testing IsTagEnabled with multiple tags
1536  * @tc.type: FUNC
1537  */
1538 HWTEST_F(HitraceNDKTest, HitraceOsal_002, TestSize.Level1)
1539 {
1540     ASSERT_TRUE(CleanTrace());
1541     IsHmKernel();
1542     SetPropertyInner("", "0");
1543     SetPropertyInner(TRACE_PROPERTY, "0");
1544     GetPropertyInner(TRACE_PROPERTY, "0");
1545     RefreshBinderServices();
1546     RefreshHalServices();
1547 }
1548 } // namespace HitraceTest
1549 } // namespace HiviewDFX
1550 } // namespace OHOS
1551