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