diff --git a/load.bash b/load.bash
index c67d9e8..a89df36 100644
--- a/load.bash
+++ b/load.bash
@@ -31,3 +31,4 @@ source "$(dirname "${BASH_SOURCE[0]}")/src/assert_line.bash"
source "$(dirname "${BASH_SOURCE[0]}")/src/refute_line.bash"
source "$(dirname "${BASH_SOURCE[0]}")/src/assert_regex.bash"
source "$(dirname "${BASH_SOURCE[0]}")/src/refute_regex.bash"
+source "$(dirname "${BASH_SOURCE[0]}")/src/assert_equals_golden.bash"
diff --git a/src/assert_equals_golden.bash b/src/assert_equals_golden.bash
new file mode 100644
index 0000000..a1523a0
--- /dev/null
+++ b/src/assert_equals_golden.bash
@@ -0,0 +1,866 @@
+# assert_equals_golden
+# ============
+#
+# Summary: Fail if the actual and golden file contents are not equal.
+#
+# Usage: assert_equals_golden [-e | --regexp | -d | --diff] [--stdin] [--allow-empty] [--] [- | <actual>] <golden file path>
+#
+# Options:
+# -e, --regexp Treat file contents of <golden file path> as an multiline extended regular expression.
+# -d, --diff Displays `diff` between <actual> and golden contents instead of full strings.
+# -, --stdin Read <actual> value from STDIN. Do not pass <actual> if set.
+# <actual> The value being compared. May be `-` to use STDIN. Omit if `--stdin` is passed.
+# <golden file path> A file that has contents which must match against <actual>.
+#
+# ```bash
+# @test 'assert_equals_golden()' {
+# assert_equals_golden 'have' 'some/path/golden_file.txt'
+# }
+# ```
+#
+# IO:
+# STDIN - actual value, if `--stdin` or `-` is supplied.
+# STDERR - expected and actual values, or their diff, on failure
+# Globals:
+# BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE - The golden file's contents will be updated to <actual> if it did not match.
+# Returns:
+# 0 - if <actual> is equal to file contents in <golden file path>
+# 1 - otherwise
+#
+# Golden files hold the entirety of the expected output.
+# Contents will properly/consistently match to empty lines / trailing new lines (when used with `run --keep-empty-lines` or similar).
+# Golden files are, by default, not allowed to be empty. This is to catch common authoring errors. If intented, this can be overridden with `--allow-empty`.
+#
+# Golden files have a number of benefits when used for asserting against output, including:
+# * WYSIWYG plaintext output assertions (separating asserted output from test case logic).
+# * Test failure output that is searchable (asserted output is checked into repo as files).
+# * Clear file diffs of test assertions during merge / code review.
+# * Terse assertions in test cases (single assert instead of many verbose `assert_line` and `refute_line` for every line of output).
+# * Reusable golden files (declared once, used for many test cases).
+# * Clear intention (same exact expected output) when asserted against same goldens in multiple test cases.
+# * Can be clearly diff'd across multiple lines in failure message(s).
+# * Easily updated.
+#
+# The assertion string target, <actual>, can instead be supplied via STDIN.
+# If `--stdin` is supplied, or if `-` is given as <actual>, STDIN will be read for the checked string.
+# When suppliying `--stdin`, only 1 argument (<golden file path>) should be supplied.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set, failed assertions will result in the golden file being updated.
+# The golden file contents is updated to be able to pass upon subsequent runs.
+# All tests that update goldens still fails (enforcing that all passing tests are achieved with pre-existing correct golden).
+# This is set via an environment variable to allow mass golden file updates across many tests.
+#
+# ## Literal matching
+#
+# On failure, the expected and actual values are displayed. Line count is always displayed.
+#
+# ```
+# -- value does not match golden --
+# golden contents (1 lines):
+# want
+# actual value (1 lines):
+# have
+# --
+# ```
+#
+# If `--diff` is given, the output is changed to `diff` between <actual> and the golden file contents.
+#
+# ```
+# -- value does not match golden --
+# 1c1
+# < have
+# ---
+# > want
+# --
+# ```
+#
+# ## Regular expression matching
+#
+# If `--regexp` is given, the golden file contents is treated as a multiline extended regular expression.
+# This allows for volatile output (e.g. timestamps, identifiers) and/or secrets to be removed from golden files, but still constrained for proper asserting.
+# Regular expression special characters (`][\.()*+?{}|^$\\`), when used as literals, must be escaped in the golden file.
+# The regular expression golden file contents respects `\n` characters and expressions which span multiple lines.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set with `--regexp`, special logic is used to reuse lines where possible.
+# Each line in the existing golden will attempt to match to the line of <actual>, preferring longer lines.
+# If no pre-existing golden line matches, that line will be updated with the exact line string from <actual>.
+# Not all lines can be reused (e.g. multiline expressions), but the golden file can be manually changed after automatic update.
+#
+# `--diff` is not supported with `--regexp`.
+#
+assert_equals_golden() {
+ local -i is_mode_regexp=0
+ local -i show_diff=0
+ local -i use_stdin_set_by_opt=0
+ local -i use_stdin_set_by_arg=0
+ local -i allow_empty=0
+
+ while (( $# > 0 )); do
+ case "$1" in
+ -e|--regexp)
+ is_mode_regexp=1
+ shift
+ ;;
+ -d|--diff)
+ show_diff=1;
+ shift
+ ;;
+ --stdin)
+ use_stdin_set_by_opt=1;
+ shift
+ ;;
+ --allow-empty)
+ allow_empty=1
+ shift
+ ;;
+ --)
+ shift
+ break
+ ;;
+ -)
+ use_stdin_set_by_arg=1
+ break
+ ;;
+ --*=|-*)
+ echo "Unsupported flag '$1'." \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ ;;
+ *)
+ break
+ ;;
+ esac
+ done
+
+ if (( use_stdin_set_by_opt )) && [ $# -ne 1 ]; then
+ echo "Incorrect number of arguments: $#. Using stdin, expecting 1 argument." \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ elif (( ! use_stdin_set_by_opt )) && [ $# -ne 2 ] ; then
+ echo "Incorrect number of arguments: $#. Expected 2 arguments." \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ if (( show_diff )) && (( is_mode_regexp )); then
+ echo "\`--diff' not supported with \`--regexp'" \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local value="$1"
+ local golden_file_path="${2-}"
+ if (( use_stdin_set_by_opt )) || (( use_stdin_set_by_arg )); then
+ value="$(cat - && printf '.')"
+ value="${value%.}"
+ fi
+ if (( use_stdin_set_by_opt )); then
+ golden_file_path="$1"
+ fi
+
+ local -r -i update_goldens_on_failure="${BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE:+1}"
+
+ if [ -z "$golden_file_path" ]; then
+ echo "Golden file path was not given or it was empty." \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+ if [ ! -e "$golden_file_path" ]; then
+ echo "Golden file was not found. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local golden_file_contents=
+ # Load the contents from the file.
+ # Append a period (to be removed on the next line) so that trailing new lines are preserved.
+ golden_file_contents="$(cat "$golden_file_path" 2>/dev/null && printf '.')"
+ if (( $? != 0 )); then
+ echo "Failed to read golden file. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+ golden_file_contents="${golden_file_contents%.}"
+ if [ -z "$golden_file_contents" ] && ! (( allow_empty )); then
+ echo "Golden file contents is empty. This may be an authoring error. Use \`--allow-empty\` if this is intentional." \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local -i assert_failed=0
+ if (( is_mode_regexp )); then
+ if [[ ! '' =~ ^${golden_file_contents}$ ]] && [[ '' =~ ^${golden_file_contents}$ ]] || (( $? == 2 )); then
+ echo "Invalid extended regular expression in golden file: \`$golden_file_contents'" \
+ | batslib_decorate 'ERROR: assert_equals_golden' \
+ | fail
+ return $?
+ elif ! [[ "$value" =~ ^${golden_file_contents}$ ]]; then
+ assert_failed=1
+ fi
+ elif [[ "$value" != "$golden_file_contents" ]]; then
+ assert_failed=1
+ fi
+
+ if (( assert_failed )); then
+ if (( show_diff )); then
+ {
+ echo "Golden file: $golden_file_path"
+ diff <(echo "$value") <(echo "$golden_file_contents")
+ } \
+ | batslib_decorate 'value does not match golden' \
+ | fail
+ elif (( is_mode_regexp )); then
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual value' "$value"
+ } \
+ | batslib_decorate 'value does not match regexp golden' \
+ | fail
+ else
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual value' "$value"
+ } \
+ | batslib_decorate 'value does not match golden' \
+ | fail
+ fi
+
+ if (( update_goldens_on_failure )); then
+ if ! (( is_mode_regexp )); then
+ # Non-regex golden update is straight forward.
+ printf '%s' "$value" 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+ else
+ # To do a best-approximation for regex goldens,
+ # try and use existing lines as a library for updated lines (preferring longer lines).
+ # This is done line by line on the asserted value.
+ # Unfortunately, this does not handle multi-line regex in the golden (e.g. `(.*\n){10}`).
+ # Any line guess which is not preferred can be manually corrected/updated by the author.
+ local -a output_lines=()
+ local -a sorted_golden_lines=()
+ local temp=
+ while IFS='' read -r temp; do
+ output_lines+=("$temp")
+ done < <(printf '%s' "$value" ; printf '\n')
+ while IFS='' read -r temp; do
+ sorted_golden_lines+=("$temp")
+ done < <(echo "$golden_file_contents" | awk '{ print length, $0 }' | sort -nrs | cut -d" " -f 2- ; printf '\n')
+ # First, clear out the golden file's contents (so new data can just be appended below).
+ : 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_equals_golden' \
+ | fail
+ return $?
+ fi
+ # Go line by line over the output, looking for the best suggested replacement.
+ local best_guess_for_line=
+ for line_in_output in "${output_lines[@]}"; do
+ # Default the output line itself as the best guess for the new golden.
+ # Though, the output line needs to be properly escaped for when being used in regex matching (on subsequent runs of the test).
+ best_guess_for_line="$(echo "$line_in_output" | sed -E 's/([][\.()*+?{}|^$\\])/\\\1/g')"
+ for line_in_golden in "${sorted_golden_lines[@]}"; do
+ if [[ "$line_in_output" =~ ^${line_in_golden}$ ]]; then
+ # If there's a line from the previous golden output that matches, use that is the best guess instead.
+ # No need to escape special characters, as `line_in_golden` is already in proper form.
+ best_guess_for_line="$line_in_golden"
+ break
+ fi
+ done
+ if [ -s "$golden_file_path" ]; then
+ printf '\n' >> "$golden_file_path"
+ fi
+ printf '%s' "$best_guess_for_line" >> "$golden_file_path"
+ done
+ fi
+ echo "Golden file updated after mismatch." \
+ | batslib_decorate 'FAIL: assert_equals_golden' \
+ | fail
+ fi
+ fi
+ return $assert_failed
+}
+
+# assert_output_equals_golden
+# ============
+#
+# Summary: Fail if the `output` environment variable and golden file contents are not equal.
+#
+# Usage: assert_output_equals_golden [-e | --regexp | -d | --diff] [--allow-empty] [--] <golden file path>
+#
+# Options:
+# -e, --regexp Treat file contents of <golden file path> as an multiline extended regular expression.
+# -d, --diff Displays `diff` between `output` and golden contents instead of full strings.
+# <golden file path> A file that has contents which must match against `output`.
+#
+# ```bash
+# @test 'assert_output_equals_golden()' {
+# run echo 'have'
+# assert_output_equals_golden 'some/path/golden_file.txt'
+# }
+# ```
+#
+# IO:
+# STDERR - expected and actual outputs, or their diff, on failure
+# Globals:
+# output - the actual output asserted against golden file contents.
+# BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE - The golden file's contents will be updated to `output` if it did not match.
+# Returns:
+# 0 - if `output` is equal to file contents in <golden file path>
+# 1 - otherwise
+#
+# Golden files hold the entirety of the expected output.
+# Contents will properly/consistently match to empty lines / trailing new lines (when used with `run --keep-empty-lines` or similar).
+# Golden files are, by default, not allowed to be empty. This is to catch common authoring errors. If intented, this can be overridden with `--allow-empty`.
+#
+# Golden files have a number of benefits when used for asserting against output, including:
+# * WYSIWYG plaintext output assertions (separating asserted output from test case logic).
+# * Test failure output that is searchable (asserted output is checked into repo as files).
+# * Clear file diffs of test assertions during merge / code review.
+# * Terse assertions in test cases (single assert instead of many verbose `assert_line` and `refute_line` for every line of output).
+# * Reusable golden files (declared once, used for many test cases).
+# * Clear intention (same exact expected output) when asserted against same goldens in multiple test cases.
+# * Can be clearly diff'd across multiple lines in failure message(s).
+# * Easily updated.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set, failed assertions will result in the golden file being updated.
+# The golden file contents is updated to be able to pass upon subsequent runs.
+# All tests that update goldens still fails (enforcing that all passing tests are achieved with pre-existing correct golden).
+# This is set via an environment variable to allow mass golden file updates across many tests.
+#
+# ## Literal matching
+#
+# On failure, the expected and actual output are displayed. Line count is always displayed.
+#
+# ```
+# -- output does not match golden --
+# golden contents (1 lines):
+# want
+# actual output (1 lines):
+# have
+# --
+# ```
+#
+# If `--diff` is given, the output is changed to `diff` between `output` and the golden file contents.
+#
+# ```
+# -- output does not match golden --
+# 1c1
+# < have
+# ---
+# > want
+# --
+# ```
+#
+# ## Regular expression matching
+#
+# If `--regexp` is given, the golden file contents is treated as a multiline extended regular expression.
+# This allows for volatile output (e.g. timestamps, identifiers) and/or secrets to be removed from golden files, but still constrained for proper asserting.
+# Regular expression special characters (`][\.()*+?{}|^$\\`), when used as literals, must be escaped in the golden file.
+# The regular expression golden file contents respects `\n` characters and expressions which span multiple lines.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set with `--regexp`, special logic is used to reuse lines where possible.
+# Each line in the existing golden will attempt to match to the line of <actual>, preferring longer lines.
+# If no pre-existing golden line matches, that line will be updated with the exact line string from <actual>.
+# Not all lines can be reused (e.g. multiline expressions), but the golden file can be manually changed after automatic update.
+#
+# `--diff` is not supported with `--regexp`.
+#
+assert_output_equals_golden() {
+ local -i is_mode_regexp=0
+ local -i show_diff=0
+ local -i allow_empty=0
+ : "${output?}"
+
+ while (( "$#" )); do
+ case "$1" in
+ -e|--regexp)
+ is_mode_regexp=1
+ shift
+ ;;
+ -d|--diff)
+ show_diff=1;
+ shift
+ ;;
+ --allow-empty)
+ allow_empty=1
+ shift
+ ;;
+ --)
+ shift
+ break
+ ;;
+ --*=|-*)
+ echo "Unsupported flag '$1'." \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ ;;
+ *)
+ break
+ ;;
+ esac
+ done
+
+ if [ $# -ne 1 ]; then
+ echo "Incorrect number of arguments: $#. Expected 1 argument." \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ if (( show_diff )) && (( is_mode_regexp )); then
+ echo "\`--diff' not supported with \`--regexp'" \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local -r golden_file_path="${1-}"
+ local -r -i update_goldens_on_failure="${BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE:-0}"
+
+ if [ -z "$golden_file_path" ]; then
+ echo "Golden file path was not given or it was empty." \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+ if [ ! -e "$golden_file_path" ]; then
+ echo "Golden file was not found. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local golden_file_contents=
+ # Load the contents from the file.
+ # Append a period (to be removed on the next line) so that trailing new lines are preserved.
+ golden_file_contents="$(cat "$golden_file_path" 2>/dev/null && printf '.')"
+ if [ $? -ne 0 ]; then
+ echo "Failed to read golden file. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+ golden_file_contents="${golden_file_contents%.}"
+ if [ -z "$golden_file_contents" ] && ! (( allow_empty )); then
+ echo "Golden file contents is empty. This may be an authoring error. Use \`--allow-empty\` if this is intentional." \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local -i assert_failed=0
+ if (( is_mode_regexp )); then
+ if [[ ! '' =~ ^${golden_file_contents}$ ]] && [[ '' =~ ^${golden_file_contents}$ ]] || (( $? == 2 )); then
+ echo "Invalid extended regular expression in golden file: \`$golden_file_contents'" \
+ | batslib_decorate 'ERROR: assert_output_equals_golden' \
+ | fail
+ return $?
+ elif ! [[ "$output" =~ ^${golden_file_contents}$ ]]; then
+ assert_failed=1
+ fi
+ elif [[ "$output" != "$golden_file_contents" ]]; then
+ assert_failed=1
+ fi
+
+ if (( assert_failed )); then
+ if (( show_diff )); then
+ {
+ echo "Golden file: $golden_file_path"
+ diff <(echo "$output") <(echo "$golden_file_contents")
+ } \
+ | batslib_decorate 'output does not match golden' \
+ | fail
+ elif (( is_mode_regexp )); then
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual output' "$output"
+ } \
+ | batslib_decorate 'output does not match regexp golden' \
+ | fail
+ else
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual output' "$output"
+ } \
+ | batslib_decorate 'output does not match golden' \
+ | fail
+ fi
+
+ if (( update_goldens_on_failure )); then
+ if ! (( is_mode_regexp )); then
+ # Non-regex golden update is straight forward.
+ printf '%s' "$output" 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+ else
+ # To do a best-approximation for regex goldens,
+ # try and use existing lines as a library for updated lines (preferring longer lines).
+ # This is done line by line on the output.
+ # Unfortunately, this does not handle multi-line regex in the golden (e.g. `(.*\n){10}`).
+ # Any line guess which is not preferred can be manually corrected/updated by the author.
+ local -a output_lines=()
+ local -a sorted_golden_lines=()
+ local temp=
+ while IFS='' read -r temp; do
+ output_lines+=("$temp")
+ done < <(printf '%s' "$output" ; printf '\n')
+ while IFS='' read -r temp; do
+ sorted_golden_lines+=("$temp")
+ done < <(echo "$golden_file_contents" | awk '{ print length, $0 }' | sort -nrs | cut -d" " -f 2- ; printf '\n')
+ # First, clear out the golden file's contents (so new data can just be appended below).
+ : 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_output_equals_golden' \
+ | fail
+ return $?
+ fi
+ # Go line by line over the output, looking for the best suggested replacement.
+ local best_guess_for_line=
+ for line_in_output in "${output_lines[@]}"; do
+ # Default the output line itself as the best guess for the new golden.
+ # Though, the output line needs to be properly escaped for when being used in regex matching (on subsequent runs of the test).
+ best_guess_for_line="$(echo "$line_in_output" | sed -E 's/([][\.()*+?{}|^$\\])/\\\1/g')"
+ for line_in_golden in "${sorted_golden_lines[@]}"; do
+ if [[ "$line_in_output" =~ ^${line_in_golden}$ ]]; then
+ # If there's a line from the previous golden output that matches, use that is the best guess instead.
+ # No need to escape special characters, as `line_in_golden` is already in proper form.
+ best_guess_for_line="$line_in_golden"
+ break
+ fi
+ done
+ if [ -s "$golden_file_path" ]; then
+ printf '\n' >> "$golden_file_path"
+ fi
+ printf '%s' "$best_guess_for_line" >> "$golden_file_path"
+ done
+ fi
+ echo "Golden file updated after mismatch." \
+ | batslib_decorate 'FAIL: assert_output_equals_golden' \
+ | fail
+ fi
+ fi
+ return $assert_failed
+}
+
+# assert_file_equals_golden
+# ============
+#
+# Summary: Fail if the target file and golden file contents are not equal.
+#
+# Usage: assert_file_equals_golden [-e | --regexp | -d | --diff] [--allow-empty] [--] <target file path> <golden file path>
+#
+# Options:
+# -e, --regexp Treat file contents of <golden file path> as an multiline extended regular expression.
+# -d, --diff Displays `diff` between target file and golden contents instead of full strings.
+# <golden file path> A file that has contents which must match against the target file's contents.
+#
+# ```bash
+# @test 'assert_file_equals_golden()' {
+# run echo 'have'
+# assert_file_equals_golden 'generated/file.txt' 'some/path/golden_file.txt'
+# }
+# ```
+#
+# IO:
+# STDERR - expected and actual outputs, or their diff, on failure
+# Globals:
+# BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE - The golden file's contents will be updated to the target file's contents if it did not match.
+# Returns:
+# 0 - if <target file path> contents is equal to file contents in <golden file path>
+# 1 - otherwise
+#
+# Golden files hold the entirety of the expected output.
+# Contents will properly/consistently match to empty lines / trailing new lines (when used with `run --keep-empty-lines` or similar).
+# Golden files are, by default, not allowed to be empty. This is to catch common authoring errors. If intented, this can be overridden with `--allow-empty`.
+#
+# Golden files have a number of benefits when used for asserting against output, including:
+# * WYSIWYG plaintext output assertions (separating asserted output from test case logic).
+# * Test failure output that is searchable (asserted output is checked into repo as files).
+# * Clear file diffs of test assertions during merge / code review.
+# * Terse assertions in test cases (single assert instead of many verbose `assert_line` and `refute_line` for every line of output).
+# * Reusable golden files (declared once, used for many test cases).
+# * Clear intention (same exact expected output) when asserted against same goldens in multiple test cases.
+# * Can be clearly diff'd across multiple lines in failure message(s).
+# * Easily updated.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set, failed assertions will result in the golden file being updated.
+# The golden file contents is updated to be able to pass upon subsequent runs.
+# All tests that update goldens still fails (enforcing that all passing tests are achieved with pre-existing correct golden).
+# This is set via an environment variable to allow mass golden file updates across many tests.
+#
+# ## Literal matching
+#
+# On failure, the expected and actual output are displayed. Line count is always displayed.
+#
+# ```
+# -- file contents does not match golden --
+# golden contents (1 lines):
+# want
+# actual file contents (1 lines):
+# have
+# --
+# ```
+#
+# If `--diff` is given, the output is changed to `diff` between target file and the golden file contents.
+#
+# ```
+# -- file contents does not match golden --
+# 1c1
+# < have
+# ---
+# > want
+# --
+# ```
+#
+# ## Regular expression matching
+#
+# If `--regexp` is given, the golden file contents is treated as a multiline extended regular expression.
+# This allows for volatile output (e.g. timestamps, identifiers) and/or secrets to be removed from golden files, but still constrained for proper asserting.
+# Regular expression special characters (`][\.()*+?{}|^$\\`), when used as literals, must be escaped in the golden file.
+# The regular expression golden file contents respects `\n` characters and expressions which span multiple lines.
+#
+# If the `BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE` environment variable is set with `--regexp`, special logic is used to reuse lines where possible.
+# Each line in the existing golden will attempt to match to the line of <actual>, preferring longer lines.
+# If no pre-existing golden line matches, that line will be updated with the exact line string from <actual>.
+# Not all lines can be reused (e.g. multiline expressions), but the golden file can be manually changed after automatic update.
+#
+# `--diff` is not supported with `--regexp`.
+#
+assert_file_equals_golden() {
+ local -i is_mode_regexp=0
+ local -i show_diff=0
+ local -i allow_empty=0
+
+ while (( "$#" )); do
+ case "$1" in
+ -e|--regexp)
+ is_mode_regexp=1
+ shift
+ ;;
+ -d|--diff)
+ show_diff=1;
+ shift
+ ;;
+ --allow-empty)
+ allow_empty=1
+ shift
+ ;;
+ --)
+ shift
+ break
+ ;;
+ --*=|-*)
+ echo "Unsupported flag '$1'." \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ ;;
+ *)
+ break
+ ;;
+ esac
+ done
+
+ if [ $# -ne 2 ]; then
+ echo "Incorrect number of arguments: $#. Expected 2 argument." \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ if (( show_diff )) && (( is_mode_regexp )); then
+ echo "\`--diff' not supported with \`--regexp'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local -r target_file_path="${1-}"
+ local -r golden_file_path="${2-}"
+ local -r -i update_goldens_on_failure="${BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE:-0}"
+
+ if [ -z "$target_file_path" ]; then
+ echo "Target file path was not given or it was empty." \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ if [ ! -e "$target_file_path" ]; then
+ echo "Target file was not found. File path: '$target_file_path'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ if [ -z "$golden_file_path" ]; then
+ echo "Golden file path was not given or it was empty." \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ if [ ! -e "$golden_file_path" ]; then
+ echo "Golden file was not found. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local target_file_contents=
+ # Load the contents from the file.
+ # Append a period (to be removed on the next line) so that trailing new lines are preserved.
+ target_file_contents="$(cat "$target_file_path" 2>/dev/null && printf '.')"
+ if [ $? -ne 0 ]; then
+ echo "Failed to read target file. File path: '$target_file_path'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ target_file_contents="${target_file_contents%.}"
+
+ local golden_file_contents=
+ # Load the contents from the file.
+ # Append a period (to be removed on the next line) so that trailing new lines are preserved.
+ golden_file_contents="$(cat "$golden_file_path" 2>/dev/null && printf '.')"
+ if [ $? -ne 0 ]; then
+ echo "Failed to read golden file. File path: '$golden_file_path'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ golden_file_contents="${golden_file_contents%.}"
+ if [ -z "$golden_file_contents" ] && ! (( allow_empty )); then
+ echo "Golden file contents is empty. This may be an authoring error. Use \`--allow-empty\` if this is intentional." \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+
+ local -i assert_failed=0
+ if (( is_mode_regexp )); then
+ if [[ ! '' =~ ^${golden_file_contents}$ ]] && [[ '' =~ ^${golden_file_contents}$ ]] || (( $? == 2 )); then
+ echo "Invalid extended regular expression in golden file: \`$golden_file_contents'" \
+ | batslib_decorate 'ERROR: assert_file_equals_golden' \
+ | fail
+ return $?
+ elif ! [[ "$target_file_contents" =~ ^${golden_file_contents}$ ]]; then
+ assert_failed=1
+ fi
+ elif [[ "$target_file_contents" != "$golden_file_contents" ]]; then
+ assert_failed=1
+ fi
+
+ if (( assert_failed )); then
+ if (( show_diff )); then
+ {
+ echo "Golden file: $golden_file_path"
+ diff <(echo "$target_file_contents") <(echo "$golden_file_contents")
+ } \
+ | batslib_decorate 'file contents does not match golden' \
+ | fail
+ elif (( is_mode_regexp )); then
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual file contents' "$target_file_contents"
+ } \
+ | batslib_decorate 'file contents does not match regexp golden' \
+ | fail
+ else
+ {
+ echo "Golden file: $golden_file_path"
+ batslib_print_kv_multi \
+ 'golden contents' "$golden_file_contents" \
+ 'actual file contents' "$target_file_contents"
+ } \
+ | batslib_decorate 'file contents does not match golden' \
+ | fail
+ fi
+
+ if (( update_goldens_on_failure )); then
+ if ! (( is_mode_regexp )); then
+ # Non-regex golden update is straight forward.
+ printf '%s' "$target_file_contents" 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ else
+ # To do a best-approximation for regex goldens,
+ # try and use existing lines as a library for updated lines (preferring longer lines).
+ # This is done line by line on the output.
+ # Unfortunately, this does not handle multi-line regex in the golden (e.g. `(.*\n){10}`).
+ # Any line guess which is not preferred can be manually corrected/updated by the author.
+ local -a output_lines=()
+ local -a sorted_golden_lines=()
+ local temp=
+ while IFS='' read -r temp; do
+ output_lines+=("$temp")
+ done < <(printf '%s' "$target_file_contents" ; printf '\n')
+ while IFS='' read -r temp; do
+ sorted_golden_lines+=("$temp")
+ done < <(echo "$golden_file_contents" | awk '{ print length, $0 }' | sort -nrs | cut -d" " -f 2- ; printf '\n')
+ # First, clear out the golden file's contents (so new data can just be appended below).
+ : 2>/dev/null > "$golden_file_path"
+ if [[ $? -ne 0 ]]; then
+ echo "Failed to write into golden file during update: '$golden_file_path'." \
+ | batslib_decorate 'FAIL: assert_file_equals_golden' \
+ | fail
+ return $?
+ fi
+ # Go line by line over the output, looking for the best suggested replacement.
+ local best_guess_for_line=
+ for line_in_output in "${output_lines[@]}"; do
+ # Default the output line itself as the best guess for the new golden.
+ # Though, the output line needs to be properly escaped for when being used in regex matching (on subsequent runs of the test).
+ best_guess_for_line="$(echo "$line_in_output" | sed -E 's/([][\.()*+?{}|^$\\])/\\\1/g')"
+ for line_in_golden in "${sorted_golden_lines[@]}"; do
+ if [[ "$line_in_output" =~ ^${line_in_golden}$ ]]; then
+ # If there's a line from the previous golden output that matches, use that is the best guess instead.
+ # No need to escape special characters, as `line_in_golden` is already in proper form.
+ best_guess_for_line="$line_in_golden"
+ break
+ fi
+ done
+ if [ -s "$golden_file_path" ]; then
+ printf '\n' >> "$golden_file_path"
+ fi
+ printf '%s' "$best_guess_for_line" >> "$golden_file_path"
+ done
+ fi
+ echo "Golden file updated after mismatch." \
+ | batslib_decorate 'FAIL: assert_file_equals_golden' \
+ | fail
+ fi
+ fi
+ return $assert_failed
+}
diff --git a/test/assert_equals_golden.bats b/test/assert_equals_golden.bats
new file mode 100644
index 0000000..89a920f
--- /dev/null
+++ b/test/assert_equals_golden.bats
@@ -0,0 +1,5376 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+bats_require_minimum_version 1.5.0
+
+test_temp_golden_file=''
+save_temp_file_path_and_run() {
+ local -r temp_file_arg="$#"
+
+ test_temp_golden_file="${!temp_file_arg}"
+
+ run "$@"
+}
+
+#
+# assert_equals_golden
+# Literal matching
+#
+
+@test "assert_equals_golden: succeeds if output and golden match" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_equals_golden: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_equals_golden: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden: fails if output and golden do not match" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden "$tested_value" <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual value (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual value (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual value (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden: fails if output is and golden are empty" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden "$tested_value" <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: succeeds if output is and golden are empty when allowed" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --allow-empty "$tested_value" <(:)
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden: succeeds if output is and golden are empty when allowed - kept empty lines" {
+ run --keep-empty-lines :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --allow-empty "$tested_value" <(:)
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --allow-empty "$tested_value" <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if output is empty with newline golden" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails if output is empty with newline golden - kept empty lines" {
+ run --keep-empty-lines :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden "$tested_value" <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden: fails with too few parameters" {
+ run assert_equals_golden
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 0. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails with too many parameters" {
+ run assert_equals_golden a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 3. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails with empty golden file path" {
+ run assert_equals_golden 'abc' ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails with nonexistent golden file" {
+ run assert_equals_golden 'abc' some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails with non-openable golden file" {
+ run assert_equals_golden 'abc' .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: '--' stops parsing options" {
+ run assert_equals_golden -- '--diff' <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden: fails due to literal (non-wildcard) matching by default" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden "$tested_value" <(printf '*')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+*
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails due to literal (non-regex) matching by default" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden "$tested_value" <(printf '.*')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.*
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+#
+# assert_equals_golden
+# Literal matching with stdin
+#
+
+@test "assert_equals_golden --stdin: succeeds if output and golden match" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(printf 'a') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if output and golden match with '-' arg" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden - <(printf 'a') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(printf 'a\nb\nc') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if multiline output and golden match with '-' arg" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden - <(printf 'a\nb\nc') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(printf 'a\n') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if output and golden match and contain trailing newline with '-' arg" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden - <(printf 'a\n') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(printf 'a\nb\nc\n') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if multiline output and golden match and contain trailing newline with '-' arg" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden - <(printf 'a\nb\nc\n') < <(printf "$tested_value")
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: fails if output and golden do not match" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --stdin <(printf 'a') < <(printf "$tested_value")
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --stdin: fails if output and golden do not match with '-' arg" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden - <(printf 'a') < <(printf "$tested_value")
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --stdin: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf 'a\n') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual value (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf 'a\nb\nc\n') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual value (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf 'a') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf 'a\nb\nc') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual value (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(printf '\n') < <(printf "$tested_value")
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: fails if output is and golden are empty" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin <(:) < <(printf "$tested_value")
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --stdin: succeeds if output is and golden are empty when allowed" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin --allow-empty <(:) < <(printf "$tested_value")
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if output is and golden are empty when allowed with '-' arg" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --allow-empty - <(:) < <(printf "$tested_value")
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: succeeds if output is and golden are empty when allowed - kept empty lines" {
+ run --keep-empty-lines :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --stdin --allow-empty <(:) < <(printf "$tested_value")
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --stdin: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf 'a') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is newline with non-empty golden with '-' arg" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden - <(printf 'a') < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin --allow-empty <(:) < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is newline with allowed empty golden with '-' arg" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --allow-empty - <(:) < <(printf "$tested_value")
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is empty with newline golden" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf '\n') < <(printf "$tested_value")
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is empty with newline golden with '-' arg" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden - <(printf '\n') < <(printf "$tested_value")
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --stdin: fails if output is empty with newline golden - kept empty lines" {
+ run --keep-empty-lines :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --stdin <(printf '\n') < <(printf "$tested_value")
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+#
+# assert_equals_golden
+# Literal matching with diff output
+#
+
+@test "assert_equals_golden --diff: succeeds if output and golden match" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: fails if output and golden do not match" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+1c1
+< b
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a\nb\nc\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+3a4
+>
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a\nb\nc')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+4d3
+<
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: fails if output is and golden are empty" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff "$tested_value" <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: succeeds if output is and golden are empty when allowed" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --diff --allow-empty "$tested_value" <(:)
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --diff: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+1,2c1
+<
+<
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff --allow-empty "$tested_value" <(:)
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails if output is empty with newline golden" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --diff "$tested_value" <(printf '\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails with too few parameters" {
+ run assert_equals_golden --diff
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 0. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails with too many parameters" {
+ run assert_equals_golden --diff a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 3. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails with empty golden file path" {
+ run assert_equals_golden --diff 'abc' ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails with nonexistent golden file" {
+ run assert_equals_golden --diff 'abc' some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: fails with non-openable golden file" {
+ run assert_equals_golden --diff 'abc' .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --diff: '--' stops parsing options" {
+ run assert_equals_golden --diff -- '--diff' <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+#
+# assert_equals_golden
+# Regex matching
+#
+
+@test "assert_equals_golden --regexp: succeeds if output and golden match" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: fails if output and golden do not match" {
+ run printf 'b'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --regexp "$tested_value" <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual value (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual value (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual value (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: fails if output is and golden are empty" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: succeeds if output is and golden are empty when allowed" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp --allow-empty "$tested_value" <(:)
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp --allow-empty "$tested_value" <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual value (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if output is empty with newline golden" {
+ run :
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual value (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails with too few parameters" {
+ run assert_equals_golden --regexp
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 0. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with too many parameters" {
+ run assert_equals_golden --regexp a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Incorrect number of arguments: 3. Expected 2 arguments.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with empty golden file path" {
+ run assert_equals_golden --regexp 'abc' ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with nonexistent golden file" {
+ run assert_equals_golden --regexp 'abc' some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with non-openable golden file" {
+ run assert_equals_golden --regexp 'abc' .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: '--' stops parsing options" {
+ run assert_equals_golden --regexp -- '--diff' <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with special characters" {
+ run printf '[.?+'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '\\[\\.\\?\\+')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with non-specific matching regex" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '.')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline non-specific exact matching regex" {
+ run printf 'a\nb'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '...')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline non-specific greedy matching regex" {
+ run printf 'abc\nxyz'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '.*')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline non-specific non-newline matching regex" {
+ run printf 'abc\nxyz'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[^\\n]+\n[^\\n]+')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with specific matching regex" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[a]')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline specific matching regex" {
+ run printf 'a\nb'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[a]\n[b]')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline specific repeating matching regex" {
+ run printf 'aabbcc\nxxyyzz'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline specific matching regex with trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\nxxyyzz\n\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline specific matching regex with special characters" {
+ run printf 'aabbcc\n[.?+\nxxyyzz'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline specific matching regex with special characters and trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\n[.?+\nxxyyzz\n\n'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: succeeds with multiline start-end matching regex" {
+ run printf 'abc\ndef\nxyz'
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf 'abc\n.*xyz')
+ assert_test_pass
+}
+
+@test "assert_equals_golden --regexp: fails with non-specific non-matching regex - too many" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --regexp "$tested_value" <(printf '..')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+..
+actual value (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with non-specific non-matching regex - too few" {
+ run printf 'ab'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --regexp "$tested_value" <(printf '.')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.
+actual value (1 lines):
+ab
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with specific non-matching regex" {
+ run printf 'a'
+ tested_value="$output"
+ output='UNUSED'
+ save_temp_file_path_and_run assert_equals_golden --regexp "$tested_value" <(printf '[b]')
+
+ assert_test_fail <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+[b]
+actual value (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden --regexp: fails with multiline specific matching regex with extra trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\nxxyyzz\n\n'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n[xyz]+')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (2 lines):
+[abc]+
+[xyz]+
+actual value (3 lines):
+aabbcc
+xxyyzz
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails with multiline specific matching regex with missing trailing newlines" {
+ run printf 'aabbcc\nxxyyzz'
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_equals_golden --regexp "$tested_value" <(printf '[abc]+\n[xyz]+\n\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+[abc]+
+[xyz]+
+
+
+actual value (2 lines):
+aabbcc
+xxyyzz
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_equals_golden --regexp: fails if regex golden is not a valid extended regular expression" {
+ tested_value="$output"
+ output='UNUSED'
+ run assert_equals_golden --regexp "$tested_value" <(printf '[.*')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Invalid extended regular expression in golden file: `[.*'
+--
+ERR_MSG
+}
+
+#
+# assert_equals_golden
+# Misc Error Handling
+#
+
+@test "assert_equals_golden: fails with --regexp --diff" {
+ run assert_equals_golden --regexp --diff 'abc' <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+`--diff' not supported with `--regexp'
+--
+ERR_MSG
+}
+
+@test "assert_equals_golden: fails with unknown option" {
+ run assert_equals_golden --not-a-real-option 'abc' <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_equals_golden --
+Unsupported flag '--not-a-real-option'.
+--
+ERR_MSG
+}
+
+#
+# assert_output_equals_golden
+# Literal matching
+#
+
+@test "assert_output_equals_golden: succeeds if output and golden match" {
+ run printf 'a'
+ run assert_output_equals_golden <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ run assert_output_equals_golden <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ run assert_output_equals_golden <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ run assert_output_equals_golden <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: fails if output and golden do not match" {
+ run printf 'b'
+ save_temp_file_path_and_run assert_output_equals_golden <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual output (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual output (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual output (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ run assert_output_equals_golden <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: fails if output is and golden are empty" {
+ run :
+ run assert_output_equals_golden <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: succeeds if output is and golden are empty when allowed" {
+ run :
+ run assert_output_equals_golden --allow-empty <(:)
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: succeeds if output is and golden are empty when allowed - kept empty lines" {
+ run --keep-empty-lines :
+ run assert_output_equals_golden --allow-empty <(:)
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --allow-empty <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual output (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if output is empty with newline golden" {
+ run :
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual output (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails if output is empty with newline golden - kept empty lines" {
+ run --keep-empty-lines :
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual output (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden: fails with too few parameters" {
+ run assert_output_equals_golden
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 0. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails with too many parameters" {
+ run assert_output_equals_golden a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 3. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails with empty golden file path" {
+ run assert_output_equals_golden ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails with nonexistent golden file" {
+ run assert_output_equals_golden some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails with non-openable golden file" {
+ run assert_output_equals_golden .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: '--' stops parsing options" {
+ run printf '%s' '--diff'
+ run assert_output_equals_golden -- <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden: fails due to literal (non-wildcard) matching by default" {
+ run printf 'b'
+ save_temp_file_path_and_run assert_output_equals_golden <(printf '*')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+*
+actual output (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails due to literal (non-regex) matching by default" {
+ run printf 'b'
+ save_temp_file_path_and_run assert_output_equals_golden <(printf '.*')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.*
+actual output (1 lines):
+b
+--
+ERR_MSG
+}
+
+#
+# assert_output_equals_golden
+# Literal matching with diff output
+#
+
+@test "assert_output_equals_golden --diff: succeeds if output and golden match" {
+ run printf 'a'
+ run assert_output_equals_golden --diff <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ run assert_output_equals_golden --diff <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ run assert_output_equals_golden --diff <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ run assert_output_equals_golden --diff <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: fails if output and golden do not match" {
+ run printf 'b'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+1c1
+< b
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a\nb\nc\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+3a4
+>
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a\nb\nc')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+4d3
+<
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ run assert_output_equals_golden --diff <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: fails if output is and golden are empty" {
+ run :
+ run assert_output_equals_golden --diff <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: succeeds if output is and golden are empty when allowed" {
+ run :
+ run assert_output_equals_golden --diff --allow-empty <(:)
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --diff: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+1,2c1
+<
+<
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ save_temp_file_path_and_run assert_output_equals_golden --diff --allow-empty <(:)
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails if output is empty with newline golden" {
+ run :
+ save_temp_file_path_and_run assert_output_equals_golden --diff <(printf '\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails with too few parameters" {
+ run assert_output_equals_golden --diff
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 0. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails with too many parameters" {
+ run assert_output_equals_golden --diff a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 3. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails with empty golden file path" {
+ run assert_output_equals_golden --diff ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails with nonexistent golden file" {
+ run assert_output_equals_golden --diff some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: fails with non-openable golden file" {
+ run assert_output_equals_golden --diff .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --diff: '--' stops parsing options" {
+ run printf '%s' '--diff'
+ run assert_output_equals_golden --diff -- <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+#
+# assert_output_equals_golden
+# Regex matching
+#
+
+@test "assert_output_equals_golden --regexp: succeeds if output and golden match" {
+ run printf 'a'
+ run assert_output_equals_golden --regexp <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds if multiline output and golden match" {
+ run printf 'a\nb\nc'
+ run assert_output_equals_golden --regexp <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds if output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\n'
+ run assert_output_equals_golden --regexp <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds if multiline output and golden match and contain trailing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ run assert_output_equals_golden --regexp <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: fails if output and golden do not match" {
+ run printf 'b'
+ save_temp_file_path_and_run assert_output_equals_golden --regexp <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails if output and golden do not match due to extra trailing newline" {
+ run printf 'a'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual output (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if multiline output and golden do not match due to extra trailing newline" {
+ run printf 'a\nb\nc'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual output (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if multiline output and golden do not match due to extra missing newline" {
+ run --keep-empty-lines printf 'a\nb\nc\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual output (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: succeeds if output is newline with newline golden" {
+ run --keep-empty-lines printf '\n'
+ run assert_output_equals_golden --regexp <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: fails if output is and golden are empty" {
+ run :
+ run assert_output_equals_golden --regexp <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: succeeds if output is and golden are empty when allowed" {
+ run :
+ run assert_output_equals_golden --regexp --allow-empty <(:)
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: fails if output is newline with non-empty golden" {
+ run --keep-empty-lines printf '\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual output (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if output is newline with allowed empty golden" {
+ run --keep-empty-lines printf '\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp --allow-empty <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual output (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if output is empty with newline golden" {
+ run :
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual output (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails with too few parameters" {
+ run assert_output_equals_golden --regexp
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 0. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with too many parameters" {
+ run assert_output_equals_golden --regexp a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Incorrect number of arguments: 3. Expected 1 argument.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with empty golden file path" {
+ run assert_output_equals_golden --regexp ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with nonexistent golden file" {
+ run assert_output_equals_golden --regexp some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with non-openable golden file" {
+ run assert_output_equals_golden --regexp .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: '--' stops parsing options" {
+ run printf '%s' '--diff'
+ run assert_output_equals_golden --regexp -- <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with special characters" {
+ run printf '[.?+'
+ run assert_output_equals_golden --regexp <(printf '\\[\\.\\?\\+')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with non-specific matching regex" {
+ run printf 'a'
+ run assert_output_equals_golden --regexp <(printf '.')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline non-specific exact matching regex" {
+ run printf 'a\nb'
+ run assert_output_equals_golden --regexp <(printf '...')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline non-specific greedy matching regex" {
+ run printf 'abc\nxyz'
+ run assert_output_equals_golden --regexp <(printf '.*')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline non-specific non-newline matching regex" {
+ run printf 'abc\nxyz'
+ run assert_output_equals_golden --regexp <(printf '[^\\n]+\n[^\\n]+')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with specific matching regex" {
+ run printf 'a'
+ run assert_output_equals_golden --regexp <(printf '[a]')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline specific matching regex" {
+ run printf 'a\nb'
+ run assert_output_equals_golden --regexp <(printf '[a]\n[b]')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline specific repeating matching regex" {
+ run printf 'aabbcc\nxxyyzz'
+ run assert_output_equals_golden --regexp <(printf '[abc]+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline specific matching regex with trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\nxxyyzz\n\n'
+ run assert_output_equals_golden --regexp <(printf '[abc]+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline specific matching regex with special characters" {
+ run printf 'aabbcc\n[.?+\nxxyyzz'
+ run assert_output_equals_golden --regexp <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline specific matching regex with special characters and trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\n[.?+\nxxyyzz\n\n'
+ run assert_output_equals_golden --regexp <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: succeeds with multiline start-end matching regex" {
+ run printf 'abc\ndef\nxyz'
+ run assert_output_equals_golden --regexp <(printf 'abc\n.*xyz')
+ assert_test_pass
+}
+
+@test "assert_output_equals_golden --regexp: fails with non-specific non-matching regex - too many" {
+ run printf 'a'
+ save_temp_file_path_and_run assert_output_equals_golden --regexp <(printf '..')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+..
+actual output (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with non-specific non-matching regex - too few" {
+ run printf 'ab'
+ save_temp_file_path_and_run assert_output_equals_golden --regexp <(printf '.')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.
+actual output (1 lines):
+ab
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with specific non-matching regex" {
+ run printf 'a'
+ save_temp_file_path_and_run assert_output_equals_golden --regexp <(printf '[b]')
+
+ assert_test_fail <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+[b]
+actual output (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden --regexp: fails with multiline specific matching regex with extra trailing newlines" {
+ run --keep-empty-lines printf 'aabbcc\nxxyyzz\n\n'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf '[abc]+\n[xyz]+')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (2 lines):
+[abc]+
+[xyz]+
+actual output (3 lines):
+aabbcc
+xxyyzz
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails with multiline specific matching regex with missing trailing newlines" {
+ run printf 'aabbcc\nxxyyzz'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_output_equals_golden --regexp <(printf '[abc]+\n[xyz]+\n\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+[abc]+
+[xyz]+
+
+
+actual output (2 lines):
+aabbcc
+xxyyzz
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_output_equals_golden --regexp: fails if regex golden is not a valid extended regular expression" {
+ run assert_output_equals_golden --regexp <(printf '[.*')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Invalid extended regular expression in golden file: `[.*'
+--
+ERR_MSG
+}
+
+#
+# assert_output_equals_golden
+# Misc Error Handling
+#
+
+@test "assert_output_equals_golden: fails with --regexp --diff" {
+ run assert_output_equals_golden --regexp --diff <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+`--diff' not supported with `--regexp'
+--
+ERR_MSG
+}
+
+@test "assert_output_equals_golden: fails with unknown option" {
+ run assert_output_equals_golden --not-a-real-option <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_output_equals_golden --
+Unsupported flag '--not-a-real-option'.
+--
+ERR_MSG
+}
+
+#
+# assert_file_equals_golden
+# Literal matching
+#
+
+@test "assert_file_equals_golden: succeeds if output and golden match" {
+ run assert_file_equals_golden <(printf 'a') <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: succeeds if multiline output and golden match" {
+ run assert_file_equals_golden <(printf 'a\nb\nc') <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: succeeds if output and golden match and contain trailing newline" {
+ run assert_file_equals_golden <(printf 'a\n') <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: succeeds if multiline output and golden match and contain trailing newline" {
+ run assert_file_equals_golden <(printf 'a\nb\nc\n') <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: fails if output and golden do not match" {
+ save_temp_file_path_and_run assert_file_equals_golden <(printf 'b') <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails if output and golden do not match due to extra trailing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(printf 'a') <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual file contents (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails if multiline output and golden do not match due to extra trailing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(printf 'a\nb\nc') <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual file contents (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails if output and golden do not match due to extra missing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(printf 'a\n') <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails if multiline output and golden do not match due to extra missing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(printf 'a\nb\nc\n') <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual file contents (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: succeeds if output is newline with newline golden" {
+ run assert_file_equals_golden <(printf '\n') <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: fails if output is and golden are empty" {
+ run assert_file_equals_golden <(:) <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: succeeds if output is and golden are empty when allowed" {
+ run assert_file_equals_golden --allow-empty <(:) <(:)
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: fails if output is newline with non-empty golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(printf '\n') <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails if output is newline with allowed empty golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --allow-empty <(printf '\n') <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual file contents (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails if output is empty with newline golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden <(:) <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual file contents (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden: fails with too few parameters" {
+ run assert_file_equals_golden
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 0. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with too many parameters" {
+ run assert_file_equals_golden a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 3. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with empty target file path" {
+ run assert_file_equals_golden '' <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with empty golden file path" {
+ run assert_file_equals_golden <(print 'a') ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with nonexistent target file" {
+ run assert_file_equals_golden some/path/this_file_definitely_does_not_exist.txt <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with nonexistent golden file" {
+ run assert_file_equals_golden <(print 'a') some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with non-openable target file" {
+ run assert_file_equals_golden . <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read target file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with non-openable golden file" {
+ run assert_file_equals_golden <(print 'a') .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: '--' stops parsing options" {
+ run assert_file_equals_golden -- <(printf '%s' '--diff') <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden: fails due to literal (non-wildcard) matching by default" {
+ save_temp_file_path_and_run assert_file_equals_golden <(printf 'b') <(printf '*')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+*
+actual file contents (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails due to literal (non-regex) matching by default" {
+ save_temp_file_path_and_run assert_file_equals_golden <(printf 'b') <(printf '.*')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.*
+actual file contents (1 lines):
+b
+--
+ERR_MSG
+}
+
+#
+# assert_file_equals_golden
+# Literal matching with diff output
+#
+
+@test "assert_file_equals_golden --diff: succeeds if output and golden match" {
+ run assert_file_equals_golden --diff <(printf 'a') <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: succeeds if multiline output and golden match" {
+ run assert_file_equals_golden --diff <(printf 'a\nb\nc') <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: succeeds if output and golden match and contain trailing newline" {
+ run assert_file_equals_golden --diff <(printf 'a\n') <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: succeeds if multiline output and golden match and contain trailing newline" {
+ run assert_file_equals_golden --diff <(printf 'a\nb\nc\n') <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: fails if output and golden do not match" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf 'b') <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+1c1
+< b
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if output and golden do not match due to extra trailing newline" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf 'a') <(printf 'a\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if multiline output and golden do not match due to extra trailing newline" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf 'a\nb\nc') <(printf 'a\nb\nc\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+3a4
+>
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if output and golden do not match due to extra missing newline" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf 'a\n') <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if multiline output and golden do not match due to extra missing newline" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf 'a\nb\nc\n') <(printf 'a\nb\nc')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+4d3
+<
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: succeeds if output is newline with newline golden" {
+ run assert_file_equals_golden --diff <(printf '\n') <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: fails if output is and golden are empty" {
+ run assert_file_equals_golden --diff <(:) <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: succeeds if output is and golden are empty when allowed" {
+ run assert_file_equals_golden --diff --allow-empty <(:) <(:)
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --diff: fails if output is newline with non-empty golden" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(printf '\n') <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+1,2c1
+<
+<
+---
+> a
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if output is newline with allowed empty golden" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff --allow-empty <(printf '\n') <(:)
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+2d1
+<
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails if output is empty with newline golden" {
+ save_temp_file_path_and_run assert_file_equals_golden --diff <(:) <(printf '\n')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $test_temp_golden_file
+1a2
+>
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with too few parameters" {
+ run assert_file_equals_golden --diff
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 0. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with too many parameters" {
+ run assert_file_equals_golden --diff a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 3. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with empty target file path" {
+ run assert_file_equals_golden --diff '' <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with empty golden file path" {
+ run assert_file_equals_golden --diff <(print 'a') ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with nonexistent target file" {
+ run assert_file_equals_golden --diff some/path/this_file_definitely_does_not_exist.txt <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with nonexistent golden file" {
+ run assert_file_equals_golden --diff <(print 'a') some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with non-openable target file" {
+ run assert_file_equals_golden --diff . <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read target file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: fails with non-openable golden file" {
+ run assert_file_equals_golden --diff <(print 'a') .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --diff: '--' stops parsing options" {
+ run assert_file_equals_golden --diff -- <(printf '%s' '--diff') <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+#
+# assert_file_equals_golden
+# Regex matching
+#
+
+@test "assert_file_equals_golden --regexp: succeeds if output and golden match" {
+ run assert_file_equals_golden --regexp <(printf 'a') <(printf 'a')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds if multiline output and golden match" {
+ run assert_file_equals_golden --regexp <(printf 'a\nb\nc') <(printf 'a\nb\nc')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds if output and golden match and contain trailing newline" {
+ run assert_file_equals_golden --regexp <(printf 'a\n') <(printf 'a\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds if multiline output and golden match and contain trailing newline" {
+ run assert_file_equals_golden --regexp <(printf 'a\nb\nc\n') <(printf 'a\nb\nc\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: fails if output and golden do not match" {
+ save_temp_file_path_and_run assert_file_equals_golden --regexp <(printf 'b') <(printf 'a')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+b
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails if output and golden do not match due to extra trailing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'a') <(printf 'a\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+
+actual file contents (1 lines):
+a
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if multiline output and golden do not match due to extra trailing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'a\nb\nc') <(printf 'a\nb\nc\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+
+actual file contents (3 lines):
+a
+b
+c
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if output and golden do not match due to extra missing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'a\n') <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+a
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if multiline output and golden do not match due to extra missing newline" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'a\nb\nc\n') <(printf 'a\nb\nc')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+a
+b
+c
+actual file contents (3 lines):
+a
+b
+c
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: succeeds if output is newline with newline golden" {
+ run assert_file_equals_golden --regexp <(printf '\n') <(printf '\n')
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: fails if output is and golden are empty" {
+ run assert_file_equals_golden --regexp <(:) <(:)
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file contents is empty. This may be an authoring error. Use `--allow-empty` if this is intentional.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: succeeds if output is and golden are empty when allowed" {
+ run assert_file_equals_golden --regexp --allow-empty <(:) <(:)
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: fails if output is newline with non-empty golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf '\n') <(printf 'a')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+a
+actual file contents (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if output is newline with allowed empty golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp --allow-empty <(printf '\n') <(:)
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (0 lines):
+
+actual file contents (1 lines):
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if output is empty with newline golden" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(:) <(printf '\n')
+
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+
+
+actual file contents (0 lines):
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails with too few parameters" {
+ run assert_file_equals_golden --regexp
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 0. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with too many parameters" {
+ run assert_file_equals_golden --regexp a b c
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Incorrect number of arguments: 3. Expected 2 argument.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with empty target file path" {
+ run assert_file_equals_golden --regexp '' <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with empty golden file path" {
+ run assert_file_equals_golden --regexp <(print 'a') ''
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file path was not given or it was empty.
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with nonexistent target file" {
+ run assert_file_equals_golden --regexp some/path/this_file_definitely_does_not_exist.txt <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Target file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with nonexistent golden file" {
+ run assert_file_equals_golden --regexp <(print 'a') some/path/this_file_definitely_does_not_exist.txt
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Golden file was not found. File path: 'some/path/this_file_definitely_does_not_exist.txt'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with non-openable target file" {
+ run assert_file_equals_golden --regexp . <(print 'a')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read target file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with non-openable golden file" {
+ run assert_file_equals_golden --regexp <(print 'a') .
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Failed to read golden file. File path: '.'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: '--' stops parsing options" {
+ run assert_file_equals_golden --regexp -- <(printf '%s' '--diff') <(printf '%s' '--diff')
+
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with special characters" {
+ run assert_file_equals_golden --regexp <(printf '[.?+') <(printf '\\[\\.\\?\\+')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with non-specific matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'a') <(printf '.')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline non-specific exact matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'a\nb') <(printf '...')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline non-specific greedy matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'abc\nxyz') <(printf '.*')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline non-specific non-newline matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'abc\nxyz') <(printf '[^\\n]+\n[^\\n]+')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with specific matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'a') <(printf '[a]')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline specific matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'a\nb') <(printf '[a]\n[b]')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline specific repeating matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'aabbcc\nxxyyzz') <(printf '[abc]+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline specific matching regex with trailing newlines" {
+ run assert_file_equals_golden --regexp <(printf 'aabbcc\nxxyyzz\n\n') <(printf '[abc]+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline specific matching regex with special characters" {
+ run assert_file_equals_golden --regexp <(printf 'aabbcc\n[.?+\nxxyyzz') <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline specific matching regex with special characters and trailing newlines" {
+ run assert_file_equals_golden --regexp <(printf 'aabbcc\n[.?+\nxxyyzz\n\n') <(printf '[abc]+\n\\[\\.\\?\\+\n[xyz]+\n\n')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: succeeds with multiline start-end matching regex" {
+ run assert_file_equals_golden --regexp <(printf 'abc\ndef\nxyz') <(printf 'abc\n.*xyz')
+ assert_test_pass
+}
+
+@test "assert_file_equals_golden --regexp: fails with non-specific non-matching regex - too many" {
+ save_temp_file_path_and_run assert_file_equals_golden --regexp <(printf 'a') <(printf '..')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+..
+actual file contents (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with non-specific non-matching regex - too few" {
+ save_temp_file_path_and_run assert_file_equals_golden --regexp <(printf 'ab') <(printf '.')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+.
+actual file contents (1 lines):
+ab
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with specific non-matching regex" {
+ save_temp_file_path_and_run assert_file_equals_golden --regexp <(printf 'a') <(printf '[b]')
+
+ assert_test_fail <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (1 lines):
+[b]
+actual file contents (1 lines):
+a
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden --regexp: fails with multiline specific matching regex with extra trailing newlines" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'aabbcc\nxxyyzz\n\n') <(printf '[abc]+\n[xyz]+')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix output "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (2 lines):
+[abc]+
+[xyz]+
+actual file contents (3 lines):
+aabbcc
+xxyyzz
+
+
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails with multiline specific matching regex with missing trailing newlines" {
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ save_temp_file_path_and_run --keep-empty-lines assert_file_equals_golden --regexp <(printf 'aabbcc\nxxyyzz') <(printf '[abc]+\n[xyz]+\n\n')
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $test_temp_golden_file
+golden contents (3 lines):
+[abc]+
+[xyz]+
+
+
+actual file contents (2 lines):
+aabbcc
+xxyyzz
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "assert_file_equals_golden --regexp: fails if regex golden is not a valid extended regular expression" {
+ run assert_file_equals_golden --regexp <(printf 'abc') <(printf '[.*')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Invalid extended regular expression in golden file: `[.*'
+--
+ERR_MSG
+}
+
+#
+# assert_file_equals_golden
+# Misc Error Handling
+#
+
+@test "assert_file_equals_golden: fails with --regexp --diff" {
+ run assert_file_equals_golden --regexp --diff <(printf 'abc') <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+`--diff' not supported with `--regexp'
+--
+ERR_MSG
+}
+
+@test "assert_file_equals_golden: fails with unknown option" {
+ run assert_file_equals_golden --not-a-real-option <(printf 'abc') <(printf 'abc')
+
+ assert_test_fail <<'ERR_MSG'
+
+-- ERROR: assert_file_equals_golden --
+Unsupported flag '--not-a-real-option'.
+--
+ERR_MSG
+}
+
+#
+# Automatic golden file updating
+#
+
+@test "auto-update: assert_equals_golden: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (1 lines):
+abc
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (1 lines):
+abc
+--
+
+
+-- FAIL: assert_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_equals_golden: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (1 lines):
+abc
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (1 lines):
+abc
+--
+
+
+-- FAIL: assert_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual value (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure multiline with regex and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual value (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure multiline with regex and special chars" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual value (7 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure multiline with regex, special chars, and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual value (8 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_equals_golden --regexp: updates golden for failure all special characters" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='[]\n.\n()\n*\n+\n?\n{}\n|\n^\n$\n\\ '
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ tested_value="$output"
+ output='UNUSED'
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- value does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual value (11 lines):
+[]
+.
+()
+*
++
+?
+{}
+|
+^
+$
+\\
+--
+
+
+-- FAIL: assert_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '\\[\\]\n\\.\n\\(\\)\n\\*\n\\+\n\\?\n\\{\\}\n\\|\n\\^\n\\$\n\\\\ ')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_equals_golden --regexp "$tested_value" "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (1 lines):
+abc
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run printf "$tested_output"
+ run assert_output_equals_golden "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (1 lines):
+abc
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_output_equals_golden: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (1 lines):
+abc
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ run printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (1 lines):
+abc
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual output (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure multiline with regex and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual output (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure multiline with regex and special chars" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual output (7 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure multiline with regex, special chars, and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno\n\n'
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual output (8 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_output_equals_golden --regexp: updates golden for failure all special characters" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='[]\n.\n()\n*\n+\n?\n{}\n|\n^\n$\n\\ '
+
+ run --keep-empty-lines printf "$tested_output"
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_output_equals_golden --regexp "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- output does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual output (11 lines):
+[]
+.
+()
+*
++
+?
+{}
+|
+^
+$
+\\
+--
+
+
+-- FAIL: assert_output_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '\\[\\]\n\\.\n\\(\\)\n\\*\n\\+\n\\?\n\\{\\}\n\\|\n\\^\n\\$\n\\\\ ')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run --keep-empty-lines printf "$tested_output"
+ run assert_output_equals_golden --regexp "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (1 lines):
+abc
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (1 lines):
+abc
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_file_equals_golden: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (1 lines):
+abc
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$tested_output" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: failure if golden file is not writable" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+ chmod a-w "$temp_golden_file"
+
+ tested_output='abc'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (1 lines):
+abc
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Failed to write into golden file during update: '$temp_golden_file'.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure multiline with trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf 'wrong output' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = 'wrong output' ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (1 lines):
+wrong output
+actual file contents (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ [ "$(cat "$temp_golden_file")" = "$(printf "$tested_output")" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure multiline with regex and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\njkl\n\nmno\n\n'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual file contents (7 lines):
+abc
+def
+ghi
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure multiline with regex and special chars" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual file contents (7 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure multiline with regex, special chars, and trailing newlines" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='abc\ndef\nghi\n].{\njkl\n\nmno\n\n'
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual file contents (8 lines):
+abc
+def
+ghi
+].{
+jkl
+
+mno
+
+
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf 'abc\n[d-l]{3}\n[d-l]{3}\n\\]\\.\\{\n[d-l]{3}\n\n[^a].[op]\n\n')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}
+
+@test "auto-update: assert_file_equals_golden --regexp: updates golden for failure all special characters" {
+ temp_golden_file="$(mktemp -t "bats_test_${BATS_TEST_NUMBER}.XXXXXXXX.txt")"
+ [ -f "$temp_golden_file" ]
+ printf '[^a].[op]\n[d-l]{3}' > "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '[^a].[op]\n[d-l]{3}')" ]
+
+ tested_output='[]\n.\n()\n*\n+\n?\n{}\n|\n^\n$\n\\ '
+
+ BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE=1
+ # Need to use `--keep-empty-lines` so that `${#lines[@]}` and `num_lines` can match in `assert_test_fail`.
+ run --keep-empty-lines assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ # TODO(https://github.com/bats-core/bats-support/issues/11): Fix golden "lines" count in expected message.
+ # Need to use variable to match trailing end lines caused by using `--keep-empty-lines`.
+ expected="$(cat <<ERR_MSG
+
+-- file contents does not match regexp golden --
+Golden file: $temp_golden_file
+golden contents (2 lines):
+[^a].[op]
+[d-l]{3}
+actual file contents (11 lines):
+[]
+.
+()
+*
++
+?
+{}
+|
+^
+$
+\\
+--
+
+
+-- FAIL: assert_file_equals_golden --
+Golden file updated after mismatch.
+--
+
+ERR_MSG
+ printf '.')"
+ expected="${expected%.}"
+ assert_test_fail "$expected"
+
+ cat "$temp_golden_file"
+ [ "$(cat "$temp_golden_file")" = "$(printf '\\[\\]\n\\.\n\\(\\)\n\\*\n\\+\n\\?\n\\{\\}\n\\|\n\\^\n\\$\n\\\\ ')" ]
+ unset BATS_ASSERT_UPDATE_GOLDENS_ON_FAILURE
+ run assert_file_equals_golden --regexp <(printf "$tested_output") "$temp_golden_file"
+
+ assert_test_pass
+}