| // Copyright 2016 Andrew Baumhauer <andy@baumhauer.us> |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| //! Represent and parse IEEE EUI-48 Media Access Control addresses |
| //! The IEEE claims trademarks on the names EUI-48 and EUI-64, in which EUI is an |
| //! abbreviation for Extended Unique Identifier. |
| |
| #![doc( |
| html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png", |
| html_favicon_url = "https://www.rust-lang.org/favicon.ico", |
| html_root_url = "https://doc.rust-lang.org/eui48/" |
| )] |
| |
| extern crate regex; |
| #[cfg(feature = "rustc-serialize")] |
| extern crate rustc_serialize; |
| #[cfg(feature = "serde")] |
| extern crate serde; |
| #[cfg(feature = "serde_json")] |
| extern crate serde_json; |
| |
| use std::default::Default; |
| use std::error::Error; |
| use std::fmt; |
| use std::str::FromStr; |
| |
| use regex::Regex; |
| #[cfg(feature = "rustc-serialize")] |
| use rustc_serialize::{Decodable, Decoder, Encodable, Encoder}; |
| #[cfg(feature = "serde")] |
| use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; |
| |
| /// A 48-bit (6 byte) buffer containing the EUI address |
| pub const EUI48LEN: usize = 6; |
| pub type Eui48 = [u8; EUI48LEN]; |
| |
| /// A 64-bit (8 byte) buffer containing the EUI address |
| pub const EUI64LEN: usize = 8; |
| pub type Eui64 = [u8; EUI64LEN]; |
| |
| /// A MAC address (EUI-48) |
| #[repr(C)] |
| #[derive(Copy, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)] |
| pub struct MacAddress { |
| /// The 48-bit number stored in 6 bytes |
| eui: Eui48, |
| } |
| |
| #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)] |
| /// Format to display MacAddress |
| pub enum MacAddressFormat { |
| /// Use - notaion |
| Canonical, |
| /// Use : notation |
| HexString, |
| /// Use . notation |
| DotNotation, |
| /// Use 0x notation |
| Hexadecimal, |
| } |
| |
| #[derive(PartialEq, Eq, Copy, Clone, Debug, Ord, PartialOrd, Hash)] |
| /// Parsing errors |
| pub enum ParseError { |
| /// Length is incorrect (should be 11 to 17) |
| InvalidLength(usize), |
| /// The input string is invalid, usize bytes were found, and we put up to 6 bytes into Eui48 |
| InvalidByteCount(usize, Eui48), |
| } |
| |
| impl MacAddress { |
| /// Create a new MacAddress from `[u8; 6]`. |
| pub const fn new(eui: Eui48) -> MacAddress { |
| MacAddress { eui } |
| } |
| |
| /// Create a new MacAddress from a byte slice. |
| /// |
| /// Returns an error (without any description) if the slice doesn't have the proper length. |
| pub fn from_bytes(bytes: &[u8]) -> Result<Self, ParseError> { |
| if bytes.len() != EUI48LEN { |
| return Err(ParseError::InvalidLength(bytes.len())); |
| } |
| let mut input: [u8; EUI48LEN] = Default::default(); |
| input[..EUI48LEN].clone_from_slice(&bytes[..EUI48LEN]); |
| Ok(Self::new(input)) |
| } |
| |
| /// Returns empty EUI-48 address |
| pub fn nil() -> MacAddress { |
| MacAddress { eui: [0; EUI48LEN] } |
| } |
| |
| /// Returns 'ff:ff:ff:ff:ff:ff', a MAC broadcast address |
| pub fn broadcast() -> MacAddress { |
| MacAddress { |
| eui: [0xFF; EUI48LEN], |
| } |
| } |
| |
| /// Returns true if the address is '00:00:00:00:00:00' |
| pub fn is_nil(&self) -> bool { |
| self.eui.iter().all(|&b| b == 0) |
| } |
| |
| /// Returns true if the address is 'ff:ff:ff:ff:ff:ff' |
| pub fn is_broadcast(&self) -> bool { |
| self.eui.iter().all(|&b| b == 0xFF) |
| } |
| |
| /// Returns true if bit 1 of Y is 0 in address 'xY:xx:xx:xx:xx:xx' |
| pub fn is_unicast(&self) -> bool { |
| self.eui[0] & 1 == 0 |
| } |
| |
| /// Returns true if bit 1 of Y is 1 in address 'xY:xx:xx:xx:xx:xx' |
| pub fn is_multicast(&self) -> bool { |
| self.eui[0] & 1 == 1 |
| } |
| |
| /// Returns true if bit 2 of Y is 0 in address 'xY:xx:xx:xx:xx:xx' |
| pub fn is_universal(&self) -> bool { |
| self.eui[0] & 1 << 1 == 0 |
| } |
| |
| /// Returns true if bit 2 of Y is 1 in address 'xY:xx:xx:xx:xx:xx' |
| pub fn is_local(&self) -> bool { |
| self.eui[0] & 1 << 1 == 2 |
| } |
| |
| /// Returns a String representation in the format '00-00-00-00-00-00' |
| pub fn to_canonical(&self) -> String { |
| format!( |
| "{:02x}-{:02x}-{:02x}-{:02x}-{:02x}-{:02x}", |
| self.eui[0], self.eui[1], self.eui[2], self.eui[3], self.eui[4], self.eui[5] |
| ) |
| } |
| |
| /// Returns a String representation in the format '00:00:00:00:00:00' |
| pub fn to_hex_string(&self) -> String { |
| format!( |
| "{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", |
| self.eui[0], self.eui[1], self.eui[2], self.eui[3], self.eui[4], self.eui[5] |
| ) |
| } |
| |
| /// Returns a String representation in the format '0000.0000.0000' |
| pub fn to_dot_string(&self) -> String { |
| format!( |
| "{:02x}{:02x}.{:02x}{:02x}.{:02x}{:02x}", |
| self.eui[0], self.eui[1], self.eui[2], self.eui[3], self.eui[4], self.eui[5] |
| ) |
| } |
| |
| /// Returns a String representation in the format '0x000000000000' |
| pub fn to_hexadecimal(&self) -> String { |
| format!( |
| "0x{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}", |
| self.eui[0], self.eui[1], self.eui[2], self.eui[3], self.eui[4], self.eui[5] |
| ) |
| } |
| |
| /// Returns a String representation in the EUI-64 interface ID format '0000:00ff:fe00:0000' |
| pub fn to_interfaceid(&self) -> String { |
| format!( |
| "{:02x}{:02x}:{:02x}ff:fe{:02x}:{:02x}{:02x}", |
| (self.eui[0] ^ 0x02), |
| self.eui[1], |
| self.eui[2], |
| self.eui[3], |
| self.eui[4], |
| self.eui[5] |
| ) |
| } |
| |
| /// Returns a String representation in the IPv6 link local format 'fe80::0000:00ff:fe00:0000' |
| pub fn to_link_local(&self) -> String { |
| format!( |
| "fe80::{:02x}{:02x}:{:02x}ff:fe{:02x}:{:02x}{:02x}", |
| (self.eui[0] ^ 0x02), |
| self.eui[1], |
| self.eui[2], |
| self.eui[3], |
| self.eui[4], |
| self.eui[5] |
| ) |
| } |
| |
| /// Returns a String in the format selected by fmt |
| pub fn to_string(&self, fmt: MacAddressFormat) -> String { |
| match fmt { |
| MacAddressFormat::Canonical => self.to_canonical(), |
| MacAddressFormat::HexString => self.to_hex_string(), |
| MacAddressFormat::DotNotation => self.to_dot_string(), |
| MacAddressFormat::Hexadecimal => self.to_hexadecimal(), |
| } |
| } |
| |
| /// Parses a String representation from any format supported |
| pub fn parse_str(s: &str) -> Result<MacAddress, ParseError> { |
| let re = Regex::new("(0x)?([0-9a-fA-F]{1,2})[:.-]?").unwrap(); |
| let mut eui: Eui48 = [0; EUI48LEN]; |
| |
| match s.len() { |
| 11..=17 => {} |
| _ => { |
| return Err(ParseError::InvalidLength(s.len())); |
| } |
| } |
| |
| let mut i = 0; |
| for caps in re.captures_iter(s) { |
| // Fill the array and keep counting for InvalidByteCount |
| if i < EUI48LEN { |
| let matched_byte = caps.get(2).unwrap().as_str(); |
| eui[i] = u8::from_str_radix(matched_byte, 16).unwrap(); |
| } |
| i += 1; |
| } |
| |
| if i != EUI48LEN { |
| return Err(ParseError::InvalidByteCount(i, eui)); |
| } |
| |
| Ok(MacAddress::new(eui)) |
| } |
| |
| /// Return the internal structure as a slice of bytes |
| pub fn as_bytes(&self) -> &[u8] { |
| &self.eui |
| } |
| |
| /// Returns an array in Eui48. Works as an inverse function of new() |
| pub fn to_array(&self) -> Eui48 { |
| self.eui |
| } |
| |
| /// Returns Display MacAddressFormat, determined at compile time. |
| pub fn get_display_format() -> MacAddressFormat { |
| if cfg!(feature = "disp_hexstring") { |
| MacAddressFormat::HexString |
| } else { |
| MacAddressFormat::Canonical |
| } |
| } |
| } |
| |
| impl FromStr for MacAddress { |
| type Err = ParseError; |
| /// Create a MacAddress from String |
| fn from_str(us: &str) -> Result<MacAddress, ParseError> { |
| MacAddress::parse_str(us) |
| } |
| } |
| |
| impl Default for MacAddress { |
| /// Create a Default MacAddress (00-00-00-00-00-00) |
| fn default() -> MacAddress { |
| MacAddress::nil() |
| } |
| } |
| |
| impl fmt::Debug for MacAddress { |
| /// Debug format for MacAddress is HexString notation |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!( |
| f, |
| "MacAddress(\"{}\")", |
| self.to_string(MacAddressFormat::HexString) |
| ) |
| } |
| } |
| |
| impl fmt::Display for MacAddress { |
| /// Display format is canonical format (00-00-00-00-00-00) by default |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| let disp_fmt = MacAddress::get_display_format(); |
| write!(f, "{}", self.to_string(disp_fmt)) |
| } |
| } |
| |
| impl fmt::Display for ParseError { |
| /// Human readable error strings for ParseError enum |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match *self { |
| ParseError::InvalidLength(found) => write!( |
| f, |
| "Invalid length; expecting 11 to 17 chars, found {}", |
| found |
| ), |
| ParseError::InvalidByteCount(found, eui) => write!( |
| f, |
| "Invalid byte count; Matched `{}` bytes ({:?})", |
| found, |
| &eui[..found] |
| ), |
| } |
| } |
| } |
| |
| impl Error for ParseError { |
| /// Human readable description for ParseError enum |
| fn description(&self) -> &str { |
| "MacAddress parse error" |
| } |
| } |
| |
| #[cfg(feature = "rustc-serialize")] |
| impl Encodable for MacAddress { |
| /// Encode a MacAddress using the default format |
| fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> { |
| let disp_fmt = MacAddress::get_display_format(); |
| e.emit_str(&self.to_string(disp_fmt)) |
| } |
| } |
| |
| #[cfg(feature = "rustc-serialize")] |
| impl Decodable for MacAddress { |
| /// Decode a MacAddress from a string in canonical form |
| fn decode<D: Decoder>(d: &mut D) -> Result<MacAddress, D::Error> { |
| let string = d.read_str()?; |
| string.parse().map_err(|err| d.error(&format!("{}", err))) |
| } |
| } |
| |
| #[cfg(all(feature = "serde", not(feature = "serde_bytes")))] |
| impl Serialize for MacAddress { |
| /// Serialize a MacAddress in the default format using the serde crate |
| fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { |
| let disp_fmt = MacAddress::get_display_format(); |
| serializer.serialize_str(&self.to_string(disp_fmt)) |
| } |
| } |
| |
| #[cfg(feature = "serde_bytes")] |
| impl Serialize for MacAddress { |
| /// Serialize a MacAddress as raw bytes using the serde crate |
| fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> { |
| serializer.serialize_bytes(self.as_bytes()) |
| } |
| } |
| |
| #[cfg(all(feature = "serde", not(feature = "serde_bytes")))] |
| impl<'de> Deserialize<'de> for MacAddress { |
| /// Deserialize a MacAddress from canonical form using the serde crate |
| fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| struct MacAddressVisitor; |
| impl<'de> de::Visitor<'de> for MacAddressVisitor { |
| type Value = MacAddress; |
| |
| fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| write!(formatter, "a string representation of a MAC address") |
| } |
| |
| fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> { |
| value.parse().map_err(|err| E::custom(&format!("{}", err))) |
| } |
| } |
| deserializer.deserialize_str(MacAddressVisitor) |
| } |
| } |
| |
| #[cfg(feature = "serde_bytes")] |
| impl<'de> Deserialize<'de> for MacAddress { |
| /// Deserialize a MacAddress from raw bytes using the serde crate |
| fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> { |
| struct MacAddressVisitor; |
| impl<'de> de::Visitor<'de> for MacAddressVisitor { |
| type Value = MacAddress; |
| |
| fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { |
| write!(formatter, "6-element byte array") |
| } |
| |
| fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Self::Value, E> { |
| MacAddress::from_bytes(value).map_err(|_| E::invalid_length(value.len(), &self)) |
| } |
| } |
| deserializer.deserialize_bytes(MacAddressVisitor) |
| } |
| } |
| |
| // ************** TESTS BEGIN HERE *************** |
| #[cfg(test)] |
| mod tests { |
| use super::{Eui48, MacAddress, MacAddressFormat, ParseError}; |
| |
| #[test] |
| fn test_new() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| |
| assert!(mac.eui[0..5] == eui[0..5]); |
| } |
| |
| #[test] |
| fn test_from_bytes() { |
| assert_eq!( |
| "12:34:56:ab:cd:ef", |
| MacAddress::from_bytes(&[0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]) |
| .unwrap() |
| .to_hex_string() |
| ); |
| assert!(MacAddress::from_bytes(&[0x12, 0x34, 0x56, 0xAB, 0xCD]).is_err()); |
| } |
| |
| #[test] |
| fn test_nil() { |
| let nil = MacAddress::nil(); |
| let not_nil = MacAddress::broadcast(); |
| assert_eq!("00:00:00:00:00:00", nil.to_hex_string()); |
| assert!(nil.is_nil()); |
| assert!(!not_nil.is_nil()); |
| } |
| |
| #[test] |
| fn test_default() { |
| let default = MacAddress::default(); |
| assert!(default.is_nil()); |
| } |
| |
| #[test] |
| fn test_broadcast() { |
| let broadcast = MacAddress::broadcast(); |
| let not_broadcast = MacAddress::nil(); |
| assert_eq!("ff:ff:ff:ff:ff:ff", broadcast.to_hex_string()); |
| assert!(broadcast.is_broadcast()); |
| assert!(!not_broadcast.is_broadcast()); |
| } |
| |
| #[test] |
| fn test_is_nil() { |
| let nil = MacAddress::nil(); |
| let not_nil = MacAddress::parse_str("01:00:5E:AB:CD:EF").unwrap(); |
| assert!(nil.is_nil()); |
| assert!(!not_nil.is_nil()); |
| } |
| |
| #[test] |
| fn test_is_broadcast() { |
| let broadcast = MacAddress::broadcast(); |
| let not_broadcast = MacAddress::parse_str("01:00:5E:AB:CD:EF").unwrap(); |
| assert!(broadcast.is_broadcast()); |
| assert!(!not_broadcast.is_broadcast()); |
| } |
| |
| #[test] |
| fn test_is_unicast() { |
| let mac_u = MacAddress::parse_str("FE:00:5E:AB:CD:EF").unwrap(); |
| let mac_m = MacAddress::parse_str("01:00:5E:AB:CD:EF").unwrap(); |
| assert!(mac_u.is_unicast()); |
| assert!(!mac_m.is_unicast()); |
| assert_eq!("fe:00:5e:ab:cd:ef", mac_u.to_hex_string()); // Catch modifying first octet |
| let mac = MacAddress::parse_str("FF:00:5E:AB:CD:EF").unwrap(); |
| assert!(!mac.is_unicast()); |
| assert_eq!("ff:00:5e:ab:cd:ef", mac.to_hex_string()); // Catch modifying first octet |
| assert!(MacAddress::nil().is_unicast()); |
| assert!(!MacAddress::broadcast().is_unicast()); |
| } |
| |
| #[test] |
| fn test_is_multicast() { |
| let mac_u = MacAddress::parse_str("FE:00:5E:AB:CD:EF").unwrap(); |
| let mac_m = MacAddress::parse_str("01:00:5E:AB:CD:EF").unwrap(); |
| assert!(!mac_u.is_multicast()); |
| assert!(mac_m.is_multicast()); |
| assert!(!MacAddress::nil().is_multicast()); |
| assert_eq!("01:00:5e:ab:cd:ef", mac_m.to_hex_string()); // Catch modifying first octet |
| let mac = MacAddress::parse_str("F0:00:5E:AB:CD:EF").unwrap(); |
| assert!(!mac.is_multicast()); |
| assert_eq!("f0:00:5e:ab:cd:ef", mac.to_hex_string()); // Catch modifying first octet |
| assert!(MacAddress::broadcast().is_multicast()); |
| } |
| |
| #[test] |
| fn test_is_universal() { |
| let universal = MacAddress::parse_str("11:24:56:AB:CD:EF").unwrap(); |
| let not_universal = MacAddress::parse_str("12:24:56:AB:CD:EF").unwrap(); |
| assert!(universal.is_universal()); |
| assert!(!not_universal.is_universal()); |
| assert_eq!("11:24:56:ab:cd:ef", universal.to_hex_string()); // Catch modifying first octet |
| } |
| |
| #[test] |
| fn test_is_local() { |
| let local = MacAddress::parse_str("06:34:56:AB:CD:EF").unwrap(); |
| let not_local = MacAddress::parse_str("00:34:56:AB:CD:EF").unwrap(); |
| assert!(local.is_local()); |
| assert!(!not_local.is_local()); |
| assert_eq!("06:34:56:ab:cd:ef", local.to_hex_string()); // Catch modifying first octet |
| } |
| |
| #[test] |
| fn test_to_canonical() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("12-34-56-ab-cd-ef", mac.to_canonical()); |
| } |
| |
| #[test] |
| fn test_to_hex_string() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("12:34:56:ab:cd:ef", mac.to_hex_string()); |
| } |
| |
| #[test] |
| fn test_to_dot_string() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("1234.56ab.cdef", mac.to_dot_string()); |
| } |
| |
| #[test] |
| fn test_to_hexadecimal() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("0x123456abcdef", mac.to_hexadecimal()); |
| } |
| |
| #[test] |
| fn test_to_interfaceid() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("1034:56ff:feab:cdef", mac.to_interfaceid()); |
| } |
| |
| #[test] |
| fn test_to_link_local() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!("fe80::1034:56ff:feab:cdef", mac.to_link_local()); |
| } |
| |
| #[test] |
| fn test_to_string() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!( |
| "0x123456abcdef", |
| mac.to_string(MacAddressFormat::Hexadecimal) |
| ); |
| assert_eq!( |
| "1234.56ab.cdef", |
| mac.to_string(MacAddressFormat::DotNotation) |
| ); |
| assert_eq!( |
| "12:34:56:ab:cd:ef", |
| mac.to_string(MacAddressFormat::HexString) |
| ); |
| assert_eq!( |
| "12-34-56-ab-cd-ef", |
| mac.to_string(MacAddressFormat::Canonical) |
| ); |
| } |
| |
| #[test] |
| fn test_parse_str() { |
| use super::ParseError::*; |
| |
| assert_eq!( |
| "0x123456abcdef", |
| MacAddress::parse_str("0x123456ABCDEF") |
| .unwrap() |
| .to_hexadecimal() |
| ); |
| assert_eq!( |
| "1234.56ab.cdef", |
| MacAddress::parse_str("1234.56AB.CDEF") |
| .unwrap() |
| .to_dot_string() |
| ); |
| assert_eq!( |
| "12:34:56:ab:cd:ef", |
| MacAddress::parse_str("12:34:56:AB:CD:EF") |
| .unwrap() |
| .to_hex_string() |
| ); |
| assert_eq!( |
| "12-34-56-ab-cd-ef", |
| MacAddress::parse_str("12-34-56-AB-CD-EF") |
| .unwrap() |
| .to_canonical() |
| ); |
| assert_eq!( |
| "12-34-56-78-90-0a", |
| MacAddress::parse_str("0x1234567890A") |
| .unwrap() |
| .to_canonical() |
| ); |
| assert_eq!( |
| "12-34-56-ab-cd-ef", |
| MacAddress::parse_str("123456ABCDEF") |
| .unwrap() |
| .to_canonical() |
| ); |
| assert_eq!( |
| "00-00-00-00-00-00", |
| MacAddress::parse_str("!0x00000000000") |
| .unwrap() |
| .to_canonical() |
| ); |
| assert_eq!( |
| "00-00-00-00-00-00", |
| MacAddress::parse_str("0x00000000000!") |
| .unwrap() |
| .to_canonical() |
| ); |
| // Test error parsing |
| assert_eq!(MacAddress::parse_str(""), Err(InvalidLength(0))); |
| assert_eq!(MacAddress::parse_str("0"), Err(InvalidLength(1))); |
| assert_eq!( |
| MacAddress::parse_str("1234567890ABCD"), |
| Err(InvalidByteCount(7, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("1234567890ABCDEF"), |
| Err(InvalidByteCount(8, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("01234567890ABCDEF"), |
| Err(InvalidByteCount(9, [0x01, 0x23, 0x45, 0x67, 0x89, 0x0A])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("0x1234567890ABCDE"), |
| Err(InvalidByteCount(8, [0x12, 0x34, 0x56, 0x78, 0x90, 0xAB])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("0x00:01:02:03:"), |
| Err(InvalidByteCount(4, [0, 1, 2, 3, 0, 0])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("0x00:01:02:03:04:"), |
| Err(InvalidByteCount(5, [0, 1, 2, 3, 4, 0])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("::::::::::::::"), |
| Err(InvalidByteCount(0, [0, 0, 0, 0, 0, 0])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str(":::::::::::::::::"), |
| Err(InvalidByteCount(0, [0, 0, 0, 0, 0, 0])) |
| ); |
| assert_eq!( |
| MacAddress::parse_str("0x0x0x0x0x0x0x"), |
| Err(InvalidByteCount(4, [0, 0, 0, 0, 0, 0])) |
| ); |
| } |
| |
| #[test] |
| fn test_as_bytes() { |
| let mac = MacAddress::broadcast(); |
| let bytes = mac.as_bytes(); |
| |
| assert!(bytes.len() == 6); |
| assert!(bytes.iter().all(|&b| b == 0xFF)); |
| } |
| |
| #[test] |
| fn test_compare() { |
| let m1 = MacAddress::nil(); |
| let m2 = MacAddress::broadcast(); |
| assert_eq!(m1, m1); |
| assert_eq!(m2, m2); |
| assert_ne!(m1, m2); |
| assert_ne!(m2, m1); |
| } |
| |
| #[test] |
| fn test_clone() { |
| let m1 = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| let m2 = m1; |
| assert_eq!(m1, m1); |
| assert_eq!(m2, m2); |
| assert_eq!(m1, m2); |
| assert_eq!(m2, m1); |
| } |
| |
| #[test] |
| fn test_serialize() { |
| use rustc_serialize::json; |
| |
| let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| // Format returned is base on compile time of feature(disp_hexstring) |
| if cfg!(feature = "disp_hexstring") { |
| assert_eq!("\"12:34:56:ab:cd:ef\"", json::encode(&mac).unwrap()); |
| } else { |
| assert_eq!("\"12-34-56-ab-cd-ef\"", json::encode(&mac).unwrap()); |
| } |
| } |
| |
| #[test] |
| fn test_deserialize() { |
| use rustc_serialize::json; |
| |
| let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| |
| if cfg!(feature = "disp_hexstring") { |
| let d = "\"12:34:56:AB:CD:EF\""; |
| assert_eq!(mac, json::decode(&d).unwrap()); |
| } else { |
| let d = "\"12-34-56-AB-CD-EF\""; |
| assert_eq!(mac, json::decode(&d).unwrap()); |
| } |
| } |
| |
| #[test] |
| fn test_serialize_roundtrip() { |
| use rustc_serialize::json; |
| |
| let m1 = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| let s = json::encode(&m1).unwrap(); |
| let m2 = json::decode(&s).unwrap(); |
| assert_eq!(m1, m2); |
| } |
| |
| #[test] |
| fn test_fmt_debug() { |
| let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| assert_eq!( |
| "MacAddress(\"12:34:56:ab:cd:ef\")".to_owned(), |
| format!("{:?}", mac) |
| ); |
| } |
| |
| #[test] |
| fn test_fmt() { |
| let mac = MacAddress::parse_str("0x123456ABCDEF").unwrap(); |
| match MacAddress::get_display_format() { |
| MacAddressFormat::HexString => { |
| assert_eq!("12:34:56:ab:cd:ef".to_owned(), format!("{}", mac)) |
| } |
| _ => assert_eq!("12-34-56-ab-cd-ef".to_owned(), format!("{}", mac)), |
| }; |
| } |
| |
| #[test] |
| fn test_fmt_parse_errors() { |
| assert_eq!( |
| "Err(InvalidByteCount(7, [18, 52, 86, 171, 205, 239]))".to_owned(), |
| format!("{:?}", MacAddress::parse_str("123456ABCDEF1")) |
| ); |
| assert_eq!( |
| "Err(InvalidLength(19))", |
| format!("{:?}", MacAddress::parse_str("12##45#67#89#AB#C#D")) |
| ); |
| } |
| |
| #[test] |
| #[cfg(feature = "serde_json")] |
| fn test_serde_json_serialize() { |
| use serde_json; |
| let serialized = |
| serde_json::to_string(&MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap()).unwrap(); |
| if cfg!(feature = "disp_hexstring") { |
| assert_eq!("\"12:34:56:ab:cd:ef\"", serialized); |
| } else { |
| assert_eq!("\"12-34-56-ab-cd-ef\"", serialized); |
| } |
| } |
| |
| #[test] |
| #[cfg(feature = "serde_json")] |
| fn test_serde_json_deserialize() { |
| use serde_json; |
| let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| let deserialized: MacAddress = serde_json::from_str("\"12-34-56-AB-CD-EF\"").unwrap(); |
| assert_eq!(deserialized, mac); |
| } |
| |
| #[test] |
| #[should_panic(expected = "Invalid length; expecting 11 to 17 chars, found 2")] |
| #[cfg(feature = "serde_json")] |
| fn test_serde_json_deserialize_panic() { |
| let _should_panic: MacAddress = serde_json::from_str("\"12\"").unwrap(); |
| } |
| |
| #[test] |
| #[cfg(feature = "serde_bytes")] |
| fn test_serde_bytes_serialization_roundtrip() { |
| use bincode; |
| let mac = MacAddress::parse_str("12:34:56:AB:CD:EF").unwrap(); |
| let mut buffer = Vec::new(); |
| bincode::serialize_into(&mut buffer, &mac).unwrap(); |
| let deserialized: MacAddress = bincode::deserialize_from(&*buffer).unwrap(); |
| assert_eq!(deserialized, mac); |
| } |
| |
| #[test] |
| fn test_macaddressformat_derive() { |
| assert_eq!(MacAddressFormat::HexString, MacAddressFormat::HexString); |
| assert_ne!(MacAddressFormat::HexString, MacAddressFormat::Canonical); |
| } |
| |
| #[test] |
| fn test_parseerror_fmt() { |
| assert_eq!( |
| "Invalid length; expecting 11 to 17 chars, found 2".to_owned(), |
| format!("{}", ParseError::InvalidLength(2)) |
| ); |
| assert_eq!( |
| "Invalid length; expecting 11 to 17 chars, found 2".to_owned(), |
| ParseError::InvalidLength(2).to_string() |
| ); |
| } |
| |
| #[test] |
| fn test_to_array() { |
| let eui: Eui48 = [0x12, 0x34, 0x56, 0xAB, 0xCD, 0xEF]; |
| let mac = MacAddress::new(eui); |
| assert_eq!(eui, MacAddress::new(eui).to_array()); |
| assert_eq!(mac, MacAddress::new(mac.to_array())); |
| } |
| } |
