1 /*
2 * Copyright (c) 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 <gtest/gtest.h>
17
18 #define private public
19 #include "bandwidth_manager.h"
20 #undef private
21 #include "iptables_type.h"
22 #include "net_manager_constants.h"
23 #include "netnative_log_wrapper.h"
24 #include "netsys_controller.h"
25 #include "netsys_native_service_proxy.h"
26
27 #include "iservice_registry.h"
28 #include "system_ability_definition.h"
29
30 namespace OHOS {
31 namespace NetsysNative {
32 using namespace testing::ext;
33 using namespace NetManagerStandard;
34 using namespace nmd;
35 std::shared_ptr<BandwidthManager> g_BandwidthManager = nullptr;
36 constexpr uint32_t TEST_UID = 11256;
37 class BandwidthManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase()45 void BandwidthManagerTest::SetUpTestCase()
46 {
47 NetsysController::GetInstance().BandwidthEnableDataSaver(false);
48 g_BandwidthManager = std::make_shared<BandwidthManager>();
49 }
50
TearDownTestCase()51 void BandwidthManagerTest::TearDownTestCase()
52 {
53 g_BandwidthManager.reset();
54 }
55
SetUp()56 void BandwidthManagerTest::SetUp() {}
57
TearDown()58 void BandwidthManagerTest::TearDown() {}
59
60 /**
61 * @tc.name: BandwidthEnableDataSaverTest001
62 * @tc.desc: Test BandwidthManager BandwidthEnableDataSaver.
63 * @tc.type: FUNC
64 */
65 HWTEST_F(BandwidthManagerTest, BandwidthEnableDataSaverTest001, TestSize.Level1)
66 {
67 int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true);
68 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
69 }
70
71 /**
72 * @tc.name: BandwidthEnableDataSaverTest002
73 * @tc.desc: Test BandwidthManager BandwidthEnableDataSaver.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(BandwidthManagerTest, BandwidthEnableDataSaverTest002, TestSize.Level1)
77 {
78 int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(false);
79 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
80 }
81
82 /**
83 * @tc.name: BandwidthEnableDataSaverTest003
84 * @tc.desc: Test BandwidthManager BandwidthEnableDataSaver.
85 * @tc.type: FUNC
86 */
87 HWTEST_F(BandwidthManagerTest, BandwidthEnableDataSaverTest003, TestSize.Level1)
88 {
89 int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true);
90 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
91 ret = NetsysController::GetInstance().BandwidthEnableDataSaver(true);
92 EXPECT_EQ(ret, NETMANAGER_ERROR);
93 }
94
95 /**
96 * @tc.name: BandwidthEnableDataSaverTest004
97 * @tc.desc: Test BandwidthManager BandwidthEnableDataSaver.
98 * @tc.type: FUNC
99 */
100 HWTEST_F(BandwidthManagerTest, BandwidthEnableDataSaverTest004, TestSize.Level1)
101 {
102 int32_t ret = NetsysController::GetInstance().BandwidthEnableDataSaver(false);
103 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
104 ret = NetsysController::GetInstance().BandwidthEnableDataSaver(false);
105 EXPECT_EQ(ret, NETMANAGER_ERROR);
106 }
107
108 /**
109 * @tc.name: BandwidthSetIfaceQuotaTest001
110 * @tc.desc: Test BandwidthManager BandwidthSetIfaceQuota.
111 * @tc.type: FUNC
112 */
113 HWTEST_F(BandwidthManagerTest, BandwidthSetIfaceQuotaTest000, TestSize.Level1)
114 {
115 int32_t ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("_0iface", 2097152);
116 EXPECT_EQ(ret, NETMANAGER_ERROR);
117 }
118
119 /**
120 * @tc.name: BandwidthSetIfaceQuotaTest001
121 * @tc.desc: Test BandwidthManager BandwidthSetIfaceQuota.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(BandwidthManagerTest, BandwidthSetIfaceQuotaTest001, TestSize.Level1)
125 {
126 int32_t ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("iface0", 2097152);
127 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
128 }
129
130 /**
131 * @tc.name: BandwidthSetIfaceQuotaTest002
132 * @tc.desc: Test BandwidthManager BandwidthSetIfaceQuota.
133 * @tc.type: FUNC
134 */
135 HWTEST_F(BandwidthManagerTest, BandwidthSetIfaceQuotaTest002, TestSize.Level1)
136 {
137 int32_t ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("wlan0", 2097152);
138 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
139 }
140
141 /**
142 * @tc.name: BandwidthSetIfaceQuotaTest003
143 * @tc.desc: Test BandwidthManager BandwidthSetIfaceQuota.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(BandwidthManagerTest, BandwidthSetIfaceQuotaTest003, TestSize.Level1)
147 {
148 int32_t ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("wlan0", 5000000000000000);
149 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
150 }
151
152 /**
153 * @tc.name: BandwidthSetIfaceQuotaTest004
154 * @tc.desc: Test BandwidthManager BandwidthSetIfaceQuota.
155 * @tc.type: FUNC
156 */
157 HWTEST_F(BandwidthManagerTest, BandwidthSetIfaceQuotaTest004, TestSize.Level1)
158 {
159 int32_t ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("wlan0", 5000000000000);
160 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
161 ret = NetsysController::GetInstance().BandwidthSetIfaceQuota("wlan0", 2097152);
162 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
163 }
164
165 /**
166 * @tc.name: BandwidthRemoveIfaceQuotaTest000
167 * @tc.desc: Test BandwidthManager BandwidthRemoveIfaceQuota.
168 * @tc.type: FUNC
169 */
170 HWTEST_F(BandwidthManagerTest, BandwidthRemoveIfaceQuotaTest000, TestSize.Level1)
171 {
172 int32_t ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota("_iface0");
173 EXPECT_EQ(ret, NETMANAGER_ERROR);
174 }
175
176 /**
177 * @tc.name: BandwidthRemoveIfaceQuotaTest001
178 * @tc.desc: Test BandwidthManager BandwidthRemoveIfaceQuota.
179 * @tc.type: FUNC
180 */
181 HWTEST_F(BandwidthManagerTest, BandwidthRemoveIfaceQuotaTest001, TestSize.Level1)
182 {
183 int32_t ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota("iface0");
184 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
185 }
186
187 /**
188 * @tc.name: BandwidthRemoveIfaceQuotaTest002
189 * @tc.desc: Test BandwidthManager BandwidthRemoveIfaceQuota.
190 * @tc.type: FUNC
191 */
192 HWTEST_F(BandwidthManagerTest, BandwidthRemoveIfaceQuotaTest002, TestSize.Level1)
193 {
194 int32_t ret = NetsysController::GetInstance().BandwidthRemoveIfaceQuota("wlan0");
195 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
196 }
197
198 /**
199 * @tc.name: BandwidthAddDeniedListTest001
200 * @tc.desc: Test BandwidthManager BandwidthAddDeniedList.
201 * @tc.type: FUNC
202 */
203 HWTEST_F(BandwidthManagerTest, BandwidthAddDeniedListTest001, TestSize.Level1)
204 {
205 int32_t ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
206 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
207 ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
208 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
209 }
210
211 /**
212 * @tc.name: BandwidthAddDeniedListTest002
213 * @tc.desc: Test BandwidthManager BandwidthAddDeniedList.
214 * @tc.type: FUNC
215 */
216 HWTEST_F(BandwidthManagerTest, BandwidthAddDeniedListTest002, TestSize.Level1)
217 {
218 int32_t ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
219 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
220 ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
221 EXPECT_EQ(ret, NETMANAGER_ERROR);
222 }
223
224 /**
225 * @tc.name: BandwidthRemoveDeniedListTest001
226 * @tc.desc: Test BandwidthManager BandwidthRemoveDeniedList.
227 * @tc.type: FUNC
228 */
229 HWTEST_F(BandwidthManagerTest, BandwidthRemoveDeniedListTest001, TestSize.Level1)
230 {
231 int32_t ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
232 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
233 }
234
235 /**
236 * @tc.name: BandwidthRemoveDeniedListTest002
237 * @tc.desc: Test BandwidthManager BandwidthRemoveDeniedList.
238 * @tc.type: FUNC
239 */
240 HWTEST_F(BandwidthManagerTest, BandwidthRemoveDeniedListTest002, TestSize.Level1)
241 {
242 int32_t ret = NetsysController::GetInstance().BandwidthAddDeniedList(TEST_UID);
243 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
244 ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
245 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
246 ret = NetsysController::GetInstance().BandwidthRemoveDeniedList(TEST_UID);
247 EXPECT_EQ(ret, NETMANAGER_ERROR);
248 }
249
250 /**
251 * @tc.name: BandwidthAddAllowedListTest001
252 * @tc.desc: Test BandwidthManager BandwidthAddAllowedList.
253 * @tc.type: FUNC
254 */
255 HWTEST_F(BandwidthManagerTest, BandwidthAddAllowedListTest001, TestSize.Level1)
256 {
257 int32_t ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID);
258 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
259 }
260
261 /**
262 * @tc.name: BandwidthAddAllowedListTest002
263 * @tc.desc: Test BandwidthManager BandwidthAddAllowedList.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(BandwidthManagerTest, BandwidthAddAllowedListTest002, TestSize.Level1)
267 {
268 int32_t ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID);
269 EXPECT_EQ(ret, NETMANAGER_ERROR);
270 }
271
272 /**
273 * @tc.name: BandwidthRemoveAllowedListTest001
274 * @tc.desc: Test BandwidthManager BandwidthRemoveAllowedList.
275 * @tc.type: FUNC
276 */
277 HWTEST_F(BandwidthManagerTest, BandwidthRemoveAllowedListTest001, TestSize.Level1)
278 {
279 int32_t ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID);
280 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
281 }
282
283 /**
284 * @tc.name: BandwidthRemoveAllowedListTest002
285 * @tc.desc: Test BandwidthManager BandwidthRemoveAllowedList.
286 * @tc.type: FUNC
287 */
288 HWTEST_F(BandwidthManagerTest, BandwidthRemoveAllowedListTest002, TestSize.Level1)
289 {
290 int32_t ret = NetsysController::GetInstance().BandwidthAddAllowedList(TEST_UID);
291 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
292 ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID);
293 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
294 ret = NetsysController::GetInstance().BandwidthRemoveAllowedList(TEST_UID);
295 EXPECT_EQ(ret, NETMANAGER_ERROR);
296 }
297
298 /**
299 * @tc.name: BandwidthInnerFuctionTest
300 * @tc.desc: Test BandwidthManager BandwidthInnerFuctionTest.
301 * @tc.type: FUNC
302 */
303 HWTEST_F(BandwidthManagerTest, BandwidthInnerFuctionTest, TestSize.Level1)
304 {
305 std::shared_ptr<OHOS::nmd::BandwidthManager> bandwidthManager = std::make_shared<OHOS::nmd::BandwidthManager>();
306 if (bandwidthManager->chainInitFlag_ == false) {
307 int32_t ret = bandwidthManager->InitChain();
308 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
309 ret = bandwidthManager->InitDefaultRules();
310 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
311 }
312 ChainType chain = ChainType::CHAIN_OHBW_INPUT;
313 std::string resultStr = bandwidthManager->FetchChainName(chain);
314 EXPECT_EQ((resultStr == "ohbw_INPUT"), true);
315
316 chain = ChainType::CHAIN_OHBW_OUTPUT;
317 resultStr = bandwidthManager->FetchChainName(chain);
318 EXPECT_EQ((resultStr == "ohbw_OUTPUT"), true);
319
320 chain = ChainType::CHAIN_OHBW_FORWARD;
321 resultStr = bandwidthManager->FetchChainName(chain);
322 EXPECT_EQ((resultStr == "ohbw_FORWARD"), true);
323
324 chain = ChainType::CHAIN_OHBW_DENIED_LIST_BOX;
325 resultStr = bandwidthManager->FetchChainName(chain);
326 EXPECT_EQ((resultStr == "ohbw_denied_list_box"), true);
327
328 chain = ChainType::CHAIN_OHBW_ALLOWED_LIST_BOX;
329 resultStr = bandwidthManager->FetchChainName(chain);
330 EXPECT_EQ((resultStr == "ohbw_allowed_list_box"), true);
331
332 chain = ChainType::CHAIN_OHBW_GLOBAL_ALERT;
333 resultStr = bandwidthManager->FetchChainName(chain);
334 EXPECT_EQ((resultStr == "ohbw_global_alert"), true);
335
336 chain = ChainType::CHAIN_OHBW_COSTLY_SHARED;
337 resultStr = bandwidthManager->FetchChainName(chain);
338 EXPECT_EQ((resultStr == "ohbw_costly_shared"), true);
339
340 chain = ChainType::CHAIN_OHBW_DATA_SAVER;
341 resultStr = bandwidthManager->FetchChainName(chain);
342 EXPECT_EQ((resultStr == "ohbw_data_saver"), true);
343
344 chain = ChainType::CHAIN_OHFW_UNDOZABLE;
345 resultStr = bandwidthManager->FetchChainName(chain);
346 EXPECT_EQ((resultStr == "oh_unusable"), true);
347 bandwidthManager->DeInitChain();
348 }
349
350 /**
351 * @tc.name: IptablesNewChain000
352 * @tc.desc: Test BandwidthManager IptablesNewChain.
353 * @tc.type: FUNC
354 */
355 HWTEST_F(BandwidthManagerTest, IptablesNewChain000, TestSize.Level1)
356 {
357 std::string chainName = g_BandwidthManager->FetchChainName(ChainType::CHAIN_OHFW_INPUT);
358 int32_t ret = g_BandwidthManager->IptablesNewChain(chainName);
359 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
360 }
361
362 /**
363 * @tc.name: IptablesDeleteChain000
364 * @tc.desc: Test BandwidthManager IptablesDeleteChain.
365 * @tc.type: FUNC
366 */
367 HWTEST_F(BandwidthManagerTest, IptablesDeleteChain000, TestSize.Level1)
368 {
369 std::string chainName = g_BandwidthManager->FetchChainName(ChainType::CHAIN_OHFW_INPUT);
370 int32_t ret = g_BandwidthManager->IptablesDeleteChain(chainName);
371 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
372 }
373
374 /**
375 * @tc.name: SetGlobalAlert000
376 * @tc.desc: Test BandwidthManager SetGlobalAlert.
377 * @tc.type: FUNC
378 */
379 HWTEST_F(BandwidthManagerTest, SetGlobalAlert000, TestSize.Level1)
380 {
381 int64_t bytes = 0;
382 int32_t ret = g_BandwidthManager->SetGlobalAlert(BandwidthManager::OP_SET, bytes);
383 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
384 }
385
386 /**
387 * @tc.name: SetGlobalAlert001
388 * @tc.desc: Test BandwidthManager SetGlobalAlert.
389 * @tc.type: FUNC
390 */
391 HWTEST_F(BandwidthManagerTest, SetGlobalAlert001, TestSize.Level1)
392 {
393 int64_t bytes = 0;
394 int32_t ret = g_BandwidthManager->SetGlobalAlert(BandwidthManager::Operate::OP_UNSET, bytes);
395 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
396 }
397
398 /**
399 * @tc.name: SetGlobalAlert002
400 * @tc.desc: Test BandwidthManager SetGlobalAlert.
401 * @tc.type: FUNC
402 */
403 HWTEST_F(BandwidthManagerTest, SetGlobalAlert002, TestSize.Level1)
404 {
405 int64_t bytes = 1;
406 int32_t ret = g_BandwidthManager->SetGlobalAlert(BandwidthManager::Operate::OP_SET, bytes);
407 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
408 }
409
410 /**
411 * @tc.name: SetGlobalAlert003
412 * @tc.desc: Test BandwidthManager SetGlobalAlert.
413 * @tc.type: FUNC
414 */
415 HWTEST_F(BandwidthManagerTest, SetGlobalAlert003, TestSize.Level1)
416 {
417 int64_t bytes = 1;
418 int32_t ret = g_BandwidthManager->SetGlobalAlert(BandwidthManager::Operate::OP_UNSET, bytes);
419 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
420 }
421
422 /**
423 * @tc.name: SetCostlyAlert000
424 * @tc.desc: Test BandwidthManager SetCostlyAlert.
425 * @tc.type: FUNC
426 */
427 HWTEST_F(BandwidthManagerTest, SetCostlyAlert000, TestSize.Level1)
428 {
429 std::string iface = "wlan0";
430 int64_t bytes = 0;
431 int32_t ret = g_BandwidthManager->SetCostlyAlert(BandwidthManager::Operate::OP_SET, iface, bytes);
432 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
433 }
434
435 /**
436 * @tc.name: SetCostlyAlert001
437 * @tc.desc: Test BandwidthManager SetCostlyAlert.
438 * @tc.type: FUNC
439 */
440 HWTEST_F(BandwidthManagerTest, SetCostlyAlert001, TestSize.Level1)
441 {
442 std::string iface = "wlan0";
443 int64_t bytes = 0;
444 int32_t ret = g_BandwidthManager->SetCostlyAlert(BandwidthManager::Operate::OP_SET, iface, bytes);
445 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
446 ret = g_BandwidthManager->SetCostlyAlert(BandwidthManager::Operate::OP_UNSET, iface, bytes);
447 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
448 }
449
450 /**
451 * @tc.name: SetCostlyAlert002
452 * @tc.desc: Test BandwidthManager SetCostlyAlert.
453 * @tc.type: FUNC
454 */
455 HWTEST_F(BandwidthManagerTest, SetCostlyAlert002, TestSize.Level1)
456 {
457 std::string iface = "wlan0";
458 int64_t bytes = 0;
459 int32_t ret = g_BandwidthManager->SetCostlyAlert(BandwidthManager::Operate::OP_SET, iface, bytes);
460 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
461 bytes = 100;
462 ret = g_BandwidthManager->SetCostlyAlert(BandwidthManager::Operate::OP_UNSET, iface, bytes);
463 EXPECT_EQ(ret, NETMANAGER_ERROR);
464 }
465
466 /**
467 * @tc.name: EnableDataSaver000
468 * @tc.desc: Test BandwidthManager EnableDataSaver.
469 * @tc.type: FUNC
470 */
471 HWTEST_F(BandwidthManagerTest, EnableDataSaver000, TestSize.Level1)
472 {
473 int32_t ret = g_BandwidthManager->EnableDataSaver(false);
474 EXPECT_EQ(ret, NETMANAGER_ERROR);
475 }
476
477 /**
478 * @tc.name: EnableDataSaver001
479 * @tc.desc: Test BandwidthManager EnableDataSaver.
480 * @tc.type: FUNC
481 */
482 HWTEST_F(BandwidthManagerTest, EnableDataSaver001, TestSize.Level1)
483 {
484 int32_t ret = g_BandwidthManager->EnableDataSaver(true);
485 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
486 ret = g_BandwidthManager->EnableDataSaver(false);
487 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
488 }
489
490 /**
491 * @tc.name: SetIfaceQuota000
492 * @tc.desc: Test BandwidthManager SetIfaceQuota.
493 * @tc.type: FUNC
494 */
495 HWTEST_F(BandwidthManagerTest, SetIfaceQuota000, TestSize.Level1)
496 {
497 std::string iface = "wlan0";
498 int64_t bytes = 0;
499 int32_t ret = g_BandwidthManager->SetIfaceQuota(iface, bytes);
500 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
501 }
502
503 /**
504 * @tc.name: SetIfaceQuota001
505 * @tc.desc: Test BandwidthManager SetIfaceQuota.
506 * @tc.type: FUNC
507 */
508 HWTEST_F(BandwidthManagerTest, SetIfaceQuota001, TestSize.Level1)
509 {
510 std::string iface = "// /.";
511 int64_t bytes = 0;
512 int32_t ret = g_BandwidthManager->SetIfaceQuota(iface, bytes);
513 EXPECT_EQ(ret, NETMANAGER_ERROR);
514 }
515
516 /**
517 * @tc.name: SetIfaceQuota002
518 * @tc.desc: Test BandwidthManager SetIfaceQuota.
519 * @tc.type: FUNC
520 */
521 HWTEST_F(BandwidthManagerTest, SetIfaceQuota002, TestSize.Level1)
522 {
523 std::string iface = "wlan0";
524 int64_t bytes = 0;
525 int32_t ret = g_BandwidthManager->SetIfaceQuota(iface, bytes);
526 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
527 bytes = 1;
528 ret = g_BandwidthManager->SetIfaceQuota(iface, bytes);
529 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
530 }
531
532 /**
533 * @tc.name: RemoveIfaceQuota000
534 * @tc.desc: Test BandwidthManager RemoveIfaceQuota.
535 * @tc.type: FUNC
536 */
537 HWTEST_F(BandwidthManagerTest, RemoveIfaceQuota000, TestSize.Level1)
538 {
539 std::string iface = "// /.";
540 int32_t ret = g_BandwidthManager->RemoveIfaceQuota(iface);
541 EXPECT_EQ(ret, NETMANAGER_ERROR);
542 }
543
544 /**
545 * @tc.name: RemoveIfaceQuota001
546 * @tc.desc: Test BandwidthManager RemoveIfaceQuota.
547 * @tc.type: FUNC
548 */
549 HWTEST_F(BandwidthManagerTest, RemoveIfaceQuota001, TestSize.Level1)
550 {
551 std::string iface = "wlan0";
552 int32_t ret = g_BandwidthManager->RemoveIfaceQuota(iface);
553 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
554 }
555
556 /**
557 * @tc.name: RemoveIfaceQuota002
558 * @tc.desc: Test BandwidthManager RemoveIfaceQuota.
559 * @tc.type: FUNC
560 */
561 HWTEST_F(BandwidthManagerTest, RemoveIfaceQuota002, TestSize.Level1)
562 {
563 std::string iface = "wlan0";
564 int64_t bytes = 0;
565 int32_t ret = g_BandwidthManager->SetIfaceQuota(iface, bytes);
566 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
567 ret = g_BandwidthManager->RemoveIfaceQuota(iface);
568 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
569 }
570
571 /**
572 * @tc.name: AddDeniedList000
573 * @tc.desc: Test BandwidthManager AddDeniedList.
574 * @tc.type: FUNC
575 */
576 HWTEST_F(BandwidthManagerTest, AddDeniedList000, TestSize.Level1)
577 {
578 uint32_t uid = 150000;
579 int32_t ret = g_BandwidthManager->AddDeniedList(uid);
580 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
581 ret = g_BandwidthManager->AddDeniedList(uid);
582 EXPECT_EQ(ret, NETMANAGER_ERROR);
583 }
584
585 /**
586 * @tc.name: RemoveDeniedList000
587 * @tc.desc: Test BandwidthManager RemoveDeniedList.
588 * @tc.type: FUNC
589 */
590 HWTEST_F(BandwidthManagerTest, RemoveDeniedList000, TestSize.Level1)
591 {
592 uint32_t uid = 150000;
593 int32_t ret = g_BandwidthManager->RemoveDeniedList(uid);
594 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
595 }
596
597 /**
598 * @tc.name: RemoveDeniedList001
599 * @tc.desc: Test BandwidthManager RemoveDeniedList.
600 * @tc.type: FUNC
601 */
602 HWTEST_F(BandwidthManagerTest, RemoveDeniedList001, TestSize.Level1)
603 {
604 uint32_t uid = 150000;
605 int32_t ret = g_BandwidthManager->AddDeniedList(uid);
606 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
607 ret = g_BandwidthManager->RemoveDeniedList(uid);
608 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
609 }
610
611 /**
612 * @tc.name: AddAllowedList000
613 * @tc.desc: Test BandwidthManager AddAllowedList.
614 * @tc.type: FUNC
615 */
616 HWTEST_F(BandwidthManagerTest, AddAllowedList000, TestSize.Level1)
617 {
618 uint32_t uid = 150000;
619 int32_t ret = g_BandwidthManager->AddAllowedList(uid);
620 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
621 ret = g_BandwidthManager->AddAllowedList(uid);
622 EXPECT_EQ(ret, NETMANAGER_ERROR);
623 }
624
625 /**
626 * @tc.name: RemoveAllowedList000
627 * @tc.desc: Test BandwidthManager RemoveAllowedList.
628 * @tc.type: FUNC
629 */
630 HWTEST_F(BandwidthManagerTest, RemoveAllowedList000, TestSize.Level1)
631 {
632 uint32_t uid = 150000;
633 int32_t ret = g_BandwidthManager->RemoveAllowedList(uid);
634 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
635 }
636
637 /**
638 * @tc.name: RemoveAllowedList001
639 * @tc.desc: Test BandwidthManager RemoveAllowedList.
640 * @tc.type: FUNC
641 */
642 HWTEST_F(BandwidthManagerTest, RemoveAllowedList001, TestSize.Level1)
643 {
644 uint32_t uid = 150000;
645 int32_t ret = g_BandwidthManager->AddDeniedList(uid);
646 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
647 ret = g_BandwidthManager->RemoveAllowedList(uid);
648 EXPECT_EQ(ret, NETMANAGER_ERROR);
649 }
650 } // namespace NetsysNative
651 } // namespace OHOS
652