• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "subcommand_record_test.h"
17 
18 #include <algorithm>
19 #include <chrono>
20 #include <cinttypes>
21 #include <sched.h>
22 #include <sstream>
23 #include <thread>
24 
25 #include <poll.h>
26 #include <unistd.h>
27 
28 #include "command.h"
29 #include "debug_logger.h"
30 #include "utilities.h"
31 #include <sys/stat.h>
32 
33 using namespace std::literals::chrono_literals;
34 using namespace testing::ext;
35 using namespace std;
36 using namespace OHOS::HiviewDFX;
37 namespace OHOS {
38 namespace Developtools {
39 namespace HiPerf {
40 static const std::string TEST_FILE = "/data/local/tmp/perf.data";
41 
42 class SubCommandRecordTest : public testing::Test {
43 public:
44     static void SetUpTestCase(void);
45     static void TearDownTestCase(void);
46     void SetUp();
47     void TearDown();
48 
49     void TestEvents(std::string &opt, std::string &uk, bool isFork = true);
50 
51     static void ForkAndRunTest(const std::string& cmd, bool expect = true, bool fixPid = true);
52 
53     static void TestRecordCommand(const std::string &option, bool expect = true, bool fixPid = true);
54 
55     size_t GetFileSize(const char* fileName);
56 
57     static constexpr size_t TEST_SIZE_F100_DWARF_SYSTEM = 1.4E4 * 1024;
58     static constexpr size_t TEST_SIZE_F500_DWARF_SYSTEM = 3.6E4 * 1024;
59     static constexpr size_t TEST_SIZE_F1000_DWARF_SYSTEM = 5.9E4 * 1024;
60     static constexpr size_t TEST_SIZE_F2000_DWARF_SYSTEM = 8.3E4 * 1024;
61     static constexpr size_t TEST_SIZE_F4000_DWARF_SYSTEM = 1.7E5 * 1024;
62     static constexpr size_t TEST_SIZE_F8000_DWARF_SYSTEM = 3.5E5 * 1024;
63     static constexpr size_t TEST_SIZE_F100_FP_SYSTEM = 10E3 * 1024;
64     static constexpr size_t TEST_SIZE_F500_FP_SYSTEM = 2E4 * 1024;
65     static constexpr size_t TEST_SIZE_F1000_FP_SYSTEM = 3E4 * 1024;
66     static constexpr size_t TEST_SIZE_F2000_FP_SYSTEM = 4E4 * 1024;
67     static constexpr size_t TEST_SIZE_F4000_FP_SYSTEM = 8E4 * 1024;
68     static constexpr size_t TEST_SIZE_F8000_FP_SYSTEM = 1.6E5 * 1024;
69 
70     static constexpr size_t TEST_SIZE_F100_DWARF_PROCESS = 5.6E3 * 1024;
71     static constexpr size_t TEST_SIZE_F500_DWARF_PROCESS = 1.6E4 * 1024;
72     static constexpr size_t TEST_SIZE_F1000_DWARF_PROCESS = 2.9E4 * 1024;
73     static constexpr size_t TEST_SIZE_F2000_DWARF_PROCESS = 6.1E4 * 1024;
74     static constexpr size_t TEST_SIZE_F4000_DWARF_PROCESS = 5.8E4 * 1024;
75     static constexpr size_t TEST_SIZE_F8000_DWARF_PROCESS = 1.2E5 * 1024;
76     static constexpr size_t TEST_SIZE_F100_FP_PROCESS = 3.6E3 * 1024;
77     static constexpr size_t TEST_SIZE_F500_FP_PROCESS = 8.8E3 * 1024;
78     static constexpr size_t TEST_SIZE_F1000_FP_PROCESS = 1.5E4 * 1024;
79     static constexpr size_t TEST_SIZE_F2000_FP_PROCESS = 3.1E4 * 1024;
80     static constexpr size_t TEST_SIZE_F4000_FP_PROCESS = 6.2E4 * 1024;
81     static constexpr size_t TEST_SIZE_F8000_FP_PROCESS = 1.3E5 * 1024;
82 };
83 
SetUpTestCase()84 void SubCommandRecordTest::SetUpTestCase() {}
85 
TearDownTestCase()86 void SubCommandRecordTest::TearDownTestCase() {}
87 
SetUp()88 void SubCommandRecordTest::SetUp()
89 {
90     SubCommand::ClearSubCommands(); // clear the subCommands left from other UT
91     ASSERT_EQ(SubCommand::GetSubCommands().size(), 0u);
92     SubCommandRecord::RegisterSubCommandRecord();
93     ASSERT_EQ(SubCommand::GetSubCommands().size(), 1u);
94 }
95 
TearDown()96 void SubCommandRecordTest::TearDown()
97 {
98     ASSERT_EQ(SubCommand::GetSubCommands().size(), 1u);
99     SubCommand::ClearSubCommands();
100     ASSERT_EQ(SubCommand::GetSubCommands().size(), 0u);
101     MemoryHold::Get().Clean();
102 }
103 
ForkAndRunTest(const std::string & cmd,bool expect,bool fixPid)104 void SubCommandRecordTest::ForkAndRunTest(const std::string& cmd, bool expect, bool fixPid)
105 {
106     pid_t pid = fork();
107     if (pid < 0) {
108         FAIL() << "Fork test process failed";
109         return;
110     }
111     if (pid == 0) {
112         TestRecordCommand(cmd, expect, fixPid);
113         _exit(0);
114     }
115     int status;
116     int ret = wait(&status);
117     GTEST_LOG_(INFO) << "Status:" << status << " Result:" << ret;
118     ASSERT_EQ(status, 0);
119 }
120 
TestRecordCommand(const std::string & option,bool expect,bool fixPid)121 void SubCommandRecordTest::TestRecordCommand(const std::string &option, bool expect, bool fixPid)
122 {
123     StdoutRecord stdoutRecord;
124 
125     std::string cmdString = "record ";
126     if (fixPid) {
127         cmdString += "--app com.ohos.launcher ";
128     }
129     cmdString += " " + option;
130     printf("command : %s\n", cmdString.c_str());
131 
132     // it need load some symbols and much more log
133     stdoutRecord.Start();
134     const auto startTime = chrono::steady_clock::now();
135     bool ret = Command::DispatchCommand(cmdString);
136     const auto costMs = std::chrono::duration_cast<std::chrono::milliseconds>(
137         chrono::steady_clock::now() - startTime);
138     std::string stringOut = stdoutRecord.Stop();
139 
140     printf("run %" PRId64 " ms return %s(expect %s)\n", (uint64_t)costMs.count(), ret ? "true" : "false",
141            expect ? "true" : "false");
142     EXPECT_EQ(expect, ret);
143 }
144 
GetFileSize(const char * fileName)145 size_t SubCommandRecordTest::GetFileSize(const char* fileName)
146 {
147     if (fileName == nullptr) {
148         return 0;
149     }
150     struct stat statbuf;
151     stat(fileName, &statbuf);
152     size_t fileSize = statbuf.st_size;
153     return fileSize;
154 }
155 
156 // app package name
157 HWTEST_F(SubCommandRecordTest, PackageName, TestSize.Level1)
158 {
159     ForkAndRunTest("-d 2  --app com.ohos.launcher ", true, false);
160 }
161 
162 HWTEST_F(SubCommandRecordTest, PackageNameErr, TestSize.Level1)
163 {
164     TestRecordCommand("-d 2  --app package_name ", false, false);
165 }
166 
167 // check app milliseconds
168 /**
169  * @tc.name: CheckAppMsMin
170  * @tc.desc: Test chkms minimum value
171  * @tc.type: FUNC
172  * @tc.require: issueI5R305
173  */
174 HWTEST_F(SubCommandRecordTest, CheckAppMsMin, TestSize.Level1)
175 {
176     ForkAndRunTest("-d 0.5 --chkms 1 ");
177 }
178 
179 /**
180  * @tc.name: CheckAppMsMinErr
181  * @tc.desc: Test chkms less than minimum value
182  * @tc.type: FUNC
183  * @tc.require: issueI5R305
184  */
185 HWTEST_F(SubCommandRecordTest, CheckAppMsMinErr, TestSize.Level1)
186 {
187     TestRecordCommand("-d 0.5 --chkms 0 ", false);
188 }
189 
190 /**
191  * @tc.name: CheckAppMsMax
192  * @tc.desc: Test chkms maximum value
193  * @tc.type: FUNC
194  * @tc.require: issueI5R305
195  */
196 HWTEST_F(SubCommandRecordTest, CheckAppMsMax, TestSize.Level1)
197 {
198     ForkAndRunTest("-d 0.5 --chkms 200 ");
199 }
200 
201 /**
202  * @tc.name: CheckAppMsMaxErr
203  * @tc.desc: Test chkms more than maximum value
204  * @tc.type: FUNC
205  * @tc.require: issueI5R305
206  */
207 HWTEST_F(SubCommandRecordTest, CheckAppMsMaxErr, TestSize.Level1)
208 {
209     TestRecordCommand("-d 0.5 --chkms 201 ", false);
210 }
211 
212 /**
213  * @tc.name: CheckAppMsInputErr
214  * @tc.desc: Test erro type of chkms
215  * @tc.type: FUNC
216  * @tc.require: issueI5R305
217  */
218 HWTEST_F(SubCommandRecordTest, CheckAppMsInputErr, TestSize.Level1)
219 {
220     TestRecordCommand("-d 0.5 --chkms abc ", false);
221 }
222 // stop seconds
223 HWTEST_F(SubCommandRecordTest, StopSecondsMin, TestSize.Level1)
224 {
225     ForkAndRunTest("-d 0.1 ");
226 }
227 
228 HWTEST_F(SubCommandRecordTest, StopSecondsMinErr, TestSize.Level1)
229 {
230     TestRecordCommand("-d 0.099 ", false);
231 }
232 
233 HWTEST_F(SubCommandRecordTest, StopSecondsMax, TestSize.Level1)
234 {
235     std::string opt = "-d 10000.0 ";
236     opt += " ls "; // because UT don't need wait so long
237     ForkAndRunTest(opt, true, false);
238 }
239 
240 HWTEST_F(SubCommandRecordTest, StopSecondsMaxErr, TestSize.Level1)
241 {
242     std::string opt = "-d 10000.1 ";
243     opt += " ";
244     TestRecordCommand(opt, false);
245 }
246 
247 // system wide
248 HWTEST_F(SubCommandRecordTest, SystemWide, TestSize.Level1)
249 {
250     ForkAndRunTest("-d 2 -a ", true, false);
251 }
252 
253 // trackedCommand_
254 HWTEST_F(SubCommandRecordTest, TrackedCommandErr, TestSize.Level1)
255 {
256     TestRecordCommand("-d 2 -a aa ", false, false);
257 }
258 
259 // --app and -p
260 HWTEST_F(SubCommandRecordTest, HasTargetErr, TestSize.Level1)
261 {
262     TestRecordCommand("--app test -p 123 -d 3 ", false, false);
263 }
264 
265 HWTEST_F(SubCommandRecordTest, HasTargetErr1, TestSize.Level1)
266 {
267     TestRecordCommand("-d 3 ", false, false);
268 }
269 
270 // exclude hiperf
271 HWTEST_F(SubCommandRecordTest, ExcludePerf, TestSize.Level1)
272 {
273     ForkAndRunTest("-d 2 -a --exclude-hiperf ", true, false);
274 }
275 
276 HWTEST_F(SubCommandRecordTest, ExcludePerfErr, TestSize.Level1)
277 {
278     TestRecordCommand("-d 2 --exclude-hiperf ", false, true);
279 }
280 
281 // select cpu
282 HWTEST_F(SubCommandRecordTest, SelectCpu, TestSize.Level1)
283 {
284     ForkAndRunTest("-d 2 -c 0 ");
285 }
286 
287 HWTEST_F(SubCommandRecordTest, SelectCpuMulti, TestSize.Level1)
288 {
289     int maxCpuid = sysconf(_SC_NPROCESSORS_CONF);
290     std::string opt = "-d 2 -e sw-task-clock -c ";
291     for (int i = 0; i < maxCpuid; i++) {
292         opt += std::to_string(i);
293         opt += ",";
294     }
295     opt.pop_back();
296     opt += " ";
297     ForkAndRunTest(opt);
298 }
299 
300 HWTEST_F(SubCommandRecordTest, SelectCpuMinErr, TestSize.Level1)
301 {
302     TestRecordCommand("-d 2 -c -1 ", false);
303 }
304 
305 HWTEST_F(SubCommandRecordTest, SelectCpuMaxErr, TestSize.Level1)
306 {
307     int maxCpuid = sysconf(_SC_NPROCESSORS_CONF);
308     std::string opt = "-d 2 -c ";
309     opt += std::to_string(maxCpuid);
310     opt += " ";
311     TestRecordCommand(opt, false);
312 }
313 
314 HWTEST_F(SubCommandRecordTest, SelectCpuInputErr, TestSize.Level1)
315 {
316     TestRecordCommand("-d 2 -c abc ", false);
317 }
318 
319 // --control
320 HWTEST_F(SubCommandRecordTest, CheckControlErr, TestSize.Level1)
321 {
322     TestRecordCommand("-a --control st", false, false);
323 }
324 
325 // cpu percent
326 HWTEST_F(SubCommandRecordTest, CpuLimitMin, TestSize.Level1)
327 {
328     ForkAndRunTest("-d 2 --cpu-limit 1 ");
329 }
330 
331 HWTEST_F(SubCommandRecordTest, CpuLimitErr, TestSize.Level1)
332 {
333     TestRecordCommand("-d 2 --cpu-limit 0 ", false);
334 }
335 
336 HWTEST_F(SubCommandRecordTest, CpuLimitMax, TestSize.Level1)
337 {
338     ForkAndRunTest("-d 2 --cpu-limit 100 ");
339 }
340 
341 HWTEST_F(SubCommandRecordTest, CpuLimitMaxErr, TestSize.Level1)
342 {
343     TestRecordCommand("-d 2 --cpu-limit 101 ", false);
344 }
345 
346 HWTEST_F(SubCommandRecordTest, CpuLimitInputErr, TestSize.Level1)
347 {
348     TestRecordCommand("-d 2 --cpu-limit abc ", false);
349 }
350 
351 // frequency
352 HWTEST_F(SubCommandRecordTest, FrequncyMin, TestSize.Level1)
353 {
354     ForkAndRunTest("-d 2 -f 1 ");
355 }
356 
357 HWTEST_F(SubCommandRecordTest, FrequncyMinErr, TestSize.Level1)
358 {
359     TestRecordCommand("-d 2 -f 0 ", false);
360 }
361 
362 HWTEST_F(SubCommandRecordTest, FrequncyMax, TestSize.Level1)
363 {
364     ForkAndRunTest("-d 2 -f 100000 ");
365 }
366 
367 HWTEST_F(SubCommandRecordTest, FrequncyMaxErr, TestSize.Level1)
368 {
369     TestRecordCommand("-d 2 -f 100001 ", false);
370 }
371 
372 HWTEST_F(SubCommandRecordTest, FrequncyInputErr, TestSize.Level1)
373 {
374     TestRecordCommand("-d 2 -f abc ", false);
375 }
376 
377 // period
378 HWTEST_F(SubCommandRecordTest, PeriodMin, TestSize.Level1)
379 {
380     ForkAndRunTest("-d 2 --period 1 ");
381 }
382 
383 HWTEST_F(SubCommandRecordTest, PeriodMinErr, TestSize.Level1)
384 {
385     TestRecordCommand("-d 2 --period 0 ", false);
386 }
387 
388 HWTEST_F(SubCommandRecordTest, PeriodMax, TestSize.Level1)
389 {
390     std::string opt = "-d 2 --period ";
391     opt += std::to_string(INT_MAX);
392     opt += " ";
393     ForkAndRunTest(opt);
394 }
395 
396 HWTEST_F(SubCommandRecordTest, PeriodMaxErr, TestSize.Level1)
397 {
398     std::string opt = "-d 2 --period ";
399     uint32_t value = static_cast<uint32_t>(INT_MAX) + 1;
400     opt += std::to_string(value);
401     opt += " ";
402     TestRecordCommand(opt, false);
403 }
404 
405 HWTEST_F(SubCommandRecordTest, PeriodInputErr, TestSize.Level1)
406 {
407     TestRecordCommand("-d 2 --period abc ", false);
408 }
409 
410 HWTEST_F(SubCommandRecordTest, PeriodAndFrequncyConflict, TestSize.Level1)
411 {
412     TestRecordCommand("-d 2 -f 2000 --period 10 ", false);
413 }
414 
TestEvents(std::string & opt,std::string & uk,bool isFork)415 void SubCommandRecordTest::TestEvents(std::string &opt, std::string &uk, bool isFork)
416 {
417     PerfEvents perfEvents;
418     for (auto type : TYPE_CONFIGS) {
419         auto configs = perfEvents.GetSupportEvents(type.first);
420         if (configs.empty()) {
421             continue;
422         }
423 
424         const int MAX_TESTEVENT = 5;
425         int testEventCount = MAX_TESTEVENT;
426         std::string cmdline = opt;
427         for (auto config : configs) {
428             if (testEventCount <= 0) {
429                 break;
430             }
431             cmdline += config.second;
432             cmdline += uk;
433             cmdline += ",";
434             testEventCount--;
435         }
436         cmdline.pop_back(); // remove the last ','
437         if (isFork) {
438             ForkAndRunTest(cmdline);
439         } else {
440             TestRecordCommand(cmdline);
441         }
442         TearDown();
443         SetUp();
444     }
445 }
446 
447 // select events
448 HWTEST_F(SubCommandRecordTest, SelectEvents, TestSize.Level1)
449 {
450     std::string opt = "-d 2 -c 0 -e ";
451     std::string uk = "";
452     TestEvents(opt, uk);
453 }
454 
455 HWTEST_F(SubCommandRecordTest, SelectEventsUser, TestSize.Level1)
456 {
457     std::string opt = "-d 2 -c 0 -e ";
458     std::string uk = ":u";
459     TestEvents(opt, uk);
460 }
461 
462 HWTEST_F(SubCommandRecordTest, SelectEventsKernel, TestSize.Level1)
463 {
464     std::string opt = "-d 2 -c 0 -e ";
465     std::string uk = ":k";
466     TestEvents(opt, uk);
467 }
468 
469 HWTEST_F(SubCommandRecordTest, SelectEventsKernel_2, TestSize.Level1)
470 {
471     std::string opt = "-d 2 -c 0 -e ";
472     std::string uk = ":k";
473     TestEvents(opt, uk, false);
474 }
475 
476 HWTEST_F(SubCommandRecordTest, SelectEventsErr, TestSize.Level1)
477 {
478     ForkAndRunTest("-d 2 -c 0 -e what ", false);
479 }
480 
481 // select group events
482 HWTEST_F(SubCommandRecordTest, GroupEvents, TestSize.Level1)
483 {
484     std::string opt = "-d 2 -c 0 -g ";
485     std::string uk = "";
486     TestEvents(opt, uk);
487 }
488 
489 HWTEST_F(SubCommandRecordTest, GroupEventsUser, TestSize.Level1)
490 {
491     std::string opt = "-d 2 -c 0 -g ";
492     std::string uk = ":u";
493     TestEvents(opt, uk);
494 }
495 
496 HWTEST_F(SubCommandRecordTest, GroupEventsKernal, TestSize.Level1)
497 {
498     std::string opt = "-d 2 -c 0 -g ";
499     std::string uk = ":k";
500     TestEvents(opt, uk);
501 }
502 
503 HWTEST_F(SubCommandRecordTest, GroupEventsErr, TestSize.Level1)
504 {
505     ForkAndRunTest("-d 2 -c 0 -g what ", false);
506 }
507 
508 HWTEST_F(SubCommandRecordTest, NoInherit, TestSize.Level1)
509 {
510     ForkAndRunTest("-d 2 --no-inherit ");
511 }
512 
513 // select pid
514 HWTEST_F(SubCommandRecordTest, SelectPid, TestSize.Level1)
515 {
516     ForkAndRunTest("-d 2 -p 1 ", true, false);
517 }
518 
519 HWTEST_F(SubCommandRecordTest, KernelSymbols, TestSize.Level1)
520 {
521     TestRecordCommand("-d 2 -p 2 -s dwarf ", true, false);
522 }
523 
524 HWTEST_F(SubCommandRecordTest, SelectPidMulti, TestSize.Level1)
525 {
526     ForkAndRunTest("-d 2 -p 1,2,3 ", true, false);
527 }
528 
529 HWTEST_F(SubCommandRecordTest, SelectPidMinErr, TestSize.Level1)
530 {
531     TestRecordCommand("-d 2 -p 0 ", false, false);
532 }
533 
534 HWTEST_F(SubCommandRecordTest, SelectPidMinErr1, TestSize.Level1)
535 {
536     TestRecordCommand("-d 2 -p -1 ", false, false);
537 }
538 
539 HWTEST_F(SubCommandRecordTest, SelectPidErr, TestSize.Level1)
540 {
541     TestRecordCommand("-d 2 -p 99999999 ", false, false);
542 }
543 
544 HWTEST_F(SubCommandRecordTest, SelectPidInputErr, TestSize.Level1)
545 {
546     TestRecordCommand("-d 2 -p abc ", false, false);
547 }
548 
549 HWTEST_F(SubCommandRecordTest, SelectPidInputConfict, TestSize.Level1)
550 {
551     ForkAndRunTest("-d 2 -a -p 1 ", false, false);
552 }
553 
554 // select tid
555 HWTEST_F(SubCommandRecordTest, SelectTid, TestSize.Level1)
556 {
557     ForkAndRunTest("-d 2 -t 1 ", true, false);
558 }
559 
560 HWTEST_F(SubCommandRecordTest, SelectTidMulti, TestSize.Level1)
561 {
562     ForkAndRunTest("-d 2 -t 1,2,3 ", true, false);
563 }
564 
565 HWTEST_F(SubCommandRecordTest, SelectTidMinErr, TestSize.Level1)
566 {
567     TestRecordCommand("-d 2 -t 0 ", false, false);
568 }
569 
570 HWTEST_F(SubCommandRecordTest, SelectTidErr, TestSize.Level1)
571 {
572     TestRecordCommand("-d 2 -t 99999999 ", false, false);
573 }
574 
575 HWTEST_F(SubCommandRecordTest, SelectTidInputErr, TestSize.Level1)
576 {
577     TestRecordCommand("-d 2 -t abc ", false, false);
578 }
579 
580 // cpu off
581 HWTEST_F(SubCommandRecordTest, CpuOff, TestSize.Level1)
582 {
583     ForkAndRunTest("-d 2 --offcpu ");
584 }
585 
586 HWTEST_F(SubCommandRecordTest, BranchFilterAny, TestSize.Level1)
587 {
588 #if is_ohos
589     TestRecordCommand("-d 2 -j any ", false); // broad doesn't support
590 #else
591     ForkAndRunTest("-d 2 -j any ");
592 #endif
593 }
594 
595 HWTEST_F(SubCommandRecordTest, BranchFilterAnyCall, TestSize.Level1)
596 {
597 #if is_ohos
598     TestRecordCommand("-d 2 -j any_call ", false); // broad doesn't support
599 #else
600     ForkAndRunTest("-d 2 -j any_call ");
601 #endif
602 }
603 
604 HWTEST_F(SubCommandRecordTest, BranchFilterIndCall, TestSize.Level1)
605 {
606 #if is_ohos
607     TestRecordCommand("-d 2 -j ind_call ", false); // broad doesn't support
608 #else
609     ForkAndRunTest("-d 2 -j ind_call ");
610 #endif
611 }
612 
613 HWTEST_F(SubCommandRecordTest, BranchFilterAnyRet, TestSize.Level1)
614 {
615 #if is_ohos
616     TestRecordCommand("-d 2 -j any_ret ", false); // broad doesn't support
617 #else
618     ForkAndRunTest("-d 2 -j any_ret ");
619 #endif
620 }
621 
622 HWTEST_F(SubCommandRecordTest, BranchFilterOnlyCall, TestSize.Level1)
623 {
624     TestRecordCommand("-d 2 -j call ", false);
625 }
626 
627 HWTEST_F(SubCommandRecordTest, BranchFilterAll, TestSize.Level1)
628 {
629 #if is_ohos
630     TestRecordCommand("-d 2 -j any,any_call,any_ret,ind_call,u,k ", false); // broad doesn't support
631 #else
632     ForkAndRunTest("-d 2 -j any,any_call,any_ret,ind_call,u,k ");
633 #endif
634 }
635 
636 HWTEST_F(SubCommandRecordTest, BranchFilterInputErr, TestSize.Level1)
637 {
638     TestRecordCommand("-d 2 -j what ", false);
639 }
640 
641 HWTEST_F(SubCommandRecordTest, BranchFilterInputMoreErr, TestSize.Level1)
642 {
643     TestRecordCommand("-d 2 -j any,n ", false);
644 }
645 
646 // call stack
647 HWTEST_F(SubCommandRecordTest, CallStackFp, TestSize.Level1)
648 {
649     ForkAndRunTest("-d 2 --call-stack fp ");
650     TearDown();
651     SetUp();
652     ForkAndRunTest("-d 2 -s fp ");
653 }
654 
655 HWTEST_F(SubCommandRecordTest, CallStackFpInputMoreErr, TestSize.Level1)
656 {
657     TestRecordCommand("-d 2 --call-stack fp,abc ", false);
658     TearDown();
659     SetUp();
660     TestRecordCommand("-d 2 -s fp,abc ", false);
661 }
662 
663 HWTEST_F(SubCommandRecordTest, CallStackInputErr, TestSize.Level1)
664 {
665     TestRecordCommand("-d 2 --call-stack what ", false);
666     TearDown();
667     SetUp();
668     TestRecordCommand("-d 2 -s what ", false);
669 }
670 
671 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeMin, TestSize.Level1)
672 {
673     // it will cause some crash in -fprofile-arcs and -ftest-coverage
674     // we will fix it latter
675     ForkAndRunTest("-d 2 --call-stack dwarf,8 ");
676     TearDown();
677     SetUp();
678     ForkAndRunTest("-d 2 -s dwarf,8 ");
679 }
680 
681 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeMinErr, TestSize.Level1)
682 {
683     TestRecordCommand("-d 2 --call-stack dwarf,7 ", false);
684     TearDown();
685     SetUp();
686     TestRecordCommand("-d 2 -s dwarf,7 ", false);
687 }
688 
689 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeMax, TestSize.Level1)
690 {
691     ForkAndRunTest("-d 2 --call-stack dwarf,65528 ");
692     TearDown();
693     SetUp();
694     ForkAndRunTest("-d 2 -s dwarf,65528 ");
695 }
696 
697 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeMaxErr, TestSize.Level1)
698 {
699     TestRecordCommand("-d 2 --call-stack dwarf,65529 ", false);
700     TearDown();
701     SetUp();
702     TestRecordCommand("-d 2 -s dwarf,65529 ", false);
703 }
704 
705 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeErr, TestSize.Level1)
706 {
707     TestRecordCommand("-d 2 --call-stack dwarf,15 ", false);
708     TearDown();
709     SetUp();
710     TestRecordCommand("-d 2 -s dwarf,15 ", false);
711 }
712 
713 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeInputErr, TestSize.Level1)
714 {
715     TestRecordCommand("-d 2 --call-stack dwarf,abc ", false);
716     TearDown();
717     SetUp();
718     TestRecordCommand("-d 2 -s dwarf,abc ", false);
719 }
720 
721 HWTEST_F(SubCommandRecordTest, CallStackDwarfSizeInputMoreErr, TestSize.Level1)
722 {
723     TestRecordCommand("-d 2 --call-stack dwarf,16,32 ", false);
724     TearDown();
725     SetUp();
726     TestRecordCommand("-d 2 -s dwarf,16,32 ", false);
727 }
728 
729 HWTEST_F(SubCommandRecordTest, CallStackUsageErr, TestSize.Level1)
730 {
731     TestRecordCommand("-d 2 -s abc --call-stack bcd", false);
732 }
733 
734 // unwind
735 HWTEST_F(SubCommandRecordTest, DlayUnwind, TestSize.Level1)
736 {
737     ForkAndRunTest("-d 2 -s dwarf,16 --delay-unwind ");
738 }
739 
740 HWTEST_F(SubCommandRecordTest, DisableUnwind, TestSize.Level1)
741 {
742     ForkAndRunTest("-d 2 -s dwarf,16 --disable-unwind ");
743 }
744 
745 HWTEST_F(SubCommandRecordTest, DisableCallstackMerge, TestSize.Level1)
746 {
747     ForkAndRunTest("-d 2 -s dwarf,16 --disable-callstack-expand ");
748 }
749 
750 // symbol dir
751 HWTEST_F(SubCommandRecordTest, SymbolDir, TestSize.Level1)
752 {
753     ForkAndRunTest("-d 2 --symbol-dir ./ ");
754 }
755 
756 HWTEST_F(SubCommandRecordTest, SymbolDirErr, TestSize.Level1)
757 {
758     TestRecordCommand("-d 2 --symbol-dir where ", false);
759 }
760 
761 // clock id
762 HWTEST_F(SubCommandRecordTest, ClockIdMonotonic, TestSize.Level1)
763 {
764     ForkAndRunTest("-d 2 --clockid monotonic ");
765 }
766 
767 HWTEST_F(SubCommandRecordTest, ClockIdMonotonicRaw, TestSize.Level1)
768 {
769     ForkAndRunTest("-d 2 --clockid monotonic_raw ");
770 }
771 
772 HWTEST_F(SubCommandRecordTest, ClockIdBoottime, TestSize.Level1)
773 {
774     ForkAndRunTest("-c 0 -d 2 -e sw-task-clock --clockid boottime ");
775 }
776 
777 HWTEST_F(SubCommandRecordTest, ClockIdRealtime, TestSize.Level1)
778 {
779     ForkAndRunTest("-c 0 -d 2 -e sw-task-clock --clockid realtime ");
780 }
781 
782 HWTEST_F(SubCommandRecordTest, ClockIdClockTai, TestSize.Level1)
783 {
784     ForkAndRunTest("-c 0 -d 2 -e sw-task-clock --clockid clock_tai ");
785 }
786 
787 HWTEST_F(SubCommandRecordTest, ClockIdInputErr, TestSize.Level1)
788 {
789     TestRecordCommand("-c 0 -d 2 --clockid what ", false);
790 }
791 
792 // mmap pages
793 HWTEST_F(SubCommandRecordTest, MmapPagesPower2Err, TestSize.Level1)
794 {
795     TestRecordCommand("-d 2 -m 101 ", false);
796 }
797 
798 HWTEST_F(SubCommandRecordTest, MmapPagesMin, TestSize.Level1)
799 {
800     ForkAndRunTest("-d 2 -m 2 ");
801 }
802 
803 HWTEST_F(SubCommandRecordTest, MmapPagesMinErr, TestSize.Level1)
804 {
805     TestRecordCommand("-d 2 -m 1 ", false);
806 }
807 
808 HWTEST_F(SubCommandRecordTest, MmapPagesMax, TestSize.Level1)
809 {
810     ForkAndRunTest("-d 2 -m 1024 ");
811 }
812 
813 HWTEST_F(SubCommandRecordTest, MmapPagesMaxErr, TestSize.Level1)
814 {
815     TestRecordCommand("-d 2 -m 1025 ", false);
816 }
817 
818 HWTEST_F(SubCommandRecordTest, MmapPagesInputErr, TestSize.Level1)
819 {
820     TestRecordCommand("-d 2 -m abc ", false);
821 }
822 
823 // output file name
824 HWTEST_F(SubCommandRecordTest, OutputFileName, TestSize.Level1)
825 {
826     ForkAndRunTest("-d 2 -o /data/local/tmp/output.perf.data ");
827 }
828 
829 HWTEST_F(SubCommandRecordTest, OutputFileNameErr, TestSize.Level1)
830 {
831     TestRecordCommand("-d 2 -o nopath/output.perf.data ", false);
832 }
833 
834 // data size limit
835 HWTEST_F(SubCommandRecordTest, DataLimit, TestSize.Level1)
836 {
837     ForkAndRunTest("-d 2 --data-limit 1K ");
838     TearDown();
839     SetUp();
840     ForkAndRunTest("-d 2 --data-limit 1M ");
841     TearDown();
842     SetUp();
843     ForkAndRunTest("-d 2 --data-limit 1G ");
844 }
845 
846 HWTEST_F(SubCommandRecordTest, DataLimit1, TestSize.Level1)
847 {
848     ForkAndRunTest("-a --data-limit 1K ", true, false);
849 }
850 
851 HWTEST_F(SubCommandRecordTest, DataLimitErr, TestSize.Level1)
852 {
853     TestRecordCommand("-d 2 --data-limit 10A ", false);
854     TearDown();
855     SetUp();
856     TestRecordCommand("-d 2 --data-limit 0G ", false);
857 }
858 
859 HWTEST_F(SubCommandRecordTest, RecordCompress, TestSize.Level1)
860 {
861     ForkAndRunTest("-d 2 -z ");
862 }
863 
864 HWTEST_F(SubCommandRecordTest, Verbose, TestSize.Level1)
865 {
866     ForkAndRunTest("-d 2 --verbose ");
867 }
868 
869 HWTEST_F(SubCommandRecordTest, DumpOptions, TestSize.Level1)
870 {
871     StdoutRecord stdoutRecord;
872     stdoutRecord.Start();
873     SubCommandRecord cmd;
874     cmd.DumpOptions();
875     std::string stringOut = stdoutRecord.Stop();
876     EXPECT_TRUE(stringOut.find("cpuPercent:	25") != std::string::npos);
877     EXPECT_TRUE(stringOut.find("mmapPages_:	1024") != std::string::npos);
878 }
879 
880 /**
881  * @tc.name: FileSizeOnFrequency100_DWARF_SYSTEM
882  * @tc.desc: Test size of file generated under system wide frequency 100 and dwarf unwind
883  * @tc.type: FUNC
884  */
885 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency100_DWARF_SYSTEM, TestSize.Level1)
886 {
887     ForkAndRunTest("-d 10 -a -f 100 -s dwarf", true, false);
888     std::string fileName = TEST_FILE;
889     size_t fileSize = GetFileSize(fileName.c_str());
890     EXPECT_LE(fileSize, TEST_SIZE_F100_DWARF_SYSTEM);
891 }
892 
893 /**
894  * @tc.name: FileSizeOnFrequency500_DWARF_SYSTEM
895  * @tc.desc: Test size of file generated under system wide frequency 500 and dwarf unwind
896  * @tc.type: FUNC
897  */
898 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency500_DWARF_SYSTEM, TestSize.Level1)
899 {
900     ForkAndRunTest("-d 10 -a -f 500 -s dwarf", true, false);
901     std::string fileName = TEST_FILE;
902     size_t fileSize = GetFileSize(fileName.c_str());
903     EXPECT_LE(fileSize, TEST_SIZE_F500_DWARF_SYSTEM);
904 }
905 
906 /**
907  * @tc.name: FileSizeOnFrequency1000_DWARF_SYSTEM
908  * @tc.desc: Test size of file generated under system wide frequency 1000 and dwarf unwind
909  * @tc.type: FUNC
910  */
911 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency1000_DWARF_SYSTEM, TestSize.Level1)
912 {
913     ForkAndRunTest("-d 10 -a -f 1000 -s dwarf", true, false);
914     std::string fileName = TEST_FILE;
915     size_t fileSize = GetFileSize(fileName.c_str());
916     EXPECT_LE(fileSize, TEST_SIZE_F1000_DWARF_SYSTEM);
917 }
918 
919 /**
920  * @tc.name: FileSizeOnFrequency2000_DWARF_SYSTEM
921  * @tc.desc: Test size of file generated under system wide frequency 2000 and dwarf unwind
922  * @tc.type: FUNC
923  */
924 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency2000_DWARF_SYSTEM, TestSize.Level1)
925 {
926     ForkAndRunTest("-d 10 -a -f 2000 -s dwarf", true, false);
927     std::string fileName = TEST_FILE;
928     size_t fileSize = GetFileSize(fileName.c_str());
929     EXPECT_LE(fileSize, TEST_SIZE_F2000_DWARF_SYSTEM);
930 }
931 
932 /**
933  * @tc.name: FileSizeOnFrequency4000_DWARF_SYSTEM
934  * @tc.desc: Test size of file generated under system wide frequency 4000 and dwarf unwind
935  * @tc.type: FUNC
936  */
937 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency4000_DWARF_SYSTEM, TestSize.Level1)
938 {
939     ForkAndRunTest("-d 10 -a -f 4000 -s dwarf", true, false);
940     std::string fileName = TEST_FILE;
941     size_t fileSize = GetFileSize(fileName.c_str());
942     EXPECT_LE(fileSize, TEST_SIZE_F4000_DWARF_SYSTEM);
943 }
944 
945 /**
946  * @tc.name: FileSizeOnFrequency8000_DWARF_SYSTEM
947  * @tc.desc: Test size of file generated under system wide frequency 8000 and dwarf unwind
948  * @tc.type: FUNC
949  */
950 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency8000_DWARF_SYSTEM, TestSize.Level1)
951 {
952     ForkAndRunTest("-d 10 -a -f 8000 -s dwarf", true, false);
953     std::string fileName = TEST_FILE;
954     size_t fileSize = GetFileSize(fileName.c_str());
955     EXPECT_LE(fileSize, TEST_SIZE_F8000_DWARF_SYSTEM);
956 }
957 
958 /**
959  * @tc.name: FileSizeOnFrequency100_FP_SYSTEM
960  * @tc.desc: Test size of file generated under system wide frequency 100 and fp unwind
961  * @tc.type: FUNC
962  */
963 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency100_FP_SYSTEM, TestSize.Level1)
964 {
965     ForkAndRunTest("-d 10 -a -f 100 -s fp", true, false);
966     std::string fileName = TEST_FILE;
967     size_t fileSize = GetFileSize(fileName.c_str());
968     EXPECT_LE(fileSize, TEST_SIZE_F100_FP_SYSTEM);
969 }
970 
971 /**
972  * @tc.name: FileSizeOnFrequency500_FP_SYSTEM
973  * @tc.desc: Test size of file generated under system wide frequency 500 and fp unwind
974  * @tc.type: FUNC
975  */
976 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency500_FP_SYSTEM, TestSize.Level1)
977 {
978     ForkAndRunTest("-d 10 -a -f 500 -s fp", true, false);
979     std::string fileName = TEST_FILE;
980     size_t fileSize = GetFileSize(fileName.c_str());
981     EXPECT_LE(fileSize, TEST_SIZE_F500_FP_SYSTEM);
982 }
983 
984 /**
985  * @tc.name: FileSizeOnFrequency1000_FP_SYSTEM
986  * @tc.desc: Test size of file generated under system wide frequency 1000 and fp unwind
987  * @tc.type: FUNC
988  */
989 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency1000_FP_SYSTEM, TestSize.Level1)
990 {
991     ForkAndRunTest("-d 10 -a -f 1000 -s fp", true, false);
992     std::string fileName = TEST_FILE;
993     size_t fileSize = GetFileSize(fileName.c_str());
994     EXPECT_LE(fileSize, TEST_SIZE_F1000_FP_SYSTEM);
995 }
996 
997 /**
998  * @tc.name: FileSizeOnFrequency2000_FP_SYSTEM
999  * @tc.desc: Test size of file generated under system wide frequency 2000 and fp unwind
1000  * @tc.type: FUNC
1001  */
1002 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency2000_FP_SYSTEM, TestSize.Level1)
1003 {
1004     ForkAndRunTest("-d 10 -a -f 2000 -s fp", true, false);
1005     std::string fileName = TEST_FILE;
1006     size_t fileSize = GetFileSize(fileName.c_str());
1007     EXPECT_LE(fileSize, TEST_SIZE_F2000_FP_SYSTEM);
1008 }
1009 
1010 /**
1011  * @tc.name: FileSizeOnFrequency4000_FP_SYSTEM
1012  * @tc.desc: Test size of file generated under system wide frequency 4000 and fp unwind
1013  * @tc.type: FUNC
1014  */
1015 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency4000_FP_SYSTEM, TestSize.Level1)
1016 {
1017     ForkAndRunTest("-d 10 -a -f 4000 -s fp", true, false);
1018     std::string fileName = TEST_FILE;
1019     size_t fileSize = GetFileSize(fileName.c_str());
1020     EXPECT_LE(fileSize, TEST_SIZE_F4000_FP_SYSTEM);
1021 }
1022 
1023 /**
1024  * @tc.name: FileSizeOnFrequency8000_FP_SYSTEM
1025  * @tc.desc: Test size of file generated under system wide frequency 8000 and fp unwind
1026  * @tc.type: FUNC
1027  */
1028 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency8000_FP_SYSTEM, TestSize.Level1)
1029 {
1030     ForkAndRunTest("-d 10 -a -f 8000 -s fp", true, false);
1031     std::string fileName = TEST_FILE;
1032     size_t fileSize = GetFileSize(fileName.c_str());
1033     EXPECT_LE(fileSize, TEST_SIZE_F8000_FP_SYSTEM);
1034 }
1035 
1036 /**
1037  * @tc.name: FileSizeOnFrequency100_DWARF_PROCESS
1038  * @tc.desc: Test size of file generated under one process frequency 100 and dwarf unwind
1039  * @tc.type: FUNC
1040  */
1041 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency100_DWARF_PROCESS, TestSize.Level1)
1042 {
1043     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 100 -s dwarf", true, false);
1044     std::string fileName = TEST_FILE;
1045     size_t fileSize = GetFileSize(fileName.c_str());
1046     EXPECT_LE(fileSize, TEST_SIZE_F100_DWARF_PROCESS);
1047 }
1048 
1049 /**
1050  * @tc.name: FileSizeOnFrequency500_DWARF_PROCESS
1051  * @tc.desc: Test size of file generated under one process frequency 500 and dwarf unwind
1052  * @tc.type: FUNC
1053  */
1054 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency500_DWARF_PROCESS, TestSize.Level1)
1055 {
1056     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 500 -s dwarf", true, false);
1057     std::string fileName = TEST_FILE;
1058     size_t fileSize = GetFileSize(fileName.c_str());
1059     EXPECT_LE(fileSize, TEST_SIZE_F500_DWARF_PROCESS);
1060 }
1061 
1062 /**
1063  * @tc.name: FileSizeOnFrequency1000_DWARF_PROCESS
1064  * @tc.desc: Test size of file generated under one process frequency 1000 and dwarf unwind
1065  * @tc.type: FUNC
1066  */
1067 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency1000_DWARF_PROCESS, TestSize.Level1)
1068 {
1069     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 1000 -s dwarf", true, false);
1070     std::string fileName = TEST_FILE;
1071     size_t fileSize = GetFileSize(fileName.c_str());
1072     EXPECT_LE(fileSize, TEST_SIZE_F1000_DWARF_PROCESS);
1073 }
1074 
1075 /**
1076  * @tc.name: FileSizeOnFrequency2000_DWARF_PROCESS
1077  * @tc.desc: Test size of file generated under one process frequency 2000 and dwarf unwind
1078  * @tc.type: FUNC
1079  */
1080 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency2000_DWARF_PROCESS, TestSize.Level1)
1081 {
1082     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 2000 -s dwarf", true, false);
1083     std::string fileName = TEST_FILE;
1084     size_t fileSize = GetFileSize(fileName.c_str());
1085     EXPECT_LE(fileSize, TEST_SIZE_F2000_DWARF_PROCESS);
1086 }
1087 
1088 /**
1089  * @tc.name: FileSizeOnFrequency4000_DWARF_PROCESS
1090  * @tc.desc: Test size of file generated under one process frequency 4000 and dwarf unwind
1091  * @tc.type: FUNC
1092  */
1093 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency4000_DWARF_PROCESS, TestSize.Level1)
1094 {
1095     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 4000 -s dwarf", true, false);
1096     std::string fileName = TEST_FILE;
1097     size_t fileSize = GetFileSize(fileName.c_str());
1098     EXPECT_LE(fileSize, TEST_SIZE_F4000_DWARF_PROCESS);
1099 }
1100 
1101 /**
1102  * @tc.name: FileSizeOnFrequency8000_DWARF_PROCESS
1103  * @tc.desc: Test size of file generated under one process frequency 8000 and dwarf unwind
1104  * @tc.type: FUNC
1105  */
1106 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency8000_DWARF_PROCESS, TestSize.Level1)
1107 {
1108     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 8000 -s dwarf", true, false);
1109     std::string fileName = TEST_FILE;
1110     size_t fileSize = GetFileSize(fileName.c_str());
1111     EXPECT_LE(fileSize, TEST_SIZE_F8000_DWARF_PROCESS);
1112 }
1113 
1114 /**
1115  * @tc.name: FileSizeOnFrequency100_FP_PROCESS
1116  * @tc.desc: Test size of file generated under one process frequency 100 and fp unwind
1117  * @tc.type: FUNC
1118  */
1119 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency100_FP_PROCESS, TestSize.Level1)
1120 {
1121     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 100 -s fp", true, false);
1122     std::string fileName = TEST_FILE;
1123     size_t fileSize = GetFileSize(fileName.c_str());
1124     EXPECT_LE(fileSize, TEST_SIZE_F100_FP_PROCESS);
1125 }
1126 
1127 /**
1128  * @tc.name: FileSizeOnFrequency500_FP_PROCESS
1129  * @tc.desc: Test size of file generated under one process frequency 500 and fp unwind
1130  * @tc.type: FUNC
1131  */
1132 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency500_FP_PROCESS, TestSize.Level1)
1133 {
1134     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 500 -s fp", true, false);
1135     std::string fileName = TEST_FILE;
1136     size_t fileSize = GetFileSize(fileName.c_str());
1137     EXPECT_LE(fileSize, TEST_SIZE_F500_FP_PROCESS);
1138 }
1139 
1140 /**
1141  * @tc.name: FileSizeOnFrequency1000_FP_PROCESS
1142  * @tc.desc: Test size of file generated under one process frequency 1000 and fp unwind
1143  * @tc.type: FUNC
1144  */
1145 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency1000_FP_PROCESS, TestSize.Level1)
1146 {
1147     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 1000 -s fp", true, false);
1148     std::string fileName = TEST_FILE;
1149     size_t fileSize = GetFileSize(fileName.c_str());
1150     EXPECT_LE(fileSize, TEST_SIZE_F1000_FP_PROCESS);
1151 }
1152 
1153 /**
1154  * @tc.name: FileSizeOnFrequency2000_FP_PROCESS
1155  * @tc.desc: Test size of file generated under one process frequency 2000 and fp unwind
1156  * @tc.type: FUNC
1157  */
1158 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency2000_FP_PROCESS, TestSize.Level1)
1159 {
1160     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 2000 -s fp", true, false);
1161     std::string fileName = TEST_FILE;
1162     size_t fileSize = GetFileSize(fileName.c_str());
1163     EXPECT_LE(fileSize, TEST_SIZE_F2000_FP_PROCESS);
1164 }
1165 
1166 /**
1167  * @tc.name: FileSizeOnFrequency4000_FP_PROCESS
1168  * @tc.desc: Test size of file generated under one process frequency 4000 and fp unwind
1169  * @tc.type: FUNC
1170  */
1171 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency4000_FP_PROCESS, TestSize.Level1)
1172 {
1173     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 4000 -s fp", true, false);
1174     std::string fileName = TEST_FILE;
1175     size_t fileSize = GetFileSize(fileName.c_str());
1176     EXPECT_LE(fileSize, TEST_SIZE_F4000_FP_PROCESS);
1177 }
1178 
1179 /**
1180  * @tc.name: FileSizeOnFrequency8000_FP_PROCESS
1181  * @tc.desc: Test size of file generated under one process frequency 8000 and fp unwind
1182  * @tc.type: FUNC
1183  */
1184 HWTEST_F(SubCommandRecordTest, FileSizeOnFrequency8000_FP_PROCESS, TestSize.Level1)
1185 {
1186     ForkAndRunTest("-d 10 --app com.ohos.systemui -f 8000 -s fp", true, false);
1187     std::string fileName = TEST_FILE;
1188     size_t fileSize = GetFileSize(fileName.c_str());
1189     EXPECT_LE(fileSize, TEST_SIZE_F8000_FP_PROCESS);
1190 }
1191 
1192 /**
1193  * @tc.name: ExcludeThreadName
1194  * @tc.desc: Test --exclude-thread option sucess
1195  * @tc.type: FUNC
1196  */
1197 HWTEST_F(SubCommandRecordTest, ExcludeThreadName, TestSize.Level1)
1198 {
1199     ForkAndRunTest("-d 2 --exclude-thread DfxWatchdog ", true);
1200 }
1201 
1202 /**
1203  * @tc.name: ExcludeThreadNames
1204  * @tc.desc: Test --exclude-thread option multi threads
1205  * @tc.type: FUNC
1206  */
1207 HWTEST_F(SubCommandRecordTest, ExcludeThreadNames, TestSize.Level1)
1208 {
1209     ForkAndRunTest("-d 2 --exclude-thread DfxWatchdog,GC_WorkerThread ", true);
1210 }
1211 
1212 /**
1213  * @tc.name: ExcludeErrorThreadName
1214  * @tc.desc: Test --exclude-thread option error thread name
1215  * @tc.type: FUNC
1216  */
1217 HWTEST_F(SubCommandRecordTest, ExcludeErrorThreadName, TestSize.Level1)
1218 {
1219     ForkAndRunTest("-d 2 --exclude-thread test ", true);
1220 }
1221 
1222 /**
1223  * @tc.name: ExcludeErrorThreadNames
1224  * @tc.desc: Test --exclude-thread option multi error thread names
1225  * @tc.type: FUNC
1226  */
1227 HWTEST_F(SubCommandRecordTest, ExcludeErrorThreadNames, TestSize.Level1)
1228 {
1229     ForkAndRunTest("-d 2 --exclude-thread test1,test2 ", true);
1230 }
1231 
1232 /**
1233  * @tc.name: ExcludeMixedThreadName
1234  * @tc.desc: Test --exclude-thread option mixed correct name and error name
1235  * @tc.type: FUNC
1236  */
1237 HWTEST_F(SubCommandRecordTest, ExcludeMixedThreadName, TestSize.Level1)
1238 {
1239     ForkAndRunTest("-d 2 --exclude-thread DfxWatchdog,test ", true);
1240 }
1241 
1242 // --restart
1243 HWTEST_F(SubCommandRecordTest, ReStartNotApp1, TestSize.Level1)
1244 {
1245     TestRecordCommand("-p 5 --restart ", false ,false);
1246 }
1247 
1248 HWTEST_F(SubCommandRecordTest, ReStartNotApp2, TestSize.Level1)
1249 {
1250     TestRecordCommand("-a --restart ", false ,false);
1251 }
1252 
1253 HWTEST_F(SubCommandRecordTest, ReStartNotApp3, TestSize.Level1)
1254 {
1255     TestRecordCommand("-p 5 -a --restart ", false ,false);
1256 }
1257 
1258 HWTEST_F(SubCommandRecordTest, ReStartConflict, TestSize.Level1)
1259 {
1260     TestRecordCommand("--restart -a ", false ,true);
1261 }
1262 
1263 HWTEST_F(SubCommandRecordTest, ReStart, TestSize.Level1)
1264 {
1265     TestRecordCommand("--restart ", false ,true);
1266 }
1267 
1268 // --exclude-tid
1269 HWTEST_F(SubCommandRecordTest, ExcludeTidConflict, TestSize.Level1)
1270 {
1271     TestRecordCommand("--exclude-tid 5 --exclude-thread test ", false , true);
1272 }
1273 
1274 /**
1275  * @tc.name: CmdLinesSizeSucess
1276  * @tc.desc: Test --cmdline-size option
1277  * @tc.type: FUNC
1278  */
1279 HWTEST_F(SubCommandRecordTest, CmdLinesSizeSucess, TestSize.Level1)
1280 {
1281     ForkAndRunTest("-d 2 --cmdline-size 1024 ", true);
1282 }
1283 
1284 /**
1285  * @tc.name: CmdLinesSizeOutRange
1286  * @tc.desc: Test --cmdline-size option
1287  * @tc.type: FUNC
1288  */
1289 HWTEST_F(SubCommandRecordTest, CmdLinesSizeOutRange, TestSize.Level1)
1290 {
1291     TestRecordCommand("-d 2 --cmdline-size 8192 ", false);
1292 }
1293 
1294 /**
1295  * @tc.name: CmdLinesSizeNotPowerOf2
1296  * @tc.desc: Test --cmdline-size option
1297  * @tc.type: FUNC
1298  */
1299 HWTEST_F(SubCommandRecordTest, CmdLinesSizeNotPowerOf2, TestSize.Level1)
1300 {
1301     TestRecordCommand("-d 2 --cmdline-size 1000 ", false);
1302 }
1303 
1304 /**
1305  * @tc.name: EnableDebugInfoSymbolicFp
1306  * @tc.desc: Test --enable-debuginfo-symbolic option with -s fp
1307  * @tc.type: FUNC
1308  */
1309 HWTEST_F(SubCommandRecordTest, EnableDebugInfoSymbolicFp, TestSize.Level1)
1310 {
1311     ForkAndRunTest("-d 2 -s fp --enable-debuginfo-symbolic ", true);
1312 }
1313 
1314 /**
1315  * @tc.name: EnableDebugInfoSymbolicDwarf
1316  * @tc.desc: Test --enable-debuginfo-symbolic option with -s dwarf
1317  * @tc.type: FUNC
1318  */
1319 HWTEST_F(SubCommandRecordTest, EnableDebugInfoSymbolicDwarf, TestSize.Level1)
1320 {
1321     ForkAndRunTest("-d 2 -s dwarf --enable-debuginfo-symbolic ", true);
1322 }
1323 
1324 /**
1325  * @tc.name: CallChainUserOnlyFp
1326  * @tc.desc: Test --callchain-useronly option with fp
1327  * @tc.type: FUNC
1328  */
1329 HWTEST_F(SubCommandRecordTest, CallChainUserOnlyFp, TestSize.Level1)
1330 {
1331     ForkAndRunTest("-d 2 -s fp --callchain-useronly", true, true);
1332 }
1333 
1334 /**
1335  * @tc.name: CallChainUserOnlyDwarf
1336  * @tc.desc: Test --callchain-useronly option with dwarf
1337  * @tc.type: FUNC
1338  */
1339 HWTEST_F(SubCommandRecordTest, CallChainUserOnlyDwarf, TestSize.Level1)
1340 {
1341     ForkAndRunTest("-d 2 -s dwarf --callchain-useronly", true, true);
1342 }
1343 
1344 /**
1345  * @tc.name: CallChainUserOnlyError
1346  * @tc.desc: Test --callchain-useronly option without fp/dwarf
1347  * @tc.type: FUNC
1348  */
1349 HWTEST_F(SubCommandRecordTest, CallChainUserOnlyError, TestSize.Level1)
1350 {
1351     ForkAndRunTest("-d 2 --callchain-useronly", false, true);
1352 }
1353 
1354 /**
1355  * @tc.name: DedupStack
1356  * @tc.desc: Test --dedup_stack option
1357  * @tc.type: FUNC
1358  */
1359 HWTEST_F(SubCommandRecordTest, DedupStack, TestSize.Level1)
1360 {
1361     ForkAndRunTest("-d 2 -s dwarf --dedup_stack", true, true);
1362 }
1363 
1364 /**
1365  * @tc.name: DedupStackErr
1366  * @tc.desc: Test --dedup_stack option with -a
1367  * @tc.type: FUNC
1368  */
1369 HWTEST_F(SubCommandRecordTest, DedupStackErr, TestSize.Level1)
1370 {
1371     TestRecordCommand("-d 2 -a -s dwarf --dedup_stack", false, false);
1372 }
1373 
1374 /**
1375  * @tc.name: TestNoFork
1376  * @tc.desc: Test no fork
1377  * @tc.type: FUNC
1378  */
1379 HWTEST_F(SubCommandRecordTest, TestNoFork, TestSize.Level1)
1380 {
1381     TestRecordCommand("-d 2 -s dwarf --dedup_stack -f 2000 --cmdline-size 1024", true, true);
1382 }
1383 
1384 /**
1385  * @tc.name: TestAllNoFork
1386  * @tc.desc: Test no fork with -a
1387  * @tc.type: FUNC
1388  */
1389 HWTEST_F(SubCommandRecordTest, TestAllNoFork, TestSize.Level1)
1390 {
1391     TestRecordCommand("-d 2 -a -s dwarf --clockid monotonic --exclude-hiperf", true, false);
1392 }
1393 } // namespace HiPerf
1394 } // namespace Developtools
1395 } // namespace OHOS
1396