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