Auto merge of #5103 - alexcrichton:no-hamcrest, r=matklad

Drop outdated hamcrest dependency

This hasn't been updated in awhile and in general we've been barely using it.
This drops the outdated dependency and vendors a small amount of the
functionality that it provided. I think eventually we'll want to transition away
from this method of assertions but I wanted to get this piece in to avoid too
much churn in one commit.

Author: bors

Cargo.toml

@@ -80,9 +80,7 @@ features = [
 
 [dev-dependencies]
 bufstream = "0.1"
-cargotest = { path = "tests/testsuite/cargotest", version = "0.1" }
 filetime = "0.1"
-hamcrest = "=0.1.1"
 
 [[bin]]
 name = "cargo"

tests/testsuite/build_lib.rs

@@ -1,6 +1,3 @@
-extern crate cargotest;
-extern crate hamcrest;
-
 use cargotest::support::{basic_bin_manifest, execs, project, Project};
 use hamcrest::{assert_that};
 

tests/testsuite/cargotest/Cargo.toml

@@ -2,7 +2,8 @@ use std::fmt;
 use std::path::{PathBuf, Path};
 
 use hamcrest::{Matcher, MatchResult, existing_file};
-use support::paths;
+
+use cargotest::support::paths;
 
 pub use self::InstalledExe as has_installed_exe;
 
@@ -23,7 +24,7 @@ impl<P: AsRef<Path>> Matcher<P> for InstalledExe {
     }
 }
 
-impl fmt::Display for InstalledExe {
+impl fmt::Debug for InstalledExe {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "installed exe `{}`", self.0)
     }

tests/testsuite/cargotest/install.rs

@@ -1,23 +1,13 @@
-#![deny(warnings)]
-
-extern crate cargo;
-extern crate filetime;
-extern crate flate2;
-extern crate git2;
-extern crate hamcrest;
-extern crate hex;
-#[macro_use]
-extern crate serde_json;
-extern crate tar;
-extern crate url;
-
 use std::ffi::OsStr;
 use std::time::Duration;
 
 use cargo::util::Rustc;
+use cargo;
 use std::path::PathBuf;
 
+#[macro_use]
 pub mod support;
+
 pub mod install;
 
 thread_local!(pub static RUSTC: Rustc = Rustc::new(PathBuf::from("rustc"), None).unwrap());
@@ -95,5 +85,5 @@ pub fn cargo_process() -> cargo::util::ProcessBuilder {
 }
 
 pub fn sleep_ms(ms: u64) {
-    std::thread::sleep(Duration::from_millis(ms));
+    ::std::thread::sleep(Duration::from_millis(ms));
 }

tests/testsuite/cargotest/lib.rs renamed to tests/testsuite/cargotest/mod.rs

@@ -3,7 +3,7 @@ use std::process::Command;
 use std::sync::{Once, ONCE_INIT};
 use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
 
