diff --git a/Justfile b/Justfile
index d6c6f54..135f054 100755
--- a/Justfile
+++ b/Justfile
@@ -31,6 +31,6 @@ test_dockerfile:
   docker run --rm \
     --cap-add=SYS_PTRACE \
     -v $(pwd)/tests/examples/bigger/script:/root/script \
-    -v $(pwd)/tests/examples/bigger/script.protocols.yaml:/root/script.protocols.yaml \
+    -v $(pwd)/tests/examples/bigger/script.test.yaml:/root/script.test.yaml \
     scriptkeeper \
     script
diff --git a/README.md b/README.md
index 9d900e8..848a4dc 100644
--- a/README.md
+++ b/README.md
@@ -31,8 +31,8 @@ Feel free to open (or vote on)
 
 ## Usage
 
-`scriptkeeper` allows you to write tests -- so-called protocols -- for
-scripts (or other executables) -- without the need to modify your executables.
+`scriptkeeper` allows you to write tests for scripts (or other executables) --
+without the need to modify your executables.
 
 Here's an example script `./build-image.sh`:
 
@@ -47,38 +47,41 @@ else
 fi
 ```
 
-And here's a matching protocols file `./build-image.sh.protocols.yaml`:
+For `scriptkeeper` to be able to test this script, you need to add a yaml file
+in the same directory as the script that has the additional file extension
+`.test.yaml`. So here's the  matching test file
+`./build-image.sh.test.yaml`:
 
 ```yaml
-protocols:
+tests:
   # builds a docker image when git repo is clean
-  - protocol:
+  - steps:
     - command: /usr/bin/git status --porcelain
       stdout: ""
     - command: /usr/bin/git rev-parse HEAD
       stdout: "mock_commit_hash\n"
     - /usr/bin/docker build --tag image_name:mock_commit_hash .
   # aborts when git repo is not clean
-  - protocol:
+  - steps:
     - command: /usr/bin/git status --porcelain
       stdout: " M some-file"
     exitcode: 1
 ```
 
 Now running `scriptkeeper ./build-image.sh` will tell you whether your script
-`./build-image.sh` conforms to your protocols in
-`./build-image.sh.protocols.yaml`.
+`./build-image.sh` conforms to your tests in
+`./build-image.sh.test.yaml`.
 
 There are more example test cases in the [tests/examples](./tests/examples)
 folder.
 
-### `.protocols.yaml` format
+### `.test.yaml` format
 
 Here's all the fields that are available in the yaml declarations for the
-protocols: (`?` marks optional fields.)
+tests: (`?` marks optional fields.)
 
 ``` yaml
-protocols:
+tests:
   - arguments?: string
       # List of arguments given to the tested script, seperated by spaces.
       # Example: "-rf /", default: ""
@@ -99,7 +102,7 @@ protocols:
     exitcode?: number
       # Exitcode that the tested script is expected to exit with.
       # Default: 0.
-    protocol:
+    steps:
       # List of commands that your script is expected to execute.
       - command|regex: string
           # One of either `command` or `regex` is required
@@ -132,7 +135,7 @@ unmockedCommands: [string]
 For convenience you can specify commands as a string directly. So this
 
 ``` yaml
-protocol:
+steps:
   - command: git add .
   - command: git push
 ```
@@ -140,79 +143,79 @@ protocol:
 can be written as
 
 ``` yaml
-protocol:
+steps:
   - git add .
   - git push
 ```
 
-#### Multiple protocols
+#### Multiple tests
 
-Multiple protocols can be specified using a YAML array:
+Multiple tests can be specified using a YAML array:
 
 ``` yaml
 # when given the 'push' argument, it pushes to the remote
 - arguments: push
-  protocol:
+  steps:
     - git add .
     - git push
 # when given the 'pull' argument, it just pulls
 - arguments: push
-  protocol:
+  steps:
     - git pull
 ```
 
-You can also put everything into a `protocols` field:
+You can also put everything into a `tests` field:
 
 ``` yaml
-protocols:
+tests:
   # when given the 'push' argument, it pushes to the remote
   - arguments: push
-    protocol:
+    steps:
       - git add .
       - git push
   # when given the 'pull' argument, it just pulls
   - arguments: push
-    protocol:
+    steps:
       - git pull
 ```
 
-## Recording protocols
+## Recording tests
 
-There is **experimental** support for recording protocols. You can either record
-protocols by passing in the `--record` command line flag, or you can put
-so-called holes into your protocols:
+There is **experimental** support for recording tests. You can either record
+tests by passing in the `--record` command line flag, or you can put so-called
+holes into your tests:
 
 ``` yaml
-protocols:
-  - protocol:
+tests:
+  - steps:
       - _
 ```
 
 This will actually execute the sub-commands that your script performs, without
-mocking them out. And it will overwrite your protocols file with the recorded
+mocking them out. And it will overwrite your tests file with the recorded
 version.
 
-You can also start with a partial protocol and have `scriptkeeper` fill in the
+You can also start with a partial test and have `scriptkeeper` fill in the
 specified holes:
 
 ``` yaml
-protocols:
+tests:
   - arguments: foo
-    protocol:
+    steps:
       - git add .
       - _
 ```
 
-This allows for an iterative process to create a protocol:
+This allows for an iterative process to create a test:
 
-1. Start with an empty protocol with a hole.
+1. Start with an empty test with a hole.
 2. Run `scriptkeeper`.
-3. Identify the step in the recorded protocol where it deviates from the
+3. Identify the step in the recorded test where it deviates from the
    intended test. (If it doesn't, you're done.)
-4. Refine the protocol by modifying the inputs to the tested script, i.e. the
+4. Refine the test by modifying the inputs to the tested script, i.e. the
    arguments, the environment, etc. This can be guided by both the recorded
    script and the script's output to `stdout` and `stderr`.
-5. Remove all protocol steps after the step identified in 3.
+5. Remove all test steps after the step identified in 3.
 6. Add a hole at the end.
 7. Re-iterate from step 2.
 
diff --git a/build-docker-image.sh.protocols.yaml b/build-docker-image.sh.test.yaml
similarity index 81%
rename from build-docker-image.sh.protocols.yaml
rename to build-docker-image.sh.test.yaml
index 214beb2..2a4aa36 100644
--- a/build-docker-image.sh.protocols.yaml
+++ b/build-docker-image.sh.test.yaml
@@ -1,2 +1,2 @@
-protocol:
+steps:
   - /usr/bin/docker build -t scriptkeeper .
diff --git a/scriptkeeper-in-docker.sh b/scriptkeeper-in-docker.sh
index cb64525..1a83769 100755
--- a/scriptkeeper-in-docker.sh
+++ b/scriptkeeper-in-docker.sh
@@ -9,5 +9,5 @@ fi
 
 docker run --rm -it --cap-add=SYS_PTRACE \
   --mount type=bind,source=$script,target=/root/$(basename $script) \
-  --mount type=bind,source=$script.protocols.yaml,target=/root/$(basename $script).protocols.yaml \
+  --mount type=bind,source=$script.test.yaml,target=/root/$(basename $script).test.yaml \
   scriptkeeper $(basename $script)
diff --git a/scriptkeeper-in-docker.sh.protocols.yaml b/scriptkeeper-in-docker.sh.test.yaml
similarity index 67%
rename from scriptkeeper-in-docker.sh.protocols.yaml
rename to scriptkeeper-in-docker.sh.test.yaml
index 84c9dce..38c8ca3 100644
--- a/scriptkeeper-in-docker.sh.protocols.yaml
+++ b/scriptkeeper-in-docker.sh.test.yaml
@@ -1,20 +1,20 @@
 unmockedCommands:
   - /usr/bin/basename
-protocols:
+tests:
   # works for relative paths
   - arguments: ./script
     cwd: /basedir
-    protocol:
+    steps:
       - /usr/bin/docker run --rm -it
         --cap-add=SYS_PTRACE
         --mount type=bind,source=/basedir/./script,target=/root/script
-        --mount type=bind,source=/basedir/./script.protocols.yaml,target=/root/script.protocols.yaml
+        --mount type=bind,source=/basedir/./script.test.yaml,target=/root/script.test.yaml
         scriptkeeper script
   # works for absolute paths
   - arguments: /test/script
-    protocol:
+    steps:
       - /usr/bin/docker run --rm -it
         --cap-add=SYS_PTRACE
         --mount type=bind,source=/test/script,target=/root/script
-        --mount type=bind,source=/test/script.protocols.yaml,target=/root/script.protocols.yaml
+        --mount type=bind,source=/test/script.test.yaml,target=/root/script.test.yaml
         scriptkeeper script
diff --git a/src/cli.rs b/src/cli.rs
index db101b2..ee9a192 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -26,7 +26,7 @@ fn parse_args_safe(args: impl Iterator<Item = String>) -> Result<Args, Error> {
         let matches = App::new("scriptkeeper")
             .arg(Arg::with_name("record").short("r").long("record").help(
                 "[EXPERIMENTAL] Runs the script (without mocking out anything), \
-                 records a protocol and prints it to stdout",
+                 records a test case and prints it to stdout",
             ))
             .arg(
                 Arg::with_name("program")
diff --git a/src/lib.rs b/src/lib.rs
index 9d3f103..e7adb5b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -14,17 +14,17 @@ extern crate memoffset;
 
 pub mod cli;
 pub mod context;
-mod protocol;
-mod protocol_checker;
 mod recorder;
+mod test_checker;
+mod test_spec;
 mod tracer;
 pub mod utils;
 
 use crate::context::Context;
-use crate::protocol::yaml::write_yaml;
-use crate::protocol::Protocols;
-use crate::protocol_checker::executable_mock;
-use crate::recorder::{hole_recorder::run_against_protocols, Recorder};
+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::Tracer;
 use std::collections::HashMap;
@@ -86,7 +86,7 @@ pub fn run_main(context: &Context, args: &cli::Args) -> R<ExitCode> {
             record,
         } => {
             if *record {
-                print_recorded_protocol(context, script_path)?
+                print_recorded_test(context, script_path)?
             } else {
                 run_scriptkeeper(context, &script_path)?
             }
@@ -129,12 +129,12 @@ pub fn run_scriptkeeper(context: &Context, script: &Path) -> R<ExitCode> {
             script.to_string_lossy()
         ))?
     }
-    let (protocols_file_path, expected_protocols) = Protocols::load(script)?;
-    run_against_protocols(&context, script, &protocols_file_path, expected_protocols)
+    let (test_file_path, tests) = Tests::load(script)?;
+    run_against_tests(&context, script, &test_file_path, tests)
 }
 
