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 <chrono>
17 #include <condition_variable>
18 #include <mutex>
19 #include <thread>
20
21 #include <gtest/gtest.h>
22
23 #include "net_mgr_log_wrapper.h"
24 #include "net_policy_callback.h"
25 #include "net_policy_callback_test.h"
26 #include "net_policy_client.h"
27 #include "net_policy_constants.h"
28 #include "net_policy_inner_define.h"
29 #include "net_policy_rule.h"
30 #include "net_policy_traffic.h"
31
32 namespace OHOS {
33 namespace NetManagerStandard {
34 const std::string TEST_STRING_PERIODDURATION = "M1";
35 const std::string ICCID_1 = "sim_abcdefg_1";
36 const std::string ICCID_2 = "sim_abcdefg_2";
37 constexpr uint32_t TEST_UID1 = 101;
38 constexpr uint32_t TEST_WARNING_BYTES_1 = 321;
39 constexpr uint32_t TEST_LIMIT_BYTES_1 = 4321;
40 constexpr uint32_t TEST_WARNING_BYTES_2 = 123;
41 constexpr uint32_t TEST_LIMIT_BYTES_2 = 1234;
42 constexpr uint32_t TEST_LAST_WARNING_REMIND_1 = 7654321;
43 constexpr uint32_t TEST_LAST_LIMIT_REMIND_1 = 87654321;
44 constexpr uint32_t TEST_LAST_WARNING_REMIND_2 = 1234567;
45 constexpr uint32_t TEST_LAST_LIMIT_REMIND_2 = 12345678;
46
47 std::mutex g_callbackMutex;
48 std::condition_variable g_cv;
49
50 int32_t g_callbackUid = -1;
51 int32_t g_callbackPolicy = -1;
52 int32_t g_callbackRule = -1;
53 int32_t g_callbackQuotaPolicySize = -1;
54 int32_t g_callbackIfacesSize = -1;
55 bool g_callbackBackgroundPolicy = false;
56
57 std::shared_ptr<NetPolicyCallback> g_netPolicyCallback = nullptr;
58 std::shared_ptr<NetPolicyRule> g_netPolicyRuleCb = nullptr;
59 std::shared_ptr<NetPolicyTraffic> g_netPolicyTrafficCb = nullptr;
60
61 using namespace testing::ext;
62
63 class INetPolicyCallbackImpl : public IRemoteStub<INetPolicyCallback> {
64 public:
NetUidPolicyChange(uint32_t uid,uint32_t policy)65 int32_t NetUidPolicyChange(uint32_t uid, uint32_t policy)
66 {
67 g_callbackUid = uid;
68 g_callbackPolicy = policy;
69 g_cv.notify_all();
70 return 0;
71 }
72
NetUidRuleChange(uint32_t uid,uint32_t rule)73 int32_t NetUidRuleChange(uint32_t uid, uint32_t rule)
74 {
75 g_callbackUid = uid;
76 g_callbackRule = rule;
77 g_cv.notify_all();
78 return 0;
79 }
80
NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> & quotaPolicies)81 int32_t NetQuotaPolicyChange(const std::vector<NetQuotaPolicy> "aPolicies)
82 {
83 g_callbackQuotaPolicySize = quotaPolicies.size();
84 g_cv.notify_all();
85 return 0;
86 }
87
NetStrategySwitch(const std::string & iccid,bool enable)88 int32_t NetStrategySwitch(const std::string &iccid, bool enable)
89 {
90 return 0;
91 }
92
NetMeteredIfacesChange(std::vector<std::string> & ifaces)93 int32_t NetMeteredIfacesChange(std::vector<std::string> &ifaces)
94 {
95 g_callbackIfacesSize = ifaces.size();
96 g_cv.notify_all();
97 return 0;
98 }
99
NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)100 int32_t NetBackgroundPolicyChange(bool isBackgroundPolicyAllow)
101 {
102 g_callbackBackgroundPolicy = isBackgroundPolicyAllow;
103 g_cv.notify_all();
104 return 0;
105 }
106 };
107
108 class NetPolicyCallbackUTest : public testing::Test {
109 public:
110 static void SetUpTestCase();
111 static void TearDownTestCase();
112 void SetUp();
113 void TearDown();
114 sptr<INetPolicyCallbackImpl> GetINetPolicyCallbackSample() const;
115 };
116
SetUpTestCase()117 void NetPolicyCallbackUTest::SetUpTestCase()
118 {
119 g_netPolicyCallback = DelayedSingleton<NetPolicyCallback>::GetInstance();
120 g_netPolicyRuleCb = std::make_shared<NetPolicyRule>();
121 g_netPolicyTrafficCb = std::make_shared<NetPolicyTraffic>();
122 }
123
TearDownTestCase()124 void NetPolicyCallbackUTest::TearDownTestCase() {}
125
SetUp()126 void NetPolicyCallbackUTest::SetUp() {}
127
TearDown()128 void NetPolicyCallbackUTest::TearDown()
129 {
130 g_netPolicyRuleCb->TransPolicyToRule(TEST_UID1, NetUidPolicy::NET_POLICY_NONE);
131 }
132
SetFirstNetQuotaPolicy(std::vector<NetQuotaPolicy> & quotaPolicies)133 void SetFirstNetQuotaPolicy(std::vector<NetQuotaPolicy> "aPolicies)
134 {
135 NetQuotaPolicy quotaPolicy1;
136 quotaPolicy1.iccid = ICCID_1;
137 quotaPolicy1.periodDuration = "M1"; // M1: First day of the month.
138 quotaPolicy1.netType = NetBearType::BEARER_CELLULAR;
139 quotaPolicy1.warningBytes = TEST_WARNING_BYTES_1;
140 quotaPolicy1.limitBytes = TEST_LIMIT_BYTES_1;
141 quotaPolicy1.lastWarningRemind = TEST_LAST_WARNING_REMIND_1;
142 quotaPolicy1.lastLimitRemind = TEST_LAST_LIMIT_REMIND_1;
143 quotaPolicy1.metered = true;
144 quotaPolicy1.limitAction = LimitAction::LIMIT_ACTION_AUTO_BILL;
145 quotaPolicies.push_back(quotaPolicy1);
146 }
147
SetSecondNetQuotaPolicy(std::vector<NetQuotaPolicy> & quotaPolicies)148 void SetSecondNetQuotaPolicy(std::vector<NetQuotaPolicy> "aPolicies)
149 {
150 NetQuotaPolicy quotaPolicy2;
151 quotaPolicy2.iccid = ICCID_2;
152 quotaPolicy2.periodDuration = "Y1"; // y1: First day of the year.
153 quotaPolicy2.netType = NetBearType::BEARER_CELLULAR;
154 quotaPolicy2.warningBytes = TEST_WARNING_BYTES_2;
155 quotaPolicy2.limitBytes = TEST_LIMIT_BYTES_2;
156 quotaPolicy2.lastWarningRemind = TEST_LAST_WARNING_REMIND_2;
157 quotaPolicy2.lastLimitRemind = TEST_LAST_LIMIT_REMIND_2;
158 quotaPolicy2.metered = true;
159 quotaPolicy2.limitAction = LimitAction::LIMIT_ACTION_DISABLE;
160 quotaPolicies.push_back(quotaPolicy2);
161 }
162
SetPolicyCallback()163 void SetPolicyCallback()
164 {
165 g_netPolicyRuleCb->TransPolicyToRule(TEST_UID1, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
166 }
167
168 /**
169 * @tc.name: NetPolicyCallback001
170 * @tc.desc: Test NetPolicyCallback NetUidPolicyChange.
171 * @tc.type: FUNC
172 */
173 HWTEST_F(NetPolicyCallbackUTest, NetPolicyCallback001, TestSize.Level1)
174 {
175 sptr<INetPolicyCallbackImpl> callback = new (std::nothrow) INetPolicyCallbackImpl();
176 g_netPolicyCallback->RegisterNetPolicyCallback(callback);
177 std::thread setPolicyCallback(SetPolicyCallback);
178
179 std::unique_lock<std::mutex> lck(g_callbackMutex);
180 g_cv.wait_for(lck, std::chrono::seconds(10));
181 setPolicyCallback.join();
182
183 std::cout << "g_callbackUid:" << g_callbackUid << std::endl;
184 std::cout << "g_callbackPolicy:" << g_callbackPolicy << std::endl;
185 ASSERT_EQ(g_callbackUid, static_cast<int32_t>(TEST_UID1));
186 ASSERT_EQ(g_callbackPolicy, 1);
187 g_netPolicyCallback->UnregisterNetPolicyCallback(callback);
188 }
189
SetPolicyCallback2()190 void SetPolicyCallback2()
191 {
192 g_netPolicyRuleCb->SetBackgroundPolicy(false);
193 g_netPolicyRuleCb->TransPolicyToRule(TEST_UID1, NetUidPolicy::NET_POLICY_ALLOW_METERED_BACKGROUND);
194 }
195
196 /**
197 * @tc.name: NetPolicyCallback002
198 * @tc.desc: Test NetPolicyCallback NetUidRuleChange.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(NetPolicyCallbackUTest, NetPolicyCallback002, TestSize.Level1)
202 {
203 sptr<INetPolicyCallbackImpl> callback = new INetPolicyCallbackImpl();
204 g_netPolicyCallback->RegisterNetPolicyCallback(callback);
205 std::thread setPolicyCallback2(SetPolicyCallback2);
206
207 std::unique_lock<std::mutex> lck(g_callbackMutex);
208 g_cv.wait_for(lck, std::chrono::seconds(10));
209 setPolicyCallback2.join();
210
211 std::cout << "g_callbackUid:" << g_callbackUid << std::endl;
212 std::cout << "g_callbackRule:" << g_callbackRule << std::endl;
213 ASSERT_EQ(g_callbackUid, static_cast<int32_t>(TEST_UID1));
214 g_netPolicyCallback->UnregisterNetPolicyCallback(callback);
215 }
216
SetQuotaPolicy()217 void SetQuotaPolicy()
218 {
219 std::vector<NetQuotaPolicy> quotaPolicies;
220 SetFirstNetQuotaPolicy(quotaPolicies);
221
222 g_netPolicyTrafficCb->UpdateQuotaPolicies(quotaPolicies);
223 }
224
225 /**
226 * @tc.name: NetPolicyCallback003
227 * @tc.desc: Test NetPolicyCallback NetQuotaPolicyChange.
228 * @tc.type: FUNC
229 */
230 HWTEST_F(NetPolicyCallbackUTest, NetPolicyCallback003, TestSize.Level1)
231 {
232 sptr<INetPolicyCallbackImpl> callback = new INetPolicyCallbackImpl();
233 g_netPolicyCallback->RegisterNetPolicyCallback(callback);
234 std::thread setQuotaPolicy(SetQuotaPolicy);
235
236 std::unique_lock<std::mutex> lck(g_callbackMutex);
237 g_cv.wait_for(lck, std::chrono::seconds(10));
238 setQuotaPolicy.join();
239
240 std::cout << "g_callbackQuotaPolicySize:" << g_callbackQuotaPolicySize << std::endl;
241 ASSERT_TRUE(g_callbackQuotaPolicySize > 0);
242 g_netPolicyCallback->UnregisterNetPolicyCallback(callback);
243 }
244
SetQuotaPolicy2()245 void SetQuotaPolicy2()
246 {
247 std::vector<NetQuotaPolicy> quotaPolicies;
248 SetFirstNetQuotaPolicy(quotaPolicies);
249 SetSecondNetQuotaPolicy(quotaPolicies);
250 g_netPolicyTrafficCb->UpdateQuotaPolicies(quotaPolicies);
251 }
252
253 /**
254 * @tc.name: NetPolicyCallback004
255 * @tc.desc: Test NetPolicyCallback NetMeteredIfacesChange.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(NetPolicyCallbackUTest, NetPolicyCallback004, TestSize.Level1)
259 {
260 sptr<INetPolicyCallbackImpl> callback = new INetPolicyCallbackImpl();
261 g_netPolicyCallback->RegisterNetPolicyCallback(callback);
262 std::thread setQuotaPolicy2(SetQuotaPolicy2);
263
264 std::unique_lock<std::mutex> lck(g_callbackMutex);
265 g_cv.wait_for(lck, std::chrono::seconds(10));
266 setQuotaPolicy2.join();
267
268 std::cout << "g_callbackIfacesSize:" << g_callbackIfacesSize << std::endl;
269 ASSERT_TRUE(g_callbackIfacesSize >= 0);
270 g_netPolicyCallback->UnregisterNetPolicyCallback(callback);
271 }
272
SetBackgroundPolicy()273 void SetBackgroundPolicy()
274 {
275 g_netPolicyRuleCb->SetBackgroundPolicy(true);
276 }
277
278 /**
279 * @tc.name: NetPolicyCallback005
280 * @tc.desc: Test NetPolicyCallback NetBackgroundPolicyChange.
281 * @tc.type: FUNC
282 */
283 HWTEST_F(NetPolicyCallbackUTest, NetPolicyCallback005, TestSize.Level1)
284 {
285 sptr<INetPolicyCallbackImpl> callback = new INetPolicyCallbackImpl();
286 g_netPolicyCallback->RegisterNetPolicyCallback(callback);
287 std::thread setBackgroundPolicy(SetBackgroundPolicy);
288
289 std::unique_lock<std::mutex> lck(g_callbackMutex);
290 g_cv.wait_for(lck, std::chrono::seconds(10));
291 setBackgroundPolicy.join();
292
293 std::cout << "g_callbackBackgroundPolicy:" << g_callbackBackgroundPolicy << std::endl;
294 ASSERT_TRUE(g_callbackBackgroundPolicy == true);
295 g_netPolicyCallback->UnregisterNetPolicyCallback(callback);
296 }
297 } // namespace NetManagerStandard
298 } // namespace OHOS
299