add tests for models/nework module

src/models/network/afi.rs

@@ -33,3 +33,64 @@ pub enum Safi {
     Multicast = 2,
     UnicastMulticast = 3,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_afi_from() {
+        assert_eq!(
+            Afi::from(IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, 1))),
+            Afi::Ipv4
+        );
+        assert_eq!(
+            Afi::from(IpAddr::V6(std::net::Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1))),
+            Afi::Ipv6
+        );
+    }
+
+    #[test]
+    fn test_afi_safi_repr() {
+        assert_eq!(Afi::Ipv4 as u16, 1);
+        assert_eq!(Afi::Ipv6 as u16, 2);
+
+        assert_eq!(Safi::Unicast as u8, 1);
+        assert_eq!(Safi::Multicast as u8, 2);
+        assert_eq!(Safi::UnicastMulticast as u8, 3);
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_afi_safi_serde() {
+        let afi = Afi::Ipv4;
+        let serialized = serde_json::to_string(&afi).unwrap();
+        assert_eq!(serialized, "\"Ipv4\"");
+        let deserialized: Afi = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, afi);
+
+        let afi = Afi::Ipv6;
+        let serialized = serde_json::to_string(&afi).unwrap();
+        assert_eq!(serialized, "\"Ipv6\"");
+        let deserialized: Afi = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, afi);
+
+        let safi = Safi::Unicast;
+        let serialized = serde_json::to_string(&safi).unwrap();
+        assert_eq!(serialized, "\"Unicast\"");
+        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, safi);
+
+        let safi = Safi::Multicast;
+        let serialized = serde_json::to_string(&safi).unwrap();
+        assert_eq!(serialized, "\"Multicast\"");
+        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, safi);
+
+        let safi = Safi::UnicastMulticast;
+        let serialized = serde_json::to_string(&safi).unwrap();
+        assert_eq!(serialized, "\"UnicastMulticast\"");
+        let deserialized: Safi = serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, safi);
+    }
+}

src/models/network/asn.rs

