• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 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 "dhcp_server_service.h"
19 #include "dhcp_result_notify.h"
20 #include "mock_system_func.h"
21 #include "dhcp_func.h"
22 
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace OHOS::Wifi;
26 namespace OHOS {
27 namespace Wifi {
28 class DhcpServerServiceTest : public testing::Test {
29 public:
SetUpTestCase()30     static void SetUpTestCase()
31     {}
TearDownTestCase()32     static void TearDownTestCase()
33     {}
SetUp()34     virtual void SetUp()
35     {
36         printf("DhcpServerServiceTest SetUp()...\n");
37         pServerService = std::make_unique<DhcpServerService>();
38     }
TearDown()39     virtual void TearDown()
40     {
41         printf("DhcpServerServiceTest TearDown()...\n");
42         if (pServerService != nullptr) {
43             pServerService.reset(nullptr);
44         }
45     }
46 public:
47     std::unique_ptr<DhcpServerService> pServerService;
48 };
49 
50 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test001, TestSize.Level1)
51 {
52     ASSERT_TRUE(pServerService != nullptr);
53 
54     MockSystemFunc::SetMockFlag(true);
55 
56     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
57         .WillOnce(Return(-1)).WillOnce(Return(1))
58         .WillOnce(Return(-1)).WillOnce(Return(1))
59         .WillRepeatedly(Return(1));
60     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _))
61         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
62     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _))
63         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
64     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillRepeatedly(Return(1));
65     EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)).WillRepeatedly(Return(0));
66     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
67     EXPECT_CALL(MockSystemFunc::GetInstance(), open(_, _)).WillRepeatedly(Return(1));
68 
69     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer("wlan1"));
70 
71     std::string tagName;
72     DhcpRange putRange;
73     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->PutDhcpRange(tagName, putRange));
74     tagName = "sta";
75     putRange.iptype = -1;
76     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->PutDhcpRange(tagName, putRange));
77     putRange.iptype = 0;
78     putRange.strStartip = "192.168.0.1";
79     putRange.strEndip = "192.168.0.49";
80     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
81     putRange.leaseHours = 12;
82     putRange.strTagName = tagName;
83     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
84     putRange.strStartip = "192.168.0.50";
85     putRange.strEndip = "192.168.0.99";
86     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->PutDhcpRange(tagName, putRange));
87     tagName.clear();
88     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->RemoveDhcpRange(tagName, putRange));
89     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->RemoveDhcpRange("ap", putRange));
90     tagName = "sta";
91     putRange.iptype = -1;
92     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->RemoveDhcpRange(tagName, putRange));
93     putRange.iptype = 0;
94     putRange.strStartip = "192.168.0.1";
95     putRange.strEndip = "192.168.0.49";
96     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->RemoveDhcpRange(tagName, putRange));
97     tagName.clear();
98     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->RemoveAllDhcpRange(tagName));
99     tagName = "sta1";
100     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->RemoveAllDhcpRange(tagName));
101     MockSystemFunc::SetMockFlag(false);
102 }
103 
104 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test002, TestSize.Level1)
105 {
106     ASSERT_TRUE(pServerService != nullptr);
107 
108     MockSystemFunc::SetMockFlag(true);
109 
110     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
111         .WillOnce(Return(-1)).WillOnce(Return(1))
112         .WillOnce(Return(-1)).WillOnce(Return(1))
113         .WillRepeatedly(Return(1));
114     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _))
115         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
116     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _))
117         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
118     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillRepeatedly(Return(1));
119     EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)).WillRepeatedly(Return(0));
120     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
121     EXPECT_CALL(MockSystemFunc::GetInstance(), open(_, _)).WillRepeatedly(Return(1));
122     std::string ifname;
123     DhcpRange setRange;
124     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, setRange));
125     ifname = "wlan0";
126     setRange.iptype = 0;
127     setRange.strStartip = "192.168.0.1";
128     setRange.strEndip = "192.168.0.49";
129     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
130     setRange.leaseHours = 12;
131     setRange.strTagName = ifname;
132     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
133 
134     ifname.clear();
135     std::string tagName = "sta";
136     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, tagName));
137     ifname = "wlan0";
138     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, "sta1"));
139     MockSystemFunc::SetMockFlag(false);
140 }
141 
142 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test003, TestSize.Level1)
143 {
144     ASSERT_TRUE(pServerService != nullptr);
145 
146     MockSystemFunc::SetMockFlag(true);
147 
148     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
149         .WillOnce(Return(-1)).WillOnce(Return(1))
150         .WillOnce(Return(-1)).WillOnce(Return(1))
151         .WillRepeatedly(Return(1));
152     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _))
153         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
154     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _))
155         .WillOnce(Return(-1)).WillRepeatedly(Return(0));
156     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillRepeatedly(Return(1));
157     EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)).WillRepeatedly(Return(0));
158     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
159     EXPECT_CALL(MockSystemFunc::GetInstance(), open(_, _)).WillRepeatedly(Return(1));
160     std::string ifname = "wlan0";
161     std::string tagName = "sta";
162     DhcpRange putRange;
163     putRange.iptype = 0;
164     putRange.strStartip = "192.168.0.1";
165     putRange.strEndip = "192.168.0.49";
166     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
167     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->RemoveDhcpRange(tagName, putRange));
168     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, tagName));
169     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
170     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, tagName));
171     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, tagName));
172 
173     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));
174     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
175     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));
176     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));
177     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));
178     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
179 
180     DhcpResultNotify dhcpResultNotify;
181     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->GetDhcpSerProExit("", nullptr));
182     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->GetDhcpSerProExit(ifname, nullptr));
183     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetDhcpSerProExit(ifname, &dhcpResultNotify));
184     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetDhcpSerProExit(ifname, &dhcpResultNotify));
185     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
186 
187     MockSystemFunc::SetMockFlag(false);
188 }
189 
190 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test3, TestSize.Level1)
191 {
192     ASSERT_TRUE(pServerService != nullptr);
193 
194     MockSystemFunc::SetMockFlag(true);
195 
196     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
197         .WillOnce(Return(0)).WillOnce(Return(1))
198         .WillRepeatedly(Return(1));
199     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _)).WillRepeatedly(Return(0));
200     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _)).WillRepeatedly(Return(0));
201     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _))
202         .WillOnce(Return(1)).WillOnce(Return(-1))
203         .WillRepeatedly(Return(1));
204     EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)).WillRepeatedly(Return(0));
205     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
206     EXPECT_CALL(MockSystemFunc::GetInstance(), open(_, _)).WillRepeatedly(Return(1));
207 
208     std::string ifname = "wlan0";
209     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));
210     DhcpRange setRange;
211     setRange.iptype = 0;
212     setRange.strStartip = "192.168.0.1";
213     setRange.strEndip = "192.168.0.49";
214     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, setRange));
215     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
216     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
217     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
218 
219     std::string ifname2 = "wlan2";
220     std::string tagName = "sta2";
221     DhcpRange putRange;
222     putRange.iptype = 0;
223     putRange.strStartip = "192.168.0.50";
224     putRange.strEndip = "192.168.0.99";
225     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
226     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname2, tagName));
227     std::string ipRange;
228     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetUsingIpRange(ifname2, ipRange));
229     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname2));   //start vfork parent success
230     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname2));   //restart start vfork parent success
231     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname2));
232 
233     MockSystemFunc::SetMockFlag(false);
234 }
235 
236 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test4, TestSize.Level1)
237 {
238     ASSERT_TRUE(pServerService != nullptr);
239 
240     MockSystemFunc::SetMockFlag(true);
241 
242     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
243         .WillOnce(Return(1))
244         .WillOnce(Return(0))
245         .WillRepeatedly(Return(1));
246     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _)).WillRepeatedly(Return(0));
247     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _)).WillRepeatedly(Return(0));
248     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _))
249         .WillOnce(Return(1)).WillOnce(Return(-1))
250         .WillRepeatedly(Return(1));
251     EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)).WillRepeatedly(Return(0));
252     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
253     EXPECT_CALL(MockSystemFunc::GetInstance(), open(_, _)).WillRepeatedly(Return(1));
254 
255     std::string ifname = "wlan0";
256     DhcpRange setRange;
257     setRange.iptype = 0;
258     setRange.strStartip = "192.168.0.1";
259     setRange.strEndip = "192.168.0.49";
260     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
261     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
262     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig(ifname));
263     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
264     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
265 
266     MockSystemFunc::SetMockFlag(false);
267 }
268 
269 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test5, TestSize.Level1)
270 {
271     ASSERT_TRUE(pServerService != nullptr);
272 
273     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig(""));
274     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig("wlan0"));
275     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->CheckAndUpdateConf(""));
276     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->CheckAndUpdateConf("wlan1"));
277 
278     std::string ipRange;
279     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->GetUsingIpRange("", ipRange));
280 
281     DhcpRange checkRange;
282     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
283     checkRange.iptype = 0;
284     checkRange.strStartip = "192.168.0";
285     checkRange.strEndip = "192.168.1";
286     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
287     checkRange.strStartip = "192.168.0.49";
288     checkRange.strEndip = "192.168.1";
289     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
290     checkRange.strEndip = "192.168.0.1";
291     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
292 
293     checkRange.iptype = 1;
294     checkRange.strStartip = "fe80:fac8";
295     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
296     checkRange.strStartip = "fe80::fac8";
297     checkRange.strEndip = "fe80:fac8";
298     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
299 
300     std::string ifname;
301     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->AddSpecifiedInterface(ifname));
302     ifname = "wlan";
303     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->AddSpecifiedInterface(ifname));
304     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->AddSpecifiedInterface(ifname));
305 
306     ifname.clear();
307     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->DelSpecifiedInterface(ifname));
308     ifname = "wlan";
309     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->DelSpecifiedInterface(ifname));
310     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->DelSpecifiedInterface(ifname));
311 
312     std::string strFile = DHCP_SERVER_LEASES_FILE + "." + ifname;
313     std::string strTestData = "dhcp server leases file test";
314     ASSERT_TRUE(DhcpFunc::CreateFile(strFile, strTestData));
315     std::vector<std::string> vecLeases;
316     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetLeases(ifname, vecLeases));
317     ASSERT_TRUE(DhcpFunc::RemoveFile(strFile));
318 }
319 }
320 }