• 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 constexpr int ZERO = 0;
37 constexpr int TWO = 2;
38 constexpr int THREE = 3;
39 constexpr int INVALID = 12;
40 static std::string g_errLog = "wifitest";
41 
42 static std::unique_ptr<OHOS::DHCP::DhcpClientStateMachine> dhcpClient = nullptr;
43 
44 class DhcpClientStateMachineTest : public testing::Test {
45 public:
SetUpTestCase()46     static void SetUpTestCase()
47     {
48         std::string ifnametest = "wlan0";
49         dhcpClient = std::make_unique<OHOS::DHCP::DhcpClientStateMachine>(ifnametest);
50     }
TearDownTestCase()51     static void TearDownTestCase()
52     {
53         if (dhcpClient != nullptr) {
54             dhcpClient.reset(nullptr);
55         }
56         DhcpTimer::GetInstance()->timer_.reset();
57     }
SetUp()58     virtual void SetUp()
59     {
60         dhcpClient->threadExit_ = false;
61     }
TearDown()62     virtual void TearDown()
63     {
64         MockCustomFunc::GetInstance().SetMockFlag(false);
65         MockSystemFunc::GetInstance().SetMockFlag(false);
66     }
67 };
68 
69 HWTEST_F(DhcpClientStateMachineTest, ExecDhcpRenew_SUCCESS, TestSize.Level1)
70 {
71     DHCP_LOGE("enter ExecDhcpRenew_SUCCESS");
72     MockSystemFunc::SetMockFlag(true);
73 
74     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
75 
76     dhcpClient->SetIpv4State(DHCP_STATE_INIT);
77     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
78     dhcpClient->SetIpv4State(DHCP_STATE_REQUESTING);
79     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
80     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
81     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
82     dhcpClient->SetIpv4State(DHCP_STATE_RENEWING);
83     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
84     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
85     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
86     MockSystemFunc::SetMockFlag(false);
87 }
88 
89 HWTEST_F(DhcpClientStateMachineTest, TEST_FAILED, TestSize.Level1)
90 {
91     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->SetIpv4State(-1));
92     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketHeaderInfo(NULL, 0));
93     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketCommonInfo(NULL));
94 }
95 /**
96  * @tc.name: PublishDhcpResultEvent_Fail1
97  * @tc.desc: PublishDhcpResultEvent()
98  * @tc.type: FUNC
99  * @tc.require: issue
100 */
101 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail1, TestSize.Level1)
102 {
103     DhcpIpResult result;
104     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(nullptr, PUBLISH_CODE_SUCCESS, &result));
105 }
106 /**
107  * @tc.name: PublishDhcpResultEvent_Fail2
108  * @tc.desc: PublishDhcpResultEvent()
109  * @tc.type: FUNC
110  * @tc.require: issue
111 */
112 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail2, TestSize.Level1)
113 {
114     DhcpIpResult result;
115     char ifname[] = "testcode//";
116     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, DHCP_HWADDR_LENGTH, &result));
117 }
118 /**
119  * @tc.name: PublishDhcpResultEvent_Fail3
120  * @tc.desc: PublishDhcpResultEvent()
121  * @tc.type: FUNC
122  * @tc.require: issue
123 */
124 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail3, TestSize.Level1)
125 {
126     DhcpIpResult *result = NULL;
127     char ifname[] = "testcode//";
128     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, result));
129 }
130 /**
131  * @tc.name: PublishDhcpResultEvent_Fail4
132  * @tc.desc: PublishDhcpResultEvent()
133  * @tc.type: FUNC
134  * @tc.require: issue
135 */
136 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail4, TestSize.Level1)
137 {
138     DhcpIpResult result;
139     char ifname[] = "testcode//";
140     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, &result));
141 }
142 /**
143  * @tc.name: PublishDhcpResultEvent_Fail5
144  * @tc.desc: PublishDhcpResultEvent()
145  * @tc.type: FUNC
146  * @tc.require: issue
147 */
148 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail5, TestSize.Level1)
149 {
150     DhcpIpResult result;
151     char ifname[] = "testcode//";
152     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_FAILED, &result));
153 }
154 /**
155  * @tc.name: ParseNetworkVendorInfo_Fail1
156  * @tc.desc: ParseNetworkVendorInfo()
157  * @tc.type: FUNC
158  * @tc.require: issue
159 */
160 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail1, TestSize.Level1)
161 {
162     struct DhcpPacket *packet = nullptr;
163     DhcpIpResult result;
164     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, &result));
165 }
166 /**
167  * @tc.name: ParseNetworkVendorInfo_Fail2
168  * @tc.desc: ParseNetworkVendorInfo()
169  * @tc.type: FUNC
170  * @tc.require: issue
171 */
172 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail2, TestSize.Level1)
173 {
174     struct DhcpPacket packet;
175     DhcpIpResult *result = nullptr;
176     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(&packet, result));
177 }
178 /**
179  * @tc.name: ParseNetworkVendorInfo_Fail3
180  * @tc.desc: ParseNetworkVendorInfo()
181  * @tc.type: FUNC
182  * @tc.require: issue
183 */
184 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail3, TestSize.Level1)
185 {
186     struct DhcpPacket *packet = nullptr;
187     DhcpIpResult *result = nullptr;
188     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, result));
189 }
190 
191 /**
192  * @tc.name: ParseNetworkVendorInfo_Fail4
193  * @tc.desc: ParseNetworkVendorInfo()
194  * @tc.type: FUNC
195  * @tc.require: issue
196 */
197 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail4, TestSize.Level1)
198 {
199     struct DhcpPacket packet;
200     struct DhcpIpResult result;
201     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
202     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
203 }
204 
205 /**
206  * @tc.name: ParseNetworkVendorInfo_Fail5
207  * @tc.desc: ParseNetworkVendorInfo()
208  * @tc.type: FUNC
209  * @tc.require: issue
210 */
211 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail5, TestSize.Level1)
212 {
213     char buf[VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES] = {0};
214     ASSERT_TRUE(snprintf_s(buf,
215                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX,
216                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX - 1,
217                     "%s-%s",
218                     DHCPC_NAME,
219                     DHCPC_VERSION) >= 0);
220 
221     struct DhcpPacket packet;
222     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
223 
224     uint8_t *pOption = packet.options;
225     pOption[DHCP_OPT_CODE_INDEX] = VENDOR_SPECIFIC_INFO_OPTION;
226     pOption[DHCP_OPT_LEN_INDEX] = strlen(buf);
227     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX,
228                     VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES,
229                     buf,
230                     strlen(buf)) == EOK);
231 
232     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
233     pOption[endIndex] = END_OPTION;
234 
235     struct DhcpIpResult result;
236     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
237 }
238 
239 /**
240  * @tc.name: GetDHCPServerHostName_Fail1
241  * @tc.desc: GetDHCPServerHostName()
242  * @tc.type: FUNC
243  * @tc.require: issue
244 */
245 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail1, TestSize.Level1)
246 {
247     struct DhcpPacket *packet = nullptr;
248     DhcpIpResult result;
249     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, &result));
250 }
251 
252 /**
253  * @tc.name: GetDHCPServerHostName_Fail2
254  * @tc.desc: GetDHCPServerHostName()
255  * @tc.type: FUNC
256  * @tc.require: issue
257 */
258 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail2, TestSize.Level1)
259 {
260     struct DhcpPacket packet;
261     DhcpIpResult *result = nullptr;
262     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(&packet, result));
263 }
264 
265 /**
266  * @tc.name: GetDHCPServerHostName_Fail3
267  * @tc.desc: GetDHCPServerHostName()
268  * @tc.type: FUNC
269  * @tc.require: issue
270 */
271 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail3, TestSize.Level1)
272 {
273     struct DhcpPacket *packet = nullptr;
274     DhcpIpResult *result = nullptr;
275     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, result));
276 }
277 
278 /**
279  * @tc.name: GetDHCPServerHostName_Success
280  * @tc.desc: GetDHCPServerHostName()
281  * @tc.type: FUNC
282  * @tc.require: issue
283 */
284 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Success, TestSize.Level1)
285 {
286     struct DhcpPacket packet;
287     struct DhcpIpResult result;
288     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
289     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetDHCPServerHostName(&packet, &result));
290 }
291 
292 HWTEST_F(DhcpClientStateMachineTest, SetSocketModeTest, TestSize.Level1)
293 {
294     DHCP_LOGE("SetSocketModeTest enter!");
295     dhcpClient->SetSocketMode(1);
296     EXPECT_FALSE(g_errLog.find("processWiTasDecisiveMessage")!=std::string::npos);
297 }
298 
299 HWTEST_F(DhcpClientStateMachineTest, SendRebootTest, TestSize.Level1)
300 {
301     DHCP_LOGE("SendRebootTest enter!");
302     dhcpClient->SendReboot(1, 1);
303     EXPECT_EQ(1, dhcpClient->m_requestedIp4);
304 }
305 
306 HWTEST_F(DhcpClientStateMachineTest, GetPacketReadSockFdTest, TestSize.Level1)
307 {
308     DHCP_LOGE("GetPacketReadSockFdTest enter!");
309     dhcpClient->GetPacketReadSockFd();
310     EXPECT_EQ(-1, dhcpClient->m_sockFd);
311 }
312 
313 HWTEST_F(DhcpClientStateMachineTest, GetSigReadSockFdTest, TestSize.Level1)
314 {
315     DHCP_LOGE("GetSigReadSockFdTest enter!");
316     dhcpClient->GetSigReadSockFd();
317     EXPECT_EQ(0, dhcpClient->m_sigSockFds[0]);
318 }
319 
320 HWTEST_F(DhcpClientStateMachineTest, GetDhcpTransIDTest, TestSize.Level1)
321 {
322     DHCP_LOGE("GetDhcpTransIDTest enter!");
323     dhcpClient->GetDhcpTransID();
324     EXPECT_EQ(0, dhcpClient->m_transID);
325 }
326 
327 HWTEST_F(DhcpClientStateMachineTest, GetPacketHeaderInfoTest, TestSize.Level1)
328 {
329     struct DhcpPacket packet;
330     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_NAK));
331     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_FORCERENEW));
332 }
333 
334 HWTEST_F(DhcpClientStateMachineTest, ExitIpv4Test, TestSize.Level1)
335 {
336     DHCP_LOGI("ExitIpv4Test enter!");
337     dhcpClient->ExitIpv4();
338     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExitIpv4());
339 }
340 
341 HWTEST_F(DhcpClientStateMachineTest, StopIpv4Test, TestSize.Level1)
342 {
343     DHCP_LOGI("StopIpv4Test enter!");
344     dhcpClient->StopIpv4();
345     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->StopIpv4());
346 }
347 
348 HWTEST_F(DhcpClientStateMachineTest, DhcpInitTest, TestSize.Level1)
349 {
350     DHCP_LOGI("DhcpInitTest enter!");
351     dhcpClient->DhcpInit();
352     EXPECT_EQ(DHCP_STATE_INIT, dhcpClient->m_dhcp4State);
353 }
354 
355 HWTEST_F(DhcpClientStateMachineTest, RenewingTest, TestSize.Level1)
356 {
357     DHCP_LOGI("RenewingTest enter!");
358     time_t curTimestamp = time(NULL);
359     dhcpClient->Renewing(curTimestamp);
360 
361     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES + 1;
362     dhcpClient->Renewing(curTimestamp);
363 
364     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES - 1;
365     dhcpClient->Renewing(curTimestamp);
366     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
367 }
368 
369 HWTEST_F(DhcpClientStateMachineTest, RebindingTest, TestSize.Level1)
370 {
371     DHCP_LOGI("RebindingTest enter!");
372     time_t curTimestamp = time(NULL);
373     dhcpClient->Rebinding(curTimestamp);
374 
375     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES + 1;
376     dhcpClient->Rebinding(curTimestamp);
377 
378     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES - 1;
379     dhcpClient->Rebinding(curTimestamp);
380 
381     dhcpClient->m_dhcp4State = DHCP_STATE_REBINDING;
382     dhcpClient->Rebinding(curTimestamp);
383     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
384 }
385 
386 HWTEST_F(DhcpClientStateMachineTest, DhcpRequestHandleTest, TestSize.Level1)
387 {
388     DHCP_LOGI("DhcpRequestHandleTest enter!");
389     time_t curTimestamp = time(NULL);
390 
391     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
392     dhcpClient->DhcpRequestHandle(curTimestamp);
393 
394     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
395     dhcpClient->DhcpRequestHandle(curTimestamp);
396 
397     dhcpClient->SetIpv4State(DHCP_STATE_RELEASED);
398     dhcpClient->DhcpRequestHandle(curTimestamp);
399 
400     dhcpClient->SetIpv4State(DHCP_STATE_RENEWED);
401     dhcpClient->DhcpRequestHandle(curTimestamp);
402 
403     dhcpClient->SetIpv4State(DHCP_STATE_REBINDING);
404     dhcpClient->DhcpRequestHandle(curTimestamp);
405 
406     dhcpClient->SetIpv4State(DHCP_STATE_FAST_ARP);
407     dhcpClient->DhcpRequestHandle(curTimestamp);
408 
409     dhcpClient->SetIpv4State(DHCP_STATE_SLOW_ARP);
410     dhcpClient->DhcpRequestHandle(curTimestamp);
411 
412     dhcpClient->SetIpv4State(DHCP_STATE_DECLINE);
413     dhcpClient->DhcpRequestHandle(curTimestamp);
414 
415     dhcpClient->SetIpv4State(INVALID);
416     dhcpClient->DhcpRequestHandle(curTimestamp);
417     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
418 }
419 
420 HWTEST_F(DhcpClientStateMachineTest, DhcpAckOrNakPacketHandleTest, TestSize.Level1)
421 {
422     DHCP_LOGI("DhcpAckOrNakPacketHandleTest enter!");
423     struct DhcpPacket *packet = nullptr;
424     uint8_t type = DHCP_REQUEST;
425     time_t curTimestamp = time(NULL);
426     dhcpClient->DhcpAckOrNakPacketHandle(type, packet, curTimestamp);
427 
428     type = DHCP_NAK;
429     DhcpPacket packet1;
430     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet1, curTimestamp);
431     dhcpClient->DhcpAckOrNakPacketHandle(type, nullptr, curTimestamp);
432 
433     type = DHCP_ACK;
434     DhcpPacket packet2;
435     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
436     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet2, curTimestamp);
437 
438     DhcpPacket packet3;
439     type = DHCP_REQUEST;
440     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet3, curTimestamp);
441     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
442 }
443 
444 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpAckPacketTest, TestSize.Level1)
445 {
446     DHCP_LOGI("ParseDhcpAckPacketTest enter!");
447     struct DhcpPacket *packet = nullptr;
448     time_t curTimestamp = time(NULL);
449     dhcpClient->ParseDhcpAckPacket(packet, curTimestamp);
450 
451     DhcpPacket packet1;
452     dhcpClient->ParseDhcpAckPacket(&packet1, curTimestamp);
453     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
454 }
455 
456 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkInfoTest, TestSize.Level1)
457 {
458     DHCP_LOGI("ParseNetworkInfoTest enter!");
459     struct DhcpPacket *packet = nullptr;
460     struct DhcpIpResult *result = nullptr;
461     dhcpClient->ParseNetworkInfo(packet, result);
462 
463     DhcpPacket *packet1 = nullptr;
464     DhcpIpResult result1;
465     dhcpClient->ParseNetworkInfo(packet1, &result1);
466 
467     DhcpPacket packet2;
468     DhcpIpResult *result2 = nullptr;
469     dhcpClient->ParseNetworkInfo(&packet2, result2);
470 
471     DhcpPacket packet3;
472     DhcpIpResult result3;
473     dhcpClient->ParseNetworkInfo(&packet3, &result3);
474     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
475 }
476 
477 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkDnsInfoTest, TestSize.Level1)
478 {
479     DHCP_LOGI("ParseNetworkDnsInfoTest enter!");
480     struct DhcpPacket *packet = nullptr;
481     struct DhcpIpResult *result = nullptr;
482     dhcpClient->ParseNetworkDnsInfo(packet, result);
483 
484     DhcpPacket *packet1 = nullptr;
485     DhcpIpResult result1;
486     dhcpClient->ParseNetworkDnsInfo(packet1, &result1);
487 
488     DhcpPacket packet2;
489     DhcpIpResult *result2 = nullptr;
490     dhcpClient->ParseNetworkDnsInfo(&packet2, result2);
491 
492     DhcpPacket packet3;
493     DhcpIpResult result3;
494     dhcpClient->ParseNetworkDnsInfo(&packet3, &result3);
495     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
496 }
497 
498 HWTEST_F(DhcpClientStateMachineTest, DhcpOfferPacketHandleTest, TestSize.Level1)
499 {
500     DHCP_LOGI("DhcpOfferPacketHandleTest enter!");
501     struct DhcpPacket *packet = nullptr;
502     uint8_t type = DHCP_REQUEST;
503     time_t curTimestamp = time(NULL);
504     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
505 
506     type = DHCP_OFFER;
507     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
508 
509     DhcpPacket packet1;
510     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
511 
512     packet1.yiaddr = 3226272232;
513     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
514     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
515 }
516 
517 HWTEST_F(DhcpClientStateMachineTest, DhcpRebootTest, TestSize.Level1)
518 {
519     DHCP_LOGE("DhcpRebootTest enter!");
520     EXPECT_NE(SOCKET_OPT_ERROR, dhcpClient->DhcpReboot(1, 1));
521 }
522 
523 HWTEST_F(DhcpClientStateMachineTest, StartIpv4TypeTest, TestSize.Level1)
524 {
525     DHCP_LOGI("StartIpv4TypeTest enter!");
526     std::string ifname;
527     bool isIpv6 = true;
528     ActionMode action = ACTION_START_NEW;
529     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->StartIpv4Type(ifname, isIpv6, action));
530 }
531 
532 HWTEST_F(DhcpClientStateMachineTest, FormatStringTest, TestSize.Level1)
533 {
534     DHCP_LOGI("FormatStringTest enter!");
535     struct DhcpIpResult *result = nullptr;
536     dhcpClient->FormatString(result);
537 
538     DhcpIpResult result1;
539     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "");
540     dhcpClient->FormatString(&result1);
541 
542     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "192.168.0.1");
543     dhcpClient->FormatString(&result1);
544 
545     DhcpIpResult result2;
546     strcpy_s(result2.strOptServerId, sizeof(result2.strOptServerId), "");
547     dhcpClient->FormatString(&result2);
548 
549     strcpy_s(result2.strYiaddr, sizeof(result2.strYiaddr), "192.168.0.2");
550     dhcpClient->FormatString(&result2);
551 
552     DhcpIpResult result3;
553     strcpy_s(result3.strOptSubnet, sizeof(result3.strOptSubnet), "");
554     dhcpClient->FormatString(&result3);
555 
556     strcpy_s(result3.strYiaddr, sizeof(result3.strYiaddr), "192.168.0.3");
557     dhcpClient->FormatString(&result3);
558 
559     DhcpIpResult result4;
560     strcpy_s(result4.strOptDns1, sizeof(result4.strOptDns1), "");
561     dhcpClient->FormatString(&result4);
562 
563     strcpy_s(result4.strYiaddr, sizeof(result4.strYiaddr), "192.168.0.");
564     dhcpClient->FormatString(&result4);
565 
566     DhcpIpResult result5;
567     strcpy_s(result5.strOptDns2, sizeof(result5.strOptDns2), "");
568     dhcpClient->FormatString(&result5);
569 
570     strcpy_s(result5.strYiaddr, sizeof(result5.strYiaddr), "192.168.0.5");
571     dhcpClient->FormatString(&result5);
572 
573     DhcpIpResult result6;
574     strcpy_s(result6.strOptRouter1, sizeof(result6.strOptRouter1), "");
575     dhcpClient->FormatString(&result6);
576 
577     strcpy_s(result6.strYiaddr, sizeof(result6.strYiaddr), "192.168.0.6");
578     dhcpClient->FormatString(&result6);
579 
580     DhcpIpResult result7;
581     strcpy_s(result7.strOptRouter2, sizeof(result7.strOptRouter2), "");
582     dhcpClient->FormatString(&result7);
583 
584     strcpy_s(result7.strYiaddr, sizeof(result7.strYiaddr), "192.168.0.7");
585     dhcpClient->FormatString(&result7);
586 
587     DhcpIpResult result8;
588     strcpy_s(result8.strOptVendor, sizeof(result8.strOptVendor), "");
589     dhcpClient->FormatString(&result8);
590 
591     strcpy_s(result8.strYiaddr, sizeof(result8.strYiaddr), "192.168.0.8");
592     dhcpClient->FormatString(&result8);
593     EXPECT_EQ(nullptr, result);
594 }
595 
596 HWTEST_F(DhcpClientStateMachineTest, RequestingTest, TestSize.Level1)
597 {
598     DHCP_LOGI("RequestingTest enter!");
599     time_t curTimestamp = time(NULL);
600     dhcpClient->m_sentPacketNum = 16;
601     dhcpClient->SetIpv4State(DHCP_STATE_RENEWED);
602     dhcpClient->Requesting(curTimestamp);
603     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
604 }
605 
606 HWTEST_F(DhcpClientStateMachineTest, RequestingTest1, TestSize.Level1)
607 {
608     DHCP_LOGI("RequestingTest1 enter!");
609     time_t timestamp = 1;
610     dhcpClient->m_sentPacketNum = TIMEOUT_TIMES_MAX + 1;
611     dhcpClient->Requesting(timestamp);
612 
613     dhcpClient->m_sentPacketNum = TWO;
614     dhcpClient->m_dhcp4State = DHCP_STATE_RENEWED;
615     dhcpClient->Requesting(timestamp);
616 
617     dhcpClient->m_dhcp4State = DHCP_STATE_RELEASED;
618     dhcpClient->Requesting(timestamp);
619     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
620 }
621 
622 HWTEST_F(DhcpClientStateMachineTest, AddHostNameToOptsTest, TestSize.Level1)
623 {
624     DHCP_LOGI("AddHostNameToOptsTest enter!");
625     struct DhcpPacket packet;
626     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
627     packet.options[0] = END_OPTION;
628     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddHostNameToOpts(nullptr));
629     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddHostNameToOpts(&packet));
630 }
631 
632 HWTEST_F(DhcpClientStateMachineTest, AddStrToOptsTest, TestSize.Level1)
633 {
634     DHCP_LOGI("AddStrToOptsTest enter!");
635     int option = 12;
636     std::string value = "ALN-AL80";
637     struct DhcpPacket packet;
638     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
639     packet.options[0] = END_OPTION;
640     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddStrToOpts(nullptr, option, value));
641     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddStrToOpts(&packet, option, value));
642 }
643 
644 HWTEST_F(DhcpClientStateMachineTest, InitSignalHandleTest, TestSize.Level1)
645 {
646     DHCP_LOGI("InitSignalHandleTest enter!");
647     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->InitSignalHandle());
648 }
649 
650 HWTEST_F(DhcpClientStateMachineTest, CloseSignalHandleTest, TestSize.Level1)
651 {
652     DHCP_LOGI("CloseSignalHandleTest enter!");
653     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->CloseSignalHandle());
654 }
655 
656 HWTEST_F(DhcpClientStateMachineTest, AddClientIdToOptsTest, TestSize.Level1)
657 {
658     DHCP_LOGI("AddClientIdToOpts enter!");
659     struct DhcpPacket packet;
660     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
661     packet.options[0] = END_OPTION;
662     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddClientIdToOpts(nullptr));
663     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddClientIdToOpts(&packet));
664 }
665 
666 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpNakPacketTest, TestSize.Level1)
667 {
668     DHCP_LOGI("ParseDhcpNakPacket enter!");
669     struct DhcpPacket *packet = nullptr;
670     time_t curTimestamp = time(NULL);
671     dhcpClient->ParseDhcpNakPacket(packet, curTimestamp);
672     DhcpPacket packet1;
673     dhcpClient->ParseDhcpNakPacket(&packet1, curTimestamp);
674 
675     dhcpClient->m_resendTimer = INVALID;
676     dhcpClient->ParseDhcpNakPacket(&packet1, curTimestamp);
677     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
678 }
679 
680 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkServerIdInfoTest, TestSize.Level1)
681 {
682     DHCP_LOGI("ParseNetworkServerIdInfo enter!");
683     struct DhcpPacket *packet = nullptr;
684     struct DhcpIpResult *result = nullptr;
685     dhcpClient->ParseNetworkServerIdInfo(packet, result);
686 
687     DhcpPacket *packet1 = nullptr;
688     DhcpIpResult result1;
689     dhcpClient->ParseNetworkServerIdInfo(packet1, &result1);
690 
691     DhcpPacket packet2;
692     DhcpIpResult *result2 = nullptr;
693     dhcpClient->ParseNetworkServerIdInfo(&packet2, result2);
694 
695     DhcpPacket packet3;
696     DhcpIpResult result3;
697     dhcpClient->ParseNetworkServerIdInfo(&packet3, &result3);
698     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
699 }
700 
701 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkDnsValueTest, TestSize.Level1)
702 {
703     DHCP_LOGI("ParseNetworkDnsValue enter!");
704     struct DhcpIpResult *result = nullptr;
705     uint32_t uData = 123456;
706     size_t len = 4;
707     int count = 0;
708     dhcpClient->ParseNetworkDnsValue(result, uData, len, count);
709 
710     struct DhcpIpResult result1;
711     dhcpClient->ParseNetworkDnsValue(&result1, uData, len, count);
712     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
713 }
714 
715 /**
716 * @tc.name: IpConflictDetectTest_SUCCESS
717 * @tc.desc: IpConflictDetectTest.
718 * @tc.type: FUNC
719 * @tc.require: AR00000000
720 */
721 HWTEST_F(DhcpClientStateMachineTest, IpConflictDetectTest_SUCCESS, TestSize.Level1)
722 {
723     DHCP_LOGI("IpConflictDetectTest_SUCCESS enter!");
724     dhcpClient->IpConflictDetect();
725     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
726 }
727 
728 /**
729 * @tc.name: FastArpDetectTest_SUCCESS
730 * @tc.desc: FastArpDetectTest.
731 * @tc.type: FUNC
732 * @tc.require: AR00000000
733 */
734 HWTEST_F(DhcpClientStateMachineTest, FastArpDetectTest_SUCCESS, TestSize.Level1)
735 {
736     DHCP_LOGI("FastArpDetectTest_SUCCESS enter!");
737     dhcpClient->FastArpDetect();
738     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
739 }
740 
741 /**
742 * @tc.name: SlowArpDetectTest_SUCCESS
743 * @tc.desc: SlowArpDetectTest.
744 * @tc.type: FUNC
745 * @tc.require: AR00000000
746 */
747 HWTEST_F(DhcpClientStateMachineTest, SlowArpDetectTest_SUCCESS, TestSize.Level1)
748 {
749     DHCP_LOGI("SlowArpDetectTest_SUCCESS enter!");
750     dhcpClient->SlowArpDetect(1);
751     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
752 }
753 
754 HWTEST_F(DhcpClientStateMachineTest, SlowArpDetectTest1, TestSize.Level1)
755 {
756     DHCP_LOGI("SlowArpDetectTest1 enter!");
757     time_t timestamp = 1;
758     dhcpClient->m_sentPacketNum = THREE;
759     dhcpClient->SlowArpDetect(timestamp);
760 
761     dhcpClient->m_sentPacketNum = TWO;
762     dhcpClient->SlowArpDetect(timestamp);
763 
764     dhcpClient->m_sentPacketNum = 0;
765     dhcpClient->SlowArpDetect(timestamp);
766     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
767 }
768 
769 /**
770 * @tc.name: SlowArpDetectCallbackTest_SUCCESS
771 * @tc.desc: SlowArpDetectCallbackTest.
772 * @tc.type: FUNC
773 * @tc.require: AR00000000
774 */
775 HWTEST_F(DhcpClientStateMachineTest, SlowArpDetectCallbackTest_SUCCESS, TestSize.Level1)
776 {
777     DHCP_LOGI("SlowArpDetectCallbackTest_SUCCESS enter!");
778     dhcpClient->SlowArpDetectCallback(true);
779     dhcpClient->SlowArpDetectCallback(false);
780 
781     dhcpClient->m_slowArpDetecting = 1;
782     dhcpClient->SlowArpDetectCallback(true);
783     dhcpClient->SlowArpDetectCallback(false);
784     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
785 }
786 
787 /**
788 * @tc.name: IsArpReachableTest_SUCCESS
789 * @tc.desc: IsArpReachableTest.
790 * @tc.type: FUNC
791 * @tc.require: AR00000000
792 */
793 HWTEST_F(DhcpClientStateMachineTest, IsArpReachableTest_SUCCESS, TestSize.Level1)
794 {
795     DHCP_LOGI("IsArpReachableTest_SUCCESS enter!");
796     EXPECT_FALSE(dhcpClient->IsArpReachable(1, "0.0.0.0"));
797 }
798 
799 /**
800 * @tc.name: SaveIpInfoInLocalFileTest_SUCCESS
801 * @tc.desc: SaveIpInfoInLocalFileTest.
802 * @tc.type: FUNC
803 * @tc.require: AR00000000
804 */
805 HWTEST_F(DhcpClientStateMachineTest, SaveIpInfoInLocalFileTest_SUCCESS, TestSize.Level1)
806 {
807     DHCP_LOGI("SaveIpInfoInLocalFileTest_SUCCESS enter!");
808     DhcpIpResult ipResult;
809     ipResult.code = 1;
810     dhcpClient->SaveIpInfoInLocalFile(ipResult);
811 
812     dhcpClient->m_routerCfg.bssid = "wlan0";
813     dhcpClient->SaveIpInfoInLocalFile(ipResult);
814     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
815 }
816 
817 /**
818 * @tc.name: TryCachedIpTest_SUCCESS
819 * @tc.desc: TryCachedIpTest.
820 * @tc.type: FUNC
821 * @tc.require: AR00000000
822 */
823 HWTEST_F(DhcpClientStateMachineTest, TryCachedIpTest_SUCCESS, TestSize.Level1)
824 {
825     DHCP_LOGI("TryCachedIpTest_SUCCESS enter!");
826     dhcpClient->TryCachedIp();
827 
828     dhcpClient->m_routerCfg.prohibitUseCacheIp = 1;
829     dhcpClient->TryCachedIp();
830     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
831 }
832 
833 HWTEST_F(DhcpClientStateMachineTest, StartStopTimerTest, TestSize.Level1)
834 {
835     DHCP_LOGI("StartTimerTest enter!");
836     int64_t dafaultInterval0 = 10000; //10 s
837     int64_t dafaultInterval1 = 30000;
838     int64_t dafaultInterval2 = 60000;
839     int64_t dafaultInterval3 = 90000;
840     uint64_t getIpTimerId = 0;
841     uint64_t renewDelayTimerId = 0;
842     uint64_t rebindDelayTimerId = 0;
843     uint64_t remainingDelayTimerId = 0;
844     dhcpClient->StartTimer(TIMER_RENEW_DELAY, getIpTimerId, dafaultInterval0, true);
845     dhcpClient->StartTimer(TIMER_RENEW_DELAY, renewDelayTimerId, dafaultInterval1, true);
846     dhcpClient->StartTimer(TIMER_REBIND_DELAY, rebindDelayTimerId, dafaultInterval2, true);
847     dhcpClient->StartTimer(TIMER_REMAINING_DELAY, remainingDelayTimerId, dafaultInterval3, true);
848     dhcpClient->StopTimer(getIpTimerId);
849     dhcpClient->StopTimer(renewDelayTimerId);
850     dhcpClient->StopTimer(rebindDelayTimerId);
851     dhcpClient->StopTimer(remainingDelayTimerId);
852     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
853 }
854 
855 HWTEST_F(DhcpClientStateMachineTest, GetIpTimerCallbackTest, TestSize.Level1)
856 {
857     DHCP_LOGI("GetIpTimerCallbackTest enter!");
858     dhcpClient->GetIpTimerCallback();
859     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
860 }
861 
862 HWTEST_F(DhcpClientStateMachineTest, GetIpTimerCallbackTest1, TestSize.Level1)
863 {
864     DHCP_LOGI("GetIpTimerCallbackTest1 enter!");
865     dhcpClient->threadExit_ = 0;
866     dhcpClient->m_action = ACTION_RENEW_T1;
867     dhcpClient->GetIpTimerCallback();
868 
869     dhcpClient->m_action = ACTION_RENEW_T3;
870     dhcpClient->GetIpTimerCallback();
871 
872     dhcpClient->m_action = ACTION_START_NEW;
873     dhcpClient->GetIpTimerCallback();
874 
875     dhcpClient->m_action = ACTION_INVALID;
876     dhcpClient->GetIpTimerCallback();
877     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
878 }
879 
880 HWTEST_F(DhcpClientStateMachineTest, RenewDelayCallbackTest, TestSize.Level1)
881 {
882     DHCP_LOGI("RenewDelayCallbackTest enter!");
883     dhcpClient->RenewDelayCallback();
884     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
885 }
886 
887 HWTEST_F(DhcpClientStateMachineTest, RebindDelayCallbackTest, TestSize.Level1)
888 {
889     DHCP_LOGI("RebindDelayCallbackTest enter!");
890     dhcpClient->RebindDelayCallback();
891     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
892 }
893 
894 HWTEST_F(DhcpClientStateMachineTest, RemainingDelayCallbackTest, TestSize.Level1)
895 {
896     DHCP_LOGI("RemainingDelayCallbackTest enter!");
897     dhcpClient->RemainingDelayCallback();
898     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
899 }
900 
901 HWTEST_F(DhcpClientStateMachineTest, ScheduleLeaseTimersTest, TestSize.Level1)
902 {
903     DHCP_LOGI("ScheduleLeaseTimersTest enter!");
904     dhcpClient->ScheduleLeaseTimers(true);
905     dhcpClient->ScheduleLeaseTimers(false);
906     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
907 }
908 
909 HWTEST_F(DhcpClientStateMachineTest, CloseAllRenewTimerTest, TestSize.Level1)
910 {
911     DHCP_LOGI("CloseAllRenewTimerTest enter!");
912     dhcpClient->CloseAllRenewTimer();
913     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
914 }
915 
916 HWTEST_F(DhcpClientStateMachineTest, SetIpv4DefaultDnsTest, TestSize.Level1)
917 {
918     DHCP_LOGI("SetIpv4DefaultDnsTest enter!");
919     struct DhcpIpResult result;
920     dhcpClient->SetIpv4DefaultDns(nullptr);
921     dhcpClient->SetIpv4DefaultDns(&result);
922     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
923 }
924 
925 HWTEST_F(DhcpClientStateMachineTest, SetDefaultNetMaskTest, TestSize.Level1)
926 {
927     DHCP_LOGI("SetDefaultNetMaskTest enter!");
928     struct DhcpIpResult result;
929 
930     dhcpClient->SetDefaultNetMask(nullptr);
931 
932     result.strOptSubnet[0] = 0;
933     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "8.168.0.8");
934     dhcpClient->SetDefaultNetMask(&result);
935 
936     result.strOptSubnet[0] = 0;
937     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "88.168.0.8");
938     dhcpClient->SetDefaultNetMask(&result);
939 
940     result.strOptSubnet[0] = 0;
941     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "127.168.0.8");
942     dhcpClient->SetDefaultNetMask(&result);
943 
944     result.strOptSubnet[0] = 0;
945     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "191.168.0.8");
946     dhcpClient->SetDefaultNetMask(&result);
947 
948     result.strOptSubnet[0] = 0;
949     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "223.168.0.8");
950     dhcpClient->SetDefaultNetMask(&result);
951 
952     result.strOptSubnet[0] = 0;
953     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "225.168.0.8");
954     dhcpClient->SetDefaultNetMask(&result);
955 
956     result.strOptSubnet[0] = 0;
957     strcpy_s(result.strYiaddr, sizeof(result.strYiaddr), "240.168.0.8");
958     dhcpClient->SetDefaultNetMask(&result);
959     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
960 }
961 
962 HWTEST_F(DhcpClientStateMachineTest, RebootTest, TestSize.Level1)
963 {
964     DHCP_LOGI("RebootTest enter!");
965     time_t timestamp = 1;
966     dhcpClient->Reboot(timestamp);
967 
968     dhcpClient->m_routerCfg.bssid = "wlan0";
969     dhcpClient->Reboot(timestamp);
970     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
971 }
972 
973 HWTEST_F(DhcpClientStateMachineTest, ExecDhcpReleaseTest, TestSize.Level1)
974 {
975     DHCP_LOGI("ExecDhcpReleaseTest enter!");
976     dhcpClient->m_dhcp4State = DHCP_STATE_BOUND;
977     dhcpClient->ExecDhcpRelease();
978 
979     dhcpClient->m_dhcp4State = DHCP_STATE_RENEWING;
980     dhcpClient->ExecDhcpRelease();
981 
982     dhcpClient->m_dhcp4State = DHCP_STATE_REBINDING;
983     dhcpClient->ExecDhcpRelease();
984 
985     dhcpClient->m_dhcp4State = DHCP_STATE_INIT;
986     dhcpClient->ExecDhcpRelease();
987     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
988 }
989 
990 HWTEST_F(DhcpClientStateMachineTest, InitSelectingTest, TestSize.Level1)
991 {
992     DHCP_LOGI("InitSelectingTest enter!");
993     time_t timestamp = 1;
994     dhcpClient->m_sentPacketNum = TIMEOUT_TIMES_MAX + 1;
995     dhcpClient->InitSelecting(timestamp);
996     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
997 }
998 
999 HWTEST_F(DhcpClientStateMachineTest, DecliningTest, TestSize.Level1)
1000 {
1001     DHCP_LOGI("DecliningTest enter!");
1002     time_t timestamp = 1;
1003     dhcpClient->Declining(timestamp);
1004 
1005     dhcpClient->m_conflictCount = THREE;
1006     dhcpClient->Declining(timestamp);
1007     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
1008 }
1009 
1010 HWTEST_F(DhcpClientStateMachineTest, GetDhcpOfferTest, TestSize.Level1)
1011 {
1012     DHCP_LOGI("GetDhcpOfferTest enter!");
1013     DhcpPacket packet;
1014     time_t timestamp = 1;
1015     dhcpClient->GetDhcpOffer(nullptr, timestamp);
1016 
1017     dhcpClient->GetDhcpOffer(&packet, timestamp);
1018     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
1019 }
1020 
1021 HWTEST_F(DhcpClientStateMachineTest, SetSecondsElapsedTest, TestSize.Level1)
1022 {
1023     DHCP_LOGI("SetSecondsElapsedTest enter!");
1024     DhcpPacket packet;
1025     dhcpClient->SetSecondsElapsed(nullptr);
1026     dhcpClient->SetSecondsElapsed(&packet);
1027     EXPECT_NE(packet.secs, TWO);
1028 }
1029 }
1030 }
1031 
1032