JakubOnderka / ip_network / 109

pending completion

Build # 109

Build Type

Pull #5

travis-ci-com

Committed by

web-flow

Commit Message

<a href="https://github.com/JakubOnderka/ip_network/commit/<a class=hub.com/JakubOnderka/ip_network/commit/<a class="double-link" href="https://git"><a class=hub.com/JakubOnderka/ip_network/commit/<a class="double-link" href="https://git"><a class=hub.com/JakubOnderka/ip_network/commit/<a class="double-link" href="https://git"><a class=hub.com/JakubOnderka/ip_network/commit/<a class="double-link" href="https://git"><a class=hub.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df">a7caa77bc">&lt;a href=&quot;https://github.com/JakubOnderka/ip_network/commit/</a><a class="double-link" href="https://github.com/JakubOnderka/ip_network/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/JakubOnderka/ip_network/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/JakubOnderka/ip_network/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df">a7caa77bc</a><a href="https://github.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df">&lt;a href=&quot;https://github.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/JakubOnderka/ip_network/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/JakubOnderka/ip_network/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df&amp;quot;&amp;gt;a7caa77bc&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce09d500df&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/JakubOnderka/ip_network/commit/a7caa77bc1e9750d702e27bcbcdf2fce&amp;lt;/a&amp;gt;09d500df&amp;qu</a>ot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/JakubOnderka/ip_network/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/JakubOnderka/ip_network/commit/&lt;a class=&quot;double-link&quot; href=&quot;https:/... (continued)

Pull Request Pull Request #5: Update travis to use cargo-tarpaulin

Run Details

48 of 48 new or added lines in 3 files covered. (100.0%)

1236 of 1427 relevant lines covered (86.62%)

1.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.82

/src/ip_network.rs

use std::cmp::Ordering;
use std::fmt;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
use std::str::FromStr;
use crate::{IpNetworkError, IpNetworkParseError};
use crate::helpers;
use crate::{Ipv4Network, Ipv6Network};

/// Holds IPv4 or IPv6 network.
#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash, PartialOrd, Ord)]
pub enum IpNetwork {
    V4(Ipv4Network),
    V6(Ipv6Network),
}

impl IpNetwork {
    /// Constructs new `IpNetwork` based on [`IpAddr`] and `netmask`.
    ///
    /// [`IpAddr`]: https://doc.rust-lang.org/std/net/enum.IpAddr.html
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::{IpAddr, Ipv4Addr};
    /// use std::str::FromStr;
    /// use ip_network::{IpNetwork, Ipv4Network};
    ///
    /// let network_address = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0));
    /// let ip_network = IpNetwork::new(network_address, 24)?;
    /// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
    /// assert_eq!(ip_network.netmask(), 24);
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    #[allow(clippy::new_ret_no_self)]
    pub fn new<I: Into<IpAddr>>(network_address: I, netmask: u8) -> Result<Self, IpNetworkError> {
        Ok(match network_address.into() {
            IpAddr::V4(ip) => IpNetwork::V4(Ipv4Network::new(ip, netmask)?),
            IpAddr::V6(ip) => IpNetwork::V6(Ipv6Network::new(ip, netmask)?),
        })
    }

    /// Constructs new `IpNetwork` based on [`IpAddr`] and `netmask` with truncating host bits
    /// from given `network_address`.
    ///
    /// Returns error if netmask is bigger than 32 for IPv4 and 128 for IPv6.
    ///
    /// [`Ipv4Addr`]: https://doc.rust-lang.org/std/net/struct.IpAddr.html
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::{IpAddr, Ipv4Addr};
    /// use ip_network::IpNetwork;
    ///
    /// let network_address = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 128));
    /// let ip_network = IpNetwork::new_truncate(network_address, 24)?;
    /// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
    /// assert_eq!(ip_network.netmask(), 24);
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    pub fn new_truncate<I: Into<IpAddr>>(
        network_address: I,
        netmask: u8,
    ) -> Result<Self, IpNetworkError> {
        Ok(match network_address.into() {
            IpAddr::V4(ip) => IpNetwork::V4(Ipv4Network::new_truncate(ip, netmask)?),
            IpAddr::V6(ip) => IpNetwork::V6(Ipv6Network::new_truncate(ip, netmask)?),
        })
    }

