1 
2 /*
3  * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include <ctime>
18 #include <net/if.h>
19 #include <thread>
20 #include <vector>
21 
22 #include <gtest/gtest.h>
23 #include <sys/resource.h>
24 #include <unistd.h>
25 
26 #ifdef GTEST_API_
27 #define private public
28 #define protected public
29 #endif
30 
31 #include "bpf_loader.h"
32 #include "bpf_mapper.h"
33 #include "bpf_path.h"
34 #include "bpf_stats.h"
35 
36 #include "net_stats_constants.h"
37 
38 namespace OHOS {
39 namespace NetManagerStandard {
40 static constexpr uint32_t TEST_UID1 = 10010;
41 static constexpr uint32_t TEST_UID2 = 10100;
42 static constexpr uint32_t TEST_UID_IF1 = 11001;
43 static constexpr uint32_t TEST_UID_IF2 = 11002;
44 static constexpr uint32_t TEST_BYTES0 = 11;
45 static constexpr uint32_t STATS_TYPE_INVALID_VALUE = 4;
46 static constexpr uint64_t TEST_COOKIE1 = 1;
47 static constexpr uint64_t TEST_NET_NS = 1;
48 static constexpr const char *TEST_IFACE_NAME_WLAN0 = "wlan0";
49 static constexpr const char *TEST_IFACE_NAME_LO = "lo";
50 static constexpr const char *TEST_IFACE_NAME_DUMMY0 = "dummy0";
51 static constexpr const char *BFP_NAME_NETSYS_PATH = "/system/etc/bpf/netsys.o";
52 static constexpr const char *TEST_BFP_NAME_NETSYS_PATH = "/data/netsys.o";
53 
54 using namespace testing::ext;
55 
56 class NetsysBpfStatsTest : public testing::Test {
57 public:
58     static void SetUpTestCase();
59 
60     static void TearDownTestCase();
61 
62     void SetUp();
63 
64     void TearDown();
65 
66 protected:
67     NetsysBpfStatsTest() = default;
68 };
SetUpTestCase()69 void NetsysBpfStatsTest::SetUpTestCase() {}
70 
TearDownTestCase()71 void NetsysBpfStatsTest::TearDownTestCase() {}
72 
SetUp()73 void NetsysBpfStatsTest::SetUp() {}
74 
TearDown()75 void NetsysBpfStatsTest::TearDown() {}
76 
77 HWTEST_F(NetsysBpfStatsTest, GetTotalStats, TestSize.Level1)
78 {
79     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
80     uint64_t stats = 0;
81     bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_BYTES);
82     EXPECT_GE(stats, 0);
83     bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_PACKETS);
84     EXPECT_GE(stats, 0);
85     bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_BYTES);
86     EXPECT_GE(stats, 0);
87     bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_PACKETS);
88     EXPECT_GE(stats, 0);
89 }
90 
91 HWTEST_F(NetsysBpfStatsTest, GetUidStats, TestSize.Level1)
92 {
93     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
94     uint64_t stats = 0;
95 
96     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID1);
97     EXPECT_GE(stats, 0);
98     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID1);
99     EXPECT_GE(stats, 0);
100     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID1);
101     EXPECT_GE(stats, 0);
102     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID1);
103     EXPECT_GE(stats, 0);
104 
105     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID2);
106     EXPECT_GE(stats, 0);
107     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID2);
108     EXPECT_GE(stats, 0);
109     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID2);
110     EXPECT_GE(stats, 0);
111     bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID2);
112     EXPECT_GE(stats, 0);
113 }
114 
115 HWTEST_F(NetsysBpfStatsTest, GetIfaceStats, TestSize.Level1)
116 {
117     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
118     uint64_t stats = 0;
119     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_WLAN0);
120     EXPECT_GE(stats, 0);
121     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_WLAN0);
122     EXPECT_GE(stats, 0);
123     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_WLAN0);
124     EXPECT_GE(stats, 0);
125     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_WLAN0);
126     EXPECT_GE(stats, 0);
127 
128     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_LO);
129     EXPECT_GE(stats, 0);
130     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_LO);
131     EXPECT_GE(stats, 0);
132     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_LO);
133     EXPECT_GE(stats, 0);
134     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_LO);
135     EXPECT_GE(stats, 0);
136 
137     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_DUMMY0);
138     EXPECT_GE(stats, 0);
139     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_DUMMY0);
140     EXPECT_GE(stats, 0);
141     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_DUMMY0);
142     EXPECT_GE(stats, 0);
143     bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_DUMMY0);
144     EXPECT_GE(stats, 0);
145 }
146 
147 HWTEST_F(NetsysBpfStatsTest, GetAllStatsInfo, TestSize.Level1)
148 {
149     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
150     std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
151     bpfStats->GetAllStatsInfo(stats);
152     EXPECT_GE(stats.size(), 0);
153 }
154 
155 HWTEST_F(NetsysBpfStatsTest, LoadElf, TestSize.Level1)
156 {
157     auto ret = OHOS::NetManagerStandard::LoadElf(TEST_BFP_NAME_NETSYS_PATH);
158     EXPECT_GE(ret, NETSYS_SUCCESS);
159 
160     ret = OHOS::NetManagerStandard::LoadElf(BFP_NAME_NETSYS_PATH);
161     EXPECT_EQ(ret, NETSYS_SUCCESS);
162 }
163 
164 HWTEST_F(NetsysBpfStatsTest, LoadAndUidStats, TestSize.Level1)
165 {
166     BpfMapper<app_uid_stats_key, app_uid_stats_value> appUidStatsMap(APP_UID_STATS_MAP_PATH, BPF_ANY);
167     EXPECT_TRUE(appUidStatsMap.IsValid());
168     app_uid_stats_value value;
169     value.rxBytes = TEST_BYTES0;
170     value.rxPackets = TEST_BYTES0;
171     value.txBytes = TEST_BYTES0;
172     value.txPackets = TEST_BYTES0;
173     auto ret = appUidStatsMap.Write(TEST_UID1, value, BPF_ANY);
174     EXPECT_EQ(ret, NETSYS_SUCCESS);
175 
176     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
177     uint64_t stats = 0;
178     EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_UID1), NETSYS_SUCCESS);
179     EXPECT_EQ(stats, TEST_BYTES0);
180     EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_UID1), NETSYS_SUCCESS);
181     EXPECT_EQ(stats, TEST_BYTES0);
182     EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_UID1), NETSYS_SUCCESS);
183     EXPECT_EQ(stats, TEST_BYTES0);
184     EXPECT_EQ(bpfStats->GetUidStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_UID1), NETSYS_SUCCESS);
185     EXPECT_EQ(stats, TEST_BYTES0);
186 
187     ret = appUidStatsMap.Delete(TEST_UID1);
188     EXPECT_EQ(ret, NETSYS_SUCCESS);
189 
190     std::vector<app_uid_stats_key> keys;
191     keys.emplace_back(TEST_UID1);
192     keys.emplace_back(TEST_UID2);
193     ret = appUidStatsMap.Clear(keys);
194     EXPECT_EQ(ret, NETMANAGER_ERROR);
195 }
196 
197 HWTEST_F(NetsysBpfStatsTest, LoadAndIfaceStats, TestSize.Level1)
198 {
199     BpfMapper<iface_stats_key, iface_stats_value> ifaceStatsMap(IFACE_STATS_MAP_PATH, BPF_ANY);
200     EXPECT_TRUE(ifaceStatsMap.IsValid());
201 
202     auto ifIndex = if_nametoindex(TEST_IFACE_NAME_WLAN0);
203 
204     auto keys = ifaceStatsMap.GetAllKeys();
205     auto r = ifaceStatsMap.Clear(keys);
206     EXPECT_EQ(r, NETSYS_SUCCESS);
207 
208     iface_stats_value ifaceStats = {0};
209     ifaceStats.rxBytes = TEST_BYTES0;
210     ifaceStats.rxPackets = TEST_BYTES0;
211     ifaceStats.txBytes = TEST_BYTES0;
212     ifaceStats.txPackets = TEST_BYTES0;
213     auto ret = ifaceStatsMap.Write(ifIndex, ifaceStats, BPF_ANY);
214     EXPECT_EQ(ret, NETSYS_SUCCESS);
215 
216     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
217     uint64_t stats = 0;
218     EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
219     EXPECT_EQ(stats, TEST_BYTES0);
220     EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
221     EXPECT_EQ(stats, TEST_BYTES0);
222     EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
223     EXPECT_EQ(stats, TEST_BYTES0);
224     EXPECT_EQ(bpfStats->GetIfaceStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_IFACE_NAME_WLAN0), NETSYS_SUCCESS);
225     EXPECT_EQ(stats, TEST_BYTES0);
226 
227     stats = 0;
228     EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_BYTES), NETSYS_SUCCESS);
229     EXPECT_EQ(stats, TEST_BYTES0);
230     EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_RX_PACKETS), NETSYS_SUCCESS);
231     EXPECT_EQ(stats, TEST_BYTES0);
232     EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_BYTES), NETSYS_SUCCESS);
233     EXPECT_EQ(stats, TEST_BYTES0);
234     EXPECT_EQ(bpfStats->GetTotalStats(stats, StatsType::STATS_TYPE_TX_PACKETS), NETSYS_SUCCESS);
235     EXPECT_EQ(stats, TEST_BYTES0);
236 
237     ret = ifaceStatsMap.Delete(ifIndex);
238     EXPECT_EQ(ret, NETSYS_SUCCESS);
239 }
240 
241 HWTEST_F(NetsysBpfStatsTest, LoadAndUidIfaceStats, TestSize.Level1)
242 {
243     BpfMapper<app_uid_if_stats_key, app_uid_if_stats_value> uidIfaceStatsMap(APP_UID_IF_STATS_MAP_PATH, BPF_ANY);
244     EXPECT_TRUE(uidIfaceStatsMap.IsValid());
245 
246     app_uid_if_stats_value value = {0};
247     value.rxBytes = TEST_BYTES0;
248     value.rxPackets = TEST_BYTES0;
249     value.txBytes = TEST_BYTES0;
250     value.txPackets = TEST_BYTES0;
251     app_uid_if_stats_key key1 = {0};
252     key1.ifIndex = TEST_UID_IF1;
253     key1.uId = TEST_UID1;
254     auto ret = uidIfaceStatsMap.Write(key1, value, BPF_ANY);
255     EXPECT_EQ(ret, NETSYS_SUCCESS);
256 
257     app_uid_if_stats_key key2 = {0};
258     key2.ifIndex = TEST_UID_IF2;
259     key2.uId = TEST_UID2;
260     ret = uidIfaceStatsMap.Write(key2, value, BPF_ANY);
261     EXPECT_EQ(ret, NETSYS_SUCCESS);
262 
263     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
264     std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
265     EXPECT_EQ(bpfStats->GetAllStatsInfo(stats), NETSYS_SUCCESS);
266 }
267 
268 HWTEST_F(NetsysBpfStatsTest, LoadAndCookieStats, TestSize.Level1)
269 {
270     BpfMapper<socket_cookie_stats_key, app_cookie_stats_value> appCookieStatsMap(APP_COOKIE_STATS_MAP_PATH, BPF_ANY);
271     EXPECT_TRUE(appCookieStatsMap.IsValid());
272     app_cookie_stats_value value;
273     value.rxBytes = TEST_BYTES0;
274     value.rxPackets = TEST_BYTES0;
275     value.txBytes = TEST_BYTES0;
276     value.txPackets = TEST_BYTES0;
277     auto ret = appCookieStatsMap.Write(TEST_COOKIE1, value, BPF_ANY);
278     EXPECT_EQ(ret, NETSYS_SUCCESS);
279 
280     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
281     uint64_t stats = 0;
282     EXPECT_EQ(bpfStats->GetCookieStats(stats, StatsType::STATS_TYPE_RX_BYTES, TEST_COOKIE1), NETSYS_SUCCESS);
283     EXPECT_EQ(stats, TEST_BYTES0);
284     EXPECT_EQ(bpfStats->GetCookieStats(stats, StatsType::STATS_TYPE_RX_PACKETS, TEST_COOKIE1), NETSYS_SUCCESS);
285     EXPECT_EQ(stats, TEST_BYTES0);
286     EXPECT_EQ(bpfStats->GetCookieStats(stats, StatsType::STATS_TYPE_TX_BYTES, TEST_COOKIE1), NETSYS_SUCCESS);
287     EXPECT_EQ(stats, TEST_BYTES0);
288     EXPECT_EQ(bpfStats->GetCookieStats(stats, StatsType::STATS_TYPE_TX_PACKETS, TEST_COOKIE1), NETSYS_SUCCESS);
289     EXPECT_EQ(stats, TEST_BYTES0);
290 
291     ret = appCookieStatsMap.Delete(TEST_COOKIE1);
292     EXPECT_EQ(ret, NETSYS_SUCCESS);
293 
294     std::vector<socket_cookie_stats_key> keys;
295     keys.emplace_back(TEST_COOKIE1);
296     ret = appCookieStatsMap.Clear(keys);
297     EXPECT_EQ(ret, NETMANAGER_ERROR);
298 }
299 
300 HWTEST_F(NetsysBpfStatsTest, DeleteStatsInfoTest001, TestSize.Level1)
301 {
302     BpfMapper<app_uid_if_stats_key, app_uid_if_stats_value> uidIfStatsMap(APP_UID_IF_STATS_MAP_PATH, BPF_ANY);
303     EXPECT_TRUE(uidIfStatsMap.IsValid());
304 
305     app_uid_if_stats_value value = {0};
306     value.rxBytes = TEST_BYTES0;
307     value.rxPackets = TEST_BYTES0;
308     value.txBytes = TEST_BYTES0;
309     value.txPackets = TEST_BYTES0;
310     app_uid_if_stats_key key1 = {0};
311     key1.ifIndex = TEST_UID_IF1;
312     key1.uId = TEST_UID1;
313     auto ret = uidIfStatsMap.Write(key1, value, BPF_ANY);
314     EXPECT_EQ(ret, NETSYS_SUCCESS);
315 
316     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
317     EXPECT_EQ(bpfStats->DeleteStatsInfo(APP_UID_IF_STATS_MAP_PATH, TEST_UID1), NETSYS_SUCCESS);
318 }
319 
320 HWTEST_F(NetsysBpfStatsTest, GetAllStatsInfoTest001, TestSize.Level1)
321 {
322     BpfMapper<app_uid_if_stats_key, app_uid_if_stats_value> uidIfStatsMap(APP_UID_IF_STATS_MAP_PATH, BPF_ANY);
323     EXPECT_TRUE(uidIfStatsMap.IsValid());
324 
325     app_uid_if_stats_value value = {0};
326     value.rxBytes = TEST_BYTES0;
327     value.rxPackets = TEST_BYTES0;
328     value.txBytes = TEST_BYTES0;
329     value.txPackets = TEST_BYTES0;
330     app_uid_if_stats_key key1 = {0};
331     key1.ifIndex = TEST_UID_IF1;
332     key1.uId = TEST_UID1;
333     auto ret = uidIfStatsMap.Write(key1, value, BPF_ANY);
334     EXPECT_EQ(ret, NETSYS_SUCCESS);
335 
336     app_uid_if_stats_key key2 = {0};
337     key2.ifIndex = TEST_UID_IF2;
338     key2.uId = TEST_UID2;
339     ret = uidIfStatsMap.Write(key2, value, BPF_ANY);
340     EXPECT_EQ(ret, NETSYS_SUCCESS);
341 
342     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
343     std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
344     EXPECT_EQ(bpfStats->GetAllStatsInfo(stats), NETSYS_SUCCESS);
345 }
346 
347 HWTEST_F(NetsysBpfStatsTest, GetAllSimStatsInfo001, TestSize.Level1)
348 {
349     BpfMapper<app_uid_sim_stats_key, app_uid_sim_stats_value> uidSimStatsMap(APP_UID_SIM_STATS_MAP_PATH, BPF_ANY);
350     EXPECT_TRUE(uidSimStatsMap.IsValid());
351 
352     app_uid_sim_stats_value value = {0};
353     value.rxBytes = TEST_BYTES0;
354     value.rxPackets = TEST_BYTES0;
355     value.txBytes = TEST_BYTES0;
356     value.txPackets = TEST_BYTES0;
357     app_uid_sim_stats_key key1 = {0};
358     key1.ifIndex = TEST_UID_IF1;
359     key1.uId = TEST_UID1;
360     auto ret = uidSimStatsMap.Write(key1, value, BPF_ANY);
361     EXPECT_EQ(ret, NETSYS_SUCCESS);
362 
363     app_uid_sim_stats_key key2 = {0};
364     key2.ifIndex = TEST_UID_IF2;
365     key2.uId = TEST_UID2;
366     ret = uidSimStatsMap.Write(key2, value, BPF_ANY);
367     EXPECT_EQ(ret, NETSYS_SUCCESS);
368 
369     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
370     std::vector<OHOS::NetManagerStandard::NetStatsInfo> stats;
371     EXPECT_EQ(bpfStats->GetAllSimStatsInfo(stats), NETSYS_SUCCESS);
372     EXPECT_EQ(stats.size(), 2);
373 }
374 
375 HWTEST_F(NetsysBpfStatsTest, SockNetnsMapTest001, TestSize.Level1)
376 {
377     BpfMapper<sock_netns_key, sock_netns_value> sockNetnsMap(SOCK_NETNS_MAP_PATH, BPF_ANY);
378     EXPECT_TRUE(sockNetnsMap.IsValid());
379 
380     auto keys = sockNetnsMap.GetAllKeys();
381     for (const auto &k : keys) {
382         sock_netns_value v = {};
383         EXPECT_EQ(sockNetnsMap.Read(k, v), NETSYS_SUCCESS);
384     }
385 
386     sock_netns_key key = TEST_NET_NS;
387     sock_netns_value value = TEST_NET_NS;
388     auto ret = sockNetnsMap.Write(key, value, BPF_ANY);
389     EXPECT_EQ(ret, NETSYS_SUCCESS);
390     sock_netns_value result = {};
391     ret = sockNetnsMap.Read(key, result);
392     EXPECT_EQ(ret, NETSYS_SUCCESS);
393     EXPECT_EQ(result, value);
394 }
395 
396 HWTEST_F(NetsysBpfStatsTest, UnloadElf, TestSize.Level1)
397 {
398     auto ret = OHOS::NetManagerStandard::UnloadElf(BFP_NAME_NETSYS_PATH);
399     EXPECT_EQ(ret, NETSYS_SUCCESS);
400 
401     ret = OHOS::NetManagerStandard::UnloadElf(TEST_BFP_NAME_NETSYS_PATH);
402     EXPECT_GE(ret, NETSYS_SUCCESS);
403 }
404 
405 HWTEST_F(NetsysBpfStatsTest, GetNumberFromStatsValue, TestSize.Level1)
406 {
407     uint64_t stats = 0;
408     StatsType statsType = static_cast<StatsType>(STATS_TYPE_INVALID_VALUE);
409     stats_value value = {};
410     std::unique_ptr<NetsysBpfStats> bpfStats = std::make_unique<NetsysBpfStats>();
411     auto ret = bpfStats->GetNumberFromStatsValue(stats, statsType, value);
412     EXPECT_EQ(ret, NetManagerStandard::NetStatsResultCode::STATS_ERR_READ_BPF_FAIL);
413 }
414 } // namespace NetManagerStandard
415 } // namespace OHOS
416