1 /*
2 * Copyright (c) 2025 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 <charconv>
17 #include <gtest/gtest.h>
18
19 #include "app_caller_event.h"
20 #include "file_util.h"
21 #include "trace_common.h"
22 #include "trace_flow_controller.h"
23 #include "trace_state_machine.h"
24 #include "time_util.h"
25
26 using namespace testing::ext;
27 namespace OHOS {
28 namespace HiviewDFX {
29 namespace {
30 const std::string TEST_DB_PATH = "/data/test/trace_storage_test/";
31 const std::vector<std::string> TAG_GROUPS = {"scene_performance"};
32
InnerCreateAppCallerEvent(int32_t uid,uint64_t happendTime)33 std::shared_ptr<AppCallerEvent> InnerCreateAppCallerEvent(int32_t uid, uint64_t happendTime)
34 {
35 std::shared_ptr<AppCallerEvent> appCallerEvent = std::make_shared<AppCallerEvent>("HiViewService");
36 appCallerEvent->messageType_ = Event::MessageType::PLUGIN_MAINTENANCE;
37 appCallerEvent->eventName_ = "DUMP_APP_TRACE";
38 appCallerEvent->isBusinessJank_ = false;
39 appCallerEvent->bundleName_ = "com.example.helloworld";
40 appCallerEvent->bundleVersion_ = "2.0.1";
41 appCallerEvent->uid_ = uid;
42 appCallerEvent->pid_ = 1000;
43 appCallerEvent->happenTime_ = happendTime;
44 appCallerEvent->beginTime_ = 0;
45 appCallerEvent->endTime_ = 0;
46 appCallerEvent->taskBeginTime_ = static_cast<int64_t>(TimeUtil::GetMilliseconds());
47 appCallerEvent->taskEndTime_ = appCallerEvent->taskBeginTime_;
48 appCallerEvent->resultCode_ = 0;
49 appCallerEvent->foreground_ = 1;
50 appCallerEvent->threadName_ = "mainThread";
51 return appCallerEvent;
52 }
53 }
54 class TraceManagerTest : public testing::Test {
55 public:
SetUp()56 void SetUp() {};
57
TearDown()58 void TearDown() {};
59
SetUpTestCase()60 static void SetUpTestCase()
61 {
62 if (!FileUtil::FileExists(TEST_DB_PATH)) {
63 FileUtil::ForceCreateDirectory(TEST_DB_PATH);
64 std::cout << "create path:" << TEST_DB_PATH << std::endl;
65 }
66 };
67
TearDownTestCase()68 static void TearDownTestCase()
69 {
70 if (FileUtil::FileExists(TEST_DB_PATH)) {
71 FileUtil::ForceRemoveDirectory(TEST_DB_PATH);
72 std::cout << "clear path:" << TEST_DB_PATH << std::endl;
73 }
74 };
75 };
76
77 /**
78 * @tc.name: TraceManagerTest001
79 * @tc.desc: used to test TraceFlowControl api: NeedUpload NeedDump
80 * @tc.type: FUNC
81 */
82 HWTEST_F(TraceManagerTest, TraceManagerTest001, TestSize.Level1)
83 {
84 auto flowController1 = std::make_shared<TraceFlowController>(CallerName::XPOWER, TEST_DB_PATH);
85 int64_t traceSize1 = 699 * 1024 * 1024; // xpower trace Threshold is 700M
86 ASSERT_TRUE(flowController1->NeedDump());
87 ASSERT_TRUE(flowController1->NeedUpload(traceSize1));
88 flowController1->StoreDb();
89
90 sleep(1);
91 auto flowController2 = std::make_shared<TraceFlowController>(CallerName::XPOWER, TEST_DB_PATH);
92 ASSERT_TRUE(flowController2->NeedDump());
93
94 // NeedUpload allow 10% over limits
95 int64_t traceSize2 = 15 * 1024 * 1024;
96 ASSERT_TRUE(flowController2->NeedUpload(traceSize2));
97 flowController2->StoreDb();
98
99 sleep(1);
100 auto flowController3 = std::make_shared<TraceFlowController>(CallerName::XPOWER, TEST_DB_PATH);
101 ASSERT_FALSE(flowController3->NeedDump());
102 }
103
104 /**
105 * @tc.name: TraceManagerTest002
106 * @tc.desc: used to test TraceFlowControl api: NeedUpload NeedDump
107 * @tc.type: FUNC
108 */
109 HWTEST_F(TraceManagerTest, TraceManagerTest002, TestSize.Level1)
110 {
111 auto flowController1 = std::make_shared<TraceFlowController>(CallerName::HIVIEW, TEST_DB_PATH);
112 int64_t traceSize1 = 349 * 1024 * 1024; // HIVIEW trace Threshold is 350M
113 ASSERT_TRUE(flowController1->NeedDump());
114 ASSERT_TRUE(flowController1->NeedUpload(traceSize1));
115 flowController1->StoreDb();
116 sleep(1);
117
118 auto flowController2 = std::make_shared<TraceFlowController>(CallerName::HIVIEW, TEST_DB_PATH);
119 ASSERT_TRUE(flowController2->NeedDump());
120 int64_t traceSize2 = 100 * 1024 * 1024;
121 ASSERT_FALSE(flowController2->NeedUpload(traceSize2));
122 flowController2->StoreDb();
123 }
124
125 /**
126 * @tc.name: TraceManagerTest003
127 * @tc.desc: used to test TraceFlowControl api: HasCallOnceToday CleanOldAppTrace RecordCaller
128 * @tc.type: FUNC
129 */
130 HWTEST_F(TraceManagerTest, TraceManagerTest003, TestSize.Level1)
131 {
132 auto flowController1 = std::make_shared<TraceFlowController>(ClientName::APP, TEST_DB_PATH);
133 int32_t appid1 = 100;
134 uint64_t happenTime1 = TimeUtil::GetMilliseconds() - 10000; // 10 seconds ago
135 auto appEvent1 = InnerCreateAppCallerEvent(appid1, happenTime1);
136 ASSERT_FALSE(flowController1->HasCallOnceToday(appid1, happenTime1));
137 flowController1->RecordCaller(appEvent1);
138 sleep(1);
139
140 auto flowController21 = std::make_shared<TraceFlowController>(ClientName::APP, TEST_DB_PATH);
141 uint64_t happenTime2 = TimeUtil::GetMilliseconds() - 5000; // 5 seconds ago
142 auto appEvent21 = InnerCreateAppCallerEvent(appid1, happenTime2);
143 ASSERT_TRUE(flowController21->HasCallOnceToday(appid1, happenTime2));
144 flowController21->RecordCaller(appEvent21);
145 sleep(1);
146
147 auto flowController22 = std::make_shared<TraceFlowController>(ClientName::APP, TEST_DB_PATH);
148 int32_t appid2 = 101;
149 ASSERT_FALSE(flowController22->HasCallOnceToday(appid2, happenTime2));
150 auto appEvent22 = InnerCreateAppCallerEvent(appid2, happenTime2);
151 flowController22->RecordCaller(appEvent22);
152
153 sleep(1);
154 std::string date = TimeUtil::TimestampFormatToDate(TimeUtil::GetSeconds(), "%Y%m%d");
155 int32_t dateNum = 0;
156 auto result = std::from_chars(date.c_str(), date.c_str() + date.size(), dateNum);
157 ASSERT_EQ(result.ec, std::errc());
158 flowController22->CleanOldAppTrace(dateNum + 1);
159
160 sleep(1);
161 auto flowController23 = std::make_shared<TraceFlowController>(ClientName::APP, TEST_DB_PATH);
162 ASSERT_FALSE(flowController22->HasCallOnceToday(appid1, TimeUtil::GetMilliseconds()));
163 ASSERT_FALSE(flowController22->HasCallOnceToday(appid2, TimeUtil::GetMilliseconds()));
164 }
165
166 /**
167 * @tc.name: TraceManagerTest004
168 * @tc.desc: used to test TraceFlowControl api: UseCacheTimeQuota
169 * @tc.type: FUNC
170 */
171 HWTEST_F(TraceManagerTest, TraceManagerTest004, TestSize.Level1)
172 {
173 auto flowController = std::make_shared<TraceFlowController>("behavior", TEST_DB_PATH);
174 ASSERT_EQ(flowController->UseCacheTimeQuota(10), CacheFlow::SUCCESS);
175 sleep(1);
176 ASSERT_EQ(flowController->UseCacheTimeQuota(10 * 60), CacheFlow::SUCCESS);
177 sleep(1);
178 ASSERT_NE(flowController->UseCacheTimeQuota(10), CacheFlow::SUCCESS);
179 }
180
181 /**
182 * @tc.name: TraceManagerTest005
183 * @tc.desc: used to test TraceFlowControl api: Telemetry interface
184 * @tc.type: FUNC
185 */
186 HWTEST_F(TraceManagerTest, TraceManagerTest005, TestSize.Level1)
187 {
188 std::map<std::string, int64_t> flowControlQuotas {
189 {CallerName::XPERF, 10000 },
190 {CallerName::XPOWER, 12000},
191 {"Total", 18000}
192 };
193
194 std::map<std::string, int64_t> flowControlQuota2 {
195 {CallerName::XPERF, 100 },
196 {CallerName::XPOWER, 120},
197 {"Total", 180}
198 };
199
200 TraceFlowController flowController(BusinessName::TELEMETRY, TEST_DB_PATH);
201 int64_t beginTime = 100;
202 ASSERT_EQ(flowController.InitTelemetryData("id", beginTime, flowControlQuotas), TelemetryRet::SUCCESS);
203 sleep(1);
204 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPERF, 9000), TelemetryRet::SUCCESS);
205 sleep(1);
206 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPERF, 2000), TelemetryRet::OVER_FLOW);
207 sleep(1);
208 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPOWER, 7000), TelemetryRet::SUCCESS);
209 sleep(1);
210 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPOWER, 6000), TelemetryRet::OVER_FLOW);
211 sleep(1);
212 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPOWER, 1000), TelemetryRet::SUCCESS);
213 sleep(1);
214
215 // Total over flow
216 ASSERT_EQ(flowController.NeedTelemetryDump(CallerName::XPOWER, 2000), TelemetryRet::OVER_FLOW);
217 flowController.ClearTelemetryData();
218
219 // data is cleared
220 TraceFlowController flowController2(BusinessName::TELEMETRY, TEST_DB_PATH);
221 ASSERT_EQ(flowController2.InitTelemetryData("id", beginTime, flowControlQuotas), TelemetryRet::SUCCESS);
222 ASSERT_EQ(flowController2.NeedTelemetryDump(CallerName::XPOWER, 5000), TelemetryRet::SUCCESS);
223
224 // do not clear db
225 TraceFlowController flowController3(BusinessName::TELEMETRY, TEST_DB_PATH);
226
227 // Already init, old data still take effect
228 ASSERT_EQ(flowController2.InitTelemetryData("id", beginTime, flowControlQuota2), TelemetryRet::SUCCESS);
229
230 // flowControlQuota2 do not take effect
231 ASSERT_EQ(flowController2.NeedTelemetryDump(CallerName::XPOWER, 500), TelemetryRet::SUCCESS);
232 flowController.ClearTelemetryData();
233
234 // flowControlQuota2 take effect
235 TraceFlowController flowController4(BusinessName::TELEMETRY, TEST_DB_PATH);
236 ASSERT_EQ(flowController2.InitTelemetryData("id", beginTime, flowControlQuota2), TelemetryRet::SUCCESS);
237 ASSERT_EQ(flowController2.NeedTelemetryDump(CallerName::XPOWER, 500), TelemetryRet::OVER_FLOW);
238 }
239
240 /**
241 * @tc.name: TraceManagerTest005
242 * @tc.desc: used to test TraceFlowControl api: Telemetry interface
243 * @tc.type: FUNC
244 */
245 HWTEST_F(TraceManagerTest, TraceManagerTest006, TestSize.Level1)
246 {
247 std::map<std::string, int64_t> flowControlQuotas {
248 {CallerName::XPERF, 10000 },
249 {CallerName::XPOWER, 12000},
250 {"Total", 18000}
251 };
252 TraceFlowController flowController(BusinessName::TELEMETRY, TEST_DB_PATH);
253 int64_t btime1 = 100;
254 ASSERT_EQ(flowController.InitTelemetryData("id1", btime1, flowControlQuotas), TelemetryRet::SUCCESS);
255 ASSERT_EQ(btime1, 100);
256
257 // if data init, correct btime2 etime2 value
258 TraceFlowController flowController2(BusinessName::TELEMETRY, TEST_DB_PATH);
259 int64_t btime2 = 300;
260 ASSERT_EQ(flowController2.InitTelemetryData("id1", btime2, flowControlQuotas), TelemetryRet::SUCCESS);
261 ASSERT_EQ(btime2, 100);
262
263 // Id is different, insert btime21 etime22 and value is not change
264 int64_t btime21 = 300;
265 flowController2.InitTelemetryData("id2", btime2, flowControlQuotas);
266 ASSERT_EQ(btime21, 300);
267 flowController2.ClearTelemetryData();
268
269 TraceFlowController flowController3(BusinessName::TELEMETRY, TEST_DB_PATH);
270 int64_t btime3 = 500;
271 ASSERT_EQ(flowController2.InitTelemetryData("id1", btime3, flowControlQuotas), TelemetryRet::SUCCESS);
272 ASSERT_EQ(btime3, 500);
273 }
274
275 /**
276 * @tc.name: TraceManagerTest007
277 * @tc.desc: used to test TraceStateMachine command state
278 * @tc.type: FUNC
279 */
280 HWTEST_F(TraceManagerTest, TraceManagerTest007, TestSize.Level1)
281 {
282 // TraceStateMachine init close state
283 TraceRet ret = TraceStateMachine::GetInstance().InitOrUpdateState();
284 ASSERT_TRUE(ret.IsSuccess());
285 TraceRet ret1 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
286 ASSERT_TRUE(ret1.IsSuccess());
287
288 // trans to command state
289 TraceRetInfo info;
290 TraceRet ret2 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
291 ASSERT_TRUE(ret2.IsSuccess());
292 TraceRet ret3 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
293 ASSERT_EQ(ret3.stateError_, TraceStateCode::FAIL);
294 TraceRet ret40 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
295 ASSERT_EQ(ret40.stateError_, TraceStateCode::FAIL);
296 TraceRet ret4 = TraceStateMachine::GetInstance().TraceCacheOn();
297 ASSERT_EQ(ret4.stateError_, TraceStateCode::FAIL);
298 TraceRet ret5 = TraceStateMachine::GetInstance().TraceCacheOff();
299 ASSERT_EQ(ret5.stateError_, TraceStateCode::FAIL);
300 TraceRet ret6 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
301 ASSERT_EQ(ret6.stateError_, TraceStateCode::FAIL);
302 TraceRet ret28 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
303 ASSERT_EQ(ret28.stateError_, TraceStateCode::FAIL);
304 TraceRet ret29 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
305 ASSERT_EQ(ret29.stateError_, TraceStateCode::FAIL);
306 TraceRet ret61 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
307 ASSERT_EQ(ret61.stateError_, TraceStateCode::FAIL);
308 TraceRet ret7 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
309 ASSERT_TRUE(ret7.IsSuccess());
310
311 // trans to command drop state
312 TraceRet ret8 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
313 ASSERT_EQ(ret8.stateError_, TraceStateCode::FAIL);
314 TraceRet ret9 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
315 ASSERT_EQ(ret9.stateError_, TraceStateCode::FAIL);
316 TraceRet ret10 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
317 ASSERT_EQ(ret10.stateError_, TraceStateCode::FAIL);
318 TraceRet ret41 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
319 ASSERT_EQ(ret41.stateError_, TraceStateCode::FAIL);
320 TraceRet ret20 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
321 ASSERT_EQ(ret20.stateError_, TraceStateCode::FAIL);
322 TraceRet ret21 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC);
323 ASSERT_EQ(ret21.stateError_, TraceStateCode::FAIL);
324 TraceRet ret50 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_TELEMETRY);
325 ASSERT_EQ(ret50.stateError_, TraceStateCode::FAIL);
326 TraceRet ret22 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
327 ASSERT_TRUE(ret22.IsSuccess());
328
329 // trans to close state
330 TraceRet ret31 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
331 ASSERT_TRUE(ret31.IsSuccess());
332 TraceRet ret30 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
333 ASSERT_TRUE(ret30.IsSuccess());
334
335 // trans to command drop state
336 TraceRet ret25 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
337 ASSERT_EQ(ret25.stateError_, TraceStateCode::DENY);
338 TraceRet ret26 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
339 ASSERT_EQ(ret26.stateError_, TraceStateCode::DENY);
340 TraceRet ret27 = TraceStateMachine::GetInstance().OpenDynamicTrace(100);
341 ASSERT_EQ(ret27.stateError_, TraceStateCode::DENY);
342 TraceRet ret11 = TraceStateMachine::GetInstance().TraceCacheOn();
343 ASSERT_EQ(ret11.stateError_, TraceStateCode::FAIL);
344 TraceRet ret12 = TraceStateMachine::GetInstance().TraceCacheOff();
345 ASSERT_EQ(ret12.stateError_, TraceStateCode::FAIL);
346 TraceRet ret13 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
347 ASSERT_EQ(ret13.stateError_, TraceStateCode::FAIL);
348 TraceRet ret14 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
349 ASSERT_TRUE(ret14.IsSuccess());
350
351 // trans to command state
352 TraceRet ret24 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
353 ASSERT_EQ(ret24.stateError_, TraceStateCode::DENY);
354 TraceRet ret15 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
355 ASSERT_EQ(ret15.stateError_, TraceStateCode::DENY);
356 TraceRet ret23 = TraceStateMachine::GetInstance().OpenDynamicTrace(100);
357 ASSERT_EQ(ret23.stateError_, TraceStateCode::DENY);
358 TraceRet ret17 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
359 ASSERT_EQ(ret17.stateError_, TraceStateCode::FAIL);
360 TraceRet ret51 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_TELEMETRY);
361 ASSERT_EQ(ret51.stateError_, TraceStateCode::FAIL);
362 TraceRet ret18 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC);
363 ASSERT_EQ(ret18.stateError_, TraceStateCode::FAIL);
364 TraceRet ret19 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
365 ASSERT_TRUE(ret19.IsSuccess());
366 }
367
368 /**
369 * @tc.name: TraceManagerTest008
370 * @tc.desc: used to test TraceStateMachine common state
371 * @tc.type: FUNC
372 */
373 HWTEST_F(TraceManagerTest, TraceManagerTest008, TestSize.Level1)
374 {
375 // TraceStateMachine init close state
376 TraceRet ret = TraceStateMachine::GetInstance().InitOrUpdateState();
377 ASSERT_TRUE(ret.IsSuccess());
378 TraceRet ret1 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
379 ASSERT_TRUE(ret1.IsSuccess());
380
381 // trans to common state
382 TraceRetInfo info;
383 TraceRet ret2 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
384 ASSERT_TRUE(ret2.IsSuccess());
385 TraceRet ret3 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
386 ASSERT_TRUE(ret3.IsSuccess());
387 TraceRet ret4 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
388 ASSERT_EQ(ret4.stateError_, TraceStateCode::FAIL);
389 TraceRet ret41 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
390 ASSERT_EQ(ret41.stateError_, TraceStateCode::FAIL);
391 TraceRet ret5 = TraceStateMachine::GetInstance().TraceCacheOn();
392 ASSERT_TRUE(ret5.IsSuccess());
393 TraceRet ret6 = TraceStateMachine::GetInstance().TraceCacheOff();
394 ASSERT_TRUE(ret6.IsSuccess());
395 TraceRet ret61 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
396 ASSERT_EQ(ret61.stateError_, TraceStateCode::FAIL);
397 TraceRet ret71 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
398 ASSERT_EQ(ret71.stateError_, TraceStateCode::FAIL);
399 TraceRet ret7 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
400 ASSERT_EQ(ret7.stateError_, TraceStateCode::FAIL);
401 TraceRet ret8 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
402 ASSERT_TRUE(ret8.IsSuccess());
403
404 // trans to common drop state
405 TraceRet ret9 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
406 ASSERT_EQ(ret9.stateError_, TraceStateCode::FAIL);
407 TraceRet ret10 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
408 ASSERT_EQ(ret10.stateError_, TraceStateCode::FAIL);
409 TraceRet ret11 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
410 ASSERT_EQ(ret11.stateError_, TraceStateCode::FAIL);
411 TraceRet ret42 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
412 ASSERT_EQ(ret42.stateError_, TraceStateCode::FAIL);
413 TraceRet ret12 = TraceStateMachine::GetInstance().TraceCacheOn();
414 ASSERT_EQ(ret12.stateError_, TraceStateCode::FAIL);
415 TraceRet ret13 = TraceStateMachine::GetInstance().TraceCacheOff();
416 ASSERT_EQ(ret13.stateError_, TraceStateCode::FAIL);
417 TraceRet ret14 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
418 ASSERT_EQ(ret14.stateError_, TraceStateCode::FAIL);
419 TraceRet ret15 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
420 ASSERT_EQ(ret15.stateError_, TraceStateCode::FAIL);
421 TraceRet ret23 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
422 ASSERT_EQ(ret23.stateError_, TraceStateCode::DENY);
423 TraceRet ret24 = TraceStateMachine::GetInstance().OpenDynamicTrace(100);
424 ASSERT_EQ(ret24.stateError_, TraceStateCode::DENY);
425 TraceRet ret25 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
426 ASSERT_TRUE(ret25.IsSuccess());
427
428 // trans to command state
429 TraceStateMachine::GetInstance().SetTraceSwitchUcOn();
430 TraceRet ret21 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
431 ASSERT_TRUE(ret21.IsSuccess());
432 TraceRet ret22 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
433 ASSERT_TRUE(ret22.IsSuccess());
434
435 // trans to common state
436 TraceRet ret34 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
437 ASSERT_TRUE(ret34.IsSuccess());
438
439 // trans to common drop state
440 TraceRet ret26 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
441 ASSERT_EQ(ret26.stateError_, TraceStateCode::FAIL);
442 TraceRet ret51 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_TELEMETRY);
443 ASSERT_EQ(ret51.stateError_, TraceStateCode::FAIL);
444 TraceRet ret27 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC);
445 ASSERT_EQ(ret27.stateError_, TraceStateCode::FAIL);
446 TraceRet ret28 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
447 ASSERT_EQ(ret28.stateError_, TraceStateCode::FAIL);
448 TraceRet ret16 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
449 ASSERT_EQ(ret16.stateError_, TraceStateCode::FAIL);
450 TraceRet ret17 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
451 ASSERT_TRUE(ret17.IsSuccess());
452
453 // trans to common state
454 TraceRet ret18 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
455 ASSERT_EQ(ret18.stateError_, TraceStateCode::DENY);
456 TraceRet ret19 = TraceStateMachine::GetInstance().OpenDynamicTrace(100);
457 ASSERT_EQ(ret19.stateError_, TraceStateCode::DENY);
458 TraceRet ret20 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
459 ASSERT_TRUE(ret20.IsSuccess());
460
461 // trans to command state
462 TraceRet ret32 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
463 ASSERT_TRUE(ret32.IsSuccess());
464 TraceRet ret33 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
465 ASSERT_TRUE(ret33.IsSuccess());
466
467 // trans to common state again
468 TraceRet ret30 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC);
469 ASSERT_EQ(ret30.stateError_, TraceStateCode::FAIL);
470 TraceRet ret29 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
471 ASSERT_TRUE(ret29.IsSuccess());
472
473 // still recover to common state
474 TraceRet ret31 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
475 ASSERT_TRUE(ret31.IsSuccess());
476
477 // close version beta and trans to close state
478 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOn();
479 TraceStateMachine::GetInstance().InitOrUpdateState();
480
481 // trans to common state
482 TraceRet ret35 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
483 ASSERT_TRUE(ret35.IsSuccess());
484
485 // still recover to common state
486 TraceRet ret36 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
487 ASSERT_TRUE(ret36.IsSuccess());
488 TraceStateMachine::GetInstance().SetTraceSwitchFreezeOff();
489 TraceStateMachine::GetInstance().SetTraceSwitchUcOff();
490 }
491
492 /**
493 * @tc.name: TraceManagerTest009
494 * @tc.desc: used to test TraceStateMachine telemetry state
495 * @tc.type: FUNC
496 */
497 HWTEST_F(TraceManagerTest, TraceManagerTest009, TestSize.Level1)
498 {
499 // TraceStateMachine init close state
500 TraceRet ret = TraceStateMachine::GetInstance().InitOrUpdateState();
501 ASSERT_TRUE(ret.IsSuccess());
502 TraceRet ret1 = TraceStateMachine::GetInstance().OpenTelemetryTrace("");
503 ASSERT_TRUE(ret1.IsSuccess());
504
505 // Trans to telemetry state
506 TraceRetInfo info;
507 TraceRet ret2 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
508 ASSERT_EQ(ret2.stateError_, TraceStateCode::FAIL);
509 TraceRet ret3 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
510 ASSERT_EQ(ret3.stateError_, TraceStateCode::FAIL);
511 TraceRet ret4 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
512 ASSERT_EQ(ret4.stateError_, TraceStateCode::FAIL);
513 TraceRet ret11 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
514 ASSERT_TRUE(ret11.IsSuccess());
515 TraceRet ret5 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
516 ASSERT_EQ(ret5.stateError_, TraceStateCode::FAIL);
517 TraceRet ret6 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
518 ASSERT_EQ(ret6.stateError_, TraceStateCode::FAIL);
519 TraceRet ret7 = TraceStateMachine::GetInstance().TraceCacheOn();
520 ASSERT_EQ(ret7.stateError_, TraceStateCode::FAIL);
521 TraceRet ret8 = TraceStateMachine::GetInstance().TraceCacheOff();
522 ASSERT_EQ(ret8.stateError_, TraceStateCode::FAIL);
523 TraceRet ret9 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
524 ASSERT_EQ(ret9.stateError_, TraceStateCode::FAIL);
525 TraceRet ret10 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
526 ASSERT_EQ(ret10.stateError_, TraceStateCode::FAIL);
527 TraceRet ret26 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
528 ASSERT_EQ(ret26.stateError_, TraceStateCode::FAIL);
529 TraceRet ret27 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC);
530 ASSERT_EQ(ret27.stateError_, TraceStateCode::FAIL);
531 TraceRet ret28 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
532 ASSERT_EQ(ret28.stateError_, TraceStateCode::FAIL);
533 TraceRet ret51 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_TELEMETRY);
534 ASSERT_TRUE(ret51.IsSuccess());
535
536 // Trans to close state
537 TraceRet ret15 = TraceStateMachine::GetInstance().OpenDynamicTrace(101);
538 ASSERT_TRUE(ret15.IsSuccess());
539
540 // APP state to telemetry state success
541 TraceRet ret16 = TraceStateMachine::GetInstance().OpenTelemetryTrace("");
542 ASSERT_TRUE(ret16.IsSuccess());
543
544 // Trans to telemetry state
545 TraceRet ret17 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
546 ASSERT_TRUE(ret17.IsSuccess());
547
548 // Common state to telemetry deny
549 TraceRet ret18 = TraceStateMachine::GetInstance().OpenTelemetryTrace("");
550 ASSERT_EQ(ret18.GetStateError(), TraceStateCode::DENY);
551 TraceRet ret19 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
552 ASSERT_TRUE(ret19.IsSuccess());
553
554 // Trans to close state
555 TraceRet ret20 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
556 ASSERT_TRUE(ret20.IsSuccess());
557
558 // Command state to telemetry deny
559 TraceRet ret21 = TraceStateMachine::GetInstance().OpenTelemetryTrace("");
560 ASSERT_EQ(ret21.GetStateError(), TraceStateCode::DENY);
561 }
562
563 /**
564 * @tc.name: TraceManagerTest010
565 * @tc.desc: used to test TraceStateMachine app state
566 * @tc.type: FUNC
567 */
568 HWTEST_F(TraceManagerTest, TraceManagerTest010, TestSize.Level1)
569 {
570 // TraceStateMachine init close state
571 TraceRet ret = TraceStateMachine::GetInstance().InitOrUpdateState();
572 ASSERT_TRUE(ret.IsSuccess());
573 TraceRet ret1 = TraceStateMachine::GetInstance().OpenDynamicTrace(100);
574 ASSERT_TRUE(ret1.IsSuccess());
575
576 // Trans to app state
577 ASSERT_EQ(TraceStateMachine::GetInstance().GetCurrentAppPid(), 100);
578 ASSERT_GT(TraceStateMachine::GetInstance().GetTaskBeginTime(), 0);
579 TraceRetInfo info;
580 TraceRet ret2 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
581 ASSERT_EQ(ret2.stateError_, TraceStateCode::FAIL);
582 TraceRet ret3 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
583 ASSERT_EQ(ret3.stateError_, TraceStateCode::FAIL);
584 TraceRet ret4 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
585 ASSERT_EQ(ret4.GetStateError(), TraceStateCode::SUCCESS);
586 TraceRet ret42 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
587 ASSERT_EQ(ret42.stateError_, TraceStateCode::FAIL);
588 TraceRet ret5 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
589 ASSERT_EQ(ret5.stateError_, TraceStateCode::FAIL);
590 TraceRet ret6 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
591 ASSERT_EQ(ret6.stateError_, TraceStateCode::FAIL);
592 TraceRet ret7 = TraceStateMachine::GetInstance().TraceCacheOn();
593 ASSERT_EQ(ret7.stateError_, TraceStateCode::FAIL);
594 TraceRet ret8 = TraceStateMachine::GetInstance().TraceCacheOff();
595 ASSERT_EQ(ret8.stateError_, TraceStateCode::FAIL);
596 TraceRet ret9 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
597 ASSERT_EQ(ret9.stateError_, TraceStateCode::FAIL);
598 TraceRet ret10 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
599 ASSERT_EQ(ret10.stateError_, TraceStateCode::FAIL);
600 TraceRet ret11 = TraceStateMachine::GetInstance().OpenDynamicTrace(101);
601 ASSERT_EQ(ret11.stateError_, TraceStateCode::DENY);
602 TraceRet ret12 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMAND, TAG_GROUPS);
603 ASSERT_TRUE(ret12.IsSuccess());
604
605 // Trans to command state
606 TraceRet ret13 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
607 ASSERT_TRUE(ret13.IsSuccess());
608 TraceRet ret14 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND);
609 ASSERT_TRUE(ret14.IsSuccess());
610
611 // Trans to close state
612 TraceRet ret15 = TraceStateMachine::GetInstance().OpenDynamicTrace(101);
613 ASSERT_TRUE(ret15.IsSuccess());
614
615 // Trans to app state again
616 ASSERT_EQ(TraceStateMachine::GetInstance().GetCurrentAppPid(), 101);
617 TraceRet ret16 = TraceStateMachine::GetInstance().OpenTrace(TraceScenario::TRACE_COMMON, TAG_GROUPS);
618 ASSERT_TRUE(ret16.IsSuccess());
619
620 // Trans to common state
621 TraceRet ret17 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
622 ASSERT_TRUE(ret17.IsSuccess());
623 TraceRet ret18 = TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON);
624 ASSERT_TRUE(ret18.IsSuccess());
625 }
626
627 /**
628 * @tc.name: TraceManagerTest011
629 * @tc.desc: used to test TraceStateMachine close state
630 * @tc.type: FUNC
631 */
632 HWTEST_F(TraceManagerTest, TraceManagerTest011, TestSize.Level1)
633 {
634 // TraceStateMachine init close state
635 TraceRet ret = TraceStateMachine::GetInstance().InitOrUpdateState();
636 ASSERT_TRUE(ret.IsSuccess());
637 TraceRetInfo info;
638 TraceRet ret2 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMAND, 0, 0, info);
639 ASSERT_EQ(ret2.stateError_, TraceStateCode::FAIL);
640 TraceRet ret3 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_COMMON, 0, 0, info);
641 ASSERT_EQ(ret3.stateError_, TraceStateCode::FAIL);
642 TraceRet ret4 = TraceStateMachine::GetInstance().DumpTrace(TraceScenario::TRACE_DYNAMIC, 0, 0, info);
643 ASSERT_EQ(ret4.stateError_, TraceStateCode::FAIL);
644 TraceRet ret42 = TraceStateMachine::GetInstance().DumpTraceWithFilter({}, 0, 0, info);
645 ASSERT_EQ(ret42.stateError_, TraceStateCode::FAIL);
646 TraceRet ret5 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMAND);
647 ASSERT_EQ(ret5.stateError_, TraceStateCode::FAIL);
648 TraceRet ret6 = TraceStateMachine::GetInstance().TraceDropOn(TraceScenario::TRACE_COMMON);
649 ASSERT_EQ(ret6.stateError_, TraceStateCode::FAIL);
650 TraceRet ret7 = TraceStateMachine::GetInstance().TraceCacheOn();
651 ASSERT_EQ(ret7.stateError_, TraceStateCode::FAIL);
652 TraceRet ret8 = TraceStateMachine::GetInstance().TraceCacheOff();
653 ASSERT_EQ(ret8.stateError_, TraceStateCode::FAIL);
654 TraceRet ret9 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMAND, info);
655 ASSERT_EQ(ret9.stateError_, TraceStateCode::FAIL);
656 TraceRet ret10 = TraceStateMachine::GetInstance().TraceDropOff(TraceScenario::TRACE_COMMON, info);
657 ASSERT_EQ(ret10.stateError_, TraceStateCode::FAIL);
658 ASSERT_TRUE(TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMAND).IsSuccess());
659 ASSERT_TRUE(TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_COMMON).IsSuccess());
660 ASSERT_TRUE(TraceStateMachine::GetInstance().CloseTrace(TraceScenario::TRACE_DYNAMIC).IsSuccess());
661 }
662 }
663 }
664