1 /*
2 * Copyright (c) 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 <vector>
17
18 #include <gtest/gtest.h>
19
20 #ifdef GTEST_API_
21 #define private public
22 #define protected public
23 #endif
24 #include "net_policy_callback_proxy.h"
25
26 namespace OHOS {
27 namespace NetManagerStandard {
28 namespace {
29 #define DTEST_LOG std::cout << __func__ << ":" << __LINE__ << ":"
30 constexpr int64_t TEST_UID = 1010;
31
32 class MockNetIRemoteObject : public IRemoteObject {
33 public:
MockNetIRemoteObject()34 MockNetIRemoteObject() : IRemoteObject(u"mock_i_remote_object") {}
~MockNetIRemoteObject()35 ~MockNetIRemoteObject() {}
36
GetObjectRefCount()37 int32_t GetObjectRefCount() override
38 {
39 return 0;
40 }
41
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)42 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
43 {
44 return eCode;
45 }
46
IsProxyObject() const47 bool IsProxyObject() const override
48 {
49 return true;
50 }
51
CheckObjectLegality() const52 bool CheckObjectLegality() const override
53 {
54 return true;
55 }
56
AddDeathRecipient(const sptr<DeathRecipient> & recipient)57 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) override
58 {
59 return true;
60 }
61
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)62 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) override
63 {
64 return true;
65 }
66
Marshalling(Parcel & parcel) const67 bool Marshalling(Parcel &parcel) const override
68 {
69 return true;
70 }
71
AsInterface()72 sptr<IRemoteBroker> AsInterface() override
73 {
74 return nullptr;
75 }
76
Dump(int fd,const std::vector<std::u16string> & args)77 int Dump(int fd, const std::vector<std::u16string> &args) override
78 {
79 return 0;
80 }
81
GetObjectDescriptor() const82 std::u16string GetObjectDescriptor() const
83 {
84 std::u16string descriptor = std::u16string();
85 return descriptor;
86 }
87
SetErrorCode(int errorCode)88 void SetErrorCode(int errorCode)
89 {
90 eCode = errorCode;
91 }
92
93 private:
94 int eCode = 0;
95 };
96
97 } // namespace
98
99 using namespace testing::ext;
100 class NetPolicyCallbackProxyTest : public testing::Test {
101 public:
102 static void SetUpTestCase();
103 static void TearDownTestCase();
104 void SetUp();
105 void TearDown();
106 static inline sptr<MockNetIRemoteObject> remoteObj_ = nullptr;
107 };
108
SetUpTestCase()109 void NetPolicyCallbackProxyTest::SetUpTestCase()
110 {
111 remoteObj_ = new (std::nothrow) MockNetIRemoteObject();
112 }
113
TearDownTestCase()114 void NetPolicyCallbackProxyTest::TearDownTestCase() { remoteObj_ = nullptr;}
115
SetUp()116 void NetPolicyCallbackProxyTest::SetUp() {}
117
TearDown()118 void NetPolicyCallbackProxyTest::TearDown() {}
119
120 HWTEST_F(NetPolicyCallbackProxyTest, NetUidPolicyChangeTest001, TestSize.Level1)
121 {
122 NetPolicyCallbackProxy instance_(nullptr);
123 EXPECT_EQ(instance_.NetUidPolicyChange(TEST_UID, 0), NETMANAGER_ERR_LOCAL_PTR_NULL);
124 }
125
126 HWTEST_F(NetPolicyCallbackProxyTest, NetUidPolicyChangeTest002, TestSize.Level1)
127 {
128 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
129 NetPolicyCallbackProxy instance_(remoteObj_);
130 EXPECT_EQ(instance_.NetUidPolicyChange(TEST_UID, 0), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
131 }
132
133 HWTEST_F(NetPolicyCallbackProxyTest, NetUidPolicyChangeTest003, TestSize.Level1)
134 {
135 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
136 NetPolicyCallbackProxy instance_(remoteObj_);
137 EXPECT_EQ(instance_.NetUidPolicyChange(TEST_UID, 0), NETMANAGER_SUCCESS);
138 }
139
140 HWTEST_F(NetPolicyCallbackProxyTest, NetUidRuleChangeTest001, TestSize.Level1)
141 {
142 NetPolicyCallbackProxy instance_(nullptr);
143 EXPECT_EQ(instance_.NetUidRuleChange(TEST_UID, 0), NETMANAGER_ERR_LOCAL_PTR_NULL);
144 }
145
146 HWTEST_F(NetPolicyCallbackProxyTest, NetUidRuleChangeTest002, TestSize.Level1)
147 {
148 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
149 NetPolicyCallbackProxy instance_(remoteObj_);
150 EXPECT_EQ(instance_.NetUidRuleChange(TEST_UID, 0), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
151 }
152
153 HWTEST_F(NetPolicyCallbackProxyTest, NetUidRuleChangeTest003, TestSize.Level1)
154 {
155 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
156 NetPolicyCallbackProxy instance_(remoteObj_);
157 EXPECT_EQ(instance_.NetUidRuleChange(TEST_UID, 0), NETMANAGER_SUCCESS);
158 }
159
160 HWTEST_F(NetPolicyCallbackProxyTest, NetBackgroundPolicyChangeTest001, TestSize.Level1)
161 {
162 NetPolicyCallbackProxy instance_(nullptr);
163 EXPECT_EQ(instance_.NetBackgroundPolicyChange(true), NETMANAGER_ERR_LOCAL_PTR_NULL);
164 }
165
166 HWTEST_F(NetPolicyCallbackProxyTest, NetBackgroundPolicyChangeTest002, TestSize.Level1)
167 {
168 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
169 NetPolicyCallbackProxy instance_(remoteObj_);
170 EXPECT_EQ(instance_.NetBackgroundPolicyChange(true), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
171 }
172
173 HWTEST_F(NetPolicyCallbackProxyTest, NetBackgroundPolicyChangeTest003, TestSize.Level1)
174 {
175 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
176 NetPolicyCallbackProxy instance_(remoteObj_);
177 EXPECT_EQ(instance_.NetBackgroundPolicyChange(true), NETMANAGER_SUCCESS);
178 }
179
180 HWTEST_F(NetPolicyCallbackProxyTest, NetQuotaPolicyChangeTest001, TestSize.Level1)
181 {
182 NetPolicyCallbackProxy instance_(nullptr);
183 std::vector<NetQuotaPolicy> netQuotaPolicys;
184 EXPECT_EQ(instance_.NetQuotaPolicyChange(netQuotaPolicys), POLICY_ERR_QUOTA_POLICY_NOT_EXIST);
185 }
186
187 HWTEST_F(NetPolicyCallbackProxyTest, NetQuotaPolicyChangeTest002, TestSize.Level1)
188 {
189 NetPolicyCallbackProxy instance_(nullptr);
190 std::vector<NetQuotaPolicy> netQuotaPolicys;
191 NetQuotaPolicy quotaPolicy;
192 netQuotaPolicys.emplace_back(quotaPolicy);
193 EXPECT_EQ(instance_.NetQuotaPolicyChange(netQuotaPolicys), NETMANAGER_ERR_LOCAL_PTR_NULL);
194 }
195
196 HWTEST_F(NetPolicyCallbackProxyTest, NetQuotaPolicyChangeTest003, TestSize.Level1)
197 {
198 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
199 NetPolicyCallbackProxy instance_(remoteObj_);
200 std::vector<NetQuotaPolicy> netQuotaPolicys;
201 NetQuotaPolicy quotaPolicy;
202 netQuotaPolicys.emplace_back(quotaPolicy);
203 EXPECT_EQ(instance_.NetQuotaPolicyChange(netQuotaPolicys), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
204 }
205
206 HWTEST_F(NetPolicyCallbackProxyTest, NetQuotaPolicyChangeTest004, TestSize.Level1)
207 {
208 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
209 NetPolicyCallbackProxy instance_(remoteObj_);
210 std::vector<NetQuotaPolicy> netQuotaPolicys;
211 NetQuotaPolicy quotaPolicy;
212 netQuotaPolicys.emplace_back(quotaPolicy);
213 EXPECT_EQ(instance_.NetQuotaPolicyChange(netQuotaPolicys), NETMANAGER_SUCCESS);
214 }
215
216 HWTEST_F(NetPolicyCallbackProxyTest, NetStrategySwitchTest001, TestSize.Level1)
217 {
218 NetPolicyCallbackProxy instance_(nullptr);
219 std::string simId = "simId";
220 EXPECT_EQ(instance_.NetStrategySwitch(simId, true), NETMANAGER_ERR_LOCAL_PTR_NULL);
221 }
222
223 HWTEST_F(NetPolicyCallbackProxyTest, NetStrategySwitchTest002, TestSize.Level1)
224 {
225 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
226 NetPolicyCallbackProxy instance_(remoteObj_);
227 std::string simId = "simId";
228 EXPECT_EQ(instance_.NetStrategySwitch(simId, true), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
229 }
230
231 HWTEST_F(NetPolicyCallbackProxyTest, NetStrategySwitchTest003, TestSize.Level1)
232 {
233 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
234 NetPolicyCallbackProxy instance_(remoteObj_);
235 std::string simId = "simId";
236 EXPECT_EQ(instance_.NetStrategySwitch(simId, true), NETMANAGER_SUCCESS);
237 }
238
239 HWTEST_F(NetPolicyCallbackProxyTest, NetMeteredIfacesChangeTest001, TestSize.Level1)
240 {
241 NetPolicyCallbackProxy instance_(nullptr);
242 std::vector<std::string> ifaces;
243 EXPECT_EQ(instance_.NetMeteredIfacesChange(ifaces), NETMANAGER_ERR_LOCAL_PTR_NULL);
244 }
245
246 HWTEST_F(NetPolicyCallbackProxyTest, NetMeteredIfacesChangeTest002, TestSize.Level1)
247 {
248 remoteObj_->SetErrorCode(NETMANAGER_ERROR);
249 NetPolicyCallbackProxy instance_(remoteObj_);
250 std::vector<std::string> ifaces;
251 EXPECT_EQ(instance_.NetMeteredIfacesChange(ifaces), NETMANAGER_ERR_IPC_CONNECT_STUB_FAIL);
252 }
253
254 HWTEST_F(NetPolicyCallbackProxyTest, NetMeteredIfacesChangeTest003, TestSize.Level1)
255 {
256 remoteObj_->SetErrorCode(NETMANAGER_SUCCESS);
257 NetPolicyCallbackProxy instance_(remoteObj_);
258 std::vector<std::string> ifaces;
259 EXPECT_EQ(instance_.NetMeteredIfacesChange(ifaces), NETMANAGER_SUCCESS);
260 }
261
262 } // namespace NetManagerStandard
263 } // namespace OHOS