diff --git a/src/lib.rs b/src/lib.rs
index e7adb5b..6182c68 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -25,7 +25,7 @@ use crate::recorder::{hole_recorder::run_against_tests, Recorder};
 use crate::test_checker::executable_mock;
 use crate::test_spec::yaml::write_yaml;
 use crate::test_spec::Tests;
-use crate::tracer::stdio_redirecting::CaptureStderr;
+use crate::tracer::stdio_redirecting::Capture;
 use crate::tracer::Tracer;
 use std::collections::HashMap;
 use std::path::Path;
@@ -107,6 +107,7 @@ mod run_main {
             &context,
             executable_mock::Config {
                 stdout: b"foo".to_vec(),
+                stderr: vec![],
                 exitcode: 0,
             },
         )?;
@@ -140,7 +141,10 @@ fn print_recorded_test(context: &Context, program: &Path) -> R<ExitCode> {
         program,
         vec![],
         HashMap::new(),
-        CaptureStderr::NoCapture,
+        Capture {
+            stdout: false,
+            stderr: false,
+        },
         Recorder::empty(),
     )?;
     write_yaml(&mut *context.stdout(), &Tests::new(vec![test]).serialize()?)?;
diff --git a/src/recorder/mod.rs b/src/recorder/mod.rs
index 602c397..db7cf88 100644
--- a/src/recorder/mod.rs
+++ b/src/recorder/mod.rs
@@ -65,6 +65,7 @@ impl SyscallMock for Recorder {
             self.test.steps.push_back(Step {
                 command_matcher: CommandMatcher::ExactMatch(command),
                 stdout: vec![],
+                stderr: vec![],
                 exitcode,
             });
         }
diff --git a/src/recorder/result.rs b/src/recorder/result.rs
index 2bdb5f6..7a932b4 100644
--- a/src/recorder/result.rs
+++ b/src/recorder/result.rs
@@ -5,7 +5,7 @@ use crate::test_checker::{
     TestChecker,
 };
 use crate::test_spec::{yaml::write_yaml, Test, Tests};
-use crate::tracer::stdio_redirecting::CaptureStderr;
+use crate::tracer::stdio_redirecting::Capture;
 use crate::tracer::Tracer;
 use crate::{ExitCode, R};
 use std::fs::OpenOptions;
