• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 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 #include <gtest/gtest.h>
16 #include <gmock/gmock.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <cstddef>
20 #include <cstdint>
21 #include <sys/stat.h>
22 #include <sys/socket.h>
23 #include <linux/rtnetlink.h>
24 #include <netinet/in.h>
25 #include <arpa/inet.h>
26 #include "securec.h"
27 #include "dhcp_logger.h"
28 #include "dhcp_function.h"
29 #include "dhcp_ipv6_client.h"
30 
31 DEFINE_DHCPLOG_DHCP_LABEL("DhcpIpv6ClientTest");
32 
33 using ::testing::_;
34 using ::testing::AtLeast;
35 using ::testing::DoAll;
36 using ::testing::Eq;
37 using ::testing::Ref;
38 using ::testing::Return;
39 using ::testing::SetArgReferee;
40 using ::testing::StrEq;
41 using ::testing::TypedEq;
42 using ::testing::ext::TestSize;
43 
44 namespace OHOS {
45 namespace DHCP {
46 const int KERNEL_SOCKET_IFA_FAMILY = 10;
47 constexpr unsigned int IPV6_SCOPE_NODELOCAL = 0x01;
48 constexpr unsigned int IPV6_SCOPE_LINKLOCAL = 0x02;
49 constexpr unsigned int IPV6_SCOPE_SITELOCAL = 0x05;
50 constexpr unsigned int IPV6_SCOPE_OTHER = 0x08;
51 constexpr unsigned int PRE_FIX_LEN = 12;
52 constexpr unsigned int PRE_FIX_ADDRSTRLEN = 128;
53 constexpr int IPV6_RETURN_ZERO = 0x00000;
54 constexpr int IPV6_RETURN_65552 = 0x10010;
55 constexpr int IPV6_RETURN_131101 = 0x20020;
56 constexpr int IPV6_RETURN_1327744 = 0x50040;
57 constexpr int IPV6_RETURN_524288 = 0x80000;
58 constexpr int IPV6_RETURN_32 = 0x0020U;
59 constexpr int IPV6_OPT_FAILED = -1;
60 constexpr int IPV6_LEN_134 = 134;
61 constexpr int IPV6_LEN_24 = 24;
62 constexpr int IPV6_LEN_16 = 16;
63 constexpr int IPV6_LEN_10 = 10;
64 constexpr int BUF_LEN = 1024;
65 constexpr int BUF_LEN_2 = 2;
66 constexpr int DATA_SIZE = 8;
67 const std::string g_errLog = "DhcpTest";
68 class DhcpIpv6ClientTest : public testing::Test {
69 public:
SetUpTestCase()70     static void SetUpTestCase()
71     {
72     }
TearDownTestCase()73     static void TearDownTestCase()
74     {
75     }
SetUp()76     virtual void SetUp()
77     {
78         std::string ifname = "wlan0";
79         ipv6Client = std::make_unique<OHOS::DHCP::DhcpIpv6Client>(ifname);
80     }
TearDown()81     virtual void TearDown()
82     {
83         if (ipv6Client != nullptr) {
84             ipv6Client.reset(nullptr);
85         }
86     }
87 public:
88     std::unique_ptr<OHOS::DHCP::DhcpIpv6Client> ipv6Client;
89 };
90 
91 HWTEST_F(DhcpIpv6ClientTest, IsRunningTest, TestSize.Level1)
92 {
93     ASSERT_TRUE(ipv6Client != nullptr);
94     DHCP_LOGE("IsRunningTest enter!");
95     ipv6Client->IsRunning();
96 }
97 
98 HWTEST_F(DhcpIpv6ClientTest, DhcpIPV6StopTest, TestSize.Level1)
99 {
100     ASSERT_TRUE(ipv6Client != nullptr);
101     DHCP_LOGE("DhcpIPV6StopTest enter!");
102     ipv6Client->DhcpIPV6Stop();
103 }
104 
105 HWTEST_F(DhcpIpv6ClientTest, ResetTest, TestSize.Level1)
106 {
107     ASSERT_TRUE(ipv6Client != nullptr);
108     DHCP_LOGE("ResetTest enter!");
109     ipv6Client->Reset();
110 }
111 
112 HWTEST_F(DhcpIpv6ClientTest, ipv6AddrScope2TypeTest, TestSize.Level1)
113 {
114     ASSERT_TRUE(ipv6Client != nullptr);
115     DHCP_LOGE("ipv6AddrScope2TypeTest enter!");
116     EXPECT_EQ(IPV6_RETURN_65552, ipv6Client->ipv6AddrScope2Type(IPV6_SCOPE_NODELOCAL));
117     EXPECT_EQ(IPV6_RETURN_131101, ipv6Client->ipv6AddrScope2Type(IPV6_SCOPE_LINKLOCAL));
118     EXPECT_EQ(IPV6_RETURN_1327744, ipv6Client->ipv6AddrScope2Type(IPV6_SCOPE_SITELOCAL));
119     EXPECT_EQ(IPV6_RETURN_524288, ipv6Client->ipv6AddrScope2Type(IPV6_SCOPE_OTHER));
120 }
121 
122 HWTEST_F(DhcpIpv6ClientTest, getAddrTypeTest, TestSize.Level1)
123 {
124     ASSERT_TRUE(ipv6Client != nullptr);
125     DHCP_LOGE("getAddrTypeTest enter!");
126     struct in6_addr addr;
127     EXPECT_EQ(IPV6_RETURN_32, ipv6Client->GetAddrType(nullptr));
128     EXPECT_EQ(IPV6_RETURN_ZERO, ipv6Client->GetAddrType(&addr));
129 }
130 
131 HWTEST_F(DhcpIpv6ClientTest, getAddrTypeTest1, TestSize.Level1)
132 {
133     ASSERT_TRUE(ipv6Client != nullptr);
134     DHCP_LOGE("getAddrTypeTest1 enter!");
135     struct in6_addr addr;
136     ipv6Client->GetAddrType(&addr);
137 
138     inet_pton(AF_INET6, "2001:0db8:85a3:0000:0000:8a2e:0370:7334", &addr);
139     ipv6Client->GetAddrType(&addr);
140 
141     inet_pton(AF_INET6, "ff02:0000:0000:0000:0000:0000:0000:0001", &addr);
142     ipv6Client->GetAddrType(&addr);
143 
144     inet_pton(AF_INET6, "fe80::", &addr);
145     ipv6Client->GetAddrType(&addr);
146 
147     inet_pton(AF_INET6, "fec0::", &addr);
148     ipv6Client->GetAddrType(&addr);
149 
150     inet_pton(AF_INET6, "::", &addr);
151     ipv6Client->GetAddrType(&addr);
152 
153     inet_pton(AF_INET6, "::1", &addr);
154     ipv6Client->GetAddrType(&addr);
155 
156     inet_pton(AF_INET6, "::ffff:192.0.2.128", &addr);
157     ipv6Client->GetAddrType(&addr);
158 
159     inet_pton(AF_INET6, "::ffff:192.0.2.128", &addr);
160     ipv6Client->GetAddrType(&addr);
161 }
162 
163 HWTEST_F(DhcpIpv6ClientTest, getAddrScopeTest, TestSize.Level1)
164 {
165     ASSERT_TRUE(ipv6Client != nullptr);
166     DHCP_LOGE("getAddrScopeTest enter!");
167     struct in6_addr addr;
168     EXPECT_EQ(IPV6_RETURN_32, ipv6Client->GetAddrScope(nullptr));
169     EXPECT_EQ(IPV6_RETURN_ZERO, ipv6Client->GetAddrScope(&addr));
170 }
171 
172 HWTEST_F(DhcpIpv6ClientTest, createKernelSocketTest, TestSize.Level1)
173 {
174     ASSERT_TRUE(ipv6Client != nullptr);
175     DHCP_LOGE("createKernelSocketTest enter!");
176     ipv6Client->createKernelSocket();
177 }
178 
179 HWTEST_F(DhcpIpv6ClientTest, GetIpv6PrefixTest, TestSize.Level1)
180 {
181     ASSERT_TRUE(ipv6Client != nullptr);
182     DHCP_LOGE("GetIpv6PrefixTest enter!");
183     char ipv6Addr[] = "192.168.1.10";
184     char ipv6PrefixBuf[] = "192.168.1.12";
185     ipv6Client->GetIpv6Prefix(nullptr, ipv6PrefixBuf, PRE_FIX_LEN);
186     ipv6Client->GetIpv6Prefix(ipv6Addr, nullptr, PRE_FIX_LEN);
187     ipv6Client->GetIpv6Prefix(ipv6Addr, ipv6PrefixBuf, PRE_FIX_ADDRSTRLEN);
188     ipv6Client->GetIpv6Prefix(ipv6Addr, ipv6PrefixBuf, PRE_FIX_LEN);
189 }
190 
191 HWTEST_F(DhcpIpv6ClientTest, GetIpFromS6AddressTest, TestSize.Level1)
192 {
193     ASSERT_TRUE(ipv6Client != nullptr);
194     DHCP_LOGE("GetIpFromS6AddressTest enter!");
195     char addr[] = "192.168.1.12";
196     char buf[BUF_LEN] = {0};
197     EXPECT_EQ(ipv6Client->GetIpFromS6Address(addr, 1, buf, BUF_LEN), IPV6_OPT_FAILED);
198     EXPECT_EQ(ipv6Client->GetIpFromS6Address(addr, 1, buf, BUF_LEN_2), IPV6_OPT_FAILED);
199 }
200 
201 HWTEST_F(DhcpIpv6ClientTest, onIpv6DnsAddEventTest, TestSize.Level1)
202 {
203     ASSERT_TRUE(ipv6Client != nullptr);
204     DHCP_LOGE("onIpv6DnsAddEventTest enter!");
205     char data[] = "192.168.1.12";
206     ipv6Client->onIpv6DnsAddEvent(static_cast<void *>(data), PRE_FIX_LEN, 1);
207     ipv6Client->onIpv6DnsAddEvent(nullptr, PRE_FIX_LEN, 0);
208     ipv6Client->onIpv6DnsAddEvent(nullptr, PRE_FIX_LEN, 44);
209     ipv6Client->onIpv6DnsAddEvent(static_cast<void *>(data), PRE_FIX_LEN, 44);
210 }
211 
212 HWTEST_F(DhcpIpv6ClientTest, onIpv6RouteUpdateEventTest, TestSize.Level1)
213 {
214     ASSERT_TRUE(ipv6Client != nullptr);
215     DHCP_LOGE("onIpv6RouteUpdateEventTest enter!");
216     char gateway[] = "192.168.1.1";
217     char dst[] = "192.168.1.2";
218     ipv6Client->OnIpv6RouteUpdateEvent(gateway, dst, 1);
219     ipv6Client->OnIpv6RouteUpdateEvent(nullptr, dst, 44);
220     ipv6Client->OnIpv6RouteUpdateEvent(gateway, nullptr, 44);
221     ipv6Client->OnIpv6RouteUpdateEvent(gateway, dst, 44);
222 }
223 
224 HWTEST_F(DhcpIpv6ClientTest, getIpv6RouteAddrTest, TestSize.Level1)
225 {
226     ASSERT_TRUE(ipv6Client != nullptr);
227     DHCP_LOGE("getIpv6RouteAddrTest enter!");
228     ipv6Client->getIpv6RouteAddr();
229 }
230 
231 HWTEST_F(DhcpIpv6ClientTest, setSocketFilterTest, TestSize.Level1)
232 {
233     ASSERT_TRUE(ipv6Client != nullptr);
234     DHCP_LOGE("setSocketFilterTest enter!");
235     char addr[] = "192.168.1.2";
236     ipv6Client->setSocketFilter(nullptr);
237     ipv6Client->setSocketFilter(static_cast<void *>(addr));
238 }
239 
240 HWTEST_F(DhcpIpv6ClientTest, parseNdUserOptMessageTest, TestSize.Level1)
241 {
242     ASSERT_TRUE(ipv6Client != nullptr);
243     DHCP_LOGE("parseNdUserOptMessageTest enter!");
244     struct nduseroptmsg data;
245     data.nduseropt_opts_len = IPV6_LEN_16;
246     data.nduseropt_family = IPV6_LEN_10;
247     data.nduseropt_icmp_type = IPV6_LEN_134;
248     data.nduseropt_icmp_code = IPV6_RETURN_ZERO;
249     ipv6Client->parseNdUserOptMessage(nullptr, IPV6_LEN_24);
250     ipv6Client->parseNdUserOptMessage(static_cast<void *>(&data), IPV6_LEN_24);
251 
252     data.nduseropt_opts_len = IPV6_LEN_24;
253     ipv6Client->parseNdUserOptMessage(static_cast<void *>(&data), IPV6_LEN_16);
254 
255     data.nduseropt_opts_len = IPV6_LEN_16;
256     data.nduseropt_family = IPV6_LEN_16;
257     ipv6Client->parseNdUserOptMessage(static_cast<void *>(&data), IPV6_LEN_24);
258 
259     data.nduseropt_opts_len = IPV6_LEN_16;
260     data.nduseropt_family = IPV6_LEN_10;
261     data.nduseropt_icmp_type = IPV6_LEN_16;
262     data.nduseropt_icmp_code = IPV6_LEN_16;
263     ipv6Client->parseNdUserOptMessage(static_cast<void *>(&data), IPV6_LEN_24);
264 
265     data.nduseropt_opts_len = IPV6_LEN_16;
266     data.nduseropt_family = IPV6_LEN_10;
267     data.nduseropt_icmp_type = IPV6_LEN_134;
268     data.nduseropt_icmp_code = IPV6_LEN_16;
269     ipv6Client->parseNdUserOptMessage(static_cast<void *>(&data), IPV6_LEN_24);
270 }
271 
272 HWTEST_F(DhcpIpv6ClientTest, parseNDRouteMessageTest, TestSize.Level1)
273 {
274     ASSERT_TRUE(ipv6Client != nullptr);
275     DHCP_LOGE("parseNDRouteMessageTest enter!");
276     struct nlmsghdr msg;
277     ipv6Client->parseNDRouteMessage(nullptr);
278     ipv6Client->parseNDRouteMessage(static_cast<void *>(&msg));
279 }
280 
281 HWTEST_F(DhcpIpv6ClientTest, ParseNDRouteMessage_TEST1, TestSize.Level1)
282 {
283     ASSERT_TRUE(ipv6Client != nullptr);
284     DHCP_LOGE("ParseNDRouteMessage_TEST1 enter!");
285     nlmsghdr hdrMsg;
286     rtmsg rtMsg;
287     hdrMsg.nlmsg_len = sizeof(rtmsg);
288     rtMsg.rtm_protocol = RTPROT_BOOT;
289     rtMsg.rtm_scope = RT_SCOPE_SITE;
290     rtMsg.rtm_type = RTN_MULTICAST;
291     rtMsg.rtm_src_len = 1;
292     rtMsg.rtm_flags = RTM_F_PREFIX;
293     ipv6Client->parseNDRouteMessage(&hdrMsg);
294 }
295 
296 HWTEST_F(DhcpIpv6ClientTest, ParseNDRouteMessage_TEST2, TestSize.Level1)
297 {
298     ASSERT_TRUE(ipv6Client != nullptr);
299     DHCP_LOGE("ParseNDRouteMessage_TEST2 enter!");
300     nlmsghdr hdrMsg;
301     rtmsg rtMsg;
302     hdrMsg.nlmsg_len = sizeof(rtmsg);
303     rtMsg.rtm_protocol = RTPROT_KERNEL;
304     rtMsg.rtm_scope = RT_SCOPE_UNIVERSE;
305     rtMsg.rtm_type = RTN_UNICAST;
306     rtMsg.rtm_src_len = 0;
307     rtMsg.rtm_flags = 0;
308     ipv6Client->parseNDRouteMessage(&hdrMsg);
309 }
310 
311 HWTEST_F(DhcpIpv6ClientTest, parseNewneighMessageTest, TestSize.Level1)
312 {
313     ASSERT_TRUE(ipv6Client != nullptr);
314     DHCP_LOGE("parseNewneighMessageTest enter!");
315     struct nlmsghdr msg;
316     ipv6Client->parseNewneighMessage(nullptr);
317     ipv6Client->parseNewneighMessage(static_cast<void *>(&msg));
318 }
319 
320 HWTEST_F(DhcpIpv6ClientTest, ParseNewneighMessage_Test, TestSize.Level1)
321 {
322     ASSERT_TRUE(ipv6Client != nullptr);
323     DHCP_LOGE("ParseNewneighMessage_Test enter!");
324     void* msg = new char[sizeof(nlmsghdr) + sizeof(ndmsg) + sizeof(rtattr) + sizeof(in6_addr)];
325     nlmsghdr* nlh = reinterpret_cast<nlmsghdr*>(msg);
326     ndmsg* ndm = reinterpret_cast<ndmsg*>((char*)msg + sizeof(nlmsghdr));
327     rtattr* rta = reinterpret_cast<rtattr*>((char*)msg + sizeof(nlmsghdr) + sizeof(ndmsg));
328     in6_addr* addr = reinterpret_cast<in6_addr*>((char*)msg + sizeof(nlmsghdr) + sizeof(ndmsg) + sizeof(rtattr));
329     nlh->nlmsg_type = RTM_NEWNEIGH;
330     ndm->ndm_family = KERNEL_SOCKET_IFA_FAMILY;
331     ndm->ndm_state = NUD_REACHABLE;
332     rta->rta_type = NDA_DST;
333     rta->rta_len = sizeof(rtattr) + sizeof(in6_addr);
334     ipv6Client->parseNewneighMessage(msg);
335 }
336 
337 HWTEST_F(DhcpIpv6ClientTest, fillRouteDataTest, TestSize.Level1)
338 {
339     ASSERT_TRUE(ipv6Client != nullptr);
340     DHCP_LOGE("fillRouteDataTest enter!");
341     int len = 0;
342     char buf[BUF_LEN] = {0};
343     ipv6Client->fillRouteData(nullptr, len);
344     ipv6Client->fillRouteData(buf, len);
345 }
346 
347 HWTEST_F(DhcpIpv6ClientTest, handleKernelEventTest, TestSize.Level1)
348 {
349     ASSERT_TRUE(ipv6Client != nullptr);
350     DHCP_LOGE("handleKernelEventTest enter!");
351     uint8_t data[] = "testcode";
352     ipv6Client->handleKernelEvent(nullptr, 0);
353     ipv6Client->handleKernelEvent(data, 1);
354     ipv6Client->handleKernelEvent(data, DATA_SIZE);
355 }
356 
357 HWTEST_F(DhcpIpv6ClientTest, AddIpv6AddressTest, TestSize.Level1)
358 {
359     DHCP_LOGI("AddIpv6Address enter!");
360     int len = 0;
361     ipv6Client->AddIpv6Address(nullptr, len);
362     EXPECT_FALSE(g_errLog.find("AddIpv6Address")!=std::string::npos);
363 }
364 
365 HWTEST_F(DhcpIpv6ClientTest, AddIpv6AddressTest1, TestSize.Level1)
366 {
367     DHCP_LOGI("AddIpv6Address1 enter!");
368     char ipv6Addr[128] = "1001:0db8:85a3:0000:0000:8a2e:0370:7334";
369     int len = DHCP_INET6_ADDRSTRLEN - 1;
370     ipv6Client->AddIpv6Address(nullptr, len);
371     EXPECT_EQ(127, len);
372 }
373 
374 const int MAC_ADDR_LEN = 6;
375 // 00:11:22:33:44:55 -> EUI-64: 0211:22ff:fe33:4455
376 const unsigned char TEST_MAC[MAC_ADDR_LEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
377 const char* EUI64_ADDR = "2001:db8::211:22ff:fe33:4455";
378 const char* RAND_ADDR = "2001:db8::1234:5678:9abc:def0";
379 const char* NOT_EUI64_ADDR = "2001:db8::0211:22ff:fe33:4456";
380 HWTEST_F(DhcpIpv6ClientTest, NullAndInvalidInput, TestSize.Level1)
381 {
382     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(nullptr, 40, TEST_MAC, MAC_ADDR_LEN));
383     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address("", 0, TEST_MAC, MAC_ADDR_LEN));
384     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address("invalid", 40, TEST_MAC, MAC_ADDR_LEN));
385     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(EUI64_ADDR, 40, nullptr, MAC_ADDR_LEN));
386     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(EUI64_ADDR, 40, TEST_MAC, 5));
387 }
388 
389 HWTEST_F(DhcpIpv6ClientTest, NotEui64Format, TestSize.Level1)
390 {
391     // 没有FF:FE的IID
392     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(RAND_ADDR, 40, TEST_MAC, MAC_ADDR_LEN));
393 }
394 
395 HWTEST_F(DhcpIpv6ClientTest, Eui64FormatButMacMismatch, TestSize.Level1)
396 {
397     // EUI-64格式但MAC不匹配
398     unsigned char wrongMac[MAC_ADDR_LEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x56};
399     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(EUI64_ADDR, 40, wrongMac, MAC_ADDR_LEN));
400 }
401 
402 HWTEST_F(DhcpIpv6ClientTest, Eui64FormatAndMacMatch, TestSize.Level1)
403 {
404     // EUI-64格式且MAC匹配
405     EXPECT_TRUE(ipv6Client->IsEui64ModeIpv6Address(EUI64_ADDR, 40, TEST_MAC, MAC_ADDR_LEN));
406 }
407 
408 HWTEST_F(DhcpIpv6ClientTest, Eui64FormatButIIDNotMatch, TestSize.Level1)
409 {
410     // EUI-64格式但IID最后一位不对
411     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(NOT_EUI64_ADDR, 40, TEST_MAC, MAC_ADDR_LEN));
412 }
413 
414 HWTEST_F(DhcpIpv6ClientTest, Eui64FormatAndMacMatch_0044, TestSize.Level1)
415 {
416     // 00:11:22:33:00:44 -> EUI-64: 0211:22ff:fe33:0044
417     const char* addr2 = "2001:db8::211:22ff:fe33:44";
418     const unsigned char TEST_MAC_2[MAC_ADDR_LEN] = {0x00, 0x11, 0x22, 0x33, 0x00, 0x44};
419     EXPECT_TRUE(ipv6Client->IsEui64ModeIpv6Address(addr2, 40, TEST_MAC_2, MAC_ADDR_LEN));
420 }
421 
422 HWTEST_F(DhcpIpv6ClientTest, Eui64FormatButMacMismatch_0044, TestSize.Level1)
423 {
424     // 00:11:22:33:00:44 -> EUI-64: 0211:22ff:fe33:0044
425     const char* addr2 = "2001:db8::211:22ff:fe33:44";
426     unsigned char wrongMac[MAC_ADDR_LEN] = {0x00, 0x11, 0x22, 0x33, 0x00, 0x45};
427     EXPECT_FALSE(ipv6Client->IsEui64ModeIpv6Address(addr2, 40, wrongMac, MAC_ADDR_LEN));
428 }
429 
430 HWTEST_F(DhcpIpv6ClientTest, IsGlobalIpv6Address_ValidGlobal, TestSize.Level1)
431 {
432     // 2001:db8:: is documentation, not global
433     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("2001:0db8::1", 40));
434     // 2400:cb00:: is global
435     EXPECT_TRUE(ipv6Client->IsGlobalIpv6Address("2400:cb00::1", 40));
436     // 3001:: is global
437     EXPECT_TRUE(ipv6Client->IsGlobalIpv6Address("3001::1", 40));
438     // fc00:: is not global
439     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("fc00::1", 40));
440     // fe80:: is not global
441     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("fe80::1", 40));
442     // ::1 is not global
443     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("::1", 40));
444 }
445 
446 HWTEST_F(DhcpIpv6ClientTest, IsUniqueLocalIpv6Address_ValidUniqueLocal, TestSize.Level1)
447 {
448     // fc00::/7
449     EXPECT_TRUE(ipv6Client->IsUniqueLocalIpv6Address("fc00::1", 40));
450     EXPECT_TRUE(ipv6Client->IsUniqueLocalIpv6Address("fd12:3456:789a::1", 40));
451     // 2001:db8:: is not unique local
452     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("2001:0db8::1", 40));
453     // fe80:: is not unique local
454     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("fe80::1", 40));
455     // ::1 is not unique local
456     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("::1", 40));
457     // 2400:cb00:: is not unique local
458     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("2400:cb00::1", 40));
459 }
460 
461 HWTEST_F(DhcpIpv6ClientTest, IsGlobalIpv6Address_InvalidInput, TestSize.Level1)
462 {
463     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address(nullptr, 40));
464     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("", 0));
465     EXPECT_FALSE(ipv6Client->IsGlobalIpv6Address("invalid", 40));
466 }
467 
468 HWTEST_F(DhcpIpv6ClientTest, IsUniqueLocalIpv6Address_InvalidInput, TestSize.Level1)
469 {
470     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address(nullptr, 40));
471     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("", 0));
472     EXPECT_FALSE(ipv6Client->IsUniqueLocalIpv6Address("invalid", 40));
473 }
474 }
475 }
476