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 "net_conn_callback_stub.h"
17 #include "net_manager_constants.h"
18 #include <gtest/gtest.h>
19 #include <memory>
20 #define private public
21 #include "net_activate.h"
22 #undef private
23
24 namespace OHOS {
25 namespace NetManagerStandard {
26 namespace {
27 using namespace testing::ext;
28 constexpr uint32_t TEST_TIMEOUT_MS = 1000;
29 constexpr uint32_t TEST_REQUEST_ID = 54656;
30 constexpr const char *TEST_IDENT = "testIdent";
31 class ConnCallbackTest : public NetConnCallbackStub {
NetAvailable(sptr<NetHandle> & netHandle)32 inline int32_t NetAvailable(sptr<NetHandle> &netHandle) override
33 {
34 return NETMANAGER_SUCCESS;
35 }
NetCapabilitiesChange(sptr<NetHandle> & netHandle,const sptr<NetAllCapabilities> & netAllCap)36 inline int32_t NetCapabilitiesChange(sptr<NetHandle> &netHandle,
37 const sptr<NetAllCapabilities> &netAllCap) override
38 {
39 return NETMANAGER_SUCCESS;
40 }
NetConnectionPropertiesChange(sptr<NetHandle> & netHandle,const sptr<NetLinkInfo> & info)41 inline int32_t NetConnectionPropertiesChange(sptr<NetHandle> &netHandle, const sptr<NetLinkInfo> &info) override
42 {
43 return NETMANAGER_SUCCESS;
44 }
NetLost(sptr<NetHandle> & netHandle)45 inline int32_t NetLost(sptr<NetHandle> &netHandle) override
46 {
47 return NETMANAGER_SUCCESS;
48 }
NetUnavailable()49 inline int32_t NetUnavailable() override
50 {
51 return NETMANAGER_SUCCESS;
52 }
NetBlockStatusChange(sptr<NetHandle> & netHandle,bool blocked)53 inline int32_t NetBlockStatusChange(sptr<NetHandle> &netHandle, bool blocked) override
54 {
55 return NETMANAGER_SUCCESS;
56 }
57 };
58
59 class NetActivateCallbackTest : public INetActivateCallback {
OnNetActivateTimeOut(uint32_t reqId)60 void OnNetActivateTimeOut(uint32_t reqId) override
61 {
62 std::cout << "Activate network request " << reqId << " timeout." << std::endl;
63 }
64 };
65 } // namespace
66
67 class NetActivateTest : public testing::Test {
68 public:
69 static void SetUpTestCase();
70 static void TearDownTestCase();
71 void SetUp();
72 void TearDown();
73 static inline std::shared_ptr<AppExecFwk::EventRunner> netActEventRunner_ = nullptr;
74 static inline std::shared_ptr<AppExecFwk::EventHandler> netActEventHandler_ = nullptr;
75 static inline std::shared_ptr<NetActivate> instance_ = nullptr;
76 static inline sptr<INetConnCallback> callback_ = nullptr;
77 static inline sptr<NetSpecifier> specifier_ = nullptr;
78 static inline std::shared_ptr<INetActivateCallback> timeoutCallback_ = nullptr;
79 };
80
SetUpTestCase()81 void NetActivateTest::SetUpTestCase()
82 {
83 callback_ = new (std::nothrow) ConnCallbackTest();
84 specifier_ = new (std::nothrow) NetSpecifier();
85 timeoutCallback_ = std::make_shared<NetActivateCallbackTest>();
86 netActEventRunner_ = AppExecFwk::EventRunner::Create("NET_ACTIVATE_WORK_THREAD");
87 netActEventHandler_ = std::make_shared<AppExecFwk::EventHandler>(netActEventRunner_);
88 instance_ =
89 std::make_shared<NetActivate>(specifier_, callback_, timeoutCallback_, TEST_TIMEOUT_MS, netActEventHandler_);
90 }
91
TearDownTestCase()92 void NetActivateTest::TearDownTestCase()
93 {
94 instance_ = nullptr;
95 }
96
SetUp()97 void NetActivateTest::SetUp() {}
98
TearDown()99 void NetActivateTest::TearDown() {}
100
101 HWTEST_F(NetActivateTest, MatchRequestAndNetworkTest001, TestSize.Level1)
102 {
103 std::set<NetCap> netCaps;
104 netCaps.insert(NET_CAPABILITY_NOT_METERED);
105 sptr<NetSupplier> supplier = new (std::nothrow) NetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT, netCaps);
106 bool ret = instance_->MatchRequestAndNetwork(supplier);
107 EXPECT_TRUE(ret);
108 sptr<NetSupplier> supplier001 = nullptr;
109 ret = instance_->MatchRequestAndNetwork(supplier001);
110 EXPECT_FALSE(ret);
111 std::string test;
112 sptr<NetSupplier> supplier002 = new (std::nothrow) NetSupplier(NetBearType::BEARER_ETHERNET, test, netCaps);
113 ret = instance_->MatchRequestAndNetwork(supplier002);
114 EXPECT_TRUE(ret);
115 std::set<NetCap> netCaps1;
116 netCaps1.insert(NET_CAPABILITY_MMS);
117 sptr<NetSupplier> supplier003 = new (std::nothrow) NetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT, netCaps1);
118 ret = instance_->MatchRequestAndNetwork(supplier003);
119 EXPECT_TRUE(ret);
120 sptr<NetSupplier> supplier004 = new (std::nothrow) NetSupplier(NetBearType::BEARER_CELLULAR, TEST_IDENT, netCaps);
121 ret = instance_->MatchRequestAndNetwork(supplier004);
122 EXPECT_TRUE(ret);
123 }
124
125 HWTEST_F(NetActivateTest, MatchRequestAndNetworkTest002, TestSize.Level1)
126 {
127 std::set<NetCap> netCaps;
128 sptr<NetSupplier> supplier = nullptr;
129 bool ret = instance_->MatchRequestAndNetwork(supplier);
130 EXPECT_EQ(ret, false);
131 supplier = new (std::nothrow) NetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT, netCaps);
132 ret = instance_->MatchRequestAndNetwork(supplier);
133 EXPECT_TRUE(ret);
134 }
135
136 HWTEST_F(NetActivateTest, SetGetRequestIdTest001, TestSize.Level1)
137 {
138 instance_->SetRequestId(TEST_REQUEST_ID);
139 uint32_t requestId = instance_->GetRequestId();
140 EXPECT_EQ(requestId, TEST_REQUEST_ID);
141 }
142
143 HWTEST_F(NetActivateTest, SetGetServiceSupplyTest001, TestSize.Level1)
144 {
145 std::set<NetCap> netCaps;
146 sptr<NetSupplier> supplier = new (std::nothrow) NetSupplier(NetBearType::BEARER_ETHERNET, TEST_IDENT, netCaps);
147 instance_->SetServiceSupply(supplier);
148 auto result = instance_->GetServiceSupply();
149 EXPECT_EQ(result, supplier);
150 }
151
152 HWTEST_F(NetActivateTest, GetNetCallbackTest001, TestSize.Level1)
153 {
154 auto result = instance_->GetNetCallback();
155 EXPECT_EQ(result, callback_);
156 }
157
158 HWTEST_F(NetActivateTest, GetNetSpecifierTest001, TestSize.Level1)
159 {
160 auto result = instance_->GetNetSpecifier();
161 EXPECT_EQ(result, specifier_);
162 }
163
164 HWTEST_F(NetActivateTest, CompareByNetworkIdentTest001, TestSize.Level1)
165 {
166 auto result = instance_->GetNetSpecifier();
167 EXPECT_EQ(result, specifier_);
168 }
169
170 HWTEST_F(NetActivateTest, CompareByNetworkIdent001, TestSize.Level1)
171 {
172 std::string ident;
173 bool ret = instance_->CompareByNetworkIdent(ident);
174 EXPECT_EQ(ret, true);
175
176 ident = "test1234";
177 ret = instance_->CompareByNetworkIdent(ident);
178 EXPECT_EQ(ret, true);
179
180 instance_->netSpecifier_->ident_ = "test1234";
181 ret = instance_->CompareByNetworkIdent(ident);
182 EXPECT_EQ(ret, true);
183
184 ident = "test5678";
185 ret = instance_->CompareByNetworkIdent(ident);
186 EXPECT_EQ(ret, false);
187 }
188
189 HWTEST_F(NetActivateTest, CompareByNetworkCapabilities001, TestSize.Level1)
190 {
191 NetCaps netCaps;
192 netCaps.InsertNetCap(NetCap::NET_CAPABILITY_NOT_VPN);
193 bool ret = instance_->CompareByNetworkCapabilities(netCaps);
194 EXPECT_EQ(ret, true);
195
196 sptr<INetConnCallback> callback = new (std::nothrow) ConnCallbackTest();
197 sptr<NetSpecifier> specifier = nullptr;
198 std::weak_ptr<INetActivateCallback> timeoutCallback = std::make_shared<NetActivateCallbackTest>();
199 std::shared_ptr<NetActivate> testNetActivate =
200 std::make_shared<NetActivate>(specifier, callback, timeoutCallback, TEST_TIMEOUT_MS, netActEventHandler_);
201
202 ret = testNetActivate->CompareByNetworkCapabilities(netCaps);
203 EXPECT_EQ(ret, false);
204 }
205
206 HWTEST_F(NetActivateTest, CompareByNetworkNetType001, TestSize.Level1)
207 {
208 NetBearType bearerType = BEARER_WIFI;
209 bool ret = instance_->CompareByNetworkNetType(bearerType);
210 EXPECT_EQ(ret, true);
211
212 instance_->netSpecifier_->SetType(BEARER_WIFI);
213 ret = instance_->CompareByNetworkNetType(bearerType);
214 EXPECT_EQ(ret, true);
215
216 bearerType = BEARER_ETHERNET;
217 ret = instance_->CompareByNetworkNetType(bearerType);
218 EXPECT_EQ(ret, false);
219
220 instance_->netSpecifier_->netCapabilities_.bearerTypes_.clear();
221 ret = instance_->CompareByNetworkNetType(bearerType);
222 EXPECT_EQ(ret, true);
223
224 sptr<INetConnCallback> callback = new (std::nothrow) ConnCallbackTest();
225 sptr<NetSpecifier> specifier = nullptr;
226 std::weak_ptr<INetActivateCallback> timeoutCallback = std::make_shared<NetActivateCallbackTest>();
227 std::shared_ptr<NetActivate> testNetActivate =
228 std::make_shared<NetActivate>(specifier, callback, timeoutCallback, TEST_TIMEOUT_MS, netActEventHandler_);
229 ret = testNetActivate->CompareByNetworkNetType(bearerType);
230 EXPECT_EQ(ret, false);
231 }
232
233 HWTEST_F(NetActivateTest, CompareByNetworkBand001, TestSize.Level1)
234 {
235 uint32_t netLinkUpBand = 100;
236 uint32_t netLinkDownBand = 100;
237 instance_->netSpecifier_->netCapabilities_.linkUpBandwidthKbps_ = 100;
238 instance_->netSpecifier_->netCapabilities_.linkDownBandwidthKbps_ = 100;
239 bool ret = instance_->CompareByNetworkBand(netLinkUpBand, netLinkDownBand);
240 EXPECT_EQ(ret, true);
241
242 netLinkUpBand = 50;
243 ret = instance_->CompareByNetworkBand(netLinkUpBand, netLinkDownBand);
244 EXPECT_EQ(ret, false);
245 }
246
247 HWTEST_F(NetActivateTest, HaveCapability001, TestSize.Level1)
248 {
249 instance_->netSpecifier_->netCapabilities_.netCaps_.clear();
250 instance_->netSpecifier_->netCapabilities_.netCaps_.insert(NET_CAPABILITY_NOT_VPN);
251 NetCap netCap = NET_CAPABILITY_NOT_VPN;
252 bool ret = instance_->HaveCapability(netCap);
253 EXPECT_EQ(ret, true);
254
255 netCap = NET_CAPABILITY_INTERNET;
256 ret = instance_->HaveCapability(netCap);
257 EXPECT_EQ(ret, false);
258
259 sptr<INetConnCallback> callback = new (std::nothrow) ConnCallbackTest();
260 sptr<NetSpecifier> specifier = nullptr;
261 std::weak_ptr<INetActivateCallback> timeoutCallback = std::make_shared<NetActivateCallbackTest>();
262 std::shared_ptr<NetActivate> testNetActivate =
263 std::make_shared<NetActivate>(specifier, callback, timeoutCallback, TEST_TIMEOUT_MS, netActEventHandler_);
264
265 ret = testNetActivate->HaveCapability(netCap);
266 EXPECT_EQ(ret, false);
267 }
268
269 HWTEST_F(NetActivateTest, HaveTypes001, TestSize.Level1)
270 {
271 std::set<NetBearType> bearerTypes;
272 bool ret = instance_->HaveTypes(bearerTypes);
273 EXPECT_EQ(ret, false);
274
275 bearerTypes.insert(BEARER_WIFI);
276 instance_->netSpecifier_->netCapabilities_.bearerTypes_.insert(BEARER_VPN);
277 ret = instance_->HaveTypes(bearerTypes);
278 EXPECT_EQ(ret, false);
279
280 instance_->netSpecifier_->netCapabilities_.bearerTypes_.insert(BEARER_WIFI);
281 ret = instance_->HaveTypes(bearerTypes);
282 EXPECT_EQ(ret, true);
283
284 sptr<INetConnCallback> callback = new (std::nothrow) ConnCallbackTest();
285 sptr<NetSpecifier> specifier = nullptr;
286 std::weak_ptr<INetActivateCallback> timeoutCallback = std::make_shared<NetActivateCallbackTest>();
287 std::shared_ptr<NetActivate> testNetActivate =
288 std::make_shared<NetActivate>(specifier, callback, timeoutCallback, TEST_TIMEOUT_MS, netActEventHandler_);
289
290 ret = testNetActivate->HaveTypes(bearerTypes);
291 EXPECT_EQ(ret, false);
292 }
293 } // namespace NetManagerStandard
294 } // namespace OHOS