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 <gtest/gtest.h>
17 #include <vector>
18 #include <string>
19 #include <sys/stat.h>
20
21 #include "common_define.h"
22 #include "common_utils.h"
23 #include "hitrace_meter.h"
24 #include "hitrace_meter_test_utils.h"
25 #include "hitrace/tracechain.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::HiviewDFX::Hitrace;
29
30 namespace OHOS {
31 namespace HiviewDFX {
32 namespace HitraceTest {
33 #ifdef LOG_DOMAIN
34 #undef LOG_DOMAIN
35 #define LOG_DOMAIN 0xD002D33
36 #endif
37 #ifdef LOG_TAG
38 #undef LOG_TAG
39 #define LOG_TAG "HitraceTest"
40 #endif
41
42 constexpr uint64_t TAG = HITRACE_TAG_OHOS;
43 constexpr uint64_t INVALID_TAG = HITRACE_TAG_BLUETOOTH;
44 const std::string LABEL_HEADER = "|H:";
45 const std::string VERTICAL_LINE = "|";
46 static char g_pid[6];
47
48 struct HitraceTagPair {
49 uint64_t tag;
50 const char* bitStr;
51 };
52
53 static const HitraceTagPair ORDERED_HITRACE_TAGS[] = {
54 {HITRACE_TAG_ALWAYS, "00"}, {HITRACE_TAG_COMMERCIAL, "05"},
55 {HITRACE_TAG_DRM, "06"}, {HITRACE_TAG_SECURITY, "07"},
56 {HITRACE_TAG_ANIMATION, "09"}, {HITRACE_TAG_PUSH, "10"}, {HITRACE_TAG_VIRSE, "11"},
57 {HITRACE_TAG_MUSL, "12"}, {HITRACE_TAG_FFRT, "13"}, {HITRACE_TAG_CLOUD, "14"},
58 {HITRACE_TAG_DEV_AUTH, "15"}, {HITRACE_TAG_COMMONLIBRARY, "16"}, {HITRACE_TAG_HDCD, "17"},
59 {HITRACE_TAG_HDF, "18"}, {HITRACE_TAG_USB, "19"}, {HITRACE_TAG_INTERCONNECTION, "20"},
60 {HITRACE_TAG_DLP_CREDENTIAL, "21"}, {HITRACE_TAG_ACCESS_CONTROL, "22"}, {HITRACE_TAG_NET, "23"},
61 {HITRACE_TAG_NWEB, "24"}, {HITRACE_TAG_HUKS, "25"}, {HITRACE_TAG_USERIAM, "26"},
62 {HITRACE_TAG_DISTRIBUTED_AUDIO, "27"}, {HITRACE_TAG_DLSM, "28"}, {HITRACE_TAG_FILEMANAGEMENT, "29"},
63 {HITRACE_TAG_OHOS, "30"}, {HITRACE_TAG_ABILITY_MANAGER, "31"}, {HITRACE_TAG_ZCAMERA, "32"},
64 {HITRACE_TAG_ZMEDIA, "33"}, {HITRACE_TAG_ZIMAGE, "34"}, {HITRACE_TAG_ZAUDIO, "35"},
65 {HITRACE_TAG_DISTRIBUTEDDATA, "36"}, {HITRACE_TAG_MDFS, "37"}, {HITRACE_TAG_GRAPHIC_AGP, "38"},
66 {HITRACE_TAG_ACE, "39"}, {HITRACE_TAG_NOTIFICATION, "40"}, {HITRACE_TAG_MISC, "41"},
67 {HITRACE_TAG_MULTIMODALINPUT, "42"}, {HITRACE_TAG_SENSORS, "43"}, {HITRACE_TAG_MSDP, "44"},
68 {HITRACE_TAG_DSOFTBUS, "45"}, {HITRACE_TAG_RPC, "46"}, {HITRACE_TAG_ARK, "47"},
69 {HITRACE_TAG_WINDOW_MANAGER, "48"}, {HITRACE_TAG_ACCOUNT_MANAGER, "49"}, {HITRACE_TAG_DISTRIBUTED_SCREEN, "50"},
70 {HITRACE_TAG_DISTRIBUTED_CAMERA, "51"}, {HITRACE_TAG_DISTRIBUTED_HARDWARE_FWK, "52"},
71 {HITRACE_TAG_GLOBAL_RESMGR, "53"}, {HITRACE_TAG_DEVICE_MANAGER, "54"}, {HITRACE_TAG_SAMGR, "55"},
72 {HITRACE_TAG_POWER, "56"}, {HITRACE_TAG_DISTRIBUTED_SCHEDULE, "57"}, {HITRACE_TAG_DEVICE_PROFILE, "58"},
73 {HITRACE_TAG_DISTRIBUTED_INPUT, "59"}, {HITRACE_TAG_BLUETOOTH, "60"},
74 {HITRACE_TAG_ACCESSIBILITY_MANAGER, "61"}, {HITRACE_TAG_APP, "62"}
75 };
76
77 class HitraceMeterTest : public testing::Test {
78 public:
79 static void SetUpTestCase(void);
80 static void TearDownTestCase(void);
81 void SetUp(void);
82 void TearDown(void);
83 };
84
SetUpTestCase(void)85 void HitraceMeterTest::SetUpTestCase(void)
86 {
87 std::string pidStr = std::to_string(getprocpid());
88 int ret = strcpy_s(g_pid, sizeof(g_pid), pidStr.c_str());
89 if (ret != 0) {
90 HILOG_ERROR(LOG_CORE, "pid[%{public}s] strcpy_s fail ret: %{public}d.", pidStr.c_str(), ret);
91 return;
92 }
93 ASSERT_TRUE(Init(g_pid));
94 ASSERT_TRUE(CleanFtrace());
95 }
96
TearDownTestCase(void)97 void HitraceMeterTest::TearDownTestCase(void)
98 {
99 SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, "0");
100 SetFtrace(TRACING_ON_NODE, false);
101 CleanTrace();
102 }
103
SetUp(void)104 void HitraceMeterTest::SetUp(void)
105 {
106 ASSERT_TRUE(CleanTrace());
107 ASSERT_TRUE(SetFtrace(TRACING_ON_NODE, true)) << "SetUp: Setting tracing_on failed.";
108 std::string value = std::to_string(TAG);
109 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, value)) << "SetUp: Setting enableflags failed.";
110 HILOG_INFO(LOG_CORE, "current tag is %{public}s", GetPropertyInner(TRACE_TAG_ENABLE_FLAGS, "0").c_str());
111 ASSERT_TRUE(GetPropertyInner(TRACE_TAG_ENABLE_FLAGS, "-123") == value);
112 UpdateTraceLabel();
113 }
114
TearDown(void)115 void HitraceMeterTest::TearDown(void)
116 {
117 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, "0")) << "TearDown: Setting enableflags failed.";
118 ASSERT_TRUE(SetFtrace(TRACING_ON_NODE, false)) << "TearDown: Setting tracing_on failed.";
119 ASSERT_TRUE(CleanTrace()) << "TearDown: Cleaning trace failed.";
120 }
121
GetLibPathsBySystemBits(std::vector<std::string> & filePaths)122 static void GetLibPathsBySystemBits(std::vector<std::string> &filePaths)
123 {
124 std::vector<std::string> lib64FilePaths = {
125 "/system/lib64/chipset-sdk-sp/libhitracechain.so",
126 "/system/lib64/chipset-sdk-sp/libhitrace_meter.so",
127 "/system/lib64/libhitrace_meter_rust.dylib.so",
128 "/system/lib64/libhitracechain.dylib.so",
129 "/system/lib64/libhitracechain_c_wrapper.so",
130 "/system/lib64/module/libbytrace.z.so",
131 "/system/lib64/module/libhitracechain_napi.z.so",
132 "/system/lib64/module/libhitracemeter_napi.z.so",
133 "/system/lib64/ndk/libhitrace_ndk.z.so",
134 "/system/lib64/platformsdk/libcj_hitracechain_ffi.z.so",
135 "/system/lib64/platformsdk/libcj_hitracemeter_ffi.z.so",
136 "/system/lib64/platformsdk/libhitrace_dump.z.so",
137 "/system/lib64/platformsdk/libhitrace_option.so"
138 };
139 std::vector<std::string> libFilePaths = {
140 "/system/lib/chipset-sdk-sp/libhitracechain.so",
141 "/system/lib/chipset-sdk-sp/libhitrace_meter.so",
142 "/system/lib/libhitrace_meter_rust.dylib.so",
143 "/system/lib/libhitracechain.dylib.so",
144 "/system/lib/libhitracechain_c_wrapper.so",
145 "/system/lib/module/libbytrace.z.so",
146 "/system/lib/module/libhitracechain_napi.z.so",
147 "/system/lib/module/libhitracemeter_napi.z.so",
148 "/system/lib/ndk/libhitrace_ndk.z.so",
149 "/system/lib/platformsdk/libcj_hitracechain_ffi.z.so",
150 "/system/lib/platformsdk/libcj_hitracemeter_ffi.z.so",
151 "/system/lib/platformsdk/libhitrace_dump.z.so",
152 "/system/lib/platformsdk/libhitrace_option.so"
153 };
154 #ifdef __LP64__
155 filePaths.insert(filePaths.end(), lib64FilePaths.begin(), lib64FilePaths.end());
156 #else
157 filePaths.insert(filePaths.end(), libFilePaths.begin(), libFilePaths.end());
158 #endif
159 }
160
161 /**
162 * @tc.name: SyncTraceInterfaceTest001
163 * @tc.desc: Testing the trace output when the system trace level threshold is DEBUG
164 * @tc.type: FUNC
165 */
166 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest001, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest001: start.";
169
170 const char* name = "SyncTraceInterfaceTest001";
171 const char* customArgs = "key=value";
172 std::string defaultLevel = GetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_INFO));
173 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_DEBUG)));
174
175 StartTraceEx(HITRACE_LEVEL_DEBUG, TAG, name, customArgs);
176 FinishTraceEx(HITRACE_LEVEL_DEBUG, TAG);
177 StartTraceEx(HITRACE_LEVEL_INFO, TAG, name, customArgs);
178 FinishTraceEx(HITRACE_LEVEL_INFO, TAG);
179 StartTraceEx(HITRACE_LEVEL_CRITICAL, TAG, name, customArgs);
180 FinishTraceEx(HITRACE_LEVEL_CRITICAL, TAG);
181 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
182 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
183
184 std::vector<std::string> list = ReadTrace();
185 char record[RECORD_SIZE_MAX + 1] = {0};
186 TraceInfo traceInfo = {'B', HITRACE_LEVEL_DEBUG, TAG, 0, name, "", customArgs};
187 bool isStartSuc = GetTraceResult(traceInfo, list, record);
188 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
189 traceInfo.level = HITRACE_LEVEL_INFO;
190 isStartSuc = GetTraceResult(traceInfo, list, record);
191 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
192 traceInfo.level = HITRACE_LEVEL_CRITICAL;
193 isStartSuc = GetTraceResult(traceInfo, list, record);
194 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
195 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
196 isStartSuc = GetTraceResult(traceInfo, list, record);
197 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
198
199 traceInfo.type = 'E';
200 traceInfo.level = HITRACE_LEVEL_DEBUG;
201 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
202 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
203 traceInfo.level = HITRACE_LEVEL_INFO;
204 isFinishSuc = GetTraceResult(traceInfo, list, record);
205 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
206 traceInfo.level = HITRACE_LEVEL_CRITICAL;
207 isFinishSuc = GetTraceResult(traceInfo, list, record);
208 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
209 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
210 isFinishSuc = GetTraceResult(traceInfo, list, record);
211 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
212
213 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, defaultLevel));
214 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest001: end.";
215 }
216
217 /**
218 * @tc.name: SyncTraceInterfaceTest002
219 * @tc.desc: Testing the trace output when the system trace level threshold is INFO
220 * @tc.type: FUNC
221 */
222 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest002, TestSize.Level1)
223 {
224 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest002: start.";
225
226 const char* name = "SyncTraceInterfaceTest002";
227 const char* customArgs = "key=value";
228 std::string defaultLevel = GetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_INFO));
229 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_INFO)));
230
231 StartTraceEx(HITRACE_LEVEL_DEBUG, TAG, name, customArgs);
232 FinishTraceEx(HITRACE_LEVEL_DEBUG, TAG);
233 StartTraceEx(HITRACE_LEVEL_INFO, TAG, name, customArgs);
234 FinishTraceEx(HITRACE_LEVEL_INFO, TAG);
235 StartTraceEx(HITRACE_LEVEL_CRITICAL, TAG, name, customArgs);
236 FinishTraceEx(HITRACE_LEVEL_CRITICAL, TAG);
237 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
238 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
239
240 std::vector<std::string> list = ReadTrace();
241 char record[RECORD_SIZE_MAX + 1] = {0};
242 TraceInfo traceInfo = {'B', HITRACE_LEVEL_DEBUG, TAG, 0, name, "", customArgs};
243 bool isStartSuc = GetTraceResult(traceInfo, list, record);
244 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
245 traceInfo.level = HITRACE_LEVEL_INFO;
246 isStartSuc = GetTraceResult(traceInfo, list, record);
247 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
248 traceInfo.level = HITRACE_LEVEL_CRITICAL;
249 isStartSuc = GetTraceResult(traceInfo, list, record);
250 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
251 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
252 isStartSuc = GetTraceResult(traceInfo, list, record);
253 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
254
255 traceInfo.type = 'E';
256 traceInfo.level = HITRACE_LEVEL_DEBUG;
257 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
258 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
259 traceInfo.level = HITRACE_LEVEL_INFO;
260 isFinishSuc = GetTraceResult(traceInfo, list, record);
261 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
262 traceInfo.level = HITRACE_LEVEL_CRITICAL;
263 isFinishSuc = GetTraceResult(traceInfo, list, record);
264 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
265 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
266 isFinishSuc = GetTraceResult(traceInfo, list, record);
267 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
268
269 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, defaultLevel));
270 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest002: end.";
271 }
272
273 /**
274 * @tc.name: SyncTraceInterfaceTest003
275 * @tc.desc: Testing the trace output when the system trace level threshold is COMMERCIAL
276 * @tc.type: FUNC
277 */
278 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest003, TestSize.Level1)
279 {
280 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest003: start.";
281
282 const char* name = "SyncTraceInterfaceTest003";
283 const char* customArgs = "key=value";
284 std::string defaultLevel = GetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_INFO));
285 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_COMMERCIAL)));
286
287 StartTraceEx(HITRACE_LEVEL_DEBUG, TAG, name, customArgs);
288 FinishTraceEx(HITRACE_LEVEL_DEBUG, TAG);
289 StartTraceEx(HITRACE_LEVEL_INFO, TAG, name, customArgs);
290 FinishTraceEx(HITRACE_LEVEL_INFO, TAG);
291 StartTraceEx(HITRACE_LEVEL_CRITICAL, TAG, name, customArgs);
292 FinishTraceEx(HITRACE_LEVEL_CRITICAL, TAG);
293 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
294 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
295
296 std::vector<std::string> list = ReadTrace();
297 char record[RECORD_SIZE_MAX + 1] = {0};
298 TraceInfo traceInfo = {'B', HITRACE_LEVEL_DEBUG, TAG, 0, name, "", customArgs};
299 bool isStartSuc = GetTraceResult(traceInfo, list, record);
300 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
301 traceInfo.level = HITRACE_LEVEL_INFO;
302 isStartSuc = GetTraceResult(traceInfo, list, record);
303 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
304 traceInfo.level = HITRACE_LEVEL_CRITICAL;
305 isStartSuc = GetTraceResult(traceInfo, list, record);
306 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
307 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
308 isStartSuc = GetTraceResult(traceInfo, list, record);
309 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
310
311 traceInfo.type = 'E';
312 traceInfo.level = HITRACE_LEVEL_DEBUG;
313 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
314 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
315 traceInfo.level = HITRACE_LEVEL_INFO;
316 isFinishSuc = GetTraceResult(traceInfo, list, record);
317 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
318 traceInfo.level = HITRACE_LEVEL_CRITICAL;
319 isFinishSuc = GetTraceResult(traceInfo, list, record);
320 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
321 traceInfo.level = HITRACE_LEVEL_COMMERCIAL;
322 isFinishSuc = GetTraceResult(traceInfo, list, record);
323 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
324
325 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, defaultLevel));
326 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest003: end.";
327 }
328
329 /**
330 * @tc.name: SyncTraceInterfaceTest004
331 * @tc.desc: Testing the trace output with multiple tags
332 * @tc.type: FUNC
333 */
334 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest004, TestSize.Level1)
335 {
336 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest004: start.";
337
338 const char* name = "SyncTraceInterfaceTest004";
339 const char* customArgs = "key=value";
340 const uint64_t multipleTags = HITRACE_TAG_APP | HITRACE_TAG_ARK | HITRACE_TAG_RPC | HITRACE_TAG_FFRT;
341 std::string value = std::to_string(multipleTags);
342 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, value));
343
344 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, multipleTags, name, customArgs);
345 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, multipleTags);
346 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG, name, customArgs);
347 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG);
348
349 std::vector<std::string> list = ReadTrace();
350 char record[RECORD_SIZE_MAX + 1] = {0};
351 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, multipleTags, 0, name, "", customArgs};
352 bool isStartSuc = GetTraceResult(traceInfo, list, record);
353 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
354 traceInfo.type = 'E';
355 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
356 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
357
358 traceInfo.tag = INVALID_TAG;
359 traceInfo.type = 'B';
360 isStartSuc = GetTraceResult(traceInfo, list, record);
361 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
362 traceInfo.type = 'E';
363 isStartSuc = GetTraceResult(traceInfo, list, record);
364 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
365
366 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest004: end.";
367 }
368
369 /**
370 * @tc.name: SyncTraceInterfaceTest005
371 * @tc.desc: Testing tag HITRACE_TAG_COMMERCIAL
372 * @tc.type: FUNC
373 */
374 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest005, TestSize.Level1)
375 {
376 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest005: start.";
377
378 const char* name = "SyncTraceInterfaceTest005";
379 const char* customArgs = "key=value";
380 const uint64_t multipleTags = TAG | HITRACE_TAG_COMMERCIAL;
381
382 StartTraceEx(HITRACE_LEVEL_INFO, multipleTags, name, customArgs);
383 FinishTraceEx(HITRACE_LEVEL_INFO, multipleTags);
384
385 std::vector<std::string> list = ReadTrace();
386 char record[RECORD_SIZE_MAX + 1] = {0};
387 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, multipleTags, 0, name, "", customArgs};
388 bool isStartSuc = GetTraceResult(traceInfo, list, record);
389 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
390 traceInfo.type = 'E';
391 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
392 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
393
394 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest005: end.";
395 }
396
397 /**
398 * @tc.name: SyncTraceInterfaceTest006
399 * @tc.desc: Testing parameters are empty strings
400 * @tc.type: FUNC
401 */
402 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest006, TestSize.Level1)
403 {
404 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest006: start.";
405
406 const char* name = "SyncTraceInterfaceTest006";
407 const char* customArgs = "key=value";
408
409 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, "", customArgs);
410 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
411
412 std::vector<std::string> list = ReadTrace();
413 char record[RECORD_SIZE_MAX + 1] = {0};
414 TraceInfo traceInfoEmptyName = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, "", "", customArgs};
415 bool isStartSucEmptyName = GetTraceResult(traceInfoEmptyName, list, record);
416 ASSERT_TRUE(isStartSucEmptyName) << "Hitrace can't find \"" << record << "\" from trace.";
417 traceInfoEmptyName.type = 'E';
418 bool isFinishSucEmptyName = GetTraceResult(traceInfoEmptyName, list, record);
419 ASSERT_TRUE(isFinishSucEmptyName) << "Hitrace can't find \"" << record << "\" from trace.";
420
421 ASSERT_TRUE(CleanTrace());
422 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, "");
423 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
424
425 list = ReadTrace();
426 TraceInfo traceInfoEmptyArgs = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", ""};
427 bool isStartSucEmptyArgs = GetTraceResult(traceInfoEmptyArgs, list, record);
428 ASSERT_TRUE(isStartSucEmptyArgs) << "Hitrace can't find \"" << record << "\" from trace.";
429 traceInfoEmptyArgs.type = 'E';
430 bool isFinishSucEmptyArgs = GetTraceResult(traceInfoEmptyArgs, list, record);
431 ASSERT_TRUE(isFinishSucEmptyArgs) << "Hitrace can't find \"" << record << "\" from trace.";
432
433 ASSERT_TRUE(CleanTrace());
434 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, nullptr, nullptr);
435 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
436
437 list = ReadTrace();
438 TraceInfo traceInfoEmptyAll = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, nullptr, nullptr, nullptr};
439 bool isStartSucEmptyAll = GetTraceResult(traceInfoEmptyAll, list, record);
440 GTEST_LOG_(INFO) << record;
441 ASSERT_TRUE(isStartSucEmptyAll) << "Hitrace can't find \"" << record << "\" from trace.";
442 traceInfoEmptyAll.type = 'E';
443 bool isFinishSucEmptyAll = GetTraceResult(traceInfoEmptyAll, list, record);
444 ASSERT_TRUE(isFinishSucEmptyAll) << "Hitrace can't find \"" << record << "\" from trace.";
445
446 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest006: end.";
447 }
448
449 /**
450 * @tc.name: SyncTraceInterfaceTest007
451 * @tc.desc: Testing parameters are overlength strings
452 * @tc.type: FUNC
453 */
454 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest007, TestSize.Level1)
455 {
456 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest007: start.";
457
458 // Each iteration adds 25 characters, resulting in a total string length of 1000 characters.
459 std::string longName = "";
460 for (int i = 0; i < 40; i++) {
461 longName += "SyncTraceInterfaceTest007";
462 }
463 std::string longCustomArgs = "key=value,key=value,key=value,key=value,key=value";
464
465 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, longName.c_str(), longCustomArgs.c_str());
466 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
467
468 std::string expectRecord = std::string("B|") + g_pid + LABEL_HEADER + longName +
469 std::string("|M30|") + longCustomArgs;
470 if (IsHmKernel()) {
471 expectRecord = expectRecord.substr(0, 512);
472 } else {
473 expectRecord = expectRecord.substr(0, 1024);
474 }
475
476 std::vector<std::string> list = ReadTrace();
477 bool isStartSuc = FindResult(expectRecord, list);
478 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << expectRecord << "\" from trace.";
479
480 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest007: end.";
481 }
482
483 /**
484 * @tc.name: SyncTraceInterfaceTest008
485 * @tc.desc: Testing StartTrace and FinishTrace
486 * @tc.type: FUNC
487 */
488 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest008, TestSize.Level1)
489 {
490 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest008: start.";
491
492 std::string name = "SyncTraceInterfaceTest008";
493
494 StartTrace(TAG, name);
495 FinishTrace(TAG);
496
497 std::vector<std::string> list = ReadTrace();
498 char record[RECORD_SIZE_MAX + 1] = {0};
499 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, name.c_str(), "", ""};
500 bool isStartSuc = GetTraceResult(traceInfo, list, record);
501 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
502 traceInfo.type = 'E';
503 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
504 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
505
506 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest008: end.";
507 }
508
509 /**
510 * @tc.name: SyncTraceInterfaceTest009
511 * @tc.desc: Testing StartTraceDebug and FinishTraceDebug
512 * @tc.type: FUNC
513 */
514 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest009, TestSize.Level1)
515 {
516 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest009: start.";
517
518 std::string name = "SyncTraceInterfaceTest009";
519
520 StartTraceDebug(true, TAG, name);
521 FinishTraceDebug(true, TAG);
522
523 std::vector<std::string> list = ReadTrace();
524 char record[RECORD_SIZE_MAX + 1] = {0};
525 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, name.c_str(), "", ""};
526 bool isStartSuc = GetTraceResult(traceInfo, list, record);
527 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
528 traceInfo.type = 'E';
529 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
530 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
531
532 ASSERT_TRUE(CleanTrace());
533 StartTraceDebug(false, TAG, name);
534 FinishTraceDebug(false, TAG);
535
536 list = ReadTrace();
537 traceInfo.type = 'B';
538 isStartSuc = GetTraceResult(traceInfo, list, record);
539 ASSERT_FALSE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
540 traceInfo.type = 'E';
541 isFinishSuc = GetTraceResult(traceInfo, list, record);
542 ASSERT_FALSE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
543
544 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest009: end.";
545 }
546
547 /**
548 * @tc.name: SyncTraceInterfaceTest010
549 * @tc.desc: Testing StartTraceArgs
550 * @tc.type: FUNC
551 */
552 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest010, TestSize.Level1)
553 {
554 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest010: start.";
555
556 const char* name = "SyncTraceInterfaceTest010-%d";
557 int var = 10;
558 // Each line contains 75 characters, and the longName has a total length of 453 characters.
559 std::string longName = "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010";
560 longName += "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010";
561 longName += "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010";
562 longName += "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010";
563 longName += "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010";
564 longName += "SyncTraceInterfaceTest010SyncTraceInterfaceTest010SyncTraceInterfaceTest010-%d";
565
566 SetTraceDisabled(true);
567 StartTraceArgs(TAG, name, var);
568 FinishTrace(TAG);
569 SetTraceDisabled(false);
570
571 std::vector<std::string> list = ReadTrace();
572 bool isSuccess = FindResult("SyncTraceInterfaceTest010", list);
573 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest010\" from trace.";
574
575 ASSERT_TRUE(CleanTrace());
576 StartTraceArgs(TAG, longName.c_str(), var);
577 FinishTrace(TAG);
578
579 list = ReadTrace();
580 isSuccess = FindResult("SyncTraceInterfaceTest010", list);
581 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest010\" from trace.";
582
583 ASSERT_TRUE(CleanTrace());
584 StartTraceArgs(INVALID_TAG, name, var);
585 FinishTrace(INVALID_TAG);
586
587 list = ReadTrace();
588 isSuccess = FindResult("SyncTraceInterfaceTest010", list);
589 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest010\" from trace.";
590
591 ASSERT_TRUE(CleanTrace());
592 StartTraceArgs(TAG, name, var);
593 FinishTrace(TAG);
594
595 list = ReadTrace();
596 char record[RECORD_SIZE_MAX + 1] = {0};
597 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, "SyncTraceInterfaceTest010-10", "", ""};
598 bool isStartSuc = GetTraceResult(traceInfo, list, record);
599 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
600 traceInfo.type = 'E';
601 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
602 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
603
604 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest010: end.";
605 }
606
607 /**
608 * @tc.name: SyncTraceInterfaceTest011
609 * @tc.desc: Testing StartTraceArgsDebug and FinishTraceDebug
610 * @tc.type: FUNC
611 */
612 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest011, TestSize.Level1)
613 {
614 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest011: start.";
615
616 const char* name = "SyncTraceInterfaceTest011-%d";
617 int var = 11;
618 // Each line contains 75 characters, and the longName has a total length of 453 characters.
619 std::string longName = "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011";
620 longName += "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011";
621 longName += "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011";
622 longName += "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011";
623 longName += "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011";
624 longName += "SyncTraceInterfaceTest011SyncTraceInterfaceTest011SyncTraceInterfaceTest011-%d";
625
626 SetTraceDisabled(true);
627 StartTraceArgsDebug(true, TAG, name, var);
628 FinishTraceDebug(true, TAG);
629 SetTraceDisabled(false);
630
631 std::vector<std::string> list = ReadTrace();
632 list = ReadTrace();
633 bool isSuccess = FindResult("SyncTraceInterfaceTest011", list);
634 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest011\" from trace.";
635
636 ASSERT_TRUE(CleanTrace());
637 StartTraceArgsDebug(false, TAG, name, var);
638 FinishTraceDebug(false, TAG);
639
640 list = ReadTrace();
641 isSuccess = FindResult("SyncTraceInterfaceTest011", list);
642 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest011\" from trace.";
643
644 ASSERT_TRUE(CleanTrace());
645 StartTraceArgsDebug(true, TAG, longName.c_str(), var);
646 FinishTraceDebug(true, TAG);
647
648 list = ReadTrace();
649 isSuccess = FindResult("SyncTraceInterfaceTest011", list);
650 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest011\" from trace.";
651
652 ASSERT_TRUE(CleanTrace());
653 StartTraceArgsDebug(true, INVALID_TAG, name, var);
654 FinishTraceDebug(true, INVALID_TAG);
655
656 list = ReadTrace();
657 isSuccess = FindResult("SyncTraceInterfaceTest011", list);
658 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest011\" from trace.";
659
660 ASSERT_TRUE(CleanTrace());
661 StartTraceArgsDebug(true, TAG, name, var);
662 FinishTraceDebug(true, TAG);
663
664 list = ReadTrace();
665 char record[RECORD_SIZE_MAX + 1] = {0};
666 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, "SyncTraceInterfaceTest011-11", "", ""};
667 bool isStartSuc = GetTraceResult(traceInfo, list, record);
668 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
669 traceInfo.type = 'E';
670 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
671 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
672
673 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest011: end.";
674 }
675
676 /**
677 * @tc.name: SyncTraceInterfaceTest012
678 * @tc.desc: Testing StartTraceWrapper
679 * @tc.type: FUNC
680 */
681 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest012, TestSize.Level1)
682 {
683 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest012: start.";
684
685 const char* name = "SyncTraceInterfaceTest012";
686
687 StartTraceWrapper(TAG, name);
688 FinishTrace(TAG);
689
690 std::vector<std::string> list = ReadTrace();
691 char record[RECORD_SIZE_MAX + 1] = {0};
692 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, name, "", ""};
693 bool isStartSuc = GetTraceResult(traceInfo, list, record);
694 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
695 traceInfo.type = 'E';
696 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
697 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
698
699 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest012: end.";
700 }
701
702 /**
703 * @tc.name: SyncTraceInterfaceTest013
704 * @tc.desc: Testing innerkits_c interfaces: HiTraceStartTraceEx and HiTraceFinishTraceEx
705 * @tc.type: FUNC
706 */
707 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest013, TestSize.Level1)
708 {
709 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest013: start.";
710
711 const char* name = "SyncTraceInterfaceTest013";
712 const char* customArgs = "key=value";
713
714 HiTraceStartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
715 HiTraceFinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
716
717 std::vector<std::string> list = ReadTrace();
718 char record[RECORD_SIZE_MAX + 1] = {0};
719 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", customArgs};
720 bool isStartSuc = GetTraceResult(traceInfo, list, record);
721 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
722 traceInfo.type = 'E';
723 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
724 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
725
726 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest013: end.";
727 }
728
729 /**
730 * @tc.name: SyncTraceInterfaceTest014
731 * @tc.desc: Testing innerkits_c interfaces: HiTraceStartTrace and HiTraceFinishTrace
732 * @tc.type: FUNC
733 */
734 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest014, TestSize.Level1)
735 {
736 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest014: start.";
737
738 const char* name = "SyncTraceInterfaceTest014";
739
740 HiTraceStartTrace(TAG, name);
741 HiTraceFinishTrace(TAG);
742
743 std::vector<std::string> list = ReadTrace();
744 char record[RECORD_SIZE_MAX + 1] = {0};
745 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, name, "", ""};
746 bool isStartSuc = GetTraceResult(traceInfo, list, record);
747 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
748 traceInfo.type = 'E';
749 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
750 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
751
752 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest014: end.";
753 }
754
755 /**
756 * @tc.name: SyncTraceInterfaceTest015
757 * @tc.desc: Testing customArgs is empty string with HiTraceId
758 * @tc.type: FUNC
759 */
760 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest015, TestSize.Level1)
761 {
762 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest015: start.";
763
764 const char* name = "SyncTraceInterfaceTest015";
765 const char* customArgs = "key=value";
766
767 HiTraceId hiTraceId = HiTraceChain::Begin(name, HiTraceFlag::HITRACE_FLAG_DEFAULT);
768 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, "");
769 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
770 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
771 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
772 HiTraceChain::End(hiTraceId);
773
774 std::vector<std::string> list = ReadTrace();
775 char record[RECORD_SIZE_MAX + 1] = {0};
776 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", "", &hiTraceId};
777 bool isStartSuc = GetTraceResult(traceInfo, list, record);
778 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
779 traceInfo.type = 'E';
780 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
781 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
782
783 traceInfo.customArgs = customArgs;
784 traceInfo.type = 'B';
785 isStartSuc = GetTraceResult(traceInfo, list, record);
786 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
787 traceInfo.type = 'E';
788 isFinishSuc = GetTraceResult(traceInfo, list, record);
789 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
790
791 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest015: end.";
792 }
793
794 /**
795 * @tc.name: SyncTraceInterfaceTest016
796 * @tc.desc: Testing StartTraceArgsEx
797 * @tc.type: FUNC
798 */
799 HWTEST_F(HitraceMeterTest, SyncTraceInterfaceTest016, TestSize.Level1)
800 {
801 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest016: start.";
802
803 const char* name = "SyncTraceInterfaceTest016-%d";
804 int var = 16;
805 // Each line contains 75 characters, and the longName has a total length of 453 characters.
806 std::string longName = "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016";
807 longName += "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016";
808 longName += "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016";
809 longName += "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016";
810 longName += "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016";
811 longName += "SyncTraceInterfaceTest016SyncTraceInterfaceTest016SyncTraceInterfaceTest016-%d";
812 const char* customArgs = "key=value";
813
814 SetTraceDisabled(true);
815 StartTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, customArgs, name, var);
816 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
817 SetTraceDisabled(false);
818
819 std::vector<std::string> list = ReadTrace();
820 bool isSuccess = FindResult("SyncTraceInterfaceTest016", list);
821 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest016\" from trace.";
822
823 ASSERT_TRUE(CleanTrace());
824 StartTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, customArgs, longName.c_str(), var);
825 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
826
827 list = ReadTrace();
828 isSuccess = FindResult("SyncTraceInterfaceTest016", list);
829 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest016\" from trace.";
830
831 ASSERT_TRUE(CleanTrace());
832 StartTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG, customArgs, name, var);
833 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG);
834
835 list = ReadTrace();
836 isSuccess = FindResult("SyncTraceInterfaceTest016", list);
837 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"SyncTraceInterfaceTest016\" from trace.";
838
839 ASSERT_TRUE(CleanTrace());
840 StartTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, customArgs, name, var);
841 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
842
843 list = ReadTrace();
844 char record[RECORD_SIZE_MAX + 1] = {0};
845 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, "SyncTraceInterfaceTest016-16", "", customArgs};
846 bool isStartSuc = GetTraceResult(traceInfo, list, record);
847 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
848 traceInfo.type = 'E';
849 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
850 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
851
852 GTEST_LOG_(INFO) << "SyncTraceInterfaceTest016: end.";
853 }
854
855 /**
856 * @tc.name: AsyncTraceInterfaceTest001
857 * @tc.desc: Testing StartAsyncTraceEx and FinishAsyncTraceEx with HiTraceId
858 * @tc.type: FUNC
859 */
860 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest001, TestSize.Level1)
861 {
862 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest001: start.";
863
864 const char* name = "AsyncTraceInterfaceTest001";
865 const char* customCategory = nullptr;
866 const char* customArgs = nullptr;
867 int32_t taskId = 1;
868
869 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, customArgs);
870 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
871
872 std::vector<std::string> list = ReadTrace();
873 char record[RECORD_SIZE_MAX + 1] = {0};
874 TraceInfo traceInfo = {'S', HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, customCategory, customArgs};
875 bool isStartSuc = GetTraceResult(traceInfo, list, record);
876 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
877 traceInfo.type = 'F';
878 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
879 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
880
881 ASSERT_TRUE(CleanTrace());
882 HiTraceId hiTraceId = HiTraceChain::Begin(name, HiTraceFlag::HITRACE_FLAG_DEFAULT);
883 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, customArgs);
884 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
885 HiTraceChain::End(hiTraceId);
886
887 list = ReadTrace();
888 traceInfo.type = 'S';
889 traceInfo.hiTraceId = &hiTraceId;
890 isStartSuc = GetTraceResult(traceInfo, list, record);
891 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
892 traceInfo.type = 'F';
893 isFinishSuc = GetTraceResult(traceInfo, list, record);
894 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
895
896 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest001: end.";
897 }
898
899 /**
900 * @tc.name: AsyncTraceInterfaceTest002
901 * @tc.desc: Testing parameters are overlength strings
902 * @tc.type: FUNC
903 */
904 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest002, TestSize.Level1)
905 {
906 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest002: start.";
907
908 // Each iteration adds 26 characters, resulting in a total string length of 1040 characters.
909 std::string longName = "";
910 for (int i = 0; i < 40; i++) {
911 longName += "AsyncTraceInterfaceTest002";
912 }
913 std::string longCustomCategory = "CategoryTestCategoryTest";
914 std::string longCustomArgs = "key=value,key=value,key=value,key=value,key=value";
915 int32_t taskId = 2;
916
917 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, longName.c_str(), taskId,
918 longCustomCategory.c_str(), longCustomArgs.c_str());
919 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, longName.c_str(), taskId);
920
921 std::string expectStartAsyncRecord = std::string("S|") + g_pid + LABEL_HEADER + longName +
922 VERTICAL_LINE + std::to_string(taskId) + std::string("|M30|") + longCustomCategory +
923 VERTICAL_LINE + longCustomArgs;
924 std::string expectFinishAsyncRecord = std::string("F|") + g_pid + LABEL_HEADER + longName +
925 VERTICAL_LINE + std::to_string(taskId) + std::string("|M30");
926 if (IsHmKernel()) {
927 expectStartAsyncRecord = expectStartAsyncRecord.substr(0, 512);
928 expectFinishAsyncRecord = expectFinishAsyncRecord.substr(0, 512);
929 } else {
930 expectStartAsyncRecord = expectStartAsyncRecord.substr(0, 1024);
931 expectFinishAsyncRecord = expectFinishAsyncRecord.substr(0, 1024);
932 }
933
934 std::vector<std::string> list = ReadTrace();
935 bool isStartSuc = FindResult(expectStartAsyncRecord, list);
936 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << expectStartAsyncRecord << "\" from trace.";
937
938 bool isFinishSuc = FindResult(expectFinishAsyncRecord, list);
939 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << expectFinishAsyncRecord << "\" from trace.";
940
941 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest002: end.";
942 }
943
944 /**
945 * @tc.name: AsyncTraceInterfaceTest003
946 * @tc.desc: Testing StartAsyncTrace and FinishAsyncTrace
947 * @tc.type: FUNC
948 */
949 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest003, TestSize.Level1)
950 {
951 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest003: start.";
952
953 std::string name = "AsyncTraceInterfaceTest003";
954 int32_t taskId = 3;
955
956 StartAsyncTrace(TAG, name, taskId);
957 FinishAsyncTrace(TAG, name, taskId);
958
959 std::vector<std::string> list = ReadTrace();
960 char record[RECORD_SIZE_MAX + 1] = {0};
961 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, name.c_str(), "", ""};
962 bool isStartSuc = GetTraceResult(traceInfo, list, record);
963 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
964 traceInfo.type = 'F';
965 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
966 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
967
968 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest003: end.";
969 }
970
971 /**
972 * @tc.name: AsyncTraceInterfaceTest004
973 * @tc.desc: Testing StartAsyncTraceDebug and FinishAsyncTraceDebug
974 * @tc.type: FUNC
975 */
976 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest004, TestSize.Level1)
977 {
978 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest004: start.";
979
980 std::string name = "AsyncTraceInterfaceTest004";
981 int32_t taskId = 4;
982
983 StartAsyncTraceDebug(true, TAG, name, taskId);
984 FinishAsyncTraceDebug(true, TAG, name, taskId);
985
986 std::vector<std::string> list = ReadTrace();
987 char record[RECORD_SIZE_MAX + 1] = {0};
988 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, name.c_str(), "", ""};
989 bool isStartSuc = GetTraceResult(traceInfo, list, record);
990 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
991 traceInfo.type = 'F';
992 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
993 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
994
995 ASSERT_TRUE(CleanTrace());
996 StartAsyncTraceDebug(false, TAG, name, taskId);
997 FinishAsyncTraceDebug(false, TAG, name, taskId);
998
999 list = ReadTrace();
1000 traceInfo.type = 'S';
1001 isStartSuc = GetTraceResult(traceInfo, list, record);
1002 ASSERT_FALSE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1003 traceInfo.type = 'F';
1004 isFinishSuc = GetTraceResult(traceInfo, list, record);
1005 ASSERT_FALSE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1006
1007 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest004: end.";
1008 }
1009
1010 /**
1011 * @tc.name: AsyncTraceInterfaceTest005
1012 * @tc.desc: Testing StartAsyncTraceArgs and FinishAsyncTraceArgs
1013 * @tc.type: FUNC
1014 */
1015 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest005, TestSize.Level1)
1016 {
1017 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest005: start.";
1018
1019 const char* name = "AsyncTraceInterfaceTest005-%d";
1020 int var = 5;
1021 // Each line contains 78 characters, and the longName has a total length of 470 characters.
1022 std::string longName = "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005";
1023 longName += "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005";
1024 longName += "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005";
1025 longName += "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005";
1026 longName += "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005";
1027 longName += "AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005AsyncTraceInterfaceTest005-%d";
1028 int32_t taskId = 5;
1029
1030 SetTraceDisabled(true);
1031 StartAsyncTraceArgs(TAG, taskId, name, var);
1032 FinishAsyncTraceArgs(TAG, taskId, name, var);
1033 SetTraceDisabled(false);
1034
1035 std::vector<std::string> list = ReadTrace();
1036 bool isSuccess = FindResult("AsyncTraceInterfaceTest005", list);
1037 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest005\" from trace.";
1038
1039 ASSERT_TRUE(CleanTrace());
1040 StartAsyncTraceArgs(TAG, taskId, longName.c_str(), var);
1041 FinishAsyncTraceArgs(TAG, taskId, longName.c_str(), var);
1042
1043 list = ReadTrace();
1044 isSuccess = FindResult("AsyncTraceInterfaceTest005", list);
1045 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest005\" from trace.";
1046
1047 ASSERT_TRUE(CleanTrace());
1048 StartAsyncTraceArgs(INVALID_TAG, taskId, name, var);
1049 FinishAsyncTraceArgs(INVALID_TAG, taskId, name, var);
1050
1051 list = ReadTrace();
1052 isSuccess = FindResult("AsyncTraceInterfaceTest005", list);
1053 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest005\" from trace.";
1054
1055 ASSERT_TRUE(CleanTrace());
1056 StartAsyncTraceArgs(TAG, taskId, name, var);
1057 FinishAsyncTraceArgs(TAG, taskId, name, var);
1058
1059 char record[RECORD_SIZE_MAX + 1] = {0};
1060 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, "AsyncTraceInterfaceTest005-5", "", ""};
1061 list = ReadTrace();
1062 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1063 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1064 traceInfo.type = 'F';
1065 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1066 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1067
1068 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest005: end.";
1069 }
1070
1071 /**
1072 * @tc.name: AsyncTraceInterfaceTest006
1073 * @tc.desc: Testing StartAsyncTraceArgsDebug and FinishAsyncTraceArgsDebug
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest006, TestSize.Level1)
1077 {
1078 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest006: start.";
1079
1080 const char* name = "AsyncTraceInterfaceTest006-%d";
1081 int var = 6;
1082 // Each line contains 78 characters, and the longName has a total length of 470 characters.
1083 std::string longName = "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006";
1084 longName += "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006";
1085 longName += "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006";
1086 longName += "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006";
1087 longName += "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006";
1088 longName += "AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006AsyncTraceInterfaceTest006-%d";
1089 int32_t taskId = 6;
1090
1091 SetTraceDisabled(true);
1092 StartAsyncTraceArgsDebug(true, TAG, taskId, name, var);
1093 FinishAsyncTraceArgsDebug(true, TAG, taskId, name, var);
1094 SetTraceDisabled(false);
1095
1096 std::vector<std::string> list = ReadTrace();
1097 bool isSuccess = FindResult("AsyncTraceInterfaceTest006", list);
1098 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest006\" from trace.";
1099
1100 ASSERT_TRUE(CleanTrace());
1101 StartAsyncTraceArgsDebug(false, TAG, taskId, name, var);
1102 FinishAsyncTraceArgsDebug(false, TAG, taskId, name, var);
1103
1104 list = ReadTrace();
1105 isSuccess = FindResult("AsyncTraceInterfaceTest006", list);
1106 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest006\" from trace.";
1107
1108 ASSERT_TRUE(CleanTrace());
1109 StartAsyncTraceArgsDebug(true, TAG, taskId, longName.c_str(), var);
1110 FinishAsyncTraceArgsDebug(true, TAG, taskId, longName.c_str(), var);
1111
1112 list = ReadTrace();
1113 isSuccess = FindResult("AsyncTraceInterfaceTest006", list);
1114 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest006\" from trace.";
1115
1116 ASSERT_TRUE(CleanTrace());
1117 StartAsyncTraceArgsDebug(true, INVALID_TAG, taskId, name, var);
1118 FinishAsyncTraceArgsDebug(true, INVALID_TAG, taskId, name, var);
1119
1120 list = ReadTrace();
1121 isSuccess = FindResult("AsyncTraceInterfaceTest006", list);
1122 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest006\" from trace.";
1123
1124 ASSERT_TRUE(CleanTrace());
1125 StartAsyncTraceArgsDebug(true, TAG, taskId, name, var);
1126 FinishAsyncTraceArgsDebug(true, TAG, taskId, name, var);
1127
1128 list = ReadTrace();
1129 char record[RECORD_SIZE_MAX + 1] = {0};
1130 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, "AsyncTraceInterfaceTest006-6", "", ""};
1131 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1132 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1133 traceInfo.type = 'F';
1134 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1135 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1136
1137 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest006: end.";
1138 }
1139
1140 /**
1141 * @tc.name: AsyncTraceInterfaceTest007
1142 * @tc.desc: Testing StartAsyncTraceWrapper and FinishAsyncTraceWrapper
1143 * @tc.type: FUNC
1144 */
1145 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest007, TestSize.Level1)
1146 {
1147 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest007: start.";
1148
1149 const char* name = "AsyncTraceInterfaceTest007";
1150 int32_t taskId = 7;
1151
1152 StartAsyncTraceWrapper(TAG, name, taskId);
1153 FinishAsyncTraceWrapper(TAG, name, taskId);
1154
1155 std::vector<std::string> list = ReadTrace();
1156 char record[RECORD_SIZE_MAX + 1] = {0};
1157 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, name, "", ""};
1158 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1159 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1160 traceInfo.type = 'F';
1161 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1162 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1163
1164 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest007: end.";
1165 }
1166
1167 /**
1168 * @tc.name: AsyncTraceInterfaceTest008
1169 * @tc.desc: Testing innerkits_c interfaces: HiTraceStartAsyncTraceEx and HiTraceFinishAsyncTraceEx
1170 * @tc.type: FUNC
1171 */
1172 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest008, TestSize.Level1)
1173 {
1174 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest008: start.";
1175
1176 const char* name = "AsyncTraceInterfaceTest008";
1177 const char* customCategory = "test";
1178 const char* customArgs = "key=value";
1179 int32_t taskId = 8;
1180
1181 HiTraceStartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, customArgs);
1182 HiTraceFinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1183
1184 std::vector<std::string> list = ReadTrace();
1185 char record[RECORD_SIZE_MAX + 1] = {0};
1186 TraceInfo traceInfo = {'S', HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, customCategory, customArgs};
1187 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1188 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1189 traceInfo.type = 'F';
1190 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1191 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1192
1193 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest008: end.";
1194 }
1195
1196 /**
1197 * @tc.name: AsyncTraceInterfaceTest009
1198 * @tc.desc: Testing innerkits_c interfaces: HiTraceStartAsyncTrace and HiTraceFinishAsyncTrace
1199 * @tc.type: FUNC
1200 */
1201 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest009, TestSize.Level1)
1202 {
1203 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest009: start.";
1204
1205 const char* name = "AsyncTraceInterfaceTest009";
1206 int32_t taskId = 9;
1207
1208 HiTraceStartAsyncTrace(TAG, name, taskId);
1209 HiTraceFinishAsyncTrace(TAG, name, taskId);
1210
1211 std::vector<std::string> list = ReadTrace();
1212 char record[RECORD_SIZE_MAX + 1] = {0};
1213 TraceInfo traceInfo = {'S', HITRACE_LEVEL_INFO, TAG, taskId, name, "", ""};
1214 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1215 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1216 traceInfo.type = 'F';
1217 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1218 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1219
1220 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest009: end.";
1221 }
1222
1223 /**
1224 * @tc.name: AsyncTraceInterfaceTest010
1225 * @tc.desc: Testing innerkits_c interfaces: HiTraceStartAsyncTrace and HiTraceFinishAsyncTrace
1226 * @tc.type: FUNC
1227 */
1228 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest010, TestSize.Level1)
1229 {
1230 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest010: start.";
1231
1232 const char* name = "AsyncTraceInterfaceTest010";
1233 const char* customCategory = "test";
1234 const char* customArgs = "key=value";
1235 int32_t taskId = 10;
1236
1237 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, nullptr, nullptr);
1238 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1239
1240 std::vector<std::string> list = ReadTrace();
1241 char record[RECORD_SIZE_MAX + 1] = {0};
1242 TraceInfo traceInfo = {'S', HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, nullptr, nullptr};
1243 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1244 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1245
1246 ASSERT_TRUE(CleanTrace());
1247 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, "");
1248 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1249
1250 traceInfo.customCategory = customCategory;
1251 traceInfo.customArgs = "";
1252 list = ReadTrace();
1253 isStartSuc = GetTraceResult(traceInfo, list, record);
1254 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1255
1256 ASSERT_TRUE(CleanTrace());
1257 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, customArgs);
1258 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1259
1260 traceInfo.customArgs = customArgs;
1261 list = ReadTrace();
1262 isStartSuc = GetTraceResult(traceInfo, list, record);
1263 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1264
1265 ASSERT_TRUE(CleanTrace());
1266 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, "", customArgs);
1267 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1268
1269 traceInfo.customCategory = "";
1270 list = ReadTrace();
1271 isStartSuc = GetTraceResult(traceInfo, list, record);
1272 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1273
1274 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest010: end.";
1275 }
1276
1277 /**
1278 * @tc.name: AsyncTraceInterfaceTest011
1279 * @tc.desc: Testing customCategory and customArgs are empty strings with HiTraceId
1280 * @tc.type: FUNC
1281 */
1282 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest011, TestSize.Level1)
1283 {
1284 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest011: start.";
1285
1286 const char* name = "AsyncTraceInterfaceTest011";
1287 const char* customCategory = "test";
1288 const char* customArgs = "key=value";
1289 int32_t taskId = 11;
1290
1291 ASSERT_TRUE(CleanTrace());
1292 HiTraceId hiTraceId = HiTraceChain::Begin(name, HiTraceFlag::HITRACE_FLAG_DEFAULT);
1293 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, customArgs);
1294 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1295 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, "", "");
1296 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1297 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, "", customArgs);
1298 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1299 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, "");
1300 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
1301 HiTraceChain::End(hiTraceId);
1302
1303 std::vector<std::string> list = ReadTrace();
1304 char record[RECORD_SIZE_MAX + 1] = {0};
1305 TraceInfo traceInfo = {'S', HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, customCategory, customArgs, &hiTraceId};
1306 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1307 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1308 traceInfo.customCategory = "";
1309 traceInfo.customArgs = "";
1310 isStartSuc = GetTraceResult(traceInfo, list, record);
1311 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1312 traceInfo.customArgs = customArgs;
1313 isStartSuc = GetTraceResult(traceInfo, list, record);
1314 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1315 traceInfo.customCategory = customCategory;
1316 traceInfo.customArgs = "";
1317 isStartSuc = GetTraceResult(traceInfo, list, record);
1318 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1319
1320 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest011: end.";
1321 }
1322
1323 /**
1324 * @tc.name: AsyncTraceInterfaceTest012
1325 * @tc.desc: Testing StartAsyncTraceArgsEx and FinishAsyncTraceArgsEx
1326 * @tc.type: FUNC
1327 */
1328 HWTEST_F(HitraceMeterTest, AsyncTraceInterfaceTest012, TestSize.Level1)
1329 {
1330 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest012: start.";
1331
1332 const char* name = "AsyncTraceInterfaceTest012-%d";
1333 int var = 12;
1334 // Each line contains 78 characters, and the longName has a total length of 470 characters.
1335 std::string longName = "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012";
1336 longName += "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012";
1337 longName += "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012";
1338 longName += "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012";
1339 longName += "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012";
1340 longName += "AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012AsyncTraceInterfaceTest012-%d";
1341 int32_t taskId = 12;
1342 const char* customCategory = "test";
1343 const char* customArgs = "key=value";
1344
1345 SetTraceDisabled(true);
1346 StartAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, customCategory, customArgs, name, var);
1347 FinishAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, var);
1348 SetTraceDisabled(false);
1349
1350 std::vector<std::string> list = ReadTrace();
1351 bool isSuccess = FindResult("AsyncTraceInterfaceTest012", list);
1352 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest012\" from trace.";
1353
1354 ASSERT_TRUE(CleanTrace());
1355 StartAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, customCategory, customArgs, longName.c_str(), var);
1356 FinishAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, longName.c_str(), var);
1357
1358 list = ReadTrace();
1359 isSuccess = FindResult("AsyncTraceInterfaceTest012", list);
1360 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest012\" from trace.";
1361
1362 ASSERT_TRUE(CleanTrace());
1363 StartAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG, taskId, customCategory, customArgs, name, var);
1364 FinishAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG, taskId, name, var);
1365
1366 list = ReadTrace();
1367 isSuccess = FindResult("AsyncTraceInterfaceTest012", list);
1368 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"AsyncTraceInterfaceTest012\" from trace.";
1369
1370 ASSERT_TRUE(CleanTrace());
1371 StartAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, customCategory, customArgs, name, var);
1372 FinishAsyncTraceArgsEx(HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, var);
1373
1374 char record[RECORD_SIZE_MAX + 1] = {0};
1375 TraceInfo traceInfo = {
1376 'S', HITRACE_LEVEL_COMMERCIAL, TAG, taskId,
1377 "AsyncTraceInterfaceTest012-12", customCategory, customArgs
1378 };
1379 list = ReadTrace();
1380 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1381 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1382 traceInfo.type = 'F';
1383 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1384 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1385
1386 GTEST_LOG_(INFO) << "AsyncTraceInterfaceTest012: end.";
1387 }
1388
1389 /**
1390 * @tc.name: CountTraceInterfaceTest001
1391 * @tc.desc: Testing CountTraceEx
1392 * @tc.type: FUNC
1393 */
1394 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest001, TestSize.Level1)
1395 {
1396 GTEST_LOG_(INFO) << "CountTraceInterfaceTest001: start.";
1397
1398 const char* name = "CountTraceInterfaceTest001";
1399 int64_t count = 1;
1400
1401 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
1402
1403 std::vector<std::string> list = ReadTrace();
1404 char record[RECORD_SIZE_MAX + 1] = {0};
1405 TraceInfo traceInfo = {'C', HITRACE_LEVEL_COMMERCIAL, TAG, count, name, "", ""};
1406 bool isSuccess = GetTraceResult(traceInfo, list, record);
1407 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1408
1409 GTEST_LOG_(INFO) << "CountTraceInterfaceTest001: end.";
1410 }
1411
1412 /**
1413 * @tc.name: CountTraceInterfaceTest002
1414 * @tc.desc: Testing CountTrace
1415 * @tc.type: FUNC
1416 */
1417 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest002, TestSize.Level1)
1418 {
1419 GTEST_LOG_(INFO) << "CountTraceInterfaceTest002: start.";
1420
1421 std::string name = "CountTraceInterfaceTest002";
1422 int64_t count = 2;
1423
1424 CountTrace(TAG, name, count);
1425
1426 std::vector<std::string> list = ReadTrace();
1427 char record[RECORD_SIZE_MAX + 1] = {0};
1428 TraceInfo traceInfo = {'C', HITRACE_LEVEL_INFO, TAG, count, name.c_str(), "", ""};
1429 bool isSuccess = GetTraceResult(traceInfo, list, record);
1430 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1431
1432 GTEST_LOG_(INFO) << "CountTraceInterfaceTest002: end.";
1433 }
1434
1435 /**
1436 * @tc.name: CountTraceInterfaceTest003
1437 * @tc.desc: Testing CountTraceDebug
1438 * @tc.type: FUNC
1439 */
1440 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest003, TestSize.Level1)
1441 {
1442 GTEST_LOG_(INFO) << "CountTraceInterfaceTest003: start.";
1443
1444 std::string name = "CountTraceInterfaceTest003";
1445 int64_t count = 3;
1446
1447 CountTraceDebug(true, TAG, name, count);
1448
1449 std::vector<std::string> list = ReadTrace();
1450 char record[RECORD_SIZE_MAX + 1] = {0};
1451 TraceInfo traceInfo = {'C', HITRACE_LEVEL_INFO, TAG, count, name.c_str(), "", ""};
1452 bool isSuccess = GetTraceResult(traceInfo, list, record);
1453 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1454
1455 ASSERT_TRUE(CleanTrace());
1456 CountTraceDebug(false, TAG, name, count);
1457
1458 list = ReadTrace();
1459 isSuccess = GetTraceResult(traceInfo, list, record);
1460 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"" << record << "\" from trace.";
1461
1462 GTEST_LOG_(INFO) << "CountTraceInterfaceTest003: end.";
1463 }
1464
1465 /**
1466 * @tc.name: CountTraceInterfaceTest004
1467 * @tc.desc: Testing CountTraceWrapper
1468 * @tc.type: FUNC
1469 */
1470 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest004, TestSize.Level1)
1471 {
1472 GTEST_LOG_(INFO) << "CountTraceInterfaceTest004: start.";
1473
1474 const char* name = "CountTraceInterfaceTest004";
1475 int64_t count = 4;
1476
1477 CountTraceWrapper(TAG, name, count);
1478
1479 std::vector<std::string> list = ReadTrace();
1480 char record[RECORD_SIZE_MAX + 1] = {0};
1481 TraceInfo traceInfo = {'C', HITRACE_LEVEL_INFO, TAG, count, name, "", ""};
1482 bool isSuccess = GetTraceResult(traceInfo, list, record);
1483 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1484
1485 GTEST_LOG_(INFO) << "CountTraceInterfaceTest004: end.";
1486 }
1487
1488 /**
1489 * @tc.name: CountTraceInterfaceTest005
1490 * @tc.desc: Testing HiTraceCountTraceEx
1491 * @tc.type: FUNC
1492 */
1493 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest005, TestSize.Level1)
1494 {
1495 GTEST_LOG_(INFO) << "CountTraceInterfaceTest005: start.";
1496
1497 const char* name = "CountTraceInterfaceTest005";
1498 int64_t count = 5;
1499
1500 HiTraceCountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
1501
1502 std::vector<std::string> list = ReadTrace();
1503 char record[RECORD_SIZE_MAX + 1] = {0};
1504 TraceInfo traceInfo = {'C', HITRACE_LEVEL_COMMERCIAL, TAG, count, name, "", ""};
1505 bool isSuccess = GetTraceResult(traceInfo, list, record);
1506 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1507
1508 GTEST_LOG_(INFO) << "CountTraceInterfaceTest005: end.";
1509 }
1510
1511 /**
1512 * @tc.name: CountTraceInterfaceTest006
1513 * @tc.desc: Testing HiTraceCountTrace
1514 * @tc.type: FUNC
1515 */
1516 HWTEST_F(HitraceMeterTest, CountTraceInterfaceTest006, TestSize.Level1)
1517 {
1518 GTEST_LOG_(INFO) << "CountTraceInterfaceTest006: start.";
1519
1520 const char* name = "CountTraceInterfaceTest006";
1521 int64_t count = 6;
1522
1523 HiTraceCountTrace(TAG, name, count);
1524
1525 std::vector<std::string> list = ReadTrace();
1526 char record[RECORD_SIZE_MAX + 1] = {0};
1527 TraceInfo traceInfo = {'C', HITRACE_LEVEL_INFO, TAG, count, name, "", ""};
1528 bool isSuccess = GetTraceResult(traceInfo, list, record);
1529 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
1530
1531 GTEST_LOG_(INFO) << "CountTraceInterfaceTest006: end.";
1532 }
1533
1534 /**
1535 * @tc.name: PrintFormatTest001
1536 * @tc.desc: Test StartTrace Print Format, expected format: B|%pid%|H:%name%|%level%%tag%
1537 * @tc.type: FUNC
1538 */
1539 HWTEST_F(HitraceMeterTest, PrintFormatTest001, TestSize.Level1)
1540 {
1541 GTEST_LOG_(INFO) << "PrintFormatTest001: start.";
1542 const std::string name = "PrintFormatTest001";
1543 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(UINT64_MAX))) <<
1544 "SetUp: Setting enableflags failed.";
1545 constexpr uint64_t traceBufferSize = 512;
1546 ASSERT_TRUE(SetFtrace(TRACE_BUFFER_SIZE_NODE, traceBufferSize)) << "Failed to set trace buffer size.";
1547 std::string pid = std::to_string(getpid());
1548 StartTrace(HITRACE_TAG_ALWAYS, "Initializing");
1549 // test single tag
1550 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1551 constexpr int repeats = 10;
1552 uint64_t tag = tagPair.tag;
1553 std::string tagStr = tagPair.bitStr;
1554 for (int i = 0; i < repeats; ++i) {
1555 StartTrace(tag, name);
1556 }
1557 // count number of traces with the same tag and name, should be 10
1558 std::vector<std::string> list = ReadTrace();
1559 int count = 0;
1560 std::string traceLevel = tag == HITRACE_TAG_COMMERCIAL ? "M" : "I";
1561 std::string targetStr = "B|" + pid + "|H:" + name + "|" + traceLevel + tagStr;
1562 for (const auto& record : list) {
1563 if (record.find(targetStr) != std::string::npos) {
1564 count++;
1565 }
1566 }
1567 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1568 }
1569 // test tags combined with HITRACE_TAG_COMMERCIAL tag
1570 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1571 constexpr int repeats = 10;
1572 uint64_t tag = tagPair.tag;
1573 if ((tag & (HITRACE_TAG_ALWAYS | HITRACE_TAG_COMMERCIAL)) != 0) {
1574 continue; // skip always and commercial tags
1575 }
1576 std::string tagStr = std::string("05") + tagPair.bitStr;
1577 for (int i = 0; i < repeats; ++i) {
1578 StartTrace(HITRACE_TAG_COMMERCIAL|tag, name);
1579 }
1580 // count number of traces with the same tag and name, should be 10
1581 std::vector<std::string> list = ReadTrace();
1582 int count = 0;
1583 std::string targetStr = "B|" + pid + "|H:" + name + "|" + "M" + tagStr;
1584 for (const auto& record : list) {
1585 if (record.find(targetStr) != std::string::npos) {
1586 count++;
1587 }
1588 }
1589 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1590 }
1591 GTEST_LOG_(INFO) << "PrintFormatTest001: end.";
1592 }
1593
1594 /**
1595 * @tc.name: PrintFormatTest002
1596 * @tc.desc: Test FinishTrace Print Format, expected format: E|%pid%|%level%%tag%
1597 * @tc.type: FUNC
1598 */
1599 HWTEST_F(HitraceMeterTest, PrintFormatTest002, TestSize.Level1)
1600 {
1601 GTEST_LOG_(INFO) << "PrintFormatTest002: start.";
1602 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(UINT64_MAX))) <<
1603 "SetUp: Setting enableflags failed.";
1604 constexpr uint64_t traceBufferSize = 512;
1605 ASSERT_TRUE(SetFtrace(TRACE_BUFFER_SIZE_NODE, traceBufferSize)) << "Failed to set trace buffer size.";
1606 std::string pid = std::to_string(getpid());
1607 std::string value = std::to_string(UINT64_MAX); // enable all tags
1608 StartTrace(HITRACE_TAG_ALWAYS, "Initializing");
1609 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1610 constexpr int repeats = 10;
1611 uint64_t tag = tagPair.tag;
1612 std::string tagStr = tagPair.bitStr;
1613 for (int i = 0; i < repeats; ++i) {
1614 FinishTrace(tag);
1615 }
1616 // count number of traces with the same tag and name, should be 10
1617 std::vector<std::string> list = ReadTrace();
1618 int count = 0;
1619 std::string traceLevel = tag == HITRACE_TAG_COMMERCIAL ? "M" : "I";
1620 std::string targetStr = "E|" + pid + "|" + traceLevel + tagStr;
1621 for (const auto& record : list) {
1622 if (record.find(targetStr) != std::string::npos) {
1623 count++;
1624 }
1625 }
1626 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1627 }
1628 // test tags combined with HITRACE_TAG_COMMERCIAL tag
1629 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1630 constexpr int repeats = 10;
1631 uint64_t tag = tagPair.tag;
1632 if ((tag & (HITRACE_TAG_ALWAYS | HITRACE_TAG_COMMERCIAL)) != 0) {
1633 continue; // skip always and commercial tags
1634 }
1635 std::string tagStr = std::string("05") + tagPair.bitStr;
1636 for (int i = 0; i < repeats; ++i) {
1637 FinishTrace(HITRACE_TAG_COMMERCIAL|tag);
1638 }
1639 // count number of traces with the same tag and name, should be 10
1640 std::vector<std::string> list = ReadTrace();
1641 int count = 0;
1642 std::string targetStr = "E|" + pid + "|" + "M" + tagStr;
1643 for (const auto& record : list) {
1644 if (record.find(targetStr) != std::string::npos) {
1645 count++;
1646 }
1647 }
1648 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1649 }
1650 GTEST_LOG_(INFO) << "PrintFormatTest002: end.";
1651 }
1652
1653 /**
1654 * @tc.name: PrintFormatTest003
1655 * @tc.desc: Test StartAsyncTrace Print Format, expected format: S|%pid%|H:%name%|%TaskId%|%level%%tag%
1656 * @tc.type: FUNC
1657 */
1658 HWTEST_F(HitraceMeterTest, PrintFormatTest003, TestSize.Level1)
1659 {
1660 GTEST_LOG_(INFO) << "PrintFormatTest003: start.";
1661 const std::string name = "PrintFormatTest003";
1662 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(UINT64_MAX))) <<
1663 "SetUp: Setting enableflags failed.";
1664 constexpr uint64_t traceBufferSize = 512;
1665 ASSERT_TRUE(SetFtrace(TRACE_BUFFER_SIZE_NODE, traceBufferSize)) << "Failed to set trace buffer size.";
1666 std::string pid = std::to_string(getpid());
1667 std::string value = std::to_string(UINT64_MAX); // enable all tags
1668 StartTrace(HITRACE_TAG_ALWAYS, "Initializing");
1669 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1670 constexpr int repeats = 10;
1671 uint64_t tag = tagPair.tag;
1672 std::string tagStr = tagPair.bitStr;
1673 for (int i = 0; i < repeats; ++i) {
1674 StartAsyncTrace(tag, name, i);
1675 }
1676 // count number of traces with the same tag and name, should be 10
1677 std::vector<std::string> list = ReadTrace();
1678 int count = 0;
1679 std::string traceLevel = tag == HITRACE_TAG_COMMERCIAL ? "M" : "I";
1680 for (const auto& record : list) {
1681 if (record.find("S|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + traceLevel + tagStr) !=
1682 std::string::npos) {
1683 count++;
1684 }
1685 }
1686 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1687 }
1688 // test tags combined with HITRACE_TAG_COMMERCIAL tag
1689 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1690 constexpr int repeats = 10;
1691 uint64_t tag = tagPair.tag;
1692 if ((tag & (HITRACE_TAG_ALWAYS | HITRACE_TAG_COMMERCIAL)) != 0) {
1693 continue; // skip always and commercial tags
1694 }
1695 std::string tagStr = std::string("05") + tagPair.bitStr;
1696 for (int i = 0; i < repeats; ++i) {
1697 StartAsyncTrace(HITRACE_TAG_COMMERCIAL|tag, name, i);
1698 }
1699 // count number of traces with the same tag and name, should be 10
1700 std::vector<std::string> list = ReadTrace();
1701 int count = 0;
1702 for (const auto& record : list) {
1703 if (record.find("S|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + "M" + tagStr) !=
1704 std::string::npos) {
1705 count++;
1706 }
1707 }
1708 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1709 }
1710 GTEST_LOG_(INFO) << "PrintFormatTest003: end.";
1711 }
1712
1713 /**
1714 * @tc.name: PrintFormatTest004
1715 * @tc.desc: Test FinishAsyncTrace Print Format, expected format: F|%pid%|H:%name%|%TaskId%|%level%%tag%
1716 * @tc.type: FUNC
1717 */
1718 HWTEST_F(HitraceMeterTest, PrintFormatTest004, TestSize.Level1)
1719 {
1720 GTEST_LOG_(INFO) << "PrintFormatTest004: start.";
1721 const std::string name = "PrintFormatTest004";
1722 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(UINT64_MAX))) <<
1723 "SetUp: Setting enableflags failed.";
1724 constexpr uint64_t traceBufferSize = 512;
1725 ASSERT_TRUE(SetFtrace(TRACE_BUFFER_SIZE_NODE, traceBufferSize)) << "Failed to set trace buffer size.";
1726 std::string pid = std::to_string(getpid());
1727 std::string value = std::to_string(UINT64_MAX); // enable all tags
1728 StartTrace(HITRACE_TAG_ALWAYS, "Initializing");
1729 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1730 constexpr int repeats = 10;
1731 uint64_t tag = tagPair.tag;
1732 std::string tagStr = tagPair.bitStr;
1733 for (int i = 0; i < repeats; ++i) {
1734 FinishAsyncTrace(tag, name, i);
1735 }
1736 // count number of traces with the same tag and name, should be 10
1737 std::vector<std::string> list = ReadTrace();
1738 int count = 0;
1739 std::string traceLevel = tag == HITRACE_TAG_COMMERCIAL ? "M" : "I";
1740 for (const auto& record : list) {
1741 if (record.find("F|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + traceLevel + tagStr) !=
1742 std::string::npos) {
1743 count++;
1744 }
1745 }
1746 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1747 }
1748 // test tags combined with HITRACE_TAG_COMMERCIAL tag
1749 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1750 constexpr int repeats = 10;
1751 uint64_t tag = tagPair.tag;
1752 if ((tag & (HITRACE_TAG_ALWAYS | HITRACE_TAG_COMMERCIAL)) != 0) {
1753 continue; // skip always and commercial tags
1754 }
1755 std::string tagStr = std::string("05") + tagPair.bitStr;
1756 for (int i = 0; i < repeats; ++i) {
1757 FinishAsyncTrace(HITRACE_TAG_COMMERCIAL|tag, name, i);
1758 }
1759 // count number of traces with the same tag and name, should be 10
1760 std::vector<std::string> list = ReadTrace();
1761 int count = 0;
1762 for (const auto& record : list) {
1763 if (record.find("F|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + "M" + tagStr) !=
1764 std::string::npos) {
1765 count++;
1766 }
1767 }
1768 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1769 }
1770 GTEST_LOG_(INFO) << "PrintFormatTest004: end.";
1771 }
1772
1773 /**
1774 * @tc.name: PrintFormatTest005
1775 * @tc.desc: Test CountTrace Print Format, expected format: C|%pid%|H:%name%|%CountValue%|%level%%tag%
1776 * @tc.type: FUNC
1777 */
1778 HWTEST_F(HitraceMeterTest, PrintFormatTest005, TestSize.Level1)
1779 {
1780 GTEST_LOG_(INFO) << "PrintFormatTest005: start.";
1781 const std::string name = "PrintFormatTest005";
1782 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(UINT64_MAX))) <<
1783 "SetUp: Setting enableflags failed.";
1784 constexpr uint64_t traceBufferSize = 512;
1785 ASSERT_TRUE(SetFtrace(TRACE_BUFFER_SIZE_NODE, traceBufferSize)) << "Failed to set trace buffer size.";
1786 std::string pid = std::to_string(getpid());
1787 std::string value = std::to_string(UINT64_MAX); // enable all tags
1788 StartTrace(HITRACE_TAG_ALWAYS, "Initializing");
1789 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1790 constexpr int repeats = 10;
1791 uint64_t tag = tagPair.tag;
1792 std::string tagStr = tagPair.bitStr;
1793 for (int i = 0; i < repeats; ++i) {
1794 CountTrace(tag, name, i);
1795 }
1796 // count number of traces with the same tag and name, should be 10
1797 std::vector<std::string> list = ReadTrace();
1798 int count = 0;
1799 std::string traceLevel = tag == HITRACE_TAG_COMMERCIAL ? "M" : "I";
1800 for (const auto& record : list) {
1801 if (record.find("C|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + traceLevel + tagStr) !=
1802 std::string::npos) {
1803 count++;
1804 }
1805 }
1806 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1807 }
1808 // test tags combined with HITRACE_TAG_COMMERCIAL tag
1809 for (auto tagPair : ORDERED_HITRACE_TAGS) {
1810 constexpr int repeats = 10;
1811 uint64_t tag = tagPair.tag;
1812 if ((tag & (HITRACE_TAG_ALWAYS | HITRACE_TAG_COMMERCIAL)) != 0) {
1813 continue; // skip always and commercial tags
1814 }
1815 std::string tagStr = std::string("05") + tagPair.bitStr;
1816 for (int i = 0; i < repeats; ++i) {
1817 CountTrace(HITRACE_TAG_COMMERCIAL|tag, name, i);
1818 }
1819 // count number of traces with the same tag and name, should be 10
1820 std::vector<std::string> list = ReadTrace();
1821 int count = 0;
1822 for (const auto& record : list) {
1823 if (record.find("C|" + pid + "|H:" + name + "|" + std::to_string(count) + "|" + "M" + tagStr) !=
1824 std::string::npos) {
1825 count++;
1826 }
1827 }
1828 EXPECT_EQ(count, repeats) << "Expected 10 traces with tag: " << tagStr;
1829 }
1830 GTEST_LOG_(INFO) << "PrintFormatTest005: end.";
1831 }
1832
1833 /**
1834 * @tc.name: TagEnabledInterfaceTest001
1835 * @tc.desc: Testing whether a single tag or multiple tags are enabled by IsTagEnabled
1836 * @tc.type: FUNC
1837 */
1838 HWTEST_F(HitraceMeterTest, TagEnabledInterfaceTest001, TestSize.Level1)
1839 {
1840 GTEST_LOG_(INFO) << "TagEnabledInterfaceTest001: start.";
1841
1842 const uint64_t multipleTags = HITRACE_TAG_APP | HITRACE_TAG_ARK | HITRACE_TAG_RPC;
1843 std::string value = std::to_string(multipleTags);
1844 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, value));
1845
1846 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_APP));
1847 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ARK));
1848 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_RPC));
1849 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_ARK));
1850 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_ARK | HITRACE_TAG_RPC));
1851 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_RPC));
1852 ASSERT_TRUE(IsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_ARK | HITRACE_TAG_RPC));
1853 ASSERT_FALSE(IsTagEnabled(TAG));
1854 ASSERT_FALSE(IsTagEnabled(INVALID_TAG));
1855 ASSERT_FALSE(IsTagEnabled(TAG | INVALID_TAG));
1856 ASSERT_FALSE(IsTagEnabled(HITRACE_TAG_APP | TAG));
1857
1858 GTEST_LOG_(INFO) << "TagEnabledInterfaceTest001: end.";
1859 }
1860
1861 /**
1862 * @tc.name: TagEnabledInterfaceTest002
1863 * @tc.desc: Testing whether a single tag or multiple tags are enabled by HiTraceIsTagEnabled
1864 * @tc.type: FUNC
1865 */
1866 HWTEST_F(HitraceMeterTest, TagEnabledInterfaceTest002, TestSize.Level1)
1867 {
1868 GTEST_LOG_(INFO) << "TagEnabledInterfaceTest002: start.";
1869
1870 const uint64_t multipleTags = HITRACE_TAG_APP | HITRACE_TAG_ARK | HITRACE_TAG_RPC;
1871 std::string value = std::to_string(multipleTags);
1872 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, value));
1873
1874 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_APP));
1875 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_ARK));
1876 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_RPC));
1877 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_ARK));
1878 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_ARK | HITRACE_TAG_RPC));
1879 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_RPC));
1880 ASSERT_TRUE(HiTraceIsTagEnabled(HITRACE_TAG_APP | HITRACE_TAG_ARK | HITRACE_TAG_RPC));
1881 ASSERT_FALSE(HiTraceIsTagEnabled(TAG));
1882 ASSERT_FALSE(HiTraceIsTagEnabled(INVALID_TAG));
1883 ASSERT_FALSE(HiTraceIsTagEnabled(TAG | INVALID_TAG));
1884 ASSERT_FALSE(HiTraceIsTagEnabled(HITRACE_TAG_APP | TAG));
1885
1886 GTEST_LOG_(INFO) << "TagEnabledInterfaceTest002: end.";
1887 }
1888
1889 /**
1890 * @tc.name: CaptureAppTraceTest001
1891 * @tc.desc: Testing invalid args of StartCaptureAppTrace
1892 * @tc.type: FUNC
1893 */
1894 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest001, TestSize.Level2)
1895 {
1896 GTEST_LOG_(INFO) << "CaptureAppTraceTest001: start.";
1897
1898 int fileSize = 100 * 1024 * 1024; // 100M
1899 std::string filePath = "/data/test.ftrace";
1900
1901 int ret = StartCaptureAppTrace(TraceFlag(0), TAG, fileSize, filePath);
1902 ASSERT_EQ(ret, RetType::RET_FAIL_INVALID_ARGS);
1903 ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, HITRACE_TAG_NOT_READY, fileSize, filePath);
1904 ASSERT_EQ(ret, RetType::RET_FAIL_INVALID_ARGS);
1905 ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, HITRACE_TAG_USB, fileSize, filePath);
1906 ASSERT_EQ(ret, RetType::RET_FAIL_INVALID_ARGS);
1907 ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, (1ULL << 63), filePath);
1908 ASSERT_EQ(ret, RetType::RET_FAIL_INVALID_ARGS);
1909
1910 GTEST_LOG_(INFO) << "CaptureAppTraceTest001: end.";
1911 }
1912
1913 /**
1914 * @tc.name: CaptureAppTraceTest002
1915 * @tc.desc: Testing repeatedly calling StartCaptureAppTrace
1916 * @tc.type: FUNC
1917 */
1918 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest002, TestSize.Level2)
1919 {
1920 GTEST_LOG_(INFO) << "CaptureAppTraceTest002: start.";
1921
1922 int fileSize = 100 * 1024 * 1024; // 100M
1923 std::string filePath = "/data/test.ftrace";
1924
1925 int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, filePath);
1926 ASSERT_EQ(ret, RetType::RET_SUCC);
1927 ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, filePath);
1928 ASSERT_EQ(ret, RetType::RET_STARTED);
1929
1930 ret = StopCaptureAppTrace();
1931 ASSERT_EQ(ret, RetType::RET_SUCC);
1932
1933 GTEST_LOG_(INFO) << "CaptureAppTraceTest002: end.";
1934 }
1935
1936 /**
1937 * @tc.name: CaptureAppTraceTest003
1938 * @tc.desc: Testing abnormal filename
1939 * @tc.type: FUNC
1940 */
1941 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest003, TestSize.Level2)
1942 {
1943 GTEST_LOG_(INFO) << "CaptureAppTraceTest003: start.";
1944
1945 int fileSize = 100 * 1024 * 1024; // 100M
1946 std::string nonExistentPath = "/data/test/test/test.ftrace";
1947 std::string noAccessFile = "/proc/test.ftrace";
1948
1949 int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, nonExistentPath);
1950 ASSERT_EQ(ret, RetType::RET_FAIL_ENOENT);
1951 ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, noAccessFile);
1952 ASSERT_NE(ret, RetType::RET_SUCC);
1953
1954 ret = StopCaptureAppTrace();
1955 ASSERT_EQ(ret, RetType::RET_STOPPED);
1956
1957 GTEST_LOG_(INFO) << "CaptureAppTraceTest003: end.";
1958 }
1959
1960 /**
1961 * @tc.name: CaptureAppTraceTest004
1962 * @tc.desc: Testing normal StartCaptureAppTrace with FLAG_MAIN_THREAD
1963 * @tc.type: FUNC
1964 */
1965 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest004, TestSize.Level1)
1966 {
1967 GTEST_LOG_(INFO) << "CaptureAppTraceTest004: start.";
1968
1969 int fileSize = 600 * 1024 * 1024; // 600MB
1970 std::string filePath = "/data/test.ftrace";
1971
1972 int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, filePath);
1973 ASSERT_EQ(ret, RetType::RET_SUCC);
1974
1975 const char* name = "CaptureAppTraceTest004";
1976 const char* customArgs = "key=value";
1977 const char* customCategory = "test";
1978 int number = 4;
1979 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
1980 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
1981 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, number, customCategory, customArgs);
1982 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, number);
1983 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, number);
1984
1985 ret = StopCaptureAppTrace();
1986 ASSERT_EQ(ret, RetType::RET_SUCC);
1987
1988 std::vector<std::string> list = ReadTrace(filePath);
1989 char record[RECORD_SIZE_MAX + 1] = {0};
1990 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, number, name, customCategory, customArgs};
1991 bool isStartSuc = GetTraceResult(traceInfo, list, record);
1992 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1993 traceInfo.type = 'E';
1994 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
1995 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1996 traceInfo.type = 'S';
1997 isStartSuc = GetTraceResult(traceInfo, list, record);
1998 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
1999 traceInfo.type = 'F';
2000 isFinishSuc = GetTraceResult(traceInfo, list, record);
2001 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2002 traceInfo.type = 'C';
2003 isStartSuc = GetTraceResult(traceInfo, list, record);
2004 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2005
2006 GTEST_LOG_(INFO) << "CaptureAppTraceTest004: end.";
2007 }
2008
2009 /**
2010 * @tc.name: CaptureAppTraceTest005
2011 * @tc.desc: Testing normal StartCaptureAppTrace with FLAG_ALL_THREAD
2012 * @tc.type: FUNC
2013 */
2014 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest005, TestSize.Level1)
2015 {
2016 GTEST_LOG_(INFO) << "CaptureAppTraceTest005: start.";
2017
2018 int fileSize = 600 * 1024 * 1024; // 600MB
2019 std::string filePath = "";
2020
2021 int ret = StartCaptureAppTrace(FLAG_ALL_THREAD, TAG, fileSize, filePath);
2022 ASSERT_EQ(ret, RetType::RET_SUCC);
2023 size_t lastSlashPos = filePath.rfind('/');
2024 ASSERT_NE(lastSlashPos, std::string::npos);
2025 if (lastSlashPos != std::string::npos) {
2026 filePath = "/data/local/tmp/" + filePath.substr(lastSlashPos + 1);
2027 }
2028 GTEST_LOG_(INFO) << filePath.c_str();
2029
2030 const char* name = "CaptureAppTraceTest005";
2031 const char* customArgs = "key=value";
2032 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
2033 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2034
2035 ret = StopCaptureAppTrace();
2036 ASSERT_EQ(ret, RetType::RET_SUCC);
2037
2038 std::vector<std::string> list = ReadTrace(filePath);
2039 char record[RECORD_SIZE_MAX + 1] = {0};
2040 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", customArgs};
2041 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2042 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2043 traceInfo.type = 'E';
2044 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2045 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2046
2047 GTEST_LOG_(INFO) << "CaptureAppTraceTest005: end.";
2048 }
2049
2050 /**
2051 * @tc.name: CaptureAppTraceTest006
2052 * @tc.desc: Testing fileLimitSize in FLAG_MAIN_THREAD and FLAG_ALL_THREAD mode
2053 * @tc.type: FUNC
2054 */
2055 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest006, TestSize.Level1)
2056 {
2057 GTEST_LOG_(INFO) << "CaptureAppTraceTest006: start.";
2058
2059 int fileSize = 1 * 1024 * 1024; // 1MB
2060 std::string filePath = "/data/test.ftrace";
2061 const char* name = "CaptureAppTraceTest006";
2062
2063 int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, filePath);
2064 ASSERT_EQ(ret, RetType::RET_SUCC);
2065 for (int loopCount = 10000, number = 0; loopCount > 0; --loopCount, ++number) {
2066 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, number);
2067 }
2068 ret = StopCaptureAppTrace();
2069 ASSERT_EQ(ret, RetType::RET_STOPPED);
2070
2071 ret = StartCaptureAppTrace(FLAG_ALL_THREAD, TAG, fileSize, filePath);
2072 ASSERT_EQ(ret, RetType::RET_SUCC);
2073 for (int loopCount = 10000, number = 0; loopCount > 0; --loopCount, ++number) {
2074 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, number);
2075 }
2076 ret = StopCaptureAppTrace();
2077 ASSERT_EQ(ret, RetType::RET_STOPPED);
2078
2079 GTEST_LOG_(INFO) << "CaptureAppTraceTest006: end.";
2080 }
2081
2082 /**
2083 * @tc.name: CaptureAppTraceTest007
2084 * @tc.desc: Testing WriteAppTraceLong in StartCaptureAppTrace
2085 * @tc.type: FUNC
2086 */
2087 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest007, TestSize.Level2)
2088 {
2089 GTEST_LOG_(INFO) << "CaptureAppTraceTest007: start.";
2090
2091 int nameSize = 32 * 1024; // 32KB
2092 int fileSize = 600 * 1024 * 1024; // 600MB
2093 std::string filePath = "/data/test.ftrace";
2094 std::string name(nameSize, 'K');
2095 int64_t number = 7;
2096
2097 int ret = StartCaptureAppTrace(FLAG_MAIN_THREAD, TAG, fileSize, filePath);
2098 ASSERT_EQ(ret, RetType::RET_SUCC);
2099 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name.c_str(), number);
2100 ret = StopCaptureAppTrace();
2101 ASSERT_EQ(ret, RetType::RET_SUCC);
2102
2103 ret = StartCaptureAppTrace(FLAG_ALL_THREAD, TAG, fileSize, filePath);
2104 ASSERT_EQ(ret, RetType::RET_SUCC);
2105 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name.c_str(), number);
2106 ret = StopCaptureAppTrace();
2107 ASSERT_EQ(ret, RetType::RET_SUCC);
2108
2109 GTEST_LOG_(INFO) << "CaptureAppTraceTest007: end.";
2110 }
2111
2112 /**
2113 * @tc.name: CaptureAppTraceTest008
2114 * @tc.desc: Testing trace with empty string args in StartCaptureAppTrace
2115 * @tc.type: FUNC
2116 */
2117 HWTEST_F(HitraceMeterTest, CaptureAppTraceTest008, TestSize.Level1)
2118 {
2119 GTEST_LOG_(INFO) << "CaptureAppTraceTest008: start.";
2120
2121 int fileSize = 600 * 1024 * 1024; // 600MB
2122 std::string filePath = "/data/test.ftrace";
2123
2124 int ret = StartCaptureAppTrace(FLAG_ALL_THREAD, TAG, fileSize, filePath);
2125 ASSERT_EQ(ret, RetType::RET_SUCC);
2126
2127 const char* name = "CaptureAppTraceTest008";
2128 const char* customArgs = "key=value";
2129 const char* customCategory = "test";
2130 int taskId = 8;
2131 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, "");
2132 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2133 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, "", "");
2134 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
2135 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, "", customArgs);
2136 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
2137 StartAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId, customCategory, "");
2138 FinishAsyncTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, taskId);
2139
2140 ret = StopCaptureAppTrace();
2141 ASSERT_EQ(ret, RetType::RET_SUCC);
2142
2143 std::vector<std::string> list = ReadTrace(filePath);
2144 char record[RECORD_SIZE_MAX + 1] = {0};
2145 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, taskId, name, "", ""};
2146 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2147 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2148
2149 traceInfo.type = 'S';
2150 isStartSuc = GetTraceResult(traceInfo, list, record);
2151 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2152 traceInfo.customArgs = customArgs;
2153 isStartSuc = GetTraceResult(traceInfo, list, record);
2154 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2155 traceInfo.customArgs = "";
2156 traceInfo.customCategory = customCategory;
2157 isStartSuc = GetTraceResult(traceInfo, list, record);
2158 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2159
2160 GTEST_LOG_(INFO) << "CaptureAppTraceTest008: end.";
2161 }
2162
2163 /**
2164 * @tc.name: ROMBaselineTest001
2165 * @tc.desc: test the ROM baseline of the hitrace component
2166 * @tc.type: FUNC
2167 */
2168 HWTEST_F(HitraceMeterTest, ROMBaselineTest001, TestSize.Level2)
2169 {
2170 GTEST_LOG_(INFO) << "ROMBaselineTest001: start.";
2171 std::vector<std::string> filePaths = {
2172 "/system/etc/hiview/hitrace_utils.json",
2173 "/system/etc/init/hitrace.cfg",
2174 "/system/etc/param/hitrace.para",
2175 "/system/etc/param/hitrace.para.dac",
2176 "/system/bin/hitrace",
2177 "/system/bin/bytrace"
2178 };
2179 GetLibPathsBySystemBits(filePaths);
2180 struct stat fileStat;
2181 int64_t totalSize = 0;
2182 constexpr int64_t bytePerKB = 1024;
2183 constexpr int64_t pageSize = 4 * bytePerKB;
2184 for (const auto& filePath : filePaths) {
2185 int ret = lstat(filePath.c_str(), &fileStat);
2186 if (ret != 0) {
2187 EXPECT_EQ(ret, 0) << "Failed to get file size of " << filePath;
2188 } else {
2189 int64_t size = (fileStat.st_size / pageSize) * pageSize / bytePerKB;
2190 if (fileStat.st_size % pageSize != 0) {
2191 size += (pageSize / bytePerKB);
2192 }
2193 GTEST_LOG_(INFO) << "File size of " << filePath << " is " << fileStat.st_size / bytePerKB <<
2194 " KB, caculate as " << size << " KB";
2195 totalSize += size;
2196 }
2197 }
2198 GTEST_LOG_(INFO) << "Total file size is " << totalSize << " KB";
2199 constexpr int64_t baseline = 726;
2200 EXPECT_LE(totalSize, baseline);
2201 GTEST_LOG_(INFO) << "ROMBaselineTest001: end.";
2202 }
2203
2204 /**
2205 * @tc.name: HitraceMeterTest001
2206 * @tc.desc: Testing CachedHandle is nullptr
2207 * @tc.type: FUNC
2208 */
2209 HWTEST_F(HitraceMeterTest, HitraceMeterTest001, TestSize.Level2)
2210 {
2211 GTEST_LOG_(INFO) << "HitraceMeterTest001: start.";
2212
2213 SetCachedHandle("g_cachedHandle", nullptr);
2214 SetCachedHandle("g_appPidCachedHandle", nullptr);
2215 SetCachedHandle("g_levelThresholdCachedHandle", nullptr);
2216
2217 const char* name = "HitraceMeterTest001";
2218 const char* customArgs = "key=value";
2219 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
2220 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2221
2222 std::vector<std::string> list = ReadTrace();
2223 char record[RECORD_SIZE_MAX + 1] = {0};
2224 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", customArgs};
2225 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2226 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2227 traceInfo.type = 'E';
2228 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2229 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2230
2231 GTEST_LOG_(INFO) << "HitraceMeterTest001: end.";
2232 }
2233
2234 /**
2235 * @tc.name: HitraceMeterTest002
2236 * @tc.desc: Testing cached system parameters changed
2237 * @tc.type: FUNC
2238 */
2239 HWTEST_F(HitraceMeterTest, HitraceMeterTest002, TestSize.Level1)
2240 {
2241 GTEST_LOG_(INFO) << "HitraceMeterTest002: start.";
2242
2243 std::string defaultTagValue = GetPropertyInner(TRACE_TAG_ENABLE_FLAGS, "0");
2244 std::string defaultAppPid = GetPropertyInner(TRACE_KEY_APP_PID, "-1");
2245 std::string defaultTraceLevel = GetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_INFO));
2246
2247 UpdateTraceLabel();
2248 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, std::to_string(INVALID_TAG)));
2249 ASSERT_TRUE(SetPropertyInner(TRACE_KEY_APP_PID, "1"));
2250 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, std::to_string(HITRACE_LEVEL_DEBUG)));
2251 UpdateTraceLabel();
2252
2253 const char* name = "HitraceMeterTest002";
2254 const char* customArgs = "key=value";
2255 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
2256 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2257
2258 std::vector<std::string> list = ReadTrace();
2259 char record[RECORD_SIZE_MAX + 1] = {0};
2260 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, name, "", customArgs};
2261 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2262 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
2263 traceInfo.type = 'E';
2264 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2265 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
2266
2267 ASSERT_TRUE(SetPropertyInner(TRACE_TAG_ENABLE_FLAGS, defaultTagValue));
2268 ASSERT_TRUE(SetPropertyInner(TRACE_KEY_APP_PID, defaultAppPid));
2269 ASSERT_TRUE(SetPropertyInner(TRACE_LEVEL_THRESHOLD, defaultTraceLevel));
2270 UpdateTraceLabel();
2271
2272 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, customArgs);
2273 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2274
2275 list = ReadTrace();
2276 traceInfo.type = 'B';
2277 isStartSuc = GetTraceResult(traceInfo, list, record);
2278 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2279 traceInfo.type = 'E';
2280 isFinishSuc = GetTraceResult(traceInfo, list, record);
2281 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2282
2283 GTEST_LOG_(INFO) << "HitraceMeterTest002: end.";
2284 }
2285
2286 /**
2287 * @tc.name: HitraceMeterTest003
2288 * @tc.desc: Testing HitraceScoped
2289 * @tc.type: FUNC
2290 */
2291 HWTEST_F(HitraceMeterTest, HitraceMeterTest003, TestSize.Level1)
2292 {
2293 GTEST_LOG_(INFO) << "HitraceMeterTest003: start.";
2294
2295 {
2296 HITRACE_METER(TAG);
2297 }
2298
2299 std::vector<std::string> list = ReadTrace();
2300 char record[RECORD_SIZE_MAX + 1] = {0};
2301 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, __func__, "", ""};
2302 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2303 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2304 traceInfo.type = 'E';
2305 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2306 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2307
2308 GTEST_LOG_(INFO) << "HitraceMeterTest003: end.";
2309 }
2310
2311 /**
2312 * @tc.name: HitraceMeterTest004
2313 * @tc.desc: Testing HitraceMeterFmtScoped
2314 * @tc.type: FUNC
2315 */
2316 HWTEST_F(HitraceMeterTest, HitraceMeterTest004, TestSize.Level1)
2317 {
2318 GTEST_LOG_(INFO) << "HitraceMeterTest004: start.";
2319
2320 const char* name = "HitraceMeterTest004-%d";
2321 int var = 4;
2322 // Each line contains 76 characters, and the longName has a total length of 458 characters.
2323 std::string longName = "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004";
2324 longName += "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004";
2325 longName += "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004";
2326 longName += "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004";
2327 longName += "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004";
2328 longName += "HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004HitraceMeterTest004-%d";
2329
2330 SetTraceDisabled(true);
2331 {
2332 HitraceMeterFmtScoped(TAG, name, var);
2333 }
2334 SetTraceDisabled(false);
2335
2336 std::vector<std::string> list = ReadTrace();
2337 bool isSuccess = FindResult("HitraceMeterTest004", list);
2338 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest004\" from trace.";
2339
2340 ASSERT_TRUE(CleanTrace());
2341 {
2342 HitraceMeterFmtScoped(TAG, longName.c_str(), var);
2343 }
2344
2345 list = ReadTrace();
2346 isSuccess = FindResult("HitraceMeterTest004", list);
2347 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest004\" from trace.";
2348
2349 ASSERT_TRUE(CleanTrace());
2350 {
2351 HitraceMeterFmtScoped(INVALID_TAG, name, var);
2352 }
2353
2354 list = ReadTrace();
2355 isSuccess = FindResult("HitraceMeterTest004", list);
2356 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest004\" from trace.";
2357
2358 ASSERT_TRUE(CleanTrace());
2359 {
2360 HITRACE_METER_FMT(TAG, name, var);
2361 }
2362
2363 list = ReadTrace();
2364 char record[RECORD_SIZE_MAX + 1] = {0};
2365 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, "HitraceMeterTest004-4", "", ""};
2366 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2367 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2368 traceInfo.type = 'E';
2369 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2370 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2371
2372 GTEST_LOG_(INFO) << "HitraceMeterTest004: end.";
2373 }
2374
2375 /**
2376 * @tc.name: HitraceMeterTest005
2377 * @tc.desc: Testing HitracePerfScoped
2378 * @tc.type: FUNC
2379 */
2380 HWTEST_F(HitraceMeterTest, HitraceMeterTest005, TestSize.Level1)
2381 {
2382 GTEST_LOG_(INFO) << "HitraceMeterTest005: start.";
2383
2384 std::string name = "HitraceMeterTest005";
2385 {
2386 HitracePerfScoped hitracePerfScoped(false, TAG, name);
2387 ASSERT_EQ(hitracePerfScoped.GetInsCount(), 0);
2388 ASSERT_EQ(hitracePerfScoped.GetCycleCount(), 0);
2389 }
2390
2391 std::vector<std::string> list = ReadTrace();
2392 bool isSuccess = FindResult("HitraceMeterTest005-Ins", list);
2393 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest005-Ins\" from trace.";
2394 isSuccess = FindResult("HitraceMeterTest005-Cycle", list);
2395 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest005-Cycle\" from trace.";
2396
2397 ASSERT_TRUE(CleanTrace());
2398 {
2399 HitracePerfScoped hitracePerfScoped(true, TAG, name);
2400 GTEST_LOG_(INFO) << hitracePerfScoped.GetInsCount();
2401 GTEST_LOG_(INFO) << hitracePerfScoped.GetCycleCount();
2402 }
2403
2404 list = ReadTrace();
2405 isSuccess = FindResult("HitraceMeterTest005-Ins", list);
2406 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"HitraceMeterTest005-Ins\" from trace.";
2407 isSuccess = FindResult("HitraceMeterTest005-Cycle", list);
2408 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"HitraceMeterTest005-Cycle\" from trace.";
2409
2410 GTEST_LOG_(INFO) << "HitraceMeterTest005: end.";
2411 }
2412
2413 /**
2414 * @tc.name: HitraceMeterTest006
2415 * @tc.desc: Testing HitraceScopedEx
2416 * @tc.type: FUNC
2417 */
2418 HWTEST_F(HitraceMeterTest, HitraceMeterTest006, TestSize.Level1)
2419 {
2420 GTEST_LOG_(INFO) << "HitraceMeterTest006: start.";
2421
2422 const char* customArgs = "key=value";
2423 {
2424 HITRACE_METER_EX(HITRACE_LEVEL_COMMERCIAL, TAG, customArgs);
2425 }
2426
2427 std::vector<std::string> list = ReadTrace();
2428 char record[RECORD_SIZE_MAX + 1] = {0};
2429 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, __func__, "", customArgs};
2430 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2431 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2432 traceInfo.type = 'E';
2433 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2434 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2435
2436 GTEST_LOG_(INFO) << "HitraceMeterTest006: end.";
2437 }
2438
2439 /**
2440 * @tc.name: HitraceMeterTest007
2441 * @tc.desc: Testing abnormal HiTraceOutputLevel
2442 * @tc.type: FUNC
2443 */
2444 HWTEST_F(HitraceMeterTest, HitraceMeterTest007, TestSize.Level2)
2445 {
2446 GTEST_LOG_(INFO) << "HitraceMeterTest007: start.";
2447
2448 const char* name = "HitraceMeterTest007";
2449 const char* customArgs = "key=value";
2450
2451 StartTraceEx(static_cast<HiTraceOutputLevel>(-1), TAG, name, customArgs);
2452 FinishTraceEx(static_cast<HiTraceOutputLevel>(-1), TAG);
2453 StartTraceEx(static_cast<HiTraceOutputLevel>(4), TAG, name, customArgs);
2454 FinishTraceEx(static_cast<HiTraceOutputLevel>(4), TAG);
2455
2456 std::vector<std::string> list = ReadTrace();
2457 bool isSuccess = FindResult("HitraceMeterTest007", list);
2458 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest007\" from trace.";
2459
2460 ASSERT_TRUE(CleanTrace());
2461 StartTraceEx(static_cast<HiTraceOutputLevel>(3), TAG, name, customArgs);
2462 FinishTraceEx(static_cast<HiTraceOutputLevel>(3), TAG);
2463
2464 list = ReadTrace();
2465 char record[RECORD_SIZE_MAX + 1] = {0};
2466 TraceInfo traceInfo = {'B', static_cast<HiTraceOutputLevel>(3), TAG, 0, name, "", customArgs};
2467 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2468 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2469 traceInfo.type = 'E';
2470 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2471 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2472
2473 GTEST_LOG_(INFO) << "HitraceMeterTest007: end.";
2474 }
2475
2476 /**
2477 * @tc.name: HitraceMeterTest008
2478 * @tc.desc: Testing MiddleTrace interface
2479 * @tc.type: FUNC
2480 */
2481 HWTEST_F(HitraceMeterTest, HitraceMeterTest008, TestSize.Level1)
2482 {
2483 GTEST_LOG_(INFO) << "HitraceMeterTest008: start.";
2484
2485 std::string nameBefore = "HitraceMeterTest008-before";
2486 std::string nameAfter = "HitraceMeterTest008-after";
2487
2488 StartTrace(TAG, nameBefore);
2489 MiddleTrace(TAG, nameBefore, nameAfter);
2490
2491 std::vector<std::string> list = ReadTrace();
2492 char record[RECORD_SIZE_MAX + 1] = {0};
2493 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, nameBefore.c_str(), "", ""};
2494 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2495 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2496 traceInfo.name = nameAfter.c_str();
2497 isStartSuc = GetTraceResult(traceInfo, list, record);
2498 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2499 traceInfo.type = 'E';
2500 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2501 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2502
2503 FinishTrace(TAG);
2504
2505 GTEST_LOG_(INFO) << "HitraceMeterTest008: end.";
2506 }
2507
2508 /**
2509 * @tc.name: HitraceMeterTest009
2510 * @tc.desc: Testing MiddleTraceDebug interface
2511 * @tc.type: FUNC
2512 */
2513 HWTEST_F(HitraceMeterTest, HitraceMeterTest009, TestSize.Level1)
2514 {
2515 GTEST_LOG_(INFO) << "HitraceMeterTest009: start.";
2516
2517 std::string nameBefore = "HitraceMeterTest009-before";
2518 std::string nameAfter = "HitraceMeterTest009-after";
2519
2520 StartTrace(TAG, nameBefore);
2521 MiddleTraceDebug(false, TAG, nameBefore, nameAfter);
2522
2523 std::vector<std::string> list = ReadTrace();
2524 char record[RECORD_SIZE_MAX + 1] = {0};
2525 TraceInfo traceInfo = {'B', HITRACE_LEVEL_INFO, TAG, 0, nameBefore.c_str(), "", ""};
2526 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2527 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2528 traceInfo.name = nameAfter.c_str();
2529 isStartSuc = GetTraceResult(traceInfo, list, record);
2530 ASSERT_FALSE(isStartSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
2531 traceInfo.type = 'E';
2532 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2533 ASSERT_FALSE(isFinishSuc) << "Hitrace shouldn't find \"" << record << "\" from trace.";
2534
2535 MiddleTraceDebug(true, TAG, nameBefore, nameAfter);
2536
2537 list = ReadTrace();
2538 traceInfo.type = 'B';
2539 isStartSuc = GetTraceResult(traceInfo, list, record);
2540 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2541 traceInfo.type = 'E';
2542 isFinishSuc = GetTraceResult(traceInfo, list, record);
2543 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2544
2545 FinishTrace(TAG);
2546
2547 GTEST_LOG_(INFO) << "HitraceMeterTest009: end.";
2548 }
2549
2550 /**
2551 * @tc.name: HitraceMeterTest010
2552 * @tc.desc: Testing WriteOnceLog function
2553 * @tc.type: FUNC
2554 */
2555 HWTEST_F(HitraceMeterTest, HitraceMeterTest010, TestSize.Level1)
2556 {
2557 GTEST_LOG_(INFO) << "HitraceMeterTest010: start.";
2558
2559 bool isWrite = true;
2560 std::string logStr = "HitraceMeterTest010";
2561
2562 SetWriteOnceLog(LOG_INFO, logStr, isWrite);
2563 ASSERT_TRUE(isWrite);
2564
2565 isWrite = false;
2566 SetWriteOnceLog(LOG_INFO, logStr, isWrite);
2567 ASSERT_TRUE(isWrite);
2568
2569 isWrite = false;
2570 SetWriteOnceLog(LOG_ERROR, logStr, isWrite);
2571 ASSERT_TRUE(isWrite);
2572
2573 isWrite = false;
2574 SetWriteOnceLog(LOG_DEBUG, logStr, isWrite);
2575 ASSERT_TRUE(isWrite);
2576
2577 GTEST_LOG_(INFO) << "HitraceMeterTest010: end.";
2578 }
2579
2580 /**
2581 * @tc.name: HitraceMeterTest011
2582 * @tc.desc: Testing MiddleTraceDebug interface
2583 * @tc.type: FUNC
2584 */
2585 HWTEST_F(HitraceMeterTest, HitraceMeterTest011, TestSize.Level1)
2586 {
2587 GTEST_LOG_(INFO) << "HitraceMeterTest011: start.";
2588
2589 const char* name = "HitraceMeterTest011";
2590 int64_t count = 11;
2591
2592 SetReloadPid(true);
2593 SetpidHasReload(true);
2594 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
2595
2596 std::vector<std::string> list = ReadTrace();
2597 char record[RECORD_SIZE_MAX + 1] = {0};
2598 TraceInfo traceInfo = {'C', HITRACE_LEVEL_COMMERCIAL, TAG, count, name, "", ""};
2599 bool isSuccess = GetTraceResult(traceInfo, list, record);
2600 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
2601
2602 ASSERT_TRUE(CleanTrace());
2603 SetReloadPid(false);
2604 SetpidHasReload(false);
2605 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
2606
2607 list = ReadTrace();
2608 isSuccess = GetTraceResult(traceInfo, list, record);
2609 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
2610
2611 ASSERT_TRUE(CleanTrace());
2612 SetReloadPid(true);
2613 SetpidHasReload(false);
2614 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
2615
2616 list = ReadTrace();
2617 isSuccess = GetTraceResult(traceInfo, list, record);
2618 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
2619
2620 ASSERT_TRUE(CleanTrace());
2621 SetReloadPid(false);
2622 SetpidHasReload(true);
2623 CountTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, count);
2624
2625 list = ReadTrace();
2626 isSuccess = GetTraceResult(traceInfo, list, record);
2627 ASSERT_TRUE(isSuccess) << "Hitrace can't find \"" << record << "\" from trace.";
2628
2629 GTEST_LOG_(INFO) << "HitraceMeterTest011: end.";
2630 }
2631
2632 /**
2633 * @tc.name: HitraceMeterTest012
2634 * @tc.desc: Testing HitraceMeterFmtScopedEx
2635 * @tc.type: FUNC
2636 */
2637 HWTEST_F(HitraceMeterTest, HitraceMeterTest012, TestSize.Level1)
2638 {
2639 GTEST_LOG_(INFO) << "HitraceMeterTest012: start.";
2640
2641 const char* name = "HitraceMeterTest012-%d";
2642 int var = 12;
2643 // Each line contains 76 characters, and the longName has a total length of 459 characters.
2644 std::string longName = "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012";
2645 longName += "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012";
2646 longName += "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012";
2647 longName += "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012";
2648 longName += "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012";
2649 longName += "HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012HitraceMeterTest012-%d";
2650
2651 SetTraceDisabled(true);
2652 {
2653 HitraceMeterFmtScopedEx(HITRACE_LEVEL_COMMERCIAL, TAG, "", name, var);
2654 }
2655 SetTraceDisabled(false);
2656
2657 std::vector<std::string> list = ReadTrace();
2658 bool isSuccess = FindResult("HitraceMeterTest012", list);
2659 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest012\" from trace.";
2660
2661 ASSERT_TRUE(CleanTrace());
2662 {
2663 HitraceMeterFmtScopedEx(HITRACE_LEVEL_COMMERCIAL, TAG, "", longName.c_str(), var);
2664 }
2665
2666 list = ReadTrace();
2667 isSuccess = FindResult("HitraceMeterTest012", list);
2668 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest012\" from trace.";
2669
2670 ASSERT_TRUE(CleanTrace());
2671 {
2672 HitraceMeterFmtScopedEx(HITRACE_LEVEL_COMMERCIAL, INVALID_TAG, "", name, var);
2673 }
2674
2675 list = ReadTrace();
2676 isSuccess = FindResult("HitraceMeterTest012", list);
2677 ASSERT_FALSE(isSuccess) << "Hitrace shouldn't find \"HitraceMeterTest012\" from trace.";
2678
2679 ASSERT_TRUE(CleanTrace());
2680 {
2681 HITRACE_METER_FMT_EX(HITRACE_LEVEL_COMMERCIAL, TAG, "", name, var);
2682 }
2683
2684 list = ReadTrace();
2685 char record[RECORD_SIZE_MAX + 1] = {0};
2686 TraceInfo traceInfo = {'B', HITRACE_LEVEL_COMMERCIAL, TAG, 0, "HitraceMeterTest012-12", "", ""};
2687 bool isStartSuc = GetTraceResult(traceInfo, list, record);
2688 ASSERT_TRUE(isStartSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2689 traceInfo.type = 'E';
2690 bool isFinishSuc = GetTraceResult(traceInfo, list, record);
2691 ASSERT_TRUE(isFinishSuc) << "Hitrace can't find \"" << record << "\" from trace.";
2692
2693 GTEST_LOG_(INFO) << "HitraceMeterTest012: end.";
2694 }
2695
2696 /**
2697 * @tc.name: HitraceMeterTest013
2698 * @tc.desc: Testing HitraceMeter Interface performance
2699 * @tc.type: FUNC
2700 */
2701 HWTEST_F(HitraceMeterTest, HitraceMeterTest013, TestSize.Level1)
2702 {
2703 GTEST_LOG_(INFO) << "HitraceMeterTest013: start.";
2704 constexpr int printRepeat = 100000;
2705 constexpr int printCostLimit = 10; // 10 us per pair
2706 constexpr int msToUs = 1000;
2707 const char* name = "HitraceMeterTest013";
2708 auto startTime = std::chrono::high_resolution_clock::now();
2709 for (int i = 0; i < printRepeat; ++i) {
2710 StartTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG, name, nullptr);
2711 FinishTraceEx(HITRACE_LEVEL_COMMERCIAL, TAG);
2712 }
2713 auto endTime = std::chrono::high_resolution_clock::now();
2714 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
2715 GTEST_LOG_(INFO) << "HitraceMeterTest013: StartTraceEx and FinishTraceEx took " << duration << " ms for " <<
2716 printRepeat << " times.";
2717 ASSERT_LE(duration, 2 * printCostLimit * printRepeat / msToUs) <<
2718 "HitraceMeterTest013: StartTraceEx and FinishTraceEx took too long.";
2719 startTime = std::chrono::high_resolution_clock::now();
2720 for (int i = 0; i < printRepeat; ++i) {
2721 StartTrace(TAG | HITRACE_TAG_COMMERCIAL, name);
2722 FinishTrace(TAG | HITRACE_TAG_COMMERCIAL);
2723 }
2724 endTime = std::chrono::high_resolution_clock::now();
2725 duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
2726 GTEST_LOG_(INFO) << "HitraceMeterTest013: StartTrace and FinishTrace with OHOS and COMMERCIAL took " <<
2727 duration << " ms for "<< printRepeat << " times.";
2728 ASSERT_LE(duration, 2 * printCostLimit * printRepeat / msToUs) <<
2729 "HitraceMeterTest013: StartTrace and FinishTrace with Commercial Tag took too long.";
2730 startTime = std::chrono::high_resolution_clock::now();
2731 for (int i = 0; i < printRepeat; ++i) {
2732 StartTrace(TAG, name);
2733 FinishTrace(TAG);
2734 }
2735 endTime = std::chrono::high_resolution_clock::now();
2736 duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
2737 GTEST_LOG_(INFO) << "HitraceMeterTest013: StartTrace and FinishTrace with OHOS took " << duration <<
2738 " ms for " << printRepeat << " times.";
2739 ASSERT_LE(duration, 2 * printCostLimit * printRepeat / msToUs) <<
2740 "HitraceMeterTest013: StartTrace and FinishTrace took too long.";
2741 }
2742 }
2743 }
2744 }
2745