1 /*
2 * Copyright (c) 2023 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 <fstream>
16 #include <iostream>
17 #include <regex>
18 #include <string>
19
20 #include "io_collector.h"
21
22 #include <gtest/gtest.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 class IoCollectorTest : public testing::Test {
30 public:
SetUp()31 void SetUp() {};
TearDown()32 void TearDown() {};
SetUpTestCase()33 static void SetUpTestCase() {};
TearDownTestCase()34 static void TearDownTestCase() {};
35 };
36
37 #ifdef UNIFIED_COLLECTOR_IO_ENABLE
38 namespace {
39 // %-13s\t%12s\t%12s\t%12s\t%12s\t%12s\t%12s\t%20s\t%20s
40 const std::regex ALL_PROC_IO_STATS1("^\\d{1,}\\s{1,}[\\w/\\.:-]{1,}\\s{1,}\\d{1,}(\\s{1,}\\d{1,}\\.\\d{2}){6}$");
41 const std::regex ALL_PROC_IO_STATS2("^[\\d\\s]{12}[\\s\\w/\\.:-]{13,}[\\s\\d]{13}([\\s\\d\\.]{13}){6}$");
42 // %-13s\t%20s\t%20s\t%20s\t%20s\t%12s\t%12s\t%12s
43 const std::regex DISK_STATS1("^\\w{1,}(\\s{1,}\\d{1,}\\.\\d{2}){4}(\\s{1,}\\d{1,}\\.\\d{4}){2}\\s{1,}\\d{1,}$");
44 const std::regex DISK_STATS2("^[\\w\\s]{13,}([\\s\\d\\.]{13}){4}([\\s\\d\\.]{13}){2}[\\s\\d]{13}$");
45 // %-15s\t%15s\t%15s\t%15s\t%15s
46 const std::regex EMMC_INFO1("^[\\w\\.]{1,}\\s{1,}\\w{1,}\\s{1,}[\\w\\s]{1,}\\w{1,}\\s{1,}\\d{1,}\\.\\d{2}$");
47 const std::regex EMMC_INFO2("^[\\w\\.\\s]{15,}([\\w\\s]{10}){3}[\\s\\d\\.]{12}$");
48 // %-12.2f\t%12.2f\t%12.2f\t%12.2f\t%12.2f\t%12.2f
49 const std::regex SYS_IO_STATS1("^\\d{1,}\\.\\d{2}(\\s{1,}\\d{1,}\\.\\d{2}){5}$");
50 const std::regex SYS_IO_STATS2("^[\\d\\s\\.]{12}([\\d\\s\\.]{13}){5}$");
51
CheckFormat(const std::string & fileName,const std::regex & reg1,const std::regex & reg2)52 bool CheckFormat(const std::string &fileName, const std::regex ®1, const std::regex ®2)
53 {
54 std::ifstream file;
55 file.open(fileName.c_str());
56 if (!file.is_open()) {
57 return false;
58 }
59 std::string line;
60 getline(file, line);
61 while (getline(file, line)) {
62 if (line.size() > 0 && line[line.size() - 1] == '\r') {
63 line.erase(line.size() - 1, 1);
64 }
65 if (line.size() == 0) {
66 continue;
67 }
68 if (!regex_match(line, reg1) || !regex_match(line, reg2)) {
69 file.close();
70 return false;
71 }
72 }
73 file.close();
74 return true;
75 }
76 }
77
78 /**
79 * @tc.name: IoCollectorTest001
80 * @tc.desc: used to test IoCollector.CollectProcessIo
81 * @tc.type: FUNC
82 */
83 HWTEST_F(IoCollectorTest, IoCollectorTest001, TestSize.Level1)
84 {
85 std::shared_ptr<IoCollector> collector = IoCollector::Create();
86 CollectResult<ProcessIo> data = collector->CollectProcessIo(1000);
87 std::cout << "collect process io result" << data.retCode << std::endl;
88 ASSERT_TRUE(data.retCode == UcError::SUCCESS);
89 }
90
91 /**
92 * @tc.name: IoCollectorTest002
93 * @tc.desc: used to test IoCollector.CollectRawDiskStats
94 * @tc.type: FUNC
95 */
96 HWTEST_F(IoCollectorTest, IoCollectorTest002, TestSize.Level1)
97 {
98 std::shared_ptr<IoCollector> collect = IoCollector::Create();
99 auto result = collect->CollectRawDiskStats();
100 std::cout << "collect raw disk stats result " << result.retCode << std::endl;
101 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
102 }
103
104 /**
105 * @tc.name: IoCollectorTest003
106 * @tc.desc: used to test IoCollector.CollectDiskStats
107 * @tc.type: FUNC
108 */
109 HWTEST_F(IoCollectorTest, IoCollectorTest003, TestSize.Level1)
110 {
111 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon891ccc380202(const DiskStats &stats) 112 auto result = collect->CollectDiskStats([] (const DiskStats &stats) {
113 return false;
114 });
115 std::cout << "collect disk stats result " << result.retCode << std::endl;
116 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
117 }
118
119 /**
120 * @tc.name: IoCollectorTest004
121 * @tc.desc: used to test IoCollector.ExportDiskStats
122 * @tc.type: FUNC
123 */
124 HWTEST_F(IoCollectorTest, IoCollectorTest004, TestSize.Level1)
125 {
126 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon891ccc380302(const DiskStats &stats) 127 auto result = collect->ExportDiskStats([] (const DiskStats &stats) {
128 return false;
129 });
130 std::cout << "export disk stats result " << result.retCode << std::endl;
131 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
132 bool flag = CheckFormat(result.data, DISK_STATS1, DISK_STATS2);
133 ASSERT_TRUE(flag);
134
135 sleep(3);
136 auto nextResult = collect->ExportDiskStats();
137 std::cout << "export disk stats nextResult " << nextResult.retCode << std::endl;
138 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
139 flag = CheckFormat(nextResult.data, DISK_STATS1, DISK_STATS2);
140 ASSERT_TRUE(flag);
141 }
142
143 /**
144 * @tc.name: IoCollectorTest005
145 * @tc.desc: used to test IoCollector.ExportDiskStats
146 * @tc.type: FUNC
147 */
148 HWTEST_F(IoCollectorTest, IoCollectorTest005, TestSize.Level1)
149 {
150 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon891ccc380402(const DiskStats &stats) 151 auto result = collect->CollectDiskStats([] (const DiskStats &stats) {
152 return false;
153 }, true);
154 std::cout << "export disk stats result " << result.retCode << std::endl;
155 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
156
157 sleep(3);
158 auto nextResult = collect->ExportDiskStats();
159 std::cout << "export disk stats nextResult " << nextResult.retCode << std::endl;
160 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
161 bool flag = CheckFormat(nextResult.data, DISK_STATS1, DISK_STATS2);
162 ASSERT_TRUE(flag);
163 }
164
165 /**
166 * @tc.name: IoCollectorTest006
167 * @tc.desc: used to test IoCollector.CollectEMMCInfo
168 * @tc.type: FUNC
169 */
170 HWTEST_F(IoCollectorTest, IoCollectorTest006, TestSize.Level1)
171 {
172 std::shared_ptr<IoCollector> collect = IoCollector::Create();
173 auto result = collect->CollectEMMCInfo();
174 std::cout << "collect emmc info result " << result.retCode << std::endl;
175 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
176 }
177
178 /**
179 * @tc.name: IoCollectorTest007
180 * @tc.desc: used to test IoCollector.ExportEMMCInfo
181 * @tc.type: FUNC
182 */
183 HWTEST_F(IoCollectorTest, IoCollectorTest007, TestSize.Level1)
184 {
185 std::shared_ptr<IoCollector> collect = IoCollector::Create();
186 auto result = collect->ExportEMMCInfo();
187 std::cout << "export emmc info result " << result.retCode << std::endl;
188 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
189 bool flag = CheckFormat(result.data, EMMC_INFO1, EMMC_INFO2);
190 ASSERT_TRUE(flag);
191 }
192
193 /**
194 * @tc.name: IoCollectorTest008
195 * @tc.desc: used to test IoCollector.CollectAllProcIoStats
196 * @tc.type: FUNC
197 */
198 HWTEST_F(IoCollectorTest, IoCollectorTest008, TestSize.Level1)
199 {
200 std::shared_ptr<IoCollector> collect = IoCollector::Create();
201 auto result = collect->CollectAllProcIoStats();
202 std::cout << "collect all proc io stats result " << result.retCode << std::endl;
203 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
204 }
205
206 /**
207 * @tc.name: IoCollectorTest009
208 * @tc.desc: used to test IoCollector.ExportAllProcIoStats
209 * @tc.type: FUNC
210 */
211 HWTEST_F(IoCollectorTest, IoCollectorTest009, TestSize.Level1)
212 {
213 std::shared_ptr<IoCollector> collect = IoCollector::Create();
214 auto result = collect->ExportAllProcIoStats();
215 std::cout << "export all proc io stats result " << result.retCode << std::endl;
216 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
217 bool flag = CheckFormat(result.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
218 ASSERT_TRUE(flag);
219 }
220
221 /**
222 * @tc.name: IoCollectorTest010
223 * @tc.desc: used to test IoCollector.ExportAllProcIoStats
224 * @tc.type: FUNC
225 */
226 HWTEST_F(IoCollectorTest, IoCollectorTest010, TestSize.Level1)
227 {
228 std::shared_ptr<IoCollector> collect = IoCollector::Create();
229 auto result = collect->ExportAllProcIoStats();
230 std::cout << "export all proc io stats result " << result.retCode << std::endl;
231 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
232 bool flag = CheckFormat(result.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
233 ASSERT_TRUE(flag);
234
235 sleep(3);
236 auto nextResult = collect->ExportAllProcIoStats();
237 std::cout << "export all proc io stats nextResult " << nextResult.retCode << std::endl;
238 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
239 flag = CheckFormat(nextResult.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
240 ASSERT_TRUE(flag);
241 }
242
243 /**
244 * @tc.name: IoCollectorTest011
245 * @tc.desc: used to test IoCollector.CollectSysIoStats
246 * @tc.type: FUNC
247 */
248 HWTEST_F(IoCollectorTest, IoCollectorTest011, TestSize.Level1)
249 {
250 std::shared_ptr<IoCollector> collect = IoCollector::Create();
251 auto result = collect->CollectSysIoStats();
252 std::cout << "collect sys io stats result " << result.retCode << std::endl;
253 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
254 }
255
256 /**
257 * @tc.name: IoCollectorTest012
258 * @tc.desc: used to test IoCollector.ExportSysIoStats
259 * @tc.type: FUNC
260 */
261 HWTEST_F(IoCollectorTest, IoCollectorTest012, TestSize.Level1)
262 {
263 std::shared_ptr<IoCollector> collect = IoCollector::Create();
264 auto result = collect->ExportSysIoStats();
265 std::cout << "export sys io stats result " << result.retCode << std::endl;
266 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
267 bool flag = CheckFormat(result.data, SYS_IO_STATS1, SYS_IO_STATS2);
268 ASSERT_TRUE(flag);
269 }
270 #else
271 /**
272 * @tc.name: IoCollectorTest001
273 * @tc.desc: used to test empty IoCollector
274 * @tc.type: FUNC
275 */
276 HWTEST_F(IoCollectorTest, IoCollectorTest001, TestSize.Level1)
277 {
278 std::shared_ptr<IoCollector> collect = IoCollector::Create();
279 auto result1 = collect->CollectProcessIo(0);
280 ASSERT_TRUE(result1.retCode == UcError::FEATURE_CLOSED);
281
282 auto result2 = collect->CollectRawDiskStats();
283 ASSERT_TRUE(result2.retCode == UcError::FEATURE_CLOSED);
284
285 auto result3 = collect->CollectDiskStats();
286 ASSERT_TRUE(result3.retCode == UcError::FEATURE_CLOSED);
287
288 auto result4 = collect->ExportDiskStats();
289 ASSERT_TRUE(result4.retCode == UcError::FEATURE_CLOSED);
290
291 auto result5 = collect->CollectEMMCInfo();
292 ASSERT_TRUE(result5.retCode == UcError::FEATURE_CLOSED);
293
294 auto result6 = collect->ExportEMMCInfo();
295 ASSERT_TRUE(result6.retCode == UcError::FEATURE_CLOSED);
296
297 auto result7 = collect->CollectAllProcIoStats();
298 ASSERT_TRUE(result7.retCode == UcError::FEATURE_CLOSED);
299
300 auto result8 = collect->ExportAllProcIoStats();
301 ASSERT_TRUE(result8.retCode == UcError::FEATURE_CLOSED);
302
303 auto result9 = collect->CollectSysIoStats();
304 ASSERT_TRUE(result9.retCode == UcError::FEATURE_CLOSED);
305
306 auto result10 = collect->ExportSysIoStats();
307 ASSERT_TRUE(result10.retCode == UcError::FEATURE_CLOSED);
308 }
309 #endif
310