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

   1 use crate::net::test::{sa4, sa6, tsa};
   2 use crate::net::*;
   3
   4 #[test]
   5 fn to_socket_addr_ipaddr_u16() {
   6     let a = Ipv4Addr::new(77, 88, 21, 11);
   7     let p = 12345;
   8     let e = SocketAddr::V4(SocketAddrV4::new(a, p));
   9     assert_eq!(Ok(vec![e]), tsa((a, p)));
  10 }
  11
  12 #[test]
  13 fn to_socket_addr_str_u16() {
  14     let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);
  15     assert_eq!(Ok(vec![a]), tsa(("77.88.21.11", 24352)));
  16
  17     let a = sa6(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
  18     assert_eq!(Ok(vec![a]), tsa(("2a02:6b8:0:1::1", 53)));
  19
  20     let a = sa4(Ipv4Addr::new(127, 0, 0, 1), 23924);
  21     #[cfg(not(target_env = "sgx"))]
  22     assert!(tsa(("localhost", 23924)).unwrap().contains(&a));
  23     #[cfg(target_env = "sgx")]
  24     let _ = a;
  25 }
  26
  27 #[test]
  28 fn to_socket_addr_str() {
  29     let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);
  30     assert_eq!(Ok(vec![a]), tsa("77.88.21.11:24352"));
  31
  32     let a = sa6(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
  33     assert_eq!(Ok(vec![a]), tsa("[2a02:6b8:0:1::1]:53"));
  34
  35     let a = sa4(Ipv4Addr::new(127, 0, 0, 1), 23924);
  36     #[cfg(not(target_env = "sgx"))]
  37     assert!(tsa("localhost:23924").unwrap().contains(&a));
  38     #[cfg(target_env = "sgx")]
  39     let _ = a;
  40 }
  41
  42 #[test]
  43 fn to_socket_addr_string() {
  44     let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);
  45     assert_eq!(Ok(vec![a]), tsa(&*format!("{}:{}", "77.88.21.11", "24352")));
  46     assert_eq!(Ok(vec![a]), tsa(&format!("{}:{}", "77.88.21.11", "24352")));
  47     assert_eq!(Ok(vec![a]), tsa(format!("{}:{}", "77.88.21.11", "24352")));
  48
  49     let s = format!("{}:{}", "77.88.21.11", "24352");
  50     assert_eq!(Ok(vec![a]), tsa(s));
  51     // s has been moved into the tsa call
  52 }
  53
  54 #[test]
  55 fn bind_udp_socket_bad() {
  56     // rust-lang/rust#53957: This is a regression test for a parsing problem
  57     // discovered as part of issue rust-lang/rust#23076, where we were
  58     // incorrectly parsing invalid input and then that would result in a
  59     // successful `UdpSocket` binding when we would expect failure.
  60     //
  61     // At one time, this test was written as a call to `tsa` with
  62     // INPUT_23076. However, that structure yields an unreliable test,
  63     // because it ends up passing junk input to the DNS server, and some DNS
  64     // servers will respond with `Ok` to such input, with the ip address of
  65     // the DNS server itself.
  66     //
  67     // This form of the test is more robust: even when the DNS server
  68     // returns its own address, it is still an error to bind a UDP socket to
  69     // a non-local address, and so we still get an error here in that case.
  70
  71     const INPUT_23076: &'static str = "1200::AB00:1234::2552:7777:1313:34300";
  72
  73     assert!(crate::net::UdpSocket::bind(INPUT_23076).is_err())
  74 }
  75
  76 #[test]
  77 fn set_ip() {
  78     fn ip4(low: u8) -> Ipv4Addr {
  79         Ipv4Addr::new(77, 88, 21, low)
  80     }
  81     fn ip6(low: u16) -> Ipv6Addr {
  82         Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, low)
  83     }
  84
  85     let mut v4 = SocketAddrV4::new(ip4(11), 80);
  86     assert_eq!(v4.ip(), &ip4(11));
  87     v4.set_ip(ip4(12));
  88     assert_eq!(v4.ip(), &ip4(12));
  89
  90     let mut addr = SocketAddr::V4(v4);
  91     assert_eq!(addr.ip(), IpAddr::V4(ip4(12)));
  92     addr.set_ip(IpAddr::V4(ip4(13)));
  93     assert_eq!(addr.ip(), IpAddr::V4(ip4(13)));
  94     addr.set_ip(IpAddr::V6(ip6(14)));
  95     assert_eq!(addr.ip(), IpAddr::V6(ip6(14)));
  96
  97     let mut v6 = SocketAddrV6::new(ip6(1), 80, 0, 0);
  98     assert_eq!(v6.ip(), &ip6(1));
  99     v6.set_ip(ip6(2));
 100     assert_eq!(v6.ip(), &ip6(2));
 101
 102     let mut addr = SocketAddr::V6(v6);
 103     assert_eq!(addr.ip(), IpAddr::V6(ip6(2)));
 104     addr.set_ip(IpAddr::V6(ip6(3)));
 105     assert_eq!(addr.ip(), IpAddr::V6(ip6(3)));
 106     addr.set_ip(IpAddr::V4(ip4(4)));
 107     assert_eq!(addr.ip(), IpAddr::V4(ip4(4)));
 108 }
 109
 110 #[test]
 111 fn set_port() {
 112     let mut v4 = SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80);
 113     assert_eq!(v4.port(), 80);
 114     v4.set_port(443);
 115     assert_eq!(v4.port(), 443);
 116
 117     let mut addr = SocketAddr::V4(v4);
 118     assert_eq!(addr.port(), 443);
 119     addr.set_port(8080);
 120     assert_eq!(addr.port(), 8080);
 121
 122     let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 0);
 123     assert_eq!(v6.port(), 80);
 124     v6.set_port(443);
 125     assert_eq!(v6.port(), 443);
 126
 127     let mut addr = SocketAddr::V6(v6);
 128     assert_eq!(addr.port(), 443);
 129     addr.set_port(8080);
 130     assert_eq!(addr.port(), 8080);
 131 }
 132
 133 #[test]
 134 fn set_flowinfo() {
 135     let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 10, 0);
 136     assert_eq!(v6.flowinfo(), 10);
 137     v6.set_flowinfo(20);
 138     assert_eq!(v6.flowinfo(), 20);
 139 }
 140
 141 #[test]
 142 fn set_scope_id() {
 143     let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 10);
 144     assert_eq!(v6.scope_id(), 10);
 145     v6.set_scope_id(20);
 146     assert_eq!(v6.scope_id(), 20);
 147 }
 148
 149 #[test]
 150 fn is_v4() {
 151     let v4 = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80));
 152     assert!(v4.is_ipv4());
 153     assert!(!v4.is_ipv6());
 154 }
 155
 156 #[test]
 157 fn is_v6() {
 158     let v6 = SocketAddr::V6(SocketAddrV6::new(
 159         Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1),
 160         80,
 161         10,
 162         0,
 163     ));
 164     assert!(!v6.is_ipv4());
 165     assert!(v6.is_ipv6());
 166 }
 167
 168 #[test]
 169 fn socket_v4_to_str() {
 170     let socket = SocketAddrV4::new(Ipv4Addr::new(192, 168, 0, 1), 8080);
 171
 172     assert_eq!(format!("{}", socket), "192.168.0.1:8080");
 173     assert_eq!(format!("{:<20}", socket), "192.168.0.1:8080    ");
 174     assert_eq!(format!("{:>20}", socket), "    192.168.0.1:8080");
 175     assert_eq!(format!("{:^20}", socket), "  192.168.0.1:8080  ");
 176     assert_eq!(format!("{:.10}", socket), "192.168.0.");
 177 }
 178
 179 #[test]
 180 fn socket_v6_to_str() {
 181     let socket: SocketAddrV6 = "[2a02:6b8:0:1::1]:53".parse().unwrap();
 182
 183     assert_eq!(format!("{}", socket), "[2a02:6b8:0:1::1]:53");
 184     assert_eq!(format!("{:<24}", socket), "[2a02:6b8:0:1::1]:53    ");
 185     assert_eq!(format!("{:>24}", socket), "    [2a02:6b8:0:1::1]:53");
 186     assert_eq!(format!("{:^24}", socket), "  [2a02:6b8:0:1::1]:53  ");
 187     assert_eq!(format!("{:.15}", socket), "[2a02:6b8:0:1::");
 188 }
 189
 190 #[test]
 191 fn compare() {
 192     let v4_1 = "224.120.45.1:23456".parse::<SocketAddrV4>().unwrap();
 193     let v4_2 = "224.210.103.5:12345".parse::<SocketAddrV4>().unwrap();
 194     let v4_3 = "224.210.103.5:23456".parse::<SocketAddrV4>().unwrap();
 195     let v6_1 = "[2001:db8:f00::1002]:23456".parse::<SocketAddrV6>().unwrap();
 196     let v6_2 = "[2001:db8:f00::2001]:12345".parse::<SocketAddrV6>().unwrap();
 197     let v6_3 = "[2001:db8:f00::2001]:23456".parse::<SocketAddrV6>().unwrap();
 198
 199     // equality
 200     assert_eq!(v4_1, v4_1);
 201     assert_eq!(v6_1, v6_1);
 202     assert_eq!(SocketAddr::V4(v4_1), SocketAddr::V4(v4_1));
 203     assert_eq!(SocketAddr::V6(v6_1), SocketAddr::V6(v6_1));
 204     assert!(v4_1 != v4_2);
 205     assert!(v6_1 != v6_2);
 206
 207     // compare different addresses
 208     assert!(v4_1 < v4_2);
 209     assert!(v6_1 < v6_2);
 210     assert!(v4_2 > v4_1);
 211     assert!(v6_2 > v6_1);
 212
 213     // compare the same address with different ports
 214     assert!(v4_2 < v4_3);
 215     assert!(v6_2 < v6_3);
 216     assert!(v4_3 > v4_2);
 217     assert!(v6_3 > v6_2);
 218
 219     // compare different addresses with the same port
 220     assert!(v4_1 < v4_3);
 221     assert!(v6_1 < v6_3);
 222     assert!(v4_3 > v4_1);
 223     assert!(v6_3 > v6_1);
 224
 225     // compare with an inferred right-hand side
 226     assert_eq!(v4_1, "224.120.45.1:23456".parse().unwrap());
 227     assert_eq!(v6_1, "[2001:db8:f00::1002]:23456".parse().unwrap());
 228     assert_eq!(SocketAddr::V4(v4_1), "224.120.45.1:23456".parse().unwrap());
 229 }