1 /*
2 * Copyright (c) 2021-2022 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 <cstdio>
17 #include <iostream>
18 #include <string>
19
20 #include "perf_file_reader.h"
21 #include "perf_file_reader_test.h"
22
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace Developtools {
26 namespace HiPerf {
27 using ProcessRecordCB = const std::function<bool(PerfEventRecord& record)>;
28 class PerfFileReaderTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
SetUpTestCase()36 void PerfFileReaderTest::SetUpTestCase() {}
37
TearDownTestCase()38 void PerfFileReaderTest::TearDownTestCase() {}
39
SetUp()40 void PerfFileReaderTest::SetUp() {}
TearDown()41 void PerfFileReaderTest::TearDown() {}
42
43 HWTEST_F(PerfFileReaderTest, Test_Instance_success, TestSize.Level1)
44 {
45 const std::string filename = "perf.data";
46 FILE *fp = stdout;
47 PerfFileReader hiperfFileReader(filename, fp);
48 std::unique_ptr<PerfFileReader> ret = hiperfFileReader.Instance(filename);
49 EXPECT_EQ(ret == nullptr, true);
50 }
51
52 HWTEST_F(PerfFileReaderTest, Test_Instance_fail, TestSize.Level3)
53 {
54 const std::string filename = "xxx";
55 FILE *fp = nullptr;
56 PerfFileReader hiperfFileReader(filename, fp);
57 std::unique_ptr<PerfFileReader> ret = hiperfFileReader.Instance(filename);
58 EXPECT_EQ(ret == nullptr, true);
59 }
60
61 HWTEST_F(PerfFileReaderTest, Test_ReadFetureSection_success, TestSize.Level0)
62 {
63 const std::string filename = "perf.data";
64 FILE *fp = stdout;
65 PerfFileReader hiperfFileReader(filename, fp);
66 bool ret = hiperfFileReader.ReadFeatureSection();
67 EXPECT_EQ(ret, true);
68 }
69
70 HWTEST_F(PerfFileReaderTest, Test_ReadFetureSection, TestSize.Level1)
71 {
72 const std::string filename = "xxx";
73 FILE *fp = nullptr;
74 PerfFileReader hiperfFileReader(filename, fp);
75 bool ret = hiperfFileReader.ReadFeatureSection();
76 EXPECT_EQ(ret, true);
77 }
78
79 HWTEST_F(PerfFileReaderTest, Test_GetFetures, TestSize.Level2)
80 {
81 const std::string filename = "perf.data";
82 FILE *fp = stdout;
83 PerfFileReader hiperfFileReader(filename, fp);
84 std::vector<FEATURE> features_;
85 FEATURE feture1 = FEATURE::RESERVED;
86 FEATURE feture2 = FEATURE::ARCH;
87 FEATURE feture3 = FEATURE::BUILD_ID;
88 FEATURE feture4 = FEATURE::LAST_FEATURE;
89 features_.push_back(feture1);
90 features_.push_back(feture2);
91 features_.push_back(feture3);
92 features_.push_back(feture4);
93 EXPECT_NE(features_.size(), hiperfFileReader.GetFeatures().size());
94 }
95
96 HWTEST_F(PerfFileReaderTest, Test_GetFetureString, TestSize.Level1)
97 {
98 const std::string filename = "perf.data";
99 FILE *fp = stdout;
100 PerfFileReader hiperfFileReader(filename, fp);
101 const FEATURE feture = FEATURE::ARCH;
102 const std::string result = "ARCH";
103 EXPECT_NE(hiperfFileReader.GetFeatureString(feture), result);
104 }
105
106 HWTEST_F(PerfFileReaderTest, ReadIdsForAttr1, TestSize.Level2)
107 {
108 perf_file_attr attr;
109 attr.ids.size = 2000000000;
110 std::vector<uint64_t> v;
111 PerfFileReader reader("", nullptr);
112 EXPECT_FALSE(reader.ReadIdsForAttr(attr, &v));
113 }
114
115 HWTEST_F(PerfFileReaderTest, ReadIdsForAttr2, TestSize.Level0)
116 {
117 perf_file_attr attr;
118 attr.ids.size = 1;
119 std::string fileName = "/proc/" + std::to_string(getpid()) + "/cmdline";
120 FILE* fp = fopen(fileName.c_str(), "r");
121 EXPECT_NE(fp, nullptr);
122 std::vector<uint64_t> v;
123 PerfFileReader reader("", fp);
124 EXPECT_TRUE(reader.ReadIdsForAttr(attr, &v));
125 EXPECT_NE(v.size(), 0);
126 }
127
128 HWTEST_F(PerfFileReaderTest, ReadIdsForAttr3, TestSize.Level1)
129 {
130 perf_file_attr attr;
131 attr.ids.size = 4;
132 attr.ids.offset = 0;
133 std::string fileName = "/proc/" + std::to_string(getpid()) + "/cmdline";
134 FILE* fp = fopen(fileName.c_str(), "r");
135 EXPECT_NE(fp, nullptr);
136 std::vector<uint64_t> v;
137 PerfFileReader reader("", fp);
138 EXPECT_TRUE(reader.ReadIdsForAttr(attr, &v));
139 EXPECT_TRUE(v.size() * sizeof(uint64_t) >= attr.ids.size);
140 }
141
142 HWTEST_F(PerfFileReaderTest, Test_OverAttrSize, TestSize.Level2)
143 {
144 const uint64_t overSize = 100 * sizeof(perf_file_attr);
145 std::string fileName = "/proc/" + std::to_string(getpid()) + "/cmdline";
146 FILE* fp = fopen(fileName.c_str(), "r");
147 EXPECT_NE(fp, nullptr);
148 PerfFileReader hiperfFileReader("", fp);
149 perf_file_header header = hiperfFileReader.GetHeader();
150 header.attrSize = overSize;
151 EXPECT_EQ(hiperfFileReader.ReadAttrSection(), false);
152 }
153 } // namespace HiPerf
154 } // namespace Developtools
155 } // namespace OHOS
156