    /// Returns network IP address.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::{IpAddr, Ipv4Addr};
    /// use ip_network::IpNetwork;
    ///
    /// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
    /// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    pub fn network_address(&self) -> IpAddr {
        match self {
            IpNetwork::V4(ip_network) => IpAddr::V4(ip_network.network_address()),
            IpNetwork::V6(ip_network) => IpAddr::V6(ip_network.network_address()),
        }
    }

    /// Returns network mask as integer.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::{IpAddr, Ipv4Addr};
    /// use ip_network::IpNetwork;
    ///
    /// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
    /// assert_eq!(ip_network.netmask(), 24);
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    pub fn netmask(&self) -> u8 {
        match self {
            IpNetwork::V4(ip_network) => ip_network.netmask(),
            IpNetwork::V6(ip_network) => ip_network.netmask(),
        }
    }

    /// Returns `true` if `IpNetwork` contains `Ipv4Network` struct.
    pub fn is_ipv4(&self) -> bool {
        match self {
            IpNetwork::V4(_) => true,
            IpNetwork::V6(_) => false,
        }
    }

    /// Returns `true` if `IpNetwork` contains `Ipv6Network` struct.
    pub fn is_ipv6(&self) -> bool {
        !self.is_ipv4()
    }

    /// Returns `true` if `IpNetwork` contains `IpAddr`. For different network type
    /// (for example IpNetwork is IPv6 and IpAddr is IPv4) always returns `false`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
    /// use ip_network::IpNetwork;
    ///
    /// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
    /// assert!(ip_network.contains(Ipv4Addr::new(192, 168, 1, 25)));
    /// assert!(!ip_network.contains(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 1, 0, 0)));
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    pub fn contains<I: Into<IpAddr>>(&self, ip: I) -> bool {
        match (self, ip.into()) {
            (IpNetwork::V4(network), IpAddr::V4(ip)) => network.contains(ip),
            (IpNetwork::V6(network), IpAddr::V6(ip)) => network.contains(ip),
            _ => false,
        }
    }

    /// Returns `true` if the network is default route, that contains all IP addresses.
    pub fn is_default_route(&self) -> bool {
        match self {
            IpNetwork::V4(ip_network) => ip_network.is_default_route(),
            IpNetwork::V6(ip_network) => ip_network.is_default_route(),
        }
    }

    /// Returns `true` if the network is part of multicast network range.
    pub fn is_multicast(&self) -> bool {
        match self {
            IpNetwork::V4(ip_network) => ip_network.is_multicast(),
            IpNetwork::V6(ip_network) => ip_network.is_multicast(),
        }
    }

    /// Returns `true` if this is a part of network reserved for documentation.
    pub fn is_documentation(&self) -> bool {
        match self {
            IpNetwork::V4(ip_network) => ip_network.is_documentation(),
            IpNetwork::V6(ip_network) => ip_network.is_documentation(),
        }
    }

    /// Returns `true` if this network is inside loopback address range.
    pub fn is_loopback(&self) -> bool {
        match self {
            IpNetwork::V4(ip_network) => ip_network.is_loopback(),
            IpNetwork::V6(ip_network) => ip_network.is_loopback(),
        }
    }

    /// Returns `true` if the network appears to be globally routable.
    pub fn is_global(&self) -> bool {
        match self {
            IpNetwork::V4(ip_network) => ip_network.is_global(),
            IpNetwork::V6(ip_network) => ip_network.is_global(),
        }
    }

    /// Converts string in format IPv4 (X.X.X.X/Y) or IPv6 (X:X::X/Y) CIDR notation to `IpNetwork`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::Ipv4Addr;
    /// use ip_network::{IpNetwork, Ipv4Network};
    ///
    /// let ip_network = IpNetwork::from_str_truncate("192.168.1.1/24").unwrap();
    /// assert_eq!(ip_network, IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()));
    /// ```
    pub fn from_str_truncate(s: &str) -> Result<Self, IpNetworkParseError> {
        let (ip, netmask) =
            helpers::split_ip_netmask(s).ok_or(IpNetworkParseError::InvalidFormatError)?;

        let network_address =
            IpAddr::from_str(ip).map_err(|_| IpNetworkParseError::AddrParseError)?;
        let netmask =
            u8::from_str(netmask).map_err(|_| IpNetworkParseError::InvalidNetmaskFormat)?;

        IpNetwork::new_truncate(network_address, netmask)
            .map_err(IpNetworkParseError::IpNetworkError)
    }

    /// Return an iterator of the collapsed IpNetworks.
    pub fn collapse_addresses(addresses: &[Self]) -> Vec<Self> {
        let mut ipv4_networks = vec![];
        let mut ipv6_networks = vec![];
        for address in addresses {
            match address {
                IpNetwork::V4(ip_network) => ipv4_networks.push(*ip_network),
                IpNetwork::V6(ip_network) => ipv6_networks.push(*ip_network),
            }
        }

        let mut collapsed = Ipv4Network::collapse_addresses(&ipv4_networks)
            .into_iter()
            .map(IpNetwork::from)
            .collect::<Vec<_>>();
        collapsed.extend(
            Ipv6Network::collapse_addresses(&ipv6_networks)
                .into_iter()
                .map(IpNetwork::from),
        );
        collapsed
    }
}

impl fmt::Display for IpNetwork {
    /// Converts `IpNetwork` to string in format X.X.X.X/Y for IPv4 and X:X::X/Y for IPv6 (CIDR notation).
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::Ipv4Addr;
    /// use ip_network::{IpNetwork, Ipv4Network};
    ///
    /// let ip_network = IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24)?);
    /// assert_eq!(ip_network.to_string(), "192.168.1.0/24");
    /// # Ok::<(), ip_network::IpNetworkError>(())
    /// ```
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            IpNetwork::V4(ref network) => network.fmt(f),
            IpNetwork::V6(ref network) => network.fmt(f),
        }
    }
}

impl FromStr for IpNetwork {
    type Err = IpNetworkParseError;

    /// Converts string in format IPv4 (X.X.X.X/Y) or IPv6 (X:X::X/Y) CIDR notation to `IpNetwork`.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::net::Ipv4Addr;
    /// use std::str::FromStr;
    /// use ip_network::{IpNetwork, Ipv4Network};
    ///
    /// let ip_network = IpNetwork::from_str("192.168.1.0/24").unwrap();
    /// assert_eq!(ip_network, IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()));
    /// ```
    fn from_str(s: &str) -> Result<IpNetwork, IpNetworkParseError> {
        let (ip, netmask) =
            helpers::split_ip_netmask(s).ok_or(IpNetworkParseError::InvalidFormatError)?;

        let network_address =
            IpAddr::from_str(ip).map_err(|_| IpNetworkParseError::AddrParseError)?;
        let netmask =
            u8::from_str(netmask).map_err(|_| IpNetworkParseError::InvalidNetmaskFormat)?;

        IpNetwork::new(network_address, netmask).map_err(IpNetworkParseError::IpNetworkError)
    }
}

impl From<Ipv4Addr> for IpNetwork {
    /// Converts `Ipv4Addr` to `IpNetwork` with netmask 32.
    #[inline]
    fn from(ip: Ipv4Addr) -> Self {
        IpNetwork::V4(Ipv4Network::from(ip))
    }
}

impl From<Ipv6Addr> for IpNetwork {
    /// Converts `Ipv6Addr` to `IpNetwork` with netmask 128.
    #[inline]
    fn from(ip: Ipv6Addr) -> Self {
        IpNetwork::V6(Ipv6Network::from(ip))
    }
}

impl From<IpAddr> for IpNetwork {
    /// Converts `IpAddr` to `IpNetwork` with netmask 32 for IPv4 address and 128 for IPv6 address.
    fn from(ip: IpAddr) -> Self {
        match ip {
            IpAddr::V4(ip) => IpNetwork::from(ip),
            IpAddr::V6(ip) => IpNetwork::from(ip),
        }
    }
}

impl From<Ipv4Network> for IpNetwork {
    #[inline]
    fn from(network: Ipv4Network) -> Self {
        IpNetwork::V4(network)
    }
}

