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