Fix all tests from the update to rust master

Author: alexcrichton

Cargo.lock

@@ -28,20 +28,16 @@ term = "0.1.13"
 regex = "0.1.18"
 threadpool = "0.1.1"
 libc = "0.1.2"
+registry = { path = "src/registry" }
 
-[target.i686-pc-windows-gnu.dependencies]
-winapi = "0.1"
-advapi32-sys = "*"
+[target.i686-pc-windows-gnu]
+dependencies = { winapi = "0.1", advapi32-sys = "*" }
+[target.x86_64-pc-windows-gnu]
+dependencies = { winapi = "0.1", advapi32-sys = "*" }
 
-[target.x86_64-pc-windows-gnu.dependencies]
-winapi = "0.1"
-advapi32-sys = "*"
-
-[dev-dependencies.hamcrest]
-git = "https://github.com/carllerche/hamcrest-rust.git"
-
-[dependencies.registry]
-path = "src/registry"
+[dev-dependencies]
+tempdir = "0.3"
+hamcrest = { git = "https://github.com/carllerche/hamcrest-rust.git" }
 
 [[bin]]
 name = "cargo"
@@ -50,9 +46,6 @@ doc = false
 
 [[test]]
 name = "tests"
-[[bench]]
-name = "tests"
-path = "tests/tests.rs"
 
 [[test]]
 name = "resolve"

Cargo.toml

@@ -101,39 +101,54 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
         return Ok(None)
     }
 
