feat(assert): Context on status failures

Provide extra context on status failures (success, failure, interrupted,
code).  At the moment, the choice of whether to print stdout or stderr
is context specific.  I have a feeling this won't work as well as I'm
expecting but we'll start here.

Fixes #16

src/assert.rs

@@ -5,6 +5,7 @@ use std::str;
 use predicates;
 use predicates::str::PredicateStrExt;
 
+use cmd::dump_buffer;
 use errors::output_fmt;
 
 /// Assert the state of an `Output`.
@@ -127,7 +128,19 @@ impl Assert {
     /// ```
     pub fn success(self) -> Self {
         if !self.output.status.success() {
-            panic!("Unexpected failure\n{}", self);
+            let actual_code = self.output.status.code().unwrap_or_else(|| {
+                panic!(
+                    "Unexpected failure.\ncode=<interrupted>\nstderr=```{}```\n{}",
+                    dump_buffer(&self.output.stderr),
+                    self
+                )
+            });
+            panic!(
+                "Unexpected failure.\ncode-{}\nstderr=```{}```\n{}",
+                actual_code,
+                dump_buffer(&self.output.stderr),
+                self
+            );
         }
         self
     }
@@ -149,15 +162,23 @@ impl Assert {
     /// ```
     pub fn failure(self) -> Self {
         if self.output.status.success() {
-            panic!("Unexpected success\n{}", self);
+            panic!(
+                "Unexpected success\nstdout=```{}```\n{}",
+                dump_buffer(&self.output.stdout),
+                self
+            );
         }
         self
     }
 
     /// Ensure the command aborted before returning a code.
     pub fn interrupted(self) -> Self {
         if self.output.status.code().is_some() {
-            panic!("Unexpected completion\n{}", self);
+            panic!(
+                "Unexpected completion\nstdout=```{}```\n{}",
+                dump_buffer(&self.output.stdout),
+                self
+            );
         }
         self
     }
@@ -186,12 +207,20 @@ impl Assert {
     }
 
     fn code_impl(self, pred: &predicates::Predicate<i32>) -> Self {
-        let actual_code = self.output
-            .status
-            .code()
-            .unwrap_or_else(|| panic!("Command interrupted\n{}", self));
+        let actual_code = self.output.status.code().unwrap_or_else(|| {
+            panic!(
+                "Command interrupted\nstderr=```{}```\n{}",
+                dump_buffer(&self.output.stderr),
+                self
+            )
+        });
         if !pred.eval(&actual_code) {
-            panic!("Unexpected return code\n{}", self);
+            panic!(
+                "Unexpected return code\nstdout=```{}```\nstderr=```{}```\n{}",
+                dump_buffer(&self.output.stdout),
+                dump_buffer(&self.output.stderr),
+                self
+            );
         }
         self
     }