1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hiperf_client_test.h"
17 
18 #include <algorithm>
19 #include <chrono>
20 #include <cinttypes>
21 #include <thread>
22 
23 #include "test_utilities.h"
24 #include "utilities.h"
25 
26 using namespace testing::ext;
27 using namespace std;
28 using namespace OHOS::HiviewDFX;
29 namespace OHOS {
30 namespace Developtools {
31 namespace HiPerf {
32 class HiperfClientTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 
39     static void TestCaseOption(const HiperfClient::RecordOption &opt);
40 };
41 
SetUpTestCase()42 void HiperfClientTest::SetUpTestCase() {}
43 
TearDownTestCase()44 void HiperfClientTest::TearDownTestCase()
45 {
46     DebugLogger::GetInstance()->Reset();
47 }
48 
SetUp()49 void HiperfClientTest::SetUp() {}
50 
TearDown()51 void HiperfClientTest::TearDown()
52 {
53 }
54 
55 /**
56  * @tc.name:
57  * @tc.desc: record
58  * @tc.type: FUNC
59  */
HWTEST_F(HiperfClientTest, NoPara, TestSize.Level1)60 HWTEST_F(HiperfClientTest, NoPara, TestSize.Level1)
61 {
62     StdoutRecord stdoutRecord;
63     stdoutRecord.Start();
64 
65     HiperfClient::Client myHiperf;
66     myHiperf.SetDebugMode();
67     ASSERT_TRUE(myHiperf.Start());
68 
69     ASSERT_TRUE(myHiperf.Pause());
70     this_thread::sleep_for(1s);
71 
72     ASSERT_TRUE(myHiperf.Resume());
73     this_thread::sleep_for(1s);
74 
75     ASSERT_TRUE(myHiperf.Stop());
76 
77     stdoutRecord.Stop();
78 }
79 
HWTEST_F(HiperfClientTest, OutDir, TestSize.Level1)80 HWTEST_F(HiperfClientTest, OutDir, TestSize.Level1)
81 {
82     StdoutRecord stdoutRecord;
83     stdoutRecord.Start();
84 
85     HiperfClient::Client myHiperf("/data/local/tmp/");
86     ASSERT_EQ(myHiperf.GetOutputDir(), "/data/local/tmp/");
87     myHiperf.SetDebugMode();
88     ASSERT_TRUE(myHiperf.Start());
89 
90     ASSERT_TRUE(myHiperf.Pause());
91     this_thread::sleep_for(1s);
92 
93     ASSERT_TRUE(myHiperf.Resume());
94     this_thread::sleep_for(1s);
95 
96     ASSERT_TRUE(myHiperf.Stop());
97 
98     stdoutRecord.Stop();
99 }
100 
HWTEST_F(HiperfClientTest, DebugMuchMode, TestSize.Level1)101 HWTEST_F(HiperfClientTest, DebugMuchMode, TestSize.Level1)
102 {
103     StdoutRecord stdoutRecord;
104     stdoutRecord.Start();
105 
106     HiperfClient::Client myHiperf;
107     myHiperf.SetDebugMuchMode();
108     ASSERT_TRUE(myHiperf.Start());
109 
110     ASSERT_TRUE(myHiperf.Pause());
111     this_thread::sleep_for(1s);
112 
113     ASSERT_TRUE(myHiperf.Resume());
114     this_thread::sleep_for(1s);
115 
116     ASSERT_TRUE(myHiperf.Stop());
117 
118     stdoutRecord.Stop();
119 }
120 
HWTEST_F(HiperfClientTest, EnableHilog, TestSize.Level1)121 HWTEST_F(HiperfClientTest, EnableHilog, TestSize.Level1)
122 {
123     StdoutRecord stdoutRecord;
124     stdoutRecord.Start();
125 
126     HiperfClient::Client myHiperf;
127     myHiperf.SetDebugMode();
128     myHiperf.EnableHilog();
129     ASSERT_TRUE(myHiperf.Start());
130 
131     ASSERT_TRUE(myHiperf.Pause());
132     this_thread::sleep_for(1s);
133 
134     ASSERT_TRUE(myHiperf.Resume());
135     this_thread::sleep_for(1s);
136 
137     ASSERT_TRUE(myHiperf.Stop());
138 
139     stdoutRecord.Stop();
140 }
141 
HWTEST_F(HiperfClientTest, Prepare, TestSize.Level1)142 HWTEST_F(HiperfClientTest, Prepare, TestSize.Level1)
143 {
144     StdoutRecord stdoutRecord;
145     stdoutRecord.Start();
146     HiperfClient::RecordOption opt;
147     opt.SetTargetSystemWide(true);
148 
149     HiperfClient::Client myHiperf("/data/local/tmp/");
150     ASSERT_TRUE(myHiperf.PrePare(opt));
151     this_thread::sleep_for(1s);
152 
153     ASSERT_TRUE(myHiperf.StartRun());
154     this_thread::sleep_for(1s);
155 
156     ASSERT_TRUE(myHiperf.Stop());
157 
158     stdoutRecord.Stop();
159 }
160 
HWTEST_F(HiperfClientTest, GetCommandPath, TestSize.Level1)161 HWTEST_F(HiperfClientTest, GetCommandPath, TestSize.Level1)
162 {
163     StdoutRecord stdoutRecord;
164     stdoutRecord.Start();
165 
166     HiperfClient::Client myHiperf("/data/local/tmp/");
167     ASSERT_EQ(myHiperf.GetCommandPath().empty(), false);
168 
169     stdoutRecord.Stop();
170 }
171 
TestCaseOption(const HiperfClient::RecordOption &opt)172 void HiperfClientTest::TestCaseOption(const HiperfClient::RecordOption &opt)
173 {
174     StdoutRecord stdoutRecord;
175     stdoutRecord.Start();
176     HiperfClient::Client myHiperf;
177     myHiperf.SetDebugMode();
178 
179     ASSERT_TRUE(myHiperf.IsReady());
180     ASSERT_TRUE(myHiperf.Start(opt));
181 
182     bool retPause = true;
183     bool retResume = true;
184     bool retStop = true;
185     if (!myHiperf.Pause()) {
186         retPause = false;
187     }
188     this_thread::sleep_for(1s);
189 
190     if (!myHiperf.Resume()) {
191         retResume = false;
192     }
193     this_thread::sleep_for(1s);
194 
195     if (!myHiperf.Stop()) {
196         retStop = false;
197     }
198 
199     ASSERT_TRUE(retPause);
200     ASSERT_TRUE(retResume);
201     ASSERT_TRUE(retStop);
202 
203     stdoutRecord.Stop();
204 }
205 
HWTEST_F(HiperfClientTest, SetTargetSystemWide, TestSize.Level1)206 HWTEST_F(HiperfClientTest, SetTargetSystemWide, TestSize.Level1)
207 {
208     HiperfClient::RecordOption opt;
209     opt.SetTargetSystemWide(true);
210 
211     TestCaseOption(opt);
212 }
213 
HWTEST_F(HiperfClientTest, SetCompressData, TestSize.Level1)214 HWTEST_F(HiperfClientTest, SetCompressData, TestSize.Level1)
215 {
216     HiperfClient::RecordOption opt;
217     vector<pid_t> selectPids = {getpid()};
218     opt.SetSelectPids(selectPids);
219     opt.SetCompressData(true);
220     TestCaseOption(opt);
221 }
222 
HWTEST_F(HiperfClientTest, SetSelectCpus, TestSize.Level1)223 HWTEST_F(HiperfClientTest, SetSelectCpus, TestSize.Level1)
224 {
225     HiperfClient::RecordOption opt;
226     vector<pid_t> selectPids = {getpid()};
227     opt.SetSelectPids(selectPids);
228     vector<int> cpus = {0, 1};
229     opt.SetSelectCpus(cpus);
230 
231     TestCaseOption(opt);
232 }
233 
HWTEST_F(HiperfClientTest, SetTimeStopSec, TestSize.Level1)234 HWTEST_F(HiperfClientTest, SetTimeStopSec, TestSize.Level1)
235 {
236     HiperfClient::RecordOption opt;
237     vector<pid_t> selectPids = {getpid()};
238     opt.SetSelectPids(selectPids);
239     opt.SetTimeStopSec(40);
240 
241     HiperfClient::Client myHiperf;
242     ASSERT_TRUE(myHiperf.IsReady());
243     ASSERT_TRUE(myHiperf.Start(opt));
244 }
245 
HWTEST_F(HiperfClientTest, SetFrequency, TestSize.Level1)246 HWTEST_F(HiperfClientTest, SetFrequency, TestSize.Level1)
247 {
248     HiperfClient::RecordOption opt;
249     vector<pid_t> selectPids = {getpid()};
250     opt.SetSelectPids(selectPids);
251     opt.SetFrequency(500);
252 
253     TestCaseOption(opt);
254 }
255 
HWTEST_F(HiperfClientTest, SetPeriod, TestSize.Level1)256 HWTEST_F(HiperfClientTest, SetPeriod, TestSize.Level1)
257 {
258     HiperfClient::RecordOption opt;
259     vector<pid_t> selectPids = {getpid()};
260     opt.SetSelectPids(selectPids);
261     opt.SetPeriod(3);
262 
263     TestCaseOption(opt);
264 }
265 
HWTEST_F(HiperfClientTest, SetSelectEvents, TestSize.Level1)266 HWTEST_F(HiperfClientTest, SetSelectEvents, TestSize.Level1)
267 {
268     HiperfClient::RecordOption opt;
269     vector<pid_t> selectPids = {getpid()};
270     opt.SetSelectPids(selectPids);
271     vector<string> selectEvents = {"hw-cpu-cycles:k"};
272     opt.SetSelectEvents(selectEvents);
273 
274     TestCaseOption(opt);
275 }
276 
HWTEST_F(HiperfClientTest, SetSelectGroups, TestSize.Level1)277 HWTEST_F(HiperfClientTest, SetSelectGroups, TestSize.Level1)
278 {
279     HiperfClient::RecordOption opt;
280     vector<pid_t> selectPids = {getpid()};
281     opt.SetSelectPids(selectPids);
282     vector<string> selectEvents = {"hw-cpu-cycles:u"};
283     opt.SetSelectGroups(selectEvents);
284     TestCaseOption(opt);
285 }
286 
HWTEST_F(HiperfClientTest, SetNoInherit, TestSize.Level1)287 HWTEST_F(HiperfClientTest, SetNoInherit, TestSize.Level1)
288 {
289     HiperfClient::RecordOption opt;
290     vector<pid_t> selectPids = {getpid()};
291     opt.SetSelectPids(selectPids);
292     opt.SetNoInherit(true);
293 
294     TestCaseOption(opt);
295 }
296 
HWTEST_F(HiperfClientTest, SetSelectPids, TestSize.Level1)297 HWTEST_F(HiperfClientTest, SetSelectPids, TestSize.Level1)
298 {
299     HiperfClient::RecordOption opt;
300     vector<pid_t> selectPids = {getpid()};
301     opt.SetSelectPids(selectPids);
302 
303     TestCaseOption(opt);
304 }
305 
HWTEST_F(HiperfClientTest, SetCallStackSamplingConfigs, TestSize.Level1)306 HWTEST_F(HiperfClientTest, SetCallStackSamplingConfigs, TestSize.Level1)
307 {
308     HiperfClient::RecordOption opt;
309     vector<pid_t> selectPids = {getpid()};
310     opt.SetSelectPids(selectPids);
311     opt.SetCallStackSamplingConfigs(1);
312 
313     HiperfClient::Client myHiperf;
314     ASSERT_TRUE(myHiperf.IsReady());
315     ASSERT_TRUE(myHiperf.Start(opt));
316 }
317 
HWTEST_F(HiperfClientTest, SetSelectTids, TestSize.Level1)318 HWTEST_F(HiperfClientTest, SetSelectTids, TestSize.Level1)
319 {
320     HiperfClient::RecordOption opt;
321     vector<pid_t> selectTids = {gettid()};
322     opt.SetSelectTids(selectTids);
323 
324     TestCaseOption(opt);
325 }
326 
HWTEST_F(HiperfClientTest, SetExcludePerf, TestSize.Level1)327 HWTEST_F(HiperfClientTest, SetExcludePerf, TestSize.Level1)
328 {
329     HiperfClient::RecordOption opt;
330     opt.SetTargetSystemWide(true);
331     opt.SetExcludePerf(true);
332 
333     TestCaseOption(opt);
334 }
335 
HWTEST_F(HiperfClientTest, SetCpuPercent, TestSize.Level1)336 HWTEST_F(HiperfClientTest, SetCpuPercent, TestSize.Level1)
337 {
338     HiperfClient::RecordOption opt;
339     vector<pid_t> selectPids = {getpid()};
340     opt.SetSelectPids(selectPids);
341     opt.SetCpuPercent(50);
342 
343     TestCaseOption(opt);
344 }
345 
HWTEST_F(HiperfClientTest, SetOffCPU, TestSize.Level1)346 HWTEST_F(HiperfClientTest, SetOffCPU, TestSize.Level1)
347 {
348     HiperfClient::RecordOption opt;
349     vector<pid_t> selectPids = {getpid()};
350     opt.SetSelectPids(selectPids);
351     opt.SetOffCPU(true);
352 
353     TestCaseOption(opt);
354 }
355 
HWTEST_F(HiperfClientTest, SetCallStack, TestSize.Level1)356 HWTEST_F(HiperfClientTest, SetCallStack, TestSize.Level1)
357 {
358     HiperfClient::RecordOption opt;
359     vector<pid_t> selectPids = {getpid()};
360     opt.SetSelectPids(selectPids);
361     opt.SetCallGraph("fp");
362 
363     TestCaseOption(opt);
364 }
365 
HWTEST_F(HiperfClientTest, SetDelayUnwind, TestSize.Level1)366 HWTEST_F(HiperfClientTest, SetDelayUnwind, TestSize.Level1)
367 {
368     HiperfClient::RecordOption opt;
369     vector<pid_t> selectPids = {getpid()};
370     opt.SetSelectPids(selectPids);
371     opt.SetDelayUnwind(true);
372 
373     TestCaseOption(opt);
374 }
375 
HWTEST_F(HiperfClientTest, SetDisableUnwind, TestSize.Level1)376 HWTEST_F(HiperfClientTest, SetDisableUnwind, TestSize.Level1)
377 {
378     HiperfClient::RecordOption opt;
379     vector<pid_t> selectPids = {getpid()};
380     opt.SetSelectPids(selectPids);
381     opt.SetDisableUnwind(true);
382 
383     TestCaseOption(opt);
384 }
385 
HWTEST_F(HiperfClientTest, SetDisableCallstackMerge, TestSize.Level1)386 HWTEST_F(HiperfClientTest, SetDisableCallstackMerge, TestSize.Level1)
387 {
388     HiperfClient::RecordOption opt;
389     vector<pid_t> selectPids = {getpid()};
390     opt.SetSelectPids(selectPids);
391     opt.SetDisableCallstackMerge(true);
392 
393     TestCaseOption(opt);
394 }
395 
HWTEST_F(HiperfClientTest, SetOutputFilename, TestSize.Level1)396 HWTEST_F(HiperfClientTest, SetOutputFilename, TestSize.Level1)
397 {
398     HiperfClient::RecordOption opt;
399     vector<pid_t> selectPids = {getpid()};
400     opt.SetSelectPids(selectPids);
401     opt.SetOutputFilename("perf.data.ut");
402 
403     TestCaseOption(opt);
404 }
405 
HWTEST_F(HiperfClientTest, SetSymbolDir, TestSize.Level1)406 HWTEST_F(HiperfClientTest, SetSymbolDir, TestSize.Level1)
407 {
408     HiperfClient::RecordOption opt;
409     vector<pid_t> selectPids = {getpid()};
410     opt.SetSelectPids(selectPids);
411     opt.SetSymbolDir("/data/local/tmp/");
412 
413     TestCaseOption(opt);
414 }
415 
HWTEST_F(HiperfClientTest, SetDataLimit, TestSize.Level1)416 HWTEST_F(HiperfClientTest, SetDataLimit, TestSize.Level1)
417 {
418     HiperfClient::RecordOption opt;
419     vector<pid_t> selectPids = {getpid()};
420     opt.SetSelectPids(selectPids);
421     opt.SetDataLimit("100M");
422 
423     TestCaseOption(opt);
424 }
425 
HWTEST_F(HiperfClientTest, SetAppPackage, TestSize.Level1)426 HWTEST_F(HiperfClientTest, SetAppPackage, TestSize.Level1)
427 {
428     HiperfClient::RecordOption opt;
429     std::string testProcesses = "com.ohos.sceneboard";
430     if (!CheckTestApp(testProcesses)) {
431         testProcesses = "com.ohos.launcher";
432     }
433     opt.SetAppPackage(testProcesses);
434 
435     TestCaseOption(opt);
436 }
437 
HWTEST_F(HiperfClientTest, SetClockId, TestSize.Level1)438 HWTEST_F(HiperfClientTest, SetClockId, TestSize.Level1)
439 {
440     HiperfClient::RecordOption opt;
441     vector<pid_t> selectPids = {getpid()};
442     opt.SetSelectPids(selectPids);
443     opt.SetClockId("monotonic");
444 
445     TestCaseOption(opt);
446 }
447 
HWTEST_F(HiperfClientTest, SetMmapPages, TestSize.Level1)448 HWTEST_F(HiperfClientTest, SetMmapPages, TestSize.Level1)
449 {
450     HiperfClient::RecordOption opt;
451     vector<pid_t> selectPids = {getpid()};
452     opt.SetSelectPids(selectPids);
453     opt.SetMmapPages(64);
454 
455     TestCaseOption(opt);
456 }
457 
HWTEST_F(HiperfClientTest, SetReport, TestSize.Level1)458 HWTEST_F(HiperfClientTest, SetReport, TestSize.Level1)
459 {
460     HiperfClient::RecordOption opt;
461     vector<pid_t> selectPids = {getpid()};
462     opt.SetSelectPids(selectPids);
463     opt.SetReport(true);
464 
465     TestCaseOption(opt);
466 }
467 
HWTEST_F(HiperfClientTest, SetVecBranchSampleTypes, TestSize.Level1)468 HWTEST_F(HiperfClientTest, SetVecBranchSampleTypes, TestSize.Level1)
469 {
470     StdoutRecord stdoutRecord;
471     stdoutRecord.Start();
472 
473     HiperfClient::RecordOption opt;
474     vector<pid_t> selectPids = {getpid()};
475     opt.SetSelectPids(selectPids);
476     std::vector<std::string> vecBranchSampleTypes = {"any", "any_call", "any_ret", "ind_call", "u", "k"};
477     opt.SetVecBranchSampleTypes(vecBranchSampleTypes);
478     HiperfClient::Client myHiperf;
479     myHiperf.SetDebugMode();
480 
481     ASSERT_TRUE(myHiperf.IsReady());
482 #ifdef is_ohos
483     ASSERT_EQ(myHiperf.Start(opt), false);
484 #else
485     ASSERT_TRUE(myHiperf.Start(opt));
486     ASSERT_TRUE(myHiperf.Pause());
487     this_thread::sleep_for(1s);
488 
489     ASSERT_TRUE(myHiperf.Resume());
490     this_thread::sleep_for(1s);
491 
492     ASSERT_TRUE(myHiperf.Stop());
493 #endif
494     stdoutRecord.Stop();
495 }
496 } // namespace HiPerf
497 } // namespace Developtools
498 } // namespace OHOS
499