• 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->StopIpv4();
55             dhcpClient.reset(nullptr);
56         }
57         DhcpTimer::GetInstance()->timer_.reset();
58     }
SetUp()59     virtual void SetUp()
60     {
61         dhcpClient->threadExit_ = false;
62     }
TearDown()63     virtual void TearDown()
64     {
65         dhcpClient->StopIpv4();
66         MockCustomFunc::GetInstance().SetMockFlag(false);
67         MockSystemFunc::GetInstance().SetMockFlag(false);
68     }
69 };
70 
71 HWTEST_F(DhcpClientStateMachineTest, ExecDhcpRenew_SUCCESS, TestSize.Level0)
72 {
73     DHCP_LOGE("enter ExecDhcpRenew_SUCCESS");
74     MockSystemFunc::SetMockFlag(true);
75 
76     EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0));
77 
78     dhcpClient->SetIpv4State(DHCP_STATE_INIT);
79     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
80     dhcpClient->SetIpv4State(DHCP_STATE_REQUESTING);
81     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
82     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
83     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
84     dhcpClient->SetIpv4State(DHCP_STATE_RENEWING);
85     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
86     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
87     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExecDhcpRenew());
88     MockSystemFunc::SetMockFlag(false);
89 }
90 
91 HWTEST_F(DhcpClientStateMachineTest, TEST_FAILED, TestSize.Level0)
92 {
93     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->SetIpv4State(-1));
94     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketHeaderInfo(NULL, 0));
95     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetPacketCommonInfo(NULL));
96 }
97 /**
98  * @tc.name: PublishDhcpResultEvent_Fail1
99  * @tc.desc: PublishDhcpResultEvent()
100  * @tc.type: FUNC
101  * @tc.require: issue
102 */
103 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail1, TestSize.Level0)
104 {
105     DhcpIpResult result;
106     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(nullptr, PUBLISH_CODE_SUCCESS, &result));
107 }
108 /**
109  * @tc.name: PublishDhcpResultEvent_Fail2
110  * @tc.desc: PublishDhcpResultEvent()
111  * @tc.type: FUNC
112  * @tc.require: issue
113 */
114 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail2, TestSize.Level0)
115 {
116     DhcpIpResult result;
117     char ifname[] = "testcode//";
118     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, DHCP_HWADDR_LENGTH, &result));
119 }
120 /**
121  * @tc.name: PublishDhcpResultEvent_Fail3
122  * @tc.desc: PublishDhcpResultEvent()
123  * @tc.type: FUNC
124  * @tc.require: issue
125 */
126 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail3, TestSize.Level0)
127 {
128     DhcpIpResult *result = NULL;
129     char ifname[] = "testcode//";
130     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, result));
131 }
132 /**
133  * @tc.name: PublishDhcpResultEvent_Fail4
134  * @tc.desc: PublishDhcpResultEvent()
135  * @tc.type: FUNC
136  * @tc.require: issue
137 */
138 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail4, TestSize.Level0)
139 {
140     DhcpIpResult result;
141     char ifname[] = "testcode//";
142     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_SUCCESS, &result));
143 }
144 /**
145  * @tc.name: PublishDhcpResultEvent_Fail5
146  * @tc.desc: PublishDhcpResultEvent()
147  * @tc.type: FUNC
148  * @tc.require: issue
149 */
150 HWTEST_F(DhcpClientStateMachineTest, PublishDhcpResultEvent_Fail5, TestSize.Level0)
151 {
152     DhcpIpResult result;
153     char ifname[] = "testcode//";
154     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->PublishDhcpResultEvent(ifname, PUBLISH_CODE_FAILED, &result));
155 }
156 /**
157  * @tc.name: ParseNetworkVendorInfo_Fail1
158  * @tc.desc: ParseNetworkVendorInfo()
159  * @tc.type: FUNC
160  * @tc.require: issue
161 */
162 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail1, TestSize.Level0)
163 {
164     struct DhcpPacket *packet = nullptr;
165     DhcpIpResult result;
166     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, &result));
167 }
168 /**
169  * @tc.name: ParseNetworkVendorInfo_Fail2
170  * @tc.desc: ParseNetworkVendorInfo()
171  * @tc.type: FUNC
172  * @tc.require: issue
173 */
174 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail2, TestSize.Level0)
175 {
176     struct DhcpPacket packet;
177     DhcpIpResult *result = nullptr;
178     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(&packet, result));
179 }
180 /**
181  * @tc.name: ParseNetworkVendorInfo_Fail3
182  * @tc.desc: ParseNetworkVendorInfo()
183  * @tc.type: FUNC
184  * @tc.require: issue
185 */
186 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail3, TestSize.Level0)
187 {
188     struct DhcpPacket *packet = nullptr;
189     DhcpIpResult *result = nullptr;
190     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->ParseNetworkVendorInfo(packet, result));
191 }
192 
193 /**
194  * @tc.name: ParseNetworkVendorInfo_Fail4
195  * @tc.desc: ParseNetworkVendorInfo()
196  * @tc.type: FUNC
197  * @tc.require: issue
198 */
199 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail4, TestSize.Level0)
200 {
201     struct DhcpPacket packet;
202     struct DhcpIpResult result;
203     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
204     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
205 }
206 
207 /**
208  * @tc.name: ParseNetworkVendorInfo_Fail5
209  * @tc.desc: ParseNetworkVendorInfo()
210  * @tc.type: FUNC
211  * @tc.require: issue
212 */
213 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkVendorInfo_Fail5, TestSize.Level0)
214 {
215     char buf[VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES] = {0};
216     ASSERT_TRUE(snprintf_s(buf,
217                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX,
218                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX - 1,
219                     "%s-%s",
220                     DHCPC_NAME,
221                     DHCPC_VERSION) >= 0);
222 
223     struct DhcpPacket packet;
224     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
225 
226     uint8_t *pOption = packet.options;
227     pOption[DHCP_OPT_CODE_INDEX] = VENDOR_SPECIFIC_INFO_OPTION;
228     pOption[DHCP_OPT_LEN_INDEX] = strlen(buf);
229     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX,
230                     VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES,
231                     buf,
232                     strlen(buf)) == EOK);
233 
234     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
235     pOption[endIndex] = END_OPTION;
236 
237     struct DhcpIpResult result;
238     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ParseNetworkVendorInfo(&packet, &result));
239 }
240 
241 /**
242  * @tc.name: GetDHCPServerHostName_Fail1
243  * @tc.desc: GetDHCPServerHostName()
244  * @tc.type: FUNC
245  * @tc.require: issue
246 */
247 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail1, TestSize.Level0)
248 {
249     struct DhcpPacket *packet = nullptr;
250     DhcpIpResult result;
251     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, &result));
252 }
253 
254 /**
255  * @tc.name: GetDHCPServerHostName_Fail2
256  * @tc.desc: GetDHCPServerHostName()
257  * @tc.type: FUNC
258  * @tc.require: issue
259 */
260 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail2, TestSize.Level0)
261 {
262     struct DhcpPacket packet;
263     DhcpIpResult *result = nullptr;
264     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(&packet, result));
265 }
266 
267 /**
268  * @tc.name: GetDHCPServerHostName_Fail3
269  * @tc.desc: GetDHCPServerHostName()
270  * @tc.type: FUNC
271  * @tc.require: issue
272 */
273 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Fail3, TestSize.Level0)
274 {
275     struct DhcpPacket *packet = nullptr;
276     DhcpIpResult *result = nullptr;
277     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->GetDHCPServerHostName(packet, result));
278 }
279 
280 /**
281  * @tc.name: GetDHCPServerHostName_Success
282  * @tc.desc: GetDHCPServerHostName()
283  * @tc.type: FUNC
284  * @tc.require: issue
285 */
286 HWTEST_F(DhcpClientStateMachineTest, GetDHCPServerHostName_Success, TestSize.Level0)
287 {
288     struct DhcpPacket packet;
289     struct DhcpIpResult result;
290     strcpy_s((char*)packet.sname, sizeof(packet.sname), "testcode");
291     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetDHCPServerHostName(&packet, &result));
292 }
293 
294 HWTEST_F(DhcpClientStateMachineTest, SetSocketModeTest, TestSize.Level0)
295 {
296     DHCP_LOGE("SetSocketModeTest enter!");
297     dhcpClient->SetSocketMode(1);
298     EXPECT_FALSE(g_errLog.find("processWiTasDecisiveMessage")!=std::string::npos);
299 }
300 
301 HWTEST_F(DhcpClientStateMachineTest, SendRebootTest, TestSize.Level0)
302 {
303     DHCP_LOGE("SendRebootTest enter!");
304     dhcpClient->SendReboot(1, 1);
305     EXPECT_EQ(1, dhcpClient->m_requestedIp4);
306 }
307 
308 HWTEST_F(DhcpClientStateMachineTest, GetPacketReadSockFdTest, TestSize.Level0)
309 {
310     DHCP_LOGE("GetPacketReadSockFdTest enter!");
311     dhcpClient->GetPacketReadSockFd();
312     EXPECT_EQ(-1, dhcpClient->m_sockFd);
313 }
314 
315 HWTEST_F(DhcpClientStateMachineTest, GetSigReadSockFdTest, TestSize.Level0)
316 {
317     DHCP_LOGE("GetSigReadSockFdTest enter!");
318     dhcpClient->GetSigReadSockFd();
319     EXPECT_EQ(0, dhcpClient->m_sigSockFds[0]);
320 }
321 
322 HWTEST_F(DhcpClientStateMachineTest, GetDhcpTransIDTest, TestSize.Level0)
323 {
324     DHCP_LOGE("GetDhcpTransIDTest enter!");
325     dhcpClient->GetDhcpTransID();
326     EXPECT_EQ(0, dhcpClient->m_transID);
327 }
328 
329 HWTEST_F(DhcpClientStateMachineTest, GetPacketHeaderInfoTest, TestSize.Level0)
330 {
331     struct DhcpPacket packet;
332     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_NAK));
333     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->GetPacketHeaderInfo(&packet, DHCP_FORCERENEW));
334 }
335 
336 HWTEST_F(DhcpClientStateMachineTest, ExitIpv4Test, TestSize.Level0)
337 {
338     DHCP_LOGI("ExitIpv4Test enter!");
339     dhcpClient->ExitIpv4();
340     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->ExitIpv4());
341 }
342 
343 HWTEST_F(DhcpClientStateMachineTest, StopIpv4Test, TestSize.Level0)
344 {
345     DHCP_LOGI("StopIpv4Test enter!");
346     dhcpClient->StopIpv4();
347     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->StopIpv4());
348 }
349 
350 HWTEST_F(DhcpClientStateMachineTest, DhcpInitTest, TestSize.Level0)
351 {
352     DHCP_LOGI("DhcpInitTest enter!");
353     dhcpClient->DhcpInit();
354     EXPECT_EQ(DHCP_STATE_INIT, dhcpClient->m_dhcp4State);
355 }
356 
357 HWTEST_F(DhcpClientStateMachineTest, RenewingTest, TestSize.Level0)
358 {
359     DHCP_LOGI("RenewingTest enter!");
360     time_t curTimestamp = time(NULL);
361     dhcpClient->Renewing(curTimestamp);
362 
363     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES + 1;
364     dhcpClient->Renewing(curTimestamp);
365 
366     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES - 1;
367     dhcpClient->Renewing(curTimestamp);
368     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
369 }
370 
371 HWTEST_F(DhcpClientStateMachineTest, RebindingTest, TestSize.Level0)
372 {
373     DHCP_LOGI("RebindingTest enter!");
374     time_t curTimestamp = time(NULL);
375     dhcpClient->Rebinding(curTimestamp);
376 
377     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES + 1;
378     dhcpClient->Rebinding(curTimestamp);
379 
380     dhcpClient->m_sentPacketNum = MAX_WAIT_TIMES - 1;
381     dhcpClient->Rebinding(curTimestamp);
382 
383     dhcpClient->m_dhcp4State = DHCP_STATE_REBINDING;
384     dhcpClient->Rebinding(curTimestamp);
385     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
386 }
387 
388 HWTEST_F(DhcpClientStateMachineTest, DhcpRequestHandleTest, TestSize.Level0)
389 {
390     DHCP_LOGI("DhcpRequestHandleTest enter!");
391     time_t curTimestamp = time(NULL);
392 
393     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
394     dhcpClient->DhcpRequestHandle(curTimestamp);
395 
396     dhcpClient->SetIpv4State(DHCP_STATE_INITREBOOT);
397     dhcpClient->DhcpRequestHandle(curTimestamp);
398 
399     dhcpClient->SetIpv4State(DHCP_STATE_RELEASED);
400     dhcpClient->DhcpRequestHandle(curTimestamp);
401 
402     dhcpClient->SetIpv4State(DHCP_STATE_RENEWED);
403     dhcpClient->DhcpRequestHandle(curTimestamp);
404 
405     dhcpClient->SetIpv4State(DHCP_STATE_REBINDING);
406     dhcpClient->DhcpRequestHandle(curTimestamp);
407 
408     dhcpClient->SetIpv4State(DHCP_STATE_FAST_ARP);
409     dhcpClient->DhcpRequestHandle(curTimestamp);
410 
411     dhcpClient->SetIpv4State(DHCP_STATE_SLOW_ARP);
412     dhcpClient->DhcpRequestHandle(curTimestamp);
413 
414     dhcpClient->SetIpv4State(DHCP_STATE_DECLINE);
415     dhcpClient->DhcpRequestHandle(curTimestamp);
416 
417     dhcpClient->SetIpv4State(INVALID);
418     dhcpClient->DhcpRequestHandle(curTimestamp);
419     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
420 }
421 
422 HWTEST_F(DhcpClientStateMachineTest, DhcpAckOrNakPacketHandleTest, TestSize.Level0)
423 {
424     DHCP_LOGI("DhcpAckOrNakPacketHandleTest enter!");
425     struct DhcpPacket *packet = nullptr;
426     uint8_t type = DHCP_REQUEST;
427     time_t curTimestamp = time(NULL);
428     dhcpClient->DhcpAckOrNakPacketHandle(type, packet, curTimestamp);
429 
430     type = DHCP_NAK;
431     DhcpPacket packet1;
432     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet1, curTimestamp);
433     dhcpClient->DhcpAckOrNakPacketHandle(type, nullptr, curTimestamp);
434 
435     type = DHCP_ACK;
436     DhcpPacket packet2;
437     dhcpClient->SetIpv4State(DHCP_STATE_BOUND);
438     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet2, curTimestamp);
439 
440     DhcpPacket packet3;
441     type = DHCP_REQUEST;
442     dhcpClient->DhcpAckOrNakPacketHandle(type, &packet3, curTimestamp);
443     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
444 }
445 
446 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpAckPacketTest, TestSize.Level0)
447 {
448     DHCP_LOGI("ParseDhcpAckPacketTest enter!");
449     struct DhcpPacket *packet = nullptr;
450     time_t curTimestamp = time(NULL);
451     dhcpClient->ParseDhcpAckPacket(packet, curTimestamp);
452 
453     DhcpPacket packet1;
454     dhcpClient->ParseDhcpAckPacket(&packet1, curTimestamp);
455     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
456 }
457 
458 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkInfoTest, TestSize.Level0)
459 {
460     DHCP_LOGI("ParseNetworkInfoTest enter!");
461     struct DhcpPacket *packet = nullptr;
462     struct DhcpIpResult *result = nullptr;
463     dhcpClient->ParseNetworkInfo(packet, result);
464 
465     DhcpPacket *packet1 = nullptr;
466     DhcpIpResult result1;
467     dhcpClient->ParseNetworkInfo(packet1, &result1);
468 
469     DhcpPacket packet2;
470     DhcpIpResult *result2 = nullptr;
471     dhcpClient->ParseNetworkInfo(&packet2, result2);
472 
473     DhcpPacket packet3;
474     DhcpIpResult result3;
475     dhcpClient->ParseNetworkInfo(&packet3, &result3);
476     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
477 }
478 
479 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkDnsInfoTest, TestSize.Level0)
480 {
481     DHCP_LOGI("ParseNetworkDnsInfoTest enter!");
482     struct DhcpPacket *packet = nullptr;
483     struct DhcpIpResult *result = nullptr;
484     dhcpClient->ParseNetworkDnsInfo(packet, result);
485 
486     DhcpPacket *packet1 = nullptr;
487     DhcpIpResult result1;
488     dhcpClient->ParseNetworkDnsInfo(packet1, &result1);
489 
490     DhcpPacket packet2;
491     DhcpIpResult *result2 = nullptr;
492     dhcpClient->ParseNetworkDnsInfo(&packet2, result2);
493 
494     DhcpPacket packet3;
495     DhcpIpResult result3;
496     dhcpClient->ParseNetworkDnsInfo(&packet3, &result3);
497     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
498 }
499 
500 HWTEST_F(DhcpClientStateMachineTest, DhcpOfferPacketHandleTest, TestSize.Level0)
501 {
502     DHCP_LOGI("DhcpOfferPacketHandleTest enter!");
503     struct DhcpPacket *packet = nullptr;
504     uint8_t type = DHCP_REQUEST;
505     time_t curTimestamp = time(NULL);
506     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
507 
508     type = DHCP_OFFER;
509     dhcpClient->DhcpOfferPacketHandle(type, packet, curTimestamp);
510 
511     DhcpPacket packet1;
512     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
513 
514     packet1.yiaddr = 3226272232;
515     dhcpClient->DhcpOfferPacketHandle(type, &packet1, curTimestamp);
516     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
517 }
518 
519 HWTEST_F(DhcpClientStateMachineTest, DhcpRebootTest, TestSize.Level0)
520 {
521     DHCP_LOGE("DhcpRebootTest enter!");
522     EXPECT_NE(SOCKET_OPT_ERROR, dhcpClient->DhcpReboot(1, 1));
523 }
524 
525 HWTEST_F(DhcpClientStateMachineTest, StartIpv4TypeTest, TestSize.Level0)
526 {
527     DHCP_LOGI("StartIpv4TypeTest enter!");
528     std::string ifname;
529     bool isIpv6 = true;
530     ActionMode action = ACTION_START_NEW;
531     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->StartIpv4Type(ifname, isIpv6, action));
532 }
533 
534 HWTEST_F(DhcpClientStateMachineTest, FormatStringTest, TestSize.Level0)
535 {
536     DHCP_LOGI("FormatStringTest enter!");
537     struct DhcpIpResult *result = nullptr;
538     dhcpClient->FormatString(result);
539 
540     DhcpIpResult result1;
541     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "");
542     dhcpClient->FormatString(&result1);
543 
544     strcpy_s(result1.strYiaddr, sizeof(result1.strYiaddr), "192.168.0.1");
545     dhcpClient->FormatString(&result1);
546 
547     DhcpIpResult result2;
548     strcpy_s(result2.strOptServerId, sizeof(result2.strOptServerId), "");
549     dhcpClient->FormatString(&result2);
550 
551     strcpy_s(result2.strYiaddr, sizeof(result2.strYiaddr), "192.168.0.2");
552     dhcpClient->FormatString(&result2);
553 
554     DhcpIpResult result3;
555     strcpy_s(result3.strOptSubnet, sizeof(result3.strOptSubnet), "");
556     dhcpClient->FormatString(&result3);
557 
558     strcpy_s(result3.strYiaddr, sizeof(result3.strYiaddr), "192.168.0.3");
559     dhcpClient->FormatString(&result3);
560 
561     DhcpIpResult result4;
562     strcpy_s(result4.strOptDns1, sizeof(result4.strOptDns1), "");
563     dhcpClient->FormatString(&result4);
564 
565     strcpy_s(result4.strYiaddr, sizeof(result4.strYiaddr), "192.168.0.");
566     dhcpClient->FormatString(&result4);
567 
568     DhcpIpResult result5;
569     strcpy_s(result5.strOptDns2, sizeof(result5.strOptDns2), "");
570     dhcpClient->FormatString(&result5);
571 
572     strcpy_s(result5.strYiaddr, sizeof(result5.strYiaddr), "192.168.0.5");
573     dhcpClient->FormatString(&result5);
574 
575     DhcpIpResult result6;
576     strcpy_s(result6.strOptRouter1, sizeof(result6.strOptRouter1), "");
577     dhcpClient->FormatString(&result6);
578 
579     strcpy_s(result6.strYiaddr, sizeof(result6.strYiaddr), "192.168.0.6");
580     dhcpClient->FormatString(&result6);
581 
582     DhcpIpResult result7;
583     strcpy_s(result7.strOptRouter2, sizeof(result7.strOptRouter2), "");
584     dhcpClient->FormatString(&result7);
585 
586     strcpy_s(result7.strYiaddr, sizeof(result7.strYiaddr), "192.168.0.7");
587     dhcpClient->FormatString(&result7);
588 
589     DhcpIpResult result8;
590     strcpy_s(result8.strOptVendor, sizeof(result8.strOptVendor), "");
591     dhcpClient->FormatString(&result8);
592 
593     strcpy_s(result8.strYiaddr, sizeof(result8.strYiaddr), "192.168.0.8");
594     dhcpClient->FormatString(&result8);
595     EXPECT_EQ(nullptr, result);
596 }
597 
598 HWTEST_F(DhcpClientStateMachineTest, RequestingTest, TestSize.Level0)
599 {
600     DHCP_LOGI("RequestingTest enter!");
601     time_t curTimestamp = time(NULL);
602     dhcpClient->m_sentPacketNum = 16;
603     dhcpClient->SetIpv4State(DHCP_STATE_RENEWED);
604     dhcpClient->Requesting(curTimestamp);
605     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
606 }
607 
608 HWTEST_F(DhcpClientStateMachineTest, RequestingTest1, TestSize.Level0)
609 {
610     DHCP_LOGI("RequestingTest1 enter!");
611     time_t timestamp = 1;
612     dhcpClient->m_sentPacketNum = TIMEOUT_TIMES_MAX + 1;
613     dhcpClient->Requesting(timestamp);
614 
615     dhcpClient->m_sentPacketNum = TWO;
616     dhcpClient->m_dhcp4State = DHCP_STATE_RENEWED;
617     dhcpClient->Requesting(timestamp);
618 
619     dhcpClient->m_dhcp4State = DHCP_STATE_RELEASED;
620     dhcpClient->Requesting(timestamp);
621     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
622 }
623 
624 HWTEST_F(DhcpClientStateMachineTest, AddHostNameToOptsTest, TestSize.Level0)
625 {
626     DHCP_LOGI("AddHostNameToOptsTest enter!");
627     struct DhcpPacket packet;
628     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
629     packet.options[0] = END_OPTION;
630     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddHostNameToOpts(nullptr));
631     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddHostNameToOpts(&packet));
632 }
633 
634 HWTEST_F(DhcpClientStateMachineTest, AddStrToOptsTest, TestSize.Level0)
635 {
636     DHCP_LOGI("AddStrToOptsTest enter!");
637     int option = 12;
638     std::string value = "ALN-AL80";
639     struct DhcpPacket packet;
640     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
641     packet.options[0] = END_OPTION;
642     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddStrToOpts(nullptr, option, value));
643     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddStrToOpts(&packet, option, value));
644 }
645 
646 HWTEST_F(DhcpClientStateMachineTest, InitSignalHandleTest, TestSize.Level0)
647 {
648     DHCP_LOGI("InitSignalHandleTest enter!");
649     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->InitSignalHandle());
650 }
651 
652 HWTEST_F(DhcpClientStateMachineTest, CloseSignalHandleTest, TestSize.Level0)
653 {
654     DHCP_LOGI("CloseSignalHandleTest enter!");
655     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->CloseSignalHandle());
656 }
657 
658 HWTEST_F(DhcpClientStateMachineTest, AddClientIdToOptsTest, TestSize.Level0)
659 {
660     DHCP_LOGI("AddClientIdToOpts enter!");
661     struct DhcpPacket packet;
662     memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket));
663     packet.options[0] = END_OPTION;
664     EXPECT_EQ(DHCP_OPT_FAILED, dhcpClient->AddClientIdToOpts(nullptr));
665     EXPECT_EQ(DHCP_OPT_SUCCESS, dhcpClient->AddClientIdToOpts(&packet));
666 }
667 
668 HWTEST_F(DhcpClientStateMachineTest, ParseDhcpNakPacketTest, TestSize.Level0)
669 {
670     DHCP_LOGI("ParseDhcpNakPacket enter!");
671     struct DhcpPacket *packet = nullptr;
672     time_t curTimestamp = time(nullptr);
673     dhcpClient->ParseDhcpNakPacket(packet, curTimestamp);
674     DhcpPacket packet1;
675     dhcpClient->m_resendTimer = ZERO;
676     dhcpClient->ParseDhcpNakPacket(&packet1, curTimestamp);
677     EXPECT_EQ(dhcpClient->m_resendTimer, FIRST_TIMEOUT_SEC);
678 }
679 
680 HWTEST_F(DhcpClientStateMachineTest, ParseNetworkServerIdInfoTest, TestSize.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
856 {
857     DHCP_LOGI("GetIpTimerCallbackTest enter!");
858     dhcpClient->GetIpTimerCallback();
859     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
860 }
861 
862 HWTEST_F(DhcpClientStateMachineTest, GetIpTimerCallbackTest1, TestSize.Level0)
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.Level0)
881 {
882     DHCP_LOGI("RenewDelayCallbackTest enter!");
883     dhcpClient->RenewDelayCallback();
884     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
885 }
886 
887 HWTEST_F(DhcpClientStateMachineTest, RebindDelayCallbackTest, TestSize.Level0)
888 {
889     DHCP_LOGI("RebindDelayCallbackTest enter!");
890     dhcpClient->RebindDelayCallback();
891     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
892 }
893 
894 HWTEST_F(DhcpClientStateMachineTest, RemainingDelayCallbackTest, TestSize.Level0)
895 {
896     DHCP_LOGI("RemainingDelayCallbackTest enter!");
897     dhcpClient->RemainingDelayCallback();
898     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
899 }
900 
901 HWTEST_F(DhcpClientStateMachineTest, ScheduleLeaseTimersTest, TestSize.Level0)
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.Level0)
910 {
911     DHCP_LOGI("CloseAllRenewTimerTest enter!");
912     dhcpClient->CloseAllRenewTimer();
913     EXPECT_EQ(DHCP_OPT_SUCCESS, ZERO);
914 }
915 
916 HWTEST_F(DhcpClientStateMachineTest, SetIpv4DefaultDnsTest, TestSize.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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