---

yaml
---
r: 127741
b: refs/heads/snap-stage3
c: 4475e6a
h: refs/heads/master
i:
  127739: 090f3df
v: v3

Author: brson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 49a970f2449a78f28b6c301e542d38593094ca77
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9fdcddb3178d4705db4aee5ee12c05796203658c
+refs/heads/snap-stage3: 4475e6a095a8fe4459ac8b854ae2336e47aaafe5
 refs/heads/try: d9c23fcbaea89871667272a67ecb8d3a512162f3
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/io/net/tcp.rs

@@ -93,21 +93,27 @@ impl TcpStream {
     }
 
     /// Creates a TCP connection to a remote socket address, timing out after
-    /// the specified number of milliseconds.
+    /// the specified duration.
     ///
     /// This is the same as the `connect` method, except that if the timeout
     /// specified (in milliseconds) elapses before a connection is made an error
     /// will be returned. The error's kind will be `TimedOut`.
     ///
     /// Note that the `addr` argument may one day be split into a separate host
     /// and port, similar to the API seen in `connect`.
+    ///
+    /// # Failure
+    ///
+    /// Fails on a `timeout` of zero or negative duration.
     #[experimental = "the timeout argument may eventually change types"]
     pub fn connect_timeout(addr: SocketAddr,
                            timeout: Duration) -> IoResult<TcpStream> {
+        assert!(timeout > Duration::milliseconds(0));
+
         let SocketAddr { ip, port } = addr;
         let addr = rtio::SocketAddr { ip: super::to_rtio(ip), port: port };
         LocalIo::maybe_raise(|io| {
-            io.tcp_connect(addr, Some(in_ms_u64(timeout))).map(TcpStream::new)
+            io.tcp_connect(addr, Some(timeout.num_milliseconds() as u64)).map(TcpStream::new)
         }).map_err(IoError::from_rtio_error)
     }
 
@@ -444,12 +450,6 @@ impl Acceptor<TcpStream> for TcpAcceptor {
     }
 }
 
-fn in_ms_u64(d: Duration) -> u64 {
-    let ms = d.num_milliseconds();
-    if ms < 0 { return 0 };
-    return ms as u64;
-}
-
 #[cfg(test)]
 #[allow(experimental)]
 mod test {

branches/snap-stage3/src/libstd/io/net/unix.rs

@@ -67,11 +67,17 @@ impl UnixStream {
     ///
     /// This function is similar to `connect`, except that if `timeout_ms`
     /// elapses the function will return an error of kind `TimedOut`.
+    ///
+    /// # Failure
+    ///
+    /// Fails on a `timeout` of zero or negative duration.
     #[experimental = "the timeout argument is likely to change types"]
     pub fn connect_timeout<P: ToCStr>(path: &P,
                                       timeout: Duration) -> IoResult<UnixStream> {
+        assert!(timeout > Duration::milliseconds(0));
+
         LocalIo::maybe_raise(|io| {
-            let s = io.unix_connect(&path.to_c_str(), Some(in_ms_u64(timeout)));
+            let s = io.unix_connect(&path.to_c_str(), Some(timeout.num_milliseconds() as u64));
             s.map(|p| UnixStream { obj: p })
         }).map_err(IoError::from_rtio_error)
     }
@@ -509,6 +515,18 @@ mod tests {
         assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(100)).is_ok());
     })
 
+    iotest!(fn connect_timeout_zero() {
+        let addr = next_test_unix();
+        let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
+        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(0)).is_ok());
+    } #[should_fail])
+
+    iotest!(fn connect_timeout_negative() {
+        let addr = next_test_unix();
+        let _a = UnixListener::bind(&addr).unwrap().listen().unwrap();
+        assert!(UnixStream::connect_timeout(&addr, Duration::milliseconds(-1)).is_ok());
+    } #[should_fail])
+
     iotest!(fn close_readwrite_smoke() {
         let addr = next_test_unix();
         let a = UnixListener::bind(&addr).listen().unwrap();