• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <gtest/gtest.h>
16 
17 #include "wifi_log.h"
18 #include "dhcp_options.h"
19 #include "dhcp_client.h"
20 #include "securec.h"
21 
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 using namespace testing::ext;
27 
28 namespace OHOS {
29 class DhcpOptionsTest : public testing::Test {
30 public:
SetUpTestCase()31     static void SetUpTestCase()
32     {}
TearDownTestCase()33     static void TearDownTestCase()
34     {}
SetUp()35     virtual void SetUp()
36     {}
TearDown()37     virtual void TearDown()
38     {}
39 };
40 
41 HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_SUCCESS, TestSize.Level1)
42 {
43     EXPECT_GT(GetDhcpOptionDataLen(DHCP_MESSAGE_TYPE_OPTION), 0);
44 }
45 
46 HWTEST_F(DhcpOptionsTest, GetDhcpOptionDataLen_FAILED, TestSize.Level1)
47 {
48     EXPECT_EQ(GetDhcpOptionDataLen(PAD_OPTION), 0);
49     EXPECT_EQ(GetDhcpOptionDataLen(CLIENT_IDENTIFIER_OPTION), 0);
50     EXPECT_EQ(GetDhcpOptionDataLen(DOMAIN_NAME_SERVER_OPTION), 0);
51 }
52 
53 HWTEST_F(DhcpOptionsTest, GetDhcpOption_SUCCESS, TestSize.Level1)
54 {
55     struct DhcpPacket packet;
56     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
57 
58     int endIndex = 0;
59     uint8_t *pOption = packet.options;
60     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
61     endIndex += DHCP_OPT_CODE_BYTES;
62 
63     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
64     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
65     uint32_t u32Data = 3226272231;
66     ASSERT_TRUE(
67         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
68     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
69 
70     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
71     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
72     uint8_t uData = DHCP_DISCOVER;
73     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
74     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
75 
76     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
77 
78     size_t len = 0;
79     EXPECT_NE(GetDhcpOption(&packet, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
80 }
81 
82 HWTEST_F(DhcpOptionsTest, GetDhcpOption_FAILED, TestSize.Level1)
83 {
84     size_t len = 0;
85     EXPECT_EQ(GetDhcpOption(nullptr, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
86 
87     struct DhcpPacket packet;
88     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
89 
90     int endIndex = 0;
91     uint8_t *pOption = packet.options;
92     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
93     endIndex += DHCP_OPT_CODE_BYTES;
94 
95     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
96     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
97     uint32_t u32Data = 3226272231;
98     ASSERT_TRUE(
99         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
100     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
101 
102     pOption[endIndex + DHCP_OPT_CODE_INDEX] = OPTION_OVERLOAD_OPTION;
103     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
104     uint8_t uData = FILE_FIELD | SNAME_FIELD;
105     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
106     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
107 
108     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
109 
110     len = 0;
111     EXPECT_EQ(GetDhcpOption(&packet, DHCP_MESSAGE_TYPE_OPTION, &len), nullptr);
112 }
113 
114 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_SUCCESS, TestSize.Level1)
115 {
116     struct DhcpPacket packet;
117     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
118 
119     uint8_t *pOption = packet.options;
120     pOption[DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
121     pOption[DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
122     uint8_t uData = DHCP_DISCOVER;
123     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
124 
125     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
126     pOption[endIndex] = END_OPTION;
127 
128     uint8_t u8Message = 0;
129     EXPECT_EQ(true, GetDhcpOptionUint8(&packet, DHCP_MESSAGE_TYPE_OPTION, &u8Message));
130 }
131 
132 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint8_FAILED, TestSize.Level1)
133 {
134     uint8_t u8Message = 0;
135     EXPECT_EQ(false, GetDhcpOptionUint8(nullptr, DHCP_MESSAGE_TYPE_OPTION, &u8Message));
136 }
137 
138 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_SUCCESS, TestSize.Level1)
139 {
140     struct DhcpPacket packet;
141     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
142 
143     int endIndex = 0;
144     uint8_t *pOption = packet.options;
145     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
146     endIndex += DHCP_OPT_CODE_BYTES;
147 
148     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
149     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
150     uint8_t uData = DHCP_DISCOVER;
151     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
152     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
153 
154     pOption[endIndex + DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
155     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
156     uint32_t u32Data = ONE_HOURS_SEC;
157     ASSERT_TRUE(
158         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
159     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
160 
161     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
162 
163     u32Data = 0;
164     EXPECT_EQ(true, GetDhcpOptionUint32(&packet, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
165 }
166 
167 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32_FAILED, TestSize.Level1)
168 {
169     uint32_t u32Data = 0;
170     EXPECT_EQ(false, GetDhcpOptionUint32(nullptr, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
171 
172     struct DhcpPacket packet;
173     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
174 
175     int endIndex = 0;
176     uint8_t *pOption = packet.options;
177     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
178     endIndex += DHCP_OPT_CODE_BYTES;
179 
180     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
181     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
182     uint8_t uData = DHCP_DISCOVER;
183     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
184     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
185 
186     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
187 
188     u32Data = 0;
189     EXPECT_EQ(false, GetDhcpOptionUint32(&packet, DHCP_MESSAGE_TYPE_OPTION, &u32Data));
190 
191     pOption[endIndex + DHCP_OPT_CODE_INDEX] = OPTION_OVERLOAD_OPTION;
192     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
193     uData = FILE_FIELD | SNAME_FIELD;
194     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
195     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
196 
197     pOption[endIndex + DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
198     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
199     u32Data = ONE_HOURS_SEC;
200     ASSERT_TRUE(
201         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
202     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
203 
204     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
205 
206     u32Data = 0;
207     EXPECT_EQ(false, GetDhcpOptionUint32(&packet, IP_ADDRESS_LEASE_TIME_OPTION, &u32Data));
208 }
209 
210 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_SUCCESS, TestSize.Level1)
211 {
212     struct DhcpPacket packet;
213     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
214 
215     int endIndex = 0;
216     uint8_t *pOption = packet.options;
217     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
218     endIndex += DHCP_OPT_CODE_BYTES;
219 
220     pOption[endIndex + DHCP_OPT_CODE_INDEX] = ROUTER_OPTION;
221     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES + DHCP_UINT32_BYTES;
222     uint32_t u32Data1 = 3226272231;
223     uint32_t u32Data2 = 3226272232;
224     ASSERT_TRUE(
225         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data1, DHCP_UINT32_BYTES) == EOK);
226     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX + DHCP_UINT32_BYTES,
227                     DHCP_UINT32_BYTES,
228                     &u32Data2,
229                     DHCP_UINT32_BYTES) == EOK);
230     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
231 
232     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
233 
234     uint32_t uData1 = 0;
235     uint32_t uData2 = 0;
236     EXPECT_EQ(true, GetDhcpOptionUint32n(&packet, ROUTER_OPTION, &uData1, &uData2));
237 }
238 
239 HWTEST_F(DhcpOptionsTest, GetDhcpOptionUint32n_FAILED, TestSize.Level1)
240 {
241     uint32_t uData1 = 0;
242     uint32_t uData2 = 0;
243     EXPECT_EQ(false, GetDhcpOptionUint32n(nullptr, ROUTER_OPTION, &uData1, &uData2));
244 
245     struct DhcpPacket packet;
246     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
247 
248     int endIndex = 0;
249     uint8_t *pOption = packet.options;
250     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
251     endIndex += DHCP_OPT_CODE_BYTES;
252 
253     pOption[endIndex + DHCP_OPT_CODE_INDEX] = DHCP_MESSAGE_TYPE_OPTION;
254     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT8_BYTES;
255     uint8_t uData = DHCP_DISCOVER;
256     ASSERT_TRUE(memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT8_BYTES, &uData, DHCP_UINT8_BYTES) == EOK);
257     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
258 
259     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
260 
261     EXPECT_EQ(false, GetDhcpOptionUint32n(nullptr, DHCP_MESSAGE_TYPE_OPTION, &uData1, &uData2));
262 }
263 
264 HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_SUCCESS, TestSize.Level1)
265 {
266     char buf[VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES] = {0};
267     ASSERT_TRUE(snprintf_s(buf,
268                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX,
269                     VENDOR_MAX_LEN - DHCP_OPT_DATA_INDEX - 1,
270                     "%s-%s",
271                     DHCPC_NAME,
272                     DHCPC_VERSION) >= 0);
273 
274     struct DhcpPacket packet;
275     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
276 
277     uint8_t *pOption = packet.options;
278     pOption[DHCP_OPT_CODE_INDEX] = VENDOR_SPECIFIC_INFO_OPTION;
279     pOption[DHCP_OPT_LEN_INDEX] = strlen(buf);
280     ASSERT_TRUE(memcpy_s(pOption + DHCP_OPT_DATA_INDEX,
281                     VENDOR_MAX_LEN - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES,
282                     buf,
283                     strlen(buf)) == EOK);
284 
285     int endIndex = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[DHCP_OPT_LEN_INDEX];
286     pOption[endIndex] = END_OPTION;
287 
288     char *pVendor = GetDhcpOptionString(&packet, VENDOR_SPECIFIC_INFO_OPTION);
289     ASSERT_TRUE(pVendor != NULL);
290     free(pVendor);
291 }
292 
293 HWTEST_F(DhcpOptionsTest, GetDhcpOptionString_FAILED, TestSize.Level1)
294 {
295     EXPECT_EQ(nullptr, GetDhcpOptionString(nullptr, VENDOR_SPECIFIC_INFO_OPTION));
296 }
297 
298 HWTEST_F(DhcpOptionsTest, GetEndOptionIndex_SUCCESS, TestSize.Level1)
299 {
300     struct DhcpPacket packet;
301     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
302 
303     int endIndex = 0;
304     uint8_t *pOption = packet.options;
305     pOption[endIndex + DHCP_OPT_CODE_INDEX] = PAD_OPTION;
306     endIndex += DHCP_OPT_CODE_BYTES;
307 
308     pOption[endIndex + DHCP_OPT_CODE_INDEX] = SUBNET_MASK_OPTION;
309     pOption[endIndex + DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
310     uint32_t u32Data = 3226272231;
311     ASSERT_TRUE(
312         memcpy_s(pOption + endIndex + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &u32Data, DHCP_UINT32_BYTES) == EOK);
313     endIndex += DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + pOption[endIndex + DHCP_OPT_LEN_INDEX];
314 
315     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
316 
317     EXPECT_GE(GetEndOptionIndex(packet.options), 0);
318 }
319 
320 HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_SUCCESS, TestSize.Level1)
321 {
322     struct DhcpPacket packet;
323     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
324     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
325 
326     uint8_t option[DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + DHCP_UINT32_BYTES];
327     option[DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
328     option[DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
329     uint32_t uData = ONE_HOURS_SEC;
330     ASSERT_TRUE(memcpy_s(option + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &uData, DHCP_UINT32_BYTES) == EOK);
331     int nLen = DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + option[DHCP_OPT_LEN_INDEX];
332 
333     EXPECT_GT(AddOptStrToOpts(packet.options, option, nLen), 0);
334 }
335 
336 HWTEST_F(DhcpOptionsTest, AddOptStrToOpts_FAILED, TestSize.Level1)
337 {
338     struct DhcpPacket packet;
339     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
340 
341     int endIndex = 0;
342     uint8_t *pOption = packet.options;
343     pOption[endIndex + DHCP_OPT_CODE_INDEX] = END_OPTION;
344 
345     uint8_t option[DHCP_OPT_CODE_BYTES + DHCP_OPT_LEN_BYTES + DHCP_UINT32_BYTES];
346     option[DHCP_OPT_CODE_INDEX] = IP_ADDRESS_LEASE_TIME_OPTION;
347     option[DHCP_OPT_LEN_INDEX] = DHCP_UINT32_BYTES;
348     uint32_t uData = ONE_HOURS_SEC;
349     ASSERT_TRUE(memcpy_s(option + DHCP_OPT_DATA_INDEX, DHCP_UINT32_BYTES, &uData, DHCP_UINT32_BYTES) == EOK);
350     EXPECT_EQ(AddOptStrToOpts(pOption, option, DHCP_OPT_CODE_BYTES), 0);
351 
352     option[DHCP_OPT_LEN_INDEX] = (uint8_t)(DHCP_OPTIONS_SIZE - DHCP_OPT_CODE_BYTES - DHCP_OPT_LEN_BYTES);
353     EXPECT_EQ(AddOptStrToOpts(pOption, option, DHCP_OPTIONS_SIZE), 0);
354 }
355 
356 HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_SUCCESS, TestSize.Level1)
357 {
358     struct DhcpPacket packet;
359     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
360     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
361 
362     uint8_t data1 = DHCP_REQUEST;
363     uint16_t data2 = 1;
364     uint32_t data3 = ONE_HOURS_SEC;
365     EXPECT_GT(AddOptValueToOpts(packet.options, DHCP_MESSAGE_TYPE_OPTION, data1), 0);
366     EXPECT_GT(AddOptValueToOpts(packet.options, INTERFACE_MTU_OPTION, data2), 0);
367     EXPECT_GT(AddOptValueToOpts(packet.options, IP_ADDRESS_LEASE_TIME_OPTION, data3), 0);
368 }
369 
370 HWTEST_F(DhcpOptionsTest, AddOptValueToOpts_FAILED, TestSize.Level1)
371 {
372     struct DhcpPacket packet;
373     ASSERT_TRUE(memset_s(&packet, sizeof(struct DhcpPacket), 0, sizeof(struct DhcpPacket)) == EOK);
374     packet.options[DHCP_OPT_CODE_INDEX] = END_OPTION;
375 
376     EXPECT_EQ(AddOptValueToOpts(packet.options, PAD_OPTION, 0), 0);
377 }
378 }  // namespace OHOS