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 <thread>
17
18 #include <gtest/gtest.h>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24
25 #include "net_manager_constants.h"
26 #include "net_policy_callback_test.h"
27 #include "net_policy_client.h"
28 #include "net_policy_constants.h"
29 #include "net_policy_inner_define.h"
30 #include "net_policy_traffic.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 constexpr uint32_t NO_DATA_SIZE = 0;
35 const std::string TEST_STRING_PERIODDURATION = "M1";
36 const std::string ICCID_1 = "sim_abcdefg_1";
37 const std::string ICCID_2 = "sim_abcdefg_2";
38 constexpr uint32_t TEST_WARNING_BYTES_1 = 321;
39 constexpr uint32_t TEST_WARNING_BYTES_2 = 123;
40 constexpr uint32_t TEST_WARNING_BYTES_3 = 123456;
41 constexpr uint32_t TEST_LIMIT_BYTES_1 = 4321;
42 constexpr uint32_t TEST_LIMIT_BYTES_2 = 1234;
43 constexpr uint32_t TEST_LIMIT_BYTES_3 = 1234567;
44 constexpr uint32_t TEST_LAST_WARNING_REMIND_1 = 7654321;
45 constexpr uint32_t TEST_LAST_WARNING_REMIND_2 = 1234567;
46 constexpr uint32_t TEST_LAST_LIMIT_REMIND_1 = 87654321;
47 constexpr uint32_t TEST_LAST_LIMIT_REMIND_2 = 12345678;
48
49 std::shared_ptr<NetPolicyTraffic> g_netPolicyTraffic = nullptr;
50
51 using namespace testing::ext;
52 class UtNetPolicyTraffic : public testing::Test {
53 public:
54 static void SetUpTestCase();
55 static void TearDownTestCase();
56 void SetUp();
57 void TearDown();
58 sptr<NetPolicyCallbackTest> GetINetPolicyCallbackSample() const;
59 };
60
SetUpTestCase()61 void UtNetPolicyTraffic::SetUpTestCase()
62 {
63 g_netPolicyTraffic = std::make_shared<NetPolicyTraffic>();
64 g_netPolicyTraffic->Init();
65 }
66
TearDownTestCase()67 void UtNetPolicyTraffic::TearDownTestCase()
68 {
69 g_netPolicyTraffic.reset();
70 }
71
SetUp()72 void UtNetPolicyTraffic::SetUp()
73 {
74 NetQuotaPolicy quotaPolicy1;
75 quotaPolicy1.networkmatchrule.simId = ICCID_1;
76 quotaPolicy1.quotapolicy.periodDuration = "M1";
77 quotaPolicy1.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
78 quotaPolicy1.quotapolicy.warningBytes = TEST_WARNING_BYTES_1;
79 quotaPolicy1.quotapolicy.limitBytes = TEST_LIMIT_BYTES_1;
80 quotaPolicy1.quotapolicy.lastWarningRemind = TEST_LAST_WARNING_REMIND_1;
81 quotaPolicy1.quotapolicy.lastLimitRemind = TEST_LAST_LIMIT_REMIND_1;
82 quotaPolicy1.quotapolicy.metered = true;
83 quotaPolicy1.quotapolicy.limitAction = LimitAction::LIMIT_ACTION_ALERT_ONLY;
84
85 NetQuotaPolicy quotaPolicy2;
86 quotaPolicy2.networkmatchrule.simId = ICCID_2;
87 quotaPolicy2.quotapolicy.periodDuration = "Y1";
88 quotaPolicy2.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
89 quotaPolicy2.quotapolicy.warningBytes = TEST_WARNING_BYTES_2;
90 quotaPolicy2.quotapolicy.limitBytes = TEST_LIMIT_BYTES_2;
91 quotaPolicy2.quotapolicy.lastWarningRemind = TEST_LAST_WARNING_REMIND_2;
92 quotaPolicy2.quotapolicy.lastLimitRemind = TEST_LAST_LIMIT_REMIND_2;
93 quotaPolicy2.quotapolicy.metered = true;
94 quotaPolicy2.quotapolicy.limitAction = LimitAction::LIMIT_ACTION_ACCESS_DISABLED;
95
96 std::vector<NetQuotaPolicy> quotaPolicies;
97 quotaPolicies.push_back(quotaPolicy1);
98 quotaPolicies.push_back(quotaPolicy2);
99 g_netPolicyTraffic->UpdateQuotaPolicies(quotaPolicies);
100 }
101
TearDown()102 void UtNetPolicyTraffic::TearDown()
103 {
104 std::vector<NetQuotaPolicy> quotaPolicies;
105 g_netPolicyTraffic->UpdateQuotaPolicies(quotaPolicies);
106 }
107
108 /**
109 * @tc.name: UpdateQuotaPolicies001
110 * @tc.desc: Test NetPolicyTraffic UpdateQuotaPolicies.
111 * @tc.type: FUNC
112 */
113 HWTEST_F(UtNetPolicyTraffic, UpdateQuotaPolicies001, TestSize.Level1)
114 {
115 NetQuotaPolicy quotaPolicy1;
116 quotaPolicy1.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
117 quotaPolicy1.networkmatchrule.simId = ICCID_1;
118 quotaPolicy1.quotapolicy.periodDuration = "M1";
119 quotaPolicy1.quotapolicy.warningBytes = TEST_WARNING_BYTES_3;
120 quotaPolicy1.quotapolicy.limitBytes = TEST_LIMIT_BYTES_3;
121 quotaPolicy1.quotapolicy.lastLimitRemind = -1;
122 quotaPolicy1.quotapolicy.metered = 0;
123 quotaPolicy1.quotapolicy.source = 0;
124
125 NetQuotaPolicy quotaPolicy2;
126 quotaPolicy2.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
127 quotaPolicy2.networkmatchrule.simId = ICCID_2;
128 quotaPolicy2.quotapolicy.periodDuration = "Y1";
129 quotaPolicy2.quotapolicy.warningBytes = TEST_WARNING_BYTES_3;
130 quotaPolicy2.quotapolicy.limitBytes = TEST_LIMIT_BYTES_3;
131 quotaPolicy2.quotapolicy.lastLimitRemind = -1;
132 quotaPolicy2.quotapolicy.metered = 0;
133 quotaPolicy2.quotapolicy.source = 0;
134 std::vector<NetQuotaPolicy> quotaPolicies;
135 quotaPolicies.push_back(quotaPolicy1);
136 quotaPolicies.push_back(quotaPolicy2);
137 int32_t result = g_netPolicyTraffic->UpdateQuotaPolicies(quotaPolicies);
138 ASSERT_EQ(result, NETMANAGER_SUCCESS);
139 }
140
141 /**
142 * @tc.name: GetNetQuotaPolicies001
143 * @tc.desc: Test NetPolicyTraffic GetNetQuotaPolicies.
144 * @tc.type: FUNC
145 */
146 HWTEST_F(UtNetPolicyTraffic, GetNetQuotaPolicies001, TestSize.Level1)
147 {
148 std::vector<NetQuotaPolicy> quotaPolicies;
149 int32_t result = g_netPolicyTraffic->GetNetQuotaPolicies(quotaPolicies);
150 ASSERT_EQ(result, NETMANAGER_SUCCESS);
151 ASSERT_GT(quotaPolicies.size(), NO_DATA_SIZE);
152 }
153
154 /**
155 * @tc.name: UpdateRemindPolicy001
156 * @tc.desc: Test NetPolicyTraffic UpdateRemindPolicy REMIND_TYPE_LIMIT
157 * @tc.type: FUNC
158 */
159 HWTEST_F(UtNetPolicyTraffic, UpdateRemindPolicy001, TestSize.Level1)
160 {
161 int32_t result =
162 g_netPolicyTraffic->UpdateRemindPolicy(NetBearType::BEARER_CELLULAR, ICCID_1, RemindType::REMIND_TYPE_LIMIT);
163 ASSERT_EQ(result, NETMANAGER_SUCCESS);
164 std::vector<NetQuotaPolicy> quotaPolicies;
165 result = g_netPolicyTraffic->GetNetQuotaPolicies(quotaPolicies);
166 ASSERT_EQ(result, NETMANAGER_SUCCESS);
167 for (auto "aPolicy : quotaPolicies) {
168 if (quotaPolicy.networkmatchrule.netType == NetBearType::BEARER_CELLULAR &&
169 quotaPolicy.networkmatchrule.simId == ICCID_1) {
170 if (quotaPolicy.quotapolicy.lastLimitRemind < 0) {
171 break;
172 }
173 auto now = time(nullptr);
174 ASSERT_LT(now - quotaPolicy.quotapolicy.lastLimitRemind, 100);
175 return;
176 }
177 }
178 FAIL();
179 }
180
181 /**
182 * @tc.name: UpdateRemindPolicy002
183 * @tc.desc: Test NetPolicyTraffic UpdateRemindPolicy REMIND_TYPE_WARNING
184 * @tc.type: FUNC
185 */
186 HWTEST_F(UtNetPolicyTraffic, UpdateRemindPolicy002, TestSize.Level1)
187 {
188 int32_t result =
189 g_netPolicyTraffic->UpdateRemindPolicy(NetBearType::BEARER_CELLULAR, ICCID_2, RemindType::REMIND_TYPE_WARNING);
190 ASSERT_EQ(result, NETMANAGER_SUCCESS);
191 std::vector<NetQuotaPolicy> quotaPolicies;
192 result = g_netPolicyTraffic->GetNetQuotaPolicies(quotaPolicies);
193 ASSERT_EQ(result, NETMANAGER_SUCCESS);
194 for (auto "aPolicy : quotaPolicies) {
195 if (quotaPolicy.networkmatchrule.netType == NetBearType::BEARER_CELLULAR &&
196 quotaPolicy.networkmatchrule.simId == ICCID_2) {
197 if (quotaPolicy.quotapolicy.lastWarningRemind < 0) {
198 break;
199 }
200 auto now = time(nullptr);
201 ASSERT_LT(now - quotaPolicy.quotapolicy.lastWarningRemind, 100);
202 return;
203 }
204 }
205 FAIL();
206 }
207
208 /**
209 * @tc.name: UpdateRemindPolicy003
210 * @tc.desc: Test NetPolicyTraffic UpdateRemindPolicy No RemindType
211 * @tc.type: FUNC
212 */
213 HWTEST_F(UtNetPolicyTraffic, UpdateRemindPolicy003, TestSize.Level1)
214 {
215 uint32_t errorRemindType = 3;
216 int32_t result = g_netPolicyTraffic->UpdateRemindPolicy(NetBearType::BEARER_CELLULAR, ICCID_2, errorRemindType);
217 ASSERT_EQ(result, NETMANAGER_ERR_PARAMETER_ERROR);
218 std::vector<NetQuotaPolicy> quotaPolicies;
219 result = g_netPolicyTraffic->GetNetQuotaPolicies(quotaPolicies);
220 ASSERT_EQ(result, NETMANAGER_SUCCESS);
221 for (auto "aPolicy : quotaPolicies) {
222 if (quotaPolicy.networkmatchrule.netType == NetBearType::BEARER_CELLULAR &&
223 quotaPolicy.networkmatchrule.simId == ICCID_2) {
224 if (quotaPolicy.quotapolicy.lastWarningRemind < 0) {
225 break;
226 }
227 auto now = time(nullptr);
228 ASSERT_GT(now - quotaPolicy.quotapolicy.lastWarningRemind, 100);
229 return;
230 }
231 }
232 FAIL();
233 }
234
235 /**
236 * @tc.name: HandleEvent001
237 * @tc.desc: Test NetPolicyTraffic HandleEvent
238 * @tc.type: FUNC
239 */
240 HWTEST_F(UtNetPolicyTraffic, HandleEvent001, TestSize.Level1)
241 {
242 int32_t eventId = 0;
243 std::shared_ptr<PolicyEvent> policyEvent = nullptr;
244 g_netPolicyTraffic->HandleEvent(eventId, policyEvent);
245
246 // Test NetPolicyTraffic GetMeteredIfaces
247 auto &ifaces = g_netPolicyTraffic->GetMeteredIfaces();
248 ASSERT_GE(ifaces.size(), NO_DATA_SIZE);
249 }
250
251 /**
252 * @tc.name: ResetPolicies001
253 * @tc.desc: Test NetPolicyTraffic ResetPolicies.
254 * @tc.type: FUNC
255 */
256 HWTEST_F(UtNetPolicyTraffic, ResetPolicies001, TestSize.Level1)
257 {
258 std::vector<NetQuotaPolicy> quotaPolicies;
259 int32_t ret = g_netPolicyTraffic->ResetPolicies(ICCID_1);
260 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
261 g_netPolicyTraffic->GetNetQuotaPolicies(quotaPolicies);
262 for (auto quotaPolicy : quotaPolicies) {
263 if (quotaPolicy.networkmatchrule.simId == ICCID_1) {
264 if (quotaPolicy.quotapolicy.periodDuration == "M1" &&
265 quotaPolicy.quotapolicy.warningBytes == DATA_USAGE_UNKNOWN &&
266 quotaPolicy.quotapolicy.limitBytes == DATA_USAGE_UNKNOWN &&
267 quotaPolicy.quotapolicy.lastWarningRemind == REMIND_NEVER &&
268 quotaPolicy.quotapolicy.lastLimitRemind == REMIND_NEVER && !quotaPolicy.quotapolicy.metered) {
269 SUCCEED();
270 return;
271 }
272 }
273 }
274 FAIL();
275 }
276
277
278 /**
279 * @tc.name: ResetPolicies002
280 * @tc.desc: Test NetPolicyTraffic ResetPolicies
281 * @tc.type: FUNC
282 */
283 HWTEST_F(UtNetPolicyTraffic, ResetPolicies002, TestSize.Level1)
284 {
285 auto ret = g_netPolicyTraffic->ResetPolicies();
286 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
287 }
288
289 /**
290 * @tc.name: ReachedLimit001
291 * @tc.desc: Test NetPolicyTraffic ReachedLimit
292 * @tc.type: FUNC
293 */
294 HWTEST_F(UtNetPolicyTraffic, ReachedLimit001, TestSize.Level1)
295 {
296 std::string testIface = "wlan0";
297 g_netPolicyTraffic->ReachedLimit(testIface);
298
299 // Test NetPolicyTraffic GetDumpMessage
300 std::string msg;
301 g_netPolicyTraffic->GetDumpMessage(msg);
302 ASSERT_FALSE(msg.empty());
303 }
304
305 /**
306 * @tc.name: UpdateQuotaPoliciesInner001
307 * @tc.desc: Test NetPolicyTraffic UpdateQuotaPoliciesInner
308 * @tc.type: FUNC
309 */
310 HWTEST_F(UtNetPolicyTraffic, UpdateQuotaPoliciesInner001, TestSize.Level1)
311 {
312 auto ret = g_netPolicyTraffic->UpdateQuotaPoliciesInner();
313 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
314 }
315
316 /**
317 * @tc.name: GetQuotaRemain001
318 * @tc.desc: Test NetPolicyTraffic GetQuotaRemain
319 * @tc.type: FUNC
320 */
321 HWTEST_F(UtNetPolicyTraffic, GetQuotaRemain001, TestSize.Level1)
322 {
323 // Test NetPolicyTraffic UpdateQuotaNotify
324 g_netPolicyTraffic->UpdateQuotaNotify();
325
326 NetQuotaPolicy quotaPolicy;
327 auto ret = g_netPolicyTraffic->GetQuotaRemain(quotaPolicy);
328 ASSERT_GE(ret, 0);
329 }
330
331 /**
332 * @tc.name: UpdateNetEnableStatus001
333 * @tc.desc: Test NetPolicyTraffic UpdateNetEnableStatus
334 * @tc.type: FUNC
335 */
336 HWTEST_F(UtNetPolicyTraffic, UpdateNetEnableStatus001, TestSize.Level1)
337 {
338 // Test NetPolicyTraffic UpdateNetEnableStatus
339 NetQuotaPolicy quotaPolicy;
340 quotaPolicy.quotapolicy.metered = true;
341 g_netPolicyTraffic->UpdateNetEnableStatus(quotaPolicy);
342
343 quotaPolicy.quotapolicy.metered = false;
344 quotaPolicy.quotapolicy.limitAction = LIMIT_ACTION_ACCESS_DISABLED;
345 g_netPolicyTraffic->UpdateNetEnableStatus(quotaPolicy);
346
347 quotaPolicy.quotapolicy.limitAction = LIMIT_ACTION_NONE;
348 g_netPolicyTraffic->UpdateNetEnableStatus(quotaPolicy);
349
350 // Test NetPolicyTraffic IsValidQuotaPolicy
351 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_DEFAULT;
352 auto ret = g_netPolicyTraffic->IsValidQuotaPolicy(quotaPolicy);
353 EXPECT_FALSE(ret);
354 }
355
356 /**
357 * @tc.name: FormalizeQuotaPolicies001
358 * @tc.desc: Test NetPolicyTraffic FormalizeQuotaPolicies
359 * @tc.type: FUNC
360 */
361 HWTEST_F(UtNetPolicyTraffic, FormalizeQuotaPolicies001, TestSize.Level1)
362 {
363 std::vector<NetQuotaPolicy> quotaPolicies;
364 NetQuotaPolicy quotaPolicy;
365 quotaPolicy.quotapolicy.metered = false;
366 quotaPolicy.quotapolicy.limitAction = LIMIT_ACTION_NONE;
367 quotaPolicy.quotapolicy.limitBytes = DATA_USAGE_UNKNOWN;
368 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_DEFAULT;
369 quotaPolicy.quotapolicy.periodDuration = "ff";
370 quotaPolicies.push_back(quotaPolicy);
371 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
372 quotaPolicy.quotapolicy.periodDuration = "";
373 quotaPolicies.push_back(quotaPolicy);
374 quotaPolicy.quotapolicy.periodDuration = "testPeriodDuration";
375 quotaPolicies.push_back(quotaPolicy);
376 quotaPolicy.quotapolicy.periodDuration = "M1";
377 quotaPolicies.push_back(quotaPolicy);
378 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_WIFI;
379 quotaPolicies.push_back(quotaPolicy);
380 quotaPolicy.quotapolicy.limitBytes = DATA_USAGE_UNLIMITED;
381 quotaPolicy.quotapolicy.warningBytes = DATA_USAGE_UNLIMITED;
382 quotaPolicies.push_back(quotaPolicy);
383 g_netPolicyTraffic->FormalizeQuotaPolicies(quotaPolicies);
384
385 // Test NetPolicyTraffic UpdateMeteredIfacesQuota
386 auto ret = g_netPolicyTraffic->UpdateMeteredIfacesQuota();
387 EXPECT_TRUE(ret.empty());
388 }
389
390 /**
391 * @tc.name: IsValidQuotaPolicy002
392 * @tc.desc: Test NetPolicyTraffic IsValidQuotaPolicy
393 * @tc.type: FUNC
394 */
395 HWTEST_F(UtNetPolicyTraffic, IsValidQuotaPolicy002, TestSize.Level1)
396 {
397 NetQuotaPolicy quotaPolicy;
398 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_BLUETOOTH;
399 quotaPolicy.quotapolicy.periodDuration = "";
400 auto ret = g_netPolicyTraffic->IsValidQuotaPolicy(quotaPolicy);
401 EXPECT_FALSE(ret);
402 }
403
404 /**
405 * @tc.name: IsValidQuotaPolicy003
406 * @tc.desc: Test NetPolicyTraffic IsValidQuotaPolicy
407 * @tc.type: FUNC
408 */
409 HWTEST_F(UtNetPolicyTraffic, IsValidQuotaPolicy003, TestSize.Level1)
410 {
411 NetQuotaPolicy quotaPolicy;
412 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_BLUETOOTH;
413 quotaPolicy.quotapolicy.periodDuration = "M1";
414 auto ret = g_netPolicyTraffic->IsValidQuotaPolicy(quotaPolicy);
415 EXPECT_TRUE(ret);
416 }
417
418 /**
419 * @tc.name: GetTotalQuota001
420 * @tc.desc: Test NetPolicyTraffic GetTotalQuota
421 * @tc.type: FUNC
422 */
423 HWTEST_F(UtNetPolicyTraffic, GetTotalQuota001, TestSize.Level1)
424 {
425 // Test NetPolicyTraffic SetNetworkEnableStatus
426 NetQuotaPolicy quotaPolicy;
427 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_BLUETOOTH;
428 quotaPolicy.quotapolicy.periodDuration = "M1";
429 g_netPolicyTraffic->SetNetworkEnableStatus(quotaPolicy, true);
430
431 // Test NetPolicyTraffic NotifyQuotaWarning
432 int64_t testQuota = 23;
433 g_netPolicyTraffic->NotifyQuotaWarning(testQuota);
434
435 // Test NetPolicyTraffic NotifyQuotaLimit
436 g_netPolicyTraffic->NotifyQuotaLimitReminded(testQuota);
437
438 // Test NetPolicyTraffic GetTotalQuota
439 auto ret = g_netPolicyTraffic->GetTotalQuota(quotaPolicy);
440 ASSERT_GE(ret, 0);
441 }
442
443 /**
444 * @tc.name: WriteQuotaPolicies001
445 * @tc.desc: Test NetPolicyTraffic WriteQuotaPolicies
446 * @tc.type: FUNC
447 */
448 HWTEST_F(UtNetPolicyTraffic, WriteQuotaPolicies001, TestSize.Level1)
449 {
450 // Test NetPolicyTraffic PublishQuotaEvent
451 std::string action = "testAction";
452 std::string describe = "testDescribe";
453 int64_t quota = 1;
454 g_netPolicyTraffic->PublishQuotaEvent(action, describe, quota);
455
456 auto ret = g_netPolicyTraffic->WriteQuotaPolicies();
457 g_netPolicyTraffic->ReadQuotaPolicies();
458 EXPECT_TRUE(ret);
459 }
460
461 /**
462 * @tc.name: GetMatchIfaces001
463 * @tc.desc: Test NetPolicyTraffic GetMatchIfaces
464 * @tc.type: FUNC
465 */
466 HWTEST_F(UtNetPolicyTraffic, GetMatchIfaces001, TestSize.Level1)
467 {
468 NetQuotaPolicy quotaPolicy;
469 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_ETHERNET;
470 auto ret = g_netPolicyTraffic->GetMatchIfaces(quotaPolicy);
471 EXPECT_TRUE(ret.empty());
472 }
473
474 /**
475 * @tc.name: GetMatchIfaces002
476 * @tc.desc: Test NetPolicyTraffic GetMatchIfaces
477 * @tc.type: FUNC
478 */
479 HWTEST_F(UtNetPolicyTraffic, GetMatchIfaces002, TestSize.Level1)
480 {
481 NetQuotaPolicy quotaPolicy;
482 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_CELLULAR;
483 auto ret = g_netPolicyTraffic->GetMatchIfaces(quotaPolicy);
484 EXPECT_TRUE(ret.empty());
485 }
486
487 /**
488 * @tc.name: GetMatchIfaces003
489 * @tc.desc: Test NetPolicyTraffic GetMatchIfaces
490 * @tc.type: FUNC
491 */
492 HWTEST_F(UtNetPolicyTraffic, GetMatchIfaces003, TestSize.Level1)
493 {
494 NetQuotaPolicy quotaPolicy;
495 quotaPolicy.networkmatchrule.netType = NetBearType::BEARER_WIFI;
496 auto ret = g_netPolicyTraffic->GetMatchIfaces(quotaPolicy);
497 EXPECT_TRUE(ret.empty());
498 }
499
500 /**
501 * @tc.name: IsValidNetType001
502 * @tc.desc: Test NetPolicyTraffic IsValidNetType
503 * @tc.type: FUNC
504 */
505 HWTEST_F(UtNetPolicyTraffic, IsValidNetType001, TestSize.Level1)
506 {
507 const std::vector<NetBearType> list = {BEARER_CELLULAR, BEARER_WIFI, BEARER_BLUETOOTH,
508 BEARER_ETHERNET, BEARER_VPN, BEARER_WIFI_AWARE};
__anona065ae2b0102(const auto &it) 509 std::for_each(list.begin(), list.end(), [](const auto &it) {
510 auto ret = g_netPolicyTraffic->IsValidNetType(it);
511 EXPECT_TRUE(ret);
512 });
513 auto ret = g_netPolicyTraffic->IsValidNetType(BEARER_DEFAULT);
514 EXPECT_FALSE(ret);
515 }
516
517 /**
518 * @tc.name: IsValidPeriodDuration001
519 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
520 * @tc.type: FUNC
521 */
522 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration001, TestSize.Level1)
523 {
524 const std::string periodDuration = "";
525 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
526 EXPECT_FALSE(ret);
527 }
528
529 /**
530 * @tc.name: IsValidPeriodDuration002
531 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
532 * @tc.type: FUNC
533 */
534 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration002, TestSize.Level1)
535 {
536 const std::string periodDuration = "M";
537 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
538 EXPECT_FALSE(ret);
539 }
540
541 /**
542 * @tc.name: IsValidPeriodDuration003
543 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
544 * @tc.type: FUNC
545 */
546 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration003, TestSize.Level1)
547 {
548 const std::string periodDuration = "D0";
549 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
550 EXPECT_FALSE(ret);
551 }
552
553 /**
554 * @tc.name: IsValidPeriodDuration004
555 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
556 * @tc.type: FUNC
557 */
558 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration004, TestSize.Level1)
559 {
560 const std::string periodDuration = "D40";
561 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
562 EXPECT_FALSE(ret);
563 }
564
565 /**
566 * @tc.name: IsValidPeriodDuration005
567 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
568 * @tc.type: FUNC
569 */
570 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration005, TestSize.Level1)
571 {
572 const std::string periodDuration = "M0";
573 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
574 EXPECT_FALSE(ret);
575 }
576
577 /**
578 * @tc.name: IsValidPeriodDuration006
579 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
580 * @tc.type: FUNC
581 */
582 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration006, TestSize.Level1)
583 {
584 const std::string periodDuration = "M13";
585 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
586 EXPECT_FALSE(ret);
587 }
588
589 /**
590 * @tc.name: IsValidPeriodDuration007
591 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
592 * @tc.type: FUNC
593 */
594 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration007, TestSize.Level1)
595 {
596 const std::string periodDuration = "Y0";
597 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
598 EXPECT_FALSE(ret);
599 }
600
601 /**
602 * @tc.name: IsValidPeriodDuration008
603 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
604 * @tc.type: FUNC
605 */
606 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration008, TestSize.Level1)
607 {
608 const std::string periodDuration = "Y400";
609 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
610 EXPECT_FALSE(ret);
611 }
612
613 /**
614 * @tc.name: IsValidPeriodDuration009
615 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
616 * @tc.type: FUNC
617 */
618 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration009, TestSize.Level1)
619 {
620 const std::string periodDuration = "D15";
621 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
622 EXPECT_TRUE(ret);
623 }
624
625 /**
626 * @tc.name: IsValidPeriodDuration010
627 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
628 * @tc.type: FUNC
629 */
630 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration010, TestSize.Level1)
631 {
632 const std::string periodDuration = "M4";
633 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
634 EXPECT_TRUE(ret);
635 }
636
637 /**
638 * @tc.name: IsValidPeriodDuration011
639 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
640 * @tc.type: FUNC
641 */
642 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration011, TestSize.Level1)
643 {
644 const std::string periodDuration = "Y10";
645 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
646 EXPECT_TRUE(ret);
647 }
648
649 /**
650 * @tc.name: IsValidPeriodDuration012
651 * @tc.desc: Test NetPolicyTraffic IsValidPeriodDuration
652 * @tc.type: FUNC
653 */
654 HWTEST_F(UtNetPolicyTraffic, IsValidPeriodDuration012, TestSize.Level1)
655 {
656 const std::string periodDuration = "S1";
657 auto ret = g_netPolicyTraffic->IsValidPeriodDuration(periodDuration);
658 EXPECT_FALSE(ret);
659 }
660 } // namespace NetManagerStandard
661 } // namespace OHOS
662