-fn print_recorded_protocol(context: &Context, program: &Path) -> R<ExitCode> {
-    let protocol = Tracer::run_against_mock(
+fn print_recorded_test(context: &Context, program: &Path) -> R<ExitCode> {
+    let test = Tracer::run_against_mock(
         context,
         &None,
         program,
@@ -143,9 +143,6 @@ fn print_recorded_protocol(context: &Context, program: &Path) -> R<ExitCode> {
         CaptureStderr::NoCapture,
         Recorder::empty(),
     )?;
-    write_yaml(
-        &mut *context.stdout(),
-        &Protocols::new(vec![protocol]).serialize()?,
-    )?;
+    write_yaml(&mut *context.stdout(), &Tests::new(vec![test]).serialize()?)?;
     Ok(ExitCode(0))
 }
diff --git a/src/recorder/hole_recorder.rs b/src/recorder/hole_recorder.rs
index 3321be7..5a21cbe 100644
--- a/src/recorder/hole_recorder.rs
+++ b/src/recorder/hole_recorder.rs
@@ -1,9 +1,9 @@
-use super::protocol_result::ProtocolResult;
 use crate::context::Context;
-use crate::protocol::{Protocol, Protocols};
-use crate::protocol_checker::checker_result::CheckerResult;
-use crate::protocol_checker::ProtocolChecker;
+use crate::recorder::result::RecorderResult;
 use crate::recorder::Recorder;
+use crate::test_checker::checker_result::CheckerResult;
+use crate::test_checker::TestChecker;
+use crate::test_spec::{Test, Tests};
 use crate::tracer::stdio_redirecting::Redirector;
 use crate::tracer::SyscallMock;
 use crate::{ExitCode, R};
@@ -14,8 +14,8 @@ use std::path::{Path, PathBuf};
 
 pub enum HoleRecorder {
     Checker {
-        checker: ProtocolChecker,
-        original_protocol: Protocol,
+        checker: TestChecker,
+        original_test: Test,
     },
     Recorder {
         recorder: Recorder,
@@ -23,20 +23,16 @@ pub enum HoleRecorder {
 }
 
 impl HoleRecorder {
-    pub fn new(
-        context: &Context,
-        unmocked_commands: &[PathBuf],
-        protocol: Protocol,
-    ) -> HoleRecorder {
+    pub fn new(context: &Context, unmocked_commands: &[PathBuf], test: Test) -> HoleRecorder {
         HoleRecorder::Checker {
-            checker: ProtocolChecker::new(context, protocol.clone(), unmocked_commands),
-            original_protocol: protocol,
+            checker: TestChecker::new(context, test.clone(), unmocked_commands),
+            original_test: test,
         }
     }
 }
 
 impl SyscallMock for HoleRecorder {
-    type Result = ProtocolResult;
+    type Result = RecorderResult;
 
     fn handle_execve_enter(
         &mut self,
@@ -48,9 +44,9 @@ impl SyscallMock for HoleRecorder {
         match self {
             HoleRecorder::Checker {
                 checker,
-                original_protocol,
+                original_test,
             } => {
-                if !checker.protocol.steps.is_empty() {
+                if !checker.test.steps.is_empty() {
                     checker.handle_execve_enter(pid, registers, executable, arguments)
                 } else {
                     match checker.result {
@@ -60,7 +56,7 @@ impl SyscallMock for HoleRecorder {
                         CheckerResult::Pass => {
                             *self = HoleRecorder::Recorder {
                                 recorder: Recorder::new(
-                                    original_protocol.clone(),
+                                    original_test.clone(),
                                     &checker.unmocked_commands,
                                 ),
                             };
@@ -82,44 +78,39 @@ impl SyscallMock for HoleRecorder {
         }
     }
 
-    fn handle_end(self, exitcode: i32, redirector: &Redirector) -> R<ProtocolResult> {
+    fn handle_end(self, exitcode: i32, redirector: &Redirector) -> R<RecorderResult> {
         Ok(match self {
             HoleRecorder::Checker {
                 checker,
-                mut original_protocol,
+                mut original_test,
             } => match checker.result {
                 CheckerResult::Pass => {
-                    original_protocol.ends_with_hole = false;
-                    let recorder = Recorder::new(original_protocol, &checker.unmocked_commands);
-                    ProtocolResult::Recorded(recorder.handle_end(exitcode, redirector)?)
+                    original_test.ends_with_hole = false;
+                    let recorder = Recorder::new(original_test, &checker.unmocked_commands);
+                    RecorderResult::Recorded(recorder.handle_end(exitcode, redirector)?)
                 }
                 failure @ CheckerResult::Failure(_) => {
-                    ProtocolResult::Checked(original_protocol, failure)
+                    RecorderResult::Checked(original_test, failure)
                 }
             },
             HoleRecorder::Recorder { recorder } => {
-                ProtocolResult::Recorded(recorder.handle_end(exitcode, redirector)?)
+                RecorderResult::Recorded(recorder.handle_end(exitcode, redirector)?)
             }
         })
     }
 }
 
-pub fn run_against_protocols(
+pub fn run_against_tests(
     context: &Context,
     program: &Path,
-    protocols_file: &Path,
-    Protocols {
-        protocols,
+    test_file: &Path,
+    Tests {
+        tests,
         unmocked_commands,
         interpreter,
-    }: Protocols,
+    }: Tests,
 ) -> R<ExitCode> {
-    let results = ProtocolResult::collect_results(
-        context,
-        &interpreter,
-        program,
-        protocols,
-        &unmocked_commands,
-    )?;
-    ProtocolResult::handle_results(context, protocols_file, unmocked_commands, &results)
+    let results =
+        RecorderResult::collect_results(context, &interpreter, program, tests, &unmocked_commands)?;
+    RecorderResult::handle_results(context, test_file, unmocked_commands, &results)
 }
diff --git a/src/recorder/mod.rs b/src/recorder/mod.rs
index 6f8741b..602c397 100644
--- a/src/recorder/mod.rs
+++ b/src/recorder/mod.rs
@@ -1,9 +1,9 @@
 pub mod hole_recorder;
-mod protocol_result;
+mod result;
 
-use crate::protocol::command::Command;
-use crate::protocol::command_matcher::CommandMatcher;
-use crate::protocol::{compare_executables, Protocol, Step};
+use crate::test_spec::command::Command;
+use crate::test_spec::command_matcher::CommandMatcher;
+use crate::test_spec::{compare_executables, Step, Test};
 use crate::tracer::stdio_redirecting::Redirector;
 use crate::tracer::SyscallMock;
 use crate::R;
@@ -13,7 +13,7 @@ use std::ffi::OsString;
 use std::path::PathBuf;
 
 pub struct Recorder {
-    protocol: Protocol,
+    test: Test,
     command: Option<Command>,
     unmocked_commands: Vec<PathBuf>,
 }
@@ -21,15 +21,15 @@ pub struct Recorder {
 impl Recorder {
     pub fn empty() -> Recorder {
         Recorder {
-            protocol: Protocol::new(vec![]),
+            test: Test::new(vec![]),
             command: None,
             unmocked_commands: vec![],
         }
     }
 
-    pub fn new(protocol: Protocol, unmocked_commands: &[PathBuf]) -> Recorder {
+    pub fn new(test: Test, unmocked_commands: &[PathBuf]) -> Recorder {
         Recorder {
-            protocol,
+            test,
             command: None,
             unmocked_commands: unmocked_commands.to_vec(),
         }
@@ -37,7 +37,7 @@ impl Recorder {
 }
 
 impl SyscallMock for Recorder {
-    type Result = Protocol;
+    type Result = Test;
 
     fn handle_execve_enter(
         &mut self,
@@ -62,7 +62,7 @@ impl SyscallMock for Recorder {
     fn handle_exited(&mut self, _pid: Pid, exitcode: i32) -> R<()> {
         if let Some(command) = self.command.clone() {
             self.command = None;
-            self.protocol.steps.push_back(Step {
+            self.test.steps.push_back(Step {
                 command_matcher: CommandMatcher::ExactMatch(command),
                 stdout: vec![],
                 exitcode,
@@ -71,10 +71,10 @@ impl SyscallMock for Recorder {
         Ok(())
     }
 
-    fn handle_end(mut self, exitcode: i32, _redirector: &Redirector) -> R<Protocol> {
+    fn handle_end(mut self, exitcode: i32, _redirector: &Redirector) -> R<Test> {
         if exitcode != 0 {
-            self.protocol.exitcode = Some(exitcode);
+            self.test.exitcode = Some(exitcode);
         }
-        Ok(self.protocol)
+        Ok(self.test)
     }
 }
diff --git a/src/recorder/protocol_result.rs b/src/recorder/result.rs
similarity index 61%
rename from src/recorder/protocol_result.rs
rename to src/recorder/result.rs
index 4dba55a..2bdb5f6 100644
--- a/src/recorder/protocol_result.rs
+++ b/src/recorder/result.rs
@@ -1,10 +1,10 @@
 use super::hole_recorder::HoleRecorder;
 use crate::context::Context;
-use crate::protocol::{yaml::write_yaml, Protocol, Protocols};
-use crate::protocol_checker::{
+use crate::test_checker::{
     checker_result::{CheckerResult, CheckerResults},
-    ProtocolChecker,
+    TestChecker,
 };
+use crate::test_spec::{yaml::write_yaml, Test, Tests};
 use crate::tracer::stdio_redirecting::CaptureStderr;
 use crate::tracer::Tracer;
 use crate::{ExitCode, R};
@@ -12,30 +12,30 @@ use std::fs::OpenOptions;
 use std::path::{Path, PathBuf};
 
 #[derive(Debug, PartialEq)]
-pub enum ProtocolResult {
-    Checked(Protocol, CheckerResult),
-    Recorded(Protocol),
+pub enum RecorderResult {
+    Checked(Test, CheckerResult),
+    Recorded(Test),
 }
 
-impl ProtocolResult {
+impl RecorderResult {
     fn is_recorded(&self) -> bool {
         match self {
-            ProtocolResult::Recorded(_) => true,
-            ProtocolResult::Checked(_, _) => false,
+            RecorderResult::Recorded(_) => true,
+            RecorderResult::Checked(_, _) => false,
         }
     }
 
-    fn get_protocol(&self) -> Protocol {
+    fn get_test(&self) -> Test {
         match self {
-            ProtocolResult::Checked(protocol, _) => protocol.clone(),
-            ProtocolResult::Recorded(protocol) => protocol.clone(),
+            RecorderResult::Checked(test, _) => test.clone(),
+            RecorderResult::Recorded(test) => test.clone(),
         }
     }
 
     fn get_test_result(&self) -> Option<CheckerResult> {
         match self {
-            ProtocolResult::Checked(_, test_result) => Some(test_result.clone()),
-            ProtocolResult::Recorded(_) => None,
+            RecorderResult::Checked(_, test_result) => Some(test_result.clone()),
+            RecorderResult::Recorded(_) => None,
         }
     }
 
@@ -43,17 +43,17 @@ impl ProtocolResult {
         context: &Context,
         interpreter: &Option<PathBuf>,
         program: &Path,
-        protocols: Vec<Protocol>,
+        tests: Vec<Test>,
         unmocked_commands: &[PathBuf],
-    ) -> R<Vec<ProtocolResult>> {
+    ) -> R<Vec<RecorderResult>> {
         let mut results = vec![];
-        for protocol in protocols.into_iter() {
-            results.push(run_against_protocol(
+        for test in tests.into_iter() {
+            results.push(run_against_test(
                 context,
                 &interpreter,
                 program,
                 unmocked_commands,
-                protocol,
+                test,
             )?);
         }
         Ok(results)
@@ -61,9 +61,9 @@ impl ProtocolResult {
 
     pub fn handle_results(
         context: &Context,
-        protocols_file: &Path,
+        test_file: &Path,
         unmocked_commands: Vec<PathBuf>,
-        results: &[ProtocolResult],
+        results: &[RecorderResult],
     ) -> R<ExitCode> {
         let checker_results = CheckerResults(
             results
@@ -71,9 +71,9 @@ impl ProtocolResult {
                 .filter_map(|result| result.get_test_result())
                 .collect(),
         );
-        ProtocolResult::handle_recorded(
+        RecorderResult::handle_recorded(
             context,
-            protocols_file,
+            test_file,
             unmocked_commands,
             &results,
             &checker_results,
@@ -84,20 +84,20 @@ impl ProtocolResult {
 
     fn handle_recorded(
         context: &Context,
-        protocols_file: &Path,
+        test_file: &Path,
         unmocked_commands: Vec<PathBuf>,
-        results: &[ProtocolResult],
+        results: &[RecorderResult],
         checker_results: &CheckerResults,
     ) -> R<()> {
         if checker_results.is_pass() && results.iter().any(|result| result.is_recorded()) {
             let mut file = OpenOptions::new()
                 .write(true)
                 .truncate(true)
-                .open(protocols_file)?;
+                .open(test_file)?;
             write_yaml(
                 &mut file,
-                &Protocols {
-                    protocols: results.iter().map(|result| result.get_protocol()).collect(),
+                &Tests {
+                    tests: results.iter().map(|result| result.get_test()).collect(),
                     unmocked_commands,
                     interpreter: None,
                 }
@@ -105,30 +105,30 @@ impl ProtocolResult {
             )?;
             writeln!(
                 context.stdout(),
-                "Protocol holes filled in {}.",
-                protocols_file.to_string_lossy()
+                "Test holes filled in {}.",
+                test_file.to_string_lossy()
             )?;
         }
         Ok(())
     }
 }
 
-fn run_against_protocol(
+fn run_against_test(
     context: &Context,
     interpreter: &Option<PathBuf>,
     program: &Path,
     unmocked_commands: &[PathBuf],
-    protocol: Protocol,
-) -> R<ProtocolResult> {
+    test: Test,
+) -> R<RecorderResult> {
     macro_rules! run_against_mock {
         ($syscall_mock:expr) => {
             Tracer::run_against_mock(
                 context,
                 interpreter,
                 program,
-                protocol.arguments.clone(),
-                protocol.env.clone(),
-                if protocol.stderr.is_some() {
+                test.arguments.clone(),
+                test.env.clone(),
+                if test.stderr.is_some() {
                     CaptureStderr::Capture
                 } else {
                     CaptureStderr::NoCapture
@@ -137,12 +137,12 @@ fn run_against_protocol(
             )
         };
     }
-    if protocol.ends_with_hole {
-        run_against_mock!(HoleRecorder::new(context, unmocked_commands, protocol))
+    if test.ends_with_hole {
+        run_against_mock!(HoleRecorder::new(context, unmocked_commands, test))
     } else {
-        Ok(ProtocolResult::Checked(
-            protocol.clone(),
-            run_against_mock!(ProtocolChecker::new(context, protocol, unmocked_commands))?,
+        Ok(RecorderResult::Checked(
+            test.clone(),
+            run_against_mock!(TestChecker::new(context, test, unmocked_commands))?,
         ))
     }
 }
diff --git a/src/protocol_checker/checker_result.rs b/src/test_checker/checker_result.rs
similarity index 91%
rename from src/protocol_checker/checker_result.rs
rename to src/test_checker/checker_result.rs
index 60d96d4..87702ae 100644
--- a/src/protocol_checker/checker_result.rs
+++ b/src/test_checker/checker_result.rs
@@ -18,13 +18,13 @@ impl CheckerResult {
         match self {
             CheckerResult::Failure(error) => {
                 let header = number.map_or("error".to_string(), |number| {
-                    format!("error in protocol {}", number)
+                    format!("error in test {}", number)
                 });
                 format!("{}:\n{}", header, error)
             }
             CheckerResult::Pass => match number {
                 None => panic!("CheckerResult.format: shouldn't happen"),
-                Some(number) => format!("protocol {}:\n  Tests passed.\n", number),
+                Some(number) => format!("test {}:\n  Tests passed.\n", number),
             },
         }
     }
diff --git a/src/protocol_checker/executable_mock.rs b/src/test_checker/executable_mock.rs
similarity index 100%
rename from src/protocol_checker/executable_mock.rs
rename to src/test_checker/executable_mock.rs
diff --git a/src/protocol_checker/mod.rs b/src/test_checker/mod.rs
similarity index 77%
rename from src/protocol_checker/mod.rs
rename to src/test_checker/mod.rs
index ec4ba33..08ed203 100644
--- a/src/protocol_checker/mod.rs
+++ b/src/test_checker/mod.rs
@@ -2,8 +2,8 @@ pub mod checker_result;
 pub mod executable_mock;
 
 use crate::context::Context;
-use crate::protocol;
-use crate::protocol::Protocol;
+use crate::test_spec;
+use crate::test_spec::Test;
 use crate::tracer::stdio_redirecting::Redirector;
 use crate::tracer::{tracee_memory, SyscallMock};
 use crate::utils::short_temp_files::ShortTempFile;
@@ -17,23 +17,19 @@ use std::os::unix::ffi::OsStrExt;
 use std::path::PathBuf;
 
 #[derive(Debug)]
-pub struct ProtocolChecker {
+pub struct TestChecker {
     context: Context,
-    pub protocol: Protocol,
+    pub test: Test,
     pub unmocked_commands: Vec<PathBuf>,
     pub result: CheckerResult,
     temporary_executables: Vec<ShortTempFile>,
 }
 
-impl ProtocolChecker {
-    pub fn new(
-        context: &Context,
-        protocol: Protocol,
-        unmocked_commands: &[PathBuf],
-    ) -> ProtocolChecker {
-        ProtocolChecker {
+impl TestChecker {
+    pub fn new(context: &Context, test: Test, unmocked_commands: &[PathBuf]) -> TestChecker {
+        TestChecker {
             context: context.clone(),
-            protocol,
+            test,
             unmocked_commands: unmocked_commands.to_vec(),
             result: CheckerResult::Pass,
             temporary_executables: vec![],
@@ -47,23 +43,23 @@ impl ProtocolChecker {
         }
     }
 
-    fn handle_step(&mut self, received: protocol::Command) -> R<PathBuf> {
-        let mock_config = match self.protocol.steps.pop_front() {
-            Some(next_protocol_step) => {
-                if !next_protocol_step.command_matcher.matches(&received) {
+    fn handle_step(&mut self, received: test_spec::Command) -> R<PathBuf> {
+        let mock_config = match self.test.steps.pop_front() {
+            Some(next_test_step) => {
+                if !next_test_step.command_matcher.matches(&received) {
                     self.register_step_error(
-                        &next_protocol_step.command_matcher.format(),
+                        &next_test_step.command_matcher.format(),
                         &received.format(),
                     );
                 }
                 executable_mock::Config {
-                    stdout: next_protocol_step.stdout,
-                    exitcode: next_protocol_step.exitcode,
+                    stdout: next_test_step.stdout,
+                    exitcode: next_test_step.exitcode,
                 }
             }
             None => {
-                self.register_step_error("<protocol end>", &received.format());
-                ProtocolChecker::allow_failing_scripts_to_continue()
+                self.register_step_error("<script termination>", &received.format());
+                TestChecker::allow_failing_scripts_to_continue()
             }
         };
         let mock_executable_contents =
@@ -91,7 +87,7 @@ impl ProtocolChecker {
     }
 }
 
-impl SyscallMock for ProtocolChecker {
+impl SyscallMock for TestChecker {
     type Result = CheckerResult;
 
     fn handle_execve_enter(
@@ -104,9 +100,9 @@ impl SyscallMock for ProtocolChecker {
         let is_unmocked_command = self
             .unmocked_commands
             .iter()
-            .any(|unmocked_command| protocol::compare_executables(unmocked_command, &executable));
+            .any(|unmocked_command| test_spec::compare_executables(unmocked_command, &executable));
         if !is_unmocked_command {
-            let mock_executable_path = self.handle_step(protocol::Command {
+            let mock_executable_path = self.handle_step(test_spec::Command {
                 executable,
                 arguments,
             })?;
@@ -120,7 +116,7 @@ impl SyscallMock for ProtocolChecker {
     }
 
     fn handle_getcwd_exit(&self, pid: Pid, registers: &user_regs_struct) -> R<()> {
-        if let Some(mock_cwd) = &self.protocol.cwd {
+        if let Some(mock_cwd) = &self.test.cwd {
             let mock_cwd = mock_cwd.as_os_str().as_bytes();
             let buffer_ptr = registers.rdi;
             let max_size = registers.rsi;
@@ -133,7 +129,7 @@ impl SyscallMock for ProtocolChecker {
     }
 
     fn handle_stat_exit(&self, pid: Pid, registers: &user_regs_struct, filename: PathBuf) -> R<()> {
-        if self.protocol.mocked_files.contains(&filename) {
+        if self.test.mocked_files.contains(&filename) {
             let statbuf_ptr = registers.rsi;
             let mock_mode = if filename.as_os_str().as_bytes().ends_with(b"/") {
                 libc::S_IFDIR
@@ -154,20 +150,20 @@ impl SyscallMock for ProtocolChecker {
     }
 
     fn handle_end(mut self, exitcode: i32, redirector: &Redirector) -> R<CheckerResult> {
-        if let Some(expected_step) = self.protocol.steps.pop_front() {
+        if let Some(expected_step) = self.test.steps.pop_front() {
             self.register_step_error(
                 &expected_step.command_matcher.format(),
                 "<script terminated>",
             );
         }
-        let expected_exitcode = self.protocol.exitcode.unwrap_or(0);
+        let expected_exitcode = self.test.exitcode.unwrap_or(0);
         if exitcode != expected_exitcode {
             self.register_step_error(
                 &format!("<exitcode {}>", expected_exitcode),
                 &format!("<exitcode {}>", exitcode),
             );
         }
-        if let Some(expected_stderr) = &self.protocol.stderr {
+        if let Some(expected_stderr) = &self.test.stderr {
             match redirector.stderr.captured()? {
                 None => panic!("scriptkeeper bug: stderr expected, but not captured"),
                 Some(captured_stderr) => {
diff --git a/src/protocol/argument_parser.rs b/src/test_spec/argument_parser.rs
similarity index 100%
rename from src/protocol/argument_parser.rs
rename to src/test_spec/argument_parser.rs
diff --git a/src/protocol/command.rs b/src/test_spec/command.rs
similarity index 100%
rename from src/protocol/command.rs
rename to src/test_spec/command.rs
diff --git a/src/protocol/command_matcher.rs b/src/test_spec/command_matcher.rs
similarity index 100%
rename from src/protocol/command_matcher.rs
rename to src/test_spec/command_matcher.rs
diff --git a/src/protocol/executable_path.rs b/src/test_spec/executable_path.rs
similarity index 100%
rename from src/protocol/executable_path.rs
rename to src/test_spec/executable_path.rs
diff --git a/src/protocol/mod.rs b/src/test_spec/mod.rs
similarity index 74%
rename from src/protocol/mod.rs
rename to src/test_spec/mod.rs
index d447d3e..9f9e13f 100644
--- a/src/protocol/mod.rs
+++ b/src/test_spec/mod.rs
@@ -8,7 +8,7 @@ pub mod yaml;
 
 use self::argument_parser::Parser;
 pub use self::executable_path::compare_executables;
-use crate::protocol::yaml::*;
+use crate::test_spec::yaml::*;
 use crate::utils::{path_to_string, with_has_more};
 use crate::R;
 pub use command::Command;
@@ -190,7 +190,7 @@ mod parse_step {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-pub struct Protocol {
+pub struct Test {
     pub steps: VecDeque<Step>,
     pub ends_with_hole: bool,
     pub arguments: Vec<String>,
@@ -201,14 +201,14 @@ pub struct Protocol {
     pub mocked_files: Vec<PathBuf>,
 }
 
-impl Protocol {
+impl Test {
     #[allow(dead_code)]
-    pub fn empty() -> Protocol {
-        Protocol::new(vec![])
+    pub fn empty() -> Test {
+        Test::new(vec![])
     }
 
-    pub fn new(steps: Vec<Step>) -> Protocol {
-        Protocol {
+    pub fn new(steps: Vec<Step>) -> Test {
+        Test {
             steps: steps.into(),
             ends_with_hole: false,
             arguments: vec![],
@@ -220,7 +220,7 @@ impl Protocol {
         }
     }
 
-    fn from_array(array: &[Yaml]) -> R<Protocol> {
+    fn from_array(array: &[Yaml]) -> R<Test> {
         enum StepOrHole {
             Step(Step),
             Hole,
@@ -231,21 +231,21 @@ impl Protocol {
                 yaml => StepOrHole::Step(Step::parse(yaml)?),
             })
         }
-        let mut protocol = Protocol::empty();
+        let mut test = Test::empty();
         for (yaml, has_more) in with_has_more(array) {
             match parse_step_or_hole(yaml)? {
                 StepOrHole::Step(step) => {
-                    protocol.steps.push_back(step);
+                    test.steps.push_back(step);
                 }
                 StepOrHole::Hole => {
-                    protocol.ends_with_hole = true;
+                    test.ends_with_hole = true;
                     if has_more {
                         Err("holes ('_') are only allowed as the last step")?;
                     }
                 }
             }
         }
-        Ok(protocol)
+        Ok(test)
     }
 
     fn add_arguments(&mut self, object: &Hash) -> R<()> {
@@ -304,10 +304,10 @@ impl Protocol {
         Ok(())
     }
 
-    fn from_object(object: &Hash) -> R<Protocol> {
+    fn from_object(object: &Hash) -> R<Test> {
         check_keys(
             &[
-                "protocol",
+                "steps",
                 "mockedFiles",
                 "arguments",
                 "env",
@@ -317,14 +317,14 @@ impl Protocol {
             ],
             object,
         )?;
-        let mut protocol = Protocol::from_array(object.expect_field("protocol")?.expect_array()?)?;
-        protocol.add_arguments(&object)?;
-        protocol.add_env(&object)?;
-        protocol.add_cwd(&object)?;
-        protocol.add_stderr(&object)?;
-        protocol.add_exitcode(&object)?;
-        protocol.add_mocked_files(&object)?;
-        Ok(protocol)
+        let mut test = Test::from_array(object.expect_field("steps")?.expect_array()?)?;
+        test.add_arguments(&object)?;
+        test.add_env(&object)?;
+        test.add_cwd(&object)?;
+        test.add_stderr(&object)?;
+        test.add_exitcode(&object)?;
+        test.add_mocked_files(&object)?;
+        Ok(test)
     }
 
     fn serialize_env(&self, object: &mut Hash) {
@@ -338,54 +338,54 @@ impl Protocol {
     }
 
     fn serialize(&self) -> Yaml {
-        let mut protocol = LinkedHashMap::new();
+        let mut test = LinkedHashMap::new();
         if !self.arguments.is_empty() {
             let arguments = self.arguments.iter().map(OsString::from).collect();
-            protocol.insert(
+            test.insert(
                 Yaml::from_str("arguments"),
                 Yaml::String(Command::format_arguments(arguments)),
             );
         }
-        self.serialize_env(&mut protocol);
+        self.serialize_env(&mut test);
         {
             let mut steps = vec![];
             for step in &self.steps {
                 steps.push(step.serialize());
             }
-            protocol.insert(Yaml::from_str("protocol"), Yaml::Array(steps));
+            test.insert(Yaml::from_str("steps"), Yaml::Array(steps));
         }
         if let Some(exitcode) = self.exitcode {
-            protocol.insert(
+            test.insert(
                 Yaml::from_str("exitcode"),
                 Yaml::Integer(i64::from(exitcode)),
             );
         }
-        Yaml::Hash(protocol)
+        Yaml::Hash(test)
     }
 }
 
 #[derive(Debug, PartialEq)]
-pub struct Protocols {
-    pub protocols: Vec<Protocol>,
+pub struct Tests {
+    pub tests: Vec<Test>,
     pub unmocked_commands: Vec<PathBuf>,
     pub interpreter: Option<PathBuf>,
 }
 
-impl Protocols {
-    pub fn new(protocols: Vec<Protocol>) -> Protocols {
-        Protocols {
-            protocols,
+impl Tests {
+    pub fn new(tests: Vec<Test>) -> Tests {
+        Tests {
+            tests,
             unmocked_commands: vec![],
             interpreter: None,
         }
     }
 
-    fn from_array(array: &[Yaml]) -> R<Protocols> {
+    fn from_array(array: &[Yaml]) -> R<Tests> {
         let mut result = vec![];
         for element in array.iter() {
-            result.push(Protocol::from_object(element.expect_object()?)?);
+            result.push(Test::from_object(element.expect_object()?)?);
         }
-        Ok(Protocols::new(result))
+        Ok(Tests::new(result))
     }
 
     fn add_interpreter(&mut self, object: &Hash) -> R<()> {
@@ -405,59 +405,50 @@ impl Protocols {
         Ok(())
     }
 
-    fn parse(yaml: Yaml) -> R<Protocols> {
+    fn parse(yaml: Yaml) -> R<Tests> {
         Ok(match &yaml {
-            Yaml::Array(array) => Protocols::from_array(&array)?,
-            Yaml::Hash(object) => match (
-                object.expect_field("protocols"),
-                object.expect_field("protocol"),
-            ) {
-                (Ok(protocols), _) => {
-                    check_keys(&["protocols", "interpreter", "unmockedCommands"], object)?;
-                    let mut protocols = Protocols::from_array(protocols.expect_array()?)?;
-                    protocols.add_unmocked_commands(object)?;
-                    protocols.add_interpreter(object)?;
-                    protocols
+            Yaml::Array(array) => Tests::from_array(&array)?,
+            Yaml::Hash(object) => {
+                match (object.expect_field("tests"), object.expect_field("steps")) {
+                    (Ok(tests), _) => {
+                        check_keys(&["tests", "interpreter", "unmockedCommands"], object)?;
+                        let mut tests = Tests::from_array(tests.expect_array()?)?;
+                        tests.add_unmocked_commands(object)?;
+                        tests.add_interpreter(object)?;
+                        tests
+                    }
+                    (Err(_), Ok(_)) => Tests::new(vec![Test::from_object(&object)?]),
+                    (Err(_), Err(_)) => Err(format!(
+                        "expected top-level field \"steps\" or \"tests\", got: {:?}",
+                        &yaml
+                    ))?,
                 }
-                (Err(_), Ok(_)) => Protocols::new(vec![Protocol::from_object(&object)?]),
-                (Err(_), Err(_)) => Err(format!(
-                    "expected top-level field \"protocol\" or \"protocols\", got: {:?}",
-                    &yaml
-                ))?,
-            },
+            }
             _ => Err(format!("expected: array or object, got: {:?}", &yaml))?,
         })
     }
 
-    pub fn load(executable_path: &Path) -> R<(PathBuf, Protocols)> {
-        let protocols_file = find_protocol_file(executable_path);
-        let file_contents = read_protocols_file(&protocols_file)?;
+    pub fn load(executable_path: &Path) -> R<(PathBuf, Tests)> {
+        let test_file = find_test_file(executable_path);
+        let file_contents = read_test_file(&test_file)?;
         let yaml: Vec<Yaml> = YamlLoader::load_from_str(&file_contents).map_err(|error| {
-            format!(
-                "invalid YAML in {}: {}",
-                protocols_file.to_string_lossy(),
-                error
-            )
+            format!("invalid YAML in {}: {}", test_file.to_string_lossy(), error)
         })?;
         let yaml: Yaml = {
             if yaml.len() > 1 {
                 Err(format!(
                     "multiple YAML documents not allowed (in {})",
-                    protocols_file.to_string_lossy()
+                    test_file.to_string_lossy()
                 ))?;
             }
-            yaml.into_iter().next().ok_or_else(|| {
-                format!(
-                    "no YAML documents (in {})",
-                    protocols_file.to_string_lossy()
-                )
-            })?
+            yaml.into_iter()
+                .next()
+                .ok_or_else(|| format!("no YAML documents (in {})", test_file.to_string_lossy()))?
         };
         Ok((
-            protocols_file.clone(),
-            Protocols::parse(yaml).map_err(|error| {
-                format!("error in {}: {}", protocols_file.to_string_lossy(), error)
-            })?,
+            test_file.clone(),
+            Tests::parse(yaml)
+                .map_err(|error| format!("error in {}: {}", test_file.to_string_lossy(), error))?,
         ))
     }
 
@@ -482,11 +473,11 @@ impl Protocols {
         let mut object = LinkedHashMap::new();
         self.serialize_unmocked_commands(&mut object)?;
         {
-            let mut protocols = vec![];
-            for protocol in self.protocols.iter() {
-                protocols.push(protocol.serialize());
+            let mut tests = vec![];
+            for test in self.tests.iter() {
+                tests.push(test.serialize());
             }
-            object.insert(Yaml::from_str("protocols"), Yaml::Array(protocols));
+            object.insert(Yaml::from_str("tests"), Yaml::Array(tests));
         }
         Ok(Yaml::Hash(object))
     }
@@ -501,29 +492,29 @@ mod load {
     use std::*;
     use test_utils::{assert_error, trim_margin, Mappable, TempFile};
 
-    fn test_parse(tempfile: &TempFile, protocol_string: &str) -> R<Protocols> {
-        let protocols_file = tempfile.path().with_extension("protocols.yaml");
-        fs::write(&protocols_file, trim_margin(protocol_string)?)?;
-        Ok(Protocols::load(&tempfile.path())?.1)
+    fn test_parse(tempfile: &TempFile, tests_string: &str) -> R<Tests> {
+        let test_file = tempfile.path().with_extension("test.yaml");
+        fs::write(&test_file, trim_margin(tests_string)?)?;
+        Ok(Tests::load(&tempfile.path())?.1)
     }
 
-    fn test_parse_one(protocol_string: &str) -> R<Protocol> {
+    fn test_parse_one(tests_string: &str) -> R<Test> {
         let tempfile = TempFile::new()?;
-        let result = test_parse(&tempfile, protocol_string)?.protocols;
+        let result = test_parse(&tempfile, tests_string)?.tests;
         assert_eq!(result.len(), 1);
         Ok(result.into_iter().next().unwrap())
     }
 
     #[test]
-    fn reads_a_protocol_from_a_sibling_yaml_file() -> R<()> {
+    fn reads_a_test_from_a_sibling_yaml_file() -> R<()> {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true
                 ",
             )?,
-            Protocol::new(vec![Step::new(CommandMatcher::ExactMatch(Command {
+            Test::new(vec![Step::new(CommandMatcher::ExactMatch(Command {
                 executable: PathBuf::from("/bin/true"),
                 arguments: vec![],
             }))]),
@@ -532,10 +523,10 @@ mod load {
     }
 
     #[test]
-    fn returns_an_informative_error_when_the_protocol_file_is_missing() {
+    fn returns_an_informative_error_when_the_test_file_is_missing() {
         assert_error!(
-            Protocols::load(&PathBuf::from("./does-not-exist")),
-            "protocol file not found: ./does-not-exist.protocols.yaml"
+            Tests::load(&PathBuf::from("./does-not-exist")),
+            "test file not found: ./does-not-exist.test.yaml"
         );
     }
 
@@ -551,15 +542,15 @@ mod load {
                     &tempfile,
                     "
                         |foo: 42
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - foo
                     "
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      unexpected field 'foo', \
-                     possible values: 'protocols', 'interpreter', 'unmockedCommands'",
+                     possible values: 'tests', 'interpreter', 'unmockedCommands'",
                     path_to_string(&tempfile.path())?
                 )
             );
@@ -567,23 +558,23 @@ mod load {
         }
 
         #[test]
-        fn disallows_unknown_protocol_keys() -> R<()> {
+        fn disallows_unknown_test_keys() -> R<()> {
             let tempfile = TempFile::new()?;
             assert_error!(
                 test_parse(
                     &tempfile,
                     "
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - foo
                         |    foo: 42
                     "
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      unexpected field 'foo', \
                      possible values: \
-                     'protocol', 'mockedFiles', 'arguments', 'env', \
+                     'steps', 'mockedFiles', 'arguments', 'env', \
                      'exitcode', 'stderr', 'cwd'",
                     path_to_string(&tempfile.path())?
                 )
@@ -598,14 +589,14 @@ mod load {
                 test_parse(
                     &tempfile,
                     "
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - command: foo
                         |        foo: 42
                     "
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      unexpected field 'foo', \
                      possible values: 'command', 'stdout', 'exitcode', 'regex'",
                     path_to_string(&tempfile.path())?
@@ -630,7 +621,7 @@ mod load {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true
                     |  - /bin/false
                 "
@@ -647,7 +638,7 @@ mod load {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true foo bar
                 "
             )?
@@ -659,15 +650,15 @@ mod load {
     }
 
     #[test]
-    fn allows_to_specify_the_protocol_as_an_object() -> R<()> {
+    fn allows_to_specify_the_test_as_an_object() -> R<()> {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true
                 "
             )?,
-            Protocol::new(vec![Step::new(CommandMatcher::ExactMatch(Command {
+            Test::new(vec![Step::new(CommandMatcher::ExactMatch(Command {
                 executable: PathBuf::from("/bin/true"),
                 arguments: vec![],
             }))]),
@@ -680,7 +671,7 @@ mod load {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true
                     |env:
                     |  foo: bar
@@ -695,20 +686,20 @@ mod load {
     }
 
     #[test]
-    fn allows_to_specify_multiple_protocols() -> R<()> {
+    fn allows_to_specify_multiple_tests() -> R<()> {
         let tempfile = TempFile::new()?;
         assert_eq!(
             test_parse(
                 &tempfile,
                 r"
                     |- arguments: foo
-                    |  protocol: []
+                    |  steps: []
                     |- arguments: bar
-                    |  protocol: []
+                    |  steps: []
                 ",
             )?
-            .protocols
-            .map(|protocol| protocol.arguments),
+            .tests
+            .map(|test| test.arguments),
             vec![vec!["foo"], vec!["bar"]]
         );
         Ok(())
@@ -721,13 +712,13 @@ mod load {
             test_parse(
                 &tempfile,
                 r"
-                    |protocol: []
+                    |steps: []
                     |---
-                    |protocol: []
+                    |steps: []
                 ",
             ),
             format!(
-                "multiple YAML documents not allowed (in {}.protocols.yaml)",
+                "multiple YAML documents not allowed (in {}.test.yaml)",
                 path_to_string(&tempfile.path())?
             )
         );
@@ -735,21 +726,21 @@ mod load {
     }
 
     #[test]
-    fn allows_to_specify_multiple_protocols_as_an_object() -> R<()> {
+    fn allows_to_specify_multiple_tests_as_an_object() -> R<()> {
         let tempfile = TempFile::new()?;
         assert_eq!(
             test_parse(
                 &tempfile,
                 r"
-                    |protocols:
+                    |tests:
                     |  - arguments: foo
-                    |    protocol: []
+                    |    steps: []
                     |  - arguments: bar
-                    |    protocol: []
+                    |    steps: []
                 ",
             )?
-            .protocols
-            .map(|protocol| protocol.arguments),
+            .tests
+            .map(|test| test.arguments),
             vec![vec!["foo"], vec!["bar"]]
         );
         Ok(())
@@ -761,8 +752,8 @@ mod load {
         assert_error!(
             test_parse(&tempfile, "{}"),
             format!(
-                "error in {}.protocols.yaml: \
-                 expected top-level field \"protocol\" or \"protocols\", \
+                "error in {}.test.yaml: \
+                 expected top-level field \"steps\" or \"tests\", \
                  got: Hash({{}})",
                 path_to_string(&tempfile.path())?
             )
@@ -779,7 +770,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                         |arguments: foo bar
                     "
@@ -795,7 +786,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r#"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                         |arguments: foo "bar baz"
                     "#
@@ -813,13 +804,13 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                         |arguments: 42
                     "
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      expected: string, got: Integer(42)",
                     path_to_string(&tempfile.path())?
                 )
@@ -837,7 +828,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                         |cwd: /foo
                     "
@@ -853,7 +844,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                     "
                 )?
@@ -867,13 +858,13 @@ mod load {
         fn disallows_relative_paths() -> R<()> {
             let yaml = YamlLoader::load_from_str(&trim_margin(
                 r"
-                    |protocol:
+                    |steps:
                     |  - /bin/true
                     |cwd: foo
                 ",
             )?)?;
             assert_error!(
-                Protocols::parse(yaml[0].clone()),
+                Tests::parse(yaml[0].clone()),
                 "cwd has to be an absolute path starting with \"/\", got: \"foo\""
             );
             Ok(())
@@ -889,7 +880,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                         |exitcode: 42
                     "
@@ -905,7 +896,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocol:
+                        |steps:
                         |  - /bin/true
                     "
                 )?
@@ -927,8 +918,8 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol: []
+                        |tests:
+                        |  - steps: []
                         |unmockedCommands:
                         |  - foo
                     "
@@ -952,8 +943,8 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol: []
+                        |tests:
+                        |  - steps: []
                         |interpreter: /bin/bash
                     ",
                 )?
@@ -972,13 +963,13 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol: []
+                        |tests:
+                        |  - steps: []
                         |interpreter: 42
                     ",
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      expected: string, got: Integer(42)",
                     path_to_string(&tempfile.path())?
                 )
@@ -992,7 +983,7 @@ mod load {
         assert_eq!(
             test_parse_one(
                 r"
-                    |protocol: []
+                    |steps: []
                     |mockedFiles:
                     |  - /foo
                 "
@@ -1013,7 +1004,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |- protocol: []
+                        |- steps: []
                         |  stderr: foo
                     "
                 )?
@@ -1029,7 +1020,7 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |- protocol: []
+                        |- steps: []
                     "
                 )?
                 .stderr,
@@ -1047,8 +1038,8 @@ mod load {
         fn parses_a_regex_command_matcher() -> R<()> {
             let step = test_parse_one(
                 r"
-                    |protocols:
-                    |  - protocol:
+                    |tests:
+                    |  - steps:
                     |      - regex: \d
                 ",
             )?
@@ -1068,14 +1059,14 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - command: foo
                         |        regex: \d
                     ",
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      please provide either a 'command' or 'regex' field but not both",
                     path_to_string(&tempfile.path())?
                 )
@@ -1090,13 +1081,13 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - regex: \x
                     ",
                 ),
                 format!(
-                    "error in {}.protocols.yaml: \
+                    "error in {}.test.yaml: \
                      regex parse error:\n    ^\\x$\n       ^\nerror: invalid hexadecimal digit",
                     path_to_string(&tempfile.path())?
                 )
@@ -1114,8 +1105,8 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - _
                     "
                 )?
@@ -1130,8 +1121,8 @@ mod load {
             assert_eq!(
                 test_parse_one(
                     r"
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - /bin/foo
                     "
                 )?
@@ -1148,14 +1139,14 @@ mod load {
                 test_parse(
                     &tempfile,
                     r"
-                        |protocols:
-                        |  - protocol:
+                        |tests:
+                        |  - steps:
                         |      - _
                         |      - /bin/foo
                     "
                 ),
                 format!(
-                    "error in {}.protocols.yaml: holes ('_') are only allowed as the last step",
+                    "error in {}.test.yaml: holes ('_') are only allowed as the last step",
                     path_to_string(&tempfile.path())?
                 )
             );
@@ -1170,98 +1161,96 @@ mod serialize {
     use super::*;
     use pretty_assertions::assert_eq;
 
-    fn roundtrip(protocols: Protocols) -> R<()> {
-        let yaml = protocols.serialize()?;
-        let result = Protocols::parse(yaml)?;
-        assert_eq!(result, protocols);
+    fn roundtrip(tests: Tests) -> R<()> {
+        let yaml = tests.serialize()?;
+        let result = Tests::parse(yaml)?;
+        assert_eq!(result, tests);
         Ok(())
     }
 
     #[test]
-    fn outputs_an_empty_protocols_object() -> R<()> {
-        roundtrip(Protocols::new(vec![]))
+    fn outputs_an_empty_tests_object() -> R<()> {
+        roundtrip(Tests::new(vec![]))
     }
 
     #[test]
-    fn outputs_a_single_protocol_with_no_steps() -> R<()> {
-        roundtrip(Protocols::new(vec![Protocol::empty()]))
+    fn outputs_a_single_test_with_no_steps() -> R<()> {
+        roundtrip(Tests::new(vec![Test::empty()]))
     }
 
     #[test]
-    fn outputs_a_single_protocol_with_a_single_step() -> R<()> {
-        roundtrip(Protocols::new(vec![Protocol::new(vec![
-            Step::from_string("cp")?,
-        ])]))
+    fn outputs_a_single_test_with_a_single_step() -> R<()> {
+        roundtrip(Tests::new(vec![Test::new(vec![Step::from_string("cp")?])]))
     }
 
     mod arguments {
         use super::*;
 
         #[test]
-        fn outputs_the_protocol_arguments() -> R<()> {
-            let mut protocol = Protocol::new(vec![Step::from_string("cp")?]);
-            protocol.arguments = vec!["foo".to_string()];
-            roundtrip(Protocols::new(vec![protocol]))
+        fn outputs_the_test_arguments() -> R<()> {
+            let mut test = Test::new(vec![Step::from_string("cp")?]);
+            test.arguments = vec!["foo".to_string()];
+            roundtrip(Tests::new(vec![test]))
         }
 
         #[test]
         fn works_for_arguments_with_special_characters() -> R<()> {
-            let mut protocol = Protocol::new(vec![Step::from_string("cp")?]);
-            protocol.arguments = vec!["foo bar".to_string()];
-            roundtrip(Protocols::new(vec![protocol]))
+            let mut test = Test::new(vec![Step::from_string("cp")?]);
+            test.arguments = vec!["foo bar".to_string()];
+            roundtrip(Tests::new(vec![test]))
         }
     }
 
     #[test]
-    fn outputs_the_protocol_exitcode() -> R<()> {
-        let mut protocol = Protocol::new(vec![Step::from_string("cp")?]);
-        protocol.exitcode = Some(42);
-        roundtrip(Protocols::new(vec![protocol]))
+    fn outputs_the_test_exitcode() -> R<()> {
+        let mut test = Test::new(vec![Step::from_string("cp")?]);
+        test.exitcode = Some(42);
+        roundtrip(Tests::new(vec![test]))
     }
 
     #[test]
     fn includes_the_step_exitcodes() -> R<()> {
-        let protocol = Protocol::new(vec![Step {
+        let test = Test::new(vec![Step {
             command_matcher: CommandMatcher::ExactMatch(Command::new("cp")?),
             stdout: vec![],
             exitcode: 42,
         }]);
-        roundtrip(Protocols::new(vec![protocol]))
+        roundtrip(Tests::new(vec![test]))
     }
 
     #[test]
     fn includes_the_environment() -> R<()> {
-        let mut protocol = Protocol::empty();
-        protocol.env.insert("FOO".to_string(), "bar".to_string());
-        roundtrip(Protocols::new(vec![protocol]))
+        let mut test = Test::empty();
+        test.env.insert("FOO".to_string(), "bar".to_string());
+        roundtrip(Tests::new(vec![test]))
     }
 
     #[test]
     fn includes_unmocked_commands() -> R<()> {
-        let mut protocols = Protocols::new(vec![Protocol::new(vec![])]);
-        protocols.unmocked_commands = vec![PathBuf::from("sed")];
-        roundtrip(protocols)
+        let mut tests = Tests::new(vec![Test::new(vec![])]);
+        tests.unmocked_commands = vec![PathBuf::from("sed")];
+        roundtrip(tests)
     }
 }
 
-fn find_protocol_file(executable: &Path) -> PathBuf {
+fn find_test_file(executable: &Path) -> PathBuf {
     let mut result = executable.to_path_buf().into_os_string();
     result.push(".");
-    result.push("protocols.yaml");
+    result.push("test.yaml");
     PathBuf::from(result)
 }
 
-fn read_protocols_file(protocols_file: &Path) -> R<String> {
-    if !protocols_file.exists() {
+fn read_test_file(test_file: &Path) -> R<String> {
+    if !test_file.exists() {
         Err(format!(
-            "protocol file not found: {}",
-            protocols_file.to_string_lossy()
+            "test file not found: {}",
+            test_file.to_string_lossy()
         ))?;
     }
-    Ok(match fs::read(&protocols_file) {
+    Ok(match fs::read(&test_file) {
         Err(error) => Err(format!(
             "error reading {}: {}",
-            path_to_string(&protocols_file)?,
+            path_to_string(&test_file)?,
             error
         ))?,
         Ok(file_contents) => String::from_utf8(file_contents)?,
@@ -1269,22 +1258,22 @@ fn read_protocols_file(protocols_file: &Path) -> R<String> {
 }
 
 #[cfg(test)]
-mod find_protocol_file {
+mod find_test_file {
     use super::*;
 
     #[test]
-    fn adds_the_protocols_file_extension() {
+    fn adds_the_test_file_extension() {
         assert_eq!(
-            find_protocol_file(&PathBuf::from("foo")),
-            PathBuf::from("foo.protocols.yaml")
+            find_test_file(&PathBuf::from("foo")),
+            PathBuf::from("foo.test.yaml")
         );
     }
 
     #[test]
     fn works_for_files_with_extensions() {
         assert_eq!(
-            find_protocol_file(&PathBuf::from("foo.ext")),
-            PathBuf::from("foo.ext.protocols.yaml")
+            find_test_file(&PathBuf::from("foo.ext")),
+            PathBuf::from("foo.ext.test.yaml")
         );
     }
 }
diff --git a/src/protocol/yaml.rs b/src/test_spec/yaml.rs
similarity index 100%
rename from src/protocol/yaml.rs
rename to src/test_spec/yaml.rs
diff --git a/tests/examples/bigger/script.protocols.yaml b/tests/examples/bigger/script.test.yaml
similarity index 93%
rename from tests/examples/bigger/script.protocols.yaml
rename to tests/examples/bigger/script.test.yaml
index 83646cf..23e9f4b 100644
--- a/tests/examples/bigger/script.protocols.yaml
+++ b/tests/examples/bigger/script.test.yaml
@@ -1,5 +1,5 @@
 arguments: test-file
-protocol:
+steps:
   - command: chmod +r test-file.txt
   - command: cat test-file.txt
     stdout: "should be deleted"
diff --git a/tests/examples/simple/script.protocols.yaml b/tests/examples/simple/script.test.yaml
similarity index 72%
rename from tests/examples/simple/script.protocols.yaml
rename to tests/examples/simple/script.test.yaml
index cc466c4..3be6e0d 100644
--- a/tests/examples/simple/script.protocols.yaml
+++ b/tests/examples/simple/script.test.yaml
@@ -1,3 +1,3 @@
-protocol:
+steps:
   - cp foo bar
   - rm foo
diff --git a/tests/files.rs b/tests/files.rs
index e1e1c8a..cfc1956 100644
--- a/tests/files.rs
+++ b/tests/files.rs
@@ -21,8 +21,8 @@ fn allows_to_mock_files_existence() -> R<()> {
             |fi
         ",
         r"
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - cp
             |    mockedFiles:
             |      - /foo
@@ -42,8 +42,8 @@ fn allows_to_mock_directory_existence() -> R<()> {
             |fi
         ",
         r"
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - command: cp
             |    mockedFiles:
             |      - /foo/
@@ -63,8 +63,8 @@ fn does_not_mock_existence_of_unspecified_files() -> R<()> {
             |fi
         ",
         r"
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
         ",
         Ok(()),
     )?;
diff --git a/tests/holes.rs b/tests/holes.rs
index d480d78..0ddcc50 100644
--- a/tests/holes.rs
+++ b/tests/holes.rs
@@ -17,7 +17,7 @@ use test_utils::trim_margin;
 use utils::{assert_eq_yaml, prepare_script};
 
 fn test_holes(script_code: &str, existing: &str, expected: &str) -> R<()> {
-    let (script, protocols_file) = prepare_script(script_code, existing)?;
+    let (script, test_file) = prepare_script(script_code, existing)?;
     run_main(
         &Context::new_mock(),
         &cli::Args::Scriptkeeper {
@@ -26,42 +26,42 @@ fn test_holes(script_code: &str, existing: &str, expected: &str) -> R<()> {
         },
     )?;
     assert_eq_yaml(
-        &String::from_utf8(fs::read(&protocols_file)?)?,
+        &String::from_utf8(fs::read(&test_file)?)?,
         &trim_margin(expected)?,
     )?;
     Ok(())
 }
 
 #[test]
-fn fills_in_holes_in_protocols_files() -> R<()> {
+fn fills_in_holes_in_test_files() -> R<()> {
     test_holes(
         "
             |#!/usr/bin/env bash
             |ls
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - _
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
         ",
     )
 }
 
 #[test]
-fn indicates_on_stdout_that_the_protocols_file_was_written_to() -> R<()> {
-    let (script, protocols_file) = prepare_script(
+fn indicates_on_stdout_that_the_test_file_was_written_to() -> R<()> {
+    let (script, test_file) = prepare_script(
         "
             |#!/usr/bin/env bash
             |/bin/true
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - _
         ",
     )?;
@@ -76,8 +76,8 @@ fn indicates_on_stdout_that_the_protocols_file_was_written_to() -> R<()> {
     assert_eq!(
         context.get_captured_stdout(),
         format!(
-            "Protocol holes filled in {}.\nAll tests passed.\n",
-            path_to_string(&protocols_file)?
+            "Test holes filled in {}.\nAll tests passed.\n",
+            path_to_string(&test_file)?
         )
     );
     Ok(())
@@ -85,18 +85,18 @@ fn indicates_on_stdout_that_the_protocols_file_was_written_to() -> R<()> {
 
 #[test]
 fn does_not_modify_files_without_holes() -> R<()> {
-    let (script, protocols_file) = prepare_script(
+    let (script, test_file) = prepare_script(
         "
             |#!/usr/bin/env bash
             |/bin/true
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - /bin/true
         ",
     )?;
-    let old_modification_time = fs::metadata(&protocols_file)?.modified()?;
+    let old_modification_time = fs::metadata(&test_file)?.modified()?;
     run_main(
         &Context::new_mock(),
         &cli::Args::Scriptkeeper {
@@ -104,7 +104,7 @@ fn does_not_modify_files_without_holes() -> R<()> {
             record: false,
         },
     )?;
-    let new_modification_time = fs::metadata(&protocols_file)?.modified()?;
+    let new_modification_time = fs::metadata(&test_file)?.modified()?;
     assert_eq!(new_modification_time, old_modification_time);
     Ok(())
 }
@@ -118,14 +118,14 @@ fn works_for_holes_following_specified_steps() -> R<()> {
             |ls -la
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
             |      - _
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
             |      - ls -la
         ",
@@ -133,7 +133,7 @@ fn works_for_holes_following_specified_steps() -> R<()> {
 }
 
 #[test]
-fn works_in_conjunction_with_protocols_without_holes() -> R<()> {
+fn works_in_conjunction_with_tests_without_holes() -> R<()> {
     test_holes(
         "
             |#!/usr/bin/env bash
@@ -144,26 +144,26 @@ fn works_in_conjunction_with_protocols_without_holes() -> R<()> {
             |fi
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - ls
-            |  - protocol:
+            |  - steps:
             |      - _
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - ls
-            |  - protocol:
+            |  - steps:
             |      - ls -la
         ",
     )
 }
 
 #[test]
-fn works_for_multiple_protocols_with_holes() -> R<()> {
+fn works_for_multiple_tests_with_holes() -> R<()> {
     test_holes(
         "
             |#!/usr/bin/env bash
@@ -174,30 +174,30 @@ fn works_for_multiple_protocols_with_holes() -> R<()> {
             |fi
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - _
-            |  - protocol:
+            |  - steps:
             |      - _
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - ls
-            |  - protocol:
+            |  - steps:
             |      - ls -la
         ",
     )
 }
 
-mod errors_in_protocols {
+mod errors_in_tests {
     use super::*;
     use pretty_assertions::assert_eq;
 
     #[test]
-    fn errors_in_protocol_with_hole() -> R<()> {
+    fn errors_in_test_with_hole() -> R<()> {
         let (script, _) = prepare_script(
             "
                 |#!/usr/bin/env bash
@@ -205,8 +205,8 @@ mod errors_in_protocols {
                 |ls > /dev/null
             ",
             "
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |      - ls -la
                 |      - _
             ",
@@ -227,7 +227,7 @@ mod errors_in_protocols {
     }
 
     #[test]
-    fn errors_in_protocol_without_hole() -> R<()> {
+    fn errors_in_test_without_hole() -> R<()> {
         let (script, _) = prepare_script(
             "
                 |#!/usr/bin/env bash
@@ -238,11 +238,11 @@ mod errors_in_protocols {
                 |fi
             ",
             "
-                |protocols:
+                |tests:
                 |  - arguments: foo
-                |    protocol:
+                |    steps:
                 |      - ls -foo
-                |  - protocol:
+                |  - steps:
                 |      - _
             ",
         )?;
@@ -270,15 +270,15 @@ fn preserves_script_arguments() -> R<()> {
             |ls > /dev/null
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - _
         ",
         "
-            |protocols:
+            |tests:
             |  - arguments: foo
-            |    protocol:
+            |    steps:
             |      - ls
         ",
     )
@@ -292,14 +292,14 @@ fn removes_hole_when_script_does_not_execute_more_steps() -> R<()> {
             |ls > /dev/null
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
             |      - _
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
         ",
     )
@@ -316,17 +316,17 @@ mod environment {
                 |ls $FOO
             ",
             "
-                |protocols:
+                |tests:
                 |  - env:
                 |      FOO: /tmp
-                |    protocol:
+                |    steps:
                 |      - _
             ",
             "
-                |protocols:
+                |tests:
                 |  - env:
                 |      FOO: /tmp
-                |    protocol:
+                |    steps:
                 |      - ls /tmp
             ",
         )
@@ -345,21 +345,21 @@ mod unmocked_commands {
             "
                 |unmockedCommands:
                 |  - sed
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |      - _
             ",
             "
                 |unmockedCommands:
                 |  - sed
-                |protocols:
-                |  - protocol: []
+                |tests:
+                |  - steps: []
             ",
         )
     }
 
     #[test]
-    fn excludes_unmocked_commands_from_recorded_protocols() -> R<()> {
+    fn excludes_unmocked_commands_from_recorded_tests() -> R<()> {
         test_holes(
             "
                 |#!/usr/bin/env bash
@@ -368,15 +368,15 @@ mod unmocked_commands {
             "
                 |unmockedCommands:
                 |  - ls
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |      - _
             ",
             "
                 |unmockedCommands:
                 |  - ls
-                |protocols:
-                |  - protocol: []
+                |tests:
+                |  - steps: []
             ",
         )
     }
diff --git a/tests/path.rs b/tests/path.rs
index 3d762b3..9ab193a 100644
--- a/tests/path.rs
+++ b/tests/path.rs
@@ -19,7 +19,7 @@ fn looks_up_step_executable_in_path() -> R<()> {
             |cp
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp
         ",
         Ok(()),
@@ -35,8 +35,8 @@ fn looks_up_unmocked_command_executable_in_path() -> R<()> {
             |ls > /dev/null
         ",
         r"
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
             |unmockedCommands:
             |  - ls
         ",
@@ -53,7 +53,7 @@ fn shortens_received_executable_to_file_name_when_reporting_step_error() -> R<()
             |mv
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp
         ",
         Err(&trim_margin(
@@ -75,7 +75,7 @@ fn runs_step_executable_that_is_not_in_path() -> R<()> {
             |/not/in/path
         ",
         r"
-            |protocol:
+            |steps:
             |  - /not/in/path
         ",
         Ok(()),
diff --git a/tests/recording.rs b/tests/recording.rs
index f396b0c..f841f68 100644
--- a/tests/recording.rs
+++ b/tests/recording.rs
@@ -61,28 +61,28 @@ fn test_recording(script: &str, expected: &str) -> R<()> {
 }
 
 #[test]
-fn records_an_empty_protocol() -> R<()> {
+fn records_an_empty_test() -> R<()> {
     test_recording(
         "
             |#!/usr/bin/env bash
         ",
         "
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
         ",
     )
 }
 
 #[test]
-fn records_protocol_steps() -> R<()> {
+fn records_test_steps() -> R<()> {
     test_recording(
         "
             |#!/usr/bin/env bash
             |ls >/dev/null
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - ls
         ",
     )
@@ -97,8 +97,8 @@ fn records_multiple_steps() -> R<()> {
             |ls > /dev/null
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - date
             |      - ls
         ",
@@ -113,8 +113,8 @@ fn records_command_arguments() -> R<()> {
             |mkdir -p foo
         ",
         "
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - mkdir -p foo
         ",
     )
@@ -128,8 +128,8 @@ fn records_script_exitcode() -> R<()> {
             |exit 42
         ",
         "
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
             |    exitcode: 42
         ",
     )
@@ -144,8 +144,8 @@ fn records_command_exitcodes() -> R<()> {
             |true
         "#,
         r#"
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |      - command: bash -c "exit 42"
             |        exitcode: 42
         "#,
diff --git a/tests/run.rs b/tests/run.rs
index 7b4cad9..b97dc0c 100644
--- a/tests/run.rs
+++ b/tests/run.rs
@@ -24,7 +24,7 @@ fn simple() -> R<()> {
             |cp
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp
         ",
         Ok(()),
@@ -45,8 +45,8 @@ fn does_not_execute_the_commands() -> R<()> {
         ),
         &format!(
             "
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |      - /usr/bin/touch {}
             ",
             path_to_string(&testfile.path())?,
@@ -74,8 +74,8 @@ fn works_for_longer_file_names() -> R<()> {
         ),
         &format!(
             "
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |      - {}
             ",
             &long_command_path
@@ -94,8 +94,8 @@ fn can_specify_interpreter() -> R<()> {
             |`true`
         ",
         r#"
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |    - "true"
             |interpreter: /usr/bin/ruby
         "#,
@@ -112,8 +112,8 @@ fn allows_to_match_command_with_regex() -> R<()> {
             |cp 1
         ",
         r#"
-            |protocols:
-            |  - protocol:
+            |tests:
+            |  - steps:
             |    - regex: cp \d
         "#,
         Ok(()),
@@ -132,13 +132,13 @@ mod yaml_parse_errors {
             &Context::new_mock(),
             &script,
             r"
-                |protocol: 42
+                |steps: 42
             ",
         );
         assert_error!(
             result,
             format!(
-                "error in {}.protocols.yaml: \
+                "error in {}.test.yaml: \
                  expected: array, got: Integer(42)",
                 path_to_string(&script.path())?
             )
@@ -153,15 +153,15 @@ mod yaml_parse_errors {
             &Context::new_mock(),
             &script,
             r"
-                |protocol: - boo
+                |steps: - boo
             ",
         );
         assert_error!(
             result,
             format!(
-                "invalid YAML in {}.protocols.yaml: \
+                "invalid YAML in {}.test.yaml: \
                  block sequence entries are not allowed \
-                 in this context at line 1 column 11",
+                 in this context at line 1 column 8",
                 path_to_string(&script.path())?
             )
         );
@@ -178,7 +178,7 @@ fn multiple() -> R<()> {
             |ls > /dev/null
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp
             |  - ls
         ",
@@ -195,7 +195,7 @@ fn failing() -> R<()> {
             |mv
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp
         ",
         Err(&trim_margin(
@@ -218,7 +218,7 @@ fn failing_later() -> R<()> {
             |mv
         ",
         r"
-            |protocol:
+            |steps:
             |  - ls
             |  - cp
         ",
@@ -260,7 +260,7 @@ mod nice_user_errors {
             &Context::new_mock(),
             &script,
             r"
-                |protocol:
+                |steps:
                 |  - cp
             ",
         );
@@ -295,7 +295,7 @@ mod nice_user_errors {
             &Context::new_mock(),
             &script,
             r"
-                |protocol:
+                |steps:
                 |  - cp
             ",
         );
@@ -330,8 +330,8 @@ mod nice_user_errors {
             &Context::new_mock(),
             &script,
             r"
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |    - cp
                 |interpreter: /usr/bin/foo
             ",
@@ -365,7 +365,7 @@ mod arguments {
                 |cp foo
             ",
             r"
-                |protocol:
+                |steps:
                 |  - cp foo
             ",
             Ok(()),
@@ -381,7 +381,7 @@ mod arguments {
                 |cp bar
             ",
             r"
-                |protocol:
+                |steps:
                 |  - cp foo
             ",
             Err(&trim_margin(
@@ -403,7 +403,7 @@ mod arguments {
                 |cp "foo bar"
             "#,
             r#"
-                |protocol:
+                |steps:
                 |  - cp "foo bar"
             "#,
             Ok(()),
@@ -419,7 +419,7 @@ mod arguments {
                 |cp foo bar
             ",
             r#"
-                |protocol:
+                |steps:
                 |  - cp "foo bar"
             "#,
             Err(&trim_margin(
@@ -443,7 +443,7 @@ fn reports_the_first_error() -> R<()> {
             |mv second
         ",
         r"
-            |protocol:
+            |steps:
             |  - cp first
             |  - cp second
         ",
@@ -469,7 +469,7 @@ mod mismatch_in_number_of_commands {
                 |ls
             ",
             r"
-                |protocol:
+                |steps:
                 |  - ls
                 |  - cp
             ",
@@ -493,13 +493,13 @@ mod mismatch_in_number_of_commands {
                 |cp
             ",
             r"
-                |protocol:
+                |steps:
                 |  - ls
             ",
             Err(&trim_margin(
                 "
                     |error:
-                    |  expected: <protocol end>
+                    |  expected: <script termination>
                     |  received: cp
                 ",
             )?),
@@ -520,7 +520,7 @@ mod stdout {
                 |cp $output
             ",
             r"
-                |protocol:
+                |steps:
                 |  - command: cp
                 |    stdout: test_output
                 |  - cp test_output
@@ -539,7 +539,7 @@ mod stdout {
                 |cp $output
             ",
             r#"
-                |protocol:
+                |steps:
                 |  - command: cp
                 |    stdout: 'foo"'
                 |  - 'cp foo\"'
@@ -558,7 +558,7 @@ mod stdout {
                 |cp "$output"
             "#,
             r#"
-                |protocol:
+                |steps:
                 |  - command: cp
                 |    stdout: "foo\nbar"
                 |  - 'cp foo\nbar'
@@ -578,7 +578,7 @@ fn pass_arguments_into_tested_script() -> R<()> {
         ",
         r"
             |arguments: foo
-            |protocol:
+            |steps:
             |  - cp foo
         ",
         Ok(()),
@@ -586,7 +586,7 @@ fn pass_arguments_into_tested_script() -> R<()> {
     Ok(())
 }
 
-mod multiple_protocols {
+mod multiple_tests {
     use super::*;
 
     #[test]
@@ -598,10 +598,10 @@ mod multiple_protocols {
             ",
             r"
                 |- arguments: foo
-                |  protocol:
+                |  steps:
                 |    - cp foo
                 |- arguments: bar
-                |  protocol:
+                |  steps:
                 |    - cp bar
             ",
             Ok(()),
@@ -617,17 +617,17 @@ mod multiple_protocols {
                 |mv
             ",
             r"
-                |- protocol:
+                |- steps:
                 |    - cp
-                |- protocol:
+                |- steps:
                 |    - cp
             ",
             Err(&trim_margin(
                 "
-                    |error in protocol 1:
+                    |error in test 1:
                     |  expected: cp
                     |  received: mv
-                    |error in protocol 2:
+                    |error in test 2:
                     |  expected: cp
                     |  received: mv
                 ",
@@ -644,16 +644,16 @@ mod multiple_protocols {
                 |mv
             ",
             r"
-                |- protocol:
+                |- steps:
                 |    - mv
-                |- protocol:
+                |- steps:
                 |    - cp
             ",
             Err(&trim_margin(
                 "
-                    |protocol 1:
+                    |test 1:
                     |  Tests passed.
-                    |error in protocol 2:
+                    |error in test 2:
                     |  expected: cp
                     |  received: mv
                 ",
@@ -676,7 +676,7 @@ mod environment {
             r"
                 |env:
                 |  FOO: test-env-var
-                |protocol:
+                |steps:
                 |  - cp test-env-var
             ",
             Ok(()),
@@ -693,7 +693,7 @@ mod environment {
                 |cp $FOO
             ",
             r"
-                |protocol:
+                |steps:
                 |  - cp
             ",
             Ok(()),
@@ -710,7 +710,7 @@ fn detects_running_commands_from_ruby_scripts() -> R<()> {
             |`ls`
         ",
         r"
-            |protocol:
+            |steps:
             |  - ls
         ",
         Ok(()),
@@ -731,7 +731,7 @@ mod mocked_exitcodes {
                 |fi
             ",
             r"
-                |protocol:
+                |steps:
                 |  - command: grep foo
                 |    exitcode: 1
                 |  - ls
@@ -751,7 +751,7 @@ mod mocked_exitcodes {
                 |fi
             ",
             r"
-                |protocol:
+                |steps:
                 |  - command: grep foo
                 |    exitcode: 0
                 |  - ls
@@ -771,7 +771,7 @@ mod mocked_exitcodes {
                 |fi
             ",
             r"
-                |protocol:
+                |steps:
                 |  - grep foo
                 |  - ls
             ",
@@ -789,7 +789,7 @@ mod mocked_exitcodes {
                 |ls $?
             ",
             r"
-                |protocol:
+                |steps:
                 |  - command: grep foo
                 |    exitcode: 42
                 |  - ls 42
@@ -812,7 +812,7 @@ mod working_directory {
             ",
             r"
                 |cwd: /foo
-                |protocol:
+                |steps:
                 |  - ls /foo/file
             ",
             Ok(()),
@@ -829,7 +829,7 @@ mod working_directory {
             ",
             r"
                 |cwd: /foo/bar/baz/foo/bar/baz/foo/bar/baz/foo
-                |protocol:
+                |steps:
                 |  - ls /foo/bar/baz/foo/bar/baz/foo/bar/baz/foo/file
             ",
             Ok(()),
@@ -847,7 +847,7 @@ mod working_directory {
             ",
             &format!(
                 r"
-                    |protocol:
+                    |steps:
                     |  - ls {}/foo
                 ",
                 path_to_string(&cwd)?
@@ -869,7 +869,7 @@ mod expected_exitcode {
                 |exit 42
             ",
             r"
-                |protocol: []
+                |steps: []
             ",
             Err(&trim_margin(
                 "
@@ -890,7 +890,7 @@ mod expected_exitcode {
                 |exit 42
             ",
             r"
-                |protocol: []
+                |steps: []
                 |exitcode: 42
             ",
             Ok(()),
@@ -906,7 +906,7 @@ mod expected_exitcode {
                 |true
             ",
             r"
-                |protocol: []
+                |steps: []
                 |exitcode: 42
             ",
             Err(&trim_margin(
@@ -932,8 +932,8 @@ mod unmocked_commands {
                 |ls $(dirname dir/file)
             ",
             r"
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |    - ls dir
                 |unmockedCommands:
                 |  - dirname
@@ -951,8 +951,8 @@ mod unmocked_commands {
                 |ls $(dirname dir/file)
             ",
             r"
-                |protocols:
-                |  - protocol:
+                |tests:
+                |  - steps:
                 |    - dirname dir/file
                 |    - ls dir
                 |unmockedCommands:
diff --git a/tests/stdio.rs b/tests/stdio.rs
index ebef19d..3cafb1d 100644
--- a/tests/stdio.rs
+++ b/tests/stdio.rs
@@ -28,8 +28,8 @@ fn relays_stdout_from_the_tested_script_to_the_user() -> R<()> {
         &context,
         &script,
         r"
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
         ",
     )?;
     assert_eq!(context.get_captured_stdout(), "foo\nAll tests passed.\n");
@@ -46,8 +46,8 @@ fn relays_stderr_from_the_tested_script_to_the_user() -> R<()> {
             |echo foo 1>&2
         ",
         r"
-            |protocols:
-            |  - protocol: []
+            |tests:
+            |  - steps: []
         ",
         Ok(()),
     )?;
@@ -66,8 +66,8 @@ mod expected_stderr {
                 |echo bar 1>&2
             ",
             r#"
-                |protocols:
-                |  - protocol: []
+                |tests:
+                |  - steps: []
                 |    stderr: "foo\n"
             "#,
             Err(&trim_margin(
@@ -89,8 +89,8 @@ mod expected_stderr {
                 |echo foo 1>&2
             ",
             r#"
-                |protocols:
-                |  - protocol: []
+                |tests:
+                |  - steps: []
                 |    stderr: "foo\n"
             "#,
             Ok(()),
@@ -105,8 +105,8 @@ mod expected_stderr {
                 |#!/usr/bin/env bash
             ",
             r#"
-                |protocols:
-                |  - protocol: []
+                |tests:
+                |  - steps: []
                 |    stderr: "foo\n"
             "#,
             Err(&trim_margin(
diff --git a/tests/utils.rs b/tests/utils.rs
index 0bc8bf8..e6602ae 100644
--- a/tests/utils.rs
+++ b/tests/utils.rs
@@ -22,21 +22,21 @@ fn compare_results(result: (ExitCode, String), expected: Result<(), &str>) {
     assert_eq!(result, expected_output);
 }
 
-pub fn prepare_script(script_code: &str, protocol: &str) -> R<(TempFile, PathBuf)> {
+pub fn prepare_script(script_code: &str, tests: &str) -> R<(TempFile, PathBuf)> {
     let script = TempFile::write_temp_script(trim_margin(script_code)?.as_bytes())?;
-    let protocols_file = format!("{}.protocols.yaml", path_to_string(&script.path())?);
-    fs::write(&protocols_file, trim_margin(protocol)?)?;
-    Ok((script, PathBuf::from(protocols_file)))
+    let test_file = format!("{}.test.yaml", path_to_string(&script.path())?);
+    fs::write(&test_file, trim_margin(tests)?)?;
+    Ok((script, PathBuf::from(test_file)))
 }
 
 pub fn test_run_with_tempfile(
     context: &Context,
     script: &TempFile,
-    protocol: &str,
+    tests: &str,
 ) -> R<(ExitCode, String)> {
     fs::write(
-        script.path().with_extension("protocols.yaml"),
-        trim_margin(protocol)?,
+        script.path().with_extension("test.yaml"),
+        trim_margin(tests)?,
     )?;
     let exitcode = run_scriptkeeper(context, &script.path())?;
     Ok((exitcode, context.get_captured_stdout()))
@@ -45,17 +45,17 @@ pub fn test_run_with_tempfile(
 pub fn test_run_with_context(
     context: &Context,
     script_code: &str,
-    protocol: &str,
+    tests: &str,
     expected: Result<(), &str>,
 ) -> R<()> {
     let script = TempFile::write_temp_script(trim_margin(script_code)?.as_bytes())?;
-    let result = test_run_with_tempfile(context, &script, protocol)?;
+    let result = test_run_with_tempfile(context, &script, tests)?;
     compare_results(result, expected);
     Ok(())
 }
 
-pub fn test_run(script_code: &str, protocol: &str, expected: Result<(), &str>) -> R<()> {
-    test_run_with_context(&Context::new_mock(), script_code, protocol, expected)
+pub fn test_run(script_code: &str, tests: &str, expected: Result<(), &str>) -> R<()> {
+    test_run_with_context(&Context::new_mock(), script_code, tests, expected)
 }
 
 pub fn assert_eq_yaml(result: &str, expected: &str) -> R<()> {