1 /*
2 * Copyright (C) 2021 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 "bytrace.h"
23 #include "bytrace_capture.h"
24 #include "parameters.h"
25
26 using namespace testing::ext;
27 using namespace std;
28 using namespace OHOS::HiviewDFX;
29 namespace OHOS {
30 namespace Developtools {
31 namespace BytraceTest {
32 const string TRACE_MARKER_PATH = "trace_marker";
33 const string TRACING_ON_PATH = "tracing_on";
34 const string TRACING_ON = "tracing_on";
35 const string TRACE_PATH = "trace";
36 const string TRACE_MARK_WRITE = "tracing_mark_write";
37 const string TRACE_PATTERN = "\\s*(.*?)-(.*?)\\s+(.*?)\\[(\\d+?)\\]\\s+(.*?)\\s+((\\d+).(\\d+)?):\\s+"
38 + TRACE_MARK_WRITE + ": ";
39 const string TRACE_START = TRACE_PATTERN + "B\\|(.*?)\\|H:";
40 const string TRACE_FINISH = TRACE_PATTERN + "E\\|";
41 const string TRACE_ASYNC_START = TRACE_PATTERN + "S\\|(.*?)\\|H:";
42 const string TRACE_ASYNC_FINISH = TRACE_PATTERN + "F\\|(.*?)\\|H:";
43 const string TRACE_COUNT = TRACE_PATTERN + "C\\|(.*?)\\|H:";
44 const string TRACE_PROPERTY = "debug.bytrace.tags.enableflags";
45 constexpr uint32_t TASK = 1;
46 constexpr uint32_t TID = 2;
47 constexpr uint32_t TGID = 3;
48 constexpr uint32_t CPU = 4;
49 constexpr uint32_t DNH2 = 5;
50 constexpr uint32_t TIMESTAMP = 6;
51 constexpr uint32_t PID = 9;
52 constexpr uint32_t TRACE_NAME = 10;
53 constexpr uint32_t NUM = 11;
54
55 constexpr uint32_t TRACE_FMA11 = 11;
56 constexpr uint32_t TRACE_FMA12 = 12;
57
58 constexpr uint64_t TRACE_INVALIDATE_TAG = 0x1000000;
59 constexpr uint64_t BYTRACE_TAG = 0xd03301;
60 const constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, BYTRACE_TAG, "BYTRACE_TEST"};
61 const uint64_t TAG = BYTRACE_TAG_OHOS;
62 static string g_traceRootPath;
63
64 bool SetProperty(const string& property, const string& value);
65 string GetProperty(const string& property, const string& value);
66 bool CleanTrace();
67 bool CleanFtrace();
68 bool SetFtrace(const string& filename, bool enabled);
69
70 class BytraceNDKTest : public testing::Test {
71 public:
72 static void SetUpTestCase(void);
73 static void TearDownTestCase(void);
74 void SetUp();
TearDown()75 void TearDown() {};
76 };
77
SetUpTestCase()78 void BytraceNDKTest::SetUpTestCase()
79 {
80 const string debugfsDir = "/sys/kernel/debug/tracing/";
81 const string tracefsDir = "/sys/kernel/tracing/";
82 if (access((debugfsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
83 g_traceRootPath = debugfsDir;
84 } else if (access((tracefsDir + TRACE_MARKER_PATH).c_str(), F_OK) != -1) {
85 g_traceRootPath = tracefsDir;
86 } else {
87 HiLog::Error(LABEL, "Error: Finding trace folder failed");
88 }
89 CleanFtrace();
90 }
91
TearDownTestCase()92 void BytraceNDKTest::TearDownTestCase()
93 {
94 SetProperty(TRACE_PROPERTY, "0");
95 SetFtrace(TRACING_ON, false);
96 CleanTrace();
97 }
98
SetUp()99 void BytraceNDKTest::SetUp()
100 {
101 ASSERT_TRUE(CleanTrace());
102 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
103 string value = to_string(TAG);
104 SetProperty(TRACE_PROPERTY, value);
105 HiLog::Info(LABEL, "current tag is %{public}s", GetProperty(TRACE_PROPERTY, "0").c_str());
106 ASSERT_TRUE(GetProperty(TRACE_PROPERTY, "-123") == value);
107 UpdateTraceLabel();
108 }
109
110 struct Param {
111 string m_task;
112 string m_tid;
113 string m_tgid;
114 string m_cpu;
115 string m_dnh2;
116 string m_timestamp;
117 string m_pid;
118 string m_traceName;
119 string m_num;
120 };
121
122 class MyTrace {
123 Param m_param;
124 bool m_loaded;
125 public:
MyTrace()126 MyTrace() : m_loaded(false)
127 {
128 m_param.m_task = "";
129 m_param.m_tid = "";
130 m_param.m_tgid = "";
131 m_param.m_cpu = "";
132 m_param.m_dnh2 = "";
133 m_param.m_timestamp = "";
134 m_param.m_pid = "";
135 m_param.m_traceName = "";
136 m_param.m_num = "";
137 }
138
~MyTrace()139 ~MyTrace()
140 {
141 }
142
143 // task-pid ( tig) [cpu] ...1 timestamp: tracing_mark_write: B|pid|traceName
144 // task-pid ( tig) [cpu] ...1 timestamp: tracing_mark_write: E|pid
Load(const Param & param)145 void Load(const Param& param)
146 {
147 m_param.m_task = param.m_task;
148 m_param.m_pid = param.m_pid;
149 m_param.m_tid = param.m_tid;
150 m_param.m_tgid = param.m_tgid;
151 m_param.m_cpu = param.m_cpu;
152 m_param.m_dnh2 = param.m_dnh2;
153 m_param.m_timestamp = param.m_timestamp;
154 m_param.m_traceName = param.m_traceName;
155 m_param.m_num = param.m_num;
156 m_loaded = true;
157 }
158
GetTask()159 string GetTask()
160 {
161 return m_param.m_task;
162 }
163
GetPid()164 string GetPid()
165 {
166 if (m_loaded) {
167 return m_param.m_pid;
168 }
169 return "";
170 }
171
GetTgid()172 string GetTgid()
173 {
174 if (m_loaded) {
175 return m_param.m_tgid;
176 }
177 return "";
178 }
179
GetCpu()180 string GetCpu()
181 {
182 if (m_loaded) {
183 return m_param.m_cpu;
184 }
185 return "";
186 }
187
GetDnh2()188 string GetDnh2()
189 {
190 if (m_loaded) {
191 return m_param.m_dnh2;
192 }
193 return "";
194 }
195
GetTimestamp()196 string GetTimestamp()
197 {
198 if (m_loaded) {
199 return m_param.m_timestamp;
200 }
201 return "";
202 }
203
GetTraceName()204 string GetTraceName()
205 {
206 if (m_loaded) {
207 return m_param.m_traceName;
208 }
209 return "";
210 }
211
GetNum()212 string GetNum()
213 {
214 if (m_loaded) {
215 return m_param.m_num;
216 }
217 return "";
218 }
219
GetTid()220 string GetTid()
221 {
222 if (m_loaded) {
223 return m_param.m_tid;
224 }
225 return "";
226 }
227
IsLoaded() const228 bool IsLoaded() const
229 {
230 return m_loaded;
231 }
232 };
233
SetProperty(const string & property,const string & value)234 bool SetProperty(const string& property, const string& value)
235 {
236 bool result = false;
237 result = OHOS::system::SetParameter(property, value);
238 if (!result) {
239 HiLog::Error(LABEL, "Error: setting %s failed", property.c_str());
240 return false;
241 }
242 return true;
243 }
244
GetProperty(const string & property,const string & value)245 string GetProperty(const string& property, const string& value)
246 {
247 return OHOS::system::GetParameter(property, value);
248 }
249
GetTimeDuration(int64_t time1,int64_t time2,int64_t diffRange)250 bool GetTimeDuration(int64_t time1, int64_t time2, int64_t diffRange)
251 {
252 int64_t duration = time2 - time1;
253 return (duration > 0) && (duration <= diffRange ? true : false);
254 }
255
Trim(string & s)256 string& Trim(string& s)
257 {
258 if (s.empty()) {
259 return s;
260 }
261 s.erase(0, s.find_first_not_of(" "));
262 s.erase(s.find_last_not_of(" ") + 1);
263 return s;
264 }
265
GetTimeStamp(string str)266 int64_t GetTimeStamp(string str)
267 {
268 if (str == "") {
269 return 0;
270 }
271 int64_t time;
272 Trim(str);
273 time = atol(str.erase(str.find("."), 1).c_str());
274 return time;
275 }
276
GetTraceResult(const string & checkContent,const vector<string> & list)277 MyTrace GetTraceResult(const string& checkContent, const vector<string>& list)
278 {
279 MyTrace trace;
280 if (list.empty() || checkContent == "") {
281 return trace;
282 }
283 regex pattern(checkContent);
284 smatch match;
285 Param param {""};
286 for (int i = list.size() - 1; i >= 0; i--) {
287 if (regex_match(list[i], match, pattern)) {
288 param.m_task = match[TASK];
289 param.m_tid = match[TID];
290 param.m_tgid = match[TGID];
291 param.m_cpu = match[CPU];
292 param.m_dnh2 = match[DNH2];
293 param.m_timestamp = match[TIMESTAMP];
294 param.m_pid = match[PID];
295 if (match.size() == TRACE_FMA11) {
296 param.m_traceName = match[TRACE_NAME],
297 param.m_num = "";
298 } else if (match.size() == TRACE_FMA12) {
299 param.m_traceName = match[TRACE_NAME],
300 param.m_num = match[NUM];
301 } else {
302 param.m_traceName = "";
303 param.m_num = "";
304 }
305 trace.Load(param);
306 break;
307 }
308 }
309 return trace;
310 }
311
WriteStringToFile(const string & fileName,const string & str)312 static bool WriteStringToFile(const string& fileName, const string& str)
313 {
314 if (g_traceRootPath.empty()) {
315 HiLog::Error(LABEL, "Error: trace path not found.");
316 return false;
317 }
318 ofstream out;
319 out.open(g_traceRootPath + fileName, ios::out);
320 out << str;
321 out.close();
322 return true;
323 }
324
CleanTrace()325 bool CleanTrace()
326 {
327 if (g_traceRootPath.empty()) {
328 HiLog::Error(LABEL, "Error: trace path not found.");
329 return false;
330 }
331 ofstream ofs;
332 ofs.open(g_traceRootPath + TRACE_PATH, ofstream::out);
333 if (!ofs.is_open()) {
334 HiLog::Error(LABEL, "Error: opening trace path failed.");
335 return false;
336 }
337 ofs << "";
338 ofs.close();
339 return true;
340 }
341
ReadFile(const string & filename)342 static stringstream ReadFile(const string& filename)
343 {
344 stringstream ss;
345 char resolvedPath[PATH_MAX] = { 0 };
346 if (realpath(filename.c_str(), resolvedPath) == nullptr) {
347 fprintf(stderr, "Error: _fullpath %s failed", filename.c_str());
348 return ss;
349 }
350 ifstream fin(resolvedPath);
351 if (!fin.is_open()) {
352 fprintf(stderr, "opening file: %s failed!", filename.c_str());
353 return ss;
354 }
355 ss << fin.rdbuf();
356 fin.close();
357 return ss;
358 }
359
IsFileExisting(const string & filename)360 static bool IsFileExisting(const string& filename)
361 {
362 return access(filename.c_str(), F_OK) != -1;
363 }
364
SetFtrace(const string & filename,bool enabled)365 bool SetFtrace(const string& filename, bool enabled)
366 {
367 return WriteStringToFile(filename, enabled ? "1" : "0");
368 }
369
CleanFtrace()370 bool CleanFtrace()
371 {
372 return WriteStringToFile("set_event", "");
373 }
374
GetFinishTraceRegex(MyTrace & trace)375 string GetFinishTraceRegex(MyTrace& trace)
376 {
377 if (!trace.IsLoaded()) {
378 return "";
379 } else {
380 return "\\s*(.*?)-(" + trace.GetTid() + "?)\\s+(.*?)\\[(\\d+?)\\]\\s+(.*?)\\s+" + "((\\d+).(\\d+)?):\\s+" +
381 TRACE_MARK_WRITE + ": E\\|(" + trace.GetPid() + ")|(.*)";
382 }
383 }
384
ReadFile2string(const string & filename)385 vector<string> ReadFile2string(const string& filename)
386 {
387 vector<string> list;
388 if (IsFileExisting(filename)) {
389 stringstream ss = ReadFile(filename);
390 string line;
391 while (getline(ss, line)) {
392 list.emplace_back(move(line));
393 }
394 }
395 return list;
396 }
397
ReadTrace()398 vector<string> ReadTrace()
399 {
400 return ReadFile2string(g_traceRootPath + TRACE_PATH);
401 }
402
403 /**
404 * @tc.name: bytrace
405 * @tc.desc: tracing_mark_write file node normal output start tracing and end tracing.
406 * @tc.type: FUNC
407 */
408 HWTEST_F(BytraceNDKTest, StartTrace_001, TestSize.Level0)
409 {
410 ASSERT_TRUE(CleanTrace());
411 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
412 StartTrace(TAG, "StartTraceTest001");
413 FinishTrace(TAG);
414 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
415 vector<string> list = ReadTrace();
416 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest001) ", list);
417 ASSERT_TRUE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest001\" from trace.";
418 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
419 ASSERT_TRUE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
420 }
421
422 /**
423 * @tc.name: bytrace
424 * @tc.desc: tracing_mark_write file node has no output.
425 * @tc.type: FUNC
426 */
427 HWTEST_F(BytraceNDKTest, StartTrace_002, TestSize.Level0)
428 {
429 ASSERT_TRUE(CleanTrace());
430 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
431 StartTrace(TAG, "StartTraceTest002");
432 FinishTrace(TAG);
433 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
434 vector<string> list = ReadTrace();
435 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest002) ", list);
436 ASSERT_TRUE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest002\" from trace.";
437 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
438 ASSERT_TRUE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
439 }
440
441 /**
442 * @tc.name: bytrace
443 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
444 * @tc.type: FUNC
445 */
446 HWTEST_F(BytraceNDKTest, StartTrace_003, TestSize.Level0)
447 {
448 ASSERT_TRUE(CleanTrace());
449 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
450 StartTrace(TAG, "StartTraceTest003 %s");
451 FinishTrace(TAG);
452 vector<string> list = ReadTrace();
453 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest003 %s) ", list);
454 ASSERT_TRUE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest003 %s\" from trace.";
455 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
456 ASSERT_TRUE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
457 ASSERT_TRUE(CleanTrace());
458 list.clear();
459 StartTrace(TAG, "StartTraceTest003 %p");
460 FinishTrace(TAG);
461 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
462 list = ReadTrace();
463 MyTrace startTrace2 = GetTraceResult(TRACE_START + "(StartTraceTest003 %p) ", list);
464 MyTrace finishTrace2 = GetTraceResult(GetFinishTraceRegex(startTrace), list);
465 ASSERT_TRUE(finishTrace2.IsLoaded()) << "Can't find \"E|\" from trace.";
466 }
467
468 /**
469 * @tc.name: bytrace
470 * @tc.desc: test Input and output interval 1ms execution, time fluctuation 1ms
471 * @tc.type: FUNC
472 */
473 HWTEST_F(BytraceNDKTest, StartTrace_004, TestSize.Level0)
474 {
475 ASSERT_TRUE(CleanTrace());
476 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
477 StartTrace(TAG, "StartTraceTest004");
478 usleep(1000);
479 FinishTrace(TAG);
480 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
481 vector<string> list = ReadTrace();
482 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest004) ", list);
483 ASSERT_TRUE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest004\" from trace.";
484 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
485 ASSERT_TRUE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
486 }
487
488 /**
489 * @tc.name: bytrace
490 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
491 * @tc.type: FUNC
492 */
493 HWTEST_F(BytraceNDKTest, StartTrace_005, TestSize.Level0)
494 {
495 ASSERT_TRUE(CleanTrace());
496 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
497 StartAsyncTrace(TAG, "asyncTraceTest005", 123);
498 FinishAsyncTrace(TAG, "asyncTraceTest005", 123);
499 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
500 vector<string> list = ReadTrace();
501 MyTrace startTrace = GetTraceResult(TRACE_ASYNC_START + "(asyncTraceTest005) (.*)", list);
502 ASSERT_TRUE(startTrace.IsLoaded()) << "Can't find \"S|pid|asyncTraceTest005\" from trace.";
503 MyTrace finishTrace =
504 GetTraceResult(TRACE_ASYNC_FINISH + startTrace.GetTraceName() + " " + startTrace.GetNum(), list);
505 ASSERT_TRUE(finishTrace.IsLoaded()) << "Can't find \"F|\" from trace.";
506 }
507
508 /**
509 * @tc.name: bytrace
510 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
511 * @tc.type: FUNC
512 */
513 HWTEST_F(BytraceNDKTest, StartTrace_006, TestSize.Level0)
514 {
515 ASSERT_TRUE(CleanTrace());
516 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
517 CountTrace(TAG, "countTraceTest006", 1);
518 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
519 vector<string> list = ReadTrace();
520 MyTrace countTrace = GetTraceResult(TRACE_COUNT + "(countTraceTest006) (.*)", list);
521 ASSERT_TRUE(countTrace.IsLoaded()) << "Can't find \"C|\" from trace.";
522 }
523
524 /**
525 * @tc.name: bytrace
526 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
527 * @tc.type: FUNC
528 */
529 HWTEST_F(BytraceNDKTest, StartTrace_007, TestSize.Level1)
530 {
531 ASSERT_TRUE(CleanTrace());
532 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
533 StartTrace(TRACE_INVALIDATE_TAG, "StartTraceTest007");
534 FinishTrace(TRACE_INVALIDATE_TAG);
535 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
536 vector<string> list = ReadTrace();
537 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest007)", list);
538 EXPECT_FALSE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest007\" from trace.";
539 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
540 EXPECT_FALSE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
541 }
542
543 /**
544 * @tc.name: bytrace
545 * @tc.desc: tracing_mark_write file node normal output start trace and end trace.
546 * @tc.type: FUNC
547 */
548 HWTEST_F(BytraceNDKTest, StartTrace_008, TestSize.Level1)
549 {
550 ASSERT_TRUE(CleanTrace());
551 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
552 StartTrace(TRACE_INVALIDATE_TAG, "StartTraceTest008 %s");
553 FinishTrace(TRACE_INVALIDATE_TAG);
554 vector<string> list = ReadTrace();
555 MyTrace startTrace = GetTraceResult(TRACE_START + "(StartTraceTest008 %s)", list);
556 EXPECT_FALSE(startTrace.IsLoaded()) << "Can't find \"B|pid|StartTraceTest008 %s\" from trace.";
557 MyTrace finishTrace = GetTraceResult(GetFinishTraceRegex(startTrace), list);
558 EXPECT_FALSE(finishTrace.IsLoaded()) << "Can't find \"E|\" from trace.";
559 ASSERT_TRUE(CleanTrace());
560 list.clear();
561 StartTrace(TRACE_INVALIDATE_TAG, "StartTraceTest008 %p");
562 FinishTrace(TRACE_INVALIDATE_TAG);
563 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
564 list = ReadTrace();
565 MyTrace startTrace2 = GetTraceResult(TRACE_START + "(StartTraceTest008 %p)", list);
566 MyTrace finishTrace2 = GetTraceResult(GetFinishTraceRegex(startTrace), list);
567 EXPECT_FALSE(finishTrace2.IsLoaded()) << "Can't find \"E|\" from trace.";
568 }
569
570 /**
571 * @tc.name: bytrace
572 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
573 * @tc.type: FUNC
574 */
575 HWTEST_F(BytraceNDKTest, StartTrace_009, TestSize.Level1)
576 {
577 ASSERT_TRUE(CleanTrace());
578 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
579 StartAsyncTrace(TRACE_INVALIDATE_TAG, "asyncTraceTest009", 123);
580 FinishAsyncTrace(TRACE_INVALIDATE_TAG, "asyncTraceTest009", 123);
581 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
582 vector<string> list = ReadTrace();
583 MyTrace startTrace = GetTraceResult(TRACE_ASYNC_START + "(asyncTraceTest009)\\|(.*)", list);
584 EXPECT_FALSE(startTrace.IsLoaded()) << "Can't find \"S|pid|asyncTraceTest009\" from trace.";
585 MyTrace finishTrace = GetTraceResult(TRACE_ASYNC_FINISH + startTrace.GetTraceName() + "\\|"
586 + startTrace.GetNum(), list);
587 EXPECT_FALSE(finishTrace.IsLoaded()) << "Can't find \"F|\" from trace.";
588 }
589
590 /**
591 * @tc.name: bytrace
592 * @tc.desc: tracing_mark_write file node normal output start trace and end trace
593 * @tc.type: FUNC
594 */
595 HWTEST_F(BytraceNDKTest, StartTrace_010, TestSize.Level1)
596 {
597 ASSERT_TRUE(CleanTrace());
598 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
599 CountTrace(TRACE_INVALIDATE_TAG, "countTraceTest010", 1);
600 ASSERT_TRUE(SetFtrace(TRACING_ON, false)) << "Setting tracing_on failed.";
601 vector<string> list = ReadTrace();
602 MyTrace countTrace = GetTraceResult(TRACE_COUNT + "(countTraceTest010)\\|(.*)", list);
603 EXPECT_FALSE(countTrace.IsLoaded()) << "Can't find \"C|\" from trace.";
604 }
605
606 /**
607 * @tc.name: bytrace
608 * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
609 * @tc.type: FUNC
610 */
611 HWTEST_F(BytraceNDKTest, StartTrace_011, TestSize.Level1)
612 {
613 ASSERT_TRUE(CleanTrace());
614 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
615 StartTraceDebug(TAG, "StartTraceTest011");
616 FinishTraceDebug(TAG);
617 }
618
619 /**
620 * @tc.name: bytrace
621 * @tc.desc: tracing_mark_write file node general output start and end tracing for debugging.
622 * @tc.type: FUNC
623 */
624 HWTEST_F(BytraceNDKTest, StartTrace_012, TestSize.Level1)
625 {
626 ASSERT_TRUE(CleanTrace());
627 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
628 StartTraceDebug(TAG, "StartTraceTest012 %s");
629 FinishTraceDebug(TAG);
630 }
631
632 /**
633 * @tc.name: bytrace
634 * @tc.desc: Testing StartAsyncTraceDebug and FinishAsyncTraceDebug functions
635 * @tc.type: FUNC
636 */
637 HWTEST_F(BytraceNDKTest, StartTrace_013, TestSize.Level1)
638 {
639 ASSERT_TRUE(CleanTrace());
640 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
641 StartAsyncTraceDebug(TAG, "asyncTraceTest013", 123);
642 FinishAsyncTraceDebug(TAG, "asyncTraceTest013", 123);
643 }
644
645 /**
646 * @tc.name: bytrace
647 * @tc.desc: Testing CountTraceDebug function
648 * @tc.type: FUNC
649 */
650 HWTEST_F(BytraceNDKTest, StartTrace_014, TestSize.Level1)
651 {
652 ASSERT_TRUE(CleanTrace());
653 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
654 CountTraceDebug(TAG, "countTraceTest014", 1);
655 }
656
657 /**
658 * @tc.name: bytrace
659 * @tc.desc: Testing MiddleTrace function
660 * @tc.type: FUNC
661 */
662 HWTEST_F(BytraceNDKTest, StartTrace_015, TestSize.Level1)
663 {
664 ASSERT_TRUE(CleanTrace());
665 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
666 MiddleTrace(TAG, "MiddleTraceTest015", "050tseTecarTelddiM");
667 }
668
669 /**
670 * @tc.name: bytrace
671 * @tc.desc: Testing MiddleTraceDebug function
672 * @tc.type: FUNC
673 */
674 HWTEST_F(BytraceNDKTest, StartTrace_016, TestSize.Level1)
675 {
676 ASSERT_TRUE(CleanTrace());
677 ASSERT_TRUE(SetFtrace(TRACING_ON, true)) << "Setting tracing_on failed.";
678 MiddleTraceDebug(TAG, "MiddleTraceTest016", "061tseTecarTelddiM");
679 }
680 } // namespace BytraceTest
681 } // namespace Developtools
682 } // namespace OHOS
683