1 /*
2 * Copyright (c) 2023-2025 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 std::cout << "not match line : " << line << std::endl;
71 return false;
72 }
73 }
74 file.close();
75 return true;
76 }
77 }
78
79 /**
80 * @tc.name: IoCollectorTest001
81 * @tc.desc: used to test IoCollector.CollectProcessIo
82 * @tc.type: FUNC
83 */
84 HWTEST_F(IoCollectorTest, IoCollectorTest001, TestSize.Level1)
85 {
86 std::shared_ptr<IoCollector> collector = IoCollector::Create();
87 CollectResult<ProcessIo> data = collector->CollectProcessIo(1000);
88 std::cout << "collect process io result" << data.retCode << std::endl;
89 ASSERT_TRUE(data.retCode == UcError::SUCCESS);
90 }
91
92 /**
93 * @tc.name: IoCollectorTest002
94 * @tc.desc: used to test IoCollector.CollectRawDiskStats
95 * @tc.type: FUNC
96 */
97 HWTEST_F(IoCollectorTest, IoCollectorTest002, TestSize.Level1)
98 {
99 std::shared_ptr<IoCollector> collect = IoCollector::Create();
100 auto result = collect->CollectRawDiskStats();
101 std::cout << "collect raw disk stats result " << result.retCode << std::endl;
102 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
103 }
104
105 /**
106 * @tc.name: IoCollectorTest003
107 * @tc.desc: used to test IoCollector.CollectDiskStats
108 * @tc.type: FUNC
109 */
110 HWTEST_F(IoCollectorTest, IoCollectorTest003, TestSize.Level1)
111 {
112 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon69bae21a0202(const DiskStats &stats) 113 auto result = collect->CollectDiskStats([] (const DiskStats &stats) {
114 return false;
115 });
116 std::cout << "collect disk stats result " << result.retCode << std::endl;
117 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
118 }
119
120 /**
121 * @tc.name: IoCollectorTest004
122 * @tc.desc: used to test IoCollector.ExportDiskStats
123 * @tc.type: FUNC
124 */
125 HWTEST_F(IoCollectorTest, IoCollectorTest004, TestSize.Level1)
126 {
127 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon69bae21a0302(const DiskStats &stats) 128 auto result = collect->ExportDiskStats([] (const DiskStats &stats) {
129 return false;
130 });
131 std::cout << "export disk stats result " << result.retCode << std::endl;
132 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
133 bool flag = CheckFormat(result.data, DISK_STATS1, DISK_STATS2);
134 ASSERT_TRUE(flag);
135
136 sleep(3);
137 auto nextResult = collect->ExportDiskStats();
138 std::cout << "export disk stats nextResult " << nextResult.retCode << std::endl;
139 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
140 flag = CheckFormat(nextResult.data, DISK_STATS1, DISK_STATS2);
141 ASSERT_TRUE(flag);
142 }
143
144 /**
145 * @tc.name: IoCollectorTest005
146 * @tc.desc: used to test IoCollector.ExportDiskStats
147 * @tc.type: FUNC
148 */
149 HWTEST_F(IoCollectorTest, IoCollectorTest005, TestSize.Level1)
150 {
151 std::shared_ptr<IoCollector> collect = IoCollector::Create();
__anon69bae21a0402(const DiskStats &stats) 152 auto result = collect->CollectDiskStats([] (const DiskStats &stats) {
153 return false;
154 }, true);
155 std::cout << "export disk stats result " << result.retCode << std::endl;
156 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
157
158 sleep(3);
159 auto nextResult = collect->ExportDiskStats();
160 std::cout << "export disk stats nextResult " << nextResult.retCode << std::endl;
161 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
162 bool flag = CheckFormat(nextResult.data, DISK_STATS1, DISK_STATS2);
163 ASSERT_TRUE(flag);
164 }
165
166 /**
167 * @tc.name: IoCollectorTest006
168 * @tc.desc: used to test IoCollector.CollectEMMCInfo
169 * @tc.type: FUNC
170 */
171 HWTEST_F(IoCollectorTest, IoCollectorTest006, TestSize.Level1)
172 {
173 std::shared_ptr<IoCollector> collect = IoCollector::Create();
174 auto result = collect->CollectEMMCInfo();
175 std::cout << "collect emmc info result " << result.retCode << std::endl;
176 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
177 }
178
179 /**
180 * @tc.name: IoCollectorTest007
181 * @tc.desc: used to test IoCollector.ExportEMMCInfo
182 * @tc.type: FUNC
183 */
184 HWTEST_F(IoCollectorTest, IoCollectorTest007, TestSize.Level1)
185 {
186 std::shared_ptr<IoCollector> collect = IoCollector::Create();
187 auto result = collect->ExportEMMCInfo();
188 std::cout << "export emmc info result " << result.retCode << std::endl;
189 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
190 bool flag = CheckFormat(result.data, EMMC_INFO1, EMMC_INFO2);
191 ASSERT_TRUE(flag);
192 }
193
194 /**
195 * @tc.name: IoCollectorTest008
196 * @tc.desc: used to test IoCollector.CollectAllProcIoStats
197 * @tc.type: FUNC
198 */
199 HWTEST_F(IoCollectorTest, IoCollectorTest008, TestSize.Level1)
200 {
201 std::shared_ptr<IoCollector> collect = IoCollector::Create();
202 auto result = collect->CollectAllProcIoStats();
203 std::cout << "collect all proc io stats result " << result.retCode << std::endl;
204 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
205 }
206
207 /**
208 * @tc.name: IoCollectorTest009
209 * @tc.desc: used to test IoCollector.ExportAllProcIoStats
210 * @tc.type: FUNC
211 */
212 HWTEST_F(IoCollectorTest, IoCollectorTest009, TestSize.Level1)
213 {
214 std::shared_ptr<IoCollector> collect = IoCollector::Create();
215 auto result = collect->ExportAllProcIoStats();
216 std::cout << "export all proc io stats result " << result.retCode << std::endl;
217 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
218 bool flag = CheckFormat(result.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
219 ASSERT_TRUE(flag);
220 }
221
222 /**
223 * @tc.name: IoCollectorTest010
224 * @tc.desc: used to test IoCollector.ExportAllProcIoStats
225 * @tc.type: FUNC
226 */
227 HWTEST_F(IoCollectorTest, IoCollectorTest010, TestSize.Level1)
228 {
229 std::shared_ptr<IoCollector> collect = IoCollector::Create();
230 auto result = collect->ExportAllProcIoStats();
231 std::cout << "export all proc io stats result " << result.retCode << std::endl;
232 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
233 bool flag = CheckFormat(result.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
234 ASSERT_TRUE(flag);
235
236 sleep(3);
237 auto nextResult = collect->ExportAllProcIoStats();
238 std::cout << "export all proc io stats nextResult " << nextResult.retCode << std::endl;
239 ASSERT_TRUE(nextResult.retCode == UcError::SUCCESS);
240 flag = CheckFormat(nextResult.data, ALL_PROC_IO_STATS1, ALL_PROC_IO_STATS2);
241 ASSERT_TRUE(flag);
242 }
243
244 /**
245 * @tc.name: IoCollectorTest011
246 * @tc.desc: used to test IoCollector.CollectSysIoStats
247 * @tc.type: FUNC
248 */
249 HWTEST_F(IoCollectorTest, IoCollectorTest011, TestSize.Level1)
250 {
251 std::shared_ptr<IoCollector> collect = IoCollector::Create();
252 auto result = collect->CollectSysIoStats();
253 std::cout << "collect sys io stats result " << result.retCode << std::endl;
254 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
255 }
256
257 /**
258 * @tc.name: IoCollectorTest012
259 * @tc.desc: used to test IoCollector.ExportSysIoStats
260 * @tc.type: FUNC
261 */
262 HWTEST_F(IoCollectorTest, IoCollectorTest012, TestSize.Level1)
263 {
264 std::shared_ptr<IoCollector> collect = IoCollector::Create();
265 auto result = collect->ExportSysIoStats();
266 std::cout << "export sys io stats result " << result.retCode << std::endl;
267 ASSERT_TRUE(result.retCode == UcError::SUCCESS);
268 bool flag = CheckFormat(result.data, SYS_IO_STATS1, SYS_IO_STATS2);
269 ASSERT_TRUE(flag);
270 }
271 #else
272 /**
273 * @tc.name: IoCollectorTest001
274 * @tc.desc: used to test empty IoCollector
275 * @tc.type: FUNC
276 */
277 HWTEST_F(IoCollectorTest, IoCollectorTest001, TestSize.Level1)
278 {
279 std::shared_ptr<IoCollector> collect = IoCollector::Create();
280 auto result1 = collect->CollectProcessIo(0);
281 ASSERT_TRUE(result1.retCode == UcError::FEATURE_CLOSED);
282
283 auto result2 = collect->CollectRawDiskStats();
284 ASSERT_TRUE(result2.retCode == UcError::FEATURE_CLOSED);
285
286 auto result3 = collect->CollectDiskStats();
287 ASSERT_TRUE(result3.retCode == UcError::FEATURE_CLOSED);
288
289 auto result4 = collect->ExportDiskStats();
290 ASSERT_TRUE(result4.retCode == UcError::FEATURE_CLOSED);
291
292 auto result5 = collect->CollectEMMCInfo();
293 ASSERT_TRUE(result5.retCode == UcError::FEATURE_CLOSED);
294
295 auto result6 = collect->ExportEMMCInfo();
296 ASSERT_TRUE(result6.retCode == UcError::FEATURE_CLOSED);
297
298 auto result7 = collect->CollectAllProcIoStats();
299 ASSERT_TRUE(result7.retCode == UcError::FEATURE_CLOSED);
300
301 auto result8 = collect->ExportAllProcIoStats();
302 ASSERT_TRUE(result8.retCode == UcError::FEATURE_CLOSED);
303
304 auto result9 = collect->CollectSysIoStats();
305 ASSERT_TRUE(result9.retCode == UcError::FEATURE_CLOSED);
306
307 auto result10 = collect->ExportSysIoStats();
308 ASSERT_TRUE(result10.retCode == UcError::FEATURE_CLOSED);
309 }
310 #endif
311