Rename const {Ipv4Network, Ipv6Network}::ANY to DEFAULT_ROUTE

Author: JakubOnderka

src/ipv4_network.rs

@@ -20,8 +20,8 @@ impl Ipv4Network {
     /// IPv4 address length in bits.
     pub const LENGTH: u8 = 32;
 
-    /// Default route, IP network 0.0.0.0/0
-    pub const ANY: Self = Self {
+    /// Default route that contains all IP addresses, IP network 0.0.0.0/0
+    pub const DEFAULT_ROUTE: Self = Self {
         network_address: Ipv4Addr::UNSPECIFIED,
         netmask: 0,
     };
@@ -674,7 +674,7 @@ impl Ipv4Network {
 
         let mut to_merge = addresses.to_vec();
         while let Some(net) = to_merge.pop() {
-            let supernet = net.supernet().unwrap_or(Ipv4Network::ANY);
+            let supernet = net.supernet().unwrap_or(Ipv4Network::DEFAULT_ROUTE);
             match subnets.entry(supernet) {
                 Entry::Vacant(vacant) => {
                     vacant.insert(net);
@@ -829,11 +829,19 @@ mod tests {
     use std::net::Ipv4Addr;
     use crate::{IpNetworkError, Ipv4Network};
     use std::str::FromStr;
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
 
     fn return_test_ipv4_network() -> Ipv4Network {
         Ipv4Network::new(Ipv4Addr::new(192, 168, 0, 0), 16).unwrap()
     }
 
+    #[test]
+    fn default_route() {
+        let network = Ipv4Network::DEFAULT_ROUTE;
+        assert!(network.is_default_route());
+    }
+
     #[test]
     fn new_host_bits_set() {
         let ip = Ipv4Addr::new(127, 0, 0, 1);
@@ -1263,4 +1271,18 @@ mod tests {
         assert_eq!(ip, ipv4_network.network_address());
         assert_eq!(32, ipv4_network.netmask());
     }
+
+    #[test]
+    fn hash() {
+        let network1 = Ipv4Network::from_str("192.0.2.0/26").unwrap();
+        let network2 = Ipv4Network::from_str("192.0.2.64/26").unwrap();
+
+        let mut hasher1 = DefaultHasher::new();
+        network1.hash(&mut hasher1);
+
+        let mut hasher2 = DefaultHasher::new();
+        network2.hash(&mut hasher2);
+
+        assert_ne!(hasher1.finish(), hasher2.finish());
+    }
 }

src/ipv6_network.rs

@@ -31,8 +31,8 @@ impl Ipv6Network {
     /// IPv6 address length in bits.
     pub const LENGTH: u8 = 128;
 
-    /// Default route, IP network ::/0
-    pub const ANY: Self = Self {
+    /// Default route that contains all IP addresses, IP network ::/0
+    pub const DEFAULT_ROUTE: Self = Self {
         network_address: Ipv6Addr::UNSPECIFIED,
         netmask: 0,
     };
@@ -556,7 +556,7 @@ impl Ipv6Network {
 
         let mut to_merge = addresses.to_vec();
         while let Some(net) = to_merge.pop() {
-            let supernet = net.supernet().unwrap_or(Ipv6Network::ANY);
+            let supernet = net.supernet().unwrap_or(Ipv6Network::DEFAULT_ROUTE);
             match subnets.entry(supernet) {
                 Entry::Vacant(vacant) => {
                     vacant.insert(net);
@@ -663,11 +663,19 @@ mod tests {
     use std::net::Ipv6Addr;
     use crate::{Ipv6Network, IpNetworkError, Ipv6MulticastScope};
     use std::str::FromStr;
+    use std::hash::{Hash, Hasher};
+    use std::collections::hash_map::DefaultHasher;
 
     fn return_test_ipv6_network() -> Ipv6Network {
         Ipv6Network::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0), 32).unwrap()
     }
 
+    #[test]
+    fn default_route() {
+        let network = Ipv6Network::DEFAULT_ROUTE;
+        assert!(network.is_default_route());
+    }
+
     #[test]
     fn new() {
         let ip = Ipv6Addr::new(0xfc00, 0, 0, 0, 0, 0, 0, 0);
@@ -879,4 +887,18 @@ mod tests {
         assert_eq!(ip, ipv6_network.network_address());
         assert_eq!(128, ipv6_network.netmask());
     }
+
+    #[test]
+    fn hash() {
+        let network1 = Ipv6Network::from_str("2001::/100").unwrap();
+        let network2 = Ipv6Network::from_str("2001::/120").unwrap();
+
+        let mut hasher1 = DefaultHasher::new();
+        network1.hash(&mut hasher1);
+
+        let mut hasher2 = DefaultHasher::new();
+        network2.hash(&mut hasher2);
+
+        assert_ne!(hasher1.finish(), hasher2.finish());
+    }
 }