---

yaml
---
r: 63883
b: refs/heads/snap-stage3
c: d820355
h: refs/heads/master
i:
  63881: 59314e7
  63879: d5ad126
v: v3

Author: thestinger

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 439b13f071a4a884ea8645670df83162ffcf129f
+refs/heads/snap-stage3: d820355213d433c85ef49bae03022d754ca2f5d5
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libstd/iterator.rs

@@ -356,20 +356,20 @@ pub trait IteratorUtil<A> {
     ///
     /// # Example
     ///
-    /// --- {.rust}
+    /// ~~~ {.rust}
     /// let xs = [-3, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
-    /// ---
+    /// ~~~
     fn max_by<B: Ord>(&mut self, f: &fn(&A) -> B) -> Option<A>;
 
     /// Return the element that gives the minimum value from the specfied function
     ///
     /// # Example
     ///
-    /// --- {.rust}
+    /// ~~~ {.rust}
     /// let xs = [-3, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
-    /// ---
+    /// ~~~
     fn min_by<B: Ord>(&mut self, f: &fn(&A) -> B) -> Option<A>;
 }
 

branches/snap-stage3/src/libstd/run.rs

@@ -943,20 +943,12 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_process_status() {
         assert_eq!(run::process_status("false", []), 1);
         assert_eq!(run::process_status("true", []), 0);
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_process_status() {
-        assert_eq!(run::process_status("/system/bin/sh", [~"-c",~"false"]), 1);
-        assert_eq!(run::process_status("/system/bin/sh", [~"-c",~"true"]), 0);
-    }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_process_output_output() {
 
         let run::ProcessOutput {status, output, error}
@@ -970,24 +962,8 @@ mod tests {
             assert_eq!(error, ~[]);
         }
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_process_output_output() {
-
-        let run::ProcessOutput {status, output, error}
-             = run::process_output("/system/bin/sh", [~"-c",~"echo hello"]);
-        let output_str = str::from_bytes(output);
-
-        assert_eq!(status, 0);
-        assert_eq!(output_str.trim().to_owned(), ~"hello");
-        // FIXME #7224
-        if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
-        }
-    }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_process_output_error() {
 
         let run::ProcessOutput {status, output, error}
@@ -997,17 +973,6 @@ mod tests {
         assert_eq!(output, ~[]);
         assert!(!error.is_empty());
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_process_output_error() {
-
-        let run::ProcessOutput {status, output, error}
-             = run::process_output("/system/bin/mkdir", [~"."]);
-
-        assert_eq!(status, 255);
-        assert_eq!(output, ~[]);
-        assert!(!error.is_empty());
-    }
 
     #[test]
     fn test_pipes() {
@@ -1058,37 +1023,19 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_finish_once() {
         let mut prog = run::Process::new("false", [], run::ProcessOptions::new());
         assert_eq!(prog.finish(), 1);
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_finish_once() {
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"false"],
-                                         run::ProcessOptions::new());
-        assert_eq!(prog.finish(), 1);
-    }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_finish_twice() {
         let mut prog = run::Process::new("false", [], run::ProcessOptions::new());
         assert_eq!(prog.finish(), 1);
         assert_eq!(prog.finish(), 1);
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_finish_twice() {
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"false"],
-                                         run::ProcessOptions::new());
-        assert_eq!(prog.finish(), 1);
-        assert_eq!(prog.finish(), 1);
-    }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_finish_with_output_once() {
 
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions::new());
@@ -1103,26 +1050,8 @@ mod tests {
             assert_eq!(error, ~[]);
         }
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_finish_with_output_once() {
-
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"echo hello"],
-                                         run::ProcessOptions::new());
-        let run::ProcessOutput {status, output, error}
-            = prog.finish_with_output();
-        let output_str = str::from_bytes(output);
-
-        assert_eq!(status, 0);
-        assert_eq!(output_str.trim().to_owned(), ~"hello");
-        // FIXME #7224
-        if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
-        }
-    }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_finish_with_output_twice() {
 
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions::new());
@@ -1148,38 +1077,10 @@ mod tests {
             assert_eq!(error, ~[]);
         }
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_finish_with_output_twice() {
-
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"echo hello"],
-                                         run::ProcessOptions::new());
-        let run::ProcessOutput {status, output, error}
-            = prog.finish_with_output();
-
-        let output_str = str::from_bytes(output);
-
-        assert_eq!(status, 0);
-        assert_eq!(output_str.trim().to_owned(), ~"hello");
-        // FIXME #7224
-        if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
-        }
-
-        let run::ProcessOutput {status, output, error}
-            = prog.finish_with_output();
-
-        assert_eq!(status, 0);
-        assert_eq!(output, ~[]);
-        // FIXME #7224
-        if !running_on_valgrind() {
-            assert_eq!(error, ~[]);
-        }
-    }
 
     #[test]
     #[should_fail]
