---

yaml
---
r: 91639
b: refs/heads/auto
c: a46b2b8
h: refs/heads/master
i:
  91637: 28f2101
  91635: 8a87ec9
  91631: 26ff522
v: v3

Author: emberian

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 4059b5c4b3b8a57a645982b0770d25f0283dfb06
+refs/heads/auto: a46b2b8e7aafd23a4d3850d4de6653e363fd0813
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustuv/addrinfo.rs

@@ -191,7 +191,6 @@ mod test {
     use super::super::local_loop;
 
     #[test]
-    #[ignore(cfg(target_os="android"))] // cannot give tcp/ip permission without help of apk
     fn getaddrinfo_test() {
         match GetAddrInfoRequest::run(local_loop(), Some("localhost"), None, None) {
             Ok(infos) => {

branches/auto/src/librustuv/pipe.rs

@@ -251,6 +251,7 @@ mod tests {
     use super::super::local_loop;
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn connect_err() {
         match PipeWatcher::connect(local_loop(), &"path/to/nowhere".to_c_str()) {
             Ok(*) => fail!(),
@@ -259,6 +260,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn bind_err() {
         match PipeListener::bind(local_loop(), &"path/to/nowhere".to_c_str()) {
             Ok(*) => fail!(),
@@ -267,6 +269,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn bind() {
         let p = next_test_unix().to_c_str();
         match PipeListener::bind(local_loop(), &p) {
@@ -276,13 +279,15 @@ mod tests {
     }
 
     #[test] #[should_fail]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn bind_fail() {
         let p = next_test_unix().to_c_str();
         let _w = PipeListener::bind(local_loop(), &p).unwrap();
         fail!();
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn connect() {
         let path = next_test_unix();
         let path2 = path.clone();
@@ -308,6 +313,7 @@ mod tests {
     }
 
     #[test] #[should_fail]
+    #[ignore(cfg(windows))] // FIXME(#10386): how windows pipes work
     fn connect_fail() {
         let path = next_test_unix();
         let path2 = path.clone();

branches/auto/src/libstd/iter.rs

@@ -65,7 +65,7 @@ the rest of the rust manuals.
 */
 
 use cmp;
-use num::{Zero, One, Integer, CheckedAdd, CheckedSub, Saturating, ToPrimitive};
+use num::{Zero, One, Integer, CheckedAdd, CheckedSub, Saturating};
 use option::{Option, Some, None};
 use ops::{Add, Mul, Sub};
 use cmp::{Eq, Ord};
@@ -1829,8 +1829,7 @@ pub fn range<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> Range<A> {
     Range{state: start, stop: stop, one: One::one()}
 }
 
-// FIXME: #10414: Unfortunate type bound
-impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> {
+impl<A: Add<A, A> + Ord + Clone> Iterator<A> for Range<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         if self.state < self.stop {
@@ -1842,42 +1841,13 @@ impl<A: Add<A, A> + Ord + Clone + ToPrimitive> Iterator<A> for Range<A> {
         }
     }
 
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        // This first checks if the elements are representable as i64. If they aren't, try u64 (to
-        // handle cases like range(huge, huger)). We don't use uint/int because the difference of
-        // the i64/u64 might lie within their range.
-        let bound = match self.state.to_i64() {
-            Some(a) => {
-                let sz = self.stop.to_i64().map(|b| b.checked_sub(&a));
-                match sz {
-                    Some(Some(bound)) => bound.to_uint(),
-                    _ => None,
-                }
-            },
-            None => match self.state.to_u64() {
-                Some(a) => {
-                    let sz = self.stop.to_u64().map(|b| b.checked_sub(&a));
-                    match sz {
-                        Some(Some(bound)) => bound.to_uint(),
-                        _ => None
-                    }
-                },
-                None => None
-            }
-        };
-
-        match bound {
-            Some(b) => (b, Some(b)),
-            // Standard fallback for unbounded/unrepresentable bounds
-            None => (0, None)
-        }
-    }
+    // FIXME: #8606 Implement size_hint() on Range
+    // Blocked on #8605 Need numeric trait for converting to `Option<uint>`
 }
 
 /// `Integer` is required to ensure the range will be the same regardless of
 /// the direction it is consumed.
-impl<A: Integer + Ord + Clone + ToPrimitive> DoubleEndedIterator<A> for Range<A> {
+impl<A: Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.stop > self.state {
@@ -1898,12 +1868,11 @@ pub struct RangeInclusive<A> {
 
 /// Return an iterator over the range [start, stop]
 #[inline]
-pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One + ToPrimitive>(start: A, stop: A)
-    -> RangeInclusive<A> {
+pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A) -> RangeInclusive<A> {
     RangeInclusive{range: range(start, stop), done: false}
 }
 
-impl<A: Add<A, A> + Eq + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusive<A> {
+impl<A: Add<A, A> + Eq + Ord + Clone> Iterator<A> for RangeInclusive<A> {
     #[inline]
     fn next(&mut self) -> Option<A> {
         match self.range.next() {
@@ -1935,8 +1904,7 @@ impl<A: Add<A, A> + Eq + Ord + Clone + ToPrimitive> Iterator<A> for RangeInclusi
     }
 }
 
-impl<A: Sub<A, A> + Integer + Ord + Clone + ToPrimitive> DoubleEndedIterator<A>
-    for RangeInclusive<A> {
+impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclusive<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
         if self.range.stop > self.range.state {
@@ -2216,7 +2184,6 @@ mod tests {
 
     use cmp;
     use uint;
-    use num;
 
     #[test]
     fn test_counter_from_iter() {
@@ -2834,51 +2801,12 @@ mod tests {
 
     #[test]
     fn test_range() {
-        /// A mock type to check Range when ToPrimitive returns None
-        struct Foo;
-
-        impl ToPrimitive for Foo {
-            fn to_i64(&self) -> Option<i64> { None }
-            fn to_u64(&self) -> Option<u64> { None }
-        }
-
-        impl Add<Foo, Foo> for Foo {
-            fn add(&self, _: &Foo) -> Foo {
-                Foo
-            }
-        }
-
-        impl Ord for Foo {
-            fn lt(&self, _: &Foo) -> bool {
-                false
-            }
-        }
-
-        impl Clone for Foo {
-            fn clone(&self) -> Foo {
-                Foo
-            }
-        }
-
-        impl num::One for Foo {
-            fn one() -> Foo {
-                Foo
-            }
-        }
-
         assert_eq!(range(0i, 5).collect::<~[int]>(), ~[0i, 1, 2, 3, 4]);
-        assert_eq!(range(-10i, -1).collect::<~[int]>(), ~[-10, -9, -8, -7, -6, -5, -4, -3, -2]);
         assert_eq!(range(0i, 5).invert().collect::<~[int]>(), ~[4, 3, 2, 1, 0]);
         assert_eq!(range(200, -5).collect::<~[int]>(), ~[]);
         assert_eq!(range(200, -5).invert().collect::<~[int]>(), ~[]);
         assert_eq!(range(200, 200).collect::<~[int]>(), ~[]);
         assert_eq!(range(200, 200).invert().collect::<~[int]>(), ~[]);
-
-        assert_eq!(range(0i, 100).size_hint(), (100, Some(100)));
-        // this test is only meaningful when sizeof uint < sizeof u64
-        assert_eq!(range(uint::max_value - 1, uint::max_value).size_hint(), (1, Some(1)));
-        assert_eq!(range(-10i, -1).size_hint(), (9, Some(9)));
-        assert_eq!(range(Foo, Foo).size_hint(), (0, None));
     }
 
     #[test]

branches/auto/src/libstd/rt/io/net/addrinfo.rs

@@ -114,7 +114,6 @@ mod test {
     use super::*;
 
     #[test]
-    #[ignore(cfg(target_os="android"))] // cannot give tcp/ip permission without help of apk
     fn dns_smoke_test() {
         let ipaddrs = get_host_addresses("localhost").unwrap();
         let mut found_local = false;

branches/auto/src/libstd/rt/io/signal.rs

@@ -161,7 +161,7 @@ mod test {
         }
     }
 
-    #[test] #[cfg(unix, not(target_os="android"))] // FIXME(#10378)
+    #[test] #[cfg(unix)]
     fn test_io_signal_smoketest() {
         let mut signal = Listener::new();
         signal.register(Interrupt);
@@ -173,7 +173,7 @@ mod test {
         }
     }
 
-    #[test] #[cfg(unix, not(target_os="android"))] // FIXME(#10378)
+    #[test] #[cfg(unix)]
     fn test_io_signal_two_signal_one_signum() {
         let mut s1 = Listener::new();
         let mut s2 = Listener::new();
@@ -191,7 +191,7 @@ mod test {
         }
     }
 
-    #[test] #[cfg(unix, not(target_os="android"))] // FIXME(#10378)
+    #[test] #[cfg(unix)]
     fn test_io_signal_unregister() {
         let mut s1 = Listener::new();
         let mut s2 = Listener::new();

branches/auto/src/libstd/rt/io/timer.rs

@@ -111,6 +111,8 @@ mod test {
     use prelude::*;
     use super::*;
     use rt::test::*;
+    use cell::Cell;
+    use task;
 
     #[test]
     fn test_io_timer_sleep_simple() {

branches/auto/src/libstd/rt/test.rs

@@ -375,11 +375,7 @@ pub fn next_test_port() -> u16 {
 /// Get a temporary path which could be the location of a unix socket
 #[fixed_stack_segment] #[inline(never)]
 pub fn next_test_unix() -> Path {
-    if cfg!(unix) {
-        os::tmpdir().join(rand::task_rng().gen_ascii_str(20))
-    } else {
-        Path::new(r"\\.\pipe\" + rand::task_rng().gen_ascii_str(20))
-    }
+    os::tmpdir().join(rand::task_rng().gen_ascii_str(20))
 }
 
 /// Get a unique IPv4 localhost:port pair starting at 9600