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 16 #include <gtest/gtest.h> 17 #include <cstdint> 18 #include "dhcp_s_define.h" 19 #include "address_utils.h" 20 #include "dhcp_logger.h" 21 22 DEFINE_DHCPLOG_DHCP_LABEL("AddressUtilsTest"); 23 24 using namespace testing::ext; 25 namespace OHOS { 26 namespace DHCP { 27 const uint8_t netmask24[] = {255, 255, 255, 0}; 28 const uint8_t netmask25[] = {255, 255, 255, 128}; 29 const uint8_t netmask26[] = {255, 255, 255, 192}; 30 const uint8_t netmask27[] = {255, 255, 255, 224}; 31 32 /** 33 * @tc.name: ParseIpAddrTest 34 * @tc.desc: test address translation. 35 * @tc.type: FUNC 36 * @tc.require: AR00000000 SR00000000 37 */ 38 HWTEST(AddressUtilsTest, ParseIpAddrTest, TestSize.Level1) 39 { 40 DHCP_LOGE("enter ParseIpAddrTest"); 41 uint8_t ipData[] = {192, 168, 100, 1}; 42 uint32_t testIp = ParseIp(ipData); 43 ASSERT_TRUE(testIp != 0); 44 EXPECT_EQ(testIp, ParseIpAddr("192.168.100.1")); 45 } 46 47 HWTEST(AddressUtilsTest, ParseIpAddrFailedTest, TestSize.Level1) 48 { 49 uint32_t expectVal = 0; 50 EXPECT_EQ(expectVal, ParseIpAddr("192.168.100.")); 51 EXPECT_EQ(expectVal, ParseIpAddr("0")); 52 EXPECT_EQ(expectVal, ParseIpAddr("abc.abc.abc.abc")); 53 } 54 55 HWTEST(AddressUtilsTest, ParseStrIpAddrTest, TestSize.Level1) 56 { 57 uint8_t ipData[] = {192, 168, 100, 1}; 58 uint32_t testIp = ParseIp(ipData); 59 EXPECT_TRUE(testIp != 0); 60 EXPECT_STREQ("192.168.100.1", ParseStrIp(testIp)); 61 } 62 63 /** 64 * @tc.name: NetworkAddressTest 65 * @tc.desc: test network address calculation. 66 * @tc.type: FUNC 67 * @tc.require: AR00000000 SR00000000 68 */ 69 HWTEST(AddressUtilsTest, NetworkAddressTest, TestSize.Level1) 70 { 71 uint8_t srcNetData[] = {192, 168, 100, 0}; 72 uint32_t srcNet = ParseIp(srcNetData); 73 ASSERT_TRUE(srcNet != 0); 74 uint32_t testIp = ParseIpAddr("192.168.100.100"); 75 ASSERT_TRUE(testIp != 0); 76 uint32_t testNetmask = ParseIp(netmask24); 77 EXPECT_TRUE(testNetmask != 0); 78 EXPECT_EQ(srcNet, NetworkAddress(testIp, testNetmask)); 79 } 80 81 HWTEST(AddressUtilsTest, FirstIpAddressTest, TestSize.Level1) 82 { 83 uint8_t srcData[] = {192, 168, 100, 1}; 84 uint32_t srcAddr = ParseIp(srcData); 85 ASSERT_TRUE(srcAddr != 0); 86 uint32_t testIp = ParseIpAddr("192.168.100.100"); 87 ASSERT_TRUE(testIp != 0); 88 uint32_t testNetmask = ParseIp(netmask24); 89 EXPECT_TRUE(testNetmask != 0); 90 EXPECT_EQ(srcAddr, FirstIpAddress(testIp, testNetmask)); 91 } 92 93 HWTEST(AddressUtilsTest, LastIpAddressTest, TestSize.Level1) 94 { 95 uint8_t srcData[] = {192, 168, 100, 254}; 96 uint32_t srcAddr = ParseIp(srcData); 97 ASSERT_TRUE(srcAddr != 0); 98 uint32_t testIp = ParseIpAddr("192.168.100.100"); 99 ASSERT_TRUE(testIp != 0); 100 uint32_t testNetmask = ParseIp(netmask24); 101 EXPECT_TRUE(testNetmask != 0); 102 EXPECT_EQ(srcAddr, LastIpAddress(testIp, testNetmask)); 103 } 104 105 HWTEST(AddressUtilsTest, FirstNetIpAddressTest, TestSize.Level1) 106 { 107 uint8_t srcData[] = {192, 168, 100, 1}; 108 uint32_t srcAddr = ParseIp(srcData); 109 ASSERT_TRUE(srcAddr != 0); 110 uint32_t testIp = ParseIpAddr("192.168.100.100"); 111 ASSERT_TRUE(testIp != 0); 112 uint32_t testNetmask = ParseIp(netmask24); 113 EXPECT_TRUE(testNetmask != 0); 114 uint32_t network = NetworkAddress(testIp, testNetmask); 115 ASSERT_TRUE(network != 0); 116 EXPECT_EQ(srcAddr, FirstNetIpAddress(network)); 117 } 118 119 HWTEST(AddressUtilsTest, NextIpAddressTest, TestSize.Level1) 120 { 121 uint8_t srcData[] = {192, 168, 100, 100}; 122 uint32_t srcAddr = ParseIp(srcData); 123 EXPECT_TRUE(srcAddr != 0); 124 uint32_t testIp1 = ParseIpAddr("192.168.100.101"); 125 EXPECT_TRUE(testIp1 != 0); 126 uint32_t testIp2 = ParseIpAddr("192.168.100.102"); 127 EXPECT_TRUE(testIp2 != 0); 128 uint32_t testNetmask = ParseIp(netmask24); 129 EXPECT_TRUE(testNetmask != 0); 130 EXPECT_EQ(testIp1, NextIpAddress(srcAddr, testNetmask, 0)); 131 EXPECT_EQ(testIp2, NextIpAddress(srcAddr, testNetmask, 1)); 132 } 133 134 HWTEST(AddressUtilsTest, IpInNetworkTest, TestSize.Level1) 135 { 136 uint8_t srcData[] = {192, 168, 100, 0}; 137 uint32_t srcAddr = ParseIp(srcData); 138 EXPECT_TRUE(srcAddr != 0); 139 uint32_t testNetmask = ParseIp(netmask25); 140 EXPECT_TRUE(testNetmask != 0); 141 uint32_t testIp1 = ParseIpAddr("192.168.100.120"); 142 EXPECT_TRUE(testIp1 != 0); 143 uint32_t testIp2= ParseIpAddr("192.168.100.150"); 144 EXPECT_TRUE(testIp2 != 0); 145 EXPECT_TRUE(IpInNetwork(testIp1, srcAddr, testNetmask)); 146 EXPECT_FALSE(IpInNetwork(testIp2, srcAddr, testNetmask)); 147 } 148 149 HWTEST(AddressUtilsTest, IpInRangeTest, TestSize.Level1) 150 { 151 uint32_t testNetmask = ParseIp(netmask26); 152 ASSERT_TRUE(testNetmask != 0); 153 uint32_t beginIp = ParseIpAddr("192.168.100.100"); 154 ASSERT_TRUE(beginIp != 0); 155 uint32_t endIp = LastIpAddress(beginIp, testNetmask); 156 ASSERT_TRUE(endIp != 0); 157 158 uint32_t testIp1 = ParseIpAddr("192.168.100.90"); 159 EXPECT_TRUE(testIp1 != 0); 160 uint32_t testIp2= ParseIpAddr("192.168.100.130"); 161 EXPECT_TRUE(testIp2 != 0); 162 uint32_t testIp3= ParseIpAddr("192.168.100.120"); 163 EXPECT_TRUE(testIp3 != 0); 164 165 EXPECT_FALSE(IpInRange(testIp1, beginIp, endIp, testNetmask)); 166 EXPECT_FALSE(IpInRange(testIp2, beginIp, endIp, testNetmask)); 167 EXPECT_TRUE(IpInRange(testIp3, beginIp, endIp, testNetmask)); 168 } 169 170 HWTEST(AddressUtilsTest, BroadCastAddressTest, TestSize.Level1) 171 { 172 uint8_t srcData[] = {192, 168, 100, 255}; 173 uint32_t srcAddr = ParseIp(srcData); 174 ASSERT_TRUE(srcAddr != 0); 175 uint32_t testNetmask = ParseIp(netmask24); 176 ASSERT_TRUE(testNetmask != 0); 177 uint32_t testIp1 = ParseIpAddr("192.168.100.120"); 178 EXPECT_TRUE(testIp1 != 0); 179 EXPECT_EQ(srcAddr, BroadCastAddress(testIp1, testNetmask)); 180 } 181 182 HWTEST(AddressUtilsTest, ParseIpHtonlTest, TestSize.Level1) 183 { 184 uint8_t srcData[] = {150, 100, 168, 192}; 185 uint32_t srcAddr = ParseIp(srcData); 186 ASSERT_TRUE(srcAddr != 0); 187 EXPECT_EQ(srcAddr, ParseIpHtonl("192.168.100.150")); 188 } 189 190 HWTEST(AddressUtilsTest, NetworkBitsTest, TestSize.Level1) 191 { 192 uint32_t mask1 = ParseIp(netmask24); 193 ASSERT_TRUE(mask1 != 0); 194 uint32_t mask2 = ParseIp(netmask25); 195 ASSERT_TRUE(mask2 != 0); 196 uint32_t mask3 = ParseIp(netmask26); 197 ASSERT_TRUE(mask3 != 0); 198 uint32_t mask4 = ParseIp(netmask27); 199 ASSERT_TRUE(mask4 != 0); 200 201 EXPECT_EQ(24, NetworkBits(mask1)); 202 EXPECT_EQ(25, NetworkBits(mask2)); 203 EXPECT_EQ(26, NetworkBits(mask3)); 204 EXPECT_EQ(27, NetworkBits(mask4)); 205 } 206 207 HWTEST(AddressUtilsTest, HostBitsTest, TestSize.Level1) 208 { 209 uint32_t mask1 = ParseIp(netmask24); 210 ASSERT_TRUE(mask1 != 0); 211 uint32_t mask2 = ParseIp(netmask25); 212 ASSERT_TRUE(mask2 != 0); 213 uint32_t mask3 = ParseIp(netmask26); 214 ASSERT_TRUE(mask3 != 0); 215 uint32_t mask4 = ParseIp(netmask27); 216 ASSERT_TRUE(mask4 != 0); 217 218 EXPECT_EQ(8, HostBits(mask1)); 219 EXPECT_EQ(7, HostBits(mask2)); 220 EXPECT_EQ(6, HostBits(mask3)); 221 EXPECT_EQ(5, HostBits(mask4)); 222 } 223 224 HWTEST(AddressUtilsTest, IsEmptyHWAddrTest, TestSize.Level1) 225 { 226 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0}; 227 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0, 0, 0, 0, 0, 0, 0, 0x01}; 228 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x43, 0}; 229 230 EXPECT_TRUE(IsEmptyHWAddr(testMac1)); 231 EXPECT_TRUE(IsEmptyHWAddr(testMac2)); 232 EXPECT_FALSE(IsEmptyHWAddr(testMac3)); 233 } 234 235 HWTEST(AddressUtilsTest, ParseStrMacTest, TestSize.Level1) 236 { 237 uint8_t testMac[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x43, 0}; 238 EXPECT_STREQ("00:ae:dc:cc:9f:43", ParseStrMac(testMac, MAC_ADDR_LENGTH)); 239 uint8_t* testMac1 = nullptr; 240 char* result = ParseStrMac(testMac1, MAC_ADDR_LENGTH); 241 ASSERT_TRUE(result == 0); 242 } 243 244 HWTEST(AddressUtilsTest, HostToNetworkTest, TestSize.Level1) 245 { 246 uint8_t srcData[] = {150, 100, 168, 192}; 247 uint32_t srcAddr = ParseIp(srcData); 248 ASSERT_TRUE(srcAddr != 0); 249 uint32_t testIp = ParseIpAddr("192.168.100.150"); 250 ASSERT_TRUE(testIp != 0); 251 EXPECT_EQ(srcAddr, HostToNetwork(testIp)); 252 } 253 254 HWTEST(AddressUtilsTest, NetworkToHostTest, TestSize.Level1) 255 { 256 uint8_t srcData[] = {192, 168, 100, 150}; 257 uint32_t srcAddr = ParseIp(srcData); 258 ASSERT_TRUE(srcAddr != 0); 259 uint8_t testData[] = {150, 100, 168, 192}; 260 uint32_t testAddr = ParseIp(testData); 261 ASSERT_TRUE(testAddr != 0); 262 EXPECT_EQ(srcAddr, NetworkToHost(testAddr)); 263 } 264 265 HWTEST(AddressUtilsTest, ParseLogMacTest, TestSize.Level1) 266 { 267 uint8_t testMac[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x43, 0}; 268 EXPECT_STREQ("??:ae:??:??:9f:43", ParseLogMac(testMac)); 269 uint8_t* testMac1 = nullptr; 270 char* result = ParseLogMac(testMac1); 271 ASSERT_TRUE(result == 0); 272 } 273 274 HWTEST(AddressUtilsTest, AddrEquelsTest, TestSize.Level1) 275 { 276 uint8_t testMac1[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x43, 0}; 277 uint8_t testMac2[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x43, 0}; 278 uint8_t testMac3[DHCP_HWADDR_LENGTH] = {0, 0xae, 0xdc, 0xcc, 0x9f, 0x45, 0}; 279 280 EXPECT_EQ(1, AddrEquels(testMac1, testMac2, MAC_ADDR_LENGTH)); 281 EXPECT_EQ(0, AddrEquels(testMac1, testMac3, MAC_ADDR_LENGTH)); 282 EXPECT_EQ(0, AddrEquels(testMac2, testMac3, MAC_ADDR_LENGTH)); 283 } 284 } 285 }