@@ -289,11 +289,93 @@ impl Asn {
 mod tests {
     use super::*;
     use crate::parser::ReadUtils;
+    use std::str::FromStr;
 
     #[test]
     fn test_asn_encode() {
         let asn = Asn::new_32bit(123);
         let mut bytes = asn.encode();
         assert_eq!(123, bytes.read_u32().unwrap());
     }
+
+    #[test]
+    fn test_asn_is_reserved() {
+        let asn = Asn::new_32bit(0);
+        assert!(asn.is_reserved());
+
+        let asn = Asn::new_32bit(23456);
+        assert!(asn.is_reserved());
+
+        let asn = Asn::new_32bit(64513);
+        assert!(asn.is_reserved());
+
+        let asn = Asn::new_32bit(4294967295);
+        assert!(asn.is_reserved());
+
+        let asn = Asn::new_32bit(112);
+        assert!(asn.is_reserved());
+    }
+
+    #[test]
+    fn test_asn_is_reserved_for_documentation() {
+        let asn = Asn::new_32bit(64497);
+        assert!(asn.is_reserved_for_documentation());
+
+        let asn = Asn::new_32bit(65537);
+        assert!(asn.is_reserved_for_documentation());
+
+        let asn = Asn::new_32bit(65535);
+        assert!(!asn.is_reserved_for_documentation());
+    }
+
+    #[test]
+    fn test_asn_is_private() {
+        let asn = Asn::new_32bit(64512);
+        assert!(asn.is_private());
+
+        let asn = Asn::new_32bit(4200000000);
+        assert!(asn.is_private());
+
+        let asn = Asn::new_32bit(4200000001);
+        assert!(asn.is_private());
+    }
+
+    #[test]
+    fn test_asn_display() {
+        let asn = Asn::from_str("AS12345").unwrap();
+        assert_eq!(12345, asn.to_u32());
+        let asn = Asn::new_32bit(12345);
+        assert_eq!("12345", format!("{}", asn));
+        let asn = Asn::new_32bit(12345);
+        assert_eq!("12345", format!("{:?}", asn));
+    }
+
+    #[test]
+    fn test_default() {
+        assert_eq!(0, Asn::default().asn)
+    }
+
+    #[test]
+    fn test_conversion() {
+        // test conversion from u32/u16/i32 to Asn
+        let asn = Asn::from(12345);
+        assert_eq!(12345, asn.to_u32());
+
+        let asn = Asn::from(12345u16);
+        assert_eq!(12345, asn.to_u32());
+
+        let asn = Asn::from(12345i32);
+        assert_eq!(12345, asn.to_u32());
+
+        // test conversion from Asn to u32/u16/i32
+        let asn = Asn::new_32bit(12345);
+        assert_eq!(12345, u32::from(asn));
+        assert_eq!(12345, u32::from(&asn));
+        assert_eq!(12345, i32::from(asn));
+        assert_eq!(12345, i32::from(&asn));
+
+        let asn = Asn::new_16bit(12345);
+        assert_eq!(12345, u16::from(asn));
+        assert_eq!(12345, u16::from(&asn));
+    }
 }

src/models/network/nexthop.rs

@@ -61,3 +61,103 @@ impl From<IpAddr> for NextHopAddress {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+    #[test]
+    fn test_next_hop_address_is_link_local() {
+        let ipv4_addr = Ipv4Addr::new(169, 254, 0, 1);
+        let ipv6_addr = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0);
+        let ipv6_link_local_addrs = (
+            Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 1),
+            Ipv6Addr::new(0xfe80, 0, 0, 2, 0, 0, 0, 1),
+        );
+
+        let next_hop_ipv4 = NextHopAddress::Ipv4(ipv4_addr);
+        let next_hop_ipv6 = NextHopAddress::Ipv6(ipv6_addr);
+        let next_hop_ipv6_link_local =
+            NextHopAddress::Ipv6LinkLocal(ipv6_link_local_addrs.0, ipv6_link_local_addrs.1);
+
+        assert!(next_hop_ipv4.is_link_local());
+        assert!(next_hop_ipv6.is_link_local());
+        assert!(next_hop_ipv6_link_local.is_link_local());
+    }
+
+    #[test]
+    fn test_next_hop_address_addr() {
+        let ipv4_addr = Ipv4Addr::new(192, 0, 2, 1);
+        let ipv6_addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
+        let ipv6_link_local_addrs = (
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+        );
+
+        let next_hop_ipv4 = NextHopAddress::Ipv4(ipv4_addr);
+        let next_hop_ipv6 = NextHopAddress::Ipv6(ipv6_addr);
+        let next_hop_ipv6_link_local =
+            NextHopAddress::Ipv6LinkLocal(ipv6_link_local_addrs.0, ipv6_link_local_addrs.1);
+
+        assert_eq!(next_hop_ipv4.addr(), IpAddr::V4(ipv4_addr));
+        assert_eq!(next_hop_ipv6.addr(), IpAddr::V6(ipv6_addr));
+        assert_eq!(
+            next_hop_ipv6_link_local.addr(),
+            IpAddr::V6(ipv6_link_local_addrs.0)
+        );
+    }
+
+    #[test]
+    fn test_next_hop_address_from() {
+        let ipv4_addr = IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1));
+        let ipv6_addr = IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));
+
+        let next_hop_ipv4 = NextHopAddress::from(ipv4_addr);
+        let next_hop_ipv6 = NextHopAddress::from(ipv6_addr);
+
+        assert_eq!(next_hop_ipv4.addr(), ipv4_addr);
+        assert_eq!(next_hop_ipv6.addr(), ipv6_addr);
+    }
+
+    #[test]
+    fn test_debug_for_next_hop_address() {
+        let ipv4_addr = Ipv4Addr::new(192, 0, 2, 1);
+        let ipv6_addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
+        let ipv6_link_local_addrs = (
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+        );
+
+        let next_hop_ipv4 = NextHopAddress::Ipv4(ipv4_addr);
+        let next_hop_ipv6 = NextHopAddress::Ipv6(ipv6_addr);
+        let next_hop_ipv6_link_local =
+            NextHopAddress::Ipv6LinkLocal(ipv6_link_local_addrs.0, ipv6_link_local_addrs.1);
+
+        assert_eq!(format!("{:?}", next_hop_ipv4), "192.0.2.1");
+        assert_eq!(format!("{:?}", next_hop_ipv6), "2001:db8::1");
+        assert_eq!(
+            format!("{:?}", next_hop_ipv6_link_local),
+            "Ipv6LinkLocal(fe80::, fe80::)"
+        );
+    }
+
+    #[test]
+    fn test_display_for_next_hop_address() {
+        let ipv4_addr = Ipv4Addr::new(192, 0, 2, 1);
+        let ipv6_addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1);
+        let ipv6_link_local_addrs = (
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+            Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0),
+        );
+
+        let next_hop_ipv4 = NextHopAddress::Ipv4(ipv4_addr);
+        let next_hop_ipv6 = NextHopAddress::Ipv6(ipv6_addr);
+        let next_hop_ipv6_link_local =
+            NextHopAddress::Ipv6LinkLocal(ipv6_link_local_addrs.0, ipv6_link_local_addrs.1);
+
+        assert_eq!(format!("{}", next_hop_ipv4), "192.0.2.1");
+        assert_eq!(format!("{}", next_hop_ipv6), "2001:db8::1");
+        assert_eq!(format!("{}", next_hop_ipv6_link_local), "fe80::");
+    }
+}

