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