• 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 
27 class DhcpServerServiceTest : public testing::Test {
28 public:
SetUpTestCase()29     static void SetUpTestCase(){}
TearDownTestCase()30     static void TearDownTestCase(){}
SetUp()31     virtual void SetUp()
32     {
33         printf("DhcpServerServiceTest SetUp()...\n");
34         pServerService = std::make_unique<DhcpServerService>();
35         if (pServerService == nullptr) {
36             printf("DhcpServerServiceTest SetUp() make_unique DhcpServerService failed\n");
37         }
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_Test2, 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 
102     std::string ifname;
103     DhcpRange setRange;
104     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, setRange));
105     ifname = "wlan0";
106     setRange.iptype = 0;
107     setRange.strStartip = "192.168.0.1";
108     setRange.strEndip = "192.168.0.49";
109     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
110     setRange.leaseHours = 12;
111     setRange.strTagName = ifname;
112     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
113 
114     ifname.clear();
115     tagName = "sta";
116     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, tagName));
117     ifname = "wlan0";
118     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, "sta1"));
119     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
120     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->RemoveDhcpRange(tagName, putRange));
121     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, tagName));
122     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
123     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, tagName));
124     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, tagName));
125 
126     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));    //start vfork failed
127     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));   //start vfork success
128     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));    //restart stop kill failed
129     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));    //restart stop waitpid failed
130     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));    //restart start vfork failed
131     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));   //restart start vfork success
132 
133     DhcpResultNotify dhcpResultNotify;
134     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->GetDhcpSerProExit("", nullptr));
135     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->GetDhcpSerProExit(ifname, nullptr));
136     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetDhcpSerProExit(ifname, &dhcpResultNotify));
137     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetDhcpSerProExit(ifname, &dhcpResultNotify));
138     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
139 
140     MockSystemFunc::SetMockFlag(false);
141 }
142 
143 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test3, TestSize.Level1)
144 {
145     ASSERT_TRUE(pServerService != nullptr);
146 
147     MockSystemFunc::SetMockFlag(true);
148 
149     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
150         .WillOnce(Return(0)).WillOnce(Return(1))
151         .WillRepeatedly(Return(1));
152     EXPECT_CALL(MockSystemFunc::GetInstance(), waitpid(_, _, _)).WillRepeatedly(Return(0));
153     EXPECT_CALL(MockSystemFunc::GetInstance(), kill(_, _)).WillRepeatedly(Return(0));
154     EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _))
155         .WillOnce(Return(1)).WillOnce(Return(-1))
156         .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 
161     std::string ifname = "wlan0";
162     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->StartDhcpServer(ifname));    //start vfork child failed
163     DhcpRange setRange;
164     setRange.iptype = 0;
165     setRange.strStartip = "192.168.0.1";
166     setRange.strEndip = "192.168.0.49";
167     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->SetDhcpRange(ifname, setRange));//socket failed
168     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
169     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
170     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
171 
172     std::string ifname2 = "wlan2";
173     std::string tagName = "sta2";
174     DhcpRange putRange;
175     putRange.iptype = 0;
176     putRange.strStartip = "192.168.0.50";
177     putRange.strEndip = "192.168.0.99";
178     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->PutDhcpRange(tagName, putRange));
179     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname2, tagName));
180     std::string ipRange;
181     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetUsingIpRange(ifname2, ipRange));
182     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname2));   //start vfork parent success
183     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname2));   //restart start vfork parent success
184     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname2));
185 
186     MockSystemFunc::SetMockFlag(false);
187 }
188 
189 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test4, TestSize.Level1)
190 {
191     ASSERT_TRUE(pServerService != nullptr);
192 
193     MockSystemFunc::SetMockFlag(true);
194 
195     EXPECT_CALL(MockSystemFunc::GetInstance(), vfork())
196         .WillOnce(Return(1))
197         .WillOnce(Return(0))
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     DhcpRange setRange;
210     setRange.iptype = 0;
211     setRange.strStartip = "192.168.0.1";
212     setRange.strEndip = "192.168.0.49";
213     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->SetDhcpRange(ifname, setRange));
214     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
215     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig(ifname));
216     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StartDhcpServer(ifname));
217     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->StopDhcpServer(ifname));
218 
219     MockSystemFunc::SetMockFlag(false);
220 }
221 
222 HWTEST_F(DhcpServerServiceTest, DhcpServerService_Test5, TestSize.Level1)
223 {
224     ASSERT_TRUE(pServerService != nullptr);
225 
226     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig(""));
227     EXPECT_EQ(DHCP_OPT_FAILED, pServerService->ReloadConfig("wlan0"));
228     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->CheckAndUpdateConf(""));
229     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->CheckAndUpdateConf("wlan1"));
230 
231     std::string ipRange;
232     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->GetUsingIpRange("", ipRange));
233 
234     DhcpRange checkRange;
235     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
236     checkRange.iptype = 0;
237     checkRange.strStartip = "192.168.0";
238     checkRange.strEndip = "192.168.1";
239     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
240     checkRange.strStartip = "192.168.0.49";
241     checkRange.strEndip = "192.168.1";
242     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
243     checkRange.strEndip = "192.168.0.1";
244     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
245 
246     checkRange.iptype = 1;
247     checkRange.strStartip = "fe80:fac8";
248     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
249     checkRange.strStartip = "fe80::fac8";
250     checkRange.strEndip = "fe80:fac8";
251     EXPECT_EQ(false, pServerService->CheckIpAddrRange(checkRange));
252 
253     std::string ifname;
254     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->AddSpecifiedInterface(ifname));
255     ifname = "wlan";
256     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->AddSpecifiedInterface(ifname));
257     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->AddSpecifiedInterface(ifname));
258 
259     ifname.clear();
260     EXPECT_EQ(DHCP_OPT_ERROR, pServerService->DelSpecifiedInterface(ifname));
261     ifname = "wlan";
262     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->DelSpecifiedInterface(ifname));
263     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->DelSpecifiedInterface(ifname));
264 
265     std::string strFile = DHCP_SERVER_LEASES_FILE + "." + ifname;
266     std::string strTestData = "dhcp server leases file test";
267     ASSERT_TRUE(DhcpFunc::CreateFile(strFile, strTestData));
268     std::vector<std::string> vecLeases;
269     EXPECT_EQ(DHCP_OPT_SUCCESS, pServerService->GetLeases(ifname, vecLeases));
270     ASSERT_TRUE(DhcpFunc::RemoveFile(strFile));
271 }
272