-    #[cfg(not(windows),not(target_os="android"))]
+    #[cfg(not(windows))]
     fn test_finish_with_output_redirected() {
         let mut prog = run::Process::new("echo", [~"hello"], run::ProcessOptions {
             env: None,
@@ -1191,36 +1092,14 @@ mod tests {
         // this should fail because it is not valid to read the output when it was redirected
         prog.finish_with_output();
     }
-    #[test]
-    #[should_fail]
-    #[cfg(not(windows),target_os="android")]
-    fn test_finish_with_output_redirected() {
-        let mut prog = run::Process::new("/system/bin/sh", [~"-c",~"echo hello"],
-                                         run::ProcessOptions {
-            env: None,
-            dir: None,
-            in_fd: Some(0),
-            out_fd: Some(1),
-            err_fd: Some(2)
-        });
-        // this should fail because it is not valid to read the output when it was redirected
-        prog.finish_with_output();
-    }
 
-    #[cfg(unix,not(target_os="android"))]
+    #[cfg(unix)]
     fn run_pwd(dir: Option<&Path>) -> run::Process {
         run::Process::new("pwd", [], run::ProcessOptions {
             dir: dir,
             .. run::ProcessOptions::new()
         })
     }
-    #[cfg(unix,target_os="android")]
-    fn run_pwd(dir: Option<&Path>) -> run::Process {
-        run::Process::new("/system/bin/sh", [~"-c",~"pwd"], run::ProcessOptions {
-            dir: dir,
-            .. run::ProcessOptions::new()
-        })
-    }
 
     #[cfg(windows)]
     fn run_pwd(dir: Option<&Path>) -> run::Process {
@@ -1262,20 +1141,13 @@ mod tests {
         assert_eq!(parent_stat.st_ino, child_stat.st_ino);
     }
 
-    #[cfg(unix,not(target_os="android"))]
+    #[cfg(unix)]
     fn run_env(env: Option<&[(~str, ~str)]>) -> run::Process {
         run::Process::new("env", [], run::ProcessOptions {
             env: env,
             .. run::ProcessOptions::new()
         })
     }
-    #[cfg(unix,target_os="android")]
-    fn run_env(env: Option<&[(~str, ~str)]>) -> run::Process {
-        run::Process::new("/system/bin/sh", [~"-c",~"set"], run::ProcessOptions {
-            env: env,
-            .. run::ProcessOptions::new()
-        })
-    }
 
     #[cfg(windows)]
     fn run_env(env: Option<&[(~str, ~str)]>) -> run::Process {
@@ -1286,7 +1158,6 @@ mod tests {
     }
 
     #[test]
-    #[cfg(not(target_os="android"))]
     fn test_inherit_env() {
         if running_on_valgrind() { return; }
 
@@ -1299,23 +1170,6 @@ mod tests {
             assert!(k.is_empty() || output.contains(fmt!("%s=%s", k, v)));
         }
     }
-    #[test]
-    #[cfg(target_os="android")]
-    fn test_inherit_env() {
-        if running_on_valgrind() { return; }
-
-        let mut prog = run_env(None);
-        let output = str::from_bytes(prog.finish_with_output().output);
-
-        let r = os::env();
-        for r.iter().advance |&(k, v)| {
-            // don't check android RANDOM variables
-            if k != ~"RANDOM" {
-                assert!(output.contains(fmt!("%s=%s", k, v)) ||
-                        output.contains(fmt!("%s=\'%s\'", k, v)));
-            }
-        }
-    }
 
     #[test]
     fn test_add_to_env() {