• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021-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 #include <cstring>
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 
21 #include "mock_system_func.h"
22 #include "mock_custom_func.h"
23 #include "dhcp_logger.h"
24 #include "dhcp_client_state_machine.h"
25 #include "dhcp_client_def.h"
26 #include "dhcp_function.h"
27 #include "securec.h"
28 #include "dhcp_thread.h"
29 
30 DEFINE_DHCPLOG_DHCP_LABEL("DhcpClientStateMachineTest");
31 
32 using namespace testing::ext;
33 using namespace OHOS::DHCP;
34 namespace OHOS {
35 namespace DHCP {
36 
37 static std::unique_ptr<OHOS::DHCP::DhcpClientStateMachine> dhcpClient = nullptr;
38 
39 class DhcpClientStateMachineTest : public testing::Test {
40 public:
SetUpTestCase()41     static void SetUpTestCase()
42     {
43         std::string ifnametest = "wlan0";
44         dhcpClient = std::make_unique<OHOS::DHCP::DhcpClientStateMachine>(ifnametest);
45     }
TearDownTestCase()46     static void TearDownTestCase()
47     {
48         if (dhcpClient != nullptr) {
49             dhcpClient.reset(nullptr);
50         }
51         DhcpTimer::GetInstance()->timer_.reset();
52     }
SetUp()53     virtual void SetUp()
54     {}
TearDown()55     virtual void TearDown()
56     {
57         MockCustomFunc::GetInstance().SetMockFlag(false);
58         MockSystemFunc::GetInstance().SetMockFlag(false);
59     }
60 
RunGetIPThreadFuncTest()61     static void RunGetIPThreadFuncTest()
62     {
63         dhcpClient->RunGetIPThreadFunc();
64     }
65 };
66 
67 HWTEST_F(DhcpClientStateMachineTest, ExecDhcpRenew_SUCCESS, TestSize.Level1)
68 {
69     DHCP_LOGE("enter ExecDhcpRenew_SUCCESS");
70     MockSystemFunc::SetMockFlag(true);
71 
72     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
73 
74     dhcpClient->SetIpv4State(DHCP_STATE_INIT);
75     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
76     dhcpClient->SetIpv4State(DHCP_STATE_REQUESTING);
77     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
78     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
79     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
80     dhcpClient->SetIpv4State(DHCP_STATE_RENEWING);
81     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
82     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
83     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
84     MockSystemFunc::SetMockFlag(false);
85 }
86 
87 HWTEST_F(DhcpClientStateMachineTest, TEST_FAILED, TestSize.Level1)
88 {
89     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->SetIpv4State(-1));
90     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketHeaderInfo(NULL, 0));
91     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketCommonInfo(NULL));
92 }
93 /**
94  * @tc.name: PublishDhcpResultEvent_Fail1
95  * @tc.desc: PublishDhcpResultEvent()
96  * @tc.type: FUNC
97  * @tc.require: issue
98 */
99 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail1, TestSize.Level1)
100 {
101     DhcpIpResult result;
102     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(nullptr, PUBLISH_CODE_SUCCESS, &result));
103 }
104 /**
105  * @tc.name: PublishDhcpResultEvent_Fail2
106  * @tc.desc: PublishDhcpResultEvent()
107  * @tc.type: FUNC
108  * @tc.require: issue
109 */
110 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail2, TestSize.Level1)
111 {
112     DhcpIpResult result;
113     char ifname[] = "testcode//";
114     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, DHCP_HWADDR_LENGTH, &result));
115 }
116 /**
117  * @tc.name: PublishDhcpResultEvent_Fail3
118  * @tc.desc: PublishDhcpResultEvent()
119  * @tc.type: FUNC
120  * @tc.require: issue
121 */
122 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail3, TestSize.Level1)
123 {
124     DhcpIpResult *result = NULL;
125     char ifname[] = "testcode//";
126     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, result));
127 }
128 /**
129  * @tc.name: PublishDhcpResultEvent_Fail4
130  * @tc.desc: PublishDhcpResultEvent()
131  * @tc.type: FUNC
132  * @tc.require: issue
133 */
134 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail4, TestSize.Level1)
135 {
136     DhcpIpResult result;
137     char ifname[] = "testcode//";
138     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, &result));
139 }
140 /**
141  * @tc.name: PublishDhcpResultEvent_Fail5
142  * @tc.desc: PublishDhcpResultEvent()
143  * @tc.type: FUNC
144  * @tc.require: issue
145 */
146 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail5, TestSize.Level1)
147 {
148     DhcpIpResult result;
149     char ifname[] = "testcode//";
150     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_FAILED, &result));
151 }
152 /**
153  * @tc.name: ParseNetworkVendorInfo_Fail1
154  * @tc.desc: ParseNetworkVendorInfo()
155  * @tc.type: FUNC
156  * @tc.require: issue
157 */
158 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail1, TestSize.Level1)
159 {
160     struct DhcpPacket *packet = nullptr;
161     DhcpIpResult result;
162     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, &result));
163 }
164 /**
165  * @tc.name: ParseNetworkVendorInfo_Fail2
166  * @tc.desc: ParseNetworkVendorInfo()
167  * @tc.type: FUNC
168  * @tc.require: issue
169 */
170 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail2, TestSize.Level1)
171 {
172     struct DhcpPacket packet;
173     DhcpIpResult *result = nullptr;
174     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(&packet, result));
175 }
176 /**
177  * @tc.name: ParseNetworkVendorInfo_Fail3
178  * @tc.desc: ParseNetworkVendorInfo()
179  * @tc.type: FUNC
180  * @tc.require: issue
181 */
182 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail3, TestSize.Level1)
183 {
184     struct DhcpPacket *packet = nullptr;
185     DhcpIpResult *result = nullptr;
186     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, result));
187 }
188 
189 /**
190  * @tc.name: ParseNetworkVendorInfo_Fail4
191  * @tc.desc: ParseNetworkVendorInfo()
192  * @tc.type: FUNC
193  * @tc.require: issue
194 */
195 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail4, TestSize.Level1)
196 {
197     struct DhcpPacket packet;
198     struct DhcpIpResult result;
199     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
200     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
201 }
202 
203 /**
204  * @tc.name: ParseNetworkVendorInfo_Fail5
205  * @tc.desc: ParseNetworkVendorInfo()
206  * @tc.type: FUNC
207  * @tc.require: issue
208 */
209 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail5, TestSize.Level1)
210 {
211     char buf[VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES] = {0};
212     ASSERT_TRUE(snprintf_s(buf,
213                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX,
214                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX - 1,
215                     "%s-%s",
216                     DHCPC_NAME,
217                     DHCPC_VERSION) >= 0);
218 
219     struct DhcpPacket packet;
220     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
221 
222     uint8_t *pOption = packet.options;
223     pOption[DHCP_OPT_CODE_INDEX] = VENDOR_SPECIFIC_INFO_OPTION;
224     pOption[DHCP_OPT_LEN_INDEX] = strlen(buf);
225     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX,
226                     VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES,
227                     buf,
228                     strlen(buf)) == EOK);
229 
230     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
231     pOption[endIndex] = END_OPTION;
232 
233     struct DhcpIpResult result;
234     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
235 }
236 
237 /**
238  * @tc.name: GetDHCPServerHostName_Fail1
239  * @tc.desc: GetDHCPServerHostName()
240  * @tc.type: FUNC
241  * @tc.require: issue
242 */
243 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail1, TestSize.Level1)
244 {
245     struct DhcpPacket *packet = nullptr;
246     DhcpIpResult result;
247     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, &result));
248 }
249 
250 /**
251  * @tc.name: GetDHCPServerHostName_Fail2
252  * @tc.desc: GetDHCPServerHostName()
253  * @tc.type: FUNC
254  * @tc.require: issue
255 */
256 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail2, TestSize.Level1)
257 {
258     struct DhcpPacket packet;
259     DhcpIpResult *result = nullptr;
260     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(&packet, result));
261 }
262 
263 /**
264  * @tc.name: GetDHCPServerHostName_Fail3
265  * @tc.desc: GetDHCPServerHostName()
266  * @tc.type: FUNC
267  * @tc.require: issue
268 */
269 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail3, TestSize.Level1)
270 {
271     struct DhcpPacket *packet = nullptr;
272     DhcpIpResult *result = nullptr;
273     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, result));
274 }
275 
276 /**
277  * @tc.name: GetDHCPServerHostName_Success
278  * @tc.desc: GetDHCPServerHostName()
279  * @tc.type: FUNC
280  * @tc.require: issue
281 */
282 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Success, TestSize.Level1)
283 {
284     struct DhcpPacket packet;
285     struct DhcpIpResult result;
286     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
287     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetDHCPServerHostName(&packet, &result));
288 }
289 
290 HWTEST_F(DhcpClientStateMachineTest, SetSocketModeTest, TestSize.Level1)
291 {
292     DHCP_LOGE("SetSocketModeTest enter!");
293     dhcpClient->SetSocketMode(1);
294 }
295 
296 HWTEST_F(DhcpClientStateMachineTest, SendRebootTest, TestSize.Level1)
297 {
298     DHCP_LOGE("SendRebootTest enter!");
299     dhcpClient->SendReboot(1, 1);
300 }
301 
302 HWTEST_F(DhcpClientStateMachineTest, GetPacketReadSockFdTest, TestSize.Level1)
303 {
304     DHCP_LOGE("GetPacketReadSockFdTest enter!");
305     dhcpClient->GetPacketReadSockFd();
306 }
307 
308 HWTEST_F(DhcpClientStateMachineTest, GetSigReadSockFdTest, TestSize.Level1)
309 {
310     DHCP_LOGE("GetSigReadSockFdTest enter!");
311     dhcpClient->GetSigReadSockFd();
312 }
313 
314 HWTEST_F(DhcpClientStateMachineTest, GetDhcpTransIDTest, TestSize.Level1)
315 {
316     DHCP_LOGE("GetDhcpTransIDTest enter!");
317     dhcpClient->GetDhcpTransID();
318 }
319 
320 HWTEST_F(DhcpClientStateMachineTest, GetPacketHeaderInfoTest, TestSize.Level1)
321 {
322     struct DhcpPacket packet;
323     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_NAK));
324     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_FORCERENEW));
325 }
326 
327 HWTEST_F(DhcpClientStateMachineTest, ExitIpv4Test, TestSize.Level1)
328 {
329     DHCP_LOGI("ExitIpv4Test enter!");
330     dhcpClient->ExitIpv4();
331     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExitIpv4());
332 }
333 
334 HWTEST_F(DhcpClientStateMachineTest, StopIpv4Test, TestSize.Level1)
335 {
336     DHCP_LOGI("StopIpv4Test enter!");
337     dhcpClient->StopIpv4();
338     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->StopIpv4());
339 }
340 
341 HWTEST_F(DhcpClientStateMachineTest, DhcpInitTest, TestSize.Level1)
342 {
343     DHCP_LOGI("DhcpInitTest enter!");
344     dhcpClient->DhcpInit();
345 }
346 
347 HWTEST_F(DhcpClientStateMachineTest, DhcpStopTest, TestSize.Level1)
348 {
349     DHCP_LOGI("DhcpStopTest enter!");
350     dhcpClient->DhcpStop();
351 }
352 
353 HWTEST_F(DhcpClientStateMachineTest, RenewingTest, TestSize.Level1)
354 {
355     DHCP_LOGI("RenewingTest enter!");
356     time_t curTimestamp = time(NULL);
357     dhcpClient->Renewing(curTimestamp);
358 }
359 
360 HWTEST_F(DhcpClientStateMachineTest, RebindingTest, TestSize.Level1)
361 {
362     DHCP_LOGI("RebindingTest enter!");
363     time_t curTimestamp = time(NULL);
364     dhcpClient->Rebinding(curTimestamp);
365 }
366 
367 HWTEST_F(DhcpClientStateMachineTest, DhcpRequestHandleTest, TestSize.Level1)
368 {
369     DHCP_LOGI("DhcpRequestHandleTest enter!");
370     time_t curTimestamp = time(NULL);
371 
372     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
373     dhcpClient->DhcpRequestHandle(curTimestamp);
374 
375     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
376     dhcpClient->DhcpRequestHandle(curTimestamp);
377 
378     dhcpClient->SetIpv4State(DHCP_STATE_RELEASED);
379     dhcpClient->DhcpRequestHandle(curTimestamp);
380 }
381 
382 HWTEST_F(DhcpClientStateMachineTest, DhcpAckOrNakPacketHandleTest, TestSize.Level1)
383 {
384     DHCP_LOGI("DhcpAckOrNakPacketHandleTest enter!");
385     struct DhcpPacket *packet = nullptr;
386     uint8_t type = DHCP_REQUEST;
387     time_t curTimestamp = time(NULL);
388     dhcpClient->DhcpAckOrNakPacketHandle(type, packet, curTimestamp);
389 
390     type = DHCP_NAK;
391     DhcpPacket packet1;
392     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet1, curTimestamp);
393 
394     type = DHCP_ACK;
395     DhcpPacket packet2;
396     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
397     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet2, curTimestamp);
398 
399     DhcpPacket packet3;
400     type = DHCP_REQUEST;
401     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet3, curTimestamp);
402 }
403 
404 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpAckPacketTest, TestSize.Level1)
405 {
406     DHCP_LOGI("ParseDhcpAckPacketTest enter!");
407     struct DhcpPacket *packet = nullptr;
408     time_t curTimestamp = time(NULL);
409     dhcpClient->ParseDhcpAckPacket(packet, curTimestamp);
410 
411     DhcpPacket packet1;
412     dhcpClient->ParseDhcpAckPacket(&packet1, curTimestamp);
413 }
414 
415 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkInfoTest, TestSize.Level1)
416 {
417     DHCP_LOGI("ParseNetworkInfoTest enter!");
418     struct DhcpPacket *packet = nullptr;
419     struct DhcpIpResult *result = nullptr;
420     dhcpClient->ParseNetworkInfo(packet, result);
421 
422     DhcpPacket *packet1 = nullptr;
423     DhcpIpResult result1;
424     dhcpClient->ParseNetworkInfo(packet1, &result1);
425 
426     DhcpPacket packet2;
427     DhcpIpResult *result2 = nullptr;
428     dhcpClient->ParseNetworkInfo(&packet2, result2);
429 
430     DhcpPacket packet3;
431     DhcpIpResult result3;
432     dhcpClient->ParseNetworkInfo(&packet3, &result3);
433 }
434 
435 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkDnsInfoTest, TestSize.Level1)
436 {
437     DHCP_LOGI("ParseNetworkDnsInfoTest enter!");
438     struct DhcpPacket *packet = nullptr;
439     struct DhcpIpResult *result = nullptr;
440     dhcpClient->ParseNetworkDnsInfo(packet, result);
441 
442     DhcpPacket *packet1 = nullptr;
443     DhcpIpResult result1;
444     dhcpClient->ParseNetworkDnsInfo(packet1, &result1);
445 
446     DhcpPacket packet2;
447     DhcpIpResult *result2 = nullptr;
448     dhcpClient->ParseNetworkDnsInfo(&packet2, result2);
449 
450     DhcpPacket packet3;
451     DhcpIpResult result3;
452     dhcpClient->ParseNetworkDnsInfo(&packet3, &result3);
453 }
454 
455 HWTEST_F(DhcpClientStateMachineTest, DhcpOfferPacketHandleTest, TestSize.Level1)
456 {
457     DHCP_LOGI("DhcpOfferPacketHandleTest enter!");
458     struct DhcpPacket *packet = nullptr;
459     uint8_t type = DHCP_REQUEST;
460     time_t curTimestamp = time(NULL);
461     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
462 
463     type = DHCP_OFFER;
464     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
465 
466     DhcpPacket packet1;
467     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
468 
469     packet1.yiaddr = 3226272232;
470     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
471 }
472 
473 HWTEST_F(DhcpClientStateMachineTest, DhcpRebootTest, TestSize.Level1)
474 {
475     DHCP_LOGE("DhcpRebootTest enter!");
476     EXPECT_EQ(SOCKET_OPT_FAILED, dhcpClient->DhcpReboot(1, 1));
477 }
478 
479 HWTEST_F(DhcpClientStateMachineTest, StartIpv4TypeTest, TestSize.Level1)
480 {
481     DHCP_LOGI("StartIpv4TypeTest enter!");
482     std::string ifname;
483     bool isIpv6 = true;
484     ActionMode action = ACTION_START_NEW;
485     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->StartIpv4Type(ifname, isIpv6, action));
486 }
487 
488 HWTEST_F(DhcpClientStateMachineTest, FormatStringTest, TestSize.Level1)
489 {
490     DHCP_LOGI("FormatStringTest enter!");
491     struct DhcpIpResult *result = nullptr;
492     dhcpClient->FormatString(result);
493 
494     DhcpIpResult result1;
495     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "");
496     dhcpClient->FormatString(&result1);
497 
498     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "192.168.0.1");
499     dhcpClient->FormatString(&result1);
500 
501     DhcpIpResult result2;
502     strcpy_s(result2.strOptServerId, sizeof(result2.strOptServerId), "");
503     dhcpClient->FormatString(&result2);
504 
505     strcpy_s(result2.strYiaddr, sizeof(result2.strYiaddr), "192.168.0.2");
506     dhcpClient->FormatString(&result2);
507 
508     DhcpIpResult result3;
509     strcpy_s(result3.strOptSubnet, sizeof(result3.strOptSubnet), "");
510     dhcpClient->FormatString(&result3);
511 
512     strcpy_s(result3.strYiaddr, sizeof(result3.strYiaddr), "192.168.0.3");
513     dhcpClient->FormatString(&result3);
514 
515     DhcpIpResult result4;
516     strcpy_s(result4.strOptDns1, sizeof(result4.strOptDns1), "");
517     dhcpClient->FormatString(&result4);
518 
519     strcpy_s(result4.strYiaddr, sizeof(result4.strYiaddr), "192.168.0.");
520     dhcpClient->FormatString(&result4);
521 
522     DhcpIpResult result5;
523     strcpy_s(result5.strOptDns2, sizeof(result5.strOptDns2), "");
524     dhcpClient->FormatString(&result5);
525 
526     strcpy_s(result5.strYiaddr, sizeof(result5.strYiaddr), "192.168.0.5");
527     dhcpClient->FormatString(&result5);
528 
529     DhcpIpResult result6;
530     strcpy_s(result6.strOptRouter1, sizeof(result6.strOptRouter1), "");
531     dhcpClient->FormatString(&result6);
532 
533     strcpy_s(result6.strYiaddr, sizeof(result6.strYiaddr), "192.168.0.6");
534     dhcpClient->FormatString(&result6);
535 
536     DhcpIpResult result7;
537     strcpy_s(result7.strOptRouter2, sizeof(result7.strOptRouter2), "");
538     dhcpClient->FormatString(&result7);
539 
540     strcpy_s(result7.strYiaddr, sizeof(result7.strYiaddr), "192.168.0.7");
541     dhcpClient->FormatString(&result7);
542 
543     DhcpIpResult result8;
544     strcpy_s(result8.strOptVendor, sizeof(result8.strOptVendor), "");
545     dhcpClient->FormatString(&result8);
546 
547     strcpy_s(result8.strYiaddr, sizeof(result8.strYiaddr), "192.168.0.8");
548     dhcpClient->FormatString(&result8);
549 }
550 
551 HWTEST_F(DhcpClientStateMachineTest, RunGetIPThreadFuncTest, TestSize.Level1)
552 {
553     DHCP_LOGI("RunGetIPThreadFuncTest enter!");
554     DhcpClientCfg m_cltCnf;
555     m_cltCnf.getMode = DHCP_IP_TYPE_ALL;
556     std::thread t(&DhcpClientStateMachineTest::RunGetIPThreadFuncTest);
557     sleep(2);
558     dhcpClient->m_pthread = nullptr;
559     dhcpClient->InitSignalHandle();
560     dhcpClient->m_cltCnf.timeoutExit =true;
561     t.join();
562 }
563 
564 HWTEST_F(DhcpClientStateMachineTest, RequestingTest, TestSize.Level1)
565 {
566     DHCP_LOGI("RequestingTest enter!");
567     time_t curTimestamp = time(NULL);
568     dhcpClient->m_sentPacketNum = 16;
569     dhcpClient->SetIpv4State(DHCP_STATE_RENEWED);
570     dhcpClient->Requesting(curTimestamp);
571 }
572 
573 HWTEST_F(DhcpClientStateMachineTest, AddHostNameToOptsTest, TestSize.Level1)
574 {
575     DHCP_LOGI("AddHostNameToOptsTest enter!");
576     struct DhcpPacket packet;
577     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddHostNameToOpts(nullptr));
578     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddHostNameToOpts(&packet));
579 }
580 
581 HWTEST_F(DhcpClientStateMachineTest, AddStrToOptsTest, TestSize.Level1)
582 {
583     DHCP_LOGI("AddStrToOptsTest enter!");
584     int option = 12;
585     std::string value = "ALN-AL80";
586     struct DhcpPacket packet;
587     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddStrToOpts(nullptr, option, value));
588     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddStrToOpts(&packet, option, value));
589 }
590 
591 HWTEST_F(DhcpClientStateMachineTest, InitSignalHandleTest, TestSize.Level1)
592 {
593     DHCP_LOGI("InitSignalHandleTest enter!");
594     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->InitSignalHandle());
595 }
596 
597 HWTEST_F(DhcpClientStateMachineTest, CloseSignalHandleTest, TestSize.Level1)
598 {
599     DHCP_LOGI("CloseSignalHandleTest enter!");
600     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->CloseSignalHandle());
601 }
602 
603 HWTEST_F(DhcpClientStateMachineTest, AddClientIdToOptsTest, TestSize.Level1)
604 {
605     DHCP_LOGI("AddClientIdToOpts enter!");
606     struct DhcpPacket packet;
607     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddClientIdToOpts(nullptr));
608     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddClientIdToOpts(&packet));
609 }
610 
611 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpNakPacketTest, TestSize.Level1)
612 {
613     DHCP_LOGI("ParseDhcpNakPacket enter!");
614     struct DhcpPacket *packet = nullptr;
615     time_t curTimestamp = time(NULL);
616     dhcpClient->ParseDhcpNakPacket(packet, curTimestamp);
617     DhcpPacket packet1;
618     dhcpClient->ParseDhcpNakPacket(&packet1, curTimestamp);
619 }
620 
621 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkServerIdInfoTest, TestSize.Level1)
622 {
623     DHCP_LOGI("ParseNetworkServerIdInfo enter!");
624     struct DhcpPacket *packet = nullptr;
625     struct DhcpIpResult *result = nullptr;
626     dhcpClient->ParseNetworkServerIdInfo(packet, result);
627 
628     DhcpPacket *packet1 = nullptr;
629     DhcpIpResult result1;
630     dhcpClient->ParseNetworkServerIdInfo(packet1, &result1);
631 
632     DhcpPacket packet2;
633     DhcpIpResult *result2 = nullptr;
634     dhcpClient->ParseNetworkServerIdInfo(&packet2, result2);
635 
636     DhcpPacket packet3;
637     DhcpIpResult result3;
638     dhcpClient->ParseNetworkServerIdInfo(&packet3, &result3);
639 }
640 
641 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkDnsValueTest, TestSize.Level1)
642 {
643     DHCP_LOGI("ParseNetworkDnsValue enter!");
644     struct DhcpIpResult *result = nullptr;
645     uint32_t uData = 123456;
646     size_t len = 4;
647     int count = 0;
648     dhcpClient->ParseNetworkDnsValue(result, uData, len, count);
649 
650     struct DhcpIpResult result1;
651     dhcpClient->ParseNetworkDnsValue(&result1, uData, len, count);
652 }
653 
654 /**
655 * @tc.name: IpConflictDetectTest_SUCCESS
656 * @tc.desc: IpConflictDetectTest.
657 * @tc.type: FUNC
658 * @tc.require: AR00000000
659 */
660 HWTEST_F(DhcpClientStateMachineTest, IpConflictDetectTest_SUCCESS, TestSize.Level1)
661 {
662     DHCP_LOGI("IpConflictDetectTest_SUCCESS enter!");
663     dhcpClient->IpConflictDetect();
664 }
665 
666 /**
667 * @tc.name: FastArpDetectTest_SUCCESS
668 * @tc.desc: FastArpDetectTest.
669 * @tc.type: FUNC
670 * @tc.require: AR00000000
671 */
672 HWTEST_F(DhcpClientStateMachineTest, FastArpDetectTest_SUCCESS, TestSize.Level1)
673 {
674     DHCP_LOGI("FastArpDetectTest_SUCCESS enter!");
675     dhcpClient->FastArpDetect();
676 }
677 
678 /**
679 * @tc.name: SlowArpDetectTest_SUCCESS
680 * @tc.desc: SlowArpDetectTest.
681 * @tc.type: FUNC
682 * @tc.require: AR00000000
683 */
684 HWTEST_F(DhcpClientStateMachineTest, SlowArpDetectTest_SUCCESS, TestSize.Level1)
685 {
686     DHCP_LOGI("SlowArpDetectTest_SUCCESS enter!");
687     dhcpClient->SlowArpDetect(1);
688 }
689 
690 /**
691 * @tc.name: SlowArpDetectCallbackTest_SUCCESS
692 * @tc.desc: SlowArpDetectCallbackTest.
693 * @tc.type: FUNC
694 * @tc.require: AR00000000
695 */
696 HWTEST_F(DhcpClientStateMachineTest, SlowArpDetectCallbackTest_SUCCESS, TestSize.Level1)
697 {
698     DHCP_LOGI("SlowArpDetectCallbackTest_SUCCESS enter!");
699     dhcpClient->SlowArpDetectCallback(true);
700     dhcpClient->SlowArpDetectCallback(false);
701 }
702 
703 /**
704 * @tc.name: IsArpReachableTest_SUCCESS
705 * @tc.desc: IsArpReachableTest.
706 * @tc.type: FUNC
707 * @tc.require: AR00000000
708 */
709 HWTEST_F(DhcpClientStateMachineTest, IsArpReachableTest_SUCCESS, TestSize.Level1)
710 {
711     DHCP_LOGI("IsArpReachableTest_SUCCESS enter!");
712     EXPECT_FALSE(dhcpClient->IsArpReachable(1, "0.0.0.0"));
713 }
714 
715 /**
716 * @tc.name: SaveIpInfoInLocalFileTest_SUCCESS
717 * @tc.desc: SaveIpInfoInLocalFileTest.
718 * @tc.type: FUNC
719 * @tc.require: AR00000000
720 */
721 HWTEST_F(DhcpClientStateMachineTest, SaveIpInfoInLocalFileTest_SUCCESS, TestSize.Level1)
722 {
723     DHCP_LOGI("SaveIpInfoInLocalFileTest_SUCCESS enter!");
724     DhcpIpResult ipResult;
725     ipResult.code = 1;
726     dhcpClient->SaveIpInfoInLocalFile(ipResult);
727 }
728 
729 /**
730 * @tc.name: TryCachedIpTest_SUCCESS
731 * @tc.desc: TryCachedIpTest.
732 * @tc.type: FUNC
733 * @tc.require: AR00000000
734 */
735 HWTEST_F(DhcpClientStateMachineTest, TryCachedIpTest_SUCCESS, TestSize.Level1)
736 {
737     DHCP_LOGI("TryCachedIpTest_SUCCESS enter!");
738     dhcpClient->TryCachedIp();
739 }
740 
741 HWTEST_F(DhcpClientStateMachineTest, StartStopTimerTest, TestSize.Level1)
742 {
743     DHCP_LOGI("StartTimerTest enter!");
744     uint32_t DEFAULT_TIMEROUT0 = 10000; //10 s
745     uint32_t DEFAULT_TIMEROUT1 = 30000;
746     uint32_t DEFAULT_TIMEROUT2 = 60000;
747     uint32_t DEFAULT_TIMEROUT3 = 90000;
748     uint32_t getIpTimerId = 0;
749     uint32_t renewDelayTimerId = 0;
750     uint32_t rebindDelayTimerId = 0;
751     uint32_t remainingDelayTimerId = 0;
752     dhcpClient->StartTimer(TIMER_RENEW_DELAY, getIpTimerId, DEFAULT_TIMEROUT0, true);
753     dhcpClient->StartTimer(TIMER_RENEW_DELAY, renewDelayTimerId, DEFAULT_TIMEROUT1, true);
754     dhcpClient->StartTimer(TIMER_REBIND_DELAY, rebindDelayTimerId, DEFAULT_TIMEROUT2, true);
755     dhcpClient->StartTimer(TIMER_REMAINING_DELAY, remainingDelayTimerId, DEFAULT_TIMEROUT3, true);
756     dhcpClient->StopTimer(getIpTimerId);
757     dhcpClient->StopTimer(renewDelayTimerId);
758     dhcpClient->StopTimer(rebindDelayTimerId);
759     dhcpClient->StopTimer(remainingDelayTimerId);
760 }
761 
762 HWTEST_F(DhcpClientStateMachineTest, GetIpTimerCallbackTest, TestSize.Level1)
763 {
764     DHCP_LOGI("GetIpTimerCallbackTest enter!");
765     dhcpClient->GetIpTimerCallback();
766 }
767 
768 HWTEST_F(DhcpClientStateMachineTest, RenewDelayCallbackTest, TestSize.Level1)
769 {
770     DHCP_LOGI("RenewDelayCallbackTest enter!");
771     dhcpClient->RenewDelayCallback();
772 }
773 
774 HWTEST_F(DhcpClientStateMachineTest, RebindDelayCallbackTest, TestSize.Level1)
775 {
776     DHCP_LOGI("RebindDelayCallbackTest enter!");
777     dhcpClient->RebindDelayCallback();
778 }
779 
780 HWTEST_F(DhcpClientStateMachineTest, RemainingDelayCallbackTest, TestSize.Level1)
781 {
782     DHCP_LOGI("RemainingDelayCallbackTest enter!");
783     dhcpClient->RemainingDelayCallback();
784 }
785 
786 HWTEST_F(DhcpClientStateMachineTest, ScheduleLeaseTimersTest, TestSize.Level1)
787 {
788     DHCP_LOGI("ScheduleLeaseTimersTest enter!");
789     dhcpClient->ScheduleLeaseTimers();
790 }
791 
792 HWTEST_F(DhcpClientStateMachineTest, CloseAllRenewTimerTest, TestSize.Level1)
793 {
794     DHCP_LOGI("CloseAllRenewTimerTest enter!");
795     dhcpClient->CloseAllRenewTimer();
796 }
797 
798 HWTEST_F(DhcpClientStateMachineTest, SendStopSignalTest, TestSize.Level1)
799 {
800     DHCP_LOGI("SendStopSignalTest enter!");
801     dhcpClient->SendStopSignal();
802 }
803 
804 HWTEST_F(DhcpClientStateMachineTest, SetIpv4DefaultDnsTest, TestSize.Level1)
805 {
806     DHCP_LOGI("SetIpv4DefaultDnsTest enter!");
807     struct DhcpIpResult result;
808     dhcpClient->SetIpv4DefaultDns(nullptr);
809     dhcpClient->SetIpv4DefaultDns(&result);
810 }
811 
812 HWTEST_F(DhcpClientStateMachineTest, SetDefaultNetMaskTest, TestSize.Level1)
813 {
814     DHCP_LOGI("SetDefaultNetMaskTest enter!");
815     struct DhcpIpResult result;
816 
817     result.strOptSubnet[0] = 0;
818     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "8.168.0.8");
819     dhcpClient->SetDefaultNetMask(&result);
820 
821     result.strOptSubnet[0] = 0;
822     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "88.168.0.8");
823     dhcpClient->SetDefaultNetMask(&result);
824 
825     result.strOptSubnet[0] = 0;
826     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "127.168.0.8");
827     dhcpClient->SetDefaultNetMask(&result);
828 
829     result.strOptSubnet[0] = 0;
830     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "191.168.0.8");
831     dhcpClient->SetDefaultNetMask(&result);
832 
833     result.strOptSubnet[0] = 0;
834     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "223.168.0.8");
835     dhcpClient->SetDefaultNetMask(&result);
836 
837     result.strOptSubnet[0] = 0;
838     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "225.168.0.8");
839     dhcpClient->SetDefaultNetMask(&result);
840 
841     result.strOptSubnet[0] = 0;
842     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "240.168.0.8");
843     dhcpClient->SetDefaultNetMask(&result);
844 }
845 }
846 }
847 
848