Kieran/ipnetwork
1
0
Fork 0
mirror of https://github.com/achanda/ipnetwork.git synced 2025-06-16 08:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement FromStr for Ipv4Network

Browse Source 
This should be more idiomatic Rust, following the examples in stdlib
This commit is contained in:
Abhishek Chanda
2016-09-16 22:32:29 -07:00
parent b110196c96
commit 7b829e5e5a
1 changed files with 27 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/ipv4.rs
View File

@ -1,5 +1,6 @@
use std::fmt; use std::fmt;
use std::net::Ipv4Addr; use std::net::Ipv4Addr;
use std::str::FromStr;
use common::{IpNetworkError, cidr_parts, parse_prefix}; use common::{IpNetworkError, cidr_parts, parse_prefix};
@ -203,6 +204,13 @@ impl fmt::Display for Ipv4Network {
} }
} }
impl FromStr for Ipv4Network {
type Err = IpNetworkError;
fn from_str(s: &str) -> Result<Ipv4Network, IpNetworkError> {
Ipv4Network::from_cidr(s)
}
}
pub struct Ipv4NetworkIterator { pub struct Ipv4NetworkIterator {
next: u64, next: u64,
end: u64, end: u64,
@ -256,77 +264,77 @@ mod test {
#[test] #[test]
fn parse_v4_0bit() { fn parse_v4_0bit() {
let cidr = Ipv4Network::from_cidr("0/0").unwrap(); let cidr: Ipv4Network = "0/0".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(0, 0, 0, 0)); assert_eq!(cidr.ip(), Ipv4Addr::new(0, 0, 0, 0));
assert_eq!(cidr.prefix(), 0); assert_eq!(cidr.prefix(), 0);
} }
#[test] #[test]
fn parse_v4_24bit() { fn parse_v4_24bit() {
let cidr = Ipv4Network::from_cidr("127.1.0.0/24").unwrap(); let cidr: Ipv4Network = "127.1.0.0/24".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(127, 1, 0, 0)); assert_eq!(cidr.ip(), Ipv4Addr::new(127, 1, 0, 0));
assert_eq!(cidr.prefix(), 24); assert_eq!(cidr.prefix(), 24);
} }
#[test] #[test]
fn parse_v4_32bit() { fn parse_v4_32bit() {
let cidr = Ipv4Network::from_cidr("127.0.0.0/32").unwrap(); let cidr: Ipv4Network = "127.0.0.0/32".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(127, 0, 0, 0)); assert_eq!(cidr.ip(), Ipv4Addr::new(127, 0, 0, 0));
assert_eq!(cidr.prefix(), 32); assert_eq!(cidr.prefix(), 32);
} }
#[test] #[test]
fn parse_v4_fail_addr() { fn parse_v4_fail_addr() {
let cidr = Ipv4Network::from_cidr("10.a.b/8"); let cidr: Option<Ipv4Network> = "10.a.b/8".parse().ok();
assert!(cidr.is_err()); assert_eq!(None, cidr);
} }
#[test] #[test]
fn parse_v4_fail_addr2() { fn parse_v4_fail_addr2() {
let cidr = Ipv4Network::from_cidr("10.1.1.1.0/8"); let cidr: Option<Ipv4Network> = "10.1.1.1.0/8".parse().ok();
assert!(cidr.is_err()); assert_eq!(None, cidr);
} }
#[test] #[test]
fn parse_v4_fail_addr3() { fn parse_v4_fail_addr3() {
let cidr = Ipv4Network::from_cidr("256/8"); let cidr: Option<Ipv4Network> = "256/8".parse().ok();
assert!(cidr.is_err()); assert_eq!(None, cidr);
} }
#[test] #[test]
fn parse_v4_non_zero_host_bits() { fn parse_v4_non_zero_host_bits() {
let cidr = Ipv4Network::from_cidr("10.1.1.1/24").unwrap(); let cidr: Ipv4Network = "10.1.1.1/24".parse().unwrap();
assert_eq!(cidr.ip(), Ipv4Addr::new(10, 1, 1, 1)); assert_eq!(cidr.ip(), Ipv4Addr::new(10, 1, 1, 1));
assert_eq!(cidr.prefix(), 24); assert_eq!(cidr.prefix(), 24);
} }
#[test] #[test]
fn parse_v4_fail_prefix() { fn parse_v4_fail_prefix() {
let cidr = Ipv4Network::from_cidr("0/39"); let cidr: Option<Ipv4Network> = "0/39".parse().ok();
assert!(cidr.is_err()); assert_eq!(None, cidr);
} }
#[test] #[test]
fn size_v4_24bit() { fn size_v4_24bit() {
let net = Ipv4Network::from_cidr("0/24").unwrap(); let net: Ipv4Network = "0/24".parse().unwrap();
assert_eq!(net.size(), 256); assert_eq!(net.size(), 256);
} }
#[test] #[test]
fn size_v4_1bit() { fn size_v4_1bit() {
let net = Ipv4Network::from_cidr("0/31").unwrap(); let net: Ipv4Network = "0/31".parse().unwrap();
assert_eq!(net.size(), 2); assert_eq!(net.size(), 2);
} }
#[test] #[test]
fn size_v4_max() { fn size_v4_max() {
let net = Ipv4Network::from_cidr("0/0").unwrap(); let net: Ipv4Network = "0/0".parse().unwrap();
assert_eq!(net.size(), 4_294_967_296); assert_eq!(net.size(), 4_294_967_296);
} }
#[test] #[test]
fn size_v4_min() { fn size_v4_min() {
let net = Ipv4Network::from_cidr("0/32").unwrap(); let net: Ipv4Network = "0/32".parse().unwrap();
assert_eq!(net.size(), 1); assert_eq!(net.size(), 1);
} }
@ -398,7 +406,7 @@ mod test {
#[test] #[test]
fn iterator_v4() { fn iterator_v4() {
let cidr = Ipv4Network::from_cidr("192.168.122.0/30").unwrap(); let cidr: Ipv4Network = "192.168.122.0/30".parse().unwrap();
let mut iter = cidr.iter(); let mut iter = cidr.iter();
assert_eq!(Ipv4Addr::new(192, 168, 122, 0), iter.next().unwrap()); assert_eq!(Ipv4Addr::new(192, 168, 122, 0), iter.next().unwrap());
assert_eq!(Ipv4Addr::new(192, 168, 122, 1), iter.next().unwrap()); assert_eq!(Ipv4Addr::new(192, 168, 122, 1), iter.next().unwrap());
@ -409,7 +417,7 @@ mod test {
#[test] #[test]
fn iterator_v4_tiny() { fn iterator_v4_tiny() {
let cidr = Ipv4Network::from_cidr("10/32").unwrap(); let cidr: Ipv4Network = "10/32".parse().unwrap();
let mut iter = cidr.iter(); let mut iter = cidr.iter();
assert_eq!(Ipv4Addr::new(10, 0, 0, 0), iter.next().unwrap()); assert_eq!(Ipv4Addr::new(10, 0, 0, 0), iter.next().unwrap());
assert_eq!(None, iter.next()); assert_eq!(None, iter.next());
@ -420,7 +428,7 @@ mod test {
#[test] #[test]
#[ignore] #[ignore]
fn iterator_v4_huge() { fn iterator_v4_huge() {
let cidr = Ipv4Network::from_cidr("0/0").unwrap(); let cidr: Ipv4Network = "0/0".parse().unwrap();
let mut iter = cidr.iter(); let mut iter = cidr.iter();
for i in 0..(u32::max_value() as u64 + 1) { for i in 0..(u32::max_value() as u64 + 1) {
assert_eq!(i as u32, u32::from(iter.next().unwrap())); assert_eq!(i as u32, u32::from(iter.next().unwrap()));