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 int HITRACEID_LEN = 64;
57 static string g_traceRootPath;
58 static string g_traceHmDir;
59 static int g_pid;
60
61 bool SetProperty(const string& property, const string& value);
62 string GetProperty(const string& property, const string& value);
63 bool CleanTrace();
64 bool CleanFtrace();
65 bool SetFtrace(const string& filename, bool enabled);
66
67 class HitraceNDKTest : public testing::Test {
68 public:
69 static void SetUpTestCase(void);
70 static void TearDownTestCase(void);
71 void SetUp();
TearDown()72 void TearDown() {}
73 };
74
SetUpTestCase()75 void HitraceNDKTest::SetUpTestCase()
76 {
77 g_pid = getpid();
78 const string debugfsDir = "/sys/kernel/debug/tracing/";
79 const string tracefsDir = "/sys/kernel/tracing/";
80 if (access((debugfsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
81 g_traceRootPath = debugfsDir;
82 } else if (access((tracefsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
83 g_traceRootPath = tracefsDir;
84 } else {
85 HILOG_ERROR(LOG_CORE, "Error: Finding trace folder failed");
86 }
87 if (access((g_traceRootPath + "hongmeng/").c_str(), F_OK) != -1) {
88 g_traceHmDir = "hongmeng/";
89 }
90 CleanFtrace();
91 }
92
TearDownTestCase()93 void HitraceNDKTest::TearDownTestCase()
94 {
95 SetProperty(TRACE_PROPERTY, "0");
96 SetFtrace(TRACING_ON, false);
97 CleanTrace();
98 }
99
SetUp()100 void HitraceNDKTest::SetUp()
101 {
102 ASSERT_TRUE(CleanTrace());
103 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
104 string value = to_string(TAG);
105 SetProperty(TRACE_PROPERTY, value);
106 HILOG_INFO(LOG_CORE, "current tag is %{public}s", GetProperty(TRACE_PROPERTY, "0").c_str());
107 ASSERT_TRUE(GetProperty(TRACE_PROPERTY, "-123") == value);
108 UpdateTraceLabel();
109 }
110
SetProperty(const string & property,const string & value)111 bool SetProperty(const string& property, const string& value)
112 {
113 bool result = false;
114 result = OHOS::system::SetParameter(property, value);
115 if (!result) {
116 HILOG_ERROR(LOG_CORE, "Error: setting %s failed", property.c_str());
117 return false;
118 }
119 return true;
120 }
121
GetProperty(const string & property,const string & value)122 string GetProperty(const string& property, const string& value)
123 {
124 return OHOS::system::GetParameter(property, value);
125 }
126
GetTimeDuration(int64_t time1,int64_t time2,int64_t diffRange)127 bool GetTimeDuration(int64_t time1, int64_t time2, int64_t diffRange)
128 {
129 int64_t duration = time2 - time1;
130 return (duration > 0) && (duration <= diffRange ? true : false);
131 }
132
Trim(string & s)133 string& Trim(string& s)
134 {
135 if (s.empty()) {
136 return s;
137 }
138 s.erase(0, s.find_first_not_of(" "));
139 s.erase(s.find_last_not_of(" ") + 1);
140 return s;
141 }
142
GetTimeStamp(string str)143 int64_t GetTimeStamp(string str)
144 {
145 if (str == "") {
146 return 0;
147 }
148 int64_t time;
149 Trim(str);
150 time = atol(str.erase(str.find("."), 1).c_str());
151 return time;
152 }
153
GetRecord(HiTraceId hiTraceId)154 string GetRecord(HiTraceId hiTraceId)
155 {
156 std::string record;
157 char buf[HITRACEID_LEN] = {0};
158 int bytes = snprintf_s(buf, sizeof(buf), sizeof(buf) - 1, "[%llx,%llx,%llx]#",
159 hiTraceId.GetChainId(), hiTraceId.GetSpanId(), hiTraceId.GetParentSpanId());
160 if (EXPECTANTLY(bytes > 0)) {
161 record += buf;
162 }
163 std::transform(record.cbegin(), record.cend(), record.begin(), [](unsigned char c) { return tolower(c); });
164 return record;
165 }
166
FindResult(string & str,const vector<string> & list)167 bool FindResult(string& str, const vector<string>& list)
168 {
169 for (int i = list.size() - 1; i >= 0; i--) {
170 std::string ele = list[i];
171 if (ele.find(str) != std::string::npos) {
172 return true;
173 }
174 }
175 return false;
176 }
177
GetTraceResult(const char type,const string & traceName,const HiTraceId * hiTraceId,const int taskId,const vector<string> & list)178 bool GetTraceResult(const char type, const string& traceName, const HiTraceId* hiTraceId,
179 const int taskId, const vector<string>& list)
180 {
181 if (list.empty()) {
182 return false;
183 }
184
185 std::string prefix;
186 std::string chainStr = "";
187 std::string str;
188
189 if (hiTraceId != nullptr) {
190 chainStr = GetRecord(*hiTraceId);
191 }
192
193 if (type == 'B') {
194 prefix = "tracing_mark_write: B|";
195 str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr + traceName;
196 } else if (type == 'E') {
197 prefix = "tracing_mark_write: E|";
198 str = prefix + std::to_string(g_pid) + VERTICAL_LINE;
199 } else if (type == 'S') {
200 prefix = "tracing_mark_write: S|";
201 str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr
202 + traceName + " " + to_string(taskId);
203 } else if (type == 'F') {
204 prefix = "tracing_mark_write: F|";
205 str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr
206 + traceName + " " + to_string(taskId);
207 } else if (type == 'C') {
208 prefix = "tracing_mark_write: C|";
209 str = prefix + std::to_string(g_pid) + LABEL_HEADER + chainStr + traceName;
210 } else {
211 return false;
212 }
213 return FindResult(str, list);
214 }
215
WriteStrToFileInner(const string & fileName,const string & str)216 static bool WriteStrToFileInner(const string& fileName, const string& str)
217 {
218 if (g_traceRootPath == "") {
219 HILOG_ERROR(LOG_CORE, "Error: trace path not found.");
220 return false;
221 }
222 ofstream out;
223 out.open(fileName, ios::out);
224 out << str;
225 out.close();
226 return true;
227 }
228
WriteStringToFile(const std::string & filename,const std::string & str)229 static bool WriteStringToFile(const std::string& filename, const std::string& str)
230 {
231 bool ret = false;
232 if (access((g_traceRootPath + "hongmeng/" + filename).c_str(), W_OK) == 0) {
233 if (WriteStrToFileInner(g_traceRootPath + "hongmeng/" + filename, str)) {
234 ret = true;
235 }
236 }
237 if (access((g_traceRootPath + filename).c_str(), W_OK) == 0) {
238 if (WriteStrToFileInner(g_traceRootPath + filename, str)) {
239 ret = true;
240 }
241 }
242
243 return ret;
244 }
245
CleanTrace()246 bool CleanTrace()
247 {
248 if (g_traceRootPath.empty()) {
249 HILOG_ERROR(LOG_CORE, "Error: trace path not found.");
250 return false;
251 }
252 ofstream ofs;
253 ofs.open(g_traceRootPath + g_traceHmDir + TRACE_PATH, ofstream::out);
254 if (!ofs.is_open()) {
255 HILOG_ERROR(LOG_CORE, "Error: opening trace path failed.");
256 return false;
257 }
258 ofs << "";
259 ofs.close();
260 return true;
261 }
262
ReadFile(const string & filename)263 static stringstream ReadFile(const string& filename)
264 {
265 stringstream ss;
266 char resolvedPath[PATH_MAX] = { 0 };
267 if (realpath(filename.c_str(), resolvedPath) == nullptr) {
268 fprintf(stderr, "Error: _fullpath %s failed", filename.c_str());
269 return ss;
270 }
271 ifstream fin(resolvedPath);
272 if (!fin.is_open()) {
273 fprintf(stderr, "opening file: %s failed!", filename.c_str());
274 return ss;
275 }
276 ss << fin.rdbuf();
277 fin.close();
278 return ss;
279 }
280
IsFileExisting(const string & filename)281 static bool IsFileExisting(const string& filename)
282 {
283 return access(filename.c_str(), F_OK) != -1;
284 }
285
SetFtrace(const string & filename,bool enabled)286 bool SetFtrace(const string& filename, bool enabled)
287 {
288 return WriteStringToFile(filename, enabled ? "1" : "0");
289 }
290
CleanFtrace()291 bool CleanFtrace()
292 {
293 return WriteStringToFile("events/enable", "0");
294 }
295
ReadFile2string(const string & filename)296 vector<string> ReadFile2string(const string& filename)
297 {
298 vector<string> list;
299 if (IsFileExisting(filename)) {
300 stringstream ss = ReadFile(filename);
301 string line;
302 while (getline(ss, line)) {
303 list.emplace_back(move(line));
304 }
305 }
306 return list;
307 }
308
ReadTrace()309 vector<string> ReadTrace()
310 {
311 return ReadFile2string(g_traceRootPath + g_traceHmDir + TRACE_PATH);
312 }
313
RunCmd(const string & cmdstr)314 bool RunCmd(const string& cmdstr)
315 {
316 FILE *fp = popen(cmdstr.c_str(), "r");
317 if (fp == nullptr) {
318 return false;
319 }
320 pclose(fp);
321 return true;
322 }
323
324 /**
325 * @tc.name: Hitrace
326 * @tc.desc: tracing_mark_write file node normal output start tracing and end tracing.
327 * @tc.type: FUNC
328 */
329 HWTEST_F(HitraceNDKTest, StartTrace_001, TestSize.Level0)
330 {
331 std::string traceName = "HitraceStartTrace001";
332 ASSERT_TRUE(CleanTrace());
333 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Hitrace Setting tracing_on failed.";
334 StartTrace(TAG, traceName);
335 FinishTrace(TAG);
336 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Hitrace Setting tracing_on failed.";
337 vector<string> list = ReadTrace();
338 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
339 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
340 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
341 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
342 }
343
344
345 /**
346 * @tc.name: Hitrace
347 * @tc.desc: tracing_mark_write file node normal output hitraceId.
348 * @tc.type: FUNC
349 */
350 HWTEST_F(HitraceNDKTest, StartHiTraceIdTest_001, TestSize.Level0)
351 {
352 std::string traceName = "StartHiTraceIdTest001";
353 ASSERT_TRUE(CleanTrace());
354 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
355 HiTraceId hiTraceId = HiTraceChain::Begin(traceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
356 StartTrace(TAG, traceName);
357 FinishTrace(TAG);
358 HiTraceChain::End(hiTraceId);
359 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
360 vector<string> list = ReadTrace();
361 bool isStartSuc = GetTraceResult('B', traceName, &hiTraceId, 0, list);
362 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
363 bool isFinishSuc = GetTraceResult('E', traceName, &hiTraceId, 0, list);
364 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
365 }
366
367 /**
368 * @tc.name: Hitrace
369 * @tc.desc: tracing_mark_write file node large output hitraceId.
370 * @tc.type: FUNC
371 */
372 HWTEST_F(HitraceNDKTest, StartHiTraceIdTest_002, TestSize.Level0)
373 {
374 std::string longTraceName = "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
375 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
376 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
377 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
378 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
379 longTraceName += "StartHiTraceIdTest002";
380 ASSERT_TRUE(CleanTrace());
381 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
382 HiTraceId hiTraceId = HiTraceChain::Begin(longTraceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
383 StartTrace(TAG, longTraceName, SLEEP_ONE_SECOND);
384 FinishTrace(TAG);
385 HiTraceChain::End(hiTraceId);
386 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
387 vector<string> list = ReadTrace();
388 bool isStartSuc = GetTraceResult('B', longTraceName, &hiTraceId, 0, list);
389 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + longTraceName + "\" from trace.";
390
391 bool isFinishSuc = GetTraceResult('E', longTraceName, &hiTraceId, 0, list);
392 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
393 }
394
395 /**
396 * @tc.name: Hitrace
397 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
398 * @tc.type: FUNC
399 */
400 HWTEST_F(HitraceNDKTest, StartAsyncHiTraceIdTest_001, TestSize.Level0)
401 {
402 string traceName = "StartAsyncHiTraceIdTest001";
403 int taskId = 123;
404 ASSERT_TRUE(CleanTrace());
405 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
406 HiTraceId hiTraceId = HiTraceChain::Begin(traceName, HiTraceFlag::HITRACE_FLAG_DEFAULT);
407 StartAsyncTrace(TAG, traceName, taskId);
408 FinishAsyncTrace(TAG, traceName, taskId);
409 HiTraceChain::End(hiTraceId);
410 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
411 vector<string> list = ReadTrace();
412 bool isStartSuc = GetTraceResult('S', traceName, &hiTraceId, taskId, list);
413 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
414 bool isFinishSuc = GetTraceResult('F', traceName, &hiTraceId, taskId, list);
415 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
416 }
417
418 /**
419 * @tc.name: Hitrace
420 * @tc.desc: tracing_mark_write file node has no output.
421 * @tc.type: FUNC
422 */
423 HWTEST_F(HitraceNDKTest, StartTrace_002, TestSize.Level0)
424 {
425 std::string longTraceName = "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
426 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
427 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
428 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
429 longTraceName += "StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002StartHiTraceIdTest002";
430 longTraceName += "StartHiTraceIdTest002";
431 ASSERT_TRUE(CleanTrace());
432 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
433 StartTrace(TAG, longTraceName);
434 FinishTrace(TAG);
435 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
436 vector<string> list = ReadTrace();
437 bool isStartSuc = GetTraceResult('B', longTraceName, nullptr, 0, list);
438 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + longTraceName + "\" from trace.";
439 bool isFinishSuc = GetTraceResult('E', longTraceName, nullptr, 0, list);
440 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
441 }
442
443 /**
444 * @tc.name: Hitrace
445 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
446 * @tc.type: FUNC
447 */
448 HWTEST_F(HitraceNDKTest, StartTrace_003, TestSize.Level0)
449 {
450 string traceName = "StartTraceTest003 %s";
451 ASSERT_TRUE(CleanTrace());
452 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
453 StartTrace(TAG, traceName);
454 FinishTrace(TAG);
455 vector<string> list = ReadTrace();
456 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
457 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
458 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
459 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
460
461 ASSERT_TRUE(CleanTrace());
462 list.clear();
463 traceName = "StartTraceTest003 %p";
464 StartTrace(TAG, traceName);
465 FinishTrace(TAG);
466 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
467 list = ReadTrace();
468 isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
469 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
470 isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
471 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
472 }
473
474 /**
475 * @tc.name: Hitrace
476 * @tc.desc: test Input and output interval 1ms execution, time fluctuation 1ms
477 * @tc.type: FUNC
478 */
479 HWTEST_F(HitraceNDKTest, StartTrace_004, TestSize.Level0)
480 {
481 string traceName = "StartTraceTest004";
482 ASSERT_TRUE(CleanTrace());
483 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
484 StartTrace(TAG, traceName);
485 usleep(1000);
486 FinishTrace(TAG);
487 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
488 vector<string> list = ReadTrace();
489 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
490 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
491 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
492 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
493 }
494
495 /**
496 * @tc.name: Hitrace
497 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
498 * @tc.type: FUNC
499 */
500 HWTEST_F(HitraceNDKTest, StartTrace_005, TestSize.Level0)
501 {
502 string traceName = "asyncTraceTest005";
503 int taskId = 123;
504 ASSERT_TRUE(CleanTrace());
505 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
506 StartAsyncTrace(TAG, traceName, taskId);
507 FinishAsyncTrace(TAG, traceName, taskId);
508 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
509 vector<string> list = ReadTrace();
510 bool isStartSuc = GetTraceResult('S', traceName, nullptr, taskId, list);
511 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
512 bool isFinishSuc = GetTraceResult('F', traceName, nullptr, taskId, list);
513 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
514 }
515
516 /**
517 * @tc.name: Hitrace
518 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
519 * @tc.type: FUNC
520 */
521 HWTEST_F(HitraceNDKTest, StartTrace_006, TestSize.Level0)
522 {
523 string traceName = "countTraceTest006";
524 int count = 1;
525 ASSERT_TRUE(CleanTrace());
526 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
527 CountTrace(TAG, traceName, count);
528 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
529 vector<string> list = ReadTrace();
530 bool isCountSuc = GetTraceResult('C', traceName, nullptr, count, list);
531 ASSERT_TRUE(isCountSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
532 }
533
534 /**
535 * @tc.name: Hitrace
536 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
537 * @tc.type: FUNC
538 */
539 HWTEST_F(HitraceNDKTest, StartTrace_007, TestSize.Level1)
540 {
541 string traceName = "StartTraceTest007";
542 ASSERT_TRUE(CleanTrace());
543 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
544 StartTrace(TRACE_INVALIDATE_TAG, traceName);
545 FinishTrace(TRACE_INVALIDATE_TAG);
546 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
547 vector<string> list = ReadTrace();
548 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
549 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
550 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
551 EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
552 }
553
554 /**
555 * @tc.name: Hitrace
556 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
557 * @tc.type: FUNC
558 */
559 HWTEST_F(HitraceNDKTest, StartTrace_008, TestSize.Level1)
560 {
561 string traceName = "StartTraceTest008 %s";
562 ASSERT_TRUE(CleanTrace());
563 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
564 StartTrace(TRACE_INVALIDATE_TAG, traceName);
565 FinishTrace(TRACE_INVALIDATE_TAG);
566 vector<string> list = ReadTrace();
567 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
568 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
569 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
570 EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
571
572 ASSERT_TRUE(CleanTrace());
573 list.clear();
574 traceName = "StartTraceTest008 %p";
575 StartTrace(TRACE_INVALIDATE_TAG, traceName);
576 FinishTrace(TRACE_INVALIDATE_TAG);
577 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
578 list = ReadTrace();
579 isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
580 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
581 isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
582 EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"E|pid|\" from trace.";
583 }
584
585 /**
586 * @tc.name: Hitrace
587 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
588 * @tc.type: FUNC
589 */
590 HWTEST_F(HitraceNDKTest, StartTrace_009, TestSize.Level1)
591 {
592 string traceName = "asyncTraceTest009";
593 int taskId = 123;
594 ASSERT_TRUE(CleanTrace());
595 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
596 StartAsyncTrace(TRACE_INVALIDATE_TAG, traceName, taskId);
597 FinishAsyncTrace(TRACE_INVALIDATE_TAG, traceName, taskId);
598 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
599 vector<string> list = ReadTrace();
600 bool isStartSuc = GetTraceResult('S', traceName, nullptr, taskId, list);
601 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
602 bool isFinishSuc = GetTraceResult('F', traceName, nullptr, taskId, list);
603 EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"F|pid|\" from trace.";
604 }
605
606 /**
607 * @tc.name: Hitrace
608 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
609 * @tc.type: FUNC
610 */
611 HWTEST_F(HitraceNDKTest, StartTrace_010, TestSize.Level1)
612 {
613 string traceName = "countTraceTest010";
614 int count = 1;
615 ASSERT_TRUE(CleanTrace());
616 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
617 CountTrace(TRACE_INVALIDATE_TAG, traceName, count);
618 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
619 vector<string> list = ReadTrace();
620 bool isStartSuc = GetTraceResult('C', traceName, nullptr, count, list);
621 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
622 }
623
624 /**
625 * @tc.name: Hitrace
626 * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
627 * @tc.type: FUNC
628 */
629 HWTEST_F(HitraceNDKTest, StartTrace_011, TestSize.Level1)
630 {
631 ASSERT_TRUE(CleanTrace());
632 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
633 StartTraceDebug(true, TAG, "StartTraceTest011");
634 FinishTraceDebug(true, TAG);
635 }
636
637 /**
638 * @tc.name: Hitrace
639 * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
640 * @tc.type: FUNC
641 */
642 HWTEST_F(HitraceNDKTest, StartTrace_012, TestSize.Level1)
643 {
644 ASSERT_TRUE(CleanTrace());
645 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
646 StartTraceDebug(true, TAG, "StartTraceTest012 %s");
647 FinishTraceDebug(true, TAG);
648 }
649
650 /**
651 * @tc.name: Hitrace
652 * @tc.desc: Testing StartAsyncTraceDebug and FinishAsyncTraceDebug functions
653 * @tc.type: FUNC
654 */
655 HWTEST_F(HitraceNDKTest, StartTrace_013, TestSize.Level1)
656 {
657 ASSERT_TRUE(CleanTrace());
658 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
659 StartAsyncTraceDebug(true, TAG, "asyncTraceTest013", 123);
660 FinishAsyncTraceDebug(true, TAG, "asyncTraceTest013", 123);
661 }
662
663 /**
664 * @tc.name: Hitrace
665 * @tc.desc: Testing CountTraceDebug function
666 * @tc.type: FUNC
667 */
668 HWTEST_F(HitraceNDKTest, StartTrace_014, TestSize.Level1)
669 {
670 ASSERT_TRUE(CleanTrace());
671 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
672 CountTraceDebug(true, TAG, "countTraceTest014", 1);
673 }
674
675 /**
676 * @tc.name: Hitrace
677 * @tc.desc: Testing MiddleTrace function
678 * @tc.type: FUNC
679 */
680 HWTEST_F(HitraceNDKTest, StartTrace_015, TestSize.Level1)
681 {
682 ASSERT_TRUE(CleanTrace());
683 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
684 MiddleTrace(TAG, "MiddleTraceTest015", "050tseTecarTelddiM");
685 }
686
687 /**
688 * @tc.name: Hitrace
689 * @tc.desc: Testing MiddleTraceDebug function
690 * @tc.type: FUNC
691 */
692 HWTEST_F(HitraceNDKTest, StartTrace_016, TestSize.Level1)
693 {
694 ASSERT_TRUE(CleanTrace());
695 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
696 MiddleTraceDebug(true, TAG, "MiddleTraceTest016", "061tseTecarTelddiM");
697 }
698
699 /**
700 * @tc.name: Hitrace
701 * @tc.desc: tracing_mark_write file node normal output start tracing and end tracing with args
702 * @tc.type: FUNC
703 */
704 HWTEST_F(HitraceNDKTest, StartTrace_017, TestSize.Level1)
705 {
706 string traceName = "StartTraceTest017-%d";
707 ASSERT_TRUE(CleanTrace());
708 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
709 int var = 1;
710 StartTraceArgs(TAG, traceName.c_str(), var);
711 FinishTrace(TAG);
712 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
713 vector<string> list = ReadTrace();
714
715 bool isStartSuc = GetTraceResult('B', traceName.replace(18, 2, to_string(var)), nullptr, 0, list);
716 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
717 bool isFinishSuc = GetTraceResult('E', traceName.replace(18, 2, to_string(var)), nullptr, 0, list);
718 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
719 }
720
721 /**
722 * @tc.name: Hitrace
723 * @tc.desc: tracing_mark_write file node normal output start trace and end trace async with args
724 * @tc.type: FUNC
725 */
726 HWTEST_F(HitraceNDKTest, StartTrace_018, TestSize.Level1)
727 {
728 string traceName = "asyncTraceTest018-%d";
729 int taskId = 123;
730 ASSERT_TRUE(CleanTrace());
731 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
732 int var = 1;
733 StartAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
734 FinishAsyncTraceArgs(TAG, taskId, traceName.c_str(), var);
735 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
736 vector<string> list = ReadTrace();
737 bool isStartSuc = GetTraceResult('S', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
738 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
739 bool isFinishSuc = GetTraceResult('F', traceName.replace(18, 2, to_string(var)), nullptr, taskId, list);
740 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"F|pid|" + traceName + "\" from trace.";
741 }
742
743 /**
744 * @tc.name: Hitrace
745 * @tc.desc: Testing StartTraceArgsDebug function
746 * @tc.type: FUNC
747 */
748 HWTEST_F(HitraceNDKTest, StartTrace_019, TestSize.Level1)
749 {
750 ASSERT_TRUE(CleanTrace());
751 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
752 int var = 1;
753 StartTraceArgsDebug(true, TAG, "StartTraceTest019-%d", var);
754 FinishTrace(TAG);
755 }
756
757 /**
758 * @tc.name: Hitrace
759 * @tc.desc: Testing StartAsyncTraceArgsDebug and FinishAsyncTraceArgsDebug function
760 * @tc.type: FUNC
761 */
762 HWTEST_F(HitraceNDKTest, StartTrace_020, TestSize.Level1)
763 {
764 ASSERT_TRUE(CleanTrace());
765 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
766 int var = 1;
767 StartAsyncTraceArgsDebug(true, TAG, 123, "asyncTraceTest020-%d", var);
768 FinishAsyncTraceArgsDebug(true, TAG, 123, "asyncTraceTest020-%d", var);
769 }
770
771 /**
772 * @tc.name: Hitrace
773 * @tc.desc: Testing StartTraceWrapper function
774 * @tc.type: FUNC
775 */
776 HWTEST_F(HitraceNDKTest, StartTraceWrapper_001, TestSize.Level0)
777 {
778 string traceName = "StartTraceWrapper001";
779 ASSERT_TRUE(CleanTrace());
780 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
781 StartTraceWrapper(TAG, traceName.c_str());
782 FinishTrace(TAG);
783 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
784 vector<string> list = ReadTrace();
785 bool isStartSuc = GetTraceResult('B', traceName, nullptr, 0, list);
786 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"B|pid|" + traceName + "\" from trace.";
787 bool isFinishSuc = GetTraceResult('E', traceName, nullptr, 0, list);
788 ASSERT_TRUE(isFinishSuc) << "Hitrace Can't find \"E|\" from trace.";
789 }
790
791 /**
792 * @tc.name: Hitrace
793 * @tc.desc: Testing StartAsyncTraceWrapper function
794 * @tc.type: FUNC
795 */
796 HWTEST_F(HitraceNDKTest, StartAsyncTraceWrapper_001, TestSize.Level1)
797 {
798 string traceName = "StartAsyncTraceWrapper009";
799 int taskId = 123;
800 ASSERT_TRUE(CleanTrace());
801 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
802 StartAsyncTraceWrapper(TRACE_INVALIDATE_TAG, traceName.c_str(), taskId);
803 FinishAsyncTraceWrapper(TRACE_INVALIDATE_TAG, traceName.c_str(), taskId);
804 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
805 vector<string> list = ReadTrace();
806 bool isStartSuc = GetTraceResult('S', traceName, nullptr, 0, list);
807 EXPECT_FALSE(isStartSuc) << "Hitrace Can't find \"S|pid|" + traceName + "\" from trace.";
808 bool isFinishSuc = GetTraceResult('F', traceName, nullptr, 0, list);
809 EXPECT_FALSE(isFinishSuc) << "Hitrace Can't find \"F|pid|" + traceName + "\" from trace.";
810 }
811
812 /**
813 * @tc.name: Hitrace
814 * @tc.desc: Testing CountTraceWrapper function
815 * @tc.type: FUNC
816 */
817 HWTEST_F(HitraceNDKTest, CountTraceWrapper_001, TestSize.Level0)
818 {
819 string traceName = "CountTraceWrapper001";
820 int count = 1;
821 ASSERT_TRUE(CleanTrace());
822 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
823 CountTraceWrapper(TAG, traceName.c_str(), count);
824 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
825 vector<string> list = ReadTrace();
826 bool isStartSuc = GetTraceResult('C', traceName, nullptr, count, list);
827 ASSERT_TRUE(isStartSuc) << "Hitrace Can't find \"C|" + traceName + "\" from trace.";
828 }
829
830 /**
831 * @tc.name: Hitrace
832 * @tc.desc: Testing SetTraceDisabled function
833 * @tc.type: FUNC
834 */
835 HWTEST_F(HitraceNDKTest, StartTrace_021, TestSize.Level1)
836 {
837 ASSERT_TRUE(CleanTrace());
838 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
839 SetTraceDisabled(true);
840 }
841
842 /**
843 * @tc.name: Hitrace
844 * @tc.desc: Testing GetPropertyInner function
845 * @tc.type: FUNC
846 */
847 HWTEST_F(HitraceNDKTest, StartTrace_022, TestSize.Level1)
848 {
849 ASSERT_TRUE(SetProperty(TRACE_PROPERTY, "0"));
850 string tmp;
851 ASSERT_TRUE(GetPropertyInner(TRACE_PROPERTY, tmp) == "0") << "GetPropertyInner failed.";
852 }
853
854 /**
855 * @tc.name: Hitrace
856 * @tc.desc: Testing IsAppValid function
857 * @tc.type: FUNC
858 */
859 HWTEST_F(HitraceNDKTest, StartTrace_023, TestSize.Level1)
860 {
861 ASSERT_TRUE(CleanTrace());
862 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
863 SetProperty(KEY_RO_DEBUGGABLE, "true");
864 SetProperty(KEY_APP_NUMBER, "1");
865 StartTrace(TRACE_INVALIDATE_TAG, "StartTraceTest023");
866 FinishTrace(TRACE_INVALIDATE_TAG);
867 }
868
869 /**
870 * @tc.name: Hitrace
871 * @tc.desc: Testing trace cmd function
872 * @tc.type: FUNC
873 */
874 HWTEST_F(HitraceNDKTest, StartTrace_024, TestSize.Level1)
875 {
876 ASSERT_TRUE(CleanTrace());
877 ASSERT_TRUE(RunCmd("hitrace -h > /data/local/tmp/test1.txt"));
878 ASSERT_TRUE(RunCmd("hitrace -l > /data/local/tmp/test2.txt"));
879 ASSERT_TRUE(RunCmd("hitrace --list_categories > /data/local/tmp/test3.txt"));
880 ASSERT_TRUE(RunCmd("hitrace --trace_begin > /data/local/tmp/test4.txt"));
881 ASSERT_TRUE(RunCmd("hitrace --trace_dump > /data/local/tmp/test5.txt"));
882 ASSERT_TRUE(RunCmd("hitrace --trace_finish > /data/local/tmp/test6.txt"));
883 ASSERT_TRUE(RunCmd("hitrace --hlep > /data/local/tmp/test7.txt"));
884 ASSERT_TRUE(RunCmd("hitrace -a > /data/local/tmp/test8.txt"));
885 ASSERT_TRUE(RunCmd("hitrace --trace_clock > /data/local/tmp/test9.txt"));
886 ASSERT_TRUE(RunCmd("hitrace -t a > /data/local/tmp/test10.txt"));
887 ASSERT_TRUE(RunCmd("hitrace -t -1 > /data/local/tmp/test11.txt"));
888 ASSERT_TRUE(RunCmd("hitrace --time a > /data/local/tmp/test12.txt"));
889 ASSERT_TRUE(RunCmd("hitrace --time -1 > /data/local/tmp/test13.txt"));
890 ASSERT_TRUE(RunCmd("hitrace -b a > /data/local/tmp/test14.txt"));
891 ASSERT_TRUE(RunCmd("hitrace -b -1 > /data/local/tmp/test15.txt"));
892 ASSERT_TRUE(RunCmd("hitrace --buffer_size a > /data/local/tmp/test16.txt"));
893 ASSERT_TRUE(RunCmd("hitrace --buffer_size -1 > /data/local/tmp/test17.txt"));
894 ASSERT_TRUE(RunCmd("hitrace -z --time 1 --buffer_size 10240 --trace_clock clock ohos > /data/local/tmp/trace01"));
895 ASSERT_TRUE(RunCmd("hitrace -z -t 1 -b 10240 --trace_clock clock --overwrite ohos > /data/local/tmp/trace02"));
896 ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock boot ohos > /data/local/tmp/trace03"));
897 ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock global ohos > /data/local/tmp/trace04"));
898 ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock mono ohos > /data/local/tmp/trace05"));
899 ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock uptime ohos > /data/local/tmp/trace06"));
900 ASSERT_TRUE(RunCmd("hitrace -t 1 --trace_clock perf ohos > /data/local/tmp/trace07"));
901 ASSERT_TRUE(RunCmd("hitrace -b 2048 -t 10 -o /data/local/tmp/test20.txt sched"));
902 ASSERT_TRUE(RunCmd("hitrace -b 2048 -t 10 -o /data/local/tmp/test21 load"));
903 }
904
905 /**
906 * @tc.name: Hitrace
907 * @tc.desc: Testing bytrace cmd function
908 * @tc.type: FUNC
909 */
910 HWTEST_F(HitraceNDKTest, StartTrace_025, TestSize.Level1)
911 {
912 ASSERT_TRUE(CleanTrace());
913 ASSERT_TRUE(RunCmd("bytrace -h > /data/local/tmp/test1.txt"));
914 ASSERT_TRUE(RunCmd("bytrace -l > /data/local/tmp/test2.txt"));
915 ASSERT_TRUE(RunCmd("bytrace --list_categories > /data/local/tmp/test3.txt"));
916 ASSERT_TRUE(RunCmd("bytrace --trace_begin > /data/local/tmp/test4.txt"));
917 ASSERT_TRUE(RunCmd("bytrace --trace_dump > /data/local/tmp/test5.txt"));
918 ASSERT_TRUE(RunCmd("bytrace --trace_finish > /data/local/tmp/test6.txt"));
919 ASSERT_TRUE(RunCmd("bytrace --hlep > /data/local/tmp/test7.txt"));
920 ASSERT_TRUE(RunCmd("bytrace -a > /data/local/tmp/test8.txt"));
921 ASSERT_TRUE(RunCmd("bytrace --trace_clock > /data/local/tmp/test9.txt"));
922 ASSERT_TRUE(RunCmd("bytrace -t a > /data/local/tmp/test10.txt"));
923 ASSERT_TRUE(RunCmd("bytrace -t -1 > /data/local/tmp/test11.txt"));
924 ASSERT_TRUE(RunCmd("bytrace --time a > /data/local/tmp/test12.txt"));
925 ASSERT_TRUE(RunCmd("bytrace --time -1 > /data/local/tmp/test13.txt"));
926 ASSERT_TRUE(RunCmd("bytrace -b a > /data/local/tmp/test14.txt"));
927 ASSERT_TRUE(RunCmd("bytrace -b -1 > /data/local/tmp/test15.txt"));
928 ASSERT_TRUE(RunCmd("bytrace --buffer_size a > /data/local/tmp/test16.txt"));
929 ASSERT_TRUE(RunCmd("bytrace --buffer_size -1 > /data/local/tmp/test17.txt"));
930 ASSERT_TRUE(RunCmd("bytrace -z --time 1 --buffer_size 10240 --trace_clock clock ohos > /data/local/tmp/trace01"));
931 ASSERT_TRUE(RunCmd("bytrace -z -t 1 -b 10240 --trace_clock clock --overwrite ohos > /data/local/tmp/trace02"));
932 ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock boot ohos > /data/local/tmp/trace03"));
933 ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock global ohos > /data/local/tmp/trace04"));
934 ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock mono ohos > /data/local/tmp/trace05"));
935 ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock uptime ohos > /data/local/tmp/trace06"));
936 ASSERT_TRUE(RunCmd("bytrace -t 1 --trace_clock perf ohos > /data/local/tmp/trace07"));
937 ASSERT_TRUE(RunCmd("bytrace -b 2048 -t 10 -o /data/local/tmp/test20.txt sched"));
938 ASSERT_TRUE(RunCmd("bytrace -b 2048 -t 10 -o /data/local/tmp/test21 load"));
939 }
940
941 /**
942 * @tc.name: Hitrace
943 * @tc.desc: Testing IsTagEnabled
944 * @tc.type: FUNC
945 */
946 HWTEST_F(HitraceNDKTest, StartTrace_026, TestSize.Level1)
947 {
948 const std::string keyTraceTag = "debug.hitrace.tags.enableflags";
949 ASSERT_TRUE(SetProperty(keyTraceTag, std::to_string(HITRACE_TAG_USB | HITRACE_TAG_HDF)));
950 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_USB));
951 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_HDF));
952 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_ZAUDIO));
953 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_GLOBAL_RESMGR));
954 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_POWER));
955 }
956
957 /**
958 * @tc.name: Hitrace
959 * @tc.desc: Testing IsTagEnabled with multiple tags
960 * @tc.type: FUNC
961 */
962 HWTEST_F(HitraceNDKTest, StartTrace_027, TestSize.Level1)
963 {
964 const std::string keyTraceTag = "debug.hitrace.tags.enableflags";
965 ASSERT_TRUE(SetProperty(keyTraceTag, std::to_string(HITRACE_TAG_ZIMAGE | HITRACE_TAG_HDF | HITRACE_TAG_ZAUDIO)));
966 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_USB));
967 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_HDF));
968 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ZAUDIO | HITRACE_TAG_HDF));
969 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ZAUDIO | HITRACE_TAG_HDF | HITRACE_TAG_ZIMAGE));
970 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_POWER));
971 }
972
973 } // namespace HitraceTest
974 } // namespace HiviewDFX
975 } // namespace OHOS