diff --git a/cli/tests/integration/watcher_tests.rs b/cli/tests/integration/watcher_tests.rs
index 872a6b259a..4cccfc83f8 100644
--- a/cli/tests/integration/watcher_tests.rs
+++ b/cli/tests/integration/watcher_tests.rs
@@ -1,10 +1,20 @@
 // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
 
 use flaky_test::flaky_test;
+use std::fs::write;
 use std::io::BufRead;
 use tempfile::TempDir;
 use test_util as util;
 
+macro_rules! assert_contains {
+  ($string:expr, $($test:expr),+) => {
+    let string = $string; // This might be a function call or something
+    if !($(string.contains($test))||+) {
+      panic!("{:?} does not contain any of {:?}", string, [$($test),+]);
+    }
+  }
+}
+
 // Helper function to skip watcher output that contains "Restarting"
 // phrase.
 fn skip_restarting_line(
@@ -18,45 +28,40 @@ fn skip_restarting_line(
   }
 }
 
-/// Helper function to skip watcher output that doesn't contain
-/// "{job_name} finished" phrase.
-fn wait_for_process_finished(
-  job_name: &str,
-  stderr_lines: &mut impl Iterator<Item = String>,
-) {
-  let phrase = format!("{} finished", job_name);
+fn wait_for(s: &str, lines: &mut impl Iterator<Item = String>) {
   loop {
-    let msg = stderr_lines.next().unwrap();
-    if msg.contains(&phrase) {
+    let msg = lines.next().unwrap();
+    if msg.contains(s) {
       break;
     }
   }
 }
 
-/// Helper function to skip watcher output that doesn't contain
-/// "{job_name} failed" phrase.
-fn wait_for_process_failed(
-  job_name: &str,
-  stderr_lines: &mut impl Iterator<Item = String>,
-) {
-  let phrase = format!("{} failed", job_name);
-  loop {
-    let msg = stderr_lines.next().unwrap();
-    if msg.contains(&phrase) {
-      break;
-    }
-  }
+fn check_alive_then_kill(mut child: std::process::Child) {
+  assert!(child.try_wait().unwrap().is_none());
+  child.kill().unwrap();
+}
+
+fn child_lines(
+  child: &mut std::process::Child,
+) -> (impl Iterator<Item = String>, impl Iterator<Item = String>) {
+  let stdout_lines = std::io::BufReader::new(child.stdout.take().unwrap())
+    .lines()
+    .map(|r| r.unwrap());
+  let stderr_lines = std::io::BufReader::new(child.stderr.take().unwrap())
+    .lines()
+    .map(|r| r.unwrap());
+  (stdout_lines, stderr_lines)
 }
 
 #[test]
 fn fmt_watch_test() {
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let fixed = util::testdata_path().join("badly_formatted_fixed.js");
   let badly_formatted_original =
     util::testdata_path().join("badly_formatted.mjs");
   let badly_formatted = t.path().join("badly_formatted.js");
-  std::fs::copy(&badly_formatted_original, &badly_formatted)
-    .expect("Failed to copy file");
+  std::fs::copy(&badly_formatted_original, &badly_formatted).unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -67,10 +72,8 @@ fn fmt_watch_test() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("Failed to spawn script");
-  let stderr = child.stderr.as_mut().unwrap();
-  let stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (_stdout_lines, stderr_lines) = child_lines(&mut child);
 
   // TODO(lucacasonato): remove this timeout. It seems to be needed on Linux.
   std::thread::sleep(std::time::Duration::from_secs(1));
@@ -82,32 +85,25 @@ fn fmt_watch_test() {
   assert_eq!(expected, actual);
 
   // Change content of the file again to be badly formatted
-  std::fs::copy(&badly_formatted_original, &badly_formatted)
-    .expect("Failed to copy file");
+  std::fs::copy(&badly_formatted_original, &badly_formatted).unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
 
   // Check if file has been automatically formatted by watcher
   let expected = std::fs::read_to_string(fixed).unwrap();
   let actual = std::fs::read_to_string(badly_formatted).unwrap();
   assert_eq!(expected, actual);
-
-  // the watcher process is still alive
-  assert!(child.try_wait().unwrap().is_none());
-
-  child.kill().unwrap();
-  drop(t);
+  check_alive_then_kill(child);
 }
 
 #[test]
 fn bundle_js_watch() {
   use std::path::PathBuf;
   // Test strategy extends this of test bundle_js by adding watcher
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let file_to_watch = t.path().join("file_to_watch.js");
-  std::fs::write(&file_to_watch, "console.log('Hello world');")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log('Hello world');").unwrap();
   assert!(file_to_watch.is_file());
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let bundle = t.path().join("mod6.bundle.js");
   let mut deno = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -120,57 +116,41 @@ fn bundle_js_watch() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
+    .unwrap();
 
-  let stderr = deno.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+  let (_stdout_lines, mut stderr_lines) = child_lines(&mut deno);
 
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("file_to_watch.js"));
-  assert!(stderr_lines.next().unwrap().contains("mod6.bundle.js"));
+  assert_contains!(stderr_lines.next().unwrap(), "file_to_watch.js");
+  assert_contains!(stderr_lines.next().unwrap(), "mod6.bundle.js");
   let file = PathBuf::from(&bundle);
   assert!(file.is_file());
-  wait_for_process_finished("Bundle", &mut stderr_lines);
+  wait_for("Bundle finished", &mut stderr_lines);
 
-  std::fs::write(&file_to_watch, "console.log('Hello world2');")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log('Hello world2');").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines
-    .next()
-    .unwrap()
-    .contains("File change detected!"));
-  assert!(stderr_lines.next().unwrap().contains("file_to_watch.js"));
-  assert!(stderr_lines.next().unwrap().contains("mod6.bundle.js"));
+  assert_contains!(stderr_lines.next().unwrap(), "File change detected!");
+  assert_contains!(stderr_lines.next().unwrap(), "file_to_watch.js");
+  assert_contains!(stderr_lines.next().unwrap(), "mod6.bundle.js");
   let file = PathBuf::from(&bundle);
   assert!(file.is_file());
-  wait_for_process_finished("Bundle", &mut stderr_lines);
+  wait_for("Bundle finished", &mut stderr_lines);
 
   // Confirm that the watcher keeps on working even if the file is updated and has invalid syntax
-  std::fs::write(&file_to_watch, "syntax error ^^")
-    .expect("error writing file");
+  write(&file_to_watch, "syntax error ^^").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines
-    .next()
-    .unwrap()
-    .contains("File change detected!"));
-  assert!(stderr_lines.next().unwrap().contains("error: "));
-  wait_for_process_failed("Bundle", &mut stderr_lines);
-
-  // the watcher process is still alive
-  assert!(deno.try_wait().unwrap().is_none());
-
-  deno.kill().unwrap();
-  drop(t);
+  assert_contains!(stderr_lines.next().unwrap(), "File change detected!");
+  assert_contains!(stderr_lines.next().unwrap(), "error: ");
+  wait_for("Bundle failed", &mut stderr_lines);
+  check_alive_then_kill(deno);
 }
 
 /// Confirm that the watcher continues to work even if module resolution fails at the *first* attempt
 #[test]
 fn bundle_watch_not_exit() {
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let file_to_watch = t.path().join("file_to_watch.js");
-  std::fs::write(&file_to_watch, "syntax error ^^")
-    .expect("error writing file");
+  write(&file_to_watch, "syntax error ^^").unwrap();
   let target_file = t.path().join("target.js");
 
   let mut deno = util::deno_cmd()
@@ -184,45 +164,32 @@ fn bundle_watch_not_exit() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
-
-  let stderr = deno.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (_stdout_lines, mut stderr_lines) = child_lines(&mut deno);
 
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("error:"));
-  assert!(stderr_lines.next().unwrap().contains("Bundle failed"));
+  assert_contains!(stderr_lines.next().unwrap(), "error:");
+  assert_contains!(stderr_lines.next().unwrap(), "Bundle failed");
   // the target file hasn't been created yet
   assert!(!target_file.is_file());
 
   // Make sure the watcher actually restarts and works fine with the proper syntax
-  std::fs::write(&file_to_watch, "console.log(42);")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log(42);").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines
-    .next()
-    .unwrap()
-    .contains("File change detected!"));
-  assert!(stderr_lines.next().unwrap().contains("file_to_watch.js"));
-  assert!(stderr_lines.next().unwrap().contains("target.js"));
-  wait_for_process_finished("Bundle", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "File change detected!");
+  assert_contains!(stderr_lines.next().unwrap(), "file_to_watch.js");
+  assert_contains!(stderr_lines.next().unwrap(), "target.js");
+  wait_for("Bundle finished", &mut stderr_lines);
   // bundled file is created
   assert!(target_file.is_file());
