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