library/std/src/net/parser/tests.rs

   1 // FIXME: These tests are all excellent candidates for AFL fuzz testing
   2 use crate::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
   3 use crate::str::FromStr;
   4
   5 const PORT: u16 = 8080;
   6 const SCOPE_ID: u32 = 1337;
   7
   8 const IPV4: Ipv4Addr = Ipv4Addr::new(192, 168, 0, 1);
   9 const IPV4_STR: &str = "192.168.0.1";
  10 const IPV4_STR_PORT: &str = "192.168.0.1:8080";
  11
  12 const IPV6: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xc0a8, 0x1);
  13 const IPV6_STR_FULL: &str = "2001:db8:0:0:0:0:c0a8:1";
  14 const IPV6_STR_COMPRESS: &str = "2001:db8::c0a8:1";
  15 const IPV6_STR_V4: &str = "2001:db8::192.168.0.1";
  16 const IPV6_STR_PORT: &str = "[2001:db8::c0a8:1]:8080";
  17 const IPV6_STR_PORT_SCOPE_ID: &str = "[2001:db8::c0a8:1%1337]:8080";
  18
  19 #[test]
  20 fn parse_ipv4() {
  21     let result: Ipv4Addr = IPV4_STR.parse().unwrap();
  22     assert_eq!(result, IPV4);
  23
  24     assert!(Ipv4Addr::from_str(IPV4_STR_PORT).is_err());
  25     assert!(Ipv4Addr::from_str(IPV6_STR_FULL).is_err());
  26     assert!(Ipv4Addr::from_str(IPV6_STR_COMPRESS).is_err());
  27     assert!(Ipv4Addr::from_str(IPV6_STR_V4).is_err());
  28     assert!(Ipv4Addr::from_str(IPV6_STR_PORT).is_err());
  29 }
  30
  31 #[test]
  32 fn parse_ipv6() {
  33     let result: Ipv6Addr = IPV6_STR_FULL.parse().unwrap();
  34     assert_eq!(result, IPV6);
  35
  36     let result: Ipv6Addr = IPV6_STR_COMPRESS.parse().unwrap();
  37     assert_eq!(result, IPV6);
  38
  39     let result: Ipv6Addr = IPV6_STR_V4.parse().unwrap();
  40     assert_eq!(result, IPV6);
  41
  42     assert!(Ipv6Addr::from_str(IPV4_STR).is_err());
  43     assert!(Ipv6Addr::from_str(IPV4_STR_PORT).is_err());
  44     assert!(Ipv6Addr::from_str(IPV6_STR_PORT).is_err());
  45 }
  46
  47 #[test]
  48 fn parse_ip() {
  49     let result: IpAddr = IPV4_STR.parse().unwrap();
  50     assert_eq!(result, IpAddr::from(IPV4));
  51
  52     let result: IpAddr = IPV6_STR_FULL.parse().unwrap();
  53     assert_eq!(result, IpAddr::from(IPV6));
  54
  55     let result: IpAddr = IPV6_STR_COMPRESS.parse().unwrap();
  56     assert_eq!(result, IpAddr::from(IPV6));
  57
  58     let result: IpAddr = IPV6_STR_V4.parse().unwrap();
  59     assert_eq!(result, IpAddr::from(IPV6));
  60
  61     assert!(IpAddr::from_str(IPV4_STR_PORT).is_err());
  62     assert!(IpAddr::from_str(IPV6_STR_PORT).is_err());
  63 }
  64
  65 #[test]
  66 fn parse_socket_v4() {
  67     let result: SocketAddrV4 = IPV4_STR_PORT.parse().unwrap();
  68     assert_eq!(result, SocketAddrV4::new(IPV4, PORT));
  69
  70     assert!(SocketAddrV4::from_str(IPV4_STR).is_err());
  71     assert!(SocketAddrV4::from_str(IPV6_STR_FULL).is_err());
  72     assert!(SocketAddrV4::from_str(IPV6_STR_COMPRESS).is_err());
  73     assert!(SocketAddrV4::from_str(IPV6_STR_V4).is_err());
  74     assert!(SocketAddrV4::from_str(IPV6_STR_PORT).is_err());
  75 }
  76
  77 #[test]
  78 fn parse_socket_v6() {
  79     assert_eq!(IPV6_STR_PORT.parse(), Ok(SocketAddrV6::new(IPV6, PORT, 0, 0)));
  80     assert_eq!(IPV6_STR_PORT_SCOPE_ID.parse(), Ok(SocketAddrV6::new(IPV6, PORT, 0, SCOPE_ID)));
  81
  82     assert!(SocketAddrV6::from_str(IPV4_STR).is_err());
  83     assert!(SocketAddrV6::from_str(IPV4_STR_PORT).is_err());
  84     assert!(SocketAddrV6::from_str(IPV6_STR_FULL).is_err());
  85     assert!(SocketAddrV6::from_str(IPV6_STR_COMPRESS).is_err());
  86     assert!(SocketAddrV6::from_str(IPV6_STR_V4).is_err());
  87 }
  88
  89 #[test]
  90 fn parse_socket() {
  91     let result: SocketAddr = IPV4_STR_PORT.parse().unwrap();
  92     assert_eq!(result, SocketAddr::from((IPV4, PORT)));
  93
  94     let result: SocketAddr = IPV6_STR_PORT.parse().unwrap();
  95     assert_eq!(result, SocketAddr::from((IPV6, PORT)));
  96
  97     assert!(SocketAddr::from_str(IPV4_STR).is_err());
  98     assert!(SocketAddr::from_str(IPV6_STR_FULL).is_err());
  99     assert!(SocketAddr::from_str(IPV6_STR_COMPRESS).is_err());
 100     assert!(SocketAddr::from_str(IPV6_STR_V4).is_err());
 101 }
 102
 103 #[test]
 104 fn ipv6_corner_cases() {
 105     let result: Ipv6Addr = "1::".parse().unwrap();
 106     assert_eq!(result, Ipv6Addr::new(1, 0, 0, 0, 0, 0, 0, 0));
 107
 108     let result: Ipv6Addr = "1:1::".parse().unwrap();
 109     assert_eq!(result, Ipv6Addr::new(1, 1, 0, 0, 0, 0, 0, 0));
 110
 111     let result: Ipv6Addr = "::1".parse().unwrap();
 112     assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
 113
 114     let result: Ipv6Addr = "::1:1".parse().unwrap();
 115     assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 1, 1));
 116
 117     let result: Ipv6Addr = "::".parse().unwrap();
 118     assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
 119
 120     let result: Ipv6Addr = "::192.168.0.1".parse().unwrap();
 121     assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc0a8, 0x1));
 122
 123     let result: Ipv6Addr = "::1:192.168.0.1".parse().unwrap();
 124     assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 1, 0xc0a8, 0x1));
 125
 126     let result: Ipv6Addr = "1:1:1:1:1:1:192.168.0.1".parse().unwrap();
 127     assert_eq!(result, Ipv6Addr::new(1, 1, 1, 1, 1, 1, 0xc0a8, 0x1));
 128 }
 129
 130 // Things that might not seem like failures but are
 131 #[test]
 132 fn ipv6_corner_failures() {
 133     // No IP address before the ::
 134     assert!(Ipv6Addr::from_str("1:192.168.0.1::").is_err());
 135
 136     // :: must have at least 1 set of zeroes
 137     assert!(Ipv6Addr::from_str("1:1:1:1::1:1:1:1").is_err());
 138
 139     // Need brackets for a port
 140     assert!(SocketAddrV6::from_str("1:1:1:1:1:1:1:1:8080").is_err());
 141 }