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 "dhcp_logger.h" 18 #include "dhcp_function.h" 19 #include "dhcp_client_def.h" 20 #include "mock_system_func.h" 21 22 DEFINE_DHCPLOG_DHCP_LABEL("DhcpFunctionTest"); 23 24 using namespace testing::ext; 25 using namespace OHOS::Wifi; 26 27 namespace OHOS { 28 class DhcpFunctionTest : public testing::Test { 29 public: SetUpTestCase()30 static void SetUpTestCase() 31 {} TearDownTestCase()32 static void TearDownTestCase() 33 {} SetUp()34 virtual void SetUp() 35 {} TearDown()36 virtual void TearDown() 37 {} 38 }; 39 40 HWTEST_F(DhcpFunctionTest, Ip4StrConToInt_SUCCESS, TestSize.Level1) 41 { 42 DHCP_LOGE("enter Ip4StrConToInt_SUCCESS"); 43 char serIp[INET_ADDRSTRLEN] = "192.77.1.231"; 44 uint32_t uSerIp = 0; 45 EXPECT_EQ(true, Ip4StrConToInt(serIp, &uSerIp, true)); 46 } 47 48 HWTEST_F(DhcpFunctionTest, Ip4StrConToInt_FAILED, TestSize.Level1) 49 { 50 char serIp[INET_ADDRSTRLEN] = {0}; 51 uint32_t uSerIp = 0; 52 EXPECT_EQ(false, Ip4StrConToInt(serIp, &uSerIp, true)); 53 54 char serIp1[INET_ADDRSTRLEN] = "192.77.231"; 55 uint32_t uSerIp1 = 0; 56 EXPECT_EQ(false, Ip4StrConToInt(serIp1, &uSerIp1, true)); 57 } 58 59 HWTEST_F(DhcpFunctionTest, Ip4IntConToStr_SUCCESS, TestSize.Level1) 60 { 61 uint32_t uSerIp = 3226272231; 62 char *pSerIp = Ip4IntConToStr(uSerIp, true); 63 ASSERT_NE(pSerIp, nullptr); 64 free(pSerIp); 65 } 66 67 HWTEST_F(DhcpFunctionTest, Ip6StrConToChar_SUCCESS, TestSize.Level1) 68 { 69 char serIp[INET6_ADDRSTRLEN] = "2001:db8:0:1::231"; 70 uint8_t addr6[sizeof(struct in6_addr)] = {0}; 71 EXPECT_EQ(true, Ip6StrConToChar(serIp, addr6, sizeof(addr6))); 72 } 73 74 HWTEST_F(DhcpFunctionTest, Ip6StrConToChar_FAILED, TestSize.Level1) 75 { 76 char serIp[INET6_ADDRSTRLEN] = {0}; 77 uint8_t addr6[sizeof(struct in6_addr)] = {0}; 78 EXPECT_EQ(false, Ip6StrConToChar(serIp, addr6, sizeof(addr6))); 79 80 char serIp1[INET6_ADDRSTRLEN] = "231"; 81 uint8_t addr61[sizeof(struct in6_addr)] = {0}; 82 EXPECT_EQ(false, Ip6StrConToChar(serIp1, addr61, sizeof(addr61))); 83 } 84 85 HWTEST_F(DhcpFunctionTest, MacChConToMacStr_SUCCESS, TestSize.Level1) 86 { 87 EXPECT_EQ(nullptr, MacChConToMacStr(NULL, 0, NULL, 0)); 88 89 char interface[INFNAME_SIZE] = "wlan0"; 90 int ifindex; 91 unsigned char hwaddr[MAC_ADDR_LEN]; 92 ASSERT_EQ(GetLocalInterface(interface, &ifindex, hwaddr, NULL), DHCP_OPT_SUCCESS); 93 EXPECT_EQ(nullptr, MacChConToMacStr(hwaddr, MAC_ADDR_LEN, NULL, 0)); 94 95 char buf[MAC_ADDR_LEN * MAC_ADDR_CHAR_NUM] = {0}; 96 EXPECT_NE(nullptr, MacChConToMacStr(hwaddr, MAC_ADDR_LEN, buf, sizeof(buf))); 97 } 98 99 HWTEST_F(DhcpFunctionTest, GetLocalInterface_SUCCESS, TestSize.Level1) 100 { 101 EXPECT_EQ(GetLocalInterface(NULL, NULL, NULL, NULL), DHCP_OPT_FAILED); 102 103 MockSystemFunc::SetMockFlag(true); 104 105 EXPECT_CALL(MockSystemFunc::GetInstance(), socket(_, _, _)).WillOnce(Return(-1)).WillRepeatedly(Return(1)); 106 EXPECT_CALL(MockSystemFunc::GetInstance(), ioctl(_, _, _)) 107 .WillRepeatedly(Return(0)); 108 EXPECT_CALL(MockSystemFunc::GetInstance(), close(_)).WillRepeatedly(Return(0)); 109 110 char interface[INFNAME_SIZE] = "wlan0"; 111 EXPECT_EQ(GetLocalInterface(interface, NULL, NULL, NULL), DHCP_OPT_FAILED); 112 int ifindex = 0; 113 EXPECT_EQ(GetLocalInterface(interface, &ifindex, NULL, NULL), DHCP_OPT_FAILED); 114 unsigned char hwaddr[MAC_ADDR_LEN]; 115 EXPECT_EQ(GetLocalInterface(interface, &ifindex, hwaddr, NULL), DHCP_OPT_FAILED); 116 uint32_t ifaddr4; 117 EXPECT_EQ(GetLocalInterface(interface, &ifindex, hwaddr, &ifaddr4), DHCP_OPT_SUCCESS); 118 EXPECT_EQ(GetLocalInterface(interface, &ifindex, hwaddr, &ifaddr4), DHCP_OPT_SUCCESS); 119 120 MockSystemFunc::SetMockFlag(false); 121 } 122 123 HWTEST_F(DhcpFunctionTest, GetLocalIp_SUCCESS, TestSize.Level1) 124 { 125 char interface[INFNAME_SIZE] = "wlan0"; 126 uint32_t ipaddr4; 127 EXPECT_EQ(DHCP_OPT_SUCCESS, GetLocalIp(interface, &ipaddr4)); 128 } 129 130 HWTEST_F(DhcpFunctionTest, GetLocalIp_FAILED, TestSize.Level1) 131 { 132 char interface[INFNAME_SIZE] = {0}; 133 uint32_t ipaddr4; 134 EXPECT_EQ(DHCP_OPT_FAILED, GetLocalIp(interface, &ipaddr4)); 135 } 136 137 HWTEST_F(DhcpFunctionTest, SetLocalInterface_SUCCESS, TestSize.Level1) 138 { 139 char interface[INFNAME_SIZE] = "wlan0"; 140 uint32_t ipaddr4 = 2981805322; 141 uint32_t netMask = 16318463; 142 EXPECT_EQ(DHCP_OPT_SUCCESS, SetLocalInterface(interface, ipaddr4, netMask)); 143 } 144 145 HWTEST_F(DhcpFunctionTest, SetLocalInterface_FAILED, TestSize.Level1) 146 { 147 char interface[INFNAME_SIZE] = {0}; 148 uint32_t ipaddr4 = 0; 149 uint32_t netMask = 0; 150 EXPECT_EQ(DHCP_OPT_FAILED, SetLocalInterface(interface, ipaddr4, netMask)); 151 EXPECT_EQ(DHCP_OPT_FAILED, SetLocalInterface("wlan", ipaddr4, netMask)); 152 } 153 154 HWTEST_F(DhcpFunctionTest, InitPidfile_SUCCESS, TestSize.Level1) 155 { 156 char workDir[DIR_MAX_LEN] = "./"; 157 char pidFile[DIR_MAX_LEN] = "./wlan0.pid"; 158 159 EXPECT_EQ(DHCP_OPT_SUCCESS, InitPidfile(workDir, pidFile, getpid())); 160 unlink(pidFile); 161 usleep(SLEEP_TIME_200_MS); 162 } 163 164 HWTEST_F(DhcpFunctionTest, InitPidfile_FAILED, TestSize.Level1) 165 { 166 char *workDir = nullptr; 167 char *pidFile = nullptr; 168 169 EXPECT_EQ(DHCP_OPT_FAILED, InitPidfile(workDir, pidFile, getpid())); 170 unlink(pidFile); 171 usleep(SLEEP_TIME_200_MS); 172 } 173 174 HWTEST_F(DhcpFunctionTest, GetPID_SUCCESS, TestSize.Level1) 175 { 176 char workDir[DIR_MAX_LEN] = "./"; 177 char pidFile[DIR_MAX_LEN] = "./wlan0.pid"; 178 179 EXPECT_EQ(DHCP_OPT_SUCCESS, InitPidfile(workDir, pidFile, getpid())); 180 EXPECT_GT(GetPID(pidFile), 0); 181 unlink(pidFile); 182 } 183 184 HWTEST_F(DhcpFunctionTest, CreateDirs_SUCCESS, TestSize.Level1) 185 { 186 EXPECT_EQ(DHCP_OPT_FAILED, CreateDirs(NULL, 0)); 187 188 const char *path = "test"; 189 EXPECT_EQ(DHCP_OPT_SUCCESS, CreateDirs(path, S_IRWXU)); 190 rmdir(path); 191 } 192 } // namespace OHOS