1 /*
2 * Copyright (c) 2022-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
16 #include <gtest/gtest.h>
17
18 #include "dns_base_service.h"
19 #include "net_conn_base_service.h"
20 #include "net_conn_service_iface.h"
21 #include "net_conn_types.h"
22 #include "net_ethernet_base_service.h"
23 #include "net_manager_center.h"
24 #include "net_manager_constants.h"
25 #include "net_policy_base_service.h"
26 #include "net_stats_base_service.h"
27
28 namespace OHOS {
29 namespace NetManagerStandard {
30 namespace {
31 using namespace testing::ext;
32 constexpr const char *TEST_IDENT = "testIdent";
33 constexpr std::initializer_list<NetBearType> BEAR_TYPE_LIST = {
34 NetBearType::BEARER_CELLULAR, NetBearType::BEARER_WIFI, NetBearType::BEARER_BLUETOOTH,
35 NetBearType::BEARER_ETHERNET, NetBearType::BEARER_VPN, NetBearType::BEARER_WIFI_AWARE,
36 };
37
38 class TestDnsService : public DnsBaseService {
GetAddressesByName(const std::string & hostName,int32_t netId,std::vector<INetAddr> & addrInfo)39 inline int32_t GetAddressesByName(const std::string &hostName, int32_t netId,
40 std::vector<INetAddr> &addrInfo) override
41 {
42 return NETMANAGER_SUCCESS;
43 }
44 };
45
46 class TestConnService : public NetConnBaseService {
47 public:
GetIfaceNames(NetBearType bearerType,std::list<std::string> & ifaceNames)48 inline int32_t GetIfaceNames(NetBearType bearerType, std::list<std::string> &ifaceNames) override
49 {
50 return NETMANAGER_SUCCESS;
51 }
GetIfaceNameByType(NetBearType bearerType,const std::string & ident,std::string & ifaceName)52 inline int32_t GetIfaceNameByType(NetBearType bearerType, const std::string &ident, std::string &ifaceName) override
53 {
54 return NETMANAGER_SUCCESS;
55 }
RegisterNetSupplier(NetBearType bearerType,const std::string & ident,const std::set<NetCap> & netCaps,uint32_t & supplierId)56 inline int32_t RegisterNetSupplier(NetBearType bearerType, const std::string &ident,
57 const std::set<NetCap> &netCaps, uint32_t &supplierId) override
58 {
59 return NETMANAGER_SUCCESS;
60 }
UnregisterNetSupplier(uint32_t supplierId)61 inline int32_t UnregisterNetSupplier(uint32_t supplierId) override
62 {
63 return NETMANAGER_SUCCESS;
64 }
UpdateNetLinkInfo(uint32_t supplierId,const sptr<NetLinkInfo> & netLinkInfo)65 inline int32_t UpdateNetLinkInfo(uint32_t supplierId, const sptr<NetLinkInfo> &netLinkInfo) override
66 {
67 return NETMANAGER_SUCCESS;
68 }
UpdateNetSupplierInfo(uint32_t supplierId,const sptr<NetSupplierInfo> & netSupplierInfo)69 inline int32_t UpdateNetSupplierInfo(uint32_t supplierId, const sptr<NetSupplierInfo> &netSupplierInfo) override
70 {
71 return NETMANAGER_SUCCESS;
72 }
RestrictBackgroundChanged(bool isRestrictBackground)73 inline int32_t RestrictBackgroundChanged(bool isRestrictBackground) override
74 {
75 return NETMANAGER_SUCCESS;
76 }
RegisterNetConnCallback(const sptr<INetConnCallback> & callback)77 inline int32_t RegisterNetConnCallback(const sptr<INetConnCallback> &callback) override
78 {
79 return NETMANAGER_SUCCESS;
80 }
RegisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> & callback)81 inline int32_t RegisterNetFactoryResetCallback(const sptr<INetFactoryResetCallback> &callback) override
82 {
83 return NETMANAGER_SUCCESS;
84 }
85 };
86
87 class TestNetEthernetService : public NetEthernetBaseService {
88 public:
ResetEthernetFactory()89 inline int32_t ResetEthernetFactory() override
90 {
91 return NETMANAGER_SUCCESS;
92 }
93 };
94
95 class TestNetPolicyService : public NetPolicyBaseService {
96 public:
ResetPolicies()97 inline int32_t ResetPolicies() override
98 {
99 return NETMANAGER_SUCCESS;
100 }
IsUidNetAllowed(uint32_t uid,bool metered)101 inline bool IsUidNetAllowed(uint32_t uid, bool metered) override
102 {
103 return NETMANAGER_SUCCESS;
104 }
105 };
106
107 class TestNetStatsService : public NetStatsBaseService {
108 public:
GetIfaceStatsDetail(const std::string & iface,uint64_t start,uint64_t end,NetStatsInfo & info)109 inline int32_t GetIfaceStatsDetail(const std::string &iface, uint64_t start, uint64_t end,
110 NetStatsInfo &info) override
111 {
112 return NETMANAGER_SUCCESS;
113 }
ResetStatsFactory()114 inline int32_t ResetStatsFactory() override
115 {
116 return NETMANAGER_SUCCESS;
117 }
118 };
119 } // namespace
120
121 class NetManagerCenterTest : public testing::Test {
122 public:
123 static void SetUpTestCase();
124 static void TearDownTestCase();
125 void SetUp();
126 void TearDown();
127 static inline NetManagerCenter &instance_ = NetManagerCenter::GetInstance();
128 static inline uint32_t supplierId_ = 0;
129 };
130
SetUpTestCase()131 void NetManagerCenterTest::SetUpTestCase() {}
132
TearDownTestCase()133 void NetManagerCenterTest::TearDownTestCase() {}
134
SetUp()135 void NetManagerCenterTest::SetUp()
136 {
137 instance_.RegisterConnService(nullptr);
138 instance_.RegisterStatsService(nullptr);
139 instance_.RegisterPolicyService(nullptr);
140 instance_.RegisterEthernetService(nullptr);
141 instance_.RegisterDnsService(nullptr);
142 }
143
TearDown()144 void NetManagerCenterTest::TearDown() {}
145
146 HWTEST_F(NetManagerCenterTest, GetIfaceNamesTest001, TestSize.Level1)
147 {
148 std::list<std::string> list;
__anon1292de0a0202(const auto &type) 149 std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [this, &list](const auto &type) {
150 int32_t ret = instance_.GetIfaceNames(type, list);
151 std::cout << "TYPE:" << type << "LIST_SIZE:" << list.size() << std::endl;
152 EXPECT_EQ(ret, NETMANAGER_ERROR);
153 EXPECT_TRUE(list.empty());
154 list.clear();
155 });
156 }
157
158 HWTEST_F(NetManagerCenterTest, GetIfaceNamesTest002, TestSize.Level1)
159 {
160 std::list<std::string> list;
161 int32_t ret = instance_.GetIfaceNames(NetBearType::BEARER_DEFAULT, list);
162 EXPECT_EQ(ret, NETMANAGER_ERROR);
163 EXPECT_TRUE(list.empty());
164 }
165
166 HWTEST_F(NetManagerCenterTest, GetIfaceNamesTest003, TestSize.Level1)
167 {
168 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
169 instance_.RegisterConnService(service);
170 std::list<std::string> list;
__anon1292de0a0302(const auto &type) 171 std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [this, &list](const auto &type) {
172 int32_t ret = instance_.GetIfaceNames(type, list);
173 std::cout << "TYPE:" << type << "LIST_SIZE:" << list.size() << std::endl;
174 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
175 EXPECT_TRUE(list.empty());
176 list.clear();
177 });
178 }
179
180 HWTEST_F(NetManagerCenterTest, GetIfaceNamesTest004, TestSize.Level1)
181 {
182 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
183 instance_.RegisterConnService(service);
184 std::list<std::string> list;
185 int32_t ret = instance_.GetIfaceNames(NetBearType::BEARER_DEFAULT, list);
186 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
187 EXPECT_TRUE(list.empty());
188 }
189
190 HWTEST_F(NetManagerCenterTest, GetIfaceNameByTypeTest001, TestSize.Level1)
191 {
192 std::string ifaceName;
__anon1292de0a0402(const auto &type) 193 std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [this, &ifaceName](const auto &type) {
194 int32_t ret = instance_.GetIfaceNameByType(type, TEST_IDENT, ifaceName);
195 std::cout << "TYPE:" << type << "LIST_SIZE:" << ifaceName.size() << std::endl;
196 EXPECT_EQ(ret, NETMANAGER_ERROR);
197 EXPECT_TRUE(ifaceName.empty());
198 ifaceName.clear();
199 });
200 }
201
202 HWTEST_F(NetManagerCenterTest, GetIfaceNameByTypeTest002, TestSize.Level1)
203 {
204 std::string ifaceName;
205 int32_t ret = instance_.GetIfaceNameByType(NetBearType::BEARER_DEFAULT, TEST_IDENT, ifaceName);
206 EXPECT_EQ(ret, NETMANAGER_ERROR);
207 EXPECT_TRUE(ifaceName.empty());
208 }
209
210 HWTEST_F(NetManagerCenterTest, GetIfaceNameByTypeTest003, TestSize.Level1)
211 {
212 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
213 instance_.RegisterConnService(service);
214 std::string ifaceName;
__anon1292de0a0502(const auto &type) 215 std::for_each(BEAR_TYPE_LIST.begin(), BEAR_TYPE_LIST.end(), [this, &ifaceName](const auto &type) {
216 int32_t ret = instance_.GetIfaceNameByType(type, TEST_IDENT, ifaceName);
217 std::cout << "TYPE:" << type << "LIST_SIZE:" << ifaceName.size() << std::endl;
218 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
219 EXPECT_TRUE(ifaceName.empty());
220 ifaceName.clear();
221 });
222 }
223
224 HWTEST_F(NetManagerCenterTest, GetIfaceNameByTypeTest004, TestSize.Level1)
225 {
226 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
227 instance_.RegisterConnService(service);
228 std::string ifaceName;
229 int32_t ret = instance_.GetIfaceNameByType(NetBearType::BEARER_DEFAULT, TEST_IDENT, ifaceName);
230 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
231 EXPECT_TRUE(ifaceName.empty());
232 }
233
234 HWTEST_F(NetManagerCenterTest, RegisterNetSupplierTest001, TestSize.Level1)
235 {
236 NetBearType bearerType = BEARER_CELLULAR;
237 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET};
238 std::string ident = "ident";
239 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId_);
240 ASSERT_EQ(result, NETMANAGER_ERROR);
241 }
242
243 HWTEST_F(NetManagerCenterTest, RegisterNetSupplierTest002, TestSize.Level1)
244 {
245 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
246 instance_.RegisterConnService(service);
247 NetBearType bearerType = BEARER_CELLULAR;
248 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET};
249 std::string ident = "ident";
250 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId_);
251 EXPECT_EQ(result, NETMANAGER_SUCCESS);
252 }
253
254 HWTEST_F(NetManagerCenterTest, UnegisterNetSupplierTest001, TestSize.Level1)
255 {
256 int32_t result = instance_.UnregisterNetSupplier(supplierId_);
257 ASSERT_EQ(result, NETMANAGER_ERROR);
258 }
259
260 HWTEST_F(NetManagerCenterTest, UnegisterNetSupplierTest002, TestSize.Level1)
261 {
262 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
263 instance_.RegisterConnService(service);
264 int32_t result = instance_.UnregisterNetSupplier(supplierId_);
265 ASSERT_EQ(result, NETMANAGER_SUCCESS);
266 }
267
268 HWTEST_F(NetManagerCenterTest, UpdateNetLinkInfoTest001, TestSize.Level1)
269 {
270 NetBearType bearerType = BEARER_CELLULAR;
271 std::set<NetCap> netCaps = {NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
272
273 std::string ident = "ident04";
274 uint32_t supplierId = 0;
275 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId);
276 ASSERT_EQ(result, NETMANAGER_ERROR);
277
278 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
279 result = instance_.UpdateNetLinkInfo(supplierId, netLinkInfo);
280 ASSERT_EQ(result, NETMANAGER_ERROR);
281 }
282
283 HWTEST_F(NetManagerCenterTest, UpdateNetLinkInfoTest002, TestSize.Level1)
284 {
285 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
286 instance_.RegisterConnService(service);
287 NetBearType bearerType = BEARER_CELLULAR;
288 std::set<NetCap> netCaps = {NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
289
290 std::string ident = "ident04";
291 uint32_t supplierId = 0;
292 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId);
293 ASSERT_EQ(result, NETMANAGER_SUCCESS);
294
295 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
296 result = instance_.UpdateNetLinkInfo(supplierId, netLinkInfo);
297 ASSERT_EQ(result, NETMANAGER_SUCCESS);
298 }
299
300 HWTEST_F(NetManagerCenterTest, UpdateNetSupplierInfoTest001, TestSize.Level1)
301 {
302 NetBearType bearerType = BEARER_CELLULAR;
303 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
304 std::string ident = "ident03";
305 uint32_t supplierId = 0;
306 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId);
307 ASSERT_EQ(result, NETMANAGER_ERROR);
308
309 sptr<NetSupplierInfo> netSupplierInfo = new NetSupplierInfo();
310 netSupplierInfo->isAvailable_ = true;
311 netSupplierInfo->isRoaming_ = true;
312 netSupplierInfo->strength_ = 0x64;
313 netSupplierInfo->frequency_ = 0x10;
314 result = instance_.UpdateNetSupplierInfo(supplierId, netSupplierInfo);
315 ASSERT_EQ(result, NETMANAGER_ERROR);
316 }
317
318 HWTEST_F(NetManagerCenterTest, UpdateNetSupplierInfoTest002, TestSize.Level1)
319 {
320 sptr<NetConnBaseService> service = new (std::nothrow) TestConnService();
321 instance_.RegisterConnService(service);
322 NetBearType bearerType = BEARER_CELLULAR;
323 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET, NET_CAPABILITY_MMS};
324 std::string ident = "ident03";
325 uint32_t supplierId = 0;
326 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId);
327 ASSERT_EQ(result, NETMANAGER_SUCCESS);
328
329 sptr<NetSupplierInfo> netSupplierInfo = new NetSupplierInfo();
330 netSupplierInfo->isAvailable_ = true;
331 netSupplierInfo->isRoaming_ = true;
332 netSupplierInfo->strength_ = 0x64;
333 netSupplierInfo->frequency_ = 0x10;
334 result = instance_.UpdateNetSupplierInfo(supplierId, netSupplierInfo);
335 ASSERT_EQ(result, NETMANAGER_SUCCESS);
336 }
337
338 HWTEST_F(NetManagerCenterTest, GetIfaceStatsDetailTest001, TestSize.Level1)
339 {
340 std::string iface = "test_iface";
341 uint32_t startTime = 0;
342 uint32_t endTime = 9999999;
343 NetStatsInfo info;
344 int32_t ret = instance_.GetIfaceStatsDetail(iface, startTime, endTime, info);
345 EXPECT_EQ(ret, NETMANAGER_ERROR);
346 }
347
348 HWTEST_F(NetManagerCenterTest, GetIfaceStatsDetailTest002, TestSize.Level1)
349 {
350 sptr<NetStatsBaseService> service = new (std::nothrow) TestNetStatsService();
351 instance_.RegisterStatsService(service);
352 std::string iface = "test_iface";
353 uint32_t startTime = 0;
354 uint32_t endTime = 9999999;
355 NetStatsInfo info;
356 int32_t ret = instance_.GetIfaceStatsDetail(iface, startTime, endTime, info);
357 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
358 }
359
360 HWTEST_F(NetManagerCenterTest, ResetStatsFactoryTest001, TestSize.Level1)
361 {
362 int32_t ret = instance_.ResetStatsFactory();
363 EXPECT_EQ(ret, NETMANAGER_ERROR);
364 }
365
366 HWTEST_F(NetManagerCenterTest, ResetStatsFactoryTest002, TestSize.Level1)
367 {
368 sptr<NetStatsBaseService> service = new (std::nothrow) TestNetStatsService();
369 instance_.RegisterStatsService(service);
370 int32_t ret = instance_.ResetStatsFactory();
371 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
372 }
373
374 HWTEST_F(NetManagerCenterTest, ResetPolicyFactoryTest001, TestSize.Level1)
375 {
376 int32_t ret = instance_.ResetPolicyFactory();
377 EXPECT_EQ(ret, NETMANAGER_ERROR);
378 }
379
380 HWTEST_F(NetManagerCenterTest, ResetPolicyFactoryTest002, TestSize.Level1)
381 {
382 sptr<NetPolicyBaseService> service = new (std::nothrow) TestNetPolicyService();
383 instance_.RegisterPolicyService(service);
384 int32_t ret = instance_.ResetPolicyFactory();
385 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
386 }
387
388 HWTEST_F(NetManagerCenterTest, ResetPoliciesTest001, TestSize.Level1)
389 {
390 int32_t ret = instance_.ResetPolicies();
391 EXPECT_EQ(ret, NETMANAGER_ERROR);
392 }
393
394 HWTEST_F(NetManagerCenterTest, ResetPoliciesTest002, TestSize.Level1)
395 {
396 sptr<NetPolicyBaseService> service = new (std::nothrow) TestNetPolicyService();
397 instance_.RegisterPolicyService(service);
398 int32_t ret = instance_.ResetPolicies();
399 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
400 }
401
402 HWTEST_F(NetManagerCenterTest, ResetEthernetFactoryTest001, TestSize.Level1)
403 {
404 int32_t ret = instance_.ResetEthernetFactory();
405 EXPECT_EQ(ret, NETMANAGER_ERROR);
406 }
407
408 HWTEST_F(NetManagerCenterTest, ResetEthernetFactoryTest002, TestSize.Level1)
409 {
410 sptr<NetEthernetBaseService> service = new (std::nothrow) TestNetEthernetService();
411 instance_.RegisterEthernetService(service);
412 int32_t ret = instance_.ResetEthernetFactory();
413 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
414 }
415
416 HWTEST_F(NetManagerCenterTest, GetAddressesByNameTest001, TestSize.Level1)
417 {
418 const std::string testHostName = "test_hostname";
419 int32_t testNetId = 111;
420 std::vector<INetAddr> addrInfo;
421 int32_t ret = instance_.GetAddressesByName(testHostName, testNetId, addrInfo);
422 EXPECT_EQ(ret, NETMANAGER_ERROR);
423 }
424
425 HWTEST_F(NetManagerCenterTest, GetAddressesByNameTest002, TestSize.Level1)
426 {
427 sptr<DnsBaseService> service = new (std::nothrow) TestDnsService();
428 instance_.RegisterDnsService(service);
429 const std::string testHostName = "test_hostname";
430 int32_t testNetId = 111;
431 std::vector<INetAddr> addrInfo;
432 int32_t ret = instance_.GetAddressesByName(testHostName, testNetId, addrInfo);
433 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
434 }
435
436 HWTEST_F(NetManagerCenterTest, RestrictBackgroundChangedTest001, TestSize.Level1)
437 {
438 int32_t ret = instance_.RestrictBackgroundChanged(true);
439 EXPECT_EQ(ret, NETMANAGER_ERROR);
440 }
441
442 HWTEST_F(NetManagerCenterTest, RestrictBackgroundChangedTest002, TestSize.Level1)
443 {
444 int32_t ret = instance_.RestrictBackgroundChanged(false);
445 EXPECT_EQ(ret, NETMANAGER_ERROR);
446 }
447
448 HWTEST_F(NetManagerCenterTest, IsUidNetAccessTest001, TestSize.Level1)
449 {
450 bool ret = instance_.IsUidNetAccess(0, false);
451 EXPECT_TRUE(ret);
452 }
453
454 HWTEST_F(NetManagerCenterTest, IsUidNetAccessTest002, TestSize.Level1)
455 {
456 bool ret = instance_.IsUidNetAccess(0, true);
457 EXPECT_TRUE(ret);
458 }
459
460 HWTEST_F(NetManagerCenterTest, IsUidNetAllowedTest001, TestSize.Level1)
461 {
462 bool ret = instance_.IsUidNetAllowed(0, true);
463 EXPECT_TRUE(ret);
464 }
465
466 HWTEST_F(NetManagerCenterTest, IsUidNetAllowedTest002, TestSize.Level1)
467 {
468 bool ret = instance_.IsUidNetAllowed(0, false);
469 EXPECT_TRUE(ret);
470 }
471
472 HWTEST_F(NetManagerCenterTest, NetManagerCenterBranchTest001, TestSize.Level1)
473 {
474 instance_.RegisterPolicyService(nullptr);
475 std::list<std::string> list;
476 int32_t ret = instance_.GetIfaceNames(NetBearType::BEARER_DEFAULT, list);
477 EXPECT_EQ(ret, NETMANAGER_ERROR);
478
479 std::string ifaceName;
480 ret = instance_.GetIfaceNameByType(NetBearType::BEARER_DEFAULT, TEST_IDENT, ifaceName);
481 EXPECT_EQ(ret, NETMANAGER_ERROR);
482
483 uint32_t supplierId = 0;
484 ret = instance_.UpdateNetLinkInfo(supplierId, nullptr);
485 EXPECT_EQ(ret, NETMANAGER_ERROR);
486
487 ret = instance_.UpdateNetSupplierInfo(supplierId, nullptr);
488 EXPECT_EQ(ret, NETMANAGER_ERROR);
489
490 ret = instance_.RegisterNetConnCallback(nullptr);
491 EXPECT_EQ(ret, NETMANAGER_ERROR);
492
493 instance_.RegisterStatsService(nullptr);
494 ret = instance_.ResetStatsFactory();
495 EXPECT_EQ(ret, NETMANAGER_ERROR);
496
497 ret = instance_.ResetPolicyFactory();
498 EXPECT_EQ(ret, NETMANAGER_ERROR);
499
500 ret = instance_.ResetPolicies();
501 EXPECT_EQ(ret, NETMANAGER_ERROR);
502
503 instance_.RegisterEthernetService(nullptr);
504 ret = instance_.ResetEthernetFactory();
505 EXPECT_EQ(ret, NETMANAGER_ERROR);
506
507 ret = instance_.RestrictBackgroundChanged(false);
508 EXPECT_EQ(ret, NETMANAGER_ERROR);
509
510 ret = instance_.RegisterNetFactoryResetCallback(nullptr);
511 EXPECT_EQ(ret, NETMANAGER_ERROR);
512 }
513
514 HWTEST_F(NetManagerCenterTest, NetManagerCenterBranchTest002, TestSize.Level1)
515 {
516 sptr<NetConnBaseService> connService = new (std::nothrow) TestConnService();
517 instance_.RegisterConnService(connService);
518 NetBearType bearerType = BEARER_CELLULAR;
519 std::set<NetCap> netCaps{NET_CAPABILITY_INTERNET};
520 std::string ident = "ident";
521 int32_t result = instance_.RegisterNetSupplier(bearerType, ident, netCaps, supplierId_);
522 EXPECT_EQ(result, NETMANAGER_SUCCESS);
523
524 result = instance_.UnregisterNetSupplier(supplierId_);
525 EXPECT_EQ(result, NETMANAGER_SUCCESS);
526
527 uint32_t supplierId = 0;
528 sptr<NetLinkInfo> netLinkInfo = new (std::nothrow) NetLinkInfo();
529 result = instance_.UpdateNetLinkInfo(supplierId, netLinkInfo);
530 EXPECT_EQ(result, NETMANAGER_SUCCESS);
531
532 result = instance_.UpdateNetSupplierInfo(supplierId, nullptr);
533 EXPECT_EQ(result, NETMANAGER_SUCCESS);
534
535 result = instance_.RegisterNetConnCallback(nullptr);
536 EXPECT_EQ(result, NETMANAGER_SUCCESS);
537
538 result = instance_.RestrictBackgroundChanged(false);
539 EXPECT_EQ(result, NETMANAGER_SUCCESS);
540
541 sptr<NetStatsBaseService> netStatsService = new (std::nothrow) TestNetStatsService();
542 instance_.RegisterStatsService(netStatsService);
543 int32_t ret = instance_.ResetStatsFactory();
544 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
545
546 sptr<NetPolicyBaseService> netPolicyService = new (std::nothrow) TestNetPolicyService();
547 instance_.RegisterPolicyService(netPolicyService);
548 EXPECT_EQ(instance_.ResetPolicyFactory(), NETMANAGER_SUCCESS);
549 }
550 } // namespace NetManagerStandard
551 } // namespace OHOS