-use support::{project, main_file, basic_bin_manifest};
+use cargotest::support::{project, main_file, basic_bin_manifest};
 
 pub fn disabled() -> bool {
     // First, disable if ./configure requested so

tests/testsuite/cargotest/support/cross_compile.rs

@@ -2,11 +2,11 @@ use std::fs::{self, File};
 use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 
-use url::Url;
+use cargo::util::ProcessError;
 use git2;
+use url::Url;
 
-use cargo::util::ProcessError;
-use support::{ProjectBuilder, Project, project, path2url};
+use cargotest::support::{ProjectBuilder, Project, project, path2url};
 
 #[must_use]
 pub struct RepoBuilder {

tests/testsuite/cargotest/support/git.rs

@@ -15,9 +15,8 @@ use hamcrest as ham;
 use cargo::util::ProcessBuilder;
 use cargo::util::{ProcessError};
 
-use support::paths::CargoPathExt;
+use cargotest::support::paths::CargoPathExt;
 
-#[macro_export]
 macro_rules! t {
     ($e:expr) => (match $e {
         Ok(e) => e,
@@ -110,10 +109,6 @@ impl ProjectBuilder {
         self.root.root()
     }
 
-    pub fn build_dir(&self) -> PathBuf {
-        self.root.build_dir()
-    }
-
     pub fn target_debug_dir(&self) -> PathBuf {
         self.root.target_debug_dir()
     }
@@ -218,7 +213,7 @@ impl Project {
     }
 
     pub fn process<T: AsRef<OsStr>>(&self, program: T) -> ProcessBuilder {
-        let mut p = ::process(program);
+        let mut p = ::cargotest::process(program);
         p.cwd(self.root());
         return p
     }
@@ -406,11 +401,6 @@ impl Execs {
         self
     }
 
-    pub fn with_neither_contains<S: ToString>(mut self, expected: S) -> Execs {
-        self.expect_neither_contains.push(expected.to_string());
-        self
-    }
-
     pub fn with_json(mut self, expected: &str) -> Execs {
         self.expect_json = Some(expected.split("\n\n").map(|obj| {
             obj.parse().unwrap()
@@ -426,11 +416,10 @@ impl Execs {
 
     fn match_status(&self, actual: &Output) -> ham::MatchResult {
         match self.expect_exit_code {
-            None => ham::success(),
-            Some(code) => {
-                ham::expect(
-                    actual.status.code() == Some(code),
-                    format!("exited with {}\n--- stdout\n{}\n--- stderr\n{}",
+            None => Ok(()),
+            Some(code) if actual.status.code() == Some(code) => Ok(()),
+            Some(_) => {
+                Err(format!("exited with {}\n--- stdout\n{}\n--- stderr\n{}",
                             actual.status,
                             String::from_utf8_lossy(&actual.stdout),
                             String::from_utf8_lossy(&actual.stderr)))
@@ -507,7 +496,7 @@ impl Execs {
                  kind: MatchKind) -> ham::MatchResult {
         let out = match expected {
             Some(out) => out,
-            None => return ham::success(),
+            None => return Ok(()),
         };
         let actual = match str::from_utf8(actual) {
             Err(..) => return Err(format!("{} was not utf8 encoded",
@@ -524,12 +513,15 @@ impl Execs {
                 let e = out.lines();
 
                 let diffs = self.diff_lines(a, e, false);
-                ham::expect(diffs.is_empty(),
-                            format!("differences:\n\
-                                    {}\n\n\
-                                    other output:\n\
-                                    `{}`", diffs.join("\n"),
-                                    String::from_utf8_lossy(extra)))
+                if diffs.is_empty() {
+                    Ok(())
+                } else {
+                    Err(format!("differences:\n\
+                                 {}\n\n\
+                                 other output:\n\
+                                 `{}`", diffs.join("\n"),
+                                 String::from_utf8_lossy(extra)))
+                }
             }
             MatchKind::Partial => {
                 let mut a = actual.lines();
@@ -542,12 +534,15 @@ impl Execs {
                         diffs = a;
                     }
                 }
-                ham::expect(diffs.is_empty(),
-                            format!("expected to find:\n\
-                                     {}\n\n\
-                                     did not find in output:\n\
-                                     {}", out,
-                                     actual))
+                if diffs.is_empty() {
+                    Ok(())
+                } else {
+                    Err(format!("expected to find:\n\
+                                 {}\n\n\
+                                 did not find in output:\n\
+                                 {}", out,
+                                 actual))
+                }
             }
             MatchKind::PartialN(number) => {
                 let mut a = actual.lines();
@@ -562,20 +557,26 @@ impl Execs {
                     a.next()
                 } {}
 
-                ham::expect(matches == number,
-                            format!("expected to find {} occurrences:\n\
-                                     {}\n\n\
-                                     did not find in output:\n\
-                                     {}", number, out,
-                                     actual))
+                if matches == number {
+                    Ok(())
+                } else {
+                    Err(format!("expected to find {} occurrences:\n\
+                                 {}\n\n\
+                                 did not find in output:\n\
+                                 {}", number, out,
+                                 actual))
+                }
             }
             MatchKind::NotPresent => {
-                ham::expect(!actual.contains(out),
-                            format!("expected not to find:\n\
-                                     {}\n\n\
-                                     but found in output:\n\
-                                     {}", out,
-                                     actual))
+                if !actual.contains(out) {
+                    Ok(())
+                } else {
+                    Err(format!("expected not to find:\n\
+                                 {}\n\n\
+                                 but found in output:\n\
+                                 {}", out,
+                                 actual))
+                }
             }
         }
     }
@@ -746,7 +747,7 @@ fn zip_all<T, I1: Iterator<Item=T>, I2: Iterator<Item=T>>(a: I1, b: I2) -> ZipAl
     }
 }
 
-impl fmt::Display for Execs {
+impl fmt::Debug for Execs {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "execs")
     }
@@ -803,31 +804,6 @@ pub fn execs() -> Execs {
     }
 }
 
-#[derive(Clone)]
-pub struct ShellWrites {
-    expected: String
-}
-
-impl fmt::Display for ShellWrites {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "`{}` written to the shell", self.expected)
-    }
-}
-
-impl<'a> ham::Matcher<&'a [u8]> for ShellWrites {
-    fn matches(&self, actual: &[u8])
-        -> ham::MatchResult
-    {
-        let actual = String::from_utf8_lossy(actual);
-        let actual = actual.to_string();
-        ham::expect(actual == self.expected, actual)
-    }
-}
-
-pub fn shell_writes<T: fmt::Display>(string: T) -> ShellWrites {
-    ShellWrites { expected: string.to_string() }
-}
-
 pub trait Tap {
     fn tap<F: FnOnce(&mut Self)>(self, callback: F) -> Self;
 }

tests/testsuite/cargotest/support/mod.rs

@@ -2,8 +2,8 @@ use std::path::PathBuf;
 use std::io::prelude::*;
 use std::fs::{self, File};
 
-use support::paths;
-use support::git::{repo, Repository};
+use cargotest::support::paths;
+use cargotest::support::git::{repo, Repository};
 
 use url::Url;
 

tests/testsuite/cargotest/support/publish.rs

@@ -3,16 +3,16 @@ use std::fs::{self, File};
 use std::io::prelude::*;
 use std::path::{PathBuf, Path};
 
+use cargo::util::Sha256;
 use flate2::Compression;
 use flate2::write::GzEncoder;
 use git2;
 use hex;
 use tar::{Builder, Header};
 use url::Url;
 
-use support::paths;
-use support::git::repo;
-use cargo::util::Sha256;
+use cargotest::support::paths;
+use cargotest::support::git::repo;
 
 pub fn registry_path() -> PathBuf { paths::root().join("registry") }
 pub fn registry() -> Url { Url::from_file_path(&*registry_path()).ok().unwrap() }

tests/testsuite/cargotest/support/registry.rs

@@ -1,10 +1,10 @@
+use cargotest::install::exe;
 use cargotest::is_nightly;
-use cargotest::support::{execs, project};
-use cargotest::support::registry::Package;
-use hamcrest::prelude::*;
 use cargotest::support::paths::CargoPathExt;
-use cargotest::install::exe;
+use cargotest::support::registry::Package;
+use cargotest::support::{execs, project};
 use glob::glob;
+use hamcrest::{assert_that, existing_file, is_not};
 
 const SIMPLE_MANIFEST: &str = r#"
 [package]
@@ -662,9 +662,8 @@ fn check_artifacts()
         is_not(existing_file()));
     assert_that(&p.root().join("target/debug").join(exe("foo")),
         is_not(existing_file()));
-    assert_that(glob(&p.root().join("target/debug/t1-*").to_str().unwrap())
-            .unwrap().count(),
-        is(equal_to(0)));
+    assert_eq!(glob(&p.root().join("target/debug/t1-*").to_str().unwrap())
+            .unwrap().count(), 0);
 
     p.root().join("target").rm_rf();
     assert_that(p.cargo("check").arg("--example").arg("ex1"),
@@ -685,7 +684,6 @@ fn check_artifacts()
         is_not(existing_file()));
     assert_that(&p.root().join("target/debug").join(exe("foo")),
         is_not(existing_file()));
-    assert_that(glob(&p.root().join("target/debug/b1-*").to_str().unwrap())
-            .unwrap().count(),
-        is(equal_to(0)));
+    assert_eq!(glob(&p.root().join("target/debug/b1-*").to_str().unwrap())
+            .unwrap().count(), 0);
 }