-    let (mut args, command) = match &flags.arg_command[..] {
+    let args = match &flags.arg_command[..] {
+        // For the commands `cargo` and `cargo help`, re-execute ourselves as
+        // `cargo -h` so we can go through the normal process of printing the
+        // help message.
         "" | "help" if flags.arg_args.len() == 0 => {
             config.shell().set_verbose(true);
-            let args = &["foo".to_string(), "-h".to_string()];
+            let args = &["cargo".to_string(), "-h".to_string()];
             let r = cargo::call_main_without_stdin(execute, config, USAGE, args,
                                                    false);
-            cargo::process_executed(r, &mut **config.shell());
+            cargo::process_executed(r, &mut config.shell());
             return Ok(None)
         }
+
+        // For `cargo help -h` and `cargo help --help`, print out the help
+        // message for `cargo help`
         "help" if flags.arg_args[0] == "-h" ||
-                  flags.arg_args[0] == "--help" =>
-            (flags.arg_args, "help"),
-        "help" => (vec!["-h".to_string()], &flags.arg_args[0][..]),
-        s => (flags.arg_args.clone(), s),
+                  flags.arg_args[0] == "--help" => {
+            vec!["cargo".to_string(), "help".to_string(), "help".to_string()]
+        }
+
+        // For `cargo help foo`, print out the usage message for the specified
+        // subcommand by executing the command with the `-h` flag.
+        "help" => {
+            vec!["cargo".to_string(), "help".to_string(),
+                 flags.arg_args[0].clone()]
+        }
+
+        // For all other invocations, we're of the form `cargo foo args...`. We
+        // use the exact environment arguments to preserve tokens like `--` for
+        // example.
+        _ => env::args().collect(),
     };
-    args.insert(0, command.to_string());
-    args.insert(0, "foo".to_string());
 
     macro_rules! cmd{ ($name:ident) => (
-        if command == stringify!($name).replace("_", "-") {
+        if args[1] == stringify!($name).replace("_", "-") {
             mod $name;
             config.shell().set_verbose(true);
             let r = cargo::call_main_without_stdin($name::execute, config,
                                                    $name::USAGE,
                                                    &args,
                                                    false);
-            cargo::process_executed(r, &mut **config.shell());
+            cargo::process_executed(r, &mut config.shell());
             return Ok(None)
         }
     ) }
     each_subcommand!(cmd);
 
-    execute_subcommand(&command, &args, &mut config.shell());
+    execute_subcommand(&args[1], &args, &mut config.shell());
     Ok(None)
 }
 
@@ -230,7 +245,7 @@ fn is_executable(path: &Path) -> bool {
 }
 #[cfg(windows)]
 fn is_executable(path: &Path) -> bool {
-    path.is_file()
+    fs::metadata(path).map(|m| m.is_file()) == Ok(true)
 }
 
 /// Get `Command` to run given command.

src/bin/cargo.rs

@@ -1,7 +1,7 @@
 use std::env;
 use std::fs;
 use std::io::prelude::*;
-use std::io;
+use std::io::{self, ErrorKind};
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 
@@ -32,7 +32,29 @@ impl CargoPathExt for Path {
      */
     fn rm_rf(&self) -> io::Result<()> {
         if self.exists() {
-            fs::remove_dir_all(self)
+            for file in fs::read_dir(self).unwrap() {
+                let file = try!(file).path();
+
+                if file.is_dir() {
+                    try!(file.rm_rf());
+                } else {
+                    // On windows we can't remove a readonly file, and git will
+                    // often clone files as readonly. As a result, we have some
+                    // special logic to remove readonly files on windows.
+                    match fs::remove_file(&file) {
+                        Ok(()) => {}
+                        Err(ref e) if cfg!(windows) &&
+                                      e.kind() == ErrorKind::PermissionDenied => {
+                            let mut p = file.metadata().unwrap().permissions();
+                            p.set_readonly(false);
+                            fs::set_permissions(&file, p).unwrap();
+                            try!(fs::remove_file(&file));
+                        }
+                        Err(e) => return Err(e)
+                    }
+                }
+            }
+            fs::remove_dir(self)
         } else {
             Ok(())
         }

tests/support/paths.rs

@@ -88,8 +88,8 @@ pub fn mock_pkg_yank(name: &str, version: &str, deps: &[(&str, &str, &str)],
     let file = match name.len() {
         1 => format!("1/{}", name),
         2 => format!("2/{}", name),
-        3 => format!("3/{}/{}", name.slice_to(1), name),
-        _ => format!("{}/{}/{}", name.slice(0, 2), name.slice(2, 4), name),
+        3 => format!("3/{}/{}", &name[..1], name),
+        _ => format!("{}/{}/{}", &name[0..2], &name[2..4], name),
     };
     publish(file.as_slice(), line.as_slice());
 }

tests/support/registry.rs

@@ -1,6 +1,7 @@
 use std::collections::HashSet;
-use std::old_io::net::tcp::TcpAcceptor;
-use std::old_io::{TcpListener, Listener, Acceptor, BufferedStream};
+use std::io::BufStream;
+use std::io::prelude::*;
+use std::net::TcpListener;
 use std::thread;
 use git2;
 
@@ -11,23 +12,12 @@ use hamcrest::assert_that;
 fn setup() {
 }
 
-struct Closer { a: TcpAcceptor }
-
-impl Drop for Closer {
-    fn drop(&mut self) {
-        let _ = self.a.close_accept();
-    }
-}
-
 // Test that HTTP auth is offered from `credential.helper`
 test!(http_auth_offered {
-    let mut listener = TcpListener::bind("127.0.0.1:0").unwrap();
-    let addr = listener.socket_name().unwrap();
-    let mut a = listener.listen().unwrap();
-    let a2 = a.clone();
-    let _c = Closer { a: a2 };
+    let a = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = a.socket_addr().unwrap();
 
-    fn headers<R: Buffer>(rdr: &mut R) -> HashSet<String> {
+    fn headers(rdr: &mut BufRead) -> HashSet<String> {
         let valid = ["GET", "Authorization", "Accept", "User-Agent"];
         rdr.lines().map(|s| s.unwrap())
            .take_while(|s| s.len() > 2)
@@ -39,7 +29,7 @@ test!(http_auth_offered {
     }
 
     let t = thread::spawn(move|| {
-        let mut s = BufferedStream::new(a.accept().unwrap());
+        let mut s = BufStream::new(a.accept().unwrap().0);
         let req = headers(&mut s);
         s.write_all(b"\
             HTTP/1.1 401 Unauthorized\r\n\
@@ -53,7 +43,7 @@ test!(http_auth_offered {
         ].into_iter().map(|s| s.to_string()).collect());
         drop(s);
 
-        let mut s = BufferedStream::new(a.accept().unwrap());
+        let mut s = BufStream::new(a.accept().unwrap().0);
         let req = headers(&mut s);
         s.write_all(b"\
             HTTP/1.1 401 Unauthorized\r\n\
@@ -91,15 +81,15 @@ test!(http_auth_offered {
                    script.display().to_string().as_slice()).unwrap();
 
     let p = project("foo")
-        .file("Cargo.toml", format!(r#"
+        .file("Cargo.toml", &format!(r#"
             [project]
             name = "foo"
             version = "0.0.1"
             authors = []
 
             [dependencies.bar]
             git = "http://127.0.0.1:{}/foo/bar"
-        "#, addr.port).as_slice())
+        "#, addr.port()))
         .file("src/main.rs", "");
 
     assert_that(p.cargo_process("build").arg("-v"),
@@ -125,25 +115,22 @@ Caused by:
 
 // Boy, sure would be nice to have a TLS implementation in rust!
 test!(https_something_happens {
-    let mut listener = TcpListener::bind("127.0.0.1:0").unwrap();
-    let addr = listener.socket_name().unwrap();
-    let mut a = listener.listen().unwrap();
-    let a2 = a.clone();
-    let _c = Closer { a: a2 };
+    let a = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = a.socket_addr().unwrap();
     let t = thread::spawn(move|| {
         drop(a.accept().unwrap());
     });
 
     let p = project("foo")
-        .file("Cargo.toml", format!(r#"
+        .file("Cargo.toml", &format!(r#"
             [project]
             name = "foo"
             version = "0.0.1"
             authors = []
 
             [dependencies.bar]
             git = "https://127.0.0.1:{}/foo/bar"
-        "#, addr.port).as_slice())
+        "#, addr.port()))
         .file("src/main.rs", "");
 
     assert_that(p.cargo_process("build").arg("-v"),
@@ -175,11 +162,8 @@ Caused by:
 
 // Boy, sure would be nice to have an SSH implementation in rust!
 test!(ssh_something_happens {
-    let mut listener = TcpListener::bind("127.0.0.1:0").unwrap();
-    let addr = listener.socket_name().unwrap();
-    let mut a = listener.listen().unwrap();
-    let a2 = a.clone();
-    let _c = Closer { a: a2 };
+    let a = TcpListener::bind("127.0.0.1:0").unwrap();
+    let addr = a.socket_addr().unwrap();
     let t = thread::spawn(move|| {
         drop(a.accept().unwrap());
     });
@@ -193,7 +177,7 @@ test!(ssh_something_happens {
 
             [dependencies.bar]
             git = "ssh://127.0.0.1:{}/foo/bar"
-        "#, addr.port).as_slice())
+        "#, addr.port()).as_slice())
         .file("src/main.rs", "");
 
     assert_that(p.cargo_process("build").arg("-v"),

tests/test_cargo_build_auth.rs

@@ -1,6 +1,7 @@
 use std::env;
-use std::fs::{self, TempDir, File};
+use std::fs::{self, File};
 use std::io::prelude::*;
+use tempdir::TempDir;
 
 use support::{project, execs, main_file, basic_bin_manifest};
 use support::{COMPILING, RUNNING, ProjectBuilder};

tests/test_cargo_compile.rs

@@ -142,7 +142,7 @@ test!(plugin_deps {
             use rustc::plugin::Registry;
             use syntax::ast::TokenTree;
             use syntax::codemap::Span;
-            use syntax::ext::base::{ExtCtxt, MacExpr, MacResult};
+            use syntax::ext::base::{ExtCtxt, MacEager, MacResult};
 
             #[plugin_registrar]
             pub fn foo(reg: &mut Registry) {
@@ -151,7 +151,7 @@ test!(plugin_deps {
 
             fn expand_bar(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
                           -> Box<MacResult + 'static> {
-                MacExpr::new(quote_expr!(cx, 1))
+                MacEager::expr(quote_expr!(cx, 1))
             }
         "#);
     let baz = project("baz")
@@ -222,7 +222,7 @@ test!(plugin_to_the_max {
             use rustc::plugin::Registry;
             use syntax::ast::TokenTree;
             use syntax::codemap::Span;
-            use syntax::ext::base::{ExtCtxt, MacExpr, MacResult};
+            use syntax::ext::base::{ExtCtxt, MacEager, MacResult};
 
             #[plugin_registrar]
             pub fn foo(reg: &mut Registry) {
@@ -231,7 +231,7 @@ test!(plugin_to_the_max {
 
             fn expand_bar(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
                           -> Box<MacResult + 'static> {
-                MacExpr::new(quote_expr!(cx, baz::baz()))
+                MacEager::expr(quote_expr!(cx, baz::baz()))
             }
         "#);
     let baz = project("baz")

tests/test_cargo_cross_compile.rs

@@ -1,6 +1,7 @@
-use std::fs::{self, File, TempDir};
+use std::fs::{self, File};
 use std::io::prelude::*;
 use std::env;
+use tempdir::TempDir;
 
 use support::{execs, paths, cargo_dir};
 use hamcrest::{assert_that, existing_file, existing_dir, is_not};