@bats-hardened/bats 1.14.1-alpha02

package/libexec/bats-core/bats-exec-test

@@ -0,0 +1,383 @@
+#!/usr/bin/env bash
+set -eET
+
+# Variables used in other scripts.
+BATS_ENABLE_TIMING=''
+BATS_EXTENDED_SYNTAX=''
+BATS_TRACE_LEVEL="${BATS_TRACE_LEVEL:-0}"
+BATS_PRINT_OUTPUT_ON_FAILURE="${BATS_PRINT_OUTPUT_ON_FAILURE:-}"
+BATS_SHOW_OUTPUT_OF_SUCCEEDING_TESTS="${BATS_SHOW_OUTPUT_OF_SUCCEEDING_TESTS:-}"
+BATS_VERBOSE_RUN="${BATS_VERBOSE_RUN:-}"
+BATS_GATHER_TEST_OUTPUTS_IN="${BATS_GATHER_TEST_OUTPUTS_IN:-}"
+BATS_TEST_NAME_PREFIX="${BATS_TEST_NAME_PREFIX:-}"
+
+while [[ "$#" -ne 0 ]]; do
+  case "$1" in
+  -T)
+    BATS_ENABLE_TIMING='-T'
+    ;;
+  -x)
+    # shellcheck disable=SC2034
+    BATS_EXTENDED_SYNTAX='-x'
+    ;;
+  --dummy-flag) ;;
+
+  --trace)
+    ((++BATS_TRACE_LEVEL)) # avoid returning 0
+    ;;
+  --print-output-on-failure)
+    BATS_PRINT_OUTPUT_ON_FAILURE=1
+    ;;
+  --show-output-of-passing-tests)
+    BATS_SHOW_OUTPUT_OF_SUCCEEDING_TESTS=1
+    ;;
+  --verbose-run)
+    BATS_VERBOSE_RUN=1
+    ;;
+  --gather-test-outputs-in)
+    shift
+    BATS_GATHER_TEST_OUTPUTS_IN="$1"
+    ;;
+  *)
+    break
+    ;;
+  esac
+  shift
+done
+
+export BATS_TEST_FILENAME="$1"
+export BATS_TEST_NAME="$2"
+export BATS_SUITE_TEST_NUMBER="$3"
+export BATS_TEST_NUMBER="$4"
+BATS_TEST_TRY_NUMBER="$5"
+
+if [[ -z "$BATS_TEST_FILENAME" ]]; then
+  printf 'usage: bats-exec-test <filename>\n' >&2
+  exit 1
+elif [[ ! -f "$BATS_TEST_FILENAME" ]]; then
+  printf 'bats: %s does not exist\n' "$BATS_TEST_FILENAME" >&2
+  exit 1
+fi
+
+bats_create_test_tmpdirs() {
+  local tests_tmpdir="${BATS_RUN_TMPDIR}/test"
+  if ! mkdir -p "$tests_tmpdir"; then
+    printf 'Failed to create: %s\n' "$tests_tmpdir" >&2
+    exit 1
+  fi
+
+  BATS_TEST_TMPDIR="$tests_tmpdir/$BATS_SUITE_TEST_NUMBER"
+  if ! mkdir "$BATS_TEST_TMPDIR"; then
+    printf 'Failed to create BATS_TEST_TMPDIR%d: %s\n' "$BATS_TEST_TRY_NUMBER" "$BATS_TEST_TMPDIR" >&2
+    exit 1
+  fi
+
+  printf "%s\n" "$BATS_TEST_NAME" >> "$BATS_TEST_TMPDIR.name" # append name in case of test retries
+
+  export BATS_TEST_TMPDIR
+}
+
+# load the test helper functions like `load` or `run` that are needed to run a (preprocessed) .bats file without bash errors
+# shellcheck source=lib/bats-core/test_functions.bash disable=SC2153
+source "$BATS_ROOT/$BATS_LIBDIR/bats-core/test_functions.bash"
+_bats_test_functions_setup "$BATS_TEST_NUMBER"
+
+# shellcheck source=lib/bats-core/tracing.bash disable=SC2153
+source "$BATS_ROOT/$BATS_LIBDIR/bats-core/tracing.bash"
+
+bats_teardown_trap() {
+  bats_check_status_from_trap
+  local bats_teardown_trap_status=0
+
+  bats_set_stacktrace_limit
+
+  # mark the start of this function to distinguish where skip is called
+  # parameter 1 will signify the reason why this function was called
+  # this is used to identify when this is called as exit trap function
+  BATS_TEARDOWN_STARTED=${1:-1}
+  teardown >>"$BATS_OUT" 2>&1 || bats_teardown_trap_status="$?"
+
+  if [[ $bats_teardown_trap_status -eq 0 ]]; then
+    BATS_TEARDOWN_COMPLETED=1
+  elif [[ -n "$BATS_TEST_COMPLETED" ]]; then
+    BATS_DEBUG_LAST_STACK_TRACE_IS_VALID=1
+    BATS_ERROR_STATUS="$bats_teardown_trap_status"
+  fi
+
+  bats_exit_trap
+}
+
+# shellcheck source=lib/bats-core/common.bash
+source "$BATS_ROOT/$BATS_LIBDIR/bats-core/common.bash"
+
+bats_exit_trap() {
+  local status
+  local exit_metadata=''
+  trap - ERR EXIT
+  if [[ -n "${BATS_TEST_TIMEOUT:-}" ]]; then
+    # Kill the watchdog in the case of of kernel finished before the timeout
+    bats_abort_timeout_countdown || status=1
+  fi
+
+  if [[ -n "$BATS_TEST_SKIPPED" ]]; then
+    exit_metadata=' # skip'
+    if [[ "$BATS_TEST_SKIPPED" != '1' ]]; then
+      exit_metadata+=" $BATS_TEST_SKIPPED"
+    fi
+  elif [[ "${BATS_TIMED_OUT-NOTSET}" != NOTSET ]]; then
+    exit_metadata=" # timeout after ${BATS_TEST_TIMEOUT}s"
+  fi
+
+  BATS_TEST_TIME=''
+  if [[ -n "$BATS_ENABLE_TIMING" ]]; then
+    get_mills_since_epoch BATS_TEST_END_TIME
+    BATS_TEST_TIME=" in "$((BATS_TEST_END_TIME - BATS_TEST_START_TIME))"ms"
+  fi
+
+  local print_bats_out="${BATS_SHOW_OUTPUT_OF_SUCCEEDING_TESTS}"
+
+  local should_retry=''
+  if [[ -z "$BATS_TEST_COMPLETED" || -z "$BATS_TEARDOWN_COMPLETED" || "${BATS_INTERRUPTED-NOTSET}" != NOTSET ]]; then
+    if [[ "$BATS_ERROR_STATUS" -eq 0 ]]; then
+      # For some versions of bash, `$?` may not be set properly for some error
+      # conditions before triggering the EXIT trap directly (see #72 and #81).
+      # Thanks to the `BATS_TEARDOWN_COMPLETED` signal, this will pinpoint such
+      # errors if they happen during `teardown()` when `bats_perform_test` calls
+      # `bats_teardown_trap` directly after the test itself passes.
+      #
+      # If instead the test fails, and the `teardown()` error happens while
+      # `bats_teardown_trap` runs as the EXIT trap, the test will fail with no
+      # output, since there's no way to reach the `bats_exit_trap` call.
+      BATS_ERROR_STATUS=1
+    fi
+    if bats_should_retry_test; then
+      should_retry=1
+      status=126                # signify retry
+      rm -r "$BATS_TEST_TMPDIR" # clean up for retry
+    else
+      printf 'not ok %d %s%s\n' "$BATS_SUITE_TEST_NUMBER" "${BATS_TEST_NAME_PREFIX:-}${BATS_TEST_DESCRIPTION}${BATS_TEST_TIME}" "$exit_metadata" >&3
+      if (( ${#BATS_TEST_TAGS[@]} > 0 )); then
+        printf '# tags:'
+        printf ' %s' "${BATS_TEST_TAGS[@]}"
+        printf '\n'
+      fi >&3
+      local stack_trace
+      bats_get_failure_stack_trace stack_trace
+      bats_print_stack_trace "${stack_trace[@]}" >&3
+      bats_print_failed_command "${stack_trace[@]}" >&3
+
+      if [[ $BATS_PRINT_OUTPUT_ON_FAILURE ]]; then
+        if [[ -n "${output:-}" ]]; then
+          printf "Last output:\n%s\n" "$output"
+        fi
+        if [[ -n "${stderr:-}" ]]; then
+          printf "Last stderr: \n%s\n" "$stderr"
+        fi
+      fi >>"$BATS_OUT"
+
+      print_bats_out=1
+      status=1
+      local state=failed
+    fi
+  else
+    printf 'ok %d %s%s\n' "$BATS_SUITE_TEST_NUMBER" "${BATS_TEST_NAME_PREFIX:-}${BATS_TEST_DESCRIPTION}${BATS_TEST_TIME}" \
+      "$exit_metadata" >&3
+    status=0
+    local state=passed
+  fi
+
+  if [[ -z "$should_retry" ]]; then
+    printf "%s %s\t%s\n" "$state" "$BATS_TEST_FILENAME" "$BATS_TEST_NAME" >>"$BATS_RUNLOG_FILE"
+
+    if [[ $print_bats_out ]]; then
+      bats_prefix_lines_for_tap_output <"$BATS_OUT" | bats_replace_filename >&3
+    fi
+  fi
+  if [[ $BATS_GATHER_TEST_OUTPUTS_IN ]]; then
+    local try_suffix=
+    if [[ -n "$should_retry" ]]; then
+      try_suffix="-try$BATS_TEST_TRY_NUMBER"
+    fi
+    # Only copy if BATS_OUT exists (it may not exist if test produced no output)
+    if [[ -f "$BATS_OUT" ]]; then
+      cp "$BATS_OUT" "$BATS_GATHER_TEST_OUTPUTS_IN/$BATS_SUITE_TEST_NUMBER$try_suffix-${BATS_TEST_DESCRIPTION//\//%2F}.log"
+    fi
+  fi
+  rm -f "$BATS_OUT"
+  exit "$status"
+}
+
+# Marks the test as failed due to timeout.
+# The actual termination of subprocesses is done via pkill in the background
+# process in bats_start_timeout_countdown
+# shellcheck disable=SC2317,SC2329
+bats_timeout_trap() {
+  BATS_TIMED_OUT=1
+  BATS_DEBUG_LAST_STACK_TRACE_IS_VALID=
+  exit 1
+}
+
+# find pids of process and all its descendants
+bats_find_processes_of() { # <parent-pid>
+  local -ri parent_pid=$1
+  child_pids=("$1")
+  {
+    read -ra header
+    local pid_col ppid_col
+    for ((i = 0; i < ${#header[@]}; ++i)); do
+      if [[ ${header[$i]} == "PID" ]]; then
+        pid_col=$i
+      fi
+      if [[ ${header[$i]} == "PPID" ]]; then
+        ppid_col=$i
+      fi
+    done
+    # PID PPID  child_pids
+    # 1   0     (2)
+    # 2   1     (2)
+    # 3   1     (2)
+    # 4   3     (2)
+    # 5   2     (2 5)
+    # 6   5     (2 5 6)
+    # assumes pids are in ascending order and there are no orphans in the chain
+
+    if (( BASH_VERSINFO[0] < 4 )); then
+      # BASHPID is not available before bash 4
+      BASHPID=$(sh -c 'echo $PPID')
+    fi
+    while read -ra row; do
+      local -i ppid=${row[ppid_col]} pid=${row[$pid_col]}
+      if (( ppid == parent_pid)) || bats_linear_reverse_search "$ppid" child_pids; then
+        # exclude `ps` command substitution below
+        if (( pid != BASHPID)); then
+          child_pids+=("$pid")
+        fi
+      fi
+    done
+  # MSYS does not support -o and rows are not sorted by pid
+  } < <(ps -Ao pid,ppid,args 2>/dev/null || { ps -ef | sort -k 2 -h; })
+}
+
+# send signal to process and all its descendants
+bats_kill_processes_of() { # <parent-pid> [<signal>]
+  local -ir parent_pid="${1?}" 
+  local -r signal=${2?}
+  bats_find_processes_of "$parent_pid"
+  kill "-$signal" "${child_pids[@]}"
+}
+
+# sets a timeout for this process
+bats_start_timeout_countdown() { # <timeout>
+  local -ri timeout=$1
+  local -ri target_pid=$$
+  # shellcheck disable=SC2064
+  trap "bats_timeout_trap $target_pid" TERM
+  if ! (command -v ps || command -v pkill) >/dev/null; then
+    printf "Error: Cannot execute timeout because neither pkill nor ps are available on this system!\n" >&2
+    exit 1
+  fi
+  # Start another process to kill the children of this process
+  (
+    # with sleep in foreground this shell wouldn't receive signals,
+    # so we use wait below and kill sleep explicitly when signalled to do so
+    # On Windows the TERM signal does not seem to shut down sleep -> 
+    # close all fds to avoid blocking IO when sleep does not turn off
+    (eval exec {0..255}">&-"; sleep "$timeout") &
+    # shellcheck disable=SC2064
+    trap "kill $!; exit 0" TERM
+    wait
+    trap '' TERM
+    bats_kill_processes_of $target_pid TERM
+  ) &
+}
+
+bats_abort_timeout_countdown() {
+  # kill the countdown process, don't care if its still there
+  kill "$BATS_killer_pid" &>/dev/null || true
+}
+
+
+if [[ -n "${EPOCHREALTIME-}"  ]]; then
+get_mills_since_epoch() { # <output-variable>
+  local -r output_variable="$1"
+  local int frac
+  # allow for different decimal separators
+  IFS=., read -r int frac <<<"$EPOCHREALTIME"
+  printf -v "$output_variable" "%d" "${int}${frac::3}"
+}
+else
+get_mills_since_epoch() { # <output-variable>
+  local -r output_variable="$1"
+  local ms_since_epoch
+  ms_since_epoch=$(bats_execute date +%s%N)
+  if [[ "$ms_since_epoch" == *N || "${#ms_since_epoch}" -lt 19 ]]; then
+    ms_since_epoch=$(($(bats_execute date +%s) * 1000))
+  else
+    ms_since_epoch=$((ms_since_epoch / 1000000))
+  fi
+  printf -v "$output_variable" "%d" "$ms_since_epoch"
+}
+fi
+
+bats_perform_test() {
+  if ! declare -F "${BATS_TEST_NAME%% *}" &>/dev/null; then
+    local quoted_test_name
+    bats_quote_code quoted_test_name "$BATS_TEST_NAME"
+    printf "bats: unknown test name %s\n" "$quoted_test_name" >&2
+    exit 1
+  fi
+
+  # is this skipped from outside ?
+  if [[ -n "${BATS_TEST_SKIPPED-}" ]]; then
+    # forward skip (with message) by overriding setup
+    # shellcheck disable=SC2317
+    setup() {
+      skip "$BATS_TEST_SKIPPED"
+    }
+  fi
+
+  if [[ -n "${BATS_TEST_TIMEOUT:-}" ]]; then
+    bats_start_timeout_countdown "$BATS_TEST_TIMEOUT"
+    declare -r BATS_killer_pid=$!
+  fi
+  BATS_TEST_COMPLETED=
+  BATS_TEST_SKIPPED=${BATS_TEST_SKIPPED-}
+  BATS_TEARDOWN_COMPLETED=
+  BATS_ERROR_STATUS=
+  bats_setup_tracing
+  # use parameter to mark this call as trap call
+  # shellcheck disable=SC2064
+  trap "bats_teardown_trap as-exit-trap" EXIT
+
+  if [[ -n "$BATS_EXTENDED_SYNTAX" ]]; then
+    printf 'begin %d %s\n' "$BATS_SUITE_TEST_NUMBER" "${BATS_TEST_NAME_PREFIX:-}$BATS_TEST_DESCRIPTION" >&3
+  fi
+
+  get_mills_since_epoch BATS_TEST_START_TIME
+  {
+    bats_set_stacktrace_limit
+    setup "$@"
+    "$@"
+  } >>"$BATS_OUT" 2>&1 4>&1
+
+  BATS_TEST_COMPLETED=1
+  # shellcheck disable=SC2064
+  trap "bats_exit_trap" EXIT
+  bats_teardown_trap "" # pass empty parameter to signify call outside trap
+}
+
+trap bats_interrupt_trap INT
+
+# shellcheck source=lib/bats-core/preprocessing.bash
+source "$BATS_ROOT/$BATS_LIBDIR/bats-core/preprocessing.bash"
+
+exec 3<&1
+BATS_OUT="$BATS_RUN_TMPDIR/test/$BATS_SUITE_TEST_NUMBER.out"
+
+bats_create_test_tmpdirs
+bats_evaluate_preprocessed_source
+
+readonly BATS_TEST_TAGS
+
+# use eval to parse (internally quoted!) test command into parameters
+bats_perform_test "${BATS_TEST_COMMAND[@]}"

package/libexec/bats-core/bats-format-cat

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -e
+
+trap '' INT
+
+cat

package/libexec/bats-core/bats-format-junit

@@ -0,0 +1,293 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# shellcheck source=lib/bats-core/formatter.bash
+source "$BATS_ROOT/$BATS_LIBDIR/bats-core/formatter.bash"
+
+init_suite() {
+  suite_test_exec_time=0
+  # since we have to print the suite header before its contents but we don't know the contents before the header,
+  # we have to buffer the contents
+  _suite_buffer=""
+  test_result_state="" # declare for the first flush, when no test has been encountered
+}
+
+init_file() {
+  file_count=0
+  file_failures=0
+  file_skipped=0
+  file_exec_time=0
+  test_exec_time=0
+  name=""
+  _buffer=""
+  _buffer_log=""
+  _system_out_log=""
+  test_result_state="" # mark that no test has run in this file so far
+}
+
+host() {
+  local hostname="${HOST:-}"
+  [[ -z "$hostname" ]] && hostname="${HOSTNAME:-}"
+  [[ -z "$hostname" ]] && hostname="$(uname -n)"
+  [[ -z "$hostname" ]] && hostname="$(hostname -f)"
+
+  echo "$hostname"
+}
+
+# convert $1 (time in milliseconds) to seconds
+milliseconds_to_seconds() {
+  # we cannot rely on having bc for this calculation
+  full_seconds=$(($1 / 1000))
+  remaining_milliseconds=$(($1 % 1000))
+  if [[ $remaining_milliseconds -eq 0 ]]; then
+    printf "%d" "$full_seconds"
+  else
+    printf "%d.%03d" "$full_seconds" "$remaining_milliseconds"
+  fi
+}
+
+suite_header() {
+  printf "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+<testsuites time=\"%s\">\n" "$(milliseconds_to_seconds "${suite_test_exec_time}")"
+}
+
+file_header() {
+  timestamp=$(date -u +"%Y-%m-%dT%H:%M:%S")
+  printf "<testsuite name=\"%s\" tests=\"%s\" failures=\"%s\" errors=\"0\" skipped=\"%s\" time=\"%s\" timestamp=\"%s\" hostname=\"%s\">\n" \
+    "$(xml_escape "${class}")" "${file_count}" "${file_failures}" "${file_skipped}" "$(milliseconds_to_seconds "${file_exec_time}")" "${timestamp}" "$(host)"
+}
+
+file_footer() {
+  printf "</testsuite>\n"
+}
+
+suite_footer() {
+  printf "</testsuites>\n"
+}
+
+print_test_case() {
+  if [[ "$test_result_state" == ok && -z "$_system_out_log" && -z "$_buffer_log" ]]; then
+    # pass and no output can be shortened
+    printf "    <testcase classname=\"%s\" name=\"%s\" time=\"%s\" />\n" "$(xml_escape "${class}")" "$(xml_escape "${name}")" "$(milliseconds_to_seconds "${test_exec_time}")"
+  else
+    printf "    <testcase classname=\"%s\" name=\"%s\" time=\"%s\">\n" "$(xml_escape "${class}")" "$(xml_escape "${name}")" "$(milliseconds_to_seconds "${test_exec_time}")"
+    if [[ -n "$_system_out_log" ]]; then
+      printf "        <system-out>%s</system-out>\n" "$(xml_escape "${_system_out_log}")"
+    fi
+    if [[ "$test_result_state" == not_ok ]]; then # Failed tests need a <failure> element.
+      # If we have system err output, we use that as the failure text.
+      printf "        <failure type=\"failure\">%s</failure>\n" "$(xml_escape "${_buffer_log}")"
+    else
+      if [[ -n "$_buffer_log" ]]; then
+        printf "        <system-err>%s</system-err>\n" "$(xml_escape "${_buffer_log}")"
+      fi
+    fi
+    if [[ "$test_result_state" == skipped ]]; then
+      printf "        <skipped>%s</skipped>\n" "$(xml_escape "$test_skip_message")"
+    fi
+    printf "    </testcase>\n"
+  fi
+}
+
+xml_escape() { # <string to escape>
+  local output=${1//&/\&amp;}
+  output=${output//</\&lt;}
+  output=${output//>/\&gt;}
+  output=${output//'"'/\&quot;}
+  output=${output//\'/\&#39;}
+  # remove ANSI escape sequences (e.g. color codes, cursor movements)
+  local CONTROL_CHAR=$'\033'
+  local REGEX="$CONTROL_CHAR\[[0-9;]*[a-zA-Z]"
+  while [[ "$output" =~ $REGEX ]]; do
+      output=${output//${BASH_REMATCH[0]}/}
+  done
+  printf "%s" "$output"
+}
+
+suite_buffer() {
+  local output
+  output="$(
+    "$@"
+    printf "x"
+  )" # use x marker to avoid losing trailing newlines
+  _suite_buffer="${_suite_buffer}${output%x}"
+}
+
+suite_flush() {
+  echo -n "${_suite_buffer}"
+  _suite_buffer=""
+}
+
+buffer() {
+  local output
+  output="$(
+    "$@"
+    printf "x"
+  )" # use x marker to avoid losing trailing newlines
+  _buffer="${_buffer}${output%x}"
+}
+
+flush() {
+  echo -n "${_buffer}"
+  _buffer=""
+}
+
+log_system_err() {
+  if [[ -n "$_buffer_log" ]]; then
+    _buffer_log="${_buffer_log}
+$1"
+  else
+    _buffer_log="$1"
+  fi
+}
+
+flush_log() {
+  if [[ -n "$test_result_state" ]]; then
+    buffer print_test_case
+  fi
+  _buffer_log=""
+  _system_out_log=""
+  test_result_state="" # Clean out result from last test. Retried tests will have multiple begin calls.
+}
+
+log_system_out() {
+  if [[ -n "$_system_out_log" ]]; then
+    _system_out_log="${_system_out_log}
+$1"
+  else
+    _system_out_log="$1"
+  fi
+}
+
+finish_file() {
+  if [[ "${class}" != JUNIT_FORMATTER_NO_FILE_ENCOUNTERED ]]; then
+    file_header
+    printf "%s" "${_buffer}"
+    file_footer
+    class=''
+    name=''
+  fi
+}
+
+finish_suite() {
+  flush_log
+  suite_header
+  suite_flush
+  finish_file # must come after suite flush to not print the last file before the others
+  suite_footer
+}
+
+bats_tap_stream_plan() { #  <number of tests>
+  :
+}
+
+bats_tap_stream_begin() { # <test index> <test name>
+  flush_log
+  # set after flushing to avoid overriding name of test
+  name="$2"
+}
+
+bats_tap_stream_ok() { # <test index> <test name>
+  test_exec_time=${BATS_FORMATTER_TEST_DURATION:-0}
+  ((file_count += 1))
+  test_result_state='ok'
+  file_exec_time="$((file_exec_time + test_exec_time))"
+  suite_test_exec_time=$((suite_test_exec_time + test_exec_time))
+}
+
+bats_tap_stream_skipped() { # <test index> <test name> <skip reason>
+  test_exec_time=${BATS_FORMATTER_TEST_DURATION:-0}
+  ((file_count += 1))
+  ((file_skipped += 1))
+  test_result_state='skipped'
+  test_exec_time=0
+  test_skip_message="$3"
+}
+
+bats_tap_stream_not_ok() { # <test index> <test name>
+  if [[ -z "${name:-}" ]]; then
+    # Can be called (after bats_tap_stream_plan) before anything else if the test fails in setup_suite
+    bats_tap_stream_suite "setup_suite"
+    bats_tap_stream_begin "$1" "$2"
+  fi
+  test_exec_time=${BATS_FORMATTER_TEST_DURATION:-0}
+  ((file_count += 1))
+  ((file_failures += 1))
+  test_result_state=not_ok
+  file_exec_time="$((file_exec_time + test_exec_time))"
+  suite_test_exec_time=$((suite_test_exec_time + test_exec_time))
+}
+
+bats_tap_stream_comment() { # <comment text without leading '# '> <scope>
+  local comment="$1" scope="$2"
+  case "$scope" in
+  begin)
+    # everything that happens between begin and [not] ok is FD3 output from the test
+    log_system_out "$comment"
+    ;;
+  ok | skipped)
+    # non failed tests can produce FD3 output
+    log_system_out "$comment"
+    ;;
+  *)
+    # everything else is considered error output
+    log_system_err "$1"
+    ;;
+  esac
+}
+
+bats_tap_stream_suite() { # <file name>
+  flush_log
+  suite_buffer finish_file
+  init_file
+  class="${1/$BASE_PATH/}"
+}
+
+bats_tap_stream_unknown() { # <full line>
+  local line="$1" scope="$2"
+  log_system_out "$line"
+}
+
+main() {
+  local _buffer_log="" \
+        name="" \
+        class="JUNIT_FORMATTER_NO_FILE_ENCOUNTERED" \
+        _buffer="" \
+        _buffer_log="" \
+        _suite_buffer="" \
+        _system_out_log="" \
+        test_result_state="" \
+        test_skip_message=""
+
+  local -i file_count=0 \
+            file_failures=0 \
+            file_skipped=0 \
+            file_exec_time=0 \
+            test_exec_time=0 \
+            suite_test_exec_time=0 
+
+  local BASE_PATH=.
+
+  while [[ "$#" -ne 0 ]]; do
+    case "$1" in
+    --base-path)
+      shift
+      normalize_base_path BASE_PATH "$1"
+      ;;
+    esac
+    shift
+  done
+
+  init_suite
+  trap finish_suite EXIT
+  trap '' INT
+
+  bats_parse_internal_extended_tap
+
+  trap - EXIT
+  finish_suite # ensure we run this with the local variables still in scope
+}
+
+# [\x00-\x08\x0B\x0C\x0E-\x1F] can't use $'\x00' as this terminates the string early
+BATS_JUNIT_FORMATTER_DELETE_CHARS_DEFAULT='\000'$'\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F'
+main "$@" | tr -d "${BATS_JUNIT_FORMATTER_DELETE_CHARS-$BATS_JUNIT_FORMATTER_DELETE_CHARS_DEFAULT}"