@@ -128,10 +128,9 @@ fn run_against_test(
                 program,
                 test.arguments.clone(),
                 test.env.clone(),
-                if test.stderr.is_some() {
-                    CaptureStderr::Capture
-                } else {
-                    CaptureStderr::NoCapture
+                Capture {
+                    stdout: test.stdout.is_some(),
+                    stderr: test.stderr.is_some(),
                 },
                 $syscall_mock,
             )
diff --git a/src/test_checker/executable_mock.rs b/src/test_checker/executable_mock.rs
index e07b6fe..a7e315c 100644
--- a/src/test_checker/executable_mock.rs
+++ b/src/test_checker/executable_mock.rs
@@ -9,6 +9,7 @@ use std::path::Path;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Config {
     pub stdout: Vec<u8>,
+    pub stderr: Vec<u8>,
     pub exitcode: i32,
 }
 
@@ -35,6 +36,7 @@ pub fn create_mock_executable(context: &Context, config: Config) -> R<Vec<u8>> {
 pub fn run(context: &Context, executable_mock_path: &Path) -> R<ExitCode> {
     let config: Config = deserialize(&skip_hashbang_line(fs::read(executable_mock_path)?))?;
     context.stdout().write_all(&config.stdout)?;
+    context.stderr().write_all(&config.stderr)?;
     Ok(ExitCode(config.exitcode))
 }
 
@@ -60,6 +62,7 @@ mod create_mock_executable {
             &Context::new_mock(),
             Config {
                 stdout: b"foo".to_vec(),
+                stderr: vec![],
                 exitcode: 0,
             },
         )?)?;
@@ -68,12 +71,28 @@ mod create_mock_executable {
         Ok(())
     }
 
+    #[test]
+    fn renders_an_executable_that_outputs_the_given_stderr() -> R<()> {
+        let mock_executable = TempFile::write_temp_script(&create_mock_executable(
+            &Context::new_mock(),
+            Config {
+                stdout: vec![],
+                stderr: b"foo".to_vec(),
+                exitcode: 0,
+            },
+        )?)?;
+        let output = Command::new(mock_executable.path()).output()?;
+        assert_eq!(output.stderr, b"foo");
+        Ok(())
+    }
+
     #[test]
     fn renders_an_executable_that_exits_with_the_given_exitcode() -> R<()> {
         let mock_executable = TempFile::write_temp_script(&create_mock_executable(
             &Context::new_mock(),
             Config {
                 stdout: b"foo".to_vec(),
+                stderr: vec![],
                 exitcode: 42,
             },
         )?)?;
@@ -92,6 +111,7 @@ mod create_mock_executable {
                 &context,
                 Config {
                     stdout: vec![],
+                    stderr: vec![],
                     exitcode: 42,
                 },
             ),
diff --git a/src/test_checker/mod.rs b/src/test_checker/mod.rs
index 08ed203..ff20ea0 100644
--- a/src/test_checker/mod.rs
+++ b/src/test_checker/mod.rs
@@ -4,7 +4,7 @@ pub mod executable_mock;
 use crate::context::Context;
 use crate::test_spec;
 use crate::test_spec::Test;
-use crate::tracer::stdio_redirecting::Redirector;
+use crate::tracer::stdio_redirecting::{Redirect, Redirector};
 use crate::tracer::{tracee_memory, SyscallMock};
 use crate::utils::short_temp_files::ShortTempFile;
 use crate::R;
@@ -39,6 +39,7 @@ impl TestChecker {
     fn allow_failing_scripts_to_continue() -> executable_mock::Config {
         executable_mock::Config {
             stdout: vec![],
+            stderr: vec![],
             exitcode: 0,
         }
     }
@@ -54,6 +55,7 @@ impl TestChecker {
                 }
                 executable_mock::Config {
                     stdout: next_test_step.stdout,
+                    stderr: next_test_step.stderr,
                     exitcode: next_test_step.exitcode,
                 }
             }
@@ -70,6 +72,28 @@ impl TestChecker {
         Ok(path)
     }
 
+    fn check_expected_output_stream(&mut self, redirect: &Redirect, expected: Vec<u8>) -> R<()> {
+        match redirect.captured()? {
+            None => panic!(
+                "scriptkeeper bug: {} expected, but not captured",
+                redirect.stream_type
+            ),
+            Some(captured) => {
+                if captured != expected {
+                    self.register_error(format!(
+                        "  expected output to {}: {:?}\
+                         \n  received output to {}: {:?}\n",
+                        redirect.stream_type,
+                        String::from_utf8_lossy(&expected).as_ref(),
+                        redirect.stream_type,
+                        String::from_utf8_lossy(&captured).as_ref(),
+                    ));
+                }
+            }
+        }
+        Ok(())
+    }
+
     fn register_step_error(&mut self, expected: &str, received: &str) {
         self.register_error(format!(
             "  expected: {}\n  received: {}\n",
@@ -163,20 +187,11 @@ impl SyscallMock for TestChecker {
                 &format!("<exitcode {}>", exitcode),
             );
         }
+        if let Some(expected_stdout) = &self.test.stdout {
+            self.check_expected_output_stream(&redirector.stdout, expected_stdout.clone())?;
+        }
         if let Some(expected_stderr) = &self.test.stderr {
-            match redirector.stderr.captured()? {
-                None => panic!("scriptkeeper bug: stderr expected, but not captured"),
-                Some(captured_stderr) => {
-                    if &captured_stderr != expected_stderr {
-                        self.register_error(format!(
-                            "  expected output to stderr: {:?}\
-                             \n  received output to stderr: {:?}\n",
-                            String::from_utf8_lossy(&expected_stderr).as_ref(),
-                            String::from_utf8_lossy(&captured_stderr).as_ref(),
-                        ));
-                    }
-                }
-            }
+            self.check_expected_output_stream(&redirector.stderr, expected_stderr.clone())?;
         }
         Ok(self.result)
     }
diff --git a/src/test_spec/mod.rs b/src/test_spec/mod.rs
index 9f9e13f..425ad46 100644
--- a/src/test_spec/mod.rs
+++ b/src/test_spec/mod.rs
@@ -24,6 +24,7 @@ use yaml_rust::{yaml::Hash, Yaml, YamlLoader};
 pub struct Step {
     pub command_matcher: CommandMatcher,
     pub stdout: Vec<u8>,
+    pub stderr: Vec<u8>,
     pub exitcode: i32,
 }
 
@@ -32,6 +33,7 @@ impl Step {
         Step {
             command_matcher,
             stdout: vec![],
+            stderr: vec![],
             exitcode: 0,
         }
     }
@@ -49,7 +51,14 @@ impl Step {
 
     fn add_stdout(&mut self, object: &Hash) -> R<()> {
         if let Ok(stdout) = object.expect_field("stdout") {
-            self.stdout = stdout.expect_str()?.as_bytes().to_vec();
+            self.stdout = stdout.expect_bytes()?;
+        }
+        Ok(())
+    }
+
+    fn add_stderr(&mut self, object: &Hash) -> R<()> {
+        if let Ok(stderr) = object.expect_field("stderr") {
+            self.stderr = stderr.expect_bytes()?;
         }
         Ok(())
     }
@@ -58,7 +67,10 @@ impl Step {
         match yaml {
             Yaml::String(string) => Step::from_string(string),
             Yaml::Hash(object) => {
-                check_keys(&["command", "stdout", "exitcode", "regex"], object)?;
+                check_keys(
+                    &["command", "stdout", "stderr", "exitcode", "regex"],
+                    object,
+                )?;
                 let mut step = match (object.expect_field("command"), object.expect_field("regex"))
                 {
                     (Ok(command_field), Err(_)) => Step::from_string(command_field.expect_str()?)?,
@@ -68,6 +80,7 @@ impl Step {
                     _ => Err("please provide either a 'command' or 'regex' field but not both")?,
                 };
                 step.add_stdout(object)?;
+                step.add_stderr(object)?;
                 step.add_exitcode(object)?;
                 Ok(step)
             }
@@ -169,6 +182,15 @@ mod parse_step {
         Ok(())
     }
 
+    #[test]
+    fn allows_to_specify_stderr() -> R<()> {
+        assert_eq!(
+            test_parse_step(r#"{command: "foo", stderr: "bar"}"#)?.stderr,
+            b"bar".to_vec(),
+        );
+        Ok(())
+    }
+
     mod exitcode {
         use super::*;
 
@@ -196,6 +218,7 @@ pub struct Test {
     pub arguments: Vec<String>,
     pub env: HashMap<String, String>,
     pub cwd: Option<PathBuf>,
+    pub stdout: Option<Vec<u8>>,
     pub stderr: Option<Vec<u8>>,
     pub exitcode: Option<i32>,
     pub mocked_files: Vec<PathBuf>,
@@ -214,9 +237,10 @@ impl Test {
             arguments: vec![],
             env: HashMap::new(),
             cwd: None,
+            stdout: None,
+            stderr: None,
             exitcode: None,
             mocked_files: vec![],
-            stderr: None,
         }
     }
 
@@ -281,9 +305,16 @@ impl Test {
         Ok(())
     }
 
+    fn add_stdout(&mut self, object: &Hash) -> R<()> {
+        if let Ok(stdout) = object.expect_field("stdout") {
+            self.stdout = Some(stdout.expect_bytes()?);
+        }
+        Ok(())
+    }
+
     fn add_stderr(&mut self, object: &Hash) -> R<()> {
         if let Ok(stderr) = object.expect_field("stderr") {
-            self.stderr = Some(stderr.expect_str()?.as_bytes().to_vec());
+            self.stderr = Some(stderr.expect_bytes()?);
         }
         Ok(())
     }
@@ -312,6 +343,7 @@ impl Test {
                 "arguments",
                 "env",
                 "exitcode",
+                "stdout",
                 "stderr",
                 "cwd",
             ],
@@ -321,6 +353,7 @@ impl Test {
         test.add_arguments(&object)?;
         test.add_env(&object)?;
         test.add_cwd(&object)?;
+        test.add_stdout(&object)?;
         test.add_stderr(&object)?;
         test.add_exitcode(&object)?;
         test.add_mocked_files(&object)?;
@@ -575,7 +608,7 @@ mod load {
                      unexpected field 'foo', \
                      possible values: \
                      'steps', 'mockedFiles', 'arguments', 'env', \
-                     'exitcode', 'stderr', 'cwd'",
+                     'exitcode', 'stdout', 'stderr', 'cwd'",
                     path_to_string(&tempfile.path())?
                 )
             );
@@ -598,7 +631,7 @@ mod load {
                 format!(
                     "error in {}.test.yaml: \
                      unexpected field 'foo', \
-                     possible values: 'command', 'stdout', 'exitcode', 'regex'",
+                     possible values: 'command', 'stdout', 'stderr', 'exitcode', 'regex'",
                     path_to_string(&tempfile.path())?
                 )
             );
@@ -995,6 +1028,41 @@ mod load {
         Ok(())
     }
 
+    mod expected_stdout {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        #[test]
+        fn allows_to_specify_the_expected_stdout() -> R<()> {
+            assert_eq!(
+                test_parse_one(
+                    r"
+                        |- steps: []
+                        |  stdout: foo
+                    "
+                )?
+                .stdout
+                .map(|s| String::from_utf8(s).unwrap()),
+                Some("foo".to_string())
+            );
+            Ok(())
+        }
+
+        #[test]
+        fn none_is_the_default() -> R<()> {
+            assert_eq!(
+                test_parse_one(
+                    r"
+                        |- steps: []
+                    "
+                )?
+                .stdout,
+                None
+            );
+            Ok(())
+        }
+    }
+
     mod expected_stderr {
         use super::*;
         use pretty_assertions::assert_eq;
@@ -1213,6 +1281,7 @@ mod serialize {
         let test = Test::new(vec![Step {
             command_matcher: CommandMatcher::ExactMatch(Command::new("cp")?),
             stdout: vec![],
+            stderr: vec![],
             exitcode: 42,
         }]);
         roundtrip(Tests::new(vec![test]))
diff --git a/src/test_spec/yaml.rs b/src/test_spec/yaml.rs
index 0e77bc6..0fe698f 100644
--- a/src/test_spec/yaml.rs
+++ b/src/test_spec/yaml.rs
@@ -6,6 +6,8 @@ use std::io::Cursor;
 use yaml_rust::{yaml::Hash, Yaml, YamlEmitter};
 
 pub trait YamlExt {
+    fn expect_bytes(&self) -> R<Vec<u8>>;
+
     fn expect_str(&self) -> R<&str>;
 
     fn expect_array(&self) -> R<&Vec<Yaml>>;
@@ -16,6 +18,11 @@ pub trait YamlExt {
 }
 
 impl YamlExt for Yaml {
+    fn expect_bytes(&self) -> R<Vec<u8>> {
+        let str = self.expect_str()?;
+        Ok(str.as_bytes().to_vec())
+    }
+
     fn expect_str(&self) -> R<&str> {
         Ok(self
             .as_str()
diff --git a/src/tracer/mod.rs b/src/tracer/mod.rs
index 08eb224..0ab8e28 100644
--- a/src/tracer/mod.rs
+++ b/src/tracer/mod.rs
@@ -25,7 +25,7 @@ use std::os::unix::ffi::OsStringExt;
 use std::panic;
 use std::path::{Path, PathBuf};
 use std::str;
-use stdio_redirecting::{CaptureStderr, Redirector};
+use stdio_redirecting::{Capture, Redirector};
 use syscall::Syscall;
 use tempdir::TempDir;
 
@@ -147,10 +147,10 @@ impl Tracer {
         program: &Path,
         args: Vec<String>,
         env: HashMap<String, String>,
-        capture_stderr: CaptureStderr,
+        capture: Capture,
         mut syscall_mock: impl SyscallMock<Result = MockResult>,
     ) -> R<MockResult> {
-        let redirector = Redirector::new(context, capture_stderr)?;
+        let redirector = Redirector::new(context, capture)?;
         fork_with_child_errors(
             || {
                 redirector.child_redirect_streams()?;
diff --git a/src/tracer/stdio_redirecting.rs b/src/tracer/stdio_redirecting.rs
index 6004e64..aee75f8 100644
--- a/src/tracer/stdio_redirecting.rs
+++ b/src/tracer/stdio_redirecting.rs
@@ -2,6 +2,7 @@ use crate::context::Context;
 use crate::R;
 use libc::c_int;
 use nix::unistd::{close, dup2, pipe, read};
+use std::fmt;
 use std::io::{Cursor, Write};
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -9,23 +10,20 @@ use std::thread;
 type RawFd = c_int;
 
 pub struct Redirector {
-    stdout: Redirect,
+    pub stdout: Redirect,
     pub stderr: Redirect,
 }
 
-pub enum CaptureStderr {
-    Capture,
-    NoCapture,
+pub struct Capture {
+    pub stdout: bool,
+    pub stderr: bool,
 }
 
 impl Redirector {
-    pub fn new(context: &Context, capture_stderr: CaptureStderr) -> R<Redirector> {
+    pub fn new(context: &Context, capture: Capture) -> R<Redirector> {
         Ok(Redirector {
-            stdout: Redirect::new(context, StreamType::Stdout)?,
-            stderr: match capture_stderr {
-                CaptureStderr::Capture => Redirect::new_capturing(context, StreamType::Stderr)?,
-                CaptureStderr::NoCapture => Redirect::new(context, StreamType::Stderr)?,
-            },
+            stdout: Redirect::new(context, StreamType::Stdout, capture.stdout)?,
+            stderr: Redirect::new(context, StreamType::Stderr, capture.stderr)?,
         })
     }
 
@@ -47,13 +45,22 @@ impl Redirector {
 }
 
 #[derive(Clone, Copy)]
-enum StreamType {
+pub enum StreamType {
     Stdout,
     Stderr,
 }
 
+impl fmt::Display for StreamType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            StreamType::Stdout => write!(f, "stdout"),
+            StreamType::Stderr => write!(f, "stderr"),
+        }
+    }
+}
+
 pub struct Redirect {
-    stream_type: StreamType,
+    pub stream_type: StreamType,
     context: Context,
     read_end: RawFd,
     write_end: RawFd,
@@ -61,30 +68,18 @@ pub struct Redirect {
 }
 
 impl Redirect {
-    fn new(context: &Context, stream_type: StreamType) -> R<Redirect> {
-        Redirect::new_internal(context, stream_type, None)
-    }
-
-    fn new_capturing(context: &Context, stream_type: StreamType) -> R<Redirect> {
-        Redirect::new_internal(
-            context,
-            stream_type,
-            Some(Arc::new(Mutex::new(Cursor::new(vec![])))),
-        )
-    }
-
-    fn new_internal(
-        context: &Context,
-        stream_type: StreamType,
-        captured: Option<Arc<Mutex<Cursor<Vec<u8>>>>>,
-    ) -> R<Redirect> {
+    fn new(context: &Context, stream_type: StreamType, capture: bool) -> R<Redirect> {
         let (read_end, write_end) = pipe()?;
         Ok(Redirect {
             stream_type,
             context: context.clone(),
             read_end,
             write_end,
-            captured,
+            captured: if capture {
+                Some(Arc::new(Mutex::new(Cursor::new(vec![]))))
+            } else {
+                None
+            },
         })
     }
 
diff --git a/tests/files.rs b/tests/files.rs
index cfc1956..00b708e 100644
--- a/tests/files.rs
+++ b/tests/files.rs
@@ -9,7 +9,7 @@
 mod utils;
 
 use scriptkeeper::R;
-use utils::test_run;
+use utils::{test_run, Expect};
 
 #[test]
 fn allows_to_mock_files_existence() -> R<()> {
@@ -27,7 +27,7 @@ fn allows_to_mock_files_existence() -> R<()> {
             |    mockedFiles:
             |      - /foo
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -48,7 +48,7 @@ fn allows_to_mock_directory_existence() -> R<()> {
             |    mockedFiles:
             |      - /foo/
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -66,7 +66,7 @@ fn does_not_mock_existence_of_unspecified_files() -> R<()> {
             |tests:
             |  - steps: []
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
diff --git a/tests/path.rs b/tests/path.rs
index 9ab193a..7b2340a 100644
--- a/tests/path.rs
+++ b/tests/path.rs
@@ -9,7 +9,7 @@ mod utils;
 
 use scriptkeeper::R;
 use test_utils::trim_margin;
-use utils::test_run;
+use utils::{test_run, Expect};
 
 #[test]
 fn looks_up_step_executable_in_path() -> R<()> {
@@ -22,7 +22,7 @@ fn looks_up_step_executable_in_path() -> R<()> {
             |steps:
             |  - cp
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -40,7 +40,7 @@ fn looks_up_unmocked_command_executable_in_path() -> R<()> {
             |unmockedCommands:
             |  - ls
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -56,7 +56,7 @@ fn shortens_received_executable_to_file_name_when_reporting_step_error() -> R<()
             |steps:
             |  - cp
         ",
-        Err(&trim_margin(
+        Expect::err(&trim_margin(
             "
                 |error:
                 |  expected: cp
@@ -78,7 +78,7 @@ fn runs_step_executable_that_is_not_in_path() -> R<()> {
             |steps:
             |  - /not/in/path
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
diff --git a/tests/run.rs b/tests/run.rs
index b97dc0c..49ebef9 100644
--- a/tests/run.rs
+++ b/tests/run.rs
@@ -14,7 +14,7 @@ use std::env;
 use std::fs;
 use std::path::PathBuf;
 use test_utils::{assert_error, trim_margin, TempFile};
-use utils::{prepare_script, test_run, test_run_with_tempfile};
+use utils::{prepare_script, test_run, test_run_with_tempfile, Expect};
 
 #[test]
 fn simple() -> R<()> {
@@ -27,7 +27,7 @@ fn simple() -> R<()> {
             |steps:
             |  - cp
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -99,7 +99,7 @@ fn can_specify_interpreter() -> R<()> {
             |    - "true"
             |interpreter: /usr/bin/ruby
         "#,
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -116,7 +116,7 @@ fn allows_to_match_command_with_regex() -> R<()> {
             |  - steps:
             |    - regex: cp \d
         "#,
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -182,7 +182,7 @@ fn multiple() -> R<()> {
             |  - cp
             |  - ls
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -198,7 +198,7 @@ fn failing() -> R<()> {
             |steps:
             |  - cp
         ",
-        Err(&trim_margin(
+        Expect::err(&trim_margin(
             "
                 |error:
                 |  expected: cp
@@ -222,7 +222,7 @@ fn failing_later() -> R<()> {
             |  - ls
             |  - cp
         ",
-        Err(&trim_margin(
+        Expect::err(&trim_margin(
             "
                 |error:
                 |  expected: cp
@@ -368,7 +368,7 @@ mod arguments {
                 |steps:
                 |  - cp foo
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -384,7 +384,7 @@ mod arguments {
                 |steps:
                 |  - cp foo
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error:
                     |  expected: cp foo
@@ -406,7 +406,7 @@ mod arguments {
                 |steps:
                 |  - cp "foo bar"
             "#,
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -422,7 +422,7 @@ mod arguments {
                 |steps:
                 |  - cp "foo bar"
             "#,
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 r#"
                     |error:
                     |  expected: cp "foo bar"
@@ -447,7 +447,7 @@ fn reports_the_first_error() -> R<()> {
             |  - cp first
             |  - cp second
         ",
-        Err(&trim_margin(
+        Expect::err(&trim_margin(
             "
                 |error:
                 |  expected: cp first
@@ -473,7 +473,7 @@ mod mismatch_in_number_of_commands {
                 |  - ls
                 |  - cp
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error:
                     |  expected: cp
@@ -496,7 +496,7 @@ mod mismatch_in_number_of_commands {
                 |steps:
                 |  - ls
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error:
                     |  expected: <script termination>
@@ -508,67 +508,6 @@ mod mismatch_in_number_of_commands {
     }
 }
 
-mod stdout {
-    use super::*;
-
-    #[test]
-    fn mock_stdout() -> R<()> {
-        test_run(
-            r"
-                |#!/usr/bin/env bash
-                |output=$(cp)
-                |cp $output
-            ",
-            r"
-                |steps:
-                |  - command: cp
-                |    stdout: test_output
-                |  - cp test_output
-            ",
-            Ok(()),
-        )?;
-        Ok(())
-    }
-
-    #[test]
-    fn mock_stdout_with_special_characters() -> R<()> {
-        test_run(
-            r"
-                |#!/usr/bin/env bash
-                |output=$(cp)
-                |cp $output
-            ",
-            r#"
-                |steps:
-                |  - command: cp
-                |    stdout: 'foo"'
-                |  - 'cp foo\"'
-            "#,
-            Ok(()),
-        )?;
-        Ok(())
-    }
-
-    #[test]
-    fn mock_stdout_with_newlines() -> R<()> {
-        test_run(
-            r#"
-                |#!/usr/bin/env bash
-                |output=$(cp)
-                |cp "$output"
-            "#,
-            r#"
-                |steps:
-                |  - command: cp
-                |    stdout: "foo\nbar"
-                |  - 'cp foo\nbar'
-            "#,
-            Ok(()),
-        )?;
-        Ok(())
-    }
-}
-
 #[test]
 fn pass_arguments_into_tested_script() -> R<()> {
     test_run(
@@ -581,7 +520,7 @@ fn pass_arguments_into_tested_script() -> R<()> {
             |steps:
             |  - cp foo
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -604,7 +543,7 @@ mod multiple_tests {
                 |  steps:
                 |    - cp bar
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -622,7 +561,7 @@ mod multiple_tests {
                 |- steps:
                 |    - cp
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error in test 1:
                     |  expected: cp
@@ -649,7 +588,7 @@ mod multiple_tests {
                 |- steps:
                 |    - cp
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |test 1:
                     |  Tests passed.
@@ -679,7 +618,7 @@ mod environment {
                 |steps:
                 |  - cp test-env-var
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -696,7 +635,7 @@ mod environment {
                 |steps:
                 |  - cp
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -713,7 +652,7 @@ fn detects_running_commands_from_ruby_scripts() -> R<()> {
             |steps:
             |  - ls
         ",
-        Ok(()),
+        Expect::ok(),
     )?;
     Ok(())
 }
@@ -736,7 +675,7 @@ mod mocked_exitcodes {
                 |    exitcode: 1
                 |  - ls
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -756,7 +695,7 @@ mod mocked_exitcodes {
                 |    exitcode: 0
                 |  - ls
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -775,7 +714,7 @@ mod mocked_exitcodes {
                 |  - grep foo
                 |  - ls
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -794,7 +733,7 @@ mod mocked_exitcodes {
                 |    exitcode: 42
                 |  - ls 42
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -815,7 +754,7 @@ mod working_directory {
                 |steps:
                 |  - ls /foo/file
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -832,7 +771,7 @@ mod working_directory {
                 |steps:
                 |  - ls /foo/bar/baz/foo/bar/baz/foo/bar/baz/foo/file
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -852,7 +791,7 @@ mod working_directory {
                 ",
                 path_to_string(&cwd)?
             ),
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -871,7 +810,7 @@ mod expected_exitcode {
             r"
                 |steps: []
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error:
                     |  expected: <exitcode 0>
@@ -893,7 +832,7 @@ mod expected_exitcode {
                 |steps: []
                 |exitcode: 42
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -909,7 +848,7 @@ mod expected_exitcode {
                 |steps: []
                 |exitcode: 42
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                 |error:
                 |  expected: <exitcode 42>
@@ -938,7 +877,7 @@ mod unmocked_commands {
                 |unmockedCommands:
                 |  - dirname
             ",
-            Ok(()),
+            Expect::ok(),
         )?;
         Ok(())
     }
@@ -958,7 +897,7 @@ mod unmocked_commands {
                 |unmockedCommands:
                 |  - dirname
             ",
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 "
                     |error:
                     |  expected: dirname dir/file
diff --git a/tests/stdio.rs b/tests/stdio.rs
index 3cafb1d..a7ba848 100644
--- a/tests/stdio.rs
+++ b/tests/stdio.rs
@@ -8,39 +8,29 @@
 #[path = "./utils.rs"]
 mod utils;
 
-use scriptkeeper::{context::Context, R};
-use test_utils::{trim_margin, TempFile};
-use utils::{test_run, test_run_with_context, test_run_with_tempfile};
+use scriptkeeper::R;
+use test_utils::trim_margin;
+use utils::{test_run, Expect};
 
 #[test]
 fn relays_stdout_from_the_tested_script_to_the_user() -> R<()> {
-    let context = Context::new_mock();
-    let script = TempFile::write_temp_script(
-        trim_margin(
-            r"
-                |#!/usr/bin/env bash
-                |echo foo
-            ",
-        )?
-        .as_bytes(),
-    )?;
-    test_run_with_tempfile(
-        &context,
-        &script,
+    test_run(
+        r"
+            |#!/usr/bin/env bash
+            |echo foo
+        ",
         r"
             |tests:
             |  - steps: []
         ",
+        Expect::ok().stdout("foo\nAll tests passed.\n"),
     )?;
-    assert_eq!(context.get_captured_stdout(), "foo\nAll tests passed.\n");
     Ok(())
 }
 
 #[test]
 fn relays_stderr_from_the_tested_script_to_the_user() -> R<()> {
-    let context = Context::new_mock();
-    test_run_with_context(
-        &context,
+    test_run(
         r"
             |#!/usr/bin/env bash
             |echo foo 1>&2
@@ -49,12 +39,216 @@ fn relays_stderr_from_the_tested_script_to_the_user() -> R<()> {
             |tests:
             |  - steps: []
         ",
-        Ok(()),
+        Expect::ok().stderr("foo\n"),
     )?;
-    assert_eq!(context.get_captured_stderr(), "foo\n");
     Ok(())
 }
 
+mod mocked_stdout {
+    use super::*;
+
+    #[test]
+    fn mock_stdout() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |output=$(cp)
+                |cp $output
+            ",
+            r"
+                |steps:
+                |  - command: cp
+                |    stdout: test_output
+                |  - cp test_output
+            ",
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn mock_stdout_with_special_characters() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |output=$(cp)
+                |cp $output
+            ",
+            r#"
+                |steps:
+                |  - command: cp
+                |    stdout: 'foo"'
+                |  - 'cp foo\"'
+            "#,
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn mock_stdout_with_newlines() -> R<()> {
+        test_run(
+            r#"
+                |#!/usr/bin/env bash
+                |output=$(cp)
+                |cp "$output"
+            "#,
+            r#"
+                |steps:
+                |  - command: cp
+                |    stdout: "foo\nbar"
+                |  - 'cp foo\nbar'
+            "#,
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+}
+
+mod expected_stdout {
+    use super::*;
+
+    #[test]
+    fn fails_when_not_matching() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |echo bar
+            ",
+            r#"
+                |tests:
+                |  - steps: []
+                |    stdout: "foo\n"
+            "#,
+            Expect::err(&trim_margin(
+                r#"
+                    |bar
+                    |error:
+                    |  expected output to stdout: "foo\n"
+                    |  received output to stdout: "bar\n"
+                "#,
+            )?),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn passes_when_matching() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |echo foo
+            ",
+            r#"
+                |tests:
+                |  - steps: []
+                |    stdout: "foo\n"
+            "#,
+            Expect::ok().stdout("foo\nAll tests passed.\n"),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn fails_when_expecting_stdout_but_none_printed() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+            ",
+            r#"
+                |tests:
+                |  - steps: []
+                |    stdout: "foo\n"
+            "#,
+            Expect::err(&trim_margin(
+                r#"
+                    |error:
+                    |  expected output to stdout: "foo\n"
+                    |  received output to stdout: ""
+                "#,
+            )?),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn when_not_specified_but_scripts_writes_to_stdout() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |echo foo
+            ",
+            r#"
+                |tests:
+                |  - steps: []
+            "#,
+            Expect::ok().stdout("foo\nAll tests passed.\n"),
+        )?;
+        Ok(())
+    }
+}
+
+mod mocked_stderr {
+    use super::*;
+
+    #[test]
+    fn mock_stderr() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |output=$(date 2>&1)
+                |mkdir $output
+            ",
+            r"
+                |steps:
+                |  - command: date
+                |    stderr: '2019-04-08'
+                |  - mkdir 2019-04-08
+            ",
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn mock_stderr_with_special_characters() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |output=$(cp 2>&1)
+                |cp $output
+            ",
+            r#"
+                |steps:
+                |  - command: cp
+                |    stderr: 'foo"'
+                |  - 'cp foo\"'
+            "#,
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    fn mock_stderr_with_newlines() -> R<()> {
+        test_run(
+            r#"
+                |#!/usr/bin/env bash
+                |output=$(cp 2>&1)
+                |cp "$output"
+            "#,
+            r#"
+                |steps:
+                |  - command: cp
+                |    stderr: "foo\nbar"
+                |  - 'cp foo\nbar'
+            "#,
+            Expect::ok(),
+        )?;
+        Ok(())
+    }
+}
+
 mod expected_stderr {
     use super::*;
 
@@ -70,13 +264,14 @@ mod expected_stderr {
                 |  - steps: []
                 |    stderr: "foo\n"
             "#,
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 r#"
                     |error:
                     |  expected output to stderr: "foo\n"
                     |  received output to stderr: "bar\n"
                 "#,
-            )?),
+            )?)
+            .stderr("bar\n"),
         )?;
         Ok(())
     }
@@ -93,7 +288,7 @@ mod expected_stderr {
                 |  - steps: []
                 |    stderr: "foo\n"
             "#,
-            Ok(()),
+            Expect::ok().stderr("foo\n"),
         )?;
         Ok(())
     }
@@ -109,7 +304,7 @@ mod expected_stderr {
                 |  - steps: []
                 |    stderr: "foo\n"
             "#,
-            Err(&trim_margin(
+            Expect::err(&trim_margin(
                 r#"
                     |error:
                     |  expected output to stderr: "foo\n"
@@ -119,4 +314,20 @@ mod expected_stderr {
         )?;
         Ok(())
     }
+
+    #[test]
+    fn when_not_specified_but_scripts_writes_to_stderr() -> R<()> {
+        test_run(
+            r"
+                |#!/usr/bin/env bash
+                |echo foo 1>&2
+            ",
+            r#"
+                |tests:
+                |  - steps: []
+            "#,
+            Expect::ok().stderr("foo\n"),
+        )?;
+        Ok(())
+    }
 }
diff --git a/tests/utils.rs b/tests/utils.rs
index e6602ae..cd34a83 100644
--- a/tests/utils.rs
+++ b/tests/utils.rs
@@ -14,12 +14,47 @@ use std::path::PathBuf;
 use test_utils::{trim_margin, TempFile};
 use yaml_rust::YamlLoader;
 
-fn compare_results(result: (ExitCode, String), expected: Result<(), &str>) {
-    let expected_output = match expected {
-        Err(expected_output) => (ExitCode(1), expected_output.to_string()),
-        Ok(()) => (ExitCode(0), "All tests passed.\n".to_string()),
-    };
-    assert_eq!(result, expected_output);
+#[derive(Debug, PartialEq)]
+pub struct Expect {
+    expected_exit_code: ExitCode,
+    expected_stdout: String,
+    expected_stderr: String,
+}
+
+impl Expect {
+    pub fn ok() -> Self {
+        Expect {
+            expected_exit_code: ExitCode(0),
+            expected_stdout: "All tests passed.\n".to_string(),
+            expected_stderr: "".to_string(),
+        }
+    }
+
+    pub fn err(expected_output: &str) -> Self {
+        Expect {
+            expected_exit_code: ExitCode(1),
+            expected_stdout: expected_output.to_string(),
+            expected_stderr: "".to_string(),
+        }
+    }
+
+    pub fn stdout(self, expected_output: &str) -> Self {
+        Expect {
+            expected_stdout: expected_output.to_string(),
+            ..self
+        }
+    }
+
+    pub fn stderr(self, expected_output: &str) -> Self {
+        Expect {
+            expected_stderr: expected_output.to_string(),
+            ..self
+        }
+    }
+}
+
+fn compare_results(actual: Expect, expected: Expect) {
+    assert_eq!(actual, expected);
 }
 
 pub fn prepare_script(script_code: &str, tests: &str) -> R<(TempFile, PathBuf)> {
@@ -46,15 +81,22 @@ pub fn test_run_with_context(
     context: &Context,
     script_code: &str,
     tests: &str,
-    expected: Result<(), &str>,
+    expected: Expect,
 ) -> R<()> {
     let script = TempFile::write_temp_script(trim_margin(script_code)?.as_bytes())?;
-    let result = test_run_with_tempfile(context, &script, tests)?;
-    compare_results(result, expected);
+    let (exit_code, stdout) = test_run_with_tempfile(context, &script, tests)?;
+    compare_results(
+        Expect {
+            expected_exit_code: exit_code,
+            expected_stdout: stdout,
+            expected_stderr: context.get_captured_stderr(),
+        },
+        expected,
+    );
     Ok(())
 }
 
-pub fn test_run(script_code: &str, tests: &str, expected: Result<(), &str>) -> R<()> {
+pub fn test_run(script_code: &str, tests: &str, expected: Expect) -> R<()> {
     test_run_with_context(&Context::new_mock(), script_code, tests, expected)
 }