impl From<Ipv6Network> for IpNetwork {
    #[inline]
    fn from(network: Ipv6Network) -> Self {
        IpNetwork::V6(network)
    }
}

impl PartialEq<Ipv4Network> for IpNetwork {
    fn eq(&self, other: &Ipv4Network) -> bool {
        match self {
            IpNetwork::V4(v4) => v4 == other,
            IpNetwork::V6(_) => false,
        }
    }
}

impl PartialEq<Ipv6Network> for IpNetwork {
    fn eq(&self, other: &Ipv6Network) -> bool {
        match self {
            IpNetwork::V4(_) => false,
            IpNetwork::V6(v6) => v6 == other,
        }
    }
}

impl PartialEq<IpNetwork> for Ipv4Network {
    fn eq(&self, other: &IpNetwork) -> bool {
        match other {
            IpNetwork::V4(v4) => self == v4,
            IpNetwork::V6(_) => false,
        }
    }
}

impl PartialEq<IpNetwork> for Ipv6Network {
    fn eq(&self, other: &IpNetwork) -> bool {
        match other {
            IpNetwork::V4(_) => false,
            IpNetwork::V6(v6) => self == v6,
        }
    }
}

impl PartialOrd<Ipv4Network> for IpNetwork {
    fn partial_cmp(&self, other: &Ipv4Network) -> Option<Ordering> {
        match self {
            IpNetwork::V4(v4) => v4.partial_cmp(other),
            IpNetwork::V6(_) => Some(Ordering::Greater),
        }
    }
}

impl PartialOrd<IpNetwork> for Ipv4Network {
    fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {
        match other {
            IpNetwork::V4(v4) => self.partial_cmp(v4),
            IpNetwork::V6(_) => Some(Ordering::Less),
        }
    }
}

impl PartialOrd<Ipv6Network> for IpNetwork {
    fn partial_cmp(&self, other: &Ipv6Network) -> Option<Ordering> {
        match self {
            IpNetwork::V4(_) => Some(Ordering::Less),
            IpNetwork::V6(v6) => v6.partial_cmp(other),
        }
    }
}

impl PartialOrd<IpNetwork> for Ipv6Network {
    fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {
        match other {
            IpNetwork::V4(_) => Some(Ordering::Greater),
            IpNetwork::V6(v6) => self.partial_cmp(v6),
        }
    }
}

#[cfg(test)]
mod tests {
    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
    use crate::{IpNetwork, IpNetworkParseError, IpNetworkError, Ipv4Network, Ipv6Network};
    use std::str::FromStr;

