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 <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 = 101;
34 const std::string INTERFACENAME = "wlan0";
35 constexpr int32_t LOCAL_NET_ID = 99;
36 class ConnManagerTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 static inline std::shared_ptr<ConnManager> instance_ = nullptr;
43 };
44
SetUpTestCase()45 void ConnManagerTest::SetUpTestCase()
46 {
47 instance_ = std::make_shared<ConnManager>();
48 }
49
TearDownTestCase()50 void ConnManagerTest::TearDownTestCase()
51 {
52 instance_ = nullptr;
53 }
54
SetUp()55 void ConnManagerTest::SetUp() {}
56
TearDown()57 void ConnManagerTest::TearDown() {}
58
59 /**
60 * @tc.name: CreatePhysicalNetworkTest001
61 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
62 * @tc.type: FUNC
63 */
64 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest001, TestSize.Level1)
65 {
66 ASSERT_NE(instance_, nullptr);
67 int32_t ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
68 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
69 }
70
71 /**
72 * @tc.name: CreatePhysicalNetworkTest002
73 * @tc.desc: Test ConnManager CreatePhysicalNetwork.
74 * @tc.type: FUNC
75 */
76 HWTEST_F(ConnManagerTest, CreatePhysicalNetworkTest002, TestSize.Level1)
77 {
78 ASSERT_NE(instance_, nullptr);
79 int32_t ret = instance_->ReinitRoute();
80 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
81 ret = instance_->CreatePhysicalNetwork(NETID, PERMISSION_NONE);
82 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
83 }
84
85 /**
86 * @tc.name: DestroyNetworkTest001
87 * @tc.desc: Test ConnManager DestroyNetwork.
88 * @tc.type: FUNC
89 */
90 HWTEST_F(ConnManagerTest, DestroyNetworkTest001, TestSize.Level1)
91 {
92 auto ret = instance_->DestroyNetwork(LOCAL_NET_ID);
93 EXPECT_EQ(ret, NETMANAGER_ERROR);
94 }
95
96 /**
97 * @tc.name: DestroyNetworkTest002
98 * @tc.desc: Test ConnManager DestroyNetwork.
99 * @tc.type: FUNC
100 */
101 HWTEST_F(ConnManagerTest, DestroyNetworkTest002, TestSize.Level1)
102 {
103 int32_t ret = instance_->DestroyNetwork(NETID);
104 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
105 ret = instance_->DestroyNetwork(NETID);
106 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
107 }
108
109 /**
110 * @tc.name: SetDefaultNetworkTest001
111 * @tc.desc: Test ConnManager SetDefaultNetwork.
112 * @tc.type: FUNC
113 */
114 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest001, TestSize.Level1)
115 {
116 ASSERT_NE(instance_, nullptr);
117 int32_t ret = instance_->SetDefaultNetwork(NETID);
118 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
119 ret = instance_->SetDefaultNetwork(NETID);
120 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
121 }
122
123 /**
124 * @tc.name: SetDefaultNetworkTest002
125 * @tc.desc: Test ConnManager SetDefaultNetwork.
126 * @tc.type: FUNC
127 */
128 HWTEST_F(ConnManagerTest, SetDefaultNetworkTest002, TestSize.Level1)
129 {
130 ASSERT_NE(instance_, nullptr);
131 int32_t ret = instance_->SetDefaultNetwork(0);
132 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
133 ret = instance_->SetDefaultNetwork(0);
134 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
135 ret = instance_->SetDefaultNetwork(NETID);
136 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
137 }
138
139 /**
140 * @tc.name: ClearDefaultNetwork001
141 * @tc.desc: Test ConnManager ClearDefaultNetwork.
142 * @tc.type: FUNC
143 */
144 HWTEST_F(ConnManagerTest, ClearDefaultNetwork001, TestSize.Level1)
145 {
146 ASSERT_NE(instance_, nullptr);
147 int32_t ret = instance_->ClearDefaultNetwork();
148 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
149 ret = instance_->ClearDefaultNetwork();
150 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
151 }
152
153 /**
154 * @tc.name: GetDefaultNetworkTest001
155 * @tc.desc: Test ConnManager GetDefaultNetwork.
156 * @tc.type: FUNC
157 */
158 HWTEST_F(ConnManagerTest, GetDefaultNetworkTest001, TestSize.Level1)
159 {
160 ASSERT_NE(instance_, nullptr);
161 int32_t ret = instance_->SetDefaultNetwork(NETID);
162 ASSERT_EQ(ret, NETMANAGER_SUCCESS);
163 ret = instance_->GetDefaultNetwork();
164 EXPECT_EQ(ret, NETID);
165 }
166
167 /**
168 * @tc.name: AddInterfaceToNetworkTest001
169 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
170 * @tc.type: FUNC
171 */
172 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest001, TestSize.Level1)
173 {
174 ASSERT_NE(instance_, nullptr);
175 std::string iface = INTERFACENAME;
176 int32_t ret = instance_->AddInterfaceToNetwork(NETID, iface);
177 EXPECT_NE(ret, 0);
178 }
179
180 /**
181 * @tc.name: AddInterfaceToNetworkTest002
182 * @tc.desc: Test ConnManager AddInterfaceToNetwork.
183 * @tc.type: FUNC
184 */
185 HWTEST_F(ConnManagerTest, AddInterfaceToNetworkTest002, TestSize.Level1)
186 {
187 ASSERT_NE(instance_, nullptr);
188 std::string testInterfaceName = "testName";
189 int32_t ret = instance_->AddInterfaceToNetwork(NETID, testInterfaceName);
190 EXPECT_NE(ret, 0);
191 }
192
193 /**
194 * @tc.name: RemoveInterfaceFromNetworkTest001
195 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
196 * @tc.type: FUNC
197 */
198 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest001, TestSize.Level1)
199 {
200 ASSERT_NE(instance_, nullptr);
201 std::string iface = INTERFACENAME;
202 int32_t ret = instance_->RemoveInterfaceFromNetwork(NETID, iface);
203 EXPECT_LE(ret, NETMANAGER_SUCCESS);
204 }
205
206 /**
207 * @tc.name: RemoveInterfaceFromNetworkTest002
208 * @tc.desc: Test ConnManager RemoveInterfaceFromNetwork.
209 * @tc.type: FUNC
210 */
211 HWTEST_F(ConnManagerTest, RemoveInterfaceFromNetworkTest002, TestSize.Level1)
212 {
213 ASSERT_NE(instance_, nullptr);
214 std::string testInterfaceName = "testName";
215 auto ret = instance_->RemoveInterfaceFromNetwork(NETID, testInterfaceName);
216 EXPECT_EQ(ret, NETMANAGER_SUCCESS);
217 }
218
219 /**
220 * @tc.name: AddRouteTest001
221 * @tc.desc: Test ConnManager AddRoute.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(ConnManagerTest, AddRouteTest001, TestSize.Level1)
225 {
226 ASSERT_NE(instance_, nullptr);
227 int32_t ret = instance_->AddRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
228 EXPECT_LE(ret, 0);
229 ret = instance_->AddRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
230 EXPECT_LE(ret, 0);
231 }
232
233 /**
234 * @tc.name: RemoveRouteTest001
235 * @tc.desc: Test ConnManager AddRoute.
236 * @tc.type: FUNC
237 */
238 HWTEST_F(ConnManagerTest, RemoveRouteTest001, TestSize.Level1)
239 {
240 ASSERT_NE(instance_, nullptr);
241 int32_t ret = instance_->RemoveRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
242 EXPECT_LE(ret, 0);
243 ret = instance_->RemoveRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
244 EXPECT_LE(ret, 0);
245 }
246
247 /**
248 * @tc.name: UpdateRouteTest001
249 * @tc.desc: Test ConnManager AddRoute.
250 * @tc.type: FUNC
251 */
252 HWTEST_F(ConnManagerTest, UpdateRouteTest001, TestSize.Level1)
253 {
254 ASSERT_NE(instance_, nullptr);
255 int32_t ret = instance_->UpdateRoute(NETID, INTERFACENAME, "0.0.0.0/0", "192.168.113.222");
256 EXPECT_LE(ret, 0);
257 ret = instance_->UpdateRoute(NETID, INTERFACENAME, "192.168.113.0/24", "0.0.0.0");
258 EXPECT_LE(ret, 0);
259 }
260
261 /**
262 * @tc.name: GetFwmarkForNetworkTest001
263 * @tc.desc: Test ConnManager GetFwmarkForNetwork.
264 * @tc.type: FUNC
265 */
266 HWTEST_F(ConnManagerTest, GetFwmarkForNetworkTest001, TestSize.Level1)
267 {
268 ASSERT_NE(instance_, nullptr);
269 int32_t ret = instance_->GetFwmarkForNetwork(NETID);
270 EXPECT_LE(ret, 0);
271 std::string info;
272 instance_->GetDumpInfos(info);
273 ASSERT_FALSE(info.empty());
274 }
275 } // namespace NetsysNative
276 } // namespace OHOS