-
-  // the watcher process is still alive
-  assert!(deno.try_wait().unwrap().is_none());
-
-  deno.kill().unwrap();
-  drop(t);
+  check_alive_then_kill(deno);
 }
 
 #[flaky_test::flaky_test]
 fn run_watch() {
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let file_to_watch = t.path().join("file_to_watch.js");
-  std::fs::write(&file_to_watch, "console.log('Hello world');")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log('Hello world');").unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -234,99 +201,83 @@ fn run_watch() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
-
-  assert!(stdout_lines.next().unwrap().contains("Hello world"));
-  wait_for_process_finished("Process", &mut stderr_lines);
+  assert_contains!(stdout_lines.next().unwrap(), "Hello world");
+  wait_for("Process finished", &mut stderr_lines);
 
   // TODO(lucacasonato): remove this timeout. It seems to be needed on Linux.
   std::thread::sleep(std::time::Duration::from_secs(1));
 
   // Change content of the file
-  std::fs::write(&file_to_watch, "console.log('Hello world2');")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log('Hello world2');").unwrap();
   // Events from the file watcher is "debounced", so we need to wait for the next execution to start
   std::thread::sleep(std::time::Duration::from_secs(1));
 
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains("Hello world2"));
-  wait_for_process_finished("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), "Hello world2");
+  wait_for("Process finished", &mut stderr_lines);
 
   // Add dependency
   let another_file = t.path().join("another_file.js");
-  std::fs::write(&another_file, "export const foo = 0;")
-    .expect("error writing file");
-  std::fs::write(
+  write(&another_file, "export const foo = 0;").unwrap();
+  write(
     &file_to_watch,
     "import { foo } from './another_file.js'; console.log(foo);",
   )
-  .expect("error writing file");
+  .unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains('0'));
-  wait_for_process_finished("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), '0');
+  wait_for("Process finished", &mut stderr_lines);
 
   // Confirm that restarting occurs when a new file is updated
-  std::fs::write(&another_file, "export const foo = 42;")
-    .expect("error writing file");
+  write(&another_file, "export const foo = 42;").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains("42"));
-  wait_for_process_finished("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), "42");
+  wait_for("Process finished", &mut stderr_lines);
 
   // Confirm that the watcher keeps on working even if the file is updated and has invalid syntax
-  std::fs::write(&file_to_watch, "syntax error ^^")
-    .expect("error writing file");
+  write(&file_to_watch, "syntax error ^^").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stderr_lines.next().unwrap().contains("error:"));
-  wait_for_process_failed("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stderr_lines.next().unwrap(), "error:");
+  wait_for("Process failed", &mut stderr_lines);
 
   // Then restore the file
-  std::fs::write(
+  write(
     &file_to_watch,
     "import { foo } from './another_file.js'; console.log(foo);",
   )
-  .expect("error writing file");
+  .unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains("42"));
-  wait_for_process_finished("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), "42");
+  wait_for("Process finished", &mut stderr_lines);
 
   // Update the content of the imported file with invalid syntax
-  std::fs::write(&another_file, "syntax error ^^").expect("error writing file");
+  write(&another_file, "syntax error ^^").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stderr_lines.next().unwrap().contains("error:"));
-  wait_for_process_failed("Process", &mut stderr_lines);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stderr_lines.next().unwrap(), "error:");
+  wait_for("Process failed", &mut stderr_lines);
 
   // Modify the imported file and make sure that restarting occurs
-  std::fs::write(&another_file, "export const foo = 'modified!';")
-    .expect("error writing file");
+  write(&another_file, "export const foo = 'modified!';").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains("modified!"));
-  wait_for_process_finished("Process", &mut stderr_lines);
-
-  // the watcher process is still alive
-  assert!(child.try_wait().unwrap().is_none());
-
-  child.kill().unwrap();
-  drop(t);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), "modified!");
+  wait_for("Process finished", &mut stderr_lines);
+  check_alive_then_kill(child);
 }
 
 #[test]
 fn run_watch_load_unload_events() {
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let file_to_watch = t.path().join("file_to_watch.js");
-  std::fs::write(
+  write(
     &file_to_watch,
     r#"
       setInterval(() => {}, 0);
@@ -339,7 +290,7 @@ fn run_watch_load_unload_events() {
       });
     "#,
   )
-  .expect("error writing file");
+  .unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -351,20 +302,14 @@ fn run_watch_load_unload_events() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
-
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
   // Wait for the first load event to fire
-  assert!(stdout_lines.next().unwrap().contains("load"));
+  assert_contains!(stdout_lines.next().unwrap(), "load");
 
   // Change content of the file, this time without an interval to keep it alive.
-  std::fs::write(
+  write(
     &file_to_watch,
     r#"
       window.addEventListener("load", () => {
@@ -376,34 +321,31 @@ fn run_watch_load_unload_events() {
       });
     "#,
   )
-  .expect("error writing file");
+  .unwrap();
 
   // Events from the file watcher is "debounced", so we need to wait for the next execution to start
   std::thread::sleep(std::time::Duration::from_secs(1));
 
   // Wait for the restart
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
 
   // Confirm that the unload event was dispatched from the first run
-  assert!(stdout_lines.next().unwrap().contains("unload"));
+  assert_contains!(stdout_lines.next().unwrap(), "unload");
 
   // Followed by the load event of the second run
-  assert!(stdout_lines.next().unwrap().contains("load"));
+  assert_contains!(stdout_lines.next().unwrap(), "load");
 
   // Which is then unloaded as there is nothing keeping it alive.
-  assert!(stdout_lines.next().unwrap().contains("unload"));
-
-  child.kill().unwrap();
-  drop(t);
+  assert_contains!(stdout_lines.next().unwrap(), "unload");
+  check_alive_then_kill(child);
 }
 
 /// Confirm that the watcher continues to work even if module resolution fails at the *first* attempt
 #[test]
 fn run_watch_not_exit() {
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
   let file_to_watch = t.path().join("file_to_watch.js");
-  std::fs::write(&file_to_watch, "syntax error ^^")
-    .expect("error writing file");
+  write(&file_to_watch, "syntax error ^^").unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -415,32 +357,20 @@ fn run_watch_not_exit() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
-
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("error:"));
-  assert!(stderr_lines.next().unwrap().contains("Process failed"));
+  assert_contains!(stderr_lines.next().unwrap(), "error:");
+  assert_contains!(stderr_lines.next().unwrap(), "Process failed");
 
   // Make sure the watcher actually restarts and works fine with the proper syntax
-  std::fs::write(&file_to_watch, "console.log(42);")
-    .expect("error writing file");
+  write(&file_to_watch, "console.log(42);").unwrap();
   std::thread::sleep(std::time::Duration::from_secs(1));
-  assert!(stderr_lines.next().unwrap().contains("Restarting"));
-  assert!(stdout_lines.next().unwrap().contains("42"));
-  wait_for_process_finished("Process", &mut stderr_lines);
-
-  // the watcher process is still alive
-  assert!(child.try_wait().unwrap().is_none());
-
-  child.kill().unwrap();
-  drop(t);
+  assert_contains!(stderr_lines.next().unwrap(), "Restarting");
+  assert_contains!(stdout_lines.next().unwrap(), "42");
+  wait_for("Process finished", &mut stderr_lines);
+  check_alive_then_kill(child);
 }
 
 #[test]
@@ -451,16 +381,15 @@ fn run_watch_with_import_map_and_relative_paths() {
     filecontent: &'static str,
   ) -> std::path::PathBuf {
     let absolute_path = directory.path().join(filename);
-    std::fs::write(&absolute_path, filecontent).expect("error writing file");
+    write(&absolute_path, filecontent).unwrap();
     let relative_path = absolute_path
       .strip_prefix(util::testdata_path())
-      .expect("unable to create relative temporary file")
+      .unwrap()
       .to_owned();
     assert!(relative_path.is_relative());
     relative_path
   }
-  let temp_directory =
-    TempDir::new_in(util::testdata_path()).expect("tempdir fail");
+  let temp_directory = TempDir::new_in(util::testdata_path()).unwrap();
   let file_to_watch = create_relative_tmp_file(
     &temp_directory,
     "file_to_watch.js",
@@ -484,37 +413,18 @@ fn run_watch_with_import_map_and_relative_paths() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+  assert_contains!(stderr_lines.next().unwrap(), "Process finished");
+  assert_contains!(stdout_lines.next().unwrap(), "Hello world");
 
-  assert!(stderr_lines.next().unwrap().contains("Process finished"));
-  assert!(stdout_lines.next().unwrap().contains("Hello world"));
-
-  child.kill().unwrap();
-
-  drop(file_to_watch);
-  drop(import_map_path);
-  temp_directory.close().unwrap();
+  check_alive_then_kill(child);
 }
 
 #[flaky_test]
 fn test_watch() {
-  macro_rules! assert_contains {
-        ($string:expr, $($test:expr),+) => {
-          let string = $string; // This might be a function call or something
-          if !($(string.contains($test))||+) {
-            panic!("{:?} does not contain any of {:?}", string, [$($test),+]);
-          }
-        }
-      }
-
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -527,40 +437,32 @@ fn test_watch() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
-
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
   assert_eq!(stdout_lines.next().unwrap(), "");
   assert_contains!(
     stdout_lines.next().unwrap(),
     "0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out"
   );
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   let foo_file = t.path().join("foo.js");
   let bar_file = t.path().join("bar.js");
   let foo_test = t.path().join("foo_test.js");
   let bar_test = t.path().join("bar_test.js");
-  std::fs::write(&foo_file, "export default function foo() { 1 + 1 }")
-    .expect("error writing file");
-  std::fs::write(&bar_file, "export default function bar() { 2 + 2 }")
-    .expect("error writing file");
-  std::fs::write(
+  write(&foo_file, "export default function foo() { 1 + 1 }").unwrap();
+  write(&bar_file, "export default function bar() { 2 + 2 }").unwrap();
+  write(
     &foo_test,
     "import foo from './foo.js'; Deno.test('foo', foo);",
   )
-  .expect("error writing file");
-  std::fs::write(
+  .unwrap();
+  write(
     &bar_test,
     "import bar from './bar.js'; Deno.test('bar', bar);",
   )
-  .expect("error writing file");
+  .unwrap();
 
   assert_eq!(stdout_lines.next().unwrap(), "");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
@@ -570,14 +472,14 @@ fn test_watch() {
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Change content of the file
-  std::fs::write(
+  write(
     &foo_test,
     "import foo from './foo.js'; Deno.test('foobar', foo);",
   )
-  .expect("error writing file");
+  .unwrap();
 
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
@@ -585,23 +487,22 @@ fn test_watch() {
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Add test
   let another_test = t.path().join("new_test.js");
-  std::fs::write(&another_test, "Deno.test('another one', () => 3 + 3)")
-    .expect("error writing file");
+  write(&another_test, "Deno.test('another one', () => 3 + 3)").unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
   assert_contains!(stdout_lines.next().unwrap(), "another one");
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Confirm that restarting occurs when a new file is updated
-  std::fs::write(&another_test, "Deno.test('another one', () => 3 + 3); Deno.test('another another one', () => 4 + 4)")
-    .expect("error writing file");
+  write(&another_test, "Deno.test('another one', () => 3 + 3); Deno.test('another another one', () => 4 + 4)")
+    .unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 2 tests");
   assert_contains!(stdout_lines.next().unwrap(), "another one");
@@ -609,81 +510,65 @@ fn test_watch() {
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Confirm that the watcher keeps on working even if the file is updated and has invalid syntax
-  std::fs::write(&another_test, "syntax error ^^").expect("error writing file");
+  write(&another_test, "syntax error ^^").unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stderr_lines.next().unwrap(), "error:");
   assert_contains!(stderr_lines.next().unwrap(), "Test failed");
 
   // Then restore the file
-  std::fs::write(&another_test, "Deno.test('another one', () => 3 + 3)")
-    .expect("error writing file");
+  write(&another_test, "Deno.test('another one', () => 3 + 3)").unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
   assert_contains!(stdout_lines.next().unwrap(), "another one");
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Confirm that the watcher keeps on working even if the file is updated and the test fails
   // This also confirms that it restarts when dependencies change
-  std::fs::write(
+  write(
     &foo_file,
     "export default function foo() { throw new Error('Whoops!'); }",
   )
-  .expect("error writing file");
+  .unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
   assert_contains!(stdout_lines.next().unwrap(), "FAILED");
-  while !stdout_lines.next().unwrap().contains("test result") {}
+  wait_for("test result", &mut stdout_lines);
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Then restore the file
-  std::fs::write(&foo_file, "export default function foo() { 1 + 1 }")
-    .expect("error writing file");
+  write(&foo_file, "export default function foo() { 1 + 1 }").unwrap();
   assert_contains!(stderr_lines.next().unwrap(), "Restarting");
   assert_contains!(stdout_lines.next().unwrap(), "running 1 test");
   assert_contains!(stdout_lines.next().unwrap(), "foo");
   stdout_lines.next();
   stdout_lines.next();
   stdout_lines.next();
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   // Test that circular dependencies work fine
-  std::fs::write(
+  write(
     &foo_file,
     "import './bar.js'; export default function foo() { 1 + 1 }",
   )
-  .expect("error writing file");
-  std::fs::write(
+  .unwrap();
+  write(
     &bar_file,
     "import './foo.js'; export default function bar() { 2 + 2 }",
   )
-  .expect("error writing file");
-
-  // the watcher process is still alive
-  assert!(child.try_wait().unwrap().is_none());
-
-  child.kill().unwrap();
-  drop(t);
+  .unwrap();
+  check_alive_then_kill(child);
 }
 
 #[flaky_test]
 fn test_watch_doc() {
-  macro_rules! assert_contains {
-        ($string:expr, $($test:expr),+) => {
-          let string = $string; // This might be a function call or something
-          if !($(string.contains($test))||+) {
-            panic!("{:?} does not contain any of {:?}", string, [$($test),+]);
-          }
-        }
-      }
-
-  let t = TempDir::new().expect("tempdir fail");
+  let t = TempDir::new().unwrap();
 
   let mut child = util::deno_cmd()
     .current_dir(util::testdata_path())
@@ -696,32 +581,26 @@ fn test_watch_doc() {
     .stdout(std::process::Stdio::piped())
     .stderr(std::process::Stdio::piped())
     .spawn()
-    .expect("failed to spawn script");
-
-  let stdout = child.stdout.as_mut().unwrap();
-  let mut stdout_lines =
-    std::io::BufReader::new(stdout).lines().map(|r| r.unwrap());
-  let stderr = child.stderr.as_mut().unwrap();
-  let mut stderr_lines =
-    std::io::BufReader::new(stderr).lines().map(|r| r.unwrap());
+    .unwrap();
+  let (mut stdout_lines, mut stderr_lines) = child_lines(&mut child);
 
   assert_eq!(stdout_lines.next().unwrap(), "");
   assert_contains!(
     stdout_lines.next().unwrap(),
     "0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out"
   );
-  wait_for_process_finished("Test", &mut stderr_lines);
+  wait_for("Test finished", &mut stderr_lines);
 
   let foo_file = t.path().join("foo.ts");
-  std::fs::write(
+  write(
     &foo_file,
     r#"
     export default function foo() {}
   "#,
   )
-  .expect("error writing file");
+  .unwrap();
 
-  std::fs::write(
+  write(
     &foo_file,
     r#"
     /**
@@ -732,14 +611,10 @@ fn test_watch_doc() {
     export default function foo() {}
   "#,
   )
-  .expect("error writing file");
+  .unwrap();
 
   // We only need to scan for a Check file://.../foo.ts$3-6 line that
   // corresponds to the documentation block being type-checked.
   assert_contains!(skip_restarting_line(stderr_lines), "foo.ts$3-6");
-
-  assert!(child.try_wait().unwrap().is_none());
-  child.kill().unwrap();
-
-  drop(t);
+  check_alive_then_kill(child);
 }