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 <algorithm>
17 #include <gtest/gtest.h>
18
19 #include "interface_manager.h"
20 #include "netsys_controller.h"
21 #include "net_manager_constants.h"
22 namespace OHOS {
23 namespace nmd {
24 namespace {
25 using namespace testing::ext;
26 using namespace OHOS::NetManagerStandard;
27 } // namespace
28
29 class InterfaceManagerTest : public testing::Test {
30 public:
31 static void SetUpTestCase();
32 static void TearDownTestCase();
33 void SetUp();
34 void TearDown();
35 };
36
SetUpTestCase()37 void InterfaceManagerTest::SetUpTestCase() {}
38
TearDownTestCase()39 void InterfaceManagerTest::TearDownTestCase() {}
40
SetUp()41 void InterfaceManagerTest::SetUp() {}
42
TearDown()43 void InterfaceManagerTest::TearDown() {}
44
45 HWTEST_F(InterfaceManagerTest, GetMtuTest001, TestSize.Level1)
46 {
47 auto ret = InterfaceManager::GetMtu(nullptr);
48 EXPECT_EQ(ret, -1);
49
50 std::string interfaceName = "IfaceNameIsExtMax16";
51 ret = InterfaceManager::GetMtu(interfaceName.data());
52 EXPECT_EQ(ret, -1);
53 }
54
55 HWTEST_F(InterfaceManagerTest, GetMtuTest002, TestSize.Level1)
56 {
57 std::string interfaceName = "eth0";
58 auto ret = InterfaceManager::GetMtu(interfaceName.c_str());
59 EXPECT_EQ(ret, -1);
60 }
61
62 HWTEST_F(InterfaceManagerTest, SetMtuTest001, TestSize.Level1)
63 {
64 std::string mtuValue = "10";
65 std::string interfaceName;
66 auto ret = InterfaceManager::SetMtu(interfaceName.data(), mtuValue.data());
67 EXPECT_EQ(ret, -1);
68 }
69
70 HWTEST_F(InterfaceManagerTest, SetMtuTest002, TestSize.Level1)
71 {
72 std::string mtuValue = "10";
73 std::string interfaceName = "eth0";
74 auto ret = InterfaceManager::SetMtu(interfaceName.data(), mtuValue.data());
75 EXPECT_EQ(ret, -1);
76 }
77
78 HWTEST_F(InterfaceManagerTest, SetMtuTest003, TestSize.Level1)
79 {
80 std::string interfaceName = "eth0";
81 auto ifaceList = NetManagerStandard::NetsysController::GetInstance().InterfaceGetList();
82 bool eth0NotExist = std::find(ifaceList.begin(), ifaceList.end(), interfaceName) == ifaceList.end();
83 if (eth0NotExist) {
84 return;
85 }
86
87 char *mtuValue = nullptr;
88 auto ret = InterfaceManager::SetMtu(interfaceName.data(), mtuValue);
89 EXPECT_EQ(ret, -1);
90
91 const char *cmtu = "";
92 ret = InterfaceManager::SetMtu(interfaceName.data(), cmtu);
93 EXPECT_EQ(ret, -1);
94
95 std::string mtu = "1500";
96 ret = InterfaceManager::SetMtu(interfaceName.data(), mtu.data());
97 EXPECT_EQ(ret, 0);
98
99 mtu = "1500000000000000";
100 ret = InterfaceManager::SetMtu(interfaceName.data(), mtu.data());
101 EXPECT_EQ(ret, -1);
102 }
103
104 HWTEST_F(InterfaceManagerTest, AddAddressTest001, TestSize.Level1)
105 {
106 std::string interfaceName = "eth0";
107 std::string addr = "";
108 int32_t prefixLength = 0;
109 auto ret = InterfaceManager::AddAddress(interfaceName.data(), addr.data(), prefixLength);
110 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
111 }
112
113 HWTEST_F(InterfaceManagerTest, AddAddressTest002, TestSize.Level1)
114 {
115 std::string addr = "14.4.1.4";
116 int32_t prefixLength = 45;
117 auto ret = InterfaceManager::AddAddress(nullptr, addr.data(), prefixLength);
118 EXPECT_LE(ret, 0);
119 }
120
121 HWTEST_F(InterfaceManagerTest, AddAddressTest003, TestSize.Level1)
122 {
123 std::string interfaceName = "eth0";
124 std::string addr;
125 int32_t prefixLength = 45;
126 auto ret = InterfaceManager::AddAddress(interfaceName.c_str(), addr.data(), prefixLength);
127 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
128 }
129
130 HWTEST_F(InterfaceManagerTest, AddAddressTest004, TestSize.Level1)
131 {
132 std::string interfaceName = "eth";
133 std::string addr;
134 int32_t prefixLength = 45;
135 auto ret = InterfaceManager::AddAddress(interfaceName.c_str(), addr.data(), prefixLength);
136 EXPECT_EQ(ret, -errno);
137 }
138
139 HWTEST_F(InterfaceManagerTest, AddAddressTest005, TestSize.Level1)
140 {
141 std::string interfaceName = "eth";
142 int32_t prefixLength = 45;
143 auto ret = InterfaceManager::AddAddress(interfaceName.c_str(), nullptr, prefixLength);
144 EXPECT_EQ(ret, -1);
145 }
146
147 HWTEST_F(InterfaceManagerTest, DelAddressTest001, TestSize.Level1)
148 {
149 std::string interfaceName = "eth0";
150 std::string addr = "";
151 int32_t prefixLength = 0;
152 auto ret = InterfaceManager::DelAddress(interfaceName.data(), addr.data(), prefixLength);
153 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
154 }
155
156 HWTEST_F(InterfaceManagerTest, DelAddressTest002, TestSize.Level1)
157 {
158 std::string addr = "14.4.1.4";
159 int32_t prefixLength = 45;
160 auto ret = InterfaceManager::DelAddress(nullptr, addr.data(), prefixLength);
161 EXPECT_LE(ret, 0);
162 }
163
164 HWTEST_F(InterfaceManagerTest, DelAddressTest003, TestSize.Level1)
165 {
166 std::string interfaceName = "eth0";
167 int32_t prefixLength = 45;
168 std::string addr;
169 auto ret = InterfaceManager::DelAddress(interfaceName.data(), addr.data(), prefixLength);
170 EXPECT_EQ(ret, NETMANAGER_ERR_PARAMETER_ERROR);
171 }
172
173 HWTEST_F(InterfaceManagerTest, GetInterfaceNamesTest001, TestSize.Level1)
174 {
175 auto ret = InterfaceManager::GetInterfaceNames();
176 EXPECT_FALSE(ret.empty());
177 }
178
179 HWTEST_F(InterfaceManagerTest, GetIfaceConfigTest001, TestSize.Level1)
180 {
181 std::string ifaceName = "";
182 auto ret = InterfaceManager::GetIfaceConfig(ifaceName);
183 EXPECT_TRUE(ret.ifName.empty());
184 }
185
186 HWTEST_F(InterfaceManagerTest, GetIfaceConfigTest002, TestSize.Level1)
187 {
188 std::string ifaceName = "eth0";
189 auto ret = InterfaceManager::GetIfaceConfig(ifaceName);
190 EXPECT_FALSE(ret.ifName.empty());
191 }
192
193 HWTEST_F(InterfaceManagerTest, SetIfaceConfigTest001, TestSize.Level1)
194 {
195 nmd::InterfaceConfigurationParcel ifaceConfig;
196 ifaceConfig.ifName = "test0";
197 int32_t ret = InterfaceManager::SetIfaceConfig(ifaceConfig);
198 EXPECT_LE(ret, 0);
199
200 ifaceConfig.flags.push_back("up");
201 ret = InterfaceManager::SetIfaceConfig(ifaceConfig);
202 EXPECT_LE(ret, 0);
203
204 std::string ifaceName = "eth0";
205 auto config = InterfaceManager::GetIfaceConfig(ifaceName);
206 EXPECT_FALSE(config.ifName.empty());
207 ret = InterfaceManager::SetIfaceConfig(config);
208 EXPECT_LE(ret, 1);
209 }
210
211 HWTEST_F(InterfaceManagerTest, SetIpAddressTest002, TestSize.Level1)
212 {
213 std::string errName = "test0";
214 std::string ipAddr = "172.17.5.245";
215 auto ret = InterfaceManager::SetIpAddress(errName, ipAddr);
216 EXPECT_LE(ret, 0);
217 }
218
219 HWTEST_F(InterfaceManagerTest, SetIffUpTest002, TestSize.Level1)
220 {
221 std::string errName = "test0";
222 auto ret = InterfaceManager::SetIffUp(errName);
223 EXPECT_LE(ret, 0);
224
225 std::string ifaceName = "eth1";
226 ret = InterfaceManager::SetIffUp(ifaceName);
227 EXPECT_LE(ret, 0);
228 }
229 } // namespace nmd
230 } // namespace OHOS