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 "iservice_registry.h"
19 #include "system_ability_definition.h"
20
21 #include "conn_manager.h"
22 #include "net_conn_manager_test_util.h"
23 #include "net_manager_constants.h"
24 #include "netnative_log_wrapper.h"
25 #include "netsys_native_service_proxy.h"
26 #include "network_permission.h"
27
28 namespace OHOS {
29 namespace NetsysNative {
30 using namespace testing::ext;
31 using namespace NetManagerStandard;
32 using namespace NetConnManagerTestUtil;
33 constexpr int32_t NETID = 103;
34 const std::string INTERFACENAME = "wlan0";
35 constexpr int32_t LOCAL_NET_ID = 99;
36 constexpr int32_t ERROR_CODE = -101;
37 class ConnManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase();
40 static void TearDownTestCase();
41 void SetUp();
42 void TearDown();
43 static inline std::shared_ptr<ConnManager> instance_ = nullptr;
44 };
45
SetUpTestCase()46 void ConnManagerTest::SetUpTestCase()
47 {
48 instance_ = std::make_shared<ConnManager>();
49 }
50
TearDownTestCase()51 void ConnManagerTest::TearDownTestCase()
52 {
53 instance_ = nullptr;
54 }
55
SetUp()56 void ConnManagerTest::SetUp() {}
57
TearDown()58 void ConnManagerTest::TearDown() {}
59
60 /**
61 * @tc.name: SetInternetPermission001
62 * @tc.desc: Test ConnManager SetInternetPermission.
63 * @tc.type: FUNC
64 */
65 HWTEST_F(ConnManagerTest, SetInternetPermission001, TestSize.Level1)
66 {
67 uint32_t uid = 0;
68 uint8_t allow = 0;
69 int32_t ret = instance_->SetInternetPermission(uid, allow);
70 EXPECT_EQ(ret, NETMANAGER_ERROR);
71 }
72
73 /**
74 * @tc.name: SetInternetPermission002
75 * @tc.desc: Test ConnManager SetInternetPermission.
76 * @tc.type: FUNC
77 */
78 HWTEST_F(ConnManagerTest, SetInternetPermission002, TestSize.Level1)
79 {
80 uint32_t uid = 1;
81 uint8_t allow = 0;
82 int32_t ret = instance_->SetInternetPermission(uid, allow);
83 EXPECT_EQ(ret, 0);
84 }
85
86 /**
87 * @tc.name: CreatePhysicalNetworkTest001
88 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
89 * @tc.type: FUNC
90 */
91 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest001, TestSize.Level1)
92 {
93 int32_t ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
94 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
95 }
96
97 /**
98 * @tc.name: CreatePhysicalNetworkTest002
99 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
100 * @tc.type: FUNC
101 */
102 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest002, TestSize.Level1)
103 {
104 int32_t ret = instance_->ReinitRoute();
105 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
106 ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
107 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
108 }
109
110 /**
111 * @tc.name: CreateVirtualNetwork001
112 * @tc.desc: Test ConnManager CreateVirtualNetwork.
113 * @tc.type: FUNC
114 */
115 HWTEST_F(ConnManagerTest, CreateVirtualNetwork001, TestSize.Level1)
116 {
117 uint16_t netId = 1;
118 bool hasDns = true;
119 int32_t ret = instance_->CreateVirtualNetwork(netId, hasDns);
120 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
121 }
122
123 /**
124 * @tc.name: DestroyNetworkTest001
125 * @tc.desc: Test ConnManager DestroyNetwork.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(ConnManagerTest, DestroyNetworkTest001, TestSize.Level1)
129 {
130 auto ret = instance_->DestroyNetwork(LOCAL_NET_ID);
131 EXPECT_EQ(ret, NETMANAGER_ERROR);
132 }
133
134 /**
135 * @tc.name: DestroyNetworkTest002
136 * @tc.desc: Test ConnManager DestroyNetwork.
137 * @tc.type: FUNC
138 */
139 HWTEST_F(ConnManagerTest, DestroyNetworkTest002, TestSize.Level1)
140 {
141 int32_t ret = instance_->DestroyNetwork(NETID);
142 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
143 ret = instance_->DestroyNetwork(NETID);
144 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
145 }
146
147 /**
148 * @tc.name: DestroyNetworkTest003
149 * @tc.desc: Test ConnManager DestroyNetwork.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(ConnManagerTest, DestroyNetworkTest003, TestSize.Level1)
153 {
154 int32_t netId = 100;
155 int32_t ret = instance_->CreatePhysicalNetwork(netId, PERMISSION_NONE);
156 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
157
158 ret = instance_->DestroyNetwork(netId);
159 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
160 }
161
162 /**
163 * @tc.name: SetDefaultNetworkTest001
164 * @tc.desc: Test ConnManager SetDefaultNetwork.
165 * @tc.type: FUNC
166 */
167 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest001, TestSize.Level1)
168 {
169 int32_t ret = instance_->SetDefaultNetwork(NETID);
170 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
171 ret = instance_->SetDefaultNetwork(NETID);
172 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
173 }
174
175 /**
176 * @tc.name: SetDefaultNetworkTest002
177 * @tc.desc: Test ConnManager SetDefaultNetwork.
178 * @tc.type: FUNC
179 */
180 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest002, TestSize.Level1)
181 {
182 int32_t ret = instance_->SetDefaultNetwork(0);
183 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
184 ret = instance_->SetDefaultNetwork(0);
185 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
186 ret = instance_->SetDefaultNetwork(NETID);
187 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
188 }
189
190 /**
191 * @tc.name: ClearDefaultNetwork001
192 * @tc.desc: Test ConnManager ClearDefaultNetwork.
193 * @tc.type: FUNC
194 */
195 HWTEST_F(ConnManagerTest, ClearDefaultNetwork001, TestSize.Level1)
196 {
197 int32_t ret = instance_->ClearDefaultNetwork();
198 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
199 ret = instance_->ClearDefaultNetwork();
200 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
201 }
202
203 /**
204 * @tc.name: GetDefaultNetworkTest001
205 * @tc.desc: Test ConnManager GetDefaultNetwork.
206 * @tc.type: FUNC
207 */
208 HWTEST_F(ConnManagerTest, GetDefaultNetworkTest001, TestSize.Level1)
209 {
210 int32_t ret = instance_->SetDefaultNetwork(NETID);
211 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
212 ret = instance_->GetDefaultNetwork();
213 EXPECT_EQ(ret, NETID);
214 }
215
216 /**
217 * @tc.name: AddInterfaceToNetworkTest001
218 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
219 * @tc.type: FUNC
220 */
221 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest001, TestSize.Level1)
222 {
223 std::string iface = INTERFACENAME;
224 int32_t ret = instance_->AddInterfaceToNetwork(NETID, iface);
225 EXPECT_NE(ret, 0);
226 }
227
228 /**
229 * @tc.name: AddInterfaceToNetworkTest002
230 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
231 * @tc.type: FUNC
232 */
233 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest002, TestSize.Level1)
234 {
235 std::string testInterfaceName = "testName";
236 int32_t ret = instance_->AddInterfaceToNetwork(NETID, testInterfaceName);
237 EXPECT_NE(ret, 0);
238 }
239
240 /**
241 * @tc.name: RemoveInterfaceFromNetworkTest001
242 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
243 * @tc.type: FUNC
244 */
245 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest001, TestSize.Level1)
246 {
247 std::string iface = INTERFACENAME;
248 int32_t ret = instance_->RemoveInterfaceFromNetwork(NETID, iface);
249 EXPECT_LE(ret, NETMANAGER_SUCCESS);
250 }
251
252 /**
253 * @tc.name: RemoveInterfaceFromNetworkTest002
254 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
255 * @tc.type: FUNC
256 */
257 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest002, TestSize.Level1)
258 {
259 std::string testInterfaceName = "testName";
260 auto ret = instance_->RemoveInterfaceFromNetwork(NETID, testInterfaceName);
261 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
262 }
263
264 /**
265 * @tc.name: AddRouteTest001
266 * @tc.desc: Test ConnManager AddRoute.
267 * @tc.type: FUNC
268 */
269 HWTEST_F(ConnManagerTest, AddRouteTest001, TestSize.Level1)
270 {
271 int32_t ret = instance_->AddRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
272 EXPECT_LE(ret, 0);
273 ret = instance_->AddRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
274 EXPECT_LE(ret, 0);
275 }
276
277 /**
278 * @tc.name: RemoveRouteTest001
279 * @tc.desc: Test ConnManager AddRoute.
280 * @tc.type: FUNC
281 */
282 HWTEST_F(ConnManagerTest, RemoveRouteTest001, TestSize.Level1)
283 {
284 int32_t ret = instance_->RemoveRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
285 EXPECT_LE(ret, 0);
286 ret = instance_->RemoveRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
287 EXPECT_LE(ret, 0);
288 }
289
290 /**
291 * @tc.name: UpdateRouteTest001
292 * @tc.desc: Test ConnManager AddRoute.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(ConnManagerTest, UpdateRouteTest001, TestSize.Level1)
296 {
297 int32_t ret = instance_->UpdateRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
298 EXPECT_LE(ret, 0);
299 ret = instance_->UpdateRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
300 EXPECT_LE(ret, 0);
301 }
302
303 /**
304 * @tc.name: UpdateRouteTest002
305 * @tc.desc: Test ConnManager AddRoute.
306 * @tc.type: FUNC
307 */
308 HWTEST_F(ConnManagerTest, UpdateRouteTest002, TestSize.Level1)
309 {
310 int32_t netId = 99;
311 int32_t ret = instance_->UpdateRoute(netId, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
312 EXPECT_EQ(ret, ERROR_CODE);
313 }
314
315 /**
316 * @tc.name: SetPermissionForNetwork001
317 * @tc.desc: Test ConnManager SetPermissionForNetwork.
318 * @tc.type: FUNC
319 */
320 HWTEST_F(ConnManagerTest, SetPermissionForNetwork001, TestSize.Level1)
321 {
322 int32_t netId = 99;
323 int32_t ret = instance_->SetPermissionForNetwork(netId, NetworkPermission::PERMISSION_NETWORK);
324 EXPECT_EQ(ret, NETMANAGER_ERROR);
325 }
326
327 /**
328 * @tc.name: AddUidsToNetwork001
329 * @tc.desc: Test ConnManager AddUidsToNetwork.
330 * @tc.type: FUNC
331 */
332 HWTEST_F(ConnManagerTest, AddUidsToNetwork001, TestSize.Level1)
333 {
334 int32_t netId = 99;
335 const std::vector<NetManagerStandard::UidRange> uidRanges;
336 int32_t ret = instance_->AddUidsToNetwork(netId, uidRanges);
337 EXPECT_EQ(ret, NETMANAGER_ERROR);
338
339 netId = 1;
340 ret = instance_->AddUidsToNetwork(netId, uidRanges);
341 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
342 }
343
344 /**
345 * @tc.name: RemoveUidsFromNetwork001
346 * @tc.desc: Test ConnManager RemoveUidsFromNetwork.
347 * @tc.type: FUNC
348 */
349 HWTEST_F(ConnManagerTest, RemoveUidsFromNetwork001, TestSize.Level1)
350 {
351 int32_t netId = 99;
352 const std::vector<NetManagerStandard::UidRange> uidRanges;
353 int32_t ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
354 EXPECT_EQ(ret, NETMANAGER_ERROR);
355
356 netId = 1;
357 ret = instance_->RemoveUidsFromNetwork(netId, uidRanges);
358 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
359 }
360
361 /**
362 * @tc.name: GetFwmarkForNetworkTest001
363 * @tc.desc: Test ConnManager GetFwmarkForNetwork.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(ConnManagerTest, GetFwmarkForNetworkTest001, TestSize.Level1)
367 {
368 int32_t ret = instance_->GetFwmarkForNetwork(NETID);
369 EXPECT_LE(ret, 0);
370 std::string info;
371 instance_->GetDumpInfos(info);
372 ASSERT_FALSE(info.empty());
373 }
374 } // namespace NetsysNative
375 } // namespace OHOS