1 /*
2  * Copyright (c) 2023-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 #include <climits>
16 #include <gtest/gtest.h>
17 #include <iostream>
18 
19 #include "file_util.h"
20 #include "parameter_ex.h"
21 #include "trace_collector.h"
22 #include "trace_manager.h"
23 
24 using namespace testing::ext;
25 using namespace OHOS::HiviewDFX;
26 using namespace OHOS::HiviewDFX::UCollectUtil;
27 using namespace OHOS::HiviewDFX::UCollect;
28 
29 namespace {
30 TraceManager g_traceManager;
31 constexpr uint32_t TIME_0S = 0;
32 constexpr uint32_t TIME_10S = 10;
33 constexpr uint32_t TIME_20S = 20;
34 constexpr uint32_t TIME_30S = 30;
35 }
36 
37 class TraceCollectorTest : public testing::Test {
38 public:
SetUp()39     void SetUp() {};
TearDown()40     void TearDown() {};
SetUpTestCase()41     static void SetUpTestCase() {};
TearDownTestCase()42     static void TearDownTestCase() {};
43 };
44 
45 /**
46  * @tc.name: TraceCollectorTest001
47  * @tc.desc: used to test TraceCollector for xperf dump
48  * @tc.type: FUNC
49 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest001, TestSize.Level1)50 HWTEST_F(TraceCollectorTest, TraceCollectorTest001, TestSize.Level1)
51 {
52     const std::vector<std::string> tagGroups = {"scene_performance"};
53     UCollect::TraceCaller caller = UCollect::TraceCaller::XPERF;
54     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
55     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
56     sleep(10);
57     std::cout << "caller : " << caller << std::endl;
58     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
59     std::vector<std::string> items = resultDumpTrace.data;
60     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
61     for (auto it = items.begin(); it != items.end(); it++) {
62         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
63     }
64     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
65     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
66 }
67 
68 /**
69  * @tc.name: TraceCollectorTest002
70  * @tc.desc: used to test TraceCollector for xpower dump
71  * @tc.type: FUNC
72 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest002, TestSize.Level1)73 HWTEST_F(TraceCollectorTest, TraceCollectorTest002, TestSize.Level1)
74 {
75     const std::vector<std::string> tagGroups = {"scene_performance"};
76     UCollect::TraceCaller caller = UCollect::TraceCaller::XPOWER;
77     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
78     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
79     sleep(10);
80     std::cout << "caller : " << caller << std::endl;
81     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
82     std::vector<std::string> items = resultDumpTrace.data;
83     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
84     for (auto it = items.begin(); it != items.end(); it++) {
85         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
86     }
87     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
88     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
89 }
90 
91 /**
92  * @tc.name: TraceCollectorTest003
93  * @tc.desc: used to test TraceCollector for reliability dump
94  * @tc.type: FUNC
95 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest003, TestSize.Level1)96 HWTEST_F(TraceCollectorTest, TraceCollectorTest003, TestSize.Level1)
97 {
98     const std::vector<std::string> tagGroups = {"scene_performance"};
99     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
100     UCollect::TraceCaller caller = UCollect::TraceCaller::RELIABILITY;
101     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
102     sleep(10);
103     std::cout << "caller : " << caller << std::endl;
104     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
105     std::vector<std::string> items = resultDumpTrace.data;
106     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
107     for (auto it = items.begin(); it != items.end(); it++) {
108         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
109     }
110     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
111     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
112 }
113 
114 /**
115  * @tc.name: TraceCollectorTest004
116  * @tc.desc: used to test TraceCollector for command
117  * @tc.type: FUNC
118 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest004, TestSize.Level1)119 HWTEST_F(TraceCollectorTest, TraceCollectorTest004, TestSize.Level1)
120 {
121     const std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
122     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
123     ASSERT_TRUE(g_traceManager.OpenRecordingTrace(args) == 0);
124 
125     CollectResult<int32_t> resultTraceOn = collector->TraceOn();
126     std::cout << "collect TraceOn result " << resultTraceOn.retCode << std::endl;
127     ASSERT_TRUE(resultTraceOn.retCode == UcError::SUCCESS);
128     sleep(10);
129     CollectResult<std::vector<std::string>> resultTraceOff = collector->TraceOff();
130     std::vector<std::string> items = resultTraceOff.data;
131     for (auto it = items.begin(); it != items.end(); it++) {
132         std::cout << "collect TraceOff result path : " << it->c_str() << std::endl;
133     }
134     ASSERT_TRUE(resultTraceOff.retCode == UcError::SUCCESS);
135     ASSERT_TRUE(resultTraceOff.data.size() > 0);
136     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
137 }
138 
139 /**
140  * @tc.name: TraceCollectorTest005
141  * @tc.desc: used to test TraceCollector for BetaClub dump
142  * @tc.type: FUNC
143 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest005, TestSize.Level1)144 HWTEST_F(TraceCollectorTest, TraceCollectorTest005, TestSize.Level1)
145 {
146     const std::vector<std::string> tagGroups = {"scene_performance"};
147     UCollect::TraceCaller caller = UCollect::TraceCaller::BETACLUB;
148     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
149     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
150     sleep(10);
151     std::cout << "caller : " << caller << std::endl;
152     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
153     std::vector<std::string> items = resultDumpTrace.data;
154     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
155     for (auto it = items.begin(); it != items.end(); it++) {
156         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
157     }
158     if (Parameter::IsBetaVersion()) {
159         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
160     }
161     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
162     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
163 }
164 
165 /**
166  * @tc.name: TraceCollectorTest006
167  * @tc.desc: used to test TraceCollector for Other dump
168  * @tc.type: FUNC
169 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest006, TestSize.Level1)170 HWTEST_F(TraceCollectorTest, TraceCollectorTest006, TestSize.Level1)
171 {
172     const std::vector<std::string> tagGroups = {"scene_performance"};
173     UCollect::TraceCaller caller = UCollect::TraceCaller::OTHER;
174     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
175     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
176     sleep(10);
177     std::cout << "caller : " << caller << std::endl;
178     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
179     std::vector<std::string> items = resultDumpTrace.data;
180     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
181     for (auto it = items.begin(); it != items.end(); it++) {
182         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
183     }
184     if (Parameter::IsBetaVersion()) {
185         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
186     }
187     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
188     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
189 }
190 
191 /**
192  * @tc.name: TraceCollectorTest007
193  * @tc.desc: used to test g_traceManager
194  * @tc.type: FUNC
195 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest007, TestSize.Level1)196 HWTEST_F(TraceCollectorTest, TraceCollectorTest007, TestSize.Level1)
197 {
198     const std::vector<std::string> tagGroups = {"scene_performance"};
199     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
200     const std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
201     ASSERT_TRUE(g_traceManager.OpenRecordingTrace(args) == 0);
202     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
203 }
204 
205 /**
206  * @tc.name: TraceCollectorTest008
207  * @tc.desc: used to test g_traceManager
208  * @tc.type: FUNC
209 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest008, TestSize.Level1)210 HWTEST_F(TraceCollectorTest, TraceCollectorTest008, TestSize.Level1)
211 {
212     const std::vector<std::string> tagGroups = {"scene_performance"};
213     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
214     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
215 }
216 
217 /**
218  * @tc.name: TraceCollectorTest009
219  * @tc.desc: used to test g_traceManager
220  * @tc.type: FUNC
221 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest009, TestSize.Level1)222 HWTEST_F(TraceCollectorTest, TraceCollectorTest009, TestSize.Level1)
223 {
224     const std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
225     ASSERT_TRUE(g_traceManager.OpenRecordingTrace(args) == 0);
226     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
227 }
228 
229 /**
230  * @tc.name: TraceCollectorTest010
231  * @tc.desc: used to test g_traceManager
232  * @tc.type: FUNC
233 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest010, TestSize.Level1)234 HWTEST_F(TraceCollectorTest, TraceCollectorTest010, TestSize.Level1)
235 {
236     const std::string args = "tags:sched clockType:boot bufferSize:1024 overwrite:1";
237     ASSERT_TRUE(g_traceManager.OpenRecordingTrace(args) == 0);
238     ASSERT_TRUE(g_traceManager.RecoverTrace() == 0);
239     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
240 }
241 
242 /**
243  * @tc.name: TraceCollectorTest011
244  * @tc.desc: used to test g_traceManager
245  * @tc.type: FUNC
246 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest011, TestSize.Level1)247 HWTEST_F(TraceCollectorTest, TraceCollectorTest011, TestSize.Level1)
248 {
249     const std::vector<std::string> tagGroups = {"scene_performance"};
250     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
251     ASSERT_TRUE(g_traceManager.RecoverTrace() == 0);
252     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
253 }
254 
255 /**
256  * @tc.name: TraceCollectorTest0012
257  * @tc.desc: used to test TraceCollector for Develop dump
258  * @tc.type: FUNC
259 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest012, TestSize.Level1)260 HWTEST_F(TraceCollectorTest, TraceCollectorTest012, TestSize.Level1)
261 {
262     const std::vector<std::string> tagGroups = {"scene_performance"};
263     UCollect::TraceCaller caller = UCollect::TraceCaller::DEVELOP;
264     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
265     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
266     sleep(10);
267     std::cout << "caller : " << caller << std::endl;
268     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
269     std::vector<std::string> items = resultDumpTrace.data;
270     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
271     for (auto it = items.begin(); it != items.end(); it++) {
272         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
273     }
274     if (Parameter::IsBetaVersion()) {
275         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
276     }
277     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
278     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
279 }
280 
281 /**
282  * @tc.name: TraceCollectorTest0013
283  * @tc.desc: used to test trace file in /share is zipped
284  * @tc.type: FUNC
285 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest013, TestSize.Level1)286 HWTEST_F(TraceCollectorTest, TraceCollectorTest013, TestSize.Level1)
287 {
288     std::vector<std::string> traceFiles;
289     FileUtil::GetDirFiles("/data/log/hiview/unified_collection/trace/share/", traceFiles, false);
290     for (auto &path : traceFiles) {
291         if (path.find("temp") == std::string::npos) {
292             std::cout << "trace in share path: " << path.c_str() << std::endl;
293             ASSERT_TRUE(path.find("zip") != std::string::npos);
294         }
295     }
296 }
297 
298 /**
299  * @tc.name: TraceCollectorTest0014
300  * @tc.desc: test interface DumpTraceWithDuration for 0 second
301  * @tc.type: FUNC
302  */
HWTEST_F(TraceCollectorTest, TraceCollectorTest014, TestSize.Level1)303 HWTEST_F(TraceCollectorTest, TraceCollectorTest014, TestSize.Level1)
304 {
305     const std::vector<std::string> tagGroups = {"scene_performance"};
306     UCollect::TraceCaller caller = UCollect::TraceCaller::DEVELOP;
307     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
308     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
309     sleep(TIME_10S);
310     std::cout << "caller : " << caller << std::endl;
311     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTraceWithDuration(caller, TIME_0S);
312     std::vector<std::string> items = resultDumpTrace.data;
313     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
314     for (auto it = items.begin(); it != items.end(); it++) {
315         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
316     }
317     if (Parameter::IsBetaVersion()) {
318         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
319     }
320     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
321 }
322 
323 /**
324  * @tc.name: TraceCollectorTest0015
325  * @tc.desc: test interface DumpTraceWithDuration for 20 second
326  * @tc.type: FUNC
327 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest015, TestSize.Level1)328 HWTEST_F(TraceCollectorTest, TraceCollectorTest015, TestSize.Level1)
329 {
330     const std::vector<std::string> tagGroups = {"scene_performance"};
331     UCollect::TraceCaller caller = UCollect::TraceCaller::DEVELOP;
332     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
333     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
334     sleep(TIME_30S);
335     std::cout << "caller : " << caller << std::endl;
336     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTraceWithDuration(caller, TIME_20S);
337     std::vector<std::string> items = resultDumpTrace.data;
338     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
339     for (auto it = items.begin(); it != items.end(); it++) {
340         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
341     }
342     if (Parameter::IsBetaVersion()) {
343         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
344     }
345     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
346     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
347 }
348 
349 /**
350  * @tc.name: TraceCollectorTest0016
351  * @tc.desc: test interface DumpTraceWithDuration for UINT32_MAX
352  * @tc.type: FUNC
353 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest016, TestSize.Level1)354 HWTEST_F(TraceCollectorTest, TraceCollectorTest016, TestSize.Level1)
355 {
356     const std::vector<std::string> tagGroups = {"scene_performance"};
357     UCollect::TraceCaller caller = UCollect::TraceCaller::DEVELOP;
358     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
359     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
360     sleep(TIME_30S);
361     std::cout << "caller : " << caller << std::endl;
362     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTraceWithDuration(caller, UINT32_MAX);
363     std::vector<std::string> items = resultDumpTrace.data;
364     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
365     for (auto it = items.begin(); it != items.end(); it++) {
366         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
367     }
368     if (Parameter::IsBetaVersion()) {
369         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
370     }
371     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
372     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
373 }
374 
375 /**
376  * @tc.name: TraceCollectorTest017
377  * @tc.desc: used to test TraceCollector for hiview dump
378  * @tc.type: FUNC
379 */
HWTEST_F(TraceCollectorTest, TraceCollectorTest017, TestSize.Level1)380 HWTEST_F(TraceCollectorTest, TraceCollectorTest017, TestSize.Level1)
381 {
382     const std::vector<std::string> tagGroups = {"scene_performance"};
383     UCollect::TraceCaller caller = UCollect::TraceCaller::HIVIEW;
384     std::shared_ptr<TraceCollector> collector = TraceCollector::Create();
385     ASSERT_EQ(g_traceManager.OpenSnapshotTrace(tagGroups), 0);
386     sleep(10);
387     std::cout << "caller : " << caller << std::endl;
388     CollectResult<std::vector<std::string>> resultDumpTrace = collector->DumpTrace(caller);
389     std::vector<std::string> items = resultDumpTrace.data;
390     std::cout << "collect DumpTrace result size : " << items.size() << std::endl;
391     for (auto it = items.begin(); it != items.end(); it++) {
392         std::cout << "collect DumpTrace result path : " << it->c_str() << std::endl;
393     }
394     if (Parameter::IsBetaVersion()) {
395         ASSERT_EQ(resultDumpTrace.retCode, UcError::SUCCESS);
396     }
397     ASSERT_TRUE(resultDumpTrace.data.size() >= 0);
398     ASSERT_TRUE(g_traceManager.CloseTrace() == 0);
399 }
400