    fn return_test_ipv4_network() -> Ipv4Network {
        Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 16).unwrap()
    }

    fn return_test_ipv6_network() -> Ipv6Network {
        Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap()
    }

    #[test]
    fn network_address_ipv4() {
        let ip_network = IpNetwork::V4(return_test_ipv4_network());
        assert_eq!(
            IpAddr::V4(Ipv4Addr::new(192, 168, 0, 0)),
            ip_network.network_address()
        );
    }

    #[test]
    fn network_address_ipv6() {
        let ip_network = IpNetwork::V6(return_test_ipv6_network());
        assert_eq!(
            IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)),
            ip_network.network_address()
        );
    }

    #[test]
    fn is_ipv4() {
        let ip_network = IpNetwork::V4(return_test_ipv4_network());
        assert!(ip_network.is_ipv4());
        assert!(!ip_network.is_ipv6());
    }

    #[test]
    fn is_ipv6() {
        let ip_network = IpNetwork::V6(return_test_ipv6_network());
        assert!(ip_network.is_ipv6());
        assert!(!ip_network.is_ipv4());
    }

    #[test]
    fn parse_ipv4() {
        let ip_network: IpNetwork = "192.168.0.0/16".parse().unwrap();
        assert_eq!(ip_network, IpNetwork::V4(return_test_ipv4_network()));
    }

    #[test]
    fn parse_ipv6() {
        let ip_network: IpNetwork = "2001:db8::/32".parse().unwrap();
        assert_eq!(ip_network, IpNetwork::V6(return_test_ipv6_network()));
    }

    #[test]
    fn parse_empty() {
        let ip_network = "".parse::<IpNetwork>();
        assert!(ip_network.is_err());
        assert_eq!(
            IpNetworkParseError::InvalidFormatError,
            ip_network.unwrap_err()
        );
    }

    #[test]
    fn parse_invalid_netmask() {
        let ip_network = "192.168.0.0/a".parse::<IpNetwork>();
        assert!(ip_network.is_err());
        assert_eq!(
            IpNetworkParseError::InvalidNetmaskFormat,
            ip_network.unwrap_err()
        );
    }

    #[test]
    fn parse_invalid_ip() {
        let ip_network = "192.168.0.0a/16".parse::<IpNetwork>();
        assert!(ip_network.is_err());
        assert_eq!(IpNetworkParseError::AddrParseError, ip_network.unwrap_err());
    }

    #[test]
    fn parse_ipv4_host_bits_set() {
        let ip_network = "192.168.0.1/16".parse::<IpNetwork>();
        assert!(ip_network.is_err());
        assert_eq!(
            IpNetworkParseError::IpNetworkError(IpNetworkError::HostBitsSet),
            ip_network.unwrap_err()
        );
    }

    #[test]
    fn parse_ipv6_host_bits_set() {
        let ip_network = "2001:db8::1/32".parse::<IpNetwork>();
        assert!(ip_network.is_err());
        assert_eq!(
            IpNetworkParseError::IpNetworkError(IpNetworkError::HostBitsSet),
            ip_network.unwrap_err()
        );
    }

    #[test]
    fn format_ipv4() {
        let ip_network = IpNetwork::V4(return_test_ipv4_network());
        assert_eq!(ip_network.to_string(), "192.168.0.0/16");
    }

    #[test]
    fn format_ipv6() {
        let ip_network = IpNetwork::V6(return_test_ipv6_network());
        assert_eq!(ip_network.to_string(), "2001:db8::/32");
    }

    #[test]
    fn from_ipv4addr() {
        let ipv4addr = Ipv4Addr::new(1, 2, 3, 4);
        let ip_network = IpNetwork::from(ipv4addr);
        assert_eq!(IpAddr::V4(ipv4addr), ip_network.network_address());
        assert_eq!(32, ip_network.netmask());
    }

    #[test]
    fn from_ipv6addr() {
        let ipv6addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);
        let ip_network = IpNetwork::from(ipv6addr);
        assert_eq!(IpAddr::V6(ipv6addr), ip_network.network_address());
        assert_eq!(128, ip_network.netmask());
    }

    #[test]
    fn from_ipaddr() {
        let ipaddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));
        let ip_network = IpNetwork::from(ipaddr);
        assert_eq!(ipaddr, ip_network.network_address());
        assert_eq!(128, ip_network.netmask());
    }

    #[test]
    fn from_ipv4_network() {
        let ipv4_network = return_test_ipv4_network();
        let ip_network = IpNetwork::from(ipv4_network);
        assert_eq!(
            IpAddr::V4(ipv4_network.network_address()),
            ip_network.network_address()
        );
        assert_eq!(ipv4_network.netmask(), ip_network.netmask());
    }

    #[test]
    fn from_ipv6_network() {
        let ipv6_network = return_test_ipv6_network();
        let ip_network = IpNetwork::from(ipv6_network);
        assert_eq!(
            IpAddr::V6(ipv6_network.network_address()),
            ip_network.network_address()
        );
        assert_eq!(ipv6_network.netmask(), ip_network.netmask());
    }

    #[test]
    fn equal_ip_network_ipv4_network() {
        let ip_network = IpNetwork::V4(return_test_ipv4_network());
        let ipv4_network = return_test_ipv4_network();
        let different = Ipv4Network::new(Ipv4Addr::new(1, 2, 3, 4), 32).unwrap();
        assert_eq!(ip_network, ipv4_network);
        assert_eq!(ipv4_network, ip_network);
        assert_ne!(ip_network, different);
        assert_ne!(different, ip_network);
        assert_ne!(ip_network, return_test_ipv6_network());
        assert_ne!(return_test_ipv6_network(), ip_network);
    }

    #[test]
    fn equal_ip_network_ipv6_network() {
        let ip_network = IpNetwork::V6(return_test_ipv6_network());
        let ipv6_network = return_test_ipv6_network();
        let different = Ipv6Network::new(Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8), 128).unwrap();
        assert_eq!(ip_network, ipv6_network);
        assert_eq!(ipv6_network, ip_network);
        assert_ne!(ip_network, different);
        assert_ne!(different, ip_network);
        assert_ne!(ip_network, return_test_ipv4_network());
        assert_ne!(return_test_ipv4_network(), ip_network);
    }

    #[test]
    fn compare_ip_network_ipv4_network_same() {
        let ip_network = IpNetwork::V4(return_test_ipv4_network());
        let ipv4_network = return_test_ipv4_network();
        assert!(ip_network <= ipv4_network);
        assert!(ip_network >= ipv4_network);
        assert!(ipv4_network <= ip_network);
        assert!(ipv4_network >= ip_network);
    }

    #[test]
    fn compare_ip_network_ipv6_network_same() {
        let ip_network = IpNetwork::V6(return_test_ipv6_network());
        let ipv6_network = return_test_ipv6_network();
        assert!(ip_network <= ipv6_network);
        assert!(ip_network >= ipv6_network);
        assert!(ipv6_network <= ip_network);
        assert!(ipv6_network >= ip_network);
    }

    #[test]
    fn compare_ip_network_v4_ip_network_v6() {
        let ip_network_v4 = IpNetwork::V4(return_test_ipv4_network());
        let ip_network_v6 = IpNetwork::V6(return_test_ipv6_network());
        assert!(ip_network_v4 < ip_network_v6);
        assert!(ip_network_v6 > ip_network_v4);
    }

    #[test]
    fn collapse_addresses() {
        let addresses: Vec<_> = [
            "192.0.2.0/25",
            "192.0.2.128/25",
            "2001::/100",
            "2001::/120",
            "2001::/96",
        ]
        .iter()
        .map(|i| IpNetwork::from_str(i).unwrap())
        .collect();
        let collapsed = IpNetwork::collapse_addresses(&addresses);
        assert_eq!(2, collapsed.len());
    }
}

