| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "portier/ll_address.h" |
| |
| #include <linux/if_packet.h> |
| #include <net/if_arp.h> |
| #include <sys/socket.h> |
| |
| #include <gtest/gtest.h> |
| #include <shill/net/byte_string.h> |
| |
| namespace portier { |
| |
| using std::string; |
| using shill::ByteString; |
| using Type = LLAddress::Type; |
| |
| // Testing constants. |
| namespace { |
| |
| // clang-format off |
| |
| constexpr uint8_t kEui48UnicastUniversal1[] = { |
| 0xa0, 0x8c, 0xfd, 0xc3, 0xb3, 0xc0 |
| }; |
| constexpr char kEui48UnicastUniversalString1[] = "a0:8c:fd:c3:b3:c0"; |
| const struct sockaddr_ll kEui48UnicastUniversalSockAddr1 = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0xa0, 0x8c, 0xfd, 0xc3, 0xb3, 0xc0 |
| } |
| }; |
| |
| constexpr uint8_t kEui48UnicastLocal1[] = { |
| 0xa2, 0x8c, 0xfd, 0xc3, 0xb3, 0xbf |
| }; |
| constexpr char kEui48UnicastLocalString1[] = "a2:8c:fd:c3:b3:bf"; |
| const struct sockaddr_ll kEui48UnicastLocalSockAddr1 = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0xa2, 0x8c, 0xfd, 0xc3, 0xb3, 0xbf |
| } |
| }; |
| |
| constexpr uint8_t kEui48MulticastUniversal1[] = { |
| 0x01, 0x00, 0x0C, 0xCC, 0xCC, 0xCC |
| }; |
| constexpr char kEui48MulticastUniversalString1[] = "01:00:0c:cc:cc:cc"; |
| const struct sockaddr_ll kEui48MulticastUniversalSockAddr1 = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0x01, 0x00, 0x0C, 0xCC, 0xCC, 0xCC |
| } |
| }; |
| |
| constexpr uint8_t kEui48MulticastLocal1[] = { |
| 0x33, 0x33, 0xfe, 0xdf, 0xdc, 0x4e |
| }; |
| constexpr char kEui48MulticastLocalString1[] = "33:33:fe:df:dc:4e"; |
| const struct sockaddr_ll kEui48MulticastLocalSockAddr1 = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0x33, 0x33, 0xfe, 0xdf, 0xdc, 0x4e |
| } |
| }; |
| |
| constexpr uint8_t kEui48Broadcast[] = { |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff |
| }; |
| constexpr char kEui48BroadcastString[] = "ff:ff:ff:ff:ff:ff"; |
| const struct sockaddr_ll kEui48BroadcastSockAddr = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0xff, 0xff, 0xff, 0xff, 0xff, 0xff |
| } |
| }; |
| |
| constexpr char kEui48MixedCaseString1[] = "eE:fF:3c:22:6A:bB"; |
| constexpr char kEui48MixedCaseString2[] = "EE:fF:3c:22:6a:bb"; |
| constexpr char kEui48MixedCaseString3[] = "ee:ff:3C:22:6A:BB"; |
| |
| // Bad address. |
| |
| constexpr uint8_t kWayTooLong[] = { |
| 0xaa, 0xf3, 0x12, 0x32, 0x03, 0xc3, 0x86, 0xb3, 0x41, 0x96, |
| 0x01, 0x64, 0x0a, 0x79, 0x79, 0xa0, 0x13, 0x28, 0xf4, 0x26 |
| }; |
| constexpr uint8_t kWayTooShort[] = { |
| 0x00 |
| }; |
| |
| constexpr char kEui48WithDashes[] = "11-22-33-44-55-66"; |
| constexpr char kEui64WithDashes[] = "11-22-33-44-55-66-77-88"; |
| |
| constexpr char kLeadingSpaces[] = " 12:23:34:45:56:67"; |
| constexpr char kTrailingSpaces[] = "12:23:34:45:56:67 "; |
| constexpr char kLeadingAndTrailingSpaces[] = " 12:23:34:45:56:67 "; |
| constexpr char kCenterSpaces[] = "11:22:33 :44:55:66"; |
| |
| constexpr char kNotAnAddress[] = "To be or not to be"; |
| constexpr char kMixedColonsAndDashes[] = "50-ef:1f-61:d1-e7"; |
| constexpr char kNotHexidecimal[] = "50:ef:1g:6z:d1:e7"; |
| constexpr char kEmptyString[] = ""; |
| |
| constexpr char kInnerSingleCharacters[] = "ee:ee:e:ee:ee:ee"; |
| constexpr char kLeadingSingleCharacters[] = "e:ee:ee:ee:ee:ee"; |
| constexpr char kTrailingSingleCharacters[] = "ee:ee:ee:ee:ee:e"; |
| constexpr char kInnerTripleCharacters[] = "ee:eee:ee:ee:ee:ee"; |
| constexpr char kLeadingTripleCharacters[] = "eee:ee:ee:ee:ee:ee"; |
| constexpr char kTrailingTripleCharacters[] = "ee:ee:ee:ee:ee:eee"; |
| |
| constexpr char kTrailingColons[] = "ee:ee:ee:ee:ee:ee:"; |
| constexpr char kLeadingColons[] = ":ee:ee:ee:ee:ee:ee"; |
| constexpr char kDoubleColon[] = "ee:ee:ee::ee:ee:ee"; |
| |
| constexpr char kWithoutLeadingZeros[] = "50:ef:f:61:1:e7"; |
| |
| // Valid but used for swapped types. |
| constexpr char kValidEui48[] = "ee:ee:ee:ee:ee:ee"; |
| constexpr char kValidEui64[] = "ee:ee:ee:ee:ee:ee:ee:ee"; |
| |
| const struct sockaddr_ll kUnknownHardwareType = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_HDLC, |
| .sll_halen = 6, |
| .sll_addr = { |
| 0x27, 0xea, 0x87, 0x12, 0x86, 0xc5 |
| } |
| }; |
| const struct sockaddr_ll kBadLengthForType = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_ETHER, |
| .sll_halen = 8, |
| .sll_addr = { |
| 0x3, 0x38, 0x73, 0x2c, 0xec, 0x1c, 0x37, 0x32 |
| } |
| }; |
| |
| const struct sockaddr_ll kBadLengthForStruct = { |
| .sll_family = AF_PACKET, |
| .sll_hatype = ARPHRD_EUI64, |
| .sll_halen = 19, |
| .sll_addr = { |
| 0x3, 0x38, 0x73, 0x2c, 0xec, 0x1c, 0x37, 0x1c |
| } |
| }; |
| |
| // clang-format on |
| |
| } // namespace |
| |
| TEST(LLAddressTest, EmptyInstance) { |
| // Make an empty LL address and check that all methods return the expected |
| // result. |
| const LLAddress empty_address; |
| |
| EXPECT_FALSE(empty_address.IsValid()); |
| EXPECT_EQ(Type::kInvalid, empty_address.type()); |
| |
| EXPECT_EQ(empty_address.GetLength(), 0); |
| |
| // Routing schemes. |
| EXPECT_FALSE(empty_address.IsUnicast()); |
| EXPECT_FALSE(empty_address.IsMulticast()); |
| EXPECT_FALSE(empty_address.IsBroadcast()); |
| |
| EXPECT_FALSE(empty_address.IsUniversal()); |
| EXPECT_FALSE(empty_address.IsLocal()); |
| |
| const LLAddress other_empty_address = empty_address; |
| |
| EXPECT_FALSE(other_empty_address.Equals(empty_address)); |
| EXPECT_FALSE(empty_address.Equals(other_empty_address)); |
| EXPECT_TRUE(empty_address.Equals(empty_address)); |
| } |
| |
| // EUI-48 Tests. |
| |
| TEST(LLAddressTest, Eui48FromBytes) { |
| // Unicast-Universal. |
| const ByteString uni_uni_address_bytes(kEui48UnicastUniversal1, |
| sizeof(kEui48UnicastUniversal1)); |
| const LLAddress uni_uni_address(Type::kEui48, uni_uni_address_bytes); |
| |
| ASSERT_TRUE(uni_uni_address.IsValid()); |
| |
| EXPECT_EQ(uni_uni_address.type(), Type::kEui48); |
| EXPECT_EQ(uni_uni_address.GetLength(), 6); |
| EXPECT_TRUE(uni_uni_address.address().Equals(uni_uni_address_bytes)); |
| |
| EXPECT_TRUE(uni_uni_address.IsUnicast()); |
| EXPECT_FALSE(uni_uni_address.IsMulticast()); |
| EXPECT_FALSE(uni_uni_address.IsBroadcast()); |
| |
| EXPECT_TRUE(uni_uni_address.IsUniversal()); |
| EXPECT_FALSE(uni_uni_address.IsLocal()); |
| |
| EXPECT_EQ(uni_uni_address.ToString(), kEui48UnicastUniversalString1); |
| EXPECT_TRUE(uni_uni_address.Equals(uni_uni_address)); |
| |
| // Unicast-Local. |
| const ByteString uni_loc_address_bytes(kEui48UnicastLocal1, |
| sizeof(kEui48UnicastLocal1)); |
| const LLAddress uni_loc_address(Type::kEui48, uni_loc_address_bytes); |
| |
| ASSERT_TRUE(uni_loc_address.IsValid()); |
| |
| EXPECT_EQ(uni_loc_address.type(), Type::kEui48); |
| EXPECT_EQ(uni_loc_address.GetLength(), 6); |
| EXPECT_TRUE(uni_loc_address.address().Equals(uni_loc_address_bytes)); |
| |
| EXPECT_TRUE(uni_loc_address.IsUnicast()); |
| EXPECT_FALSE(uni_loc_address.IsMulticast()); |
| EXPECT_FALSE(uni_loc_address.IsBroadcast()); |
| |
| EXPECT_FALSE(uni_loc_address.IsUniversal()); |
| EXPECT_TRUE(uni_loc_address.IsLocal()); |
| |
| EXPECT_EQ(uni_loc_address.ToString(), kEui48UnicastLocalString1); |
| EXPECT_TRUE(uni_loc_address.Equals(uni_loc_address)); |
| |
| // Multi-Universal. |
| const ByteString multi_uni_address_bytes(kEui48MulticastUniversal1, |
| sizeof(kEui48MulticastUniversal1)); |
| const LLAddress multi_uni_address(Type::kEui48, multi_uni_address_bytes); |
| |
| ASSERT_TRUE(multi_uni_address.IsValid()); |
| |
| EXPECT_EQ(multi_uni_address.type(), Type::kEui48); |
| EXPECT_EQ(multi_uni_address.GetLength(), 6); |
| EXPECT_TRUE(multi_uni_address.address().Equals(multi_uni_address_bytes)); |
| |
| EXPECT_FALSE(multi_uni_address.IsUnicast()); |
| EXPECT_TRUE(multi_uni_address.IsMulticast()); |
| EXPECT_FALSE(multi_uni_address.IsBroadcast()); |
| |
| EXPECT_TRUE(multi_uni_address.IsUniversal()); |
| EXPECT_FALSE(multi_uni_address.IsLocal()); |
| |
| EXPECT_EQ(multi_uni_address.ToString(), kEui48MulticastUniversalString1); |
| EXPECT_TRUE(multi_uni_address.Equals(multi_uni_address)); |
| |
| // Multi-Local. |
| const ByteString multi_loc_address_bytes(kEui48MulticastLocal1, |
| sizeof(kEui48MulticastLocal1)); |
| const LLAddress multi_loc_address(Type::kEui48, multi_loc_address_bytes); |
| |
| ASSERT_TRUE(multi_loc_address.IsValid()); |
| |
| EXPECT_EQ(multi_loc_address.type(), Type::kEui48); |
| EXPECT_EQ(multi_loc_address.GetLength(), 6); |
| EXPECT_TRUE(multi_loc_address.address().Equals(multi_loc_address_bytes)); |
| |
| EXPECT_FALSE(multi_loc_address.IsUnicast()); |
| EXPECT_TRUE(multi_loc_address.IsMulticast()); |
| EXPECT_FALSE(multi_loc_address.IsBroadcast()); |
| |
| EXPECT_FALSE(multi_loc_address.IsUniversal()); |
| EXPECT_TRUE(multi_loc_address.IsLocal()); |
| |
| EXPECT_EQ(multi_loc_address.ToString(), kEui48MulticastLocalString1); |
| EXPECT_TRUE(multi_loc_address.Equals(multi_loc_address)); |
| |
| // Broadcast. |
| const ByteString broadcast_address_bytes(kEui48Broadcast, |
| sizeof(kEui48Broadcast)); |
| const LLAddress broadcast_address(Type::kEui48, broadcast_address_bytes); |
| |
| ASSERT_TRUE(broadcast_address.IsValid()); |
| |
| EXPECT_EQ(broadcast_address.type(), Type::kEui48); |
| EXPECT_EQ(broadcast_address.GetLength(), 6); |
| EXPECT_TRUE(broadcast_address.address().Equals(broadcast_address_bytes)); |
| |
| EXPECT_FALSE(broadcast_address.IsUnicast()); |
| EXPECT_TRUE(broadcast_address.IsMulticast()); |
| EXPECT_TRUE(broadcast_address.IsBroadcast()); |
| |
| EXPECT_FALSE(broadcast_address.IsUniversal()); |
| EXPECT_TRUE(broadcast_address.IsLocal()); |
| |
| EXPECT_EQ(broadcast_address.ToString(), kEui48BroadcastString); |
| EXPECT_TRUE(broadcast_address.Equals(broadcast_address)); |
| |
| // Comparisons. |
| EXPECT_FALSE(uni_uni_address.Equals(uni_loc_address)); |
| EXPECT_FALSE(uni_uni_address.Equals(multi_uni_address)); |
| EXPECT_FALSE(uni_uni_address.Equals(multi_loc_address)); |
| EXPECT_FALSE(uni_uni_address.Equals(broadcast_address)); |
| |
| EXPECT_FALSE(uni_loc_address.Equals(multi_uni_address)); |
| EXPECT_FALSE(uni_loc_address.Equals(multi_loc_address)); |
| EXPECT_FALSE(uni_loc_address.Equals(broadcast_address)); |
| |
| EXPECT_FALSE(multi_uni_address.Equals(multi_loc_address)); |
| EXPECT_FALSE(multi_uni_address.Equals(broadcast_address)); |
| |
| EXPECT_FALSE(multi_loc_address.Equals(broadcast_address)); |
| } |
| |
| TEST(LLAddressTest, Eui48FromOthers) { |
| // Test that each constructor call results in the same object as the |
| // byte derived address. It is assumed that the byte derived address |
| // is correct as it was tested in the Eui48FromBytes testcase. |
| // Unicast-Universal. |
| |
| const LLAddress uni_uni_address( |
| Type::kEui48, |
| ByteString(kEui48UnicastUniversal1, sizeof(kEui48UnicastUniversal1))); |
| const LLAddress uni_uni_str_address(Type::kEui48, |
| kEui48UnicastUniversalString1); |
| const LLAddress uni_uni_ll_struct_address(&kEui48UnicastUniversalSockAddr1); |
| |
| ASSERT_TRUE(uni_uni_address.IsValid()); |
| EXPECT_TRUE(uni_uni_str_address.IsValid()); |
| EXPECT_TRUE(uni_uni_ll_struct_address.IsValid()); |
| |
| EXPECT_EQ(uni_uni_ll_struct_address.type(), Type::kEui48); |
| |
| EXPECT_TRUE(uni_uni_address.Equals(uni_uni_str_address)); |
| EXPECT_TRUE(uni_uni_address.Equals(uni_uni_ll_struct_address)); |
| |
| // Unicast-Local. |
| const LLAddress uni_loc_address( |
| Type::kEui48, |
| ByteString(kEui48UnicastLocal1, sizeof(kEui48UnicastLocal1))); |
| const LLAddress uni_loc_str_address(Type::kEui48, kEui48UnicastLocalString1); |
| const LLAddress uni_loc_ll_struct_address(&kEui48UnicastLocalSockAddr1); |
| |
| ASSERT_TRUE(uni_loc_address.IsValid()); |
| EXPECT_TRUE(uni_loc_str_address.IsValid()); |
| EXPECT_TRUE(uni_loc_ll_struct_address.IsValid()); |
| |
| EXPECT_EQ(uni_loc_ll_struct_address.type(), Type::kEui48); |
| |
| EXPECT_TRUE(uni_loc_address.Equals(uni_loc_str_address)); |
| EXPECT_TRUE(uni_loc_address.Equals(uni_loc_ll_struct_address)); |
| |
| // Multi-Universal. |
| const LLAddress multi_uni_address( |
| Type::kEui48, |
| ByteString(kEui48MulticastUniversal1, sizeof(kEui48MulticastUniversal1))); |
| const LLAddress multi_uni_str_address(Type::kEui48, |
| kEui48MulticastUniversalString1); |
| const LLAddress multi_uni_ll_struct_address( |
| &kEui48MulticastUniversalSockAddr1); |
| |
| ASSERT_TRUE(multi_uni_address.IsValid()); |
| EXPECT_TRUE(multi_uni_str_address.IsValid()); |
| EXPECT_TRUE(multi_uni_ll_struct_address.IsValid()); |
| |
| EXPECT_EQ(multi_uni_ll_struct_address.type(), Type::kEui48); |
| |
| EXPECT_TRUE(multi_uni_address.Equals(multi_uni_str_address)); |
| EXPECT_TRUE(multi_uni_address.Equals(multi_uni_ll_struct_address)); |
| |
| // Multi-Local. |
| const LLAddress multi_loc_address( |
| Type::kEui48, |
| ByteString(kEui48MulticastLocal1, sizeof(kEui48MulticastLocal1))); |
| const LLAddress multi_loc_str_address(Type::kEui48, |
| kEui48MulticastLocalString1); |
| const LLAddress multi_loc_ll_struct_address(&kEui48MulticastLocalSockAddr1); |
| |
| ASSERT_TRUE(multi_loc_address.IsValid()); |
| EXPECT_TRUE(multi_loc_str_address.IsValid()); |
| EXPECT_TRUE(multi_loc_ll_struct_address.IsValid()); |
| |
| EXPECT_EQ(multi_loc_ll_struct_address.type(), Type::kEui48); |
| |
| EXPECT_TRUE(multi_loc_address.Equals(multi_loc_str_address)); |
| EXPECT_TRUE(multi_loc_address.Equals(multi_loc_ll_struct_address)); |
| |
| // Broadcast. |
| const LLAddress broadcast_address( |
| Type::kEui48, ByteString(kEui48Broadcast, sizeof(kEui48Broadcast))); |
| const LLAddress broadcast_str_address(Type::kEui48, kEui48BroadcastString); |
| const LLAddress broadcast_ll_struct_address(&kEui48BroadcastSockAddr); |
| |
| ASSERT_TRUE(broadcast_address.IsValid()); |
| EXPECT_TRUE(broadcast_str_address.IsValid()); |
| EXPECT_TRUE(broadcast_ll_struct_address.IsValid()); |
| |
| EXPECT_EQ(broadcast_ll_struct_address.type(), Type::kEui48); |
| |
| EXPECT_TRUE(broadcast_address.Equals(broadcast_str_address)); |
| EXPECT_TRUE(broadcast_address.Equals(broadcast_ll_struct_address)); |
| } |
| |
| TEST(LLAddressTest, Eui48MixedCase) { |
| // Valid but mixed lowercase and uppercase |
| const LLAddress address1(Type::kEui48, kEui48MixedCaseString1); |
| const LLAddress address2(Type::kEui48, kEui48MixedCaseString2); |
| const LLAddress address3(Type::kEui48, kEui48MixedCaseString3); |
| |
| ASSERT_TRUE(address1.IsValid()); |
| ASSERT_TRUE(address2.IsValid()); |
| ASSERT_TRUE(address3.IsValid()); |
| |
| EXPECT_TRUE(address1.Equals(address2)); |
| EXPECT_TRUE(address1.Equals(address3)); |
| EXPECT_TRUE(address2.Equals(address1)); |
| EXPECT_TRUE(address2.Equals(address3)); |
| EXPECT_TRUE(address3.Equals(address1)); |
| EXPECT_TRUE(address3.Equals(address2)); |
| } |
| |
| TEST(LLAddressTest, EuiWithDashes) { |
| const LLAddress eui_48_with_dashes(Type::kEui48, kEui48WithDashes); |
| const LLAddress eui_64_with_dashes(Type::kEui64, kEui64WithDashes); |
| |
| EXPECT_FALSE(eui_48_with_dashes.IsValid()); |
| EXPECT_FALSE(eui_64_with_dashes.IsValid()); |
| } |
| |
| TEST(LLAddressTest, Eui48WithSpaces) { |
| const LLAddress leading_spaces_address(Type::kEui48, kLeadingSpaces); |
| const LLAddress trailing_spaces_address(Type::kEui48, kTrailingSpaces); |
| const LLAddress leading_and_trailing_spaces_address( |
| Type::kEui48, kLeadingAndTrailingSpaces); |
| const LLAddress center_spaces_address(Type::kEui48, kCenterSpaces); |
| |
| EXPECT_FALSE(leading_spaces_address.IsValid()); |
| EXPECT_FALSE(trailing_spaces_address.IsValid()); |
| EXPECT_FALSE(leading_and_trailing_spaces_address.IsValid()); |
| EXPECT_FALSE(center_spaces_address.IsValid()); |
| } |
| |
| TEST(LLAddressTest, Eui48BadStrings) { |
| // Invalid strings. |
| const LLAddress not_an_address(Type::kEui48, kNotAnAddress); |
| const LLAddress mixed_col_n_dash_address(Type::kEui48, kMixedColonsAndDashes); |
| const LLAddress not_hex_address(Type::kEui48, kNotHexidecimal); |
| const LLAddress empty_string_address(Type::kEui48, kEmptyString); |
| |
| EXPECT_FALSE(not_an_address.IsValid()); |
| EXPECT_FALSE(mixed_col_n_dash_address.IsValid()); |
| EXPECT_FALSE(not_hex_address.IsValid()); |
| EXPECT_FALSE(empty_string_address.IsValid()); |
| } |
| |
| TEST(LLAddressTest, InvalidHexOclet) { |
| const LLAddress inner_single_character_address(Type::kEui48, |
| kInnerSingleCharacters); |
| const LLAddress leading_single_character_address(Type::kEui48, |
| kLeadingSingleCharacters); |
| const LLAddress trailing_single_character_address(Type::kEui48, |
| kTrailingSingleCharacters); |
| const LLAddress inner_triple_character_address(Type::kEui48, |
| kInnerTripleCharacters); |
| const LLAddress leading_triple_character_address(Type::kEui48, |
| kLeadingTripleCharacters); |
| const LLAddress trailing_triple_character_address(Type::kEui48, |
| kTrailingTripleCharacters); |
| |
| EXPECT_FALSE(inner_single_character_address.IsValid()); |
| EXPECT_FALSE(leading_single_character_address.IsValid()); |
| EXPECT_FALSE(trailing_single_character_address.IsValid()); |
| EXPECT_FALSE(inner_triple_character_address.IsValid()); |
| EXPECT_FALSE(leading_triple_character_address.IsValid()); |
| EXPECT_FALSE(trailing_triple_character_address.IsValid()); |
| } |
| |
| TEST(LLAddressTest, InvalidOcletSeparator) { |
| const LLAddress trailing_colon_address(Type::kEui48, kTrailingColons); |
| const LLAddress leading_colon_address(Type::kEui48, kLeadingColons); |
| const LLAddress double_colon_address(Type::kEui48, kDoubleColon); |
| |
| EXPECT_FALSE(trailing_colon_address.IsValid()); |
| EXPECT_FALSE(leading_colon_address.IsValid()); |
| EXPECT_FALSE(double_colon_address.IsValid()); |
| } |
| |
| TEST(LLAddressTest, Eui48WithoutLeadingZeros) { |
| const LLAddress without_leading_zeros(Type::kEui48, kWithoutLeadingZeros); |
| |
| EXPECT_FALSE(without_leading_zeros.IsValid()); |
| } |
| |
| TEST(LLAddressTest, SwappedEuiTypes) { |
| const LLAddress eui_48_from_64(Type::kEui48, kValidEui64); |
| const LLAddress eui_64_from_48(Type::kEui64, kValidEui48); |
| |
| EXPECT_FALSE(eui_48_from_64.IsValid()); |
| EXPECT_FALSE(eui_64_from_48.IsValid()); |
| } |
| |
| TEST(LLAddressTest, BadSizeBytes) { |
| // Invalid bytes. |
| const LLAddress eui_48_too_short( |
| Type::kEui48, ByteString(kWayTooShort, sizeof(kWayTooShort))); |
| const LLAddress eui_64_too_short( |
| Type::kEui64, ByteString(kWayTooShort, sizeof(kWayTooShort))); |
| |
| const LLAddress eui_48_too_long(Type::kEui48, |
| ByteString(kWayTooLong, sizeof(kWayTooLong))); |
| const LLAddress eui_64_too_long(Type::kEui64, |
| ByteString(kWayTooLong, sizeof(kWayTooLong))); |
| |
| EXPECT_FALSE(eui_48_too_short.IsValid()); |
| EXPECT_FALSE(eui_64_too_short.IsValid()); |
| EXPECT_FALSE(eui_48_too_long.IsValid()); |
| EXPECT_FALSE(eui_64_too_long.IsValid()); |
| } |
| |
| TEST(LLAddressTest, BadSockAddrStructs) { |
| // Bad sockaddr_ll structs. |
| const LLAddress unknown_hardware_address(&kUnknownHardwareType); |
| const LLAddress bad_length_for_type_address(&kBadLengthForType); |
| const LLAddress bad_length_for_struct(&kBadLengthForStruct); |
| |
| EXPECT_FALSE(unknown_hardware_address.IsValid()); |
| EXPECT_FALSE(bad_length_for_type_address.IsValid()); |
| EXPECT_FALSE(bad_length_for_struct.IsValid()); |
| } |
| |
| } // namespace portier |