src/models/network/prefix.rs

@@ -134,3 +134,62 @@ mod serde_impl {
         }
     }
 }
+
+// Here's the test code appended at the end of your source code
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fromstr() {
+        let prefix_str = "192.168.0.0/24";
+        let network_prefix = NetworkPrefix::from_str(prefix_str).unwrap();
+        assert_eq!(
+            network_prefix.prefix,
+            IpNet::from_str("192.168.0.0/24").unwrap()
+        );
+        assert_eq!(network_prefix.path_id, 0);
+    }
+
+    #[test]
+    fn test_encode() {
+        let prefix = IpNet::from_str("192.168.0.0/24").unwrap();
+        let network_prefix = NetworkPrefix::new(prefix, 1);
+        let _encoded = network_prefix.encode(true);
+    }
+
+    #[test]
+    fn test_display() {
+        let prefix = IpNet::from_str("192.168.0.0/24").unwrap();
+        let network_prefix = NetworkPrefix::new(prefix, 1);
+        assert_eq!(network_prefix.to_string(), "192.168.0.0/24");
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_serialization() {
+        let prefix = IpNet::from_str("192.168.0.0/24").unwrap();
+        let network_prefix = NetworkPrefix::new(prefix, 1);
+        let serialized = serde_json::to_string(&network_prefix).unwrap();
+        assert_eq!(serialized, "{\"prefix\":\"192.168.0.0/24\",\"path_id\":1}");
+    }
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_deserialization() {
+        let serialized = "{\"prefix\":\"192.168.0.0/24\",\"path_id\":1}";
+        let deserialized: NetworkPrefix = serde_json::from_str(serialized).unwrap();
+        assert_eq!(
+            deserialized.prefix,
+            IpNet::from_str("192.168.0.0/24").unwrap()
+        );
+        assert_eq!(deserialized.path_id, 1);
+    }
+
+    #[test]
+    fn test_debug() {
+        let prefix = IpNet::from_str("192.168.0.0/24").unwrap();
+        let network_prefix = NetworkPrefix::new(prefix, 1);
+        assert_eq!(format!("{:?}", network_prefix), "192.168.0.0/24#1");
+    }
+}