1	use std::cmp::Ordering;
2	use std::fmt;
3	use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
4	use std::str::FromStr;
5	use crate::{IpNetworkError, IpNetworkParseError};
6	use crate::helpers;
7	use crate::{Ipv4Network, Ipv6Network};
8
9	/// Holds IPv4 or IPv6 network.
10	#[derive(Clone, Copy, Eq, PartialEq, Debug, Hash, PartialOrd, Ord)]
11	pub enum IpNetwork {
12	V4(Ipv4Network),
13	V6(Ipv6Network),
14	}
15
16	impl IpNetwork {
17	/// Constructs new `IpNetwork` based on [`IpAddr`] and `netmask`.
18	///
19	/// [`IpAddr`]: https://doc.rust-lang.org/std/net/enum.IpAddr.html
20	///
21	/// # Examples
22	///
23	/// ```
24	/// use std::net::{IpAddr, Ipv4Addr};
25	/// use std::str::FromStr;
26	/// use ip_network::{IpNetwork, Ipv4Network};
27	///
28	/// let network_address = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0));
29	/// let ip_network = IpNetwork::new(network_address, 24)?;
30	/// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
31	/// assert_eq!(ip_network.netmask(), 24);
32	/// # Ok::<(), ip_network::IpNetworkError>(())
33	/// ```
34	#[allow(clippy::new_ret_no_self)]
35	pub fn new<I: Into<IpAddr>>(network_address: I, netmask: u8) -> Result<Self, IpNetworkError> {	2✔
36	Ok(match network_address.into() {	7✔
37	IpAddr::V4(ip) => IpNetwork::V4(Ipv4Network::new(ip, netmask)?),	4✔
38	IpAddr::V6(ip) => IpNetwork::V6(Ipv6Network::new(ip, netmask)?),	2✔
39	})
40	}
41
42	/// Constructs new `IpNetwork` based on [`IpAddr`] and `netmask` with truncating host bits
43	/// from given `network_address`.
44	///
45	/// Returns error if netmask is bigger than 32 for IPv4 and 128 for IPv6.
46	///
47	/// [`Ipv4Addr`]: https://doc.rust-lang.org/std/net/struct.IpAddr.html
48	///
49	/// # Examples
50	///
51	/// ```
52	/// use std::net::{IpAddr, Ipv4Addr};
53	/// use ip_network::IpNetwork;
54	///
55	/// let network_address = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 128));
56	/// let ip_network = IpNetwork::new_truncate(network_address, 24)?;
57	/// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
58	/// assert_eq!(ip_network.netmask(), 24);
59	/// # Ok::<(), ip_network::IpNetworkError>(())
60	/// ```
61	pub fn new_truncate<I: Into<IpAddr>>(	×
62	network_address: I,
63	netmask: u8,
64	) -> Result<Self, IpNetworkError> {
65	Ok(match network_address.into() {	×
66	IpAddr::V4(ip) => IpNetwork::V4(Ipv4Network::new_truncate(ip, netmask)?),	×
67	IpAddr::V6(ip) => IpNetwork::V6(Ipv6Network::new_truncate(ip, netmask)?),	×
68	})
69	}
70
71	/// Returns network IP address.
72	///
73	/// # Examples
74	///
75	/// ```
76	/// use std::net::{IpAddr, Ipv4Addr};
77	/// use ip_network::IpNetwork;
78	///
79	/// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
80	/// assert_eq!(ip_network.network_address(), IpAddr::V4(Ipv4Addr::new(192, 168, 1, 0)));
81	/// # Ok::<(), ip_network::IpNetworkError>(())
82	/// ```
83	pub fn network_address(&self) -> IpAddr {	1✔
84	match self {	1✔
85	IpNetwork::V4(ip_network) => IpAddr::V4(ip_network.network_address()),	2✔
86	IpNetwork::V6(ip_network) => IpAddr::V6(ip_network.network_address()),	2✔
87	}
88	}
89
90	/// Returns network mask as integer.
91	///
92	/// # Examples
93	///
94	/// ```
95	/// use std::net::{IpAddr, Ipv4Addr};
96	/// use ip_network::IpNetwork;
97	///
98	/// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
99	/// assert_eq!(ip_network.netmask(), 24);
100	/// # Ok::<(), ip_network::IpNetworkError>(())
101	/// ```
102	pub fn netmask(&self) -> u8 {	1✔
103	match self {	×
104	IpNetwork::V4(ip_network) => ip_network.netmask(),	2✔
105	IpNetwork::V6(ip_network) => ip_network.netmask(),	1✔
106	}
107	}
108
109	/// Returns `true` if `IpNetwork` contains `Ipv4Network` struct.
110	pub fn is_ipv4(&self) -> bool {	1✔
111	match self {	1✔
112	IpNetwork::V4(_) => true,	2✔
113	IpNetwork::V6(_) => false,	1✔
114	}
115	}
116
117	/// Returns `true` if `IpNetwork` contains `Ipv6Network` struct.
118	pub fn is_ipv6(&self) -> bool {	1✔
119	!self.is_ipv4()	1✔
120	}
121
122	/// Returns `true` if `IpNetwork` contains `IpAddr`. For different network type
123	/// (for example IpNetwork is IPv6 and IpAddr is IPv4) always returns `false`.
124	///
125	/// # Examples
126	///
127	/// ```
128	/// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
129	/// use ip_network::IpNetwork;
130	///
131	/// let ip_network = IpNetwork::new(Ipv4Addr::new(192, 168, 1, 0), 24)?;
132	/// assert!(ip_network.contains(Ipv4Addr::new(192, 168, 1, 25)));
133	/// assert!(!ip_network.contains(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 1, 0, 0)));
134	/// # Ok::<(), ip_network::IpNetworkError>(())
135	/// ```
136	pub fn contains<I: Into<IpAddr>>(&self, ip: I) -> bool {	×
137	match (self, ip.into()) {	×
138	(IpNetwork::V4(network), IpAddr::V4(ip)) => network.contains(ip),	×
139	(IpNetwork::V6(network), IpAddr::V6(ip)) => network.contains(ip),	×
140	_ => false,	×
141	}
142	}
143
144	/// Returns `true` if the network is default route, that contains all IP addresses.
145	pub fn is_default_route(&self) -> bool {	×
146	match self {	×
147	IpNetwork::V4(ip_network) => ip_network.is_default_route(),	×
148	IpNetwork::V6(ip_network) => ip_network.is_default_route(),	×
149	}
150	}
151
152	/// Returns `true` if the network is part of multicast network range.
153	pub fn is_multicast(&self) -> bool {	×
154	match self {	×
155	IpNetwork::V4(ip_network) => ip_network.is_multicast(),	×
156	IpNetwork::V6(ip_network) => ip_network.is_multicast(),	×
157	}
158	}
159
160	/// Returns `true` if this is a part of network reserved for documentation.
161	pub fn is_documentation(&self) -> bool {	×
162	match self {	×
163	IpNetwork::V4(ip_network) => ip_network.is_documentation(),	×
164	IpNetwork::V6(ip_network) => ip_network.is_documentation(),	×
165	}
166	}
167
168	/// Returns `true` if this network is inside loopback address range.
169	pub fn is_loopback(&self) -> bool {	×
170	match self {	×
171	IpNetwork::V4(ip_network) => ip_network.is_loopback(),	×
172	IpNetwork::V6(ip_network) => ip_network.is_loopback(),	×
173	}
174	}
175
176	/// Returns `true` if the network appears to be globally routable.
177	pub fn is_global(&self) -> bool {	×
178	match self {	×
179	IpNetwork::V4(ip_network) => ip_network.is_global(),	×
180	IpNetwork::V6(ip_network) => ip_network.is_global(),	×
181	}
182	}
183
184	/// Converts string in format IPv4 (X.X.X.X/Y) or IPv6 (X:X::X/Y) CIDR notation to `IpNetwork`.
185	///
186	/// # Examples
187	///
188	/// ```
189	/// use std::net::Ipv4Addr;
190	/// use ip_network::{IpNetwork, Ipv4Network};
191	///
192	/// let ip_network = IpNetwork::from_str_truncate("192.168.1.1/24").unwrap();
193	/// assert_eq!(ip_network, IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()));
194	/// ```
195	pub fn from_str_truncate(s: &str) -> Result<Self, IpNetworkParseError> {	×
196	let (ip, netmask) =	×
197	helpers::split_ip_netmask(s).ok_or(IpNetworkParseError::InvalidFormatError)?;	×
198
199	let network_address =	×
200	IpAddr::from_str(ip).map_err(\|_\| IpNetworkParseError::AddrParseError)?;	×
201	let netmask =	×
202	u8::from_str(netmask).map_err(\|_\| IpNetworkParseError::InvalidNetmaskFormat)?;	×
203
204	IpNetwork::new_truncate(network_address, netmask)	×
205	.map_err(IpNetworkParseError::IpNetworkError)	×
206	}
207
208	/// Return an iterator of the collapsed IpNetworks.
209	pub fn collapse_addresses(addresses: &[Self]) -> Vec<Self> {	1✔
210	let mut ipv4_networks = vec![];	1✔
211	let mut ipv6_networks = vec![];	1✔
212	for address in addresses {	2✔
213	match address {	×
214	IpNetwork::V4(ip_network) => ipv4_networks.push(*ip_network),	3✔
215	IpNetwork::V6(ip_network) => ipv6_networks.push(*ip_network),	2✔
216	}
217	}
218
219	let mut collapsed = Ipv4Network::collapse_addresses(&ipv4_networks)	2✔
220	.into_iter()
221	.map(IpNetwork::from)	×
222	.collect::<Vec<_>>();
223	collapsed.extend(	1✔
224	Ipv6Network::collapse_addresses(&ipv6_networks)	1✔
225	.into_iter()	×
226	.map(IpNetwork::from),	×
227	);
228	collapsed	×
229	}
230	}
231
232	impl fmt::Display for IpNetwork {
233	/// Converts `IpNetwork` to string in format X.X.X.X/Y for IPv4 and X:X::X/Y for IPv6 (CIDR notation).
234	///
235	/// # Examples
236	///
237	/// ```
238	/// use std::net::Ipv4Addr;
239	/// use ip_network::{IpNetwork, Ipv4Network};
240	///
241	/// let ip_network = IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24)?);
242	/// assert_eq!(ip_network.to_string(), "192.168.1.0/24");
243	/// # Ok::<(), ip_network::IpNetworkError>(())
244	/// ```
245	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {	1✔
246	match *self {	×
247	IpNetwork::V4(ref network) => network.fmt(f),	2✔
248	IpNetwork::V6(ref network) => network.fmt(f),	1✔
249	}
250	}
251	}
252
253	impl FromStr for IpNetwork {
254	type Err = IpNetworkParseError;
255
256	/// Converts string in format IPv4 (X.X.X.X/Y) or IPv6 (X:X::X/Y) CIDR notation to `IpNetwork`.
257	///
258	/// # Examples
259	///
260	/// ```
261	/// use std::net::Ipv4Addr;
262	/// use std::str::FromStr;
263	/// use ip_network::{IpNetwork, Ipv4Network};
264	///
265	/// let ip_network = IpNetwork::from_str("192.168.1.0/24").unwrap();
266	/// assert_eq!(ip_network, IpNetwork::V4(Ipv4Network::new(Ipv4Addr::new(192, 168, 1, 0), 24).unwrap()));
267	/// ```
268	fn from_str(s: &str) -> Result<IpNetwork, IpNetworkParseError> {	1✔
269	let (ip, netmask) =	1✔
270	helpers::split_ip_netmask(s).ok_or(IpNetworkParseError::InvalidFormatError)?;	×
271
272	let network_address =	4✔
273	IpAddr::from_str(ip).map_err(\|_\| IpNetworkParseError::AddrParseError)?;	×
274	let netmask =	4✔
275	u8::from_str(netmask).map_err(\|_\| IpNetworkParseError::InvalidNetmaskFormat)?;	×
276
277	IpNetwork::new(network_address, netmask).map_err(IpNetworkParseError::IpNetworkError)	2✔
278	}
279	}
280
281	impl From<Ipv4Addr> for IpNetwork {
282	/// Converts `Ipv4Addr` to `IpNetwork` with netmask 32.
283	#[inline]
284	fn from(ip: Ipv4Addr) -> Self {	1✔
285	IpNetwork::V4(Ipv4Network::from(ip))	1✔
286	}
287	}
288
289	impl From<Ipv6Addr> for IpNetwork {
290	/// Converts `Ipv6Addr` to `IpNetwork` with netmask 128.
291	#[inline]
292	fn from(ip: Ipv6Addr) -> Self {	1✔
293	IpNetwork::V6(Ipv6Network::from(ip))	1✔
294	}
295	}
296
297	impl From<IpAddr> for IpNetwork {
298	/// Converts `IpAddr` to `IpNetwork` with netmask 32 for IPv4 address and 128 for IPv6 address.
299	fn from(ip: IpAddr) -> Self {	1✔
300	match ip {	×
301	IpAddr::V4(ip) => IpNetwork::from(ip),	1✔
302	IpAddr::V6(ip) => IpNetwork::from(ip),	1✔
303	}
304	}
305	}
306
307	impl From<Ipv4Network> for IpNetwork {
308	#[inline]
309	fn from(network: Ipv4Network) -> Self {	1✔
310	IpNetwork::V4(network)	1✔
311	}
312	}
313
314	impl From<Ipv6Network> for IpNetwork {
315	#[inline]
316	fn from(network: Ipv6Network) -> Self {	1✔
317	IpNetwork::V6(network)	1✔
318	}
319	}
320
321	impl PartialEq<Ipv4Network> for IpNetwork {
322	fn eq(&self, other: &Ipv4Network) -> bool {	1✔
323	match self {	1✔
324	IpNetwork::V4(v4) => v4 == other,	2✔
325	IpNetwork::V6(_) => false,	1✔
326	}
327	}
328	}
329
330	impl PartialEq<Ipv6Network> for IpNetwork {
331	fn eq(&self, other: &Ipv6Network) -> bool {	1✔
332	match self {	×
333	IpNetwork::V4(_) => false,	2✔
334	IpNetwork::V6(v6) => v6 == other,	1✔
335	}
336	}
337	}
338
339	impl PartialEq<IpNetwork> for Ipv4Network {
340	fn eq(&self, other: &IpNetwork) -> bool {	1✔
341	match other {	1✔
342	IpNetwork::V4(v4) => self == v4,	2✔
343	IpNetwork::V6(_) => false,	1✔
344	}
345	}
346	}
347
348	impl PartialEq<IpNetwork> for Ipv6Network {
349	fn eq(&self, other: &IpNetwork) -> bool {	1✔
350	match other {	×
351	IpNetwork::V4(_) => false,	2✔
352	IpNetwork::V6(v6) => self == v6,	1✔
353	}
354	}
355	}
356
357	impl PartialOrd<Ipv4Network> for IpNetwork {
358	fn partial_cmp(&self, other: &Ipv4Network) -> Option<Ordering> {	1✔
359	match self {	×
360	IpNetwork::V4(v4) => v4.partial_cmp(other),	2✔
361	IpNetwork::V6(_) => Some(Ordering::Greater),	×
362	}
363	}
364	}
365
366	impl PartialOrd<IpNetwork> for Ipv4Network {
367	fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {	1✔
368	match other {	×
369	IpNetwork::V4(v4) => self.partial_cmp(v4),	2✔
370	IpNetwork::V6(_) => Some(Ordering::Less),	×
371	}
372	}
373	}
374
375	impl PartialOrd<Ipv6Network> for IpNetwork {
376	fn partial_cmp(&self, other: &Ipv6Network) -> Option<Ordering> {	1✔
377	match self {	×
378	IpNetwork::V4(_) => Some(Ordering::Less),	1✔
379	IpNetwork::V6(v6) => v6.partial_cmp(other),	1✔
380	}
381	}
382	}
383
384	impl PartialOrd<IpNetwork> for Ipv6Network {
385	fn partial_cmp(&self, other: &IpNetwork) -> Option<Ordering> {	1✔
386	match other {	×
387	IpNetwork::V4(_) => Some(Ordering::Greater),	1✔
388	IpNetwork::V6(v6) => self.partial_cmp(v6),	1✔
389	}
390	}
391	}
392
393	#[cfg(test)]
394	mod tests {
395	use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
396	use crate::{IpNetwork, IpNetworkParseError, IpNetworkError, Ipv4Network, Ipv6Network};
397	use std::str::FromStr;
398
399	fn return_test_ipv4_network() -> Ipv4Network {	1✔
400	Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 16).unwrap()	1✔
401	}
402
403	fn return_test_ipv6_network() -> Ipv6Network {	1✔
404	Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap()	2✔
405	}
406
407	#[test]
408	fn network_address_ipv4() {	3✔
409	let ip_network = IpNetwork::V4(return_test_ipv4_network());	1✔
410	assert_eq!(	1✔
411	IpAddr::V4(Ipv4Addr::new(192, 168, 0, 0)),	1✔
412	ip_network.network_address()	1✔
413	);
414	}
415
416	#[test]
417	fn network_address_ipv6() {	3✔
418	let ip_network = IpNetwork::V6(return_test_ipv6_network());	1✔
419	assert_eq!(	1✔
420	IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)),	1✔
421	ip_network.network_address()	1✔
422	);
423	}
424
425	#[test]
426	fn is_ipv4() {	3✔
427	let ip_network = IpNetwork::V4(return_test_ipv4_network());	1✔
428	assert!(ip_network.is_ipv4());	1✔
429	assert!(!ip_network.is_ipv6());	1✔
430	}
431
432	#[test]
433	fn is_ipv6() {	3✔
434	let ip_network = IpNetwork::V6(return_test_ipv6_network());	1✔
435	assert!(ip_network.is_ipv6());	1✔
436	assert!(!ip_network.is_ipv4());	1✔
437	}
438
439	#[test]
440	fn parse_ipv4() {	3✔
441	let ip_network: IpNetwork = "192.168.0.0/16".parse().unwrap();	1✔
442	assert_eq!(ip_network, IpNetwork::V4(return_test_ipv4_network()));	1✔
443	}
444
445	#[test]
446	fn parse_ipv6() {	3✔
447	let ip_network: IpNetwork = "2001:db8::/32".parse().unwrap();	1✔
448	assert_eq!(ip_network, IpNetwork::V6(return_test_ipv6_network()));	1✔
449	}
450
451	#[test]
452	fn parse_empty() {	3✔
453	let ip_network = "".parse::<IpNetwork>();	1✔
454	assert!(ip_network.is_err());	1✔
455	assert_eq!(	1✔
456	IpNetworkParseError::InvalidFormatError,
457	ip_network.unwrap_err()	1✔
458	);
459	}
460
461	#[test]
462	fn parse_invalid_netmask() {	3✔
463	let ip_network = "192.168.0.0/a".parse::<IpNetwork>();	1✔
464	assert!(ip_network.is_err());	1✔
465	assert_eq!(	1✔
466	IpNetworkParseError::InvalidNetmaskFormat,
467	ip_network.unwrap_err()	1✔
468	);
469	}
470
471	#[test]
472	fn parse_invalid_ip() {	3✔
473	let ip_network = "192.168.0.0a/16".parse::<IpNetwork>();	1✔
474	assert!(ip_network.is_err());	1✔
475	assert_eq!(IpNetworkParseError::AddrParseError, ip_network.unwrap_err());	1✔
476	}
477
478	#[test]
479	fn parse_ipv4_host_bits_set() {	3✔
480	let ip_network = "192.168.0.1/16".parse::<IpNetwork>();	1✔
481	assert!(ip_network.is_err());	1✔
482	assert_eq!(	1✔
483	IpNetworkParseError::IpNetworkError(IpNetworkError::HostBitsSet),
484	ip_network.unwrap_err()	1✔
485	);
486	}
487
488	#[test]
489	fn parse_ipv6_host_bits_set() {	3✔
490	let ip_network = "2001:db8::1/32".parse::<IpNetwork>();	1✔
491	assert!(ip_network.is_err());	1✔
492	assert_eq!(	1✔
493	IpNetworkParseError::IpNetworkError(IpNetworkError::HostBitsSet),
494	ip_network.unwrap_err()	1✔
495	);
496	}
497
498	#[test]
499	fn format_ipv4() {	3✔
500	let ip_network = IpNetwork::V4(return_test_ipv4_network());	1✔
501	assert_eq!(ip_network.to_string(), "192.168.0.0/16");	1✔
502	}
503
504	#[test]
505	fn format_ipv6() {	3✔
506	let ip_network = IpNetwork::V6(return_test_ipv6_network());	1✔
507	assert_eq!(ip_network.to_string(), "2001:db8::/32");	1✔
508	}
509
510	#[test]
511	fn from_ipv4addr() {	3✔
512	let ipv4addr = Ipv4Addr::new(1, 2, 3, 4);	1✔
513	let ip_network = IpNetwork::from(ipv4addr);	1✔
514	assert_eq!(IpAddr::V4(ipv4addr), ip_network.network_address());	1✔
515	assert_eq!(32, ip_network.netmask());	1✔
516	}
517
518	#[test]
519	fn from_ipv6addr() {	3✔
520	let ipv6addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0);	1✔
521	let ip_network = IpNetwork::from(ipv6addr);	1✔
522	assert_eq!(IpAddr::V6(ipv6addr), ip_network.network_address());	1✔
523	assert_eq!(128, ip_network.netmask());	1✔
524	}
525
526	#[test]
527	fn from_ipaddr() {	3✔
528	let ipaddr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0));	1✔
529	let ip_network = IpNetwork::from(ipaddr);	1✔
530	assert_eq!(ipaddr, ip_network.network_address());	1✔
531	assert_eq!(128, ip_network.netmask());	1✔
532	}
533
534	#[test]
535	fn from_ipv4_network() {	3✔
536	let ipv4_network = return_test_ipv4_network();	1✔
537	let ip_network = IpNetwork::from(ipv4_network);	1✔
538	assert_eq!(	1✔
539	IpAddr::V4(ipv4_network.network_address()),	1✔
540	ip_network.network_address()	1✔
541	);
542	assert_eq!(ipv4_network.netmask(), ip_network.netmask());	1✔
543	}
544
545	#[test]
546	fn from_ipv6_network() {	3✔
547	let ipv6_network = return_test_ipv6_network();	1✔
548	let ip_network = IpNetwork::from(ipv6_network);	1✔
549	assert_eq!(	1✔
550	IpAddr::V6(ipv6_network.network_address()),	1✔
551	ip_network.network_address()	1✔
552	);
553	assert_eq!(ipv6_network.netmask(), ip_network.netmask());	1✔
554	}
555
556	#[test]
557	fn equal_ip_network_ipv4_network() {	3✔
558	let ip_network = IpNetwork::V4(return_test_ipv4_network());	1✔
559	let ipv4_network = return_test_ipv4_network();	1✔
560	let different = Ipv4Network::new(Ipv4Addr::new(1, 2, 3, 4), 32).unwrap();	1✔
561	assert_eq!(ip_network, ipv4_network);	1✔
562	assert_eq!(ipv4_network, ip_network);	1✔
563	assert_ne!(ip_network, different);	1✔
564	assert_ne!(different, ip_network);	1✔
565	assert_ne!(ip_network, return_test_ipv6_network());	1✔
566	assert_ne!(return_test_ipv6_network(), ip_network);	1✔
567	}
568
569	#[test]
570	fn equal_ip_network_ipv6_network() {	3✔
571	let ip_network = IpNetwork::V6(return_test_ipv6_network());	1✔
572	let ipv6_network = return_test_ipv6_network();	1✔
573	let different = Ipv6Network::new(Ipv6Addr::new(1, 2, 3, 4, 5, 6, 7, 8), 128).unwrap();	1✔
574	assert_eq!(ip_network, ipv6_network);	1✔
575	assert_eq!(ipv6_network, ip_network);	1✔
576	assert_ne!(ip_network, different);	1✔
577	assert_ne!(different, ip_network);	1✔
578	assert_ne!(ip_network, return_test_ipv4_network());	1✔
579	assert_ne!(return_test_ipv4_network(), ip_network);	1✔
580	}
581
582	#[test]
583	fn compare_ip_network_ipv4_network_same() {	3✔
584	let ip_network = IpNetwork::V4(return_test_ipv4_network());	1✔
585	let ipv4_network = return_test_ipv4_network();	1✔
586	assert!(ip_network <= ipv4_network);	1✔
587	assert!(ip_network >= ipv4_network);	1✔
588	assert!(ipv4_network <= ip_network);	1✔
589	assert!(ipv4_network >= ip_network);	1✔
590	}
591
592	#[test]
593	fn compare_ip_network_ipv6_network_same() {	3✔
594	let ip_network = IpNetwork::V6(return_test_ipv6_network());	1✔
595	let ipv6_network = return_test_ipv6_network();	1✔
596	assert!(ip_network <= ipv6_network);	1✔
597	assert!(ip_network >= ipv6_network);	1✔
598	assert!(ipv6_network <= ip_network);	1✔
599	assert!(ipv6_network >= ip_network);	1✔
600	}
601
602	#[test]
603	fn compare_ip_network_v4_ip_network_v6() {	3✔
604	let ip_network_v4 = IpNetwork::V4(return_test_ipv4_network());	1✔
605	let ip_network_v6 = IpNetwork::V6(return_test_ipv6_network());	1✔
606	assert!(ip_network_v4 < ip_network_v6);	1✔
607	assert!(ip_network_v6 > ip_network_v4);	1✔
608	}
609
610	#[test]
611	fn collapse_addresses() {	3✔
612	let addresses: Vec<_> = [	1✔
613	"192.0.2.0/25",
614	"192.0.2.128/25",
615	"2001::/100",
616	"2001::/120",
617	"2001::/96",
618	]
619	.iter()
620	.map(\|i\| IpNetwork::from_str(i).unwrap())	2✔
621	.collect();
622	let collapsed = IpNetwork::collapse_addresses(&addresses);	1✔
623	assert_eq!(2, collapsed.len());	1✔
624	}
625	}

JakubOnderka / ip_network / 109

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous