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 "net_manager_constants.h"
19 #include "net_policy_callback.h"
20 #include "net_policy_callback_test.h"
21 #include "net_policy_inner_define.h"
22
23 namespace OHOS {
24 namespace NetManagerStandard {
25 namespace {
26 using namespace testing::ext;
27 constexpr uint32_t TEST_UID = 4454;
28 constexpr uint32_t TEST_POLICY = 2121;
29 constexpr uint32_t TEST_RULE = 441;
30 std::map<int32_t, sptr<INetPolicyCallback>> g_callbackMap;
31 } // namespace
32
33 class UtNetPolicyCallbackIpcTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 static inline std::shared_ptr<NetPolicyCallback> instance_ = DelayedSingleton<NetPolicyCallback>::GetInstance();
40 static inline sptr<INetPolicyCallback> callback_ = nullptr;
41 };
42
SetUpTestCase()43 void UtNetPolicyCallbackIpcTest::SetUpTestCase()
44 {
45 callback_ = new (std::nothrow) NetPolicyCallbackTest();
46 for (int32_t i = 0; i < LIMIT_CALLBACK_NUM; i++) {
47 g_callbackMap[i] = new (std::nothrow) NetPolicyCallbackTest();
48 }
49 }
50
TearDownTestCase()51 void UtNetPolicyCallbackIpcTest::TearDownTestCase()
52 {
53 instance_->UnregisterNetPolicyCallbackAsync(callback_);
54 }
55
SetUp()56 void UtNetPolicyCallbackIpcTest::SetUp() {}
57
TearDown()58 void UtNetPolicyCallbackIpcTest::TearDown() {}
59
60 HWTEST_F(UtNetPolicyCallbackIpcTest, RegisterNetStatsCallbackTest001, TestSize.Level1)
61 {
62 int32_t ret = instance_->RegisterNetPolicyCallbackAsync(callback_);
63 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
64 ret = instance_->RegisterNetPolicyCallbackAsync(callback_);
65 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
66 ret = instance_->RegisterNetPolicyCallbackAsync(nullptr);
67 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
68 ret = instance_->UnregisterNetPolicyCallbackAsync(callback_);
69 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
70 ret = instance_->UnregisterNetPolicyCallbackAsync(nullptr);
71 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
72 std::for_each(g_callbackMap.begin(), g_callbackMap.end(),
__anon4f52b1540202(const auto &pair) 73 [this](const auto &pair) { instance_->RegisterNetPolicyCallbackAsync(pair.second); });
74 ret = instance_->RegisterNetPolicyCallbackAsync(callback_);
75 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
76 std::for_each(g_callbackMap.begin(), g_callbackMap.end(),
__anon4f52b1540302(const auto &pair) 77 [this](const auto &pair) { instance_->UnregisterNetPolicyCallbackAsync(pair.second); });
78 instance_->RegisterNetPolicyCallbackAsync(callback_);
79 }
80
81 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetUidPolicyChangeTest001, TestSize.Level1)
82 {
83 int32_t ret = instance_->NotifyNetUidPolicyChangeAsync(TEST_UID, TEST_POLICY);
84 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
85 }
86
87 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetUidRuleChangeTest001, TestSize.Level1)
88 {
89 int32_t ret = instance_->NotifyNetUidRuleChangeAsync(TEST_UID, TEST_RULE);
90 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
91 }
92
93 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetQuotaPolicyChangeTest001, TestSize.Level1)
94 {
95 std::vector<NetQuotaPolicy> quotaPolicies;
96 int32_t ret = instance_->NotifyNetQuotaPolicyChangeAsync(quotaPolicies);
97 EXPECT_EQ(ret, POLICY_ERR_QUOTA_POLICY_NOT_EXIST);
98 }
99
100 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetQuotaPolicyChangeTest002, TestSize.Level1)
101 {
102 NetQuotaPolicy quota;
103 std::vector<NetQuotaPolicy> quotaPolicies;
104 quotaPolicies.push_back(quota);
105 int32_t ret = instance_->NotifyNetQuotaPolicyChangeAsync(quotaPolicies);
106 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
107 }
108
109 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetMeteredIfacesChangeTest001, TestSize.Level1)
110 {
111 std::vector<std::string> ifaces = {};
112 int32_t ret = instance_->NotifyNetMeteredIfacesChangeAsync(ifaces);
113 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
114 }
115
116 HWTEST_F(UtNetPolicyCallbackIpcTest, NotifyNetBackgroundPolicyChangeTest001, TestSize.Level1)
117 {
118 int32_t ret = instance_->NotifyNetBackgroundPolicyChangeAsync(false);
119 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
120 }
121 } // namespace NetManagerStandard
122